1 /***************************************************************************
2 begin : Mon Mar 01 2004
3 copyright : (C) 2019 by Martin Preuss
4 email : martin@libchipcard.de
5
6 ***************************************************************************
7 * Please see toplevel file COPYING for license details *
8 ***************************************************************************/
9
10
11 #ifdef HAVE_CONFIG_H
12 # include <config.h>
13 #endif
14
15
16 #include "user_p.h"
17 #include "provider_l.h"
18
19 #include <gwenhywfar/debug.h>
20
21 #include <assert.h>
22
23
GWEN_INHERIT(AB_USER,EBC_USER)24 GWEN_INHERIT(AB_USER, EBC_USER)
25
26
27 const char *EBC_User_Status_toString(EBC_USER_STATUS st)
28 {
29 switch (st) {
30 case EBC_UserStatus_New:
31 return "new";
32 case EBC_UserStatus_Enabled:
33 return "enabled";
34 case EBC_UserStatus_Init1:
35 return "init1";
36 case EBC_UserStatus_Init2:
37 return "init2";
38 case EBC_UserStatus_Disabled:
39 return "disabled";
40 default:
41 return "unknown";
42 } /* switch */
43 }
44
45
46
EBC_User_Status_fromString(const char * s)47 EBC_USER_STATUS EBC_User_Status_fromString(const char *s)
48 {
49 assert(s);
50 if (strcasecmp(s, "new")==0)
51 return EBC_UserStatus_New;
52 else if (strcasecmp(s, "enabled")==0)
53 return EBC_UserStatus_Enabled;
54 else if (strcasecmp(s, "init1")==0)
55 return EBC_UserStatus_Init1;
56 else if (strcasecmp(s, "init2")==0)
57 return EBC_UserStatus_Init2;
58 else if (strcasecmp(s, "disabled")==0)
59 return EBC_UserStatus_Disabled;
60 else
61 return EBC_UserStatus_Unknown;
62 }
63
64
65
EBC_User_Flags_toDb(GWEN_DB_NODE * db,const char * name,uint32_t flags)66 void EBC_User_Flags_toDb(GWEN_DB_NODE *db, const char *name,
67 uint32_t flags)
68 {
69 GWEN_DB_DeleteVar(db, name);
70 if (flags & EBC_USER_FLAGS_BANK_DOESNT_SIGN)
71 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "bankDoesntSign");
72 if (flags & EBC_USER_FLAGS_FORCE_SSLV3)
73 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "forceSslv3");
74 if (flags & EBC_USER_FLAGS_INI)
75 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "INI");
76 if (flags & EBC_USER_FLAGS_HIA)
77 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "HIA");
78 if (flags & EBC_USER_FLAGS_CLIENT_DATA_DOWNLOAD_SPP)
79 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "clientDataDownloadSpp");
80 if (flags & EBC_USER_FLAGS_PREVALIDATION_SPP)
81 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "prevalidationSpp");
82 if (flags & EBC_USER_FLAGS_RECOVERY_SPP)
83 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "recoverySpp");
84 if (flags & EBC_USER_FLAGS_STA_SPP)
85 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "staSpp");
86 if (flags & EBC_USER_FLAGS_IZV_SPP)
87 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "izvSpp");
88 if (flags & EBC_USER_FLAGS_USE_IZL)
89 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "useIZL");
90 if (flags & EBC_USER_FLAGS_TIMESTAMP_FIX1)
91 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "timestampFix1");
92 if (flags & EBC_USER_FLAGS_NO_EU)
93 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "noEu");
94 #if 0
95 if (flags & EBC_USER_FLAGS_TLS_IGN_PREMATURE_CLOSE)
96 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "tlsIgnPrematureClose");
97 #endif
98 if (flags & EBC_USER_FLAGS_TLS_ABORT_ON_PREMATURE_CLOSE)
99 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_DEFAULT, name, "tlsAbortOnPrematureClose");
100
101 }
102
103
104
EBC_User_Flags_fromDb(GWEN_DB_NODE * db,const char * name)105 uint32_t EBC_User_Flags_fromDb(GWEN_DB_NODE *db, const char *name)
106 {
107 uint32_t fl=0;
108 int i;
109
110 for (i=0; ; i++) {
111 const char *s;
112
113 s=GWEN_DB_GetCharValue(db, name, i, 0);
114 if (!s)
115 break;
116 if (strcasecmp(s, "bankDoesntSign")==0)
117 fl|=EBC_USER_FLAGS_BANK_DOESNT_SIGN;
118 else if (strcasecmp(s, "forceSslv3")==0)
119 fl|=EBC_USER_FLAGS_FORCE_SSLV3;
120 else if (strcasecmp(s, "ini")==0)
121 fl|=EBC_USER_FLAGS_INI;
122 else if (strcasecmp(s, "hia")==0)
123 fl|=EBC_USER_FLAGS_HIA;
124 else if (strcasecmp(s, "clientDataDownloadSpp")==0)
125 fl|=EBC_USER_FLAGS_CLIENT_DATA_DOWNLOAD_SPP;
126 else if (strcasecmp(s, "prevalidationSpp")==0)
127 fl|=EBC_USER_FLAGS_PREVALIDATION_SPP;
128 else if (strcasecmp(s, "recoverySpp")==0)
129 fl|=EBC_USER_FLAGS_RECOVERY_SPP;
130 else if (strcasecmp(s, "staSpp")==0)
131 fl|=EBC_USER_FLAGS_STA_SPP;
132 else if (strcasecmp(s, "izvSpp")==0)
133 fl|=EBC_USER_FLAGS_IZV_SPP;
134 else if (strcasecmp(s, "useIZL")==0)
135 fl|=EBC_USER_FLAGS_USE_IZL;
136 else if (strcasecmp(s, "timestampFix1")==0)
137 fl|=EBC_USER_FLAGS_TIMESTAMP_FIX1;
138 else if (strcasecmp(s, "noEu")==0)
139 fl|=EBC_USER_FLAGS_NO_EU;
140 else if (strcasecmp(s, "tlsIgnPrematureClose")==0) { /* ignore deprecated flag */
141 #if 0
142 fl|=EBC_USER_FLAGS_TLS_IGN_PREMATURE_CLOSE;
143 #endif
144 }
145 else if (strcasecmp(s, "tlsAbortOnPrematureClose")==0)
146 fl|=EBC_USER_FLAGS_TLS_ABORT_ON_PREMATURE_CLOSE;
147 else {
148 DBG_WARN(AQEBICS_LOGDOMAIN, "Unknown user flag \"%s\"", s);
149 }
150 }
151
152 return fl;
153 }
154
155
156
157
158
159
160
161
EBC_User_new(AB_PROVIDER * pro)162 AB_USER *EBC_User_new(AB_PROVIDER *pro)
163 {
164 AB_USER *u;
165 EBC_USER *ue;
166
167 assert(pro);
168 u=AB_User_new();
169 assert(u);
170
171 AB_User_SetProvider(u, pro);
172 AB_User_SetBackendName(u, "aqebics");
173
174 GWEN_NEW_OBJECT(EBC_USER, ue);
175 GWEN_INHERIT_SETDATA(AB_USER, EBC_USER, u, ue, EBC_User_freeData);
176
177 ue->readFromDbFn=AB_User_SetReadFromDbFn(u, EBC_User_ReadFromDb);
178 ue->writeToDbFn=AB_User_SetWriteToDbFn(u, EBC_User_WriteToDb);
179
180 /* some reasonable presets */
181 AB_User_SetCountry(u, "de");
182 ue->protoVersion=strdup("H003");
183 ue->signVersion=strdup("A005");
184 ue->cryptVersion=strdup("E002");
185 ue->authVersion=strdup("X002");
186
187 return u;
188 }
189
190
191
EBC_User_freeData(GWEN_UNUSED void * bp,void * p)192 void GWENHYWFAR_CB EBC_User_freeData(GWEN_UNUSED void *bp, void *p)
193 {
194 EBC_USER *ue;
195
196 ue=(EBC_USER *)p;
197 free(ue->peerId);
198 free(ue->tokenType);
199 free(ue->tokenName);
200 free(ue->protoVersion);
201 free(ue->signVersion);
202 free(ue->cryptVersion);
203 free(ue->authVersion);
204 free(ue->systemId);
205 free(ue->httpUserAgent);
206 free(ue->httpContentType);
207 free(ue->serverUrl);
208 GWEN_FREE_OBJECT(ue);
209 }
210
211
212
EBC_User__ReadDb(AB_USER * u,GWEN_DB_NODE * db)213 void EBC_User__ReadDb(AB_USER *u, GWEN_DB_NODE *db)
214 {
215 EBC_USER *ue;
216 const char *s;
217
218 assert(u);
219 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
220 assert(ue);
221
222 ue->flags=EBC_User_Flags_fromDb(db, "userFlags");
223
224 s=GWEN_DB_GetCharValue(db, "status", 0, "new");
225 ue->status=EBC_User_Status_fromString(s);
226
227 /* load server address */
228 free(ue->serverUrl);
229 s=GWEN_DB_GetCharValue(db, "server", 0, 0);
230 if (s)
231 ue->serverUrl=strdup(s);
232 else
233 ue->serverUrl=NULL;
234
235 /* get peer id */
236 free(ue->peerId);
237 s=GWEN_DB_GetCharValue(db, "peerId", 0, 0);
238 if (s)
239 ue->peerId=strdup(s);
240 else
241 ue->peerId=NULL;
242
243 free(ue->systemId);
244 s=GWEN_DB_GetCharValue(db, "systemId", 0, 0);
245 if (s)
246 ue->systemId=strdup(s);
247 else
248 ue->systemId=NULL;
249
250 /* setup HTTP version */
251 ue->httpVMajor=GWEN_DB_GetIntValue(db, "httpVMajor", 0, -1);
252 ue->httpVMinor=GWEN_DB_GetIntValue(db, "httpVMinor", 0, -1);
253 if (ue->httpVMajor==-1 || ue->httpVMinor==-1) {
254 ue->httpVMajor=1;
255 ue->httpVMinor=1;
256 }
257
258 free(ue->httpUserAgent);
259 s=GWEN_DB_GetCharValue(db, "httpUserAgent", 0, 0);
260 if (s)
261 ue->httpUserAgent=strdup(s);
262 else
263 ue->httpUserAgent=NULL;
264
265 free(ue->httpContentType);
266 s=GWEN_DB_GetCharValue(db, "httpContentType", 0,
267 "text/xml; charset=UTF-8");
268 if (s)
269 ue->httpContentType=strdup(s);
270 else
271 ue->httpContentType=NULL;
272
273 /* setup medium stuff */
274 free(ue->tokenType);
275 s=GWEN_DB_GetCharValue(db, "tokenType", 0, 0);
276 if (s)
277 ue->tokenType=strdup(s);
278 else
279 ue->tokenType=NULL;
280
281 free(ue->tokenName);
282 s=GWEN_DB_GetCharValue(db, "tokenName", 0, 0);
283 if (s)
284 ue->tokenName=strdup(s);
285 else
286 ue->tokenName=NULL;
287
288 free(ue->protoVersion);
289 s=GWEN_DB_GetCharValue(db, "protoVersion", 0, "H002");
290 if (s)
291 ue->protoVersion=strdup(s);
292 else
293 ue->protoVersion=NULL;
294
295 free(ue->signVersion);
296 s=GWEN_DB_GetCharValue(db, "signVersion", 0, "A004");
297 if (s)
298 ue->signVersion=strdup(s);
299 else
300 ue->signVersion=NULL;
301
302 free(ue->cryptVersion);
303 s=GWEN_DB_GetCharValue(db, "cryptVersion", 0, "E001");
304 if (s)
305 ue->cryptVersion=strdup(s);
306 else
307 ue->cryptVersion=NULL;
308
309 free(ue->authVersion);
310 s=GWEN_DB_GetCharValue(db, "authVersion", 0, "X001");
311 if (s)
312 ue->authVersion=strdup(s);
313 else
314 ue->authVersion=NULL;
315
316 ue->tokenContextId=GWEN_DB_GetIntValue(db, "tokenContextId", 0, 1);
317 }
318
319
320
EBC_User__WriteDb(const AB_USER * u,GWEN_DB_NODE * db)321 void EBC_User__WriteDb(const AB_USER *u, GWEN_DB_NODE *db)
322 {
323 EBC_USER *ue;
324
325 assert(u);
326 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
327 assert(ue);
328
329 EBC_User_Flags_toDb(db, "userFlags", ue->flags);
330
331 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
332 "status",
333 EBC_User_Status_toString(ue->status));
334
335 if (ue->peerId)
336 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
337 "peerId", ue->peerId);
338 if (ue->systemId)
339 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
340 "systemId", ue->systemId);
341
342 /* save crypt token settings */
343 if (ue->tokenType)
344 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
345 "tokenType", ue->tokenType);
346 if (ue->tokenName)
347 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
348 "tokenName", ue->tokenName);
349 GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
350 "tokenContextId", ue->tokenContextId);
351 if (ue->protoVersion)
352 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
353 "protoVersion", ue->protoVersion);
354 if (ue->signVersion)
355 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
356 "signVersion", ue->signVersion);
357 if (ue->cryptVersion)
358 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
359 "cryptVersion", ue->cryptVersion);
360 if (ue->authVersion)
361 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
362 "authVersion", ue->authVersion);
363
364 /* save http settings */
365 GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
366 "httpVMajor", ue->httpVMajor);
367 GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
368 "httpVMinor", ue->httpVMinor);
369 if (ue->httpUserAgent)
370 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
371 "httpUserAgent", ue->httpUserAgent);
372 if (ue->httpContentType)
373 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
374 "httpContentType", ue->httpContentType);
375
376 /* save URL */
377 if (ue->serverUrl)
378 GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS,
379 "server", ue->serverUrl);
380 }
381
382
383
EBC_User_ReadFromDb(AB_USER * u,GWEN_DB_NODE * db)384 int EBC_User_ReadFromDb(AB_USER *u, GWEN_DB_NODE *db)
385 {
386 EBC_USER *ue;
387 int rv;
388 GWEN_DB_NODE *dbP;
389 AB_PROVIDER *pro;
390
391 assert(u);
392 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
393 assert(ue);
394
395 /* save provider, because AB_User_ReadFromDb clears it */
396 pro=AB_User_GetProvider(u);
397
398 /* read data for base class */
399 rv=(ue->readFromDbFn)(u, db);
400 if (rv<0) {
401 DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
402 return rv;
403 }
404
405 /* set provider again */
406 AB_User_SetProvider(u, pro);
407
408 /* read data for provider */
409 dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend");
410 EBC_User__ReadDb(u, dbP);
411
412 return 0;
413 }
414
415
416
EBC_User_WriteToDb(const AB_USER * u,GWEN_DB_NODE * db)417 int EBC_User_WriteToDb(const AB_USER *u, GWEN_DB_NODE *db)
418 {
419 EBC_USER *ue;
420 int rv;
421 GWEN_DB_NODE *dbP;
422
423 assert(u);
424 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
425 assert(ue);
426
427 /* write data for base class */
428 rv=(ue->writeToDbFn)(u, db);
429 if (rv<0) {
430 DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);
431 return rv;
432 }
433
434 /* write data for provider */
435 dbP=GWEN_DB_GetGroup(db, GWEN_DB_FLAGS_DEFAULT, "data/backend");
436 EBC_User__WriteDb(u, dbP);
437
438 return 0;
439 }
440
441
442
443
444
445
EBC_User_GetPeerId(const AB_USER * u)446 const char *EBC_User_GetPeerId(const AB_USER *u)
447 {
448 EBC_USER *ue;
449
450 assert(u);
451 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
452 assert(ue);
453
454 return ue->peerId;
455 }
456
457
458
EBC_User_SetPeerId(AB_USER * u,const char * s)459 void EBC_User_SetPeerId(AB_USER *u, const char *s)
460 {
461 EBC_USER *ue;
462
463 assert(u);
464 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
465 assert(ue);
466
467 free(ue->peerId);
468 if (s)
469 ue->peerId=strdup(s);
470 else
471 ue->peerId=NULL;
472 }
473
474
475
EBC_User_GetTokenContextId(const AB_USER * u)476 uint32_t EBC_User_GetTokenContextId(const AB_USER *u)
477 {
478 EBC_USER *ue;
479
480 assert(u);
481 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
482 assert(ue);
483
484 return ue->tokenContextId;
485 }
486
487
488
EBC_User_SetTokenContextId(AB_USER * u,uint32_t id)489 void EBC_User_SetTokenContextId(AB_USER *u, uint32_t id)
490 {
491 EBC_USER *ue;
492
493 assert(u);
494 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
495 assert(ue);
496
497 ue->tokenContextId=id;
498 }
499
500
501
EBC_User_GetTokenType(const AB_USER * u)502 const char *EBC_User_GetTokenType(const AB_USER *u)
503 {
504 EBC_USER *ue;
505
506 assert(u);
507 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
508 assert(ue);
509
510 return ue->tokenType;
511 }
512
513
514
EBC_User_SetTokenType(AB_USER * u,const char * s)515 void EBC_User_SetTokenType(AB_USER *u, const char *s)
516 {
517 EBC_USER *ue;
518
519 assert(u);
520 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
521 assert(ue);
522
523 free(ue->tokenType);
524 if (s)
525 ue->tokenType=strdup(s);
526 else
527 ue->tokenType=NULL;
528 }
529
530
531
EBC_User_GetTokenName(const AB_USER * u)532 const char *EBC_User_GetTokenName(const AB_USER *u)
533 {
534 EBC_USER *ue;
535
536 assert(u);
537 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
538 assert(ue);
539
540 return ue->tokenName;
541 }
542
543
544
EBC_User_SetTokenName(AB_USER * u,const char * s)545 void EBC_User_SetTokenName(AB_USER *u, const char *s)
546 {
547 EBC_USER *ue;
548
549 assert(u);
550 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
551 assert(ue);
552
553 free(ue->tokenName);
554 if (s)
555 ue->tokenName=strdup(s);
556 else
557 ue->tokenName=NULL;
558 }
559
560
561
562
EBC_User_GetStatus(const AB_USER * u)563 EBC_USER_STATUS EBC_User_GetStatus(const AB_USER *u)
564 {
565 EBC_USER *ue;
566
567 assert(u);
568 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
569 assert(ue);
570
571 return ue->status;
572 }
573
574
575
EBC_User_SetStatus(AB_USER * u,EBC_USER_STATUS i)576 void EBC_User_SetStatus(AB_USER *u, EBC_USER_STATUS i)
577 {
578 EBC_USER *ue;
579
580 assert(u);
581 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
582 assert(ue);
583
584 ue->status=i;
585 }
586
587
588
EBC_User_GetServerUrl(const AB_USER * u)589 const char *EBC_User_GetServerUrl(const AB_USER *u)
590 {
591 EBC_USER *ue;
592
593 assert(u);
594 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
595 assert(ue);
596
597 return ue->serverUrl;
598 }
599
600
601
EBC_User_SetServerUrl(AB_USER * u,const char * s)602 void EBC_User_SetServerUrl(AB_USER *u, const char *s)
603 {
604 EBC_USER *ue;
605
606 assert(u);
607 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
608 assert(ue);
609
610 free(ue->serverUrl);
611 if (s)
612 ue->serverUrl=strdup(s);
613 else
614 ue->serverUrl=NULL;
615 }
616
617
618
EBC_User_GetSystemId(const AB_USER * u)619 const char *EBC_User_GetSystemId(const AB_USER *u)
620 {
621 EBC_USER *ue;
622
623 assert(u);
624 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
625 assert(ue);
626
627 return ue->systemId;
628 }
629
630
631
EBC_User_SetSystemId(AB_USER * u,const char * s)632 void EBC_User_SetSystemId(AB_USER *u, const char *s)
633 {
634 EBC_USER *ue;
635
636 assert(u);
637 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
638 assert(ue);
639
640 free(ue->systemId);
641 if (s)
642 ue->systemId=strdup(s);
643 else
644 ue->systemId=NULL;
645 }
646
647
648
EBC_User_GetFlags(const AB_USER * u)649 uint32_t EBC_User_GetFlags(const AB_USER *u)
650 {
651 EBC_USER *ue;
652
653 assert(u);
654 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
655 assert(ue);
656
657 return ue->flags;
658 }
659
660
661
EBC_User_SetFlags(AB_USER * u,uint32_t flags)662 void EBC_User_SetFlags(AB_USER *u, uint32_t flags)
663 {
664 EBC_USER *ue;
665
666 assert(u);
667 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
668 assert(ue);
669
670 ue->flags=flags;
671 }
672
673
674
EBC_User_AddFlags(AB_USER * u,uint32_t flags)675 void EBC_User_AddFlags(AB_USER *u, uint32_t flags)
676 {
677 EBC_USER *ue;
678
679 assert(u);
680 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
681 assert(ue);
682
683 ue->flags|=flags;
684 }
685
686
687
EBC_User_SubFlags(AB_USER * u,uint32_t flags)688 void EBC_User_SubFlags(AB_USER *u, uint32_t flags)
689 {
690 EBC_USER *ue;
691
692 assert(u);
693 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
694 assert(ue);
695
696 ue->flags&=~flags;
697 }
698
699
700
EBC_User_GetHttpUserAgent(const AB_USER * u)701 const char *EBC_User_GetHttpUserAgent(const AB_USER *u)
702 {
703 EBC_USER *ue;
704
705 assert(u);
706 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
707 assert(ue);
708
709 return ue->httpUserAgent;
710 }
711
712
713
EBC_User_SetHttpUserAgent(AB_USER * u,const char * s)714 void EBC_User_SetHttpUserAgent(AB_USER *u, const char *s)
715 {
716 EBC_USER *ue;
717
718 assert(u);
719 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
720 assert(ue);
721
722 free(ue->httpUserAgent);
723 if (s)
724 ue->httpUserAgent=strdup(s);
725 else
726 ue->httpUserAgent=NULL;
727 }
728
729
730
EBC_User_GetHttpContentType(const AB_USER * u)731 const char *EBC_User_GetHttpContentType(const AB_USER *u)
732 {
733 EBC_USER *ue;
734
735 assert(u);
736 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
737 assert(ue);
738
739 return ue->httpContentType;
740 }
741
742
743
EBC_User_SetHttpContentType(AB_USER * u,const char * s)744 void EBC_User_SetHttpContentType(AB_USER *u, const char *s)
745 {
746 EBC_USER *ue;
747
748 assert(u);
749 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
750 assert(ue);
751
752 free(ue->httpContentType);
753 if (s)
754 ue->httpContentType=strdup(s);
755 else
756 ue->httpContentType=NULL;
757 }
758
759
760
EBC_User_GetHttpVMajor(const AB_USER * u)761 int EBC_User_GetHttpVMajor(const AB_USER *u)
762 {
763 EBC_USER *ue;
764
765 assert(u);
766 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
767 assert(ue);
768
769 return ue->httpVMajor;
770 }
771
772
773
EBC_User_SetHttpVMajor(AB_USER * u,int i)774 void EBC_User_SetHttpVMajor(AB_USER *u, int i)
775 {
776 EBC_USER *ue;
777
778 assert(u);
779 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
780 assert(ue);
781
782 ue->httpVMajor=i;
783 }
784
785
786
EBC_User_GetHttpVMinor(const AB_USER * u)787 int EBC_User_GetHttpVMinor(const AB_USER *u)
788 {
789 EBC_USER *ue;
790
791 assert(u);
792 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
793 assert(ue);
794
795 return ue->httpVMinor;
796 }
797
798
799
EBC_User_SetHttpVMinor(AB_USER * u,int i)800 void EBC_User_SetHttpVMinor(AB_USER *u, int i)
801 {
802 EBC_USER *ue;
803
804 assert(u);
805 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
806 assert(ue);
807
808 ue->httpVMinor=i;
809 }
810
811
812
EBC_User_GetProtoVersion(const AB_USER * u)813 const char *EBC_User_GetProtoVersion(const AB_USER *u)
814 {
815 EBC_USER *ue;
816
817 assert(u);
818 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
819 assert(ue);
820
821 return ue->protoVersion;
822 }
823
824
825
EBC_User_SetProtoVersion(AB_USER * u,const char * s)826 void EBC_User_SetProtoVersion(AB_USER *u, const char *s)
827 {
828 EBC_USER *ue;
829
830 assert(u);
831 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
832 assert(ue);
833
834 free(ue->protoVersion);
835 if (s)
836 ue->protoVersion=strdup(s);
837 else
838 ue->protoVersion=NULL;
839 }
840
841
842
EBC_User_GetSignVersion(const AB_USER * u)843 const char *EBC_User_GetSignVersion(const AB_USER *u)
844 {
845 EBC_USER *ue;
846
847 assert(u);
848 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
849 assert(ue);
850
851 return ue->signVersion;
852 }
853
854
855
EBC_User_SetSignVersion(AB_USER * u,const char * s)856 void EBC_User_SetSignVersion(AB_USER *u, const char *s)
857 {
858 EBC_USER *ue;
859
860 assert(u);
861 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
862 assert(ue);
863
864 free(ue->signVersion);
865 if (s)
866 ue->signVersion=strdup(s);
867 else
868 ue->signVersion=NULL;
869 }
870
871
872
EBC_User_GetCryptVersion(const AB_USER * u)873 const char *EBC_User_GetCryptVersion(const AB_USER *u)
874 {
875 EBC_USER *ue;
876
877 assert(u);
878 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
879 assert(ue);
880
881 return ue->cryptVersion;
882 }
883
884
885
EBC_User_SetCryptVersion(AB_USER * u,const char * s)886 void EBC_User_SetCryptVersion(AB_USER *u, const char *s)
887 {
888 EBC_USER *ue;
889
890 assert(u);
891 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
892 assert(ue);
893
894 free(ue->cryptVersion);
895 if (s)
896 ue->cryptVersion=strdup(s);
897 else
898 ue->cryptVersion=NULL;
899 }
900
901
902
EBC_User_GetAuthVersion(const AB_USER * u)903 const char *EBC_User_GetAuthVersion(const AB_USER *u)
904 {
905 EBC_USER *ue;
906
907 assert(u);
908 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
909 assert(ue);
910
911 return ue->authVersion;
912 }
913
914
915
EBC_User_SetAuthVersion(AB_USER * u,const char * s)916 void EBC_User_SetAuthVersion(AB_USER *u, const char *s)
917 {
918 EBC_USER *ue;
919
920 assert(u);
921 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
922 assert(ue);
923
924 free(ue->authVersion);
925 if (s)
926 ue->authVersion=strdup(s);
927 else
928 ue->authVersion=NULL;
929 }
930
931
932
EBC_User_MkPasswdName(const AB_USER * u,GWEN_BUFFER * buf)933 int EBC_User_MkPasswdName(const AB_USER *u, GWEN_BUFFER *buf)
934 {
935 EBC_USER *ue;
936
937 assert(u);
938 ue=GWEN_INHERIT_GETDATA(AB_USER, EBC_USER, u);
939 assert(ue);
940
941 if (ue->tokenType==NULL) {
942 DBG_ERROR(AQEBICS_LOGDOMAIN, "Missing tokenType or tokenName");
943 return GWEN_ERROR_NO_DATA;
944 }
945
946 if (ue->tokenName) {
947 GWEN_Buffer_AppendString(buf, "PASSWORD_");
948 GWEN_Buffer_AppendString(buf, ue->tokenType);
949 GWEN_Buffer_AppendString(buf, "_");
950 GWEN_Buffer_AppendString(buf, ue->tokenName);
951 return 0;
952 }
953 else {
954 DBG_ERROR(AQEBICS_LOGDOMAIN, "Missing tokenName");
955 return GWEN_ERROR_NO_DATA;
956 }
957 }
958
959
960
961
962
963
964
965
966
967
968
969
970