00001
00002
00003
00004 #ifdef HAVE_CONFIG_H
00005 # include "config.h"
00006 #endif
00007
00008 #include "ct_context_p.h"
00009 #include <gwenhywfar/misc.h>
00010 #include <gwenhywfar/db.h>
00011 #include <gwenhywfar/debug.h>
00012 #include <assert.h>
00013 #include <stdlib.h>
00014 #include <strings.h>
00015
00016 #include <gwenhywfar/types.h>
00017
00018
00019 GWEN_INHERIT_FUNCTIONS(GWEN_CRYPT_TOKEN_CONTEXT)
00020 GWEN_LIST_FUNCTIONS(GWEN_CRYPT_TOKEN_CONTEXT, GWEN_Crypt_Token_Context)
00021 GWEN_LIST2_FUNCTIONS(GWEN_CRYPT_TOKEN_CONTEXT, GWEN_Crypt_Token_Context)
00022
00023
00024
00025
00026 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_new() {
00027 GWEN_CRYPT_TOKEN_CONTEXT *st;
00028
00029 GWEN_NEW_OBJECT(GWEN_CRYPT_TOKEN_CONTEXT, st)
00030 st->_usage=1;
00031 GWEN_INHERIT_INIT(GWEN_CRYPT_TOKEN_CONTEXT, st)
00032 GWEN_LIST_INIT(GWEN_CRYPT_TOKEN_CONTEXT, st)
00033 return st;
00034 }
00035
00036
00037 void GWEN_Crypt_Token_Context_free(GWEN_CRYPT_TOKEN_CONTEXT *st) {
00038 if (st) {
00039 assert(st->_usage);
00040 if (--(st->_usage)==0) {
00041 GWEN_INHERIT_FINI(GWEN_CRYPT_TOKEN_CONTEXT, st)
00042 if (st->serviceId)
00043 free(st->serviceId);
00044 if (st->userId)
00045 free(st->userId);
00046 if (st->userName)
00047 free(st->userName);
00048 if (st->peerId)
00049 free(st->peerId);
00050 if (st->peerName)
00051 free(st->peerName);
00052 if (st->address)
00053 free(st->address);
00054 if (st->systemId)
00055 free(st->systemId);
00056 GWEN_LIST_FINI(GWEN_CRYPT_TOKEN_CONTEXT, st)
00057 GWEN_FREE_OBJECT(st);
00058 }
00059 }
00060
00061 }
00062
00063
00064 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_dup(const GWEN_CRYPT_TOKEN_CONTEXT *d) {
00065 GWEN_CRYPT_TOKEN_CONTEXT *st;
00066
00067 assert(d);
00068 st=GWEN_Crypt_Token_Context_new();
00069 st->id=d->id;
00070 st->signKeyId=d->signKeyId;
00071 st->verifyKeyId=d->verifyKeyId;
00072 st->encipherKeyId=d->encipherKeyId;
00073 st->decipherKeyId=d->decipherKeyId;
00074 st->authSignKeyId=d->authSignKeyId;
00075 st->authVerifyKeyId=d->authVerifyKeyId;
00076 if (d->serviceId)
00077 st->serviceId=strdup(d->serviceId);
00078 if (d->userId)
00079 st->userId=strdup(d->userId);
00080 if (d->userName)
00081 st->userName=strdup(d->userName);
00082 if (d->peerId)
00083 st->peerId=strdup(d->peerId);
00084 if (d->peerName)
00085 st->peerName=strdup(d->peerName);
00086 if (d->address)
00087 st->address=strdup(d->address);
00088 st->port=d->port;
00089 if (d->systemId)
00090 st->systemId=strdup(d->systemId);
00091 return st;
00092 }
00093
00094
00095 int GWEN_Crypt_Token_Context_toDb(const GWEN_CRYPT_TOKEN_CONTEXT *st, GWEN_DB_NODE *db) {
00096 assert(st);
00097 assert(db);
00098 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "id", st->id))
00099 return -1;
00100 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "signKeyId", st->signKeyId))
00101 return -1;
00102 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "verifyKeyId", st->verifyKeyId))
00103 return -1;
00104 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "encipherKeyId", st->encipherKeyId))
00105 return -1;
00106 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "decipherKeyId", st->decipherKeyId))
00107 return -1;
00108 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "authSignKeyId", st->authSignKeyId))
00109 return -1;
00110 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "authVerifyKeyId", st->authVerifyKeyId))
00111 return -1;
00112 if (st->serviceId)
00113 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "serviceId", st->serviceId))
00114 return -1;
00115 if (st->userId)
00116 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "userId", st->userId))
00117 return -1;
00118 if (st->userName)
00119 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "userName", st->userName))
00120 return -1;
00121 if (st->peerId)
00122 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "peerId", st->peerId))
00123 return -1;
00124 if (st->peerName)
00125 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "peerName", st->peerName))
00126 return -1;
00127 if (st->address)
00128 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "address", st->address))
00129 return -1;
00130 if (GWEN_DB_SetIntValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "port", st->port))
00131 return -1;
00132 if (st->systemId)
00133 if (GWEN_DB_SetCharValue(db, GWEN_DB_FLAGS_OVERWRITE_VARS, "systemId", st->systemId))
00134 return -1;
00135 return 0;
00136 }
00137
00138
00139 int GWEN_Crypt_Token_Context_ReadDb(GWEN_CRYPT_TOKEN_CONTEXT *st, GWEN_DB_NODE *db) {
00140 assert(st);
00141 assert(db);
00142 GWEN_Crypt_Token_Context_SetId(st, GWEN_DB_GetIntValue(db, "id", 0, 0));
00143 GWEN_Crypt_Token_Context_SetSignKeyId(st, GWEN_DB_GetIntValue(db, "signKeyId", 0, 0));
00144 GWEN_Crypt_Token_Context_SetVerifyKeyId(st, GWEN_DB_GetIntValue(db, "verifyKeyId", 0, 0));
00145 GWEN_Crypt_Token_Context_SetEncipherKeyId(st, GWEN_DB_GetIntValue(db, "encipherKeyId", 0, 0));
00146 GWEN_Crypt_Token_Context_SetDecipherKeyId(st, GWEN_DB_GetIntValue(db, "decipherKeyId", 0, 0));
00147 GWEN_Crypt_Token_Context_SetAuthSignKeyId(st, GWEN_DB_GetIntValue(db, "authSignKeyId", 0, 0));
00148 GWEN_Crypt_Token_Context_SetAuthVerifyKeyId(st, GWEN_DB_GetIntValue(db, "authVerifyKeyId", 0, 0));
00149 GWEN_Crypt_Token_Context_SetServiceId(st, GWEN_DB_GetCharValue(db, "serviceId", 0, 0));
00150 GWEN_Crypt_Token_Context_SetUserId(st, GWEN_DB_GetCharValue(db, "userId", 0, 0));
00151 GWEN_Crypt_Token_Context_SetUserName(st, GWEN_DB_GetCharValue(db, "userName", 0, 0));
00152 GWEN_Crypt_Token_Context_SetPeerId(st, GWEN_DB_GetCharValue(db, "peerId", 0, 0));
00153 GWEN_Crypt_Token_Context_SetPeerName(st, GWEN_DB_GetCharValue(db, "peerName", 0, 0));
00154 GWEN_Crypt_Token_Context_SetAddress(st, GWEN_DB_GetCharValue(db, "address", 0, 0));
00155 GWEN_Crypt_Token_Context_SetPort(st, GWEN_DB_GetIntValue(db, "port", 0, 0));
00156 GWEN_Crypt_Token_Context_SetSystemId(st, GWEN_DB_GetCharValue(db, "systemId", 0, 0));
00157 return 0;
00158 }
00159
00160
00161 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_fromDb(GWEN_DB_NODE *db) {
00162 GWEN_CRYPT_TOKEN_CONTEXT *st;
00163
00164 assert(db);
00165 st=GWEN_Crypt_Token_Context_new();
00166 GWEN_Crypt_Token_Context_ReadDb(st, db);
00167 st->_modified=0;
00168 return st;
00169 }
00170
00171
00172
00173
00174 uint32_t GWEN_Crypt_Token_Context_GetId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00175 assert(st);
00176 return st->id;
00177 }
00178
00179
00180 void GWEN_Crypt_Token_Context_SetId(GWEN_CRYPT_TOKEN_CONTEXT *st, uint32_t d) {
00181 assert(st);
00182 st->id=d;
00183 st->_modified=1;
00184 }
00185
00186
00187
00188
00189 uint32_t GWEN_Crypt_Token_Context_GetSignKeyId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00190 assert(st);
00191 return st->signKeyId;
00192 }
00193
00194
00195 void GWEN_Crypt_Token_Context_SetSignKeyId(GWEN_CRYPT_TOKEN_CONTEXT *st, uint32_t d) {
00196 assert(st);
00197 st->signKeyId=d;
00198 st->_modified=1;
00199 }
00200
00201
00202
00203
00204 uint32_t GWEN_Crypt_Token_Context_GetVerifyKeyId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00205 assert(st);
00206 return st->verifyKeyId;
00207 }
00208
00209
00210 void GWEN_Crypt_Token_Context_SetVerifyKeyId(GWEN_CRYPT_TOKEN_CONTEXT *st, uint32_t d) {
00211 assert(st);
00212 st->verifyKeyId=d;
00213 st->_modified=1;
00214 }
00215
00216
00217
00218
00219 uint32_t GWEN_Crypt_Token_Context_GetEncipherKeyId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00220 assert(st);
00221 return st->encipherKeyId;
00222 }
00223
00224
00225 void GWEN_Crypt_Token_Context_SetEncipherKeyId(GWEN_CRYPT_TOKEN_CONTEXT *st, uint32_t d) {
00226 assert(st);
00227 st->encipherKeyId=d;
00228 st->_modified=1;
00229 }
00230
00231
00232
00233
00234 uint32_t GWEN_Crypt_Token_Context_GetDecipherKeyId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00235 assert(st);
00236 return st->decipherKeyId;
00237 }
00238
00239
00240 void GWEN_Crypt_Token_Context_SetDecipherKeyId(GWEN_CRYPT_TOKEN_CONTEXT *st, uint32_t d) {
00241 assert(st);
00242 st->decipherKeyId=d;
00243 st->_modified=1;
00244 }
00245
00246
00247
00248
00249 uint32_t GWEN_Crypt_Token_Context_GetAuthSignKeyId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00250 assert(st);
00251 return st->authSignKeyId;
00252 }
00253
00254
00255 void GWEN_Crypt_Token_Context_SetAuthSignKeyId(GWEN_CRYPT_TOKEN_CONTEXT *st, uint32_t d) {
00256 assert(st);
00257 st->authSignKeyId=d;
00258 st->_modified=1;
00259 }
00260
00261
00262
00263
00264 uint32_t GWEN_Crypt_Token_Context_GetAuthVerifyKeyId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00265 assert(st);
00266 return st->authVerifyKeyId;
00267 }
00268
00269
00270 void GWEN_Crypt_Token_Context_SetAuthVerifyKeyId(GWEN_CRYPT_TOKEN_CONTEXT *st, uint32_t d) {
00271 assert(st);
00272 st->authVerifyKeyId=d;
00273 st->_modified=1;
00274 }
00275
00276
00277
00278
00279 const char *GWEN_Crypt_Token_Context_GetServiceId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00280 assert(st);
00281 return st->serviceId;
00282 }
00283
00284
00285 void GWEN_Crypt_Token_Context_SetServiceId(GWEN_CRYPT_TOKEN_CONTEXT *st, const char *d) {
00286 assert(st);
00287 if (st->serviceId)
00288 free(st->serviceId);
00289 if (d && *d)
00290 st->serviceId=strdup(d);
00291 else
00292 st->serviceId=0;
00293 st->_modified=1;
00294 }
00295
00296
00297
00298
00299 const char *GWEN_Crypt_Token_Context_GetUserId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00300 assert(st);
00301 return st->userId;
00302 }
00303
00304
00305 void GWEN_Crypt_Token_Context_SetUserId(GWEN_CRYPT_TOKEN_CONTEXT *st, const char *d) {
00306 assert(st);
00307 if (st->userId)
00308 free(st->userId);
00309 if (d && *d)
00310 st->userId=strdup(d);
00311 else
00312 st->userId=0;
00313 st->_modified=1;
00314 }
00315
00316
00317
00318
00319 const char *GWEN_Crypt_Token_Context_GetUserName(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00320 assert(st);
00321 return st->userName;
00322 }
00323
00324
00325 void GWEN_Crypt_Token_Context_SetUserName(GWEN_CRYPT_TOKEN_CONTEXT *st, const char *d) {
00326 assert(st);
00327 if (st->userName)
00328 free(st->userName);
00329 if (d && *d)
00330 st->userName=strdup(d);
00331 else
00332 st->userName=0;
00333 st->_modified=1;
00334 }
00335
00336
00337
00338
00339 const char *GWEN_Crypt_Token_Context_GetPeerId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00340 assert(st);
00341 return st->peerId;
00342 }
00343
00344
00345 void GWEN_Crypt_Token_Context_SetPeerId(GWEN_CRYPT_TOKEN_CONTEXT *st, const char *d) {
00346 assert(st);
00347 if (st->peerId)
00348 free(st->peerId);
00349 if (d && *d)
00350 st->peerId=strdup(d);
00351 else
00352 st->peerId=0;
00353 st->_modified=1;
00354 }
00355
00356
00357
00358
00359 const char *GWEN_Crypt_Token_Context_GetPeerName(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00360 assert(st);
00361 return st->peerName;
00362 }
00363
00364
00365 void GWEN_Crypt_Token_Context_SetPeerName(GWEN_CRYPT_TOKEN_CONTEXT *st, const char *d) {
00366 assert(st);
00367 if (st->peerName)
00368 free(st->peerName);
00369 if (d && *d)
00370 st->peerName=strdup(d);
00371 else
00372 st->peerName=0;
00373 st->_modified=1;
00374 }
00375
00376
00377
00378
00379 const char *GWEN_Crypt_Token_Context_GetAddress(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00380 assert(st);
00381 return st->address;
00382 }
00383
00384
00385 void GWEN_Crypt_Token_Context_SetAddress(GWEN_CRYPT_TOKEN_CONTEXT *st, const char *d) {
00386 assert(st);
00387 if (st->address)
00388 free(st->address);
00389 if (d && *d)
00390 st->address=strdup(d);
00391 else
00392 st->address=0;
00393 st->_modified=1;
00394 }
00395
00396
00397
00398
00399 int GWEN_Crypt_Token_Context_GetPort(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00400 assert(st);
00401 return st->port;
00402 }
00403
00404
00405 void GWEN_Crypt_Token_Context_SetPort(GWEN_CRYPT_TOKEN_CONTEXT *st, int d) {
00406 assert(st);
00407 st->port=d;
00408 st->_modified=1;
00409 }
00410
00411
00412
00413
00414 const char *GWEN_Crypt_Token_Context_GetSystemId(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00415 assert(st);
00416 return st->systemId;
00417 }
00418
00419
00420 void GWEN_Crypt_Token_Context_SetSystemId(GWEN_CRYPT_TOKEN_CONTEXT *st, const char *d) {
00421 assert(st);
00422 if (st->systemId)
00423 free(st->systemId);
00424 if (d && *d)
00425 st->systemId=strdup(d);
00426 else
00427 st->systemId=0;
00428 st->_modified=1;
00429 }
00430
00431
00432
00433
00434 int GWEN_Crypt_Token_Context_IsModified(const GWEN_CRYPT_TOKEN_CONTEXT *st) {
00435 assert(st);
00436 return st->_modified;
00437 }
00438
00439
00440
00441 void GWEN_Crypt_Token_Context_SetModified(GWEN_CRYPT_TOKEN_CONTEXT *st, int i) {
00442 assert(st);
00443 st->_modified=i;
00444 }
00445
00446
00447
00448 void GWEN_Crypt_Token_Context_Attach(GWEN_CRYPT_TOKEN_CONTEXT *st) {
00449 assert(st);
00450 st->_usage++;
00451 }
00452
00453
00454
00455 GWEN_CRYPT_TOKEN_CONTEXT *GWEN_Crypt_Token_Context_List2__freeAll_cb(GWEN_CRYPT_TOKEN_CONTEXT *st,
00456 GWEN_UNUSED void *user_data) {
00457 GWEN_Crypt_Token_Context_free(st);
00458 return 0;
00459 }
00460
00461
00462 void GWEN_Crypt_Token_Context_List2_freeAll(GWEN_CRYPT_TOKEN_CONTEXT_LIST2 *stl) {
00463 if (stl) {
00464 GWEN_Crypt_Token_Context_List2_ForEach(stl, GWEN_Crypt_Token_Context_List2__freeAll_cb, 0);
00465 GWEN_Crypt_Token_Context_List2_free(stl);
00466 }
00467 }
00468
00469
00470
00471 GWEN_CRYPT_TOKEN_CONTEXT_LIST *GWEN_Crypt_Token_Context_List_dup(const GWEN_CRYPT_TOKEN_CONTEXT_LIST *stl) {
00472 if (stl) {
00473 GWEN_CRYPT_TOKEN_CONTEXT_LIST *nl;
00474 GWEN_CRYPT_TOKEN_CONTEXT *e;
00475
00476 nl=GWEN_Crypt_Token_Context_List_new();
00477 e=GWEN_Crypt_Token_Context_List_First(stl);
00478 while(e) {
00479 GWEN_CRYPT_TOKEN_CONTEXT *ne;
00480
00481 ne=GWEN_Crypt_Token_Context_dup(e);
00482 assert(ne);
00483 GWEN_Crypt_Token_Context_List_Add(ne, nl);
00484 e=GWEN_Crypt_Token_Context_List_Next(e);
00485 }
00486 return nl;
00487 }
00488 else
00489 return 0;
00490 }
00491
00492
00493
00494