24 #include "syncml_internals.h" 25 #include "sml_error_internals.h" 26 #include "sml_parse_internals.h" 27 #include "sml_command_internals.h" 28 #include "sml_elements_internals.h" 29 #include "sml_notification_internals.h" 31 #include "parser/sml_xml_assm.h" 32 #include "parser/sml_xml_parse.h" 33 #include "parser/sml_wbxml.h" 52 smlTrace(TRACE_ENTRY,
"%s(%i, %i, %p)", __func__, type, limit, error);
60 parser->limit = limit;
63 case SML_MIMETYPE_XML:
64 if (!(parser->parser_userdata = smlXmlParserNew(&(parser->functions), error)))
65 goto error_free_parser;
67 case SML_MIMETYPE_SAN:
69 if (!(parser->parser_userdata = smlXmlParserNew(&(parser->functions), error)))
70 goto error_free_parser;
72 case SML_MIMETYPE_WBXML:
74 if (!(parser->parser_userdata = smlWbxmlParserNew(&(parser->functions), error)))
75 goto error_free_parser;
78 smlErrorSet(error, SML_ERROR_GENERIC,
"Wbxml not enabled in this build");
79 goto error_free_parser;
82 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown parser type");
83 goto error_free_parser;
86 smlTrace(TRACE_EXIT,
"%s: %p", __func__, parser);
90 smlSafeFree((gpointer *)&parser);
100 parser->manager = manager;
110 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, parser);
113 if (parser->functions.free)
114 parser->functions.free(parser->parser_userdata);
116 smlSafeFree((gpointer *)&parser);
118 smlTrace(TRACE_EXIT,
"%s", __func__);
134 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %i, %p)", __func__, parser, data, size, error);
139 smlAssert(parser->functions.start);
140 smlAssertMsg(parser->type != SML_MIMETYPE_SAN || parser->manager,
141 SML_ASSERT_MSG_SAN_PARSE_REQUIRES_MANAGER);
143 if (parser->limit && size > parser->limit) {
144 smlErrorSet(error, SML_ERROR_GENERIC,
"Input data too large");
148 if (parser->type == SML_MIMETYPE_SAN) {
150 smlTrace(TRACE_INTERNAL,
"%s - detected an OMA DS 1.2 SAN", __func__);
158 smlNotificationSetManager(san, parser->manager);
159 san->type = SML_MIMETYPE_XML;
160 san->sessionType = SML_SESSION_TYPE_CLIENT;
161 san->target = smlLocationNew(
"/", NULL, error);
166 char *xmlData = NULL;
167 unsigned int xmlSize = 0;
168 if (!smlNotificationAssemble11(san, &xmlData, &xmlSize, SML_VERSION_12, error))
170 smlNotificationFree(san);
174 "%s - converted OMA DS 1.2 SAN to SyncML 1.1 server alerted sync - %s",
175 __func__, VA_STRING(xmlData));
178 smlNotificationFree(san);
182 if (!parser->functions.start(parser->parser_userdata, xmlData, xmlSize, error)) {
183 smlSafeCFree(&xmlData);
186 smlSafeCFree(&xmlData);
189 if (!parser->functions.start(parser->parser_userdata, data, size, error))
193 smlTrace(TRACE_EXIT,
"%s", __func__);
218 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, header, cred, error);
223 smlAssert(parser->functions.get_header);
225 if (!parser->functions.get_header(parser->parser_userdata, header, cred, error))
228 smlTrace(TRACE_EXIT,
"%s", __func__);
252 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, cmd, error);
256 smlAssert(parser->functions.get_cmd);
257 SmlParserResult result = SML_PARSER_RESULT_ERROR;
259 if (!(result = parser->functions.get_cmd(parser->parser_userdata, cmd, error)))
262 smlTrace(TRACE_EXIT,
"%s: %i", __func__, result);
267 return SML_PARSER_RESULT_ERROR;
286 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, parser, status, error);
290 smlAssert(parser->functions.get_status);
292 if (!parser->functions.get_status(parser->parser_userdata, status, error))
295 smlTrace(TRACE_EXIT,
"%s", __func__);
316 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p)", __func__, parser,
final, end, error);
319 smlAssert(parser->functions.end);
321 if (!parser->functions.end(parser->parser_userdata,
final, end, error))
324 smlTrace(TRACE_INTERNAL,
"%s: Final %i, End %i", __func__,
final ? *
final : -1, end ? *end : -1);
326 smlTrace(TRACE_EXIT,
"%s", __func__);
354 smlTrace(TRACE_ENTRY,
"%s(%i, %i, %p)", __func__, type, limit, error);
362 assm->remoteMaxMsgSize = limit;
364 assm->remoteMaxObjSize = 0;
367 case SML_MIMETYPE_XML:
369 goto error_free_assm;
371 case SML_MIMETYPE_WBXML:
373 if (!(assm->assm_userdata = smlWbxmlAssemblerNew(assm, &(assm->functions), error)))
374 goto error_free_assm;
377 smlErrorSet(error, SML_ERROR_GENERIC,
"Wbxml not enabled in this build");
378 goto error_free_assm;
381 smlErrorSet(error, SML_ERROR_GENERIC,
"Unknown assembler type");
382 goto error_free_assm;
385 assm->options = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
387 smlTrace(TRACE_EXIT,
"%s: %p", __func__, assm);
391 smlSafeFree((gpointer *)&assm);
404 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, assm);
407 if (assm->functions.free)
408 assm->functions.free(assm->assm_userdata);
410 g_hash_table_destroy(assm->options);
412 smlSafeFree((gpointer *)&assm);
414 smlTrace(TRACE_EXIT,
"%s", __func__);
430 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, assm, session, error);
434 smlAssert(assm->functions.start);
436 if (!assm->functions.start(assm->assm_userdata, session, error))
439 smlTrace(TRACE_EXIT,
"%s", __func__);
458 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p, %i, %p)", __func__, assm, data, size, end,
final, error);
463 smlAssert(assm->functions.run);
465 if (!assm->functions.run(assm->assm_userdata, data, size, end,
final, smlAssemblerGetRemoteMaxMsgSize(assm), error))
468 smlTrace(TRACE_EXIT,
"%s", __func__);
487 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %p)", __func__, assm, headeronly, error);
490 smlAssert(assm->functions.check_size);
492 unsigned int size = 0;
493 if (!(size = assm->functions.check_size(assm->assm_userdata, headeronly, error)))
496 smlTrace(TRACE_EXIT,
"%s: %i", __func__, size);
516 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, assm);
518 smlAssert(assm->functions.flush);
520 unsigned int ret = assm->functions.flush(assm->assm_userdata);
523 smlTrace(TRACE_EXIT,
"%s: %i", __func__, ret);
529 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, assm);
531 smlAssert(assm->functions.restore_cmds);
533 assm->functions.restore_cmds(assm->assm_userdata);
536 smlTrace(TRACE_EXIT,
"%s", __func__);
547 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p, %p)", __func__, assm, space, parent, cmd, error);
552 smlAssert(assm->functions.start_cmd);
553 smlAssert(assm->functions.rem_cmd);
554 smlAssert(cmd->type == SML_COMMAND_TYPE_ADD || cmd->type == SML_COMMAND_TYPE_REPLACE);
555 unsigned int parentID = 0;
557 int limit = smlAssemblerGetRemoteMaxMsgSize(assm);
560 smlTrace(TRACE_EXIT,
"%s: No limit", __func__);
566 if (!parent->cmdID) {
567 smlErrorSet(error, SML_ERROR_GENERIC,
"Parent has to be added before");
570 parentID = parent->cmdID;
574 if (cmd->private.change.items)
577 for (i=0; i < g_list_length(cmd->private.change.items); i++)
579 SmlItem *item = g_list_nth_data(cmd->private.change.items, i);
580 item->disabled = TRUE;
584 SmlBool noCmdID = FALSE;
592 if (!assm->functions.start_cmd(assm->assm_userdata, parentID, cmd, error))
593 goto error_enable_item;
603 *space = limit - size - 10;
606 if (!assm->functions.rem_cmd(assm->assm_userdata, parentID, error))
610 if (cmd->private.change.items)
613 for (i=0; i < g_list_length(cmd->private.change.items); i++)
615 SmlItem *item = g_list_nth_data(cmd->private.change.items, i);
616 item->disabled = FALSE;
623 smlTrace(TRACE_EXIT,
"%s: %i", __func__, *space);
627 assm->functions.rem_cmd(assm->assm_userdata, parentID, NULL);
629 if (cmd->private.change.items)
632 for (i=0; i < g_list_length(cmd->private.change.items); i++)
634 SmlItem *item = g_list_nth_data(cmd->private.change.items, i);
635 item->disabled = FALSE;
661 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p)", __func__, assm, parent, cmd, error);
665 smlAssert(assm->functions.start_cmd);
666 smlAssert(assm->functions.rem_cmd);
667 unsigned int parentID = 0;
671 if (!parent->cmdID) {
672 smlErrorSet(error, SML_ERROR_GENERIC,
"Parent has to be added before");
675 parentID = parent->cmdID;
678 if (!assm->functions.start_cmd(assm->assm_userdata, parentID, cmd, error))
682 int limit = smlAssemblerGetRemoteMaxMsgSize(assm);
691 if (!assm->functions.rem_cmd(assm->assm_userdata, parentID, error))
694 smlTrace(TRACE_EXIT,
"%s: Mismatch", __func__);
695 return SML_ASSEMBLER_RESULT_MISMATCH;
697 smlTrace(TRACE_INTERNAL,
"%s: size %i, limit %i", __func__, size, limit);
703 smlTrace(TRACE_EXIT,
"%s", __func__);
704 return SML_ASSEMBLER_RESULT_OK;
708 return SML_ASSEMBLER_RESULT_ERROR;
724 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, assm, parent, error);
727 smlAssert(assm->functions.end_cmd);
729 unsigned int parentID = 0;
733 if (!parent->cmdID) {
734 smlErrorSet(error, SML_ERROR_GENERIC,
"Parent has to be added before");
737 parentID = parent->cmdID;
741 if (!assm->functions.end_cmd(assm->assm_userdata, parentID, error))
744 smlTrace(TRACE_EXIT,
"%s", __func__);
764 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, assm, session, error);
768 smlAssert(assm->functions.add_header);
771 if (!assm->functions.add_header(assm->assm_userdata, session, error))
775 unsigned int size = 0;
780 if (smlAssemblerGetRemoteMaxMsgSize(assm) && size > smlAssemblerGetRemoteMaxMsgSize(assm)) {
781 smlErrorSet(error, SML_ERROR_GENERIC,
"Limit to small. Unable to fit a the header");
785 smlTrace(TRACE_EXIT,
"%s", __func__);
808 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %i, %i, %p)", __func__, assm, cmdRef, msgRef, cmdID, error);
811 smlAssert(assm->functions.reserve_status);
814 if (!assm->functions.reserve_status(assm->assm_userdata, cmdRef, msgRef, cmdID, error))
817 smlTrace(TRACE_EXIT,
"%s", __func__);
841 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %i, %p)", __func__, assm, status, force, error);
845 smlAssert(assm->functions.add_status);
846 smlAssert(assm->functions.rem_status);
849 if (!assm->functions.add_status(assm->assm_userdata, status, error))
854 int limit = smlAssemblerGetRemoteMaxMsgSize(assm);
863 if (!assm->functions.rem_status(assm->assm_userdata, error))
866 smlTrace(TRACE_EXIT,
"%s: Mismatch", __func__);
867 return SML_ASSEMBLER_RESULT_MISMATCH;
875 smlTrace(TRACE_EXIT,
"%s", __func__);
876 return SML_ASSEMBLER_RESULT_OK;
880 return SML_ASSEMBLER_RESULT_ERROR;
898 smlTrace(TRACE_ENTRY,
"%s(%p, %s, %s)", __func__, assm, VA_STRING(optionname), VA_STRING(value));
900 smlAssert(optionname);
902 g_hash_table_replace(assm->options, g_strdup(optionname), g_strdup(value));
904 smlTrace(TRACE_EXIT,
"%s", __func__);
916 smlTrace(TRACE_ENTRY,
"%s(%p, %s)", __func__, assm, VA_STRING(optionname));
918 smlAssert(optionname);
920 const char *ret = g_hash_table_lookup(assm->options, optionname);
922 smlTrace(TRACE_EXIT,
"%s: %s", __func__, VA_STRING(ret));
929 return smlAssemblerGetRemoteMaxMsgSize(assm);
932 unsigned int smlAssemblerGetRemoteMaxMsgSize(
SmlAssembler *assm)
934 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, assm);
937 smlTrace(TRACE_EXIT,
"%s: %i", __func__, assm->remoteMaxMsgSize);
938 return assm->remoteMaxMsgSize;
942 void smlAssemblerSetRequestedLimit(
SmlAssembler *assm,
unsigned int limit)
944 smlAssemblerSetRemoteMaxMsgSize(assm, limit);
948 void smlAssemblerSetLimit(
SmlAssembler *assm,
unsigned int limit)
950 smlAssemblerSetRemoteMaxMsgSize(assm, limit);
953 unsigned int smlAssemblerSetRemoteMaxMsgSize(
SmlAssembler *assm,
unsigned int limit)
955 smlTrace(TRACE_ENTRY,
"%s(%p, %i)", __func__, assm, limit);
961 assm->remoteMaxMsgSize = limit;
963 if (limit < assm->remoteMaxMsgSize || assm->remoteMaxMsgSize == 0)
966 assm->remoteMaxMsgSize = limit;
969 "%s: using old limit (%d) because of large new limit (%d).",
970 __func__, assm->remoteMaxMsgSize, limit);
974 smlTrace(TRACE_EXIT,
"%s - %d", __func__, assm->remoteMaxMsgSize);
975 return assm->remoteMaxMsgSize;
979 int smlAssemblerGetSendingMaxObjSize(
SmlAssembler *assm)
981 return smlAssemblerGetRemoteMaxObjSize(assm);
985 int smlAssemblerGetRequestedMaxObjSize(
SmlAssembler *assm)
987 return smlAssemblerGetRemoteMaxObjSize(assm);
991 unsigned int smlAssemblerGetRemoteMaxObjSize(
SmlAssembler *assm)
993 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, assm);
996 smlTrace(TRACE_EXIT,
"%s: %i", __func__, assm->remoteMaxObjSize);
997 return assm->remoteMaxObjSize;
1001 void smlAssemblerSetRequestedMaxObjSize(
SmlAssembler *assm,
int limit)
1003 smlAssemblerSetRemoteMaxObjSize(assm, limit);
1007 void smlAssemblerSetSendingMaxObjSize(
SmlAssembler *assm,
int limit)
1009 smlAssemblerSetRemoteMaxObjSize(assm, limit);
1012 unsigned int smlAssemblerSetRemoteMaxObjSize(
SmlAssembler *assm,
unsigned int limit)
1014 smlTrace(TRACE_ENTRY,
"%s(%p, %i)", __func__, assm, limit);
1020 assm->remoteMaxObjSize = limit;
1022 if (limit < assm->remoteMaxObjSize || assm->remoteMaxObjSize == 0)
1025 assm->remoteMaxObjSize = limit;
1028 "%s: using old limit (%d) because of large new limit (%d).",
1029 __func__, assm->remoteMaxObjSize, limit);
1033 smlTrace(TRACE_EXIT,
"%s - %d", __func__, assm->remoteMaxObjSize);
1034 return assm->remoteMaxObjSize;
1039 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, assm);
1042 SmlBool ret = assm->empty;
1044 smlTrace(TRACE_EXIT,
"%s: %i", __func__, ret);
1056 smlAssert(assm->functions.missing_status);
1058 SmlBool ret = assm->functions.missing_status(assm->assm_userdata);
1063 SmlBool smlAssemblerGetNextCmdRef(
SmlAssembler *assm,
unsigned int *cmdRef,
unsigned int *msgRef)
1068 smlAssert(assm->functions.next_cmdref);
1070 return assm->functions.next_cmdref(assm->assm_userdata, cmdRef, msgRef);
void smlAssemblerSetOption(SmlAssembler *assm, const char *optionname, const char *value)
Sets a option on the assembler.
SmlBool smlAssemblerAddHeader(SmlAssembler *assm, SmlSession *session, SmlError **error)
Assembles the header.
const char * smlErrorPrint(SmlError **error)
Returns the message of the error.
const char * smlAssemblerGetOption(SmlAssembler *assm, const char *optionname)
Gets a option from the assembler.
SmlBool smlParserGetHeader(SmlParser *parser, SmlHeader **header, SmlCred **cred, SmlError **error)
Parses the SyncHdr.
void smlParserFree(SmlParser *parser)
Frees a parser.
SmlAssemblerResult smlAssemblerStartCommand(SmlAssembler *assm, SmlCommand *parent, SmlCommand *cmd, SmlError **error)
Starts a parent command.
SmlAssemblerResult smlAssemblerAddStatusFull(SmlAssembler *assm, SmlStatus *status, SmlBool force, SmlError **error)
Assembles a status.
SmlAssemblerResult smlAssemblerReserveStatus(SmlAssembler *assm, unsigned int cmdRef, unsigned int msgRef, unsigned int cmdID, SmlError **error)
Reserves a place for a status with this assembler.
SmlBool smlParserEnd(SmlParser *parser, SmlBool *final, SmlBool *end, SmlError **error)
Ends the parsing.
SmlBool smlAssemblerRun(SmlAssembler *assm, char **data, unsigned int *size, SmlBool *end, SmlBool final, SmlError **error)
Assembles the complete message and returns the result.
unsigned int smlAssemblerFlush(SmlAssembler *assm)
Flushes the already parsed commands.
SmlBool smlAssemblerStart(SmlAssembler *assm, SmlSession *session, SmlError **error)
Starts a new message.
SmlBool smlAssemblerIsStatusMissing(SmlAssembler *assm)
Checks if there are reserved statuses missing.
SmlParser * smlParserNew(SmlMimeType type, unsigned int limit, SmlError **error)
Creates a new parser.
SmlXmlAssembler * smlXmlAssemblerNew(SmlAssembler *assembler, SmlAssemblerFunctions *functions, SmlError **error)
Creates a new XML assembler.
void smlTrace(SmlTraceType type, const char *message,...)
Used for tracing the application.
void smlAssemblerFree(SmlAssembler *assm)
Frees a assembler.
SmlBool smlAssemblerEndCommand(SmlAssembler *assm, SmlCommand *parent, SmlError **error)
Ends a parent command.
SmlBool smlParserStart(SmlParser *parser, const char *data, unsigned int size, SmlError **error)
Starts the parser on a given data buffer.
SmlBool smlParserGetStatus(SmlParser *parser, SmlStatus **status, SmlError **error)
Parses the next status.
SmlAssembler * smlAssemblerNew(SmlMimeType type, unsigned int limit, SmlError **error)
Creates a new assembler.
SmlParserResult smlParserGetCommand(SmlParser *parser, SmlCommand **cmd, SmlError **error)
Parses the next command.
void * smlTryMalloc0(long n_bytes, SmlError **error)
Safely mallocs.
unsigned int smlAssemblerCheckSize(SmlAssembler *assm, SmlBool headeronly, SmlError **error)
Assembles the complete message and returns the result.
void smlErrorSet(SmlError **error, SmlErrorType type, const char *format,...)
Sets the error.
SmlBool smlAssemblerGetSpace(SmlAssembler *assm, int *space, SmlCommand *parent, SmlCommand *cmd, SmlError **error)
Gets the available space in the assembler.