00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include "syncml.h"
00023
00024 #include "syncml_internals.h"
00025 #include "sml_devinf_internals.h"
00026 #include "sml_command_internals.h"
00027 #include "sml_elements_internals.h"
00028 #include "sml_parse_internals.h"
00029 #include "parser/sml_xml_assm.h"
00030 #include "parser/sml_xml_parse.h"
00031 #include "sml_error_internals.h"
00032
00033 SmlDevInfDevTyp smlDevInfDevTypeFromString(const char *name, SmlError **error)
00034 {
00035 CHECK_ERROR_REF
00036
00037 if (!strcmp(name, SML_ELEMENT_DEVTYP_PAGER)) {
00038 return SML_DEVINF_DEVTYPE_PAGER;
00039 } else if (!strcmp(name, SML_ELEMENT_DEVTYP_HANDHELD)) {
00040 return SML_DEVINF_DEVTYPE_HANDHELD;
00041 } else if (!strcmp(name, SML_ELEMENT_DEVTYP_PDA)) {
00042 return SML_DEVINF_DEVTYPE_PDA;
00043 } else if (!strcmp(name, SML_ELEMENT_DEVTYP_PHONE)) {
00044 return SML_DEVINF_DEVTYPE_PHONE;
00045 } else if (!strcmp(name, SML_ELEMENT_DEVTYP_SMARTPHONE)) {
00046 return SML_DEVINF_DEVTYPE_SMARTPHONE;
00047 } else if (!strcmp(name, SML_ELEMENT_DEVTYP_SERVER)) {
00048 return SML_DEVINF_DEVTYPE_SERVER;
00049 } else if (!strcmp(name, SML_ELEMENT_DEVTYP_WORKSTATION)) {
00050 return SML_DEVINF_DEVTYPE_WORKSTATION;
00051 }
00052
00053 smlErrorSet(error, SML_ERROR_GENERIC, "Unknown devinf type name \"%s\"", name);
00054 return SML_DEVINF_DEVTYPE_UNKNOWN;
00055 }
00056
00057 const char *smlDevInfDevTypeToString(SmlDevInfDevTyp type, SmlError **error)
00058 {
00059 CHECK_ERROR_REF
00060
00061 switch (type) {
00062 case SML_DEVINF_DEVTYPE_PAGER:
00063 return SML_ELEMENT_DEVTYP_PAGER;
00064 case SML_DEVINF_DEVTYPE_HANDHELD:
00065 return SML_ELEMENT_DEVTYP_HANDHELD;
00066 case SML_DEVINF_DEVTYPE_PDA:
00067 return SML_ELEMENT_DEVTYP_PDA;
00068 case SML_DEVINF_DEVTYPE_PHONE:
00069 return SML_ELEMENT_DEVTYP_PHONE;
00070 case SML_DEVINF_DEVTYPE_SMARTPHONE:
00071 return SML_ELEMENT_DEVTYP_SMARTPHONE;
00072 case SML_DEVINF_DEVTYPE_SERVER:
00073 return SML_ELEMENT_DEVTYP_SERVER;
00074 case SML_DEVINF_DEVTYPE_WORKSTATION:
00075 return SML_ELEMENT_DEVTYP_WORKSTATION;
00076 case SML_DEVINF_DEVTYPE_UNKNOWN:
00077 smlErrorSet(error, SML_ERROR_GENERIC, "Unknown devinf type \"%i\"", type);
00078
00079 }
00080
00081 return NULL;
00082 }
00083
00084 SmlDevInf *smlDevInfNew(const char *devid, SmlDevInfDevTyp devtyp, SmlError **error)
00085 {
00086 smlTrace(TRACE_ENTRY, "%s(%s, %i, %p)", __func__, VA_STRING(devid), devtyp, error);
00087 CHECK_ERROR_REF
00088 smlAssert(devid);
00089
00090 SmlDevInf *devinf = smlTryMalloc0(sizeof(SmlDevInf), error);
00091 if (!devinf)
00092 goto error;
00093
00094 devinf->devid = g_strdup(devid);
00095 devinf->devtyp = devtyp;
00096 devinf->refCount = 1;
00097
00098 smlTrace(TRACE_EXIT, "%s: %p", __func__, devinf);
00099 return devinf;
00100
00101 error:
00102 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
00103 return NULL;
00104 }
00105
00106 SmlDevInf *smlDevInfRef(SmlDevInf *devinf)
00107 {
00108 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, devinf);
00109 smlAssert(devinf);
00110
00111 g_atomic_int_inc(&(devinf->refCount));
00112
00113 smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, devinf->refCount);
00114 return devinf;
00115 }
00116
00117 void smlDevInfUnref(SmlDevInf *devinf)
00118 {
00119 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, devinf);
00120 smlAssert(devinf);
00121
00122 if (g_atomic_int_dec_and_test(&(devinf->refCount))) {
00123 smlTrace(TRACE_INTERNAL, "%s: Refcount == 0!", __func__);
00124
00125 if (devinf->manufacturer)
00126 smlSafeCFree(&(devinf->manufacturer));
00127 if (devinf->model)
00128 smlSafeCFree(&(devinf->model));
00129 if (devinf->oem)
00130 smlSafeCFree(&(devinf->oem));
00131 if (devinf->softwareVersion)
00132 smlSafeCFree(&(devinf->softwareVersion));
00133 if (devinf->hardwareVersion)
00134 smlSafeCFree(&(devinf->hardwareVersion));
00135 if (devinf->firmwareVersion)
00136 smlSafeCFree(&(devinf->firmwareVersion));
00137 if (devinf->devid)
00138 smlSafeCFree(&(devinf->devid));
00139
00140 while (devinf->datastores) {
00141 SmlDevInfDataStore *store = devinf->datastores->data;
00142 devinf->datastores = g_list_remove(devinf->datastores, store);
00143 smlDevInfDataStoreUnref(store);
00144 }
00145
00146 while (devinf->ctcaps) {
00147 SmlDevInfCTCap *ctcap = devinf->ctcaps->data;
00148 devinf->ctcaps = g_list_remove(devinf->ctcaps, ctcap);
00149 smlSafeCFree(&(ctcap->ct->cttype));
00150 if (ctcap->ct->verct)
00151 smlSafeCFree(&(ctcap->ct->verct));
00152 smlSafeFree((gpointer *)&(ctcap->ct));
00153 while (ctcap->properties) {
00154 SmlDevInfProperty *prop = ctcap->properties->data;
00155 ctcap->properties = g_list_remove(ctcap->properties, prop);
00156 smlSafeCFree(&(prop->propName));
00157 if (prop->dataType)
00158 smlSafeCFree(&(prop->dataType));
00159 if (prop->displayName)
00160 smlSafeCFree(&(prop->displayName));
00161
00162
00163
00164 while (prop->valEnums) {
00165 char *valEnum = prop->valEnums->data;
00166 prop->valEnums = g_list_remove(prop->valEnums, valEnum);
00167 smlSafeCFree(&valEnum);
00168 }
00169 while (prop->propParams) {
00170 SmlDevInfPropParam *param = prop->propParams->data;
00171 prop->propParams = g_list_remove(prop->propParams, param);
00172 smlSafeCFree(&(param->paramName));
00173 if (param->dataType)
00174 smlSafeCFree(&(param->dataType));
00175 if (param->displayName)
00176 smlSafeCFree(&(param->displayName));
00177
00178
00179
00180 while (param->valEnums) {
00181 char *valEnum = param->valEnums->data;
00182 param->valEnums = g_list_remove(param->valEnums, valEnum);
00183 smlSafeCFree(&valEnum);
00184 }
00185
00186 smlSafeFree((gpointer *) ¶m);
00187 }
00188
00189 smlSafeFree((gpointer *) &prop);
00190 }
00191
00192 smlSafeFree((gpointer *)&ctcap);
00193 }
00194
00195 smlSafeFree((gpointer *)&devinf);
00196 }
00197
00198 smlTrace(TRACE_EXIT, "%s", __func__);
00199 }
00200
00201 const char *smlDevInfGetManufacturer(SmlDevInf *devinf)
00202 {
00203 return devinf->manufacturer;
00204 }
00205
00206 void smlDevInfSetManufacturer(SmlDevInf *devinf, const char *man)
00207 {
00208 if (devinf->manufacturer)
00209 smlSafeCFree(&(devinf->manufacturer));
00210 devinf->manufacturer = g_strdup(man);
00211 }
00212
00213 const char *smlDevInfGetModel(SmlDevInf *devinf)
00214 {
00215 return devinf->model;
00216 }
00217
00218 void smlDevInfSetModel(SmlDevInf *devinf, const char *model)
00219 {
00220 if (devinf->model)
00221 smlSafeCFree(&(devinf->model));
00222 devinf->model = g_strdup(model);
00223 }
00224
00225 const char *smlDevInfGetOEM(SmlDevInf *devinf)
00226 {
00227 return devinf->oem;
00228 }
00229
00230 void smlDevInfSetOEM(SmlDevInf *devinf, const char *oem)
00231 {
00232 if (devinf->oem)
00233 smlSafeCFree(&(devinf->oem));
00234 devinf->oem = g_strdup(oem);
00235 }
00236
00237 const char *smlDevInfGetFirmwareVersion(SmlDevInf *devinf)
00238 {
00239 return devinf->firmwareVersion;
00240 }
00241
00242 void smlDevInfSetFirmwareVersion(SmlDevInf *devinf, const char *firmwareVersion)
00243 {
00244 if (devinf->firmwareVersion)
00245 smlSafeCFree(&(devinf->firmwareVersion));
00246 devinf->firmwareVersion = g_strdup(firmwareVersion);
00247 }
00248
00249 const char *smlDevInfGetSoftwareVersion(SmlDevInf *devinf)
00250 {
00251 return devinf->softwareVersion;
00252 }
00253
00254 void smlDevInfSetSoftwareVersion(SmlDevInf *devinf, const char *softwareVersion)
00255 {
00256 if (devinf->softwareVersion)
00257 smlSafeCFree(&(devinf->softwareVersion));
00258 devinf->softwareVersion = g_strdup(softwareVersion);
00259 }
00260
00261 const char *smlDevInfGetHardwareVersion(SmlDevInf *devinf)
00262 {
00263 return devinf->hardwareVersion;
00264 }
00265
00266 void smlDevInfSetHardwareVersion(SmlDevInf *devinf, const char *hardwareVersion)
00267 {
00268 if (devinf->hardwareVersion)
00269 smlSafeCFree(&(devinf->hardwareVersion));
00270 devinf->hardwareVersion = g_strdup(hardwareVersion);
00271 }
00272
00273 const char *smlDevInfGetDeviceID(SmlDevInf *devinf)
00274 {
00275 return devinf->devid;
00276 }
00277
00278 void smlDevInfSetDeviceID(SmlDevInf *devinf, const char *devid)
00279 {
00280 if (devinf->devid)
00281 smlSafeCFree(&(devinf->devid));
00282 devinf->devid = g_strdup(devid);
00283 }
00284
00285 SmlDevInfDevTyp smlDevInfGetDeviceType(SmlDevInf *devinf)
00286 {
00287 return devinf->devtyp;
00288 }
00289
00290 void smlDevInfSetDeviceType(SmlDevInf *devinf, SmlDevInfDevTyp devtyp)
00291 {
00292 devinf->devtyp = devtyp;
00293 }
00294
00295 SmlBool smlDevInfSupportsUTC(SmlDevInf *devinf)
00296 {
00297 return devinf->supportsUTC;
00298 }
00299
00300 void smlDevInfSetSupportsUTC(SmlDevInf *devinf, SmlBool supports)
00301 {
00302 devinf->supportsUTC = supports;
00303 }
00304
00305 SmlBool smlDevInfSupportsLargeObjs(SmlDevInf *devinf)
00306 {
00307 return devinf->supportsLargeObjs;
00308 }
00309
00310 void smlDevInfSetSupportsLargeObjs(SmlDevInf *devinf, SmlBool supports)
00311 {
00312 devinf->supportsLargeObjs = supports;
00313 }
00314
00315 SmlBool smlDevInfSupportsNumberOfChanges(SmlDevInf *devinf)
00316 {
00317 return devinf->supportsNumberOfChanges;
00318 }
00319
00320 void smlDevInfSetSupportsNumberOfChanges(SmlDevInf *devinf, SmlBool supports)
00321 {
00322 devinf->supportsNumberOfChanges = supports;
00323 }
00324
00325 void smlDevInfAddDataStore(SmlDevInf *devinf, SmlDevInfDataStore *datastore)
00326 {
00327 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, devinf, datastore);
00328 smlAssert(devinf);
00329 smlAssert(datastore);
00330
00331 devinf->datastores = g_list_append(devinf->datastores, datastore);
00332
00333
00334 smlTrace(TRACE_EXIT, "%s", __func__);
00335 }
00336
00337 unsigned int smlDevInfNumDataStores(SmlDevInf *devinf)
00338 {
00339 smlAssert(devinf);
00340
00341 return g_list_length(devinf->datastores);
00342 }
00343
00344 const SmlDevInfDataStore *smlDevInfGetNthDataStore(const SmlDevInf *devinf, unsigned int nth)
00345 {
00346 smlAssert(devinf);
00347
00348 return g_list_nth_data(devinf->datastores, nth);
00349 }
00350
00351 SmlDevInfDataStore *smlDevInfDataStoreNew(const char *sourceRef, SmlError **error)
00352 {
00353 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, sourceRef, error);
00354 CHECK_ERROR_REF
00355
00356 SmlDevInfDataStore *datastore = smlTryMalloc0(sizeof(SmlDevInfDataStore), error);
00357 if (!datastore)
00358 goto error;
00359
00360 datastore->sourceref = g_strdup(sourceRef);
00361 datastore->refCount = 1;
00362
00363 smlTrace(TRACE_EXIT, "%s: %p", __func__, datastore);
00364 return datastore;
00365
00366 error:
00367 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
00368 return NULL;
00369 }
00370
00371
00372 SmlDevInfDataStore *smlDevInfDataStoreRef(SmlDevInfDataStore *datastore)
00373 {
00374 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, datastore);
00375 smlAssert(datastore);
00376
00377 g_atomic_int_inc(&(datastore->refCount));
00378
00379 smlTrace(TRACE_EXIT, "%s: New refcount: %i", __func__, datastore->refCount);
00380 return datastore;
00381 }
00382
00383 void smlDevInfDataStoreUnref(SmlDevInfDataStore *datastore)
00384 {
00385 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, datastore);
00386 smlAssert(datastore);
00387
00388 if (g_atomic_int_dec_and_test(&(datastore->refCount))) {
00389 smlTrace(TRACE_INTERNAL, "%s: Refcount == 0!", __func__);
00390
00391 smlSafeCFree(&(datastore->sourceref));
00392 if (datastore->displayname)
00393 smlSafeCFree(&(datastore->displayname));
00394
00395 smlSafeCFree(&(datastore->rxPrefContentType));
00396 smlSafeCFree(&(datastore->rxPrefVersion));
00397 GList *d = NULL;
00398 for (d = datastore->rx; d; d = d->next) {
00399 SmlDevInfContentType *ct = d->data;
00400 smlDevInfFreeContentType(ct);
00401 }
00402 g_list_free(datastore->rx);
00403
00404 smlSafeCFree(&(datastore->txPrefContentType));
00405 smlSafeCFree(&(datastore->txPrefVersion));
00406 for (d = datastore->tx; d; d = d->next) {
00407 SmlDevInfContentType *ct = d->data;
00408 smlDevInfFreeContentType(ct);
00409 }
00410 g_list_free(datastore->tx);
00411
00412 smlSafeFree((gpointer *)&datastore);
00413 }
00414
00415 smlTrace(TRACE_EXIT, "%s", __func__);
00416 }
00417
00418 const char *smlDevInfDataStoreGetSourceRef(const SmlDevInfDataStore *datastore)
00419 {
00420 return datastore->sourceref;
00421 }
00422
00423 void smlDevInfDataStoreSetSourceRef(SmlDevInfDataStore *datastore, const char *sourceref)
00424 {
00425 if (datastore->sourceref)
00426 smlSafeCFree(&(datastore->sourceref));
00427 datastore->sourceref = g_strdup(sourceref);
00428 }
00429
00430 const char *smlDevInfDataStoreGetDisplayName(const SmlDevInfDataStore *datastore)
00431 {
00432 return datastore->displayname;
00433 }
00434
00435 void smlDevInfDataStoreSetDisplayName(SmlDevInfDataStore *datastore, const char *displayName)
00436 {
00437 if (datastore->displayname)
00438 smlSafeCFree(&(datastore->displayname));
00439 datastore->displayname = g_strdup(displayName);
00440 }
00441
00442 unsigned int smlDevInfGetMaxGUIDSize(const SmlDevInfDataStore *datastore)
00443 {
00444 return datastore->maxGUIDSize;
00445 }
00446
00447 void smlDevInfSetMaxGUIDSize(SmlDevInfDataStore *datastore, unsigned int max)
00448 {
00449 datastore->maxGUIDSize = max;
00450 }
00451
00452 void smlDevInfDataStoreSetRxPref(SmlDevInfDataStore *datastore, const char *contenttype, const char *version)
00453 {
00454 if (datastore->rxPrefContentType)
00455 smlSafeCFree(&(datastore->rxPrefContentType));
00456 datastore->rxPrefContentType = g_strdup(contenttype);
00457
00458 if (datastore->rxPrefVersion)
00459 smlSafeCFree(&(datastore->rxPrefVersion));
00460 datastore->rxPrefVersion = g_strdup(version);
00461 }
00462
00463 SmlBool smlDevInfDataStoreGetRxPref(const SmlDevInfDataStore *datastore, char **contenttype, char **version)
00464 {
00465 if (!datastore->rxPrefContentType)
00466 return FALSE;
00467
00468 *contenttype = datastore->rxPrefContentType;
00469 *version = datastore->rxPrefVersion;
00470
00471 return TRUE;
00472 }
00473
00474
00475 void smlDevInfDataStoreSetRx(SmlDevInfDataStore *datastore, const char *contenttype, const char *version)
00476 {
00477 SmlError *error = NULL;
00478 SmlDevInfContentType *ct = smlDevInfNewContentType(contenttype, version, &error);
00479 if (!ct)
00480 {
00481 smlTrace(TRACE_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00482 smlErrorDeref(&error);
00483 return;
00484 }
00485 smlDevInfDataStoreAddRx(datastore, ct);
00486 }
00487
00488
00489 SmlBool smlDevInfDataStoreGetRx(const SmlDevInfDataStore *datastore, char **contenttype, char **version)
00490 {
00491 const SmlDevInfContentType *ct = smlDevInfDataStoreGetNthRx(datastore, 0);
00492 if (!ct)
00493 return FALSE;
00494
00495 *contenttype = smlDevInfContentTypeGetCTType(ct);
00496 *version = smlDevInfContentTypeGetVerCT(ct);
00497 return TRUE;
00498 }
00499
00500 void smlDevInfDataStoreAddRx(SmlDevInfDataStore *datastore, SmlDevInfContentType *ct)
00501 {
00502 smlAssert(datastore);
00503 datastore->rx = g_list_append(datastore->rx, ct);
00504 }
00505
00506 unsigned int smlDevInfDataStoreNumRx(const SmlDevInfDataStore *datastore)
00507 {
00508 return g_list_length(datastore->rx);
00509 }
00510
00511 const SmlDevInfContentType *smlDevInfDataStoreGetNthRx(
00512 const SmlDevInfDataStore *datastore,
00513 unsigned int n)
00514 {
00515 return g_list_nth_data(datastore->rx, n);
00516 }
00517
00518 void smlDevInfDataStoreSetTxPref(SmlDevInfDataStore *datastore, const char *contenttype, const char *version)
00519 {
00520 if (datastore->txPrefContentType)
00521 smlSafeCFree(&(datastore->txPrefContentType));
00522 datastore->txPrefContentType = g_strdup(contenttype);
00523
00524 if (datastore->txPrefVersion)
00525 smlSafeCFree(&(datastore->txPrefVersion));
00526 datastore->txPrefVersion = g_strdup(version);
00527 }
00528
00529 SmlBool smlDevInfDataStoreGetTxPref(const SmlDevInfDataStore *datastore, char **contenttype, char **version)
00530 {
00531 if (!datastore->txPrefContentType)
00532 return FALSE;
00533
00534 *contenttype = datastore->txPrefContentType;
00535 *version = datastore->txPrefVersion;
00536
00537 return TRUE;
00538 }
00539
00540
00541 void smlDevInfDataStoreSetTx(SmlDevInfDataStore *datastore, const char *contenttype, const char *version)
00542 {
00543 SmlError *error = NULL;
00544 SmlDevInfContentType *ct = smlDevInfNewContentType(contenttype, version, &error);
00545 if (!ct)
00546 {
00547 smlTrace(TRACE_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00548 smlErrorDeref(&error);
00549 return;
00550 }
00551 smlDevInfDataStoreAddTx(datastore, ct);
00552 }
00553
00554
00555 SmlBool smlDevInfDataStoreGetTx(const SmlDevInfDataStore *datastore, char **contenttype, char **version)
00556 {
00557 const SmlDevInfContentType *ct = smlDevInfDataStoreGetNthRx(datastore, 0);
00558 if (!ct)
00559 return FALSE;
00560
00561 *contenttype = smlDevInfContentTypeGetCTType(ct);
00562 *version = smlDevInfContentTypeGetVerCT(ct);
00563 return TRUE;
00564 }
00565
00566 void smlDevInfDataStoreAddTx(SmlDevInfDataStore *datastore, SmlDevInfContentType *ct)
00567 {
00568 smlAssert(datastore);
00569 datastore->tx = g_list_append(datastore->tx, ct);
00570 }
00571
00572 unsigned int smlDevInfDataStoreNumTx(const SmlDevInfDataStore *datastore)
00573 {
00574 return g_list_length(datastore->tx);
00575 }
00576
00577 const SmlDevInfContentType *smlDevInfDataStoreGetNthTx(
00578 const SmlDevInfDataStore *datastore,
00579 unsigned int n)
00580 {
00581 return g_list_nth_data(datastore->tx, n);
00582 }
00583
00584 void smlDevInfDataStoreSetMemory(SmlDevInfDataStore *datastore, SmlBool shared, unsigned int maxid, unsigned int maxmem)
00585 {
00586 datastore->sharedMem = shared;
00587 datastore->maxid = maxid;
00588 datastore->maxmem = maxmem;
00589 }
00590
00591 void smlDevInfDataStoreGetMemory(const SmlDevInfDataStore *datastore, SmlBool *shared, unsigned int *maxid, unsigned int *maxmem)
00592 {
00593 if (shared)
00594 *shared = datastore->sharedMem;
00595
00596 if (maxid)
00597 *maxid = datastore->maxid;
00598
00599 if (maxmem)
00600 *maxmem = datastore->maxmem;
00601 }
00602
00603 void smlDevInfDataStoreSetSyncCap(SmlDevInfDataStore *datastore, SmlDevInfSyncCap cap, SmlBool supported)
00604 {
00605 if (supported)
00606 datastore->synccap = datastore->synccap | cap;
00607 else
00608 datastore->synccap = datastore->synccap & ~cap;
00609 }
00610
00611 SmlBool smlDevInfDataStoreGetSyncCap(const SmlDevInfDataStore *datastore, SmlDevInfSyncCap cap)
00612 {
00613 return datastore->synccap & cap ? TRUE : FALSE;
00614 }
00615
00616 void smlDevInfConfigureSession(SmlDevInf *devinf, SmlSession *session)
00617 {
00618 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, devinf, session);
00619 smlAssert(devinf);
00620 smlAssert(session);
00621
00622 if (!devinf->supportsNumberOfChanges)
00623 smlSessionUseNumberOfChanges(session, FALSE);
00624
00625 if (!devinf->supportsLargeObjs)
00626 smlSessionUseLargeObjects(session, FALSE);
00627
00628 smlTrace(TRACE_EXIT, "%s", __func__);
00629 }
00630
00631 SmlBool smlDevInfAssemble(SmlDevInf *devinf, char **data, unsigned int *size, SmlError **error)
00632 {
00633 CHECK_ERROR_REF
00634 return smlXmlDevInfAssemble(devinf, devinf->version, data, size, error);
00635 }
00636
00637 SmlCommand *smlDevInfNewResult(SmlCommand *cmd, SmlDevInf *devinf, SmlDevInfVersion version, SmlError **error)
00638 {
00639 smlTrace(TRACE_ENTRY, "%s(%p, %i, %p, %p)", __func__, cmd, devinf, version, error);
00640 CHECK_ERROR_REF
00641 smlAssert(cmd);
00642 SmlLocation *source = NULL;
00643
00644 char *data = NULL;
00645 unsigned int size = 0;
00646 if (!smlXmlDevInfAssemble(devinf, version, &data, &size, error))
00647 goto error;
00648
00649 if (version == SML_DEVINF_VERSION_10)
00650 source = smlLocationNew("./devinf10", NULL, error);
00651 else if (version == SML_DEVINF_VERSION_12)
00652 source = smlLocationNew("./devinf12", NULL, error);
00653 else
00654 source = smlLocationNew("./devinf11", NULL, error);
00655
00656 if (!source)
00657 goto error_free_data;
00658
00659 SmlCommand *result = smlCommandNewResult(cmd, source, data, size, SML_ELEMENT_DEVINF_XML, error);
00660 if (!result) {
00661 smlLocationUnref(source);
00662 goto error_free_data;
00663 }
00664
00665 result->private.results.status->item->raw = TRUE;
00666
00667 smlLocationUnref(source);
00668
00669 smlTrace(TRACE_EXIT, "%s: %p", __func__, result);
00670 return result;
00671
00672 error_free_data:
00673 smlSafeCFree(&data);
00674 error:
00675 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
00676 return NULL;
00677 }
00678
00679 SmlCommand *smlDevInfNewPut(SmlDevInf *devinf, SmlDevInfVersion version, SmlError **error)
00680 {
00681 smlTrace(TRACE_ENTRY, "%s(%p, %i, %p)", __func__, devinf, version, error);
00682 CHECK_ERROR_REF
00683 smlAssert(devinf);
00684 SmlLocation *source = NULL;
00685
00686
00687 if (devinf->version == SML_DEVINF_VERSION_UNKNOWN)
00688 devinf->version = version;
00689
00690 if (version == SML_DEVINF_VERSION_10)
00691 source = smlLocationNew("./devinf10", NULL, error);
00692 else if (version == SML_DEVINF_VERSION_12)
00693 source = smlLocationNew("./devinf12", NULL, error);
00694 else
00695 source = smlLocationNew("./devinf11", NULL, error);
00696
00697 if (!source)
00698 goto error;
00699
00700 SmlCommand *cmd = smlCommandNewPut(NULL, source, NULL, 0, SML_ELEMENT_DEVINF_XML, error);
00701 if (!cmd)
00702 goto error_free_source;
00703
00704 smlLocationUnref(source);
00705
00706 char *data = NULL;
00707 unsigned int size = 0;
00708 if (!smlXmlDevInfAssemble(devinf, version, &data, &size, error))
00709 goto error_free_cmd;
00710
00711 if (!smlItemAddData(cmd->private.access.item, data, size, error)) {
00712 smlSafeCFree(&data);
00713 goto error_free_cmd;
00714 }
00715 smlSafeCFree(&data);
00716 smlItemSetRaw(cmd->private.access.item, TRUE);
00717
00718 smlTrace(TRACE_EXIT, "%s: %p", __func__, cmd);
00719 return cmd;
00720
00721 error_free_cmd:
00722 smlCommandUnref(cmd);
00723 error_free_source:
00724 smlLocationUnref(source);
00725 error:
00726 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
00727 return NULL;
00728 }
00729
00730 SmlCommand *smlDevInfNewGet(SmlDevInfVersion version, SmlError **error)
00731 {
00732 smlTrace(TRACE_ENTRY, "%s(%i, %p)", __func__, version, error);
00733 CHECK_ERROR_REF
00734 SmlLocation *target = NULL;
00735
00736 if (version == SML_DEVINF_VERSION_10)
00737 target = smlLocationNew("./devinf10", NULL, error);
00738 else if (version == SML_DEVINF_VERSION_12)
00739 target = smlLocationNew("./devinf12", NULL, error);
00740 else
00741 target = smlLocationNew("./devinf11", NULL, error);
00742
00743 if (!target)
00744 goto error;
00745
00746 SmlCommand *cmd = smlCommandNewGet(target, SML_ELEMENT_DEVINF_XML, error);
00747 if (!cmd)
00748 goto error_free_target;
00749
00750 smlLocationUnref(target);
00751
00752 smlTrace(TRACE_EXIT, "%s: %p", __func__, cmd);
00753 return cmd;
00754
00755 error_free_target:
00756 smlLocationUnref(target);
00757 error:
00758 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
00759 return NULL;
00760 }
00761
00762 SmlDevInf *smlDevInfParse(const char *data, unsigned int length, SmlError **error)
00763 {
00764 smlTrace(TRACE_ENTRY, "%s(%p, %i, %p)", __func__, data, length, error);
00765 CHECK_ERROR_REF
00766 smlAssert(data);
00767 smlAssert(length);
00768
00769 SmlDevInf *devinf = smlXmlDevInfParse(data, length, error);
00770 if (!devinf)
00771 goto error;
00772
00773 smlTrace(TRACE_EXIT, "%s", __func__);
00774 return devinf;
00775
00776 error:
00777 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
00778 return NULL;
00779 }
00780
00781 SmlDevInf *smlDevInfFromResult(SmlCommand *result, SmlError **error)
00782 {
00783 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, result, error);
00784 CHECK_ERROR_REF
00785 smlAssert(result);
00786
00787 if (result->type != SML_COMMAND_TYPE_RESULTS) {
00788 smlErrorSet(error, SML_ERROR_GENERIC, "devinf command was not a result");
00789 goto error;
00790 }
00791
00792 SmlItem *item = result->private.results.status->item;
00793 if (!item) {
00794 smlErrorSet(error, SML_ERROR_GENERIC, "devinf result did not have a item");
00795 goto error;
00796 }
00797
00798 char *data = NULL;
00799 unsigned int size = 0;
00800 if (!smlItemGetData(item, &data, &size, error))
00801 goto error;
00802
00803 SmlDevInf *devinf = smlDevInfParse(data, size, error);
00804 if (!devinf)
00805 goto error;
00806
00807 smlTrace(TRACE_EXIT, "%s", __func__);
00808 return devinf;
00809
00810 error:
00811 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
00812 return NULL;
00813 }
00814
00815 SmlDevInfCTCapType smlDevInfCTCapTypeFromString(const char *name, SmlError **error)
00816 {
00817 CHECK_ERROR_REF
00818
00819 if (!strcmp(name, SML_ELEMENT_CTTYPE)) {
00820 return SML_DEVINF_CTCAP_CTTYPE;
00821 } else if (!strcmp(name, SML_ELEMENT_PROPNAME)) {
00822 return SML_DEVINF_CTCAP_PROPNAME;
00823 } else if (!strcmp(name, SML_ELEMENT_VALENUM)) {
00824 return SML_DEVINF_CTCAP_VALENUM;
00825 } else if (!strcmp(name, SML_ELEMENT_DATATYPE)) {
00826 return SML_DEVINF_CTCAP_DATATYPE;
00827 } else if (!strcmp(name, SML_ELEMENT_SIZE)) {
00828 return SML_DEVINF_CTCAP_SIZE;
00829 } else if (!strcmp(name, SML_ELEMENT_DISPLAYNAME)) {
00830 return SML_DEVINF_CTCAP_DISPLAYNAME;
00831 } else if (!strcmp(name, SML_ELEMENT_PARAMNAME)) {
00832 return SML_DEVINF_CTCAP_PARAMNAME;
00833 } else if (!strcmp(name, SML_ELEMENT_VERCT)) {
00834 return SML_DEVINF_CTCAP_VERCT;
00835 } else if (!strcmp(name, SML_ELEMENT_PROPERTY)) {
00836 return SML_DEVINF_CTCAP_PROPERTY;
00837 } else if (!strcmp(name, SML_ELEMENT_PROPPARAM)) {
00838 return SML_DEVINF_CTCAP_PROPPARAM;
00839 } else if (!strcmp(name, SML_ELEMENT_NOTRUNCATE)) {
00840 return SML_DEVINF_CTCAP_NOTRUNCATE;
00841 } else if (!strcmp(name, SML_ELEMENT_MAXOCCUR)) {
00842 return SML_DEVINF_CTCAP_MAXOCCUR;
00843 } else if (!strcmp(name, SML_ELEMENT_MAXSIZE)) {
00844 return SML_DEVINF_CTCAP_MAXSIZE;
00845 }
00846
00847 smlErrorSet(error, SML_ERROR_GENERIC, "Unknown ctcap type name \"%s\"", name);
00848 smlTrace(TRACE_ERROR, "%s - %s", __func__, smlErrorPrint(error));
00849 return SML_DEVINF_CTCAP_UNKNOWN;
00850 }
00851
00852
00853 const char *smlDevInfCTCapTypeToString(SmlDevInfCTCapType type, SmlError **error)
00854 {
00855 CHECK_ERROR_REF
00856
00857 switch (type) {
00858 case SML_DEVINF_CTCAP_CTTYPE:
00859 return SML_ELEMENT_CTTYPE;
00860 case SML_DEVINF_CTCAP_PROPNAME:
00861 return SML_ELEMENT_PROPNAME;
00862 case SML_DEVINF_CTCAP_VALENUM:
00863 return SML_ELEMENT_VALENUM;
00864 case SML_DEVINF_CTCAP_DATATYPE:
00865 return SML_ELEMENT_DATATYPE;
00866 case SML_DEVINF_CTCAP_SIZE:
00867 return SML_ELEMENT_SIZE;
00868 case SML_DEVINF_CTCAP_DISPLAYNAME:
00869 return SML_ELEMENT_DISPLAYNAME;
00870 case SML_DEVINF_CTCAP_PARAMNAME:
00871 return SML_ELEMENT_PARAMNAME;
00872 case SML_DEVINF_CTCAP_NOTRUNCATE:
00873 return SML_ELEMENT_NOTRUNCATE;
00874 case SML_DEVINF_CTCAP_MAXOCCUR:
00875 return SML_ELEMENT_MAXOCCUR;
00876 case SML_DEVINF_CTCAP_VERCT:
00877 return SML_ELEMENT_VERCT;
00878 case SML_DEVINF_CTCAP_PROPERTY:
00879 return SML_ELEMENT_PROPERTY;
00880 case SML_DEVINF_CTCAP_PROPPARAM:
00881 return SML_ELEMENT_PROPPARAM;
00882 case SML_DEVINF_CTCAP_MAXSIZE:
00883 return SML_ELEMENT_MAXSIZE;
00884 case SML_DEVINF_CTCAP_UNKNOWN:
00885 smlErrorSet(error, SML_ERROR_GENERIC, "Unknown ctcap type \"%i\"", type);
00886
00887 }
00888
00889 return NULL;
00890 }
00891
00892
00893
00894 SmlDevInfPropParam *smlDevInfNewPropParam(SmlError **error)
00895 {
00896 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, error);
00897 CHECK_ERROR_REF
00898
00899 SmlDevInfPropParam *param = smlTryMalloc0(sizeof(SmlDevInfPropParam), error);
00900 if (!param) {
00901 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
00902 return NULL;
00903 }
00904
00905 param->paramName = NULL;
00906 param->dataType = NULL;
00907 param->displayName = NULL;
00908 param->valEnums = NULL;
00909
00910 smlTrace(TRACE_EXIT, "%s", __func__);
00911 return param;
00912 }
00913
00914 void smlDevInfPropParamSetParamName(
00915 SmlDevInfPropParam *propParam,
00916 const char *paramName)
00917 {
00918 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, propParam, VA_STRING(paramName));
00919 smlAssert(propParam);
00920 smlAssert(paramName);
00921
00922 if (propParam->paramName != NULL)
00923 smlSafeCFree(&(propParam->paramName));
00924 propParam->paramName = g_strdup(paramName);
00925
00926 smlTrace(TRACE_EXIT, "%s", __func__);
00927 }
00928
00929 void smlDevInfPropParamSetDataType(
00930 SmlDevInfPropParam *propParam,
00931 const char *dataType)
00932 {
00933 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, propParam, VA_STRING(dataType));
00934 smlAssert(propParam);
00935 smlAssert(dataType);
00936
00937 if (propParam->dataType != NULL)
00938 smlSafeCFree(&(propParam->dataType));
00939 propParam->dataType = g_strdup(dataType);
00940
00941 smlTrace(TRACE_EXIT, "%s", __func__);
00942 }
00943
00944 void smlDevInfPropParamSetDisplayName(
00945 SmlDevInfPropParam *propParam,
00946 const char *displayName)
00947 {
00948 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, propParam, VA_STRING(displayName));
00949 smlAssert(propParam);
00950 smlAssert(displayName);
00951
00952 if (propParam->displayName != NULL)
00953 smlSafeCFree(&(propParam->displayName));
00954 propParam->displayName = g_strdup(displayName);
00955
00956 smlTrace(TRACE_EXIT, "%s", __func__);
00957 }
00958
00959 void smlDevInfPropParamAddValEnum(
00960 SmlDevInfPropParam *propParam,
00961 const char *valEnum)
00962 {
00963 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, propParam, VA_STRING(valEnum));
00964 smlAssert(propParam);
00965 smlAssert(valEnum);
00966 propParam->valEnums = g_list_append(propParam->valEnums, g_strdup(valEnum));
00967 smlTrace(TRACE_EXIT, "%s", __func__);
00968 }
00969
00970 char *smlDevInfPropParamGetParamName(const SmlDevInfPropParam *propParam)
00971 {
00972 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, propParam);
00973 smlAssert(propParam);
00974 char *result = g_strdup(propParam->paramName);
00975 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(result));
00976 return result;
00977 }
00978
00979 char *smlDevInfPropParamGetDataType(const SmlDevInfPropParam *propParam)
00980 {
00981 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, propParam);
00982 smlAssert(propParam);
00983 char *result = g_strdup(propParam->dataType);
00984 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(result));
00985 return result;
00986 }
00987
00988 char *smlDevInfPropParamGetDisplayName(const SmlDevInfPropParam *propParam)
00989 {
00990 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, propParam);
00991 smlAssert(propParam);
00992 char *result = g_strdup(propParam->displayName);
00993 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(result));
00994 return result;
00995 }
00996
00997 unsigned int smlDevInfPropParamNumValEnums(const SmlDevInfPropParam *propParam)
00998 {
00999 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, propParam);
01000 smlAssert(propParam);
01001 unsigned int num = g_list_length(propParam->valEnums);
01002 smlTrace(TRACE_EXIT, "%s - %d", __func__, num);
01003 return num;
01004 }
01005
01006 char *smlDevInfPropParamGetNthValEnum(
01007 const SmlDevInfPropParam *propParam,
01008 unsigned int n)
01009 {
01010 smlTrace(TRACE_ENTRY, "%s(%p, %d)", __func__, propParam, n);
01011 smlAssert(propParam);
01012 char *result = g_strdup(g_list_nth_data(propParam->valEnums, n));
01013 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(result));
01014 return result;
01015 }
01016
01017
01018
01019 SmlDevInfProperty *smlDevInfNewProperty(SmlError **error)
01020 {
01021 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, error);
01022 CHECK_ERROR_REF
01023
01024 SmlDevInfProperty *property = smlTryMalloc0(sizeof(SmlDevInfProperty), error);
01025 if (!property) {
01026 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
01027 return NULL;
01028 }
01029
01030 property->propName = NULL;
01031 property->dataType = NULL;
01032 property->maxOccur = 0;
01033 property->maxSize = 0;
01034 property->noTruncate = FALSE;
01035 property->displayName = NULL;
01036 property->valEnums = NULL;
01037 property->propParams = NULL;
01038
01039 smlTrace(TRACE_EXIT, "%s", __func__);
01040 return property;
01041 }
01042
01043 void smlDevInfPropertySetPropName(
01044 SmlDevInfProperty *property,
01045 const char *propName)
01046 {
01047 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, property, VA_STRING(propName));
01048 smlAssert(property);
01049 smlAssert(propName);
01050
01051 if (property->propName != NULL)
01052 smlSafeCFree(&(property->propName));
01053 property->propName = g_strdup(propName);
01054
01055 smlTrace(TRACE_EXIT, "%s", __func__);
01056 }
01057
01058 void smlDevInfPropertySetDataType(
01059 SmlDevInfProperty *property,
01060 const char *dataType)
01061 {
01062 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, property, VA_STRING(dataType));
01063 smlAssert(property);
01064 smlAssert(dataType);
01065
01066 if (property->dataType != NULL)
01067 smlSafeCFree(&(property->dataType));
01068 property->dataType = g_strdup(dataType);
01069
01070 smlTrace(TRACE_EXIT, "%s", __func__);
01071 }
01072
01073 void smlDevInfPropertySetMaxOccur(
01074 SmlDevInfProperty *property,
01075 unsigned int maxOccur)
01076 {
01077 smlTrace(TRACE_ENTRY, "%s(%p, %d)", __func__, property, maxOccur);
01078 smlAssert(property);
01079
01080 property->maxOccur = maxOccur;
01081
01082 smlTrace(TRACE_EXIT, "%s", __func__);
01083 }
01084
01085 void smlDevInfPropertySetMaxSize(
01086 SmlDevInfProperty *property,
01087 unsigned int maxSize)
01088 {
01089 smlTrace(TRACE_ENTRY, "%s(%p, %d)", __func__, property, maxSize);
01090 smlAssert(property);
01091
01092 property->maxSize = maxSize;
01093
01094 smlTrace(TRACE_EXIT, "%s", __func__);
01095 }
01096
01097 void smlDevInfPropertySetPropSize(
01098 SmlDevInfProperty *property,
01099 unsigned int propSize)
01100 {
01101 smlTrace(TRACE_ENTRY, "%s(%p, %d)", __func__, property, propSize);
01102 smlAssert(property);
01103
01104 property->propSize = propSize;
01105
01106 smlTrace(TRACE_EXIT, "%s", __func__);
01107 }
01108
01109 void smlDevInfPropertySetNoTruncate(
01110 SmlDevInfProperty *property)
01111 {
01112 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01113 smlAssert(property);
01114
01115 property->noTruncate = TRUE;
01116
01117 smlTrace(TRACE_EXIT, "%s", __func__);
01118 }
01119
01120 void smlDevInfPropertySetDisplayName(
01121 SmlDevInfProperty *property,
01122 const char *displayName)
01123 {
01124 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, property, VA_STRING(displayName));
01125 smlAssert(property);
01126 smlAssert(displayName);
01127
01128 if (property->displayName != NULL)
01129 smlSafeCFree(&(property->displayName));
01130 property->displayName = g_strdup(displayName);
01131
01132 smlTrace(TRACE_EXIT, "%s", __func__);
01133 }
01134
01135 void smlDevInfPropertyAddValEnum(
01136 SmlDevInfProperty *property,
01137 const char *valEnum)
01138 {
01139 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, property, VA_STRING(valEnum));
01140 smlAssert(property);
01141 smlAssert(valEnum);
01142 property->valEnums = g_list_append(property->valEnums, g_strdup(valEnum));
01143 smlTrace(TRACE_EXIT, "%s", __func__);
01144 }
01145
01146 void smlDevInfPropertyAddPropParam(
01147 SmlDevInfProperty *property,
01148 SmlDevInfPropParam *propParam)
01149 {
01150 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, property, propParam);
01151 smlAssert(property);
01152 smlAssert(propParam);
01153 property->propParams = g_list_append(property->propParams, propParam);
01154 smlTrace(TRACE_EXIT, "%s", __func__);
01155 }
01156
01157 char *smlDevInfPropertyGetPropName(const SmlDevInfProperty *property)
01158 {
01159 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01160 smlAssert(property);
01161 char *result = g_strdup(property->propName);
01162 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(result));
01163 return result;
01164 }
01165
01166 char *smlDevInfPropertyGetDataType(const SmlDevInfProperty *property)
01167 {
01168 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01169 smlAssert(property);
01170 char *result = g_strdup(property->dataType);
01171 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(result));
01172 return result;
01173 }
01174
01175 unsigned int smlDevInfPropertyGetMaxOccur(const SmlDevInfProperty *property)
01176 {
01177 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01178 smlAssert(property);
01179 smlTrace(TRACE_EXIT, "%s - %d", __func__, property->maxOccur);
01180 return property->maxOccur;
01181 }
01182
01183 unsigned int smlDevInfPropertyGetMaxSize(const SmlDevInfProperty *property)
01184 {
01185 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01186 smlAssert(property);
01187 smlTrace(TRACE_EXIT, "%s - %d", __func__, property->maxSize);
01188 return property->maxSize;
01189 }
01190
01191 SmlBool smlDevInfPropertyGetNoTruncate(const SmlDevInfProperty *property)
01192 {
01193 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01194 smlAssert(property);
01195 smlTrace(TRACE_EXIT, "%s - %d", __func__, property->noTruncate);
01196 return property->noTruncate;
01197 }
01198
01199 char *smlDevInfPropertyGetDisplayName(const SmlDevInfProperty *property)
01200 {
01201 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01202 smlAssert(property);
01203 char *result = g_strdup(property->displayName);
01204 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(result));
01205 return result;
01206 }
01207
01208 unsigned int smlDevInfPropertyNumValEnums(const SmlDevInfProperty *property)
01209 {
01210 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01211 smlAssert(property);
01212 unsigned int num = g_list_length(property->valEnums);
01213 smlTrace(TRACE_EXIT, "%s - %d", __func__, num);
01214 return num;
01215 }
01216
01217 char *smlDevInfPropertyGetNthValEnum(
01218 const SmlDevInfProperty *property,
01219 unsigned int n)
01220 {
01221 smlTrace(TRACE_ENTRY, "%s(%p, %d)", __func__, property, n);
01222 smlAssert(property);
01223 char *result = g_strdup(g_list_nth_data(property->valEnums, n));
01224 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(result));
01225 return result;
01226 }
01227
01228 unsigned int smlDevInfPropertyNumPropParams(const SmlDevInfProperty *property)
01229 {
01230 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, property);
01231 smlAssert(property);
01232 unsigned int num = g_list_length(property->propParams);
01233 smlTrace(TRACE_EXIT, "%s - %d", __func__, num);
01234 return num;
01235 }
01236
01237 const SmlDevInfPropParam *smlDevInfPropertyGetNthPropParam(
01238 const SmlDevInfProperty *property,
01239 unsigned int n)
01240 {
01241 smlTrace(TRACE_ENTRY, "%s(%p, %d)", __func__, property, n);
01242 smlAssert(property);
01243 SmlDevInfPropParam *param = g_list_nth_data(property->propParams, n);
01244 smlTrace(TRACE_EXIT, "%s - %p", __func__, param);
01245 return param;
01246 }
01247
01248
01249
01250 SmlDevInfContentType *smlDevInfNewContentType(
01251 const char *cttype,
01252 const char *verct,
01253 SmlError **error)
01254 {
01255 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, error);
01256 CHECK_ERROR_REF
01257
01258 SmlDevInfContentType *ct = smlTryMalloc0(sizeof(SmlDevInfContentType), error);
01259 if (!ct) {
01260 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
01261 return NULL;
01262 }
01263
01264 if (cttype != NULL)
01265 ct->cttype = g_strdup(cttype);
01266 else
01267 ct->cttype = NULL;
01268 if (verct != NULL)
01269 ct->verct = g_strdup(verct);
01270 else
01271 ct->verct = NULL;
01272
01273 smlTrace(TRACE_EXIT, "%s", __func__);
01274 return ct;
01275 }
01276
01277 char *smlDevInfContentTypeGetCTType(const SmlDevInfContentType *ct)
01278 {
01279 return g_strdup(ct->cttype);
01280 }
01281
01282 char *smlDevInfContentTypeGetVerCT(const SmlDevInfContentType *ct)
01283 {
01284 return g_strdup(ct->verct);
01285 }
01286
01287 void smlDevInfFreeContentType(SmlDevInfContentType *ct)
01288 {
01289 smlTrace(TRACE_ENTRY, "%s", __func__);
01290 smlAssert(ct);
01291
01292 if (ct->cttype != NULL)
01293 smlSafeCFree(&(ct->cttype));
01294 if (ct->verct != NULL)
01295 smlSafeCFree(&(ct->verct));
01296 smlSafeFree((gpointer *)&ct);
01297
01298 smlTrace(TRACE_EXIT, "%s", __func__);
01299 }
01300
01301 SmlDevInfCTCap *smlDevInfNewCTCap(SmlError **error)
01302 {
01303 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, error);
01304 CHECK_ERROR_REF
01305
01306 SmlDevInfCTCap *ctcap = smlTryMalloc0(sizeof(SmlDevInfCTCap), error);
01307 if (!ctcap) {
01308 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
01309 return NULL;
01310 }
01311
01312 ctcap->ct = smlDevInfNewContentType(NULL, NULL, error);
01313 if (!ctcap->ct) {
01314 smlTrace(TRACE_EXIT_ERROR, "%s: %s", __func__, smlErrorPrint(error));
01315 smlSafeFree((gpointer *)&ctcap);
01316 return NULL;
01317 }
01318 ctcap->properties = NULL;
01319
01320 smlTrace(TRACE_EXIT, "%s", __func__);
01321 return ctcap;
01322 }
01323
01324 void smlDevInfCTCapSetCTType(
01325 SmlDevInfCTCap *ctcap,
01326 const char *cttype)
01327 {
01328 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, ctcap, VA_STRING(cttype));
01329 smlAssert(ctcap);
01330 smlAssert(cttype);
01331
01332 ctcap->ct->cttype = g_strdup(cttype);
01333
01334 smlTrace(TRACE_EXIT, "%s", __func__);
01335 }
01336
01337 void smlDevInfCTCapSetVerCT(
01338 SmlDevInfCTCap *ctcap,
01339 const char *verct)
01340 {
01341 smlTrace(TRACE_ENTRY, "%s(%p, %s)", __func__, ctcap, VA_STRING(verct));
01342 smlAssert(ctcap);
01343 smlAssert(verct);
01344
01345 ctcap->ct->verct = g_strdup(verct);
01346
01347 smlTrace(TRACE_EXIT, "%s", __func__);
01348 }
01349
01350 char *smlDevInfCTCapGetCTType(const SmlDevInfCTCap *ctcap)
01351 {
01352 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, ctcap);
01353 smlAssert(ctcap);
01354 char *cttype;
01355
01356 cttype = g_strdup(ctcap->ct->cttype);
01357
01358 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(cttype));
01359 return cttype;
01360 }
01361
01362 char *smlDevInfCTCapGetVerCT(const SmlDevInfCTCap *ctcap)
01363 {
01364 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, ctcap);
01365 smlAssert(ctcap);
01366 char *verct;
01367
01368 verct = g_strdup(ctcap->ct->verct);
01369
01370 smlTrace(TRACE_EXIT, "%s - %s", __func__, VA_STRING(verct));
01371 return verct;
01372 }
01373
01374 void smlDevInfCTCapAddProperty(
01375 SmlDevInfCTCap *ctcap,
01376 SmlDevInfProperty *property)
01377 {
01378 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, ctcap, property);
01379 smlAssert(ctcap);
01380 smlAssert(property);
01381 ctcap->properties = g_list_append(ctcap->properties, property);
01382 smlTrace(TRACE_EXIT, "%s", __func__);
01383 }
01384
01385 void smlDevInfAppendCTCap(SmlDevInf *devinf, SmlDevInfCTCap *ctcap)
01386 {
01387 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, devinf, ctcap);
01388 smlAssert(devinf);
01389 smlAssert(ctcap);
01390 devinf->ctcaps = g_list_append(devinf->ctcaps, ctcap);
01391 smlTrace(TRACE_EXIT, "%s", __func__);
01392 }
01393
01394
01395 void smlDevInfAddCTCap(SmlDevInf *devinf, SmlDevInfCTCapType type, const char *value)
01396 {
01397 SmlDevInfCTCap *ctcap = smlDevInfNewCTCap(NULL);
01398 smlDevInfCTCapSetCTType(ctcap, smlDevInfCTCapTypeToString(type, NULL));
01399 smlDevInfCTCapSetVerCT(ctcap, value);
01400 smlDevInfAppendCTCap(devinf, ctcap);
01401 }
01402
01403
01404 SmlDevInfCTCapType smlDevInfGetNthCTCapType(SmlDevInf *devinf, unsigned int nth)
01405 {
01406 const SmlDevInfCTCap *ctcap = smlDevInfGetNthCTCap(devinf, nth);
01407 char *type = smlDevInfCTCapGetCTType(ctcap);
01408 SmlError *error = NULL;
01409 SmlDevInfCTCapType cttype = smlDevInfCTCapTypeFromString(type, &error);
01410 smlSafeCFree(&type);
01411 return cttype;
01412 }
01413
01414
01415 const char *smlDevInfGetNthCTCapValue(SmlDevInf *devinf, unsigned int nth)
01416 {
01417 const SmlDevInfCTCap *ctcap = smlDevInfGetNthCTCap(devinf, nth);
01418 return smlDevInfCTCapGetVerCT(ctcap);
01419 }
01420
01421 const SmlDevInfCTCap *smlDevInfGetCTCap(
01422 const SmlDevInf *devinf,
01423 SmlDevInfContentType *ct)
01424 {
01425 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, devinf, ct);
01426 smlAssert(devinf);
01427 smlAssert(ct);
01428 smlAssert(ct->cttype);
01429 smlAssert(ct->verct);
01430
01431 GList *h;
01432 for (h = devinf->ctcaps; h; h = h->next)
01433 {
01434 SmlDevInfCTCap *ctcap = h->data;
01435
01436 if (!strcmp(ct->cttype, ctcap->ct->cttype) &&
01437 !strcmp(ct->verct, ctcap->ct->verct))
01438 {
01439 smlTrace(TRACE_EXIT, "%s - succeeded", __func__);
01440 return ctcap;
01441 }
01442 }
01443 smlTrace(TRACE_EXIT, "%s - nothing found", __func__);
01444 return NULL;
01445 }
01446
01447 unsigned int smlDevInfNumCTCaps(const SmlDevInf *devinf)
01448 {
01449 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, devinf);
01450 smlAssert(devinf);
01451 unsigned int num = g_list_length(devinf->ctcaps);
01452 smlTrace(TRACE_EXIT, "%s - %d", __func__, num);
01453 return num;
01454 }
01455
01456 const SmlDevInfCTCap *smlDevInfGetNthCTCap(
01457 const SmlDevInf *devinf,
01458 unsigned int n)
01459 {
01460 smlTrace(TRACE_ENTRY, "%s(%p, %d)", __func__, devinf, n);
01461 smlAssert(devinf);
01462 SmlDevInfCTCap *ctcap = g_list_nth_data(devinf->ctcaps, n);
01463 smlTrace(TRACE_EXIT, "%s - %p", __func__, ctcap);
01464 return ctcap;
01465 }
01466
01467 unsigned int smlDevInfCTCapNumProperties(const SmlDevInfCTCap *ctcap)
01468 {
01469 smlTrace(TRACE_ENTRY, "%s(%p)", __func__, ctcap);
01470 smlAssert(ctcap);
01471 unsigned int num = g_list_length(ctcap->properties);
01472 smlTrace(TRACE_EXIT, "%s - %d", __func__, num);
01473 return num;
01474 }
01475
01476 const SmlDevInfProperty *smlDevInfCTCapGetNthProperty(
01477 const SmlDevInfCTCap *ctcap,
01478 unsigned int n)
01479 {
01480 smlTrace(TRACE_ENTRY, "%s(%p, %d)", __func__, ctcap, n);
01481 smlAssert(ctcap);
01482 SmlDevInfProperty *property = g_list_nth_data(ctcap->properties, n);
01483 smlTrace(TRACE_EXIT, "%s - %p", __func__, property);
01484 return property;
01485 }
01486
01487 SmlDevInfSyncCap smlDevInfSyncCapConvert(unsigned int id, SmlError **error)
01488 {
01489 smlTrace(TRACE_ENTRY, "%s(%u, %p)", __func__, id, error);
01490 CHECK_ERROR_REF
01491 SmlDevInfSyncCap result = SML_DEVINF_SYNCTYPE_UNKNOWN;
01492
01493 switch (id)
01494 {
01495 case SML_DEVINF_SYNCTYPE_TWO_WAY:
01496 result = SML_DEVINF_SYNCTYPE_TWO_WAY;
01497 break;
01498 case SML_DEVINF_SYNCTYPE_SLOW_SYNC:
01499 result = SML_DEVINF_SYNCTYPE_SLOW_SYNC;
01500 break;
01501 case SML_DEVINF_SYNCTYPE_ONE_WAY_FROM_CLIENT:
01502 result = SML_DEVINF_SYNCTYPE_ONE_WAY_FROM_CLIENT;
01503 break;
01504 case SML_DEVINF_SYNCTYPE_REFRESH_FROM_CLIENT:
01505 result = SML_DEVINF_SYNCTYPE_REFRESH_FROM_CLIENT;
01506 break;
01507 case SML_DEVINF_SYNCTYPE_ONE_WAY_FROM_SERVER:
01508 result = SML_DEVINF_SYNCTYPE_ONE_WAY_FROM_SERVER;
01509 break;
01510 case SML_DEVINF_SYNCTYPE_REFRESH_FROM_SERVER:
01511 result = SML_DEVINF_SYNCTYPE_REFRESH_FROM_SERVER;
01512 break;
01513 case SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC:
01514 result = SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC;
01515 break;
01516 default:
01517 smlErrorSet(error, SML_ERROR_GENERIC,
01518 "The synchronization type %u is unknwon.", id);
01519 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(error));
01520 return SML_DEVINF_SYNCTYPE_UNKNOWN;
01521 break;
01522 }
01523 smlTrace(TRACE_EXIT, "%s - %u", __func__, result);
01524 return result;
01525 }
01526