24 #include "syncml_internals.h"
25 #include "sml_devinf_internals.h"
26 #include "sml_command_internals.h"
27 #include "sml_elements_internals.h"
28 #include "sml_parse_internals.h"
29 #include "parser/sml_xml_assm.h"
30 #include "parser/sml_xml_parse.h"
31 #include "sml_error_internals.h"
33 SmlDevInfDevTyp smlDevInfDevTypeFromString(
const char *name,
SmlError **error)
37 if (!strcmp(name, SML_ELEMENT_DEVTYP_PAGER)) {
38 return SML_DEVINF_DEVTYPE_PAGER;
39 }
else if (!strcmp(name, SML_ELEMENT_DEVTYP_HANDHELD)) {
40 return SML_DEVINF_DEVTYPE_HANDHELD;
41 }
else if (!strcmp(name, SML_ELEMENT_DEVTYP_PDA)) {
42 return SML_DEVINF_DEVTYPE_PDA;
43 }
else if (!strcmp(name, SML_ELEMENT_DEVTYP_PHONE)) {
44 return SML_DEVINF_DEVTYPE_PHONE;
45 }
else if (!strcmp(name, SML_ELEMENT_DEVTYP_SMARTPHONE)) {
46 return SML_DEVINF_DEVTYPE_SMARTPHONE;
47 }
else if (!strcmp(name, SML_ELEMENT_DEVTYP_SERVER)) {
48 return SML_DEVINF_DEVTYPE_SERVER;
49 }
else if (!strcmp(name, SML_ELEMENT_DEVTYP_WORKSTATION)) {
50 return SML_DEVINF_DEVTYPE_WORKSTATION;
53 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown devinf type name \"%s\"", name);
54 return SML_DEVINF_DEVTYPE_UNKNOWN;
57 const char *smlDevInfDevTypeToString(SmlDevInfDevTyp type,
SmlError **error)
62 case SML_DEVINF_DEVTYPE_PAGER:
63 return SML_ELEMENT_DEVTYP_PAGER;
64 case SML_DEVINF_DEVTYPE_HANDHELD:
65 return SML_ELEMENT_DEVTYP_HANDHELD;
66 case SML_DEVINF_DEVTYPE_PDA:
67 return SML_ELEMENT_DEVTYP_PDA;
68 case SML_DEVINF_DEVTYPE_PHONE:
69 return SML_ELEMENT_DEVTYP_PHONE;
70 case SML_DEVINF_DEVTYPE_SMARTPHONE:
71 return SML_ELEMENT_DEVTYP_SMARTPHONE;
72 case SML_DEVINF_DEVTYPE_SERVER:
73 return SML_ELEMENT_DEVTYP_SERVER;
74 case SML_DEVINF_DEVTYPE_WORKSTATION:
75 return SML_ELEMENT_DEVTYP_WORKSTATION;
76 case SML_DEVINF_DEVTYPE_UNKNOWN:
77 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown devinf type \"%i\"", type);
84 SmlDevInf *smlDevInfNew(
const char *devid, SmlDevInfDevTyp devtyp,
SmlError **error)
86 smlTrace(TRACE_ENTRY,
"%s(%s, %i, %p)", __func__, VA_STRING(devid), devtyp, error);
94 devinf->devid = g_strdup(devid);
95 devinf->devtyp = devtyp;
98 smlTrace(TRACE_EXIT,
"%s: %p", __func__, devinf);
108 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, devinf);
111 g_atomic_int_inc(&(devinf->refCount));
113 smlTrace(TRACE_EXIT,
"%s: New refcount: %i", __func__, devinf->refCount);
119 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, devinf);
122 if (g_atomic_int_dec_and_test(&(devinf->refCount))) {
123 smlTrace(TRACE_INTERNAL,
"%s: Refcount == 0!", __func__);
125 if (devinf->manufacturer)
126 smlSafeCFree(&(devinf->manufacturer));
128 smlSafeCFree(&(devinf->model));
130 smlSafeCFree(&(devinf->oem));
131 if (devinf->softwareVersion)
132 smlSafeCFree(&(devinf->softwareVersion));
133 if (devinf->hardwareVersion)
134 smlSafeCFree(&(devinf->hardwareVersion));
135 if (devinf->firmwareVersion)
136 smlSafeCFree(&(devinf->firmwareVersion));
138 smlSafeCFree(&(devinf->devid));
140 while (devinf->datastores) {
142 devinf->datastores = g_list_remove(devinf->datastores, store);
143 smlDevInfDataStoreUnref(store);
146 while (devinf->ctcaps) {
148 devinf->ctcaps = g_list_remove(devinf->ctcaps, ctcap);
149 smlSafeCFree(&(ctcap->ct->cttype));
150 if (ctcap->ct->verct)
151 smlSafeCFree(&(ctcap->ct->verct));
152 smlSafeFree((gpointer *)&(ctcap->ct));
153 while (ctcap->properties) {
155 ctcap->properties = g_list_remove(ctcap->properties, prop);
156 smlSafeCFree(&(prop->propName));
158 smlSafeCFree(&(prop->dataType));
159 if (prop->displayName)
160 smlSafeCFree(&(prop->displayName));
164 while (prop->valEnums) {
165 char *valEnum = prop->valEnums->data;
166 prop->valEnums = g_list_remove(prop->valEnums, valEnum);
167 smlSafeCFree(&valEnum);
169 while (prop->propParams) {
171 prop->propParams = g_list_remove(prop->propParams, param);
172 smlSafeCFree(&(param->paramName));
174 smlSafeCFree(&(param->dataType));
175 if (param->displayName)
176 smlSafeCFree(&(param->displayName));
180 while (param->valEnums) {
181 char *valEnum = param->valEnums->data;
182 param->valEnums = g_list_remove(param->valEnums, valEnum);
183 smlSafeCFree(&valEnum);
186 smlSafeFree((gpointer *) ¶m);
189 smlSafeFree((gpointer *) &prop);
192 smlSafeFree((gpointer *)&ctcap);
195 smlSafeFree((gpointer *)&devinf);
198 smlTrace(TRACE_EXIT,
"%s", __func__);
201 const char *smlDevInfGetManufacturer(
SmlDevInf *devinf)
203 return devinf->manufacturer;
206 void smlDevInfSetManufacturer(
SmlDevInf *devinf,
const char *man)
208 if (devinf->manufacturer)
209 smlSafeCFree(&(devinf->manufacturer));
210 devinf->manufacturer = g_strdup(man);
213 const char *smlDevInfGetModel(
SmlDevInf *devinf)
215 return devinf->model;
218 void smlDevInfSetModel(
SmlDevInf *devinf,
const char *model)
221 smlSafeCFree(&(devinf->model));
222 devinf->model = g_strdup(model);
225 const char *smlDevInfGetOEM(
SmlDevInf *devinf)
230 void smlDevInfSetOEM(
SmlDevInf *devinf,
const char *oem)
233 smlSafeCFree(&(devinf->oem));
234 devinf->oem = g_strdup(oem);
237 const char *smlDevInfGetFirmwareVersion(
SmlDevInf *devinf)
239 return devinf->firmwareVersion;
242 void smlDevInfSetFirmwareVersion(
SmlDevInf *devinf,
const char *firmwareVersion)
244 if (devinf->firmwareVersion)
245 smlSafeCFree(&(devinf->firmwareVersion));
246 devinf->firmwareVersion = g_strdup(firmwareVersion);
249 const char *smlDevInfGetSoftwareVersion(
SmlDevInf *devinf)
251 return devinf->softwareVersion;
254 void smlDevInfSetSoftwareVersion(
SmlDevInf *devinf,
const char *softwareVersion)
256 if (devinf->softwareVersion)
257 smlSafeCFree(&(devinf->softwareVersion));
258 devinf->softwareVersion = g_strdup(softwareVersion);
261 const char *smlDevInfGetHardwareVersion(
SmlDevInf *devinf)
263 return devinf->hardwareVersion;
266 void smlDevInfSetHardwareVersion(
SmlDevInf *devinf,
const char *hardwareVersion)
268 if (devinf->hardwareVersion)
269 smlSafeCFree(&(devinf->hardwareVersion));
270 devinf->hardwareVersion = g_strdup(hardwareVersion);
273 const char *smlDevInfGetDeviceID(
SmlDevInf *devinf)
275 return devinf->devid;
278 void smlDevInfSetDeviceID(
SmlDevInf *devinf,
const char *devid)
281 smlSafeCFree(&(devinf->devid));
282 devinf->devid = g_strdup(devid);
285 SmlDevInfDevTyp smlDevInfGetDeviceType(
SmlDevInf *devinf)
287 return devinf->devtyp;
290 void smlDevInfSetDeviceType(
SmlDevInf *devinf, SmlDevInfDevTyp devtyp)
292 devinf->devtyp = devtyp;
295 SmlBool smlDevInfSupportsUTC(
SmlDevInf *devinf)
297 return devinf->supportsUTC;
300 void smlDevInfSetSupportsUTC(
SmlDevInf *devinf, SmlBool supports)
302 devinf->supportsUTC = supports;
305 SmlBool smlDevInfSupportsLargeObjs(
SmlDevInf *devinf)
307 return devinf->supportsLargeObjs;
310 void smlDevInfSetSupportsLargeObjs(
SmlDevInf *devinf, SmlBool supports)
312 devinf->supportsLargeObjs = supports;
315 SmlBool smlDevInfSupportsNumberOfChanges(
SmlDevInf *devinf)
317 return devinf->supportsNumberOfChanges;
320 void smlDevInfSetSupportsNumberOfChanges(
SmlDevInf *devinf, SmlBool supports)
322 devinf->supportsNumberOfChanges = supports;
327 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, devinf, datastore);
329 smlAssert(datastore);
331 devinf->datastores = g_list_append(devinf->datastores, datastore);
334 smlTrace(TRACE_EXIT,
"%s", __func__);
337 unsigned int smlDevInfNumDataStores(
SmlDevInf *devinf)
341 return g_list_length(devinf->datastores);
348 return g_list_nth_data(devinf->datastores, nth);
353 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, sourceRef, error);
360 datastore->sourceref = g_strdup(sourceRef);
361 datastore->refCount = 1;
363 smlTrace(TRACE_EXIT,
"%s: %p", __func__, datastore);
374 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, datastore);
375 smlAssert(datastore);
377 g_atomic_int_inc(&(datastore->refCount));
379 smlTrace(TRACE_EXIT,
"%s: New refcount: %i", __func__, datastore->refCount);
385 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, datastore);
386 smlAssert(datastore);
388 if (g_atomic_int_dec_and_test(&(datastore->refCount))) {
389 smlTrace(TRACE_INTERNAL,
"%s: Refcount == 0!", __func__);
391 smlSafeCFree(&(datastore->sourceref));
392 if (datastore->displayname)
393 smlSafeCFree(&(datastore->displayname));
395 smlSafeCFree(&(datastore->rxPrefContentType));
396 smlSafeCFree(&(datastore->rxPrefVersion));
398 for (d = datastore->rx; d; d = d->next) {
400 smlDevInfFreeContentType(ct);
402 g_list_free(datastore->rx);
404 smlSafeCFree(&(datastore->txPrefContentType));
405 smlSafeCFree(&(datastore->txPrefVersion));
406 for (d = datastore->tx; d; d = d->next) {
408 smlDevInfFreeContentType(ct);
410 g_list_free(datastore->tx);
412 smlSafeFree((gpointer *)&datastore);
415 smlTrace(TRACE_EXIT,
"%s", __func__);
420 return datastore->sourceref;
423 void smlDevInfDataStoreSetSourceRef(
SmlDevInfDataStore *datastore,
const char *sourceref)
425 if (datastore->sourceref)
426 smlSafeCFree(&(datastore->sourceref));
427 datastore->sourceref = g_strdup(sourceref);
432 return datastore->displayname;
435 void smlDevInfDataStoreSetDisplayName(
SmlDevInfDataStore *datastore,
const char *displayName)
437 if (datastore->displayname)
438 smlSafeCFree(&(datastore->displayname));
439 datastore->displayname = g_strdup(displayName);
444 return datastore->maxGUIDSize;
449 datastore->maxGUIDSize = max;
452 void smlDevInfDataStoreSetRxPref(
SmlDevInfDataStore *datastore,
const char *contenttype,
const char *version)
454 if (datastore->rxPrefContentType)
455 smlSafeCFree(&(datastore->rxPrefContentType));
456 datastore->rxPrefContentType = g_strdup(contenttype);
458 if (datastore->rxPrefVersion)
459 smlSafeCFree(&(datastore->rxPrefVersion));
460 datastore->rxPrefVersion = g_strdup(version);
463 SmlBool smlDevInfDataStoreGetRxPref(
const SmlDevInfDataStore *datastore,
char **contenttype,
char **version)
465 if (!datastore->rxPrefContentType)
468 *contenttype = datastore->rxPrefContentType;
469 *version = datastore->rxPrefVersion;
475 void smlDevInfDataStoreSetRx(
SmlDevInfDataStore *datastore,
const char *contenttype,
const char *version)
482 smlErrorDeref(&error);
485 smlDevInfDataStoreAddRx(datastore, ct);
489 SmlBool smlDevInfDataStoreGetRx(
const SmlDevInfDataStore *datastore,
char **contenttype,
char **version)
495 *contenttype = smlDevInfContentTypeGetCTType(ct);
496 *version = smlDevInfContentTypeGetVerCT(ct);
502 smlAssert(datastore);
503 datastore->rx = g_list_append(datastore->rx, ct);
508 return g_list_length(datastore->rx);
515 return g_list_nth_data(datastore->rx, n);
518 void smlDevInfDataStoreSetTxPref(
SmlDevInfDataStore *datastore,
const char *contenttype,
const char *version)
520 if (datastore->txPrefContentType)
521 smlSafeCFree(&(datastore->txPrefContentType));
522 datastore->txPrefContentType = g_strdup(contenttype);
524 if (datastore->txPrefVersion)
525 smlSafeCFree(&(datastore->txPrefVersion));
526 datastore->txPrefVersion = g_strdup(version);
529 SmlBool smlDevInfDataStoreGetTxPref(
const SmlDevInfDataStore *datastore,
char **contenttype,
char **version)
531 if (!datastore->txPrefContentType)
534 *contenttype = datastore->txPrefContentType;
535 *version = datastore->txPrefVersion;
541 void smlDevInfDataStoreSetTx(
SmlDevInfDataStore *datastore,
const char *contenttype,
const char *version)
548 smlErrorDeref(&error);
551 smlDevInfDataStoreAddTx(datastore, ct);
555 SmlBool smlDevInfDataStoreGetTx(
const SmlDevInfDataStore *datastore,
char **contenttype,
char **version)
561 *contenttype = smlDevInfContentTypeGetCTType(ct);
562 *version = smlDevInfContentTypeGetVerCT(ct);
568 smlAssert(datastore);
569 datastore->tx = g_list_append(datastore->tx, ct);
574 return g_list_length(datastore->tx);
581 return g_list_nth_data(datastore->tx, n);
584 void smlDevInfDataStoreSetMemory(
SmlDevInfDataStore *datastore, SmlBool shared,
unsigned int maxid,
unsigned int maxmem)
586 datastore->sharedMem = shared;
587 datastore->maxid = maxid;
588 datastore->maxmem = maxmem;
591 void smlDevInfDataStoreGetMemory(
const SmlDevInfDataStore *datastore, SmlBool *shared,
unsigned int *maxid,
unsigned int *maxmem)
594 *shared = datastore->sharedMem;
597 *maxid = datastore->maxid;
600 *maxmem = datastore->maxmem;
603 void smlDevInfDataStoreSetSyncCap(
SmlDevInfDataStore *datastore, SmlDevInfSyncCap cap, SmlBool supported)
606 datastore->synccap = datastore->synccap | cap;
608 datastore->synccap = datastore->synccap & ~cap;
611 SmlBool smlDevInfDataStoreGetSyncCap(
const SmlDevInfDataStore *datastore, SmlDevInfSyncCap cap)
613 return datastore->synccap & cap ? TRUE : FALSE;
618 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, devinf, session);
622 if (!devinf->supportsNumberOfChanges)
623 smlSessionUseNumberOfChanges(session, FALSE);
625 if (!devinf->supportsLargeObjs)
626 smlSessionUseLargeObjects(session, FALSE);
628 smlTrace(TRACE_EXIT,
"%s", __func__);
631 SmlBool smlDevInfAssemble(
SmlDevInf *devinf,
char **data,
unsigned int *size,
SmlError **error)
634 return smlXmlDevInfAssemble(devinf, devinf->version, data, size, error);
639 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %p, %p)", __func__, cmd, devinf, version, error);
645 unsigned int size = 0;
646 if (!smlXmlDevInfAssemble(devinf, version, &data, &size, error))
649 if (version == SML_DEVINF_VERSION_10)
650 source = smlLocationNew(
"./devinf10", NULL, error);
651 else if (version == SML_DEVINF_VERSION_12)
652 source = smlLocationNew(
"./devinf12", NULL, error);
654 source = smlLocationNew(
"./devinf11", NULL, error);
657 goto error_free_data;
659 SmlCommand *result = smlCommandNewResult(cmd, source, data, size, SML_ELEMENT_DEVINF_XML, error);
661 smlLocationUnref(source);
662 goto error_free_data;
665 result->private.results.status->item->
raw = TRUE;
667 smlLocationUnref(source);
669 smlTrace(TRACE_EXIT,
"%s: %p", __func__, result);
681 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %p)", __func__, devinf, version, error);
687 if (devinf->version == SML_DEVINF_VERSION_UNKNOWN)
688 devinf->version = version;
690 if (version == SML_DEVINF_VERSION_10)
691 source = smlLocationNew(
"./devinf10", NULL, error);
692 else if (version == SML_DEVINF_VERSION_12)
693 source = smlLocationNew(
"./devinf12", NULL, error);
695 source = smlLocationNew(
"./devinf11", NULL, error);
700 SmlCommand *cmd = smlCommandNewPut(NULL, source, NULL, 0, SML_ELEMENT_DEVINF_XML, error);
702 goto error_free_source;
704 smlLocationUnref(source);
707 unsigned int size = 0;
708 if (!smlXmlDevInfAssemble(devinf, version, &data, &size, error))
711 if (!smlItemAddData(cmd->private.access.item, data, size, error)) {
716 smlItemSetRaw(cmd->private.access.item, TRUE);
718 smlTrace(TRACE_EXIT,
"%s: %p", __func__, cmd);
722 smlCommandUnref(cmd);
724 smlLocationUnref(source);
732 smlTrace(TRACE_ENTRY,
"%s(%i, %p)", __func__, version, error);
736 if (version == SML_DEVINF_VERSION_10)
737 target = smlLocationNew(
"./devinf10", NULL, error);
738 else if (version == SML_DEVINF_VERSION_12)
739 target = smlLocationNew(
"./devinf12", NULL, error);
741 target = smlLocationNew(
"./devinf11", NULL, error);
746 SmlCommand *cmd = smlCommandNewGet(target, SML_ELEMENT_DEVINF_XML, error);
748 goto error_free_target;
750 smlLocationUnref(target);
752 smlTrace(TRACE_EXIT,
"%s: %p", __func__, cmd);
756 smlLocationUnref(target);
762 SmlDevInf *smlDevInfParse(
const char *data,
unsigned int length,
SmlError **error)
764 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %p)", __func__, data, length, error);
769 SmlDevInf *devinf = smlXmlDevInfParse(data, length, error);
773 smlTrace(TRACE_EXIT,
"%s", __func__);
783 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, result, error);
787 if (result->type != SML_COMMAND_TYPE_RESULTS) {
788 smlErrorSet(error, SML_ERROR_GENERIC,
"devinf command was not a result");
792 SmlItem *item = result->private.results.status->item;
794 smlErrorSet(error, SML_ERROR_GENERIC,
"devinf result did not have a item");
799 unsigned int size = 0;
803 SmlDevInf *devinf = smlDevInfParse(data, size, error);
807 smlTrace(TRACE_EXIT,
"%s", __func__);
815 SmlDevInfCTCapType smlDevInfCTCapTypeFromString(
const char *name,
SmlError **error)
819 if (!strcmp(name, SML_ELEMENT_CTTYPE)) {
820 return SML_DEVINF_CTCAP_CTTYPE;
821 }
else if (!strcmp(name, SML_ELEMENT_PROPNAME)) {
822 return SML_DEVINF_CTCAP_PROPNAME;
823 }
else if (!strcmp(name, SML_ELEMENT_VALENUM)) {
824 return SML_DEVINF_CTCAP_VALENUM;
825 }
else if (!strcmp(name, SML_ELEMENT_DATATYPE)) {
826 return SML_DEVINF_CTCAP_DATATYPE;
827 }
else if (!strcmp(name, SML_ELEMENT_SIZE)) {
828 return SML_DEVINF_CTCAP_SIZE;
829 }
else if (!strcmp(name, SML_ELEMENT_DISPLAYNAME)) {
830 return SML_DEVINF_CTCAP_DISPLAYNAME;
831 }
else if (!strcmp(name, SML_ELEMENT_PARAMNAME)) {
832 return SML_DEVINF_CTCAP_PARAMNAME;
833 }
else if (!strcmp(name, SML_ELEMENT_VERCT)) {
834 return SML_DEVINF_CTCAP_VERCT;
835 }
else if (!strcmp(name, SML_ELEMENT_PROPERTY)) {
836 return SML_DEVINF_CTCAP_PROPERTY;
837 }
else if (!strcmp(name, SML_ELEMENT_PROPPARAM)) {
838 return SML_DEVINF_CTCAP_PROPPARAM;
839 }
else if (!strcmp(name, SML_ELEMENT_NOTRUNCATE)) {
840 return SML_DEVINF_CTCAP_NOTRUNCATE;
841 }
else if (!strcmp(name, SML_ELEMENT_MAXOCCUR)) {
842 return SML_DEVINF_CTCAP_MAXOCCUR;
843 }
else if (!strcmp(name, SML_ELEMENT_MAXSIZE)) {
844 return SML_DEVINF_CTCAP_MAXSIZE;
847 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown ctcap type name \"%s\"", name);
849 return SML_DEVINF_CTCAP_UNKNOWN;
853 const char *smlDevInfCTCapTypeToString(SmlDevInfCTCapType type,
SmlError **error)
858 case SML_DEVINF_CTCAP_CTTYPE:
859 return SML_ELEMENT_CTTYPE;
860 case SML_DEVINF_CTCAP_PROPNAME:
861 return SML_ELEMENT_PROPNAME;
862 case SML_DEVINF_CTCAP_VALENUM:
863 return SML_ELEMENT_VALENUM;
864 case SML_DEVINF_CTCAP_DATATYPE:
865 return SML_ELEMENT_DATATYPE;
866 case SML_DEVINF_CTCAP_SIZE:
867 return SML_ELEMENT_SIZE;
868 case SML_DEVINF_CTCAP_DISPLAYNAME:
869 return SML_ELEMENT_DISPLAYNAME;
870 case SML_DEVINF_CTCAP_PARAMNAME:
871 return SML_ELEMENT_PARAMNAME;
872 case SML_DEVINF_CTCAP_NOTRUNCATE:
873 return SML_ELEMENT_NOTRUNCATE;
874 case SML_DEVINF_CTCAP_MAXOCCUR:
875 return SML_ELEMENT_MAXOCCUR;
876 case SML_DEVINF_CTCAP_VERCT:
877 return SML_ELEMENT_VERCT;
878 case SML_DEVINF_CTCAP_PROPERTY:
879 return SML_ELEMENT_PROPERTY;
880 case SML_DEVINF_CTCAP_PROPPARAM:
881 return SML_ELEMENT_PROPPARAM;
882 case SML_DEVINF_CTCAP_MAXSIZE:
883 return SML_ELEMENT_MAXSIZE;
884 case SML_DEVINF_CTCAP_UNKNOWN:
885 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown ctcap type \"%i\"", type);
896 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, error);
905 param->paramName = NULL;
906 param->dataType = NULL;
907 param->displayName = NULL;
908 param->valEnums = NULL;
910 smlTrace(TRACE_EXIT,
"%s", __func__);
914 void smlDevInfPropParamSetParamName(
916 const char *paramName)
918 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, propParam, VA_STRING(paramName));
919 smlAssert(propParam);
920 smlAssert(paramName);
922 if (propParam->paramName != NULL)
923 smlSafeCFree(&(propParam->paramName));
924 propParam->paramName = g_strdup(paramName);
926 smlTrace(TRACE_EXIT,
"%s", __func__);
929 void smlDevInfPropParamSetDataType(
931 const char *dataType)
933 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, propParam, VA_STRING(dataType));
934 smlAssert(propParam);
937 if (propParam->dataType != NULL)
938 smlSafeCFree(&(propParam->dataType));
939 propParam->dataType = g_strdup(dataType);
941 smlTrace(TRACE_EXIT,
"%s", __func__);
944 void smlDevInfPropParamSetDisplayName(
946 const char *displayName)
948 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, propParam, VA_STRING(displayName));
949 smlAssert(propParam);
950 smlAssert(displayName);
952 if (propParam->displayName != NULL)
953 smlSafeCFree(&(propParam->displayName));
954 propParam->displayName = g_strdup(displayName);
956 smlTrace(TRACE_EXIT,
"%s", __func__);
959 void smlDevInfPropParamAddValEnum(
963 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, propParam, VA_STRING(valEnum));
964 smlAssert(propParam);
966 propParam->valEnums = g_list_append(propParam->valEnums, g_strdup(valEnum));
967 smlTrace(TRACE_EXIT,
"%s", __func__);
972 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, propParam);
973 smlAssert(propParam);
974 char *result = g_strdup(propParam->paramName);
975 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(result));
981 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, propParam);
982 smlAssert(propParam);
983 char *result = g_strdup(propParam->dataType);
984 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(result));
990 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, propParam);
991 smlAssert(propParam);
992 char *result = g_strdup(propParam->displayName);
993 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(result));
999 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, propParam);
1000 smlAssert(propParam);
1001 unsigned int num = g_list_length(propParam->valEnums);
1002 smlTrace(TRACE_EXIT,
"%s - %d", __func__, num);
1006 char *smlDevInfPropParamGetNthValEnum(
1010 smlTrace(TRACE_ENTRY,
"%s(%p, %d)", __func__, propParam, n);
1011 smlAssert(propParam);
1012 char *result = g_strdup(g_list_nth_data(propParam->valEnums, n));
1013 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(result));
1021 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, error);
1030 property->propName = NULL;
1031 property->dataType = NULL;
1032 property->maxOccur = 0;
1033 property->maxSize = 0;
1034 property->noTruncate = FALSE;
1035 property->displayName = NULL;
1036 property->valEnums = NULL;
1037 property->propParams = NULL;
1039 smlTrace(TRACE_EXIT,
"%s", __func__);
1043 void smlDevInfPropertySetPropName(
1044 SmlDevInfProperty *property,
1045 const char *propName)
1047 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, property, VA_STRING(propName));
1048 smlAssert(property);
1049 smlAssert(propName);
1051 if (property->propName != NULL)
1052 smlSafeCFree(&(property->propName));
1053 property->propName = g_strdup(propName);
1055 smlTrace(TRACE_EXIT,
"%s", __func__);
1058 void smlDevInfPropertySetDataType(
1059 SmlDevInfProperty *property,
1060 const char *dataType)
1062 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, property, VA_STRING(dataType));
1063 smlAssert(property);
1064 smlAssert(dataType);
1066 if (property->dataType != NULL)
1067 smlSafeCFree(&(property->dataType));
1068 property->dataType = g_strdup(dataType);
1070 smlTrace(TRACE_EXIT,
"%s", __func__);
1073 void smlDevInfPropertySetMaxOccur(
1074 SmlDevInfProperty *property,
1075 unsigned int maxOccur)
1077 smlTrace(TRACE_ENTRY,
"%s(%p, %d)", __func__, property, maxOccur);
1078 smlAssert(property);
1080 property->maxOccur = maxOccur;
1082 smlTrace(TRACE_EXIT,
"%s", __func__);
1085 void smlDevInfPropertySetMaxSize(
1086 SmlDevInfProperty *property,
1087 unsigned int maxSize)
1089 smlTrace(TRACE_ENTRY,
"%s(%p, %d)", __func__, property, maxSize);
1090 smlAssert(property);
1092 property->maxSize = maxSize;
1094 smlTrace(TRACE_EXIT,
"%s", __func__);
1097 void smlDevInfPropertySetPropSize(
1098 SmlDevInfProperty *property,
1099 unsigned int propSize)
1101 smlTrace(TRACE_ENTRY,
"%s(%p, %d)", __func__, property, propSize);
1102 smlAssert(property);
1104 property->propSize = propSize;
1106 smlTrace(TRACE_EXIT,
"%s", __func__);
1109 void smlDevInfPropertySetNoTruncate(
1110 SmlDevInfProperty *property)
1112 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1113 smlAssert(property);
1115 property->noTruncate = TRUE;
1117 smlTrace(TRACE_EXIT,
"%s", __func__);
1120 void smlDevInfPropertySetDisplayName(
1121 SmlDevInfProperty *property,
1122 const char *displayName)
1124 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, property, VA_STRING(displayName));
1125 smlAssert(property);
1126 smlAssert(displayName);
1128 if (property->displayName != NULL)
1129 smlSafeCFree(&(property->displayName));
1130 property->displayName = g_strdup(displayName);
1132 smlTrace(TRACE_EXIT,
"%s", __func__);
1135 void smlDevInfPropertyAddValEnum(
1136 SmlDevInfProperty *property,
1137 const char *valEnum)
1139 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, property, VA_STRING(valEnum));
1140 smlAssert(property);
1142 property->valEnums = g_list_append(property->valEnums, g_strdup(valEnum));
1143 smlTrace(TRACE_EXIT,
"%s", __func__);
1146 void smlDevInfPropertyAddPropParam(
1147 SmlDevInfProperty *property,
1150 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, property, propParam);
1151 smlAssert(property);
1152 smlAssert(propParam);
1153 property->propParams = g_list_append(property->propParams, propParam);
1154 smlTrace(TRACE_EXIT,
"%s", __func__);
1157 char *smlDevInfPropertyGetPropName(
const SmlDevInfProperty *property)
1159 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1160 smlAssert(property);
1161 char *result = g_strdup(property->propName);
1162 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(result));
1166 char *smlDevInfPropertyGetDataType(
const SmlDevInfProperty *property)
1168 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1169 smlAssert(property);
1170 char *result = g_strdup(property->dataType);
1171 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(result));
1175 unsigned int smlDevInfPropertyGetMaxOccur(
const SmlDevInfProperty *property)
1177 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1178 smlAssert(property);
1179 smlTrace(TRACE_EXIT,
"%s - %d", __func__, property->maxOccur);
1180 return property->maxOccur;
1183 unsigned int smlDevInfPropertyGetMaxSize(
const SmlDevInfProperty *property)
1185 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1186 smlAssert(property);
1187 smlTrace(TRACE_EXIT,
"%s - %d", __func__, property->maxSize);
1188 return property->maxSize;
1191 SmlBool smlDevInfPropertyGetNoTruncate(
const SmlDevInfProperty *property)
1193 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1194 smlAssert(property);
1195 smlTrace(TRACE_EXIT,
"%s - %d", __func__, property->noTruncate);
1196 return property->noTruncate;
1199 char *smlDevInfPropertyGetDisplayName(
const SmlDevInfProperty *property)
1201 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1202 smlAssert(property);
1203 char *result = g_strdup(property->displayName);
1204 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(result));
1208 unsigned int smlDevInfPropertyNumValEnums(
const SmlDevInfProperty *property)
1210 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1211 smlAssert(property);
1212 unsigned int num = g_list_length(property->valEnums);
1213 smlTrace(TRACE_EXIT,
"%s - %d", __func__, num);
1217 char *smlDevInfPropertyGetNthValEnum(
1218 const SmlDevInfProperty *property,
1221 smlTrace(TRACE_ENTRY,
"%s(%p, %d)", __func__, property, n);
1222 smlAssert(property);
1223 char *result = g_strdup(g_list_nth_data(property->valEnums, n));
1224 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(result));
1228 unsigned int smlDevInfPropertyNumPropParams(
const SmlDevInfProperty *property)
1230 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, property);
1231 smlAssert(property);
1232 unsigned int num = g_list_length(property->propParams);
1233 smlTrace(TRACE_EXIT,
"%s - %d", __func__, num);
1238 const SmlDevInfProperty *property,
1241 smlTrace(TRACE_ENTRY,
"%s(%p, %d)", __func__, property, n);
1242 smlAssert(property);
1244 smlTrace(TRACE_EXIT,
"%s - %p", __func__, param);
1255 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, error);
1265 ct->cttype = g_strdup(cttype);
1269 ct->verct = g_strdup(verct);
1273 smlTrace(TRACE_EXIT,
"%s", __func__);
1279 return g_strdup(ct->cttype);
1284 return g_strdup(ct->verct);
1289 smlTrace(TRACE_ENTRY,
"%s", __func__);
1292 if (ct->cttype != NULL)
1293 smlSafeCFree(&(ct->cttype));
1294 if (ct->verct != NULL)
1295 smlSafeCFree(&(ct->verct));
1296 smlSafeFree((gpointer *)&ct);
1298 smlTrace(TRACE_EXIT,
"%s", __func__);
1303 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, error);
1312 ctcap->ct = smlDevInfNewContentType(NULL, NULL, error);
1315 smlSafeFree((gpointer *)&ctcap);
1318 ctcap->properties = NULL;
1320 smlTrace(TRACE_EXIT,
"%s", __func__);
1324 void smlDevInfCTCapSetCTType(
1328 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, ctcap, VA_STRING(cttype));
1332 ctcap->ct->cttype = g_strdup(cttype);
1334 smlTrace(TRACE_EXIT,
"%s", __func__);
1337 void smlDevInfCTCapSetVerCT(
1341 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, ctcap, VA_STRING(verct));
1345 ctcap->ct->verct = g_strdup(verct);
1347 smlTrace(TRACE_EXIT,
"%s", __func__);
1352 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, ctcap);
1356 cttype = g_strdup(ctcap->ct->cttype);
1358 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(cttype));
1364 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, ctcap);
1368 verct = g_strdup(ctcap->ct->verct);
1370 smlTrace(TRACE_EXIT,
"%s - %s", __func__, VA_STRING(verct));
1374 void smlDevInfCTCapAddProperty(
1376 SmlDevInfProperty *property)
1378 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, ctcap, property);
1380 smlAssert(property);
1381 ctcap->properties = g_list_append(ctcap->properties, property);
1382 smlTrace(TRACE_EXIT,
"%s", __func__);
1387 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, devinf, ctcap);
1390 devinf->ctcaps = g_list_append(devinf->ctcaps, ctcap);
1391 smlTrace(TRACE_EXIT,
"%s", __func__);
1395 void smlDevInfAddCTCap(
SmlDevInf *devinf, SmlDevInfCTCapType type,
const char *value)
1398 smlDevInfCTCapSetCTType(ctcap, smlDevInfCTCapTypeToString(type, NULL));
1399 smlDevInfCTCapSetVerCT(ctcap, value);
1400 smlDevInfAppendCTCap(devinf, ctcap);
1404 SmlDevInfCTCapType smlDevInfGetNthCTCapType(
SmlDevInf *devinf,
unsigned int nth)
1407 char *type = smlDevInfCTCapGetCTType(ctcap);
1409 SmlDevInfCTCapType cttype = smlDevInfCTCapTypeFromString(type, &error);
1410 smlSafeCFree(&type);
1415 const char *smlDevInfGetNthCTCapValue(
SmlDevInf *devinf,
unsigned int nth)
1418 return smlDevInfCTCapGetVerCT(ctcap);
1425 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, devinf, ct);
1428 smlAssert(ct->cttype);
1429 smlAssert(ct->verct);
1432 for (h = devinf->ctcaps; h; h = h->next)
1436 if (!strcmp(ct->cttype, ctcap->ct->cttype) &&
1437 !strcmp(ct->verct, ctcap->ct->verct))
1439 smlTrace(TRACE_EXIT,
"%s - succeeded", __func__);
1443 smlTrace(TRACE_EXIT,
"%s - nothing found", __func__);
1447 unsigned int smlDevInfNumCTCaps(
const SmlDevInf *devinf)
1449 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, devinf);
1451 unsigned int num = g_list_length(devinf->ctcaps);
1452 smlTrace(TRACE_EXIT,
"%s - %d", __func__, num);
1460 smlTrace(TRACE_ENTRY,
"%s(%p, %d)", __func__, devinf, n);
1463 smlTrace(TRACE_EXIT,
"%s - %p", __func__, ctcap);
1467 unsigned int smlDevInfCTCapNumProperties(
const SmlDevInfCTCap *ctcap)
1469 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, ctcap);
1471 unsigned int num = g_list_length(ctcap->properties);
1472 smlTrace(TRACE_EXIT,
"%s - %d", __func__, num);
1476 const SmlDevInfProperty *smlDevInfCTCapGetNthProperty(
1480 smlTrace(TRACE_ENTRY,
"%s(%p, %d)", __func__, ctcap, n);
1482 SmlDevInfProperty *
property = g_list_nth_data(ctcap->properties, n);
1483 smlTrace(TRACE_EXIT,
"%s - %p", __func__, property);
1487 SmlDevInfSyncCap smlDevInfSyncCapConvert(
unsigned int id,
SmlError **error)
1489 smlTrace(TRACE_ENTRY,
"%s(%u, %p)", __func__,
id, error);
1491 SmlDevInfSyncCap result = SML_DEVINF_SYNCTYPE_UNKNOWN;
1495 case SML_DEVINF_SYNCTYPE_TWO_WAY:
1496 result = SML_DEVINF_SYNCTYPE_TWO_WAY;
1498 case SML_DEVINF_SYNCTYPE_SLOW_SYNC:
1499 result = SML_DEVINF_SYNCTYPE_SLOW_SYNC;
1501 case SML_DEVINF_SYNCTYPE_ONE_WAY_FROM_CLIENT:
1502 result = SML_DEVINF_SYNCTYPE_ONE_WAY_FROM_CLIENT;
1504 case SML_DEVINF_SYNCTYPE_REFRESH_FROM_CLIENT:
1505 result = SML_DEVINF_SYNCTYPE_REFRESH_FROM_CLIENT;
1507 case SML_DEVINF_SYNCTYPE_ONE_WAY_FROM_SERVER:
1508 result = SML_DEVINF_SYNCTYPE_ONE_WAY_FROM_SERVER;
1510 case SML_DEVINF_SYNCTYPE_REFRESH_FROM_SERVER:
1511 result = SML_DEVINF_SYNCTYPE_REFRESH_FROM_SERVER;
1513 case SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC:
1514 result = SML_DEVINF_SYNCTYPE_SERVER_ALERTED_SYNC;
1518 "The synchronization type %u is unknwon.",
id);
1520 return SML_DEVINF_SYNCTYPE_UNKNOWN;
1523 smlTrace(TRACE_EXIT,
"%s - %u", __func__, result);