22 #include <libsyncml/syncml.h>
23 #include "sml_ds_server.h"
25 #include <libsyncml/syncml_internals.h>
26 #include "sml_ds_server_internals.h"
27 #include <libsyncml/sml_error_internals.h>
28 #include <libsyncml/sml_manager_internals.h>
29 #include <libsyncml/sml_session_internals.h>
30 #include <libsyncml/sml_command_internals.h>
31 #include <libsyncml/sml_elements_internals.h>
35 smlTrace(TRACE_ENTRY,
"%s(%p, %s, %i)", __func__, dsession, VA_STRING(uid), type);
37 g_mutex_lock(dsession->pendingMapsLock);
39 for (c = dsession->pendingMaps; c; c = c->next) {
41 if (!strcmp(uid, ctx->uid) && ctx->type == type) {
42 g_mutex_unlock(dsession->pendingMapsLock);
43 smlTrace(TRACE_EXIT,
"%s: %p", __func__, ctx);
47 g_mutex_unlock(dsession->pendingMapsLock);
49 smlTrace(TRACE_EXIT_ERROR,
"%s: Not found", __func__);
55 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, ctx);
58 smlStatusUnref(ctx->status);
61 smlSafeCFree(&(ctx->uid));
64 smlSafeCFree(&(ctx->newuid));
66 smlSafeFree((gpointer *)&ctx);
68 smlTrace(TRACE_EXIT,
"%s", __func__);
73 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, dsession, ctx);
76 smlTrace(TRACE_EXIT,
"%s: No status yet", __func__);
80 smlTrace(TRACE_INTERNAL,
"%s: Dispatching: uid %s, Type %i, newuid %s, result %i", __func__, VA_STRING(ctx->uid), ctx->type, VA_STRING(ctx->newuid), smlStatusGetCode(ctx->status));
82 if (ctx->type == SML_CHANGE_ADD &&
83 smlStatusGetClass(ctx->status) == SML_ERRORCLASS_SUCCESS &&
86 dsession->server->servertype == SML_DS_SERVER)
88 smlTrace(TRACE_EXIT,
"%s: No mapitem yet", __func__);
92 ctx->callback(dsession, ctx->status, ctx->newuid, ctx->userdata);
94 g_mutex_lock(dsession->pendingMapsLock);
95 dsession->pendingMaps = g_list_remove(dsession->pendingMaps, ctx);
96 g_mutex_unlock(dsession->pendingMapsLock);
98 if (ctx->type == SML_CHANGE_ADD &&
99 smlStatusGetClass(ctx->status) == SML_ERRORCLASS_SUCCESS &&
101 !dsession->pendingMaps)
108 dsession->
recvEventCallback(dsession, SML_DS_EVENT_COMMITEDCHANGES, dsession->recvEventCallbackUserdata);
109 smlTrace(TRACE_INTERNAL,
"%s: recvEventCallback commited changes callback", __func__);
112 _write_context_free(ctx);
114 smlTrace(TRACE_EXIT,
"%s", __func__);
119 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, status, userdata);
123 dsession->
sentAlertCallback(session, status, dsession->sentAlertCallbackUserdata);
126 dsession->sentAlertCallbackUserdata = NULL;
128 smlTrace(TRACE_EXIT,
"%s", __func__);
133 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, status, userdata);
137 dsession->
sentSyncCallback(session, status, dsession->sentSyncCallbackUserdata);
140 dsession->sentSyncCallbackUserdata = NULL;
144 dsession->
recvEventCallback(dsession, SML_DS_EVENT_COMMITEDCHANGES, dsession->recvEventCallbackUserdata);
145 smlTrace(TRACE_INTERNAL,
"%s: recvEventCallback commited changes callback", __func__);
148 smlTrace(TRACE_EXIT,
"%s", __func__);
153 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, status, userdata);
167 if (status->type == SML_COMMAND_TYPE_ADD ||
168 session->sessionType == SML_SESSION_TYPE_CLIENT) {
174 if (!status->sourceRef) {
175 smlTrace(TRACE_EXIT_ERROR,
"%s: Received add status or change reply from an OMA DS server without sourceRef", __func__);
179 if (!status->targetRef) {
180 smlTrace(TRACE_EXIT_ERROR,
"%s: Received delete or modify status or change reply from an OMA DS client without targetRef", __func__);
185 ctx->status = status;
186 smlStatusRef(status);
187 _write_context_dispatch(dsession, ctx);
189 smlTrace(TRACE_EXIT,
"%s", __func__);
194 smlTrace(TRACE_ENTRY,
"%s(%s, %p, %p)", __func__, VA_STRING(type), location, error);
202 server->location = location;
203 smlLocationRef(location);
205 server->contenttype = g_strdup(type);
206 server->servertype = SML_DS_SERVER;
208 smlTrace(TRACE_EXIT,
"%s: %p", __func__, server);
218 smlTrace(TRACE_ENTRY,
"%s(%s, %p, %p, %p)", __func__, VA_STRING(type), location, target, error);
227 server->location = location;
228 smlLocationRef(location);
230 server->target = target;
231 smlLocationRef(target);
233 server->contenttype = g_strdup(type);
234 server->servertype = SML_DS_CLIENT;
236 smlTrace(TRACE_EXIT,
"%s: %p", __func__, server);
244 SmlDsServerType smlDsServerGetServerType(
SmlDsServer *server)
247 return server->servertype;
252 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, server);
255 if (server->location)
256 smlLocationUnref(server->location);
259 smlLocationUnref(server->
target);
261 if (server->contenttype)
262 smlSafeCFree(&(server->contenttype));
264 smlSafeFree((gpointer *)&server);
266 smlTrace(TRACE_EXIT,
"%s", __func__);
281 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, server, callback, userdata);
285 server->connectCallbackUserdata = userdata;
287 smlTrace(TRACE_EXIT,
"%s", __func__);
290 void smlDsServerSetSanCallback(
SmlDsServer *server, SmlDsServerSanCb callback,
void *userdata)
292 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, server, callback, userdata);
294 smlAssert(server->servertype == SML_DS_CLIENT);
296 server->sanCallback = callback;
297 server->sanCallbackUserdata = userdata;
299 smlTrace(TRACE_EXIT,
"%s", __func__);
302 void smlDsServerSetSanSessionCallback(
SmlDsServer *server, SmlDsServerSanSessionCb callback,
void *userdata)
304 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, server, callback, userdata);
306 smlAssert(server->servertype == SML_DS_CLIENT);
308 server->sanSessionCallback = callback;
309 server->sanSessionCallbackUserdata = userdata;
311 smlTrace(TRACE_EXIT,
"%s", __func__);
314 const char *smlDsServerGetLocation(
SmlDsServer *server)
317 if (server->location)
318 return server->location->locURI;
322 const char *smlDsServerGetContentType(
SmlDsServer *server)
325 return server->contenttype;
330 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, server, san, error);
335 if (!smlNotificationNewAlert(san, SML_ALERT_TWO_WAY_BY_SERVER, server->contenttype, smlLocationGetURI(server->location), error))
338 smlTrace(TRACE_EXIT,
"%s", __func__);
348 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, server, session, cmd);
351 SmlDsSession *dsession = smlDsSessionNew(server, session, &error);
355 smlDsSessionRecvAlert(session, cmd, dsession);
360 smlDsSessionUnref(dsession);
362 smlTrace(TRACE_EXIT,
"%s", __func__);
367 smlErrorDeref(&error);
373 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %i, %s, %s, %p)", __func__, server, session, type, VA_STRING(last), VA_STRING(next), error);
378 SmlDsSession *dsession = smlDsSessionNew(server, session, error);
382 if (server->manager) {
383 if (!
smlManagerObjectRegister(server->manager, SML_COMMAND_TYPE_SYNC, session, server->location, NULL, NULL, smlDsSessionRecvSync, smlDsSessionRecvChange, dsession, error))
384 goto error_free_dsession;
386 if (!
smlManagerObjectRegister(server->manager, SML_COMMAND_TYPE_MAP, session, server->location, NULL, NULL, smlDsSessionRecvMap, NULL, dsession, error))
387 goto error_free_dsession;
389 if (!
smlManagerObjectRegister(server->manager, SML_COMMAND_TYPE_ALERT, session, server->location, NULL, NULL, smlDsSessionRecvAlert, NULL, dsession, error))
390 goto error_free_dsession;
394 goto error_free_dsession;
396 smlTrace(TRACE_EXIT,
"%s", __func__);
400 smlSafeFree((gpointer *)&dsession);
408 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, server, session, error);
416 dsession->server = server;
417 dsession->session = session;
418 dsession->write_lock = g_mutex_new();
419 dsession->lock = g_mutex_new();
420 dsession->syncReply = SML_ERROR_UNKNOWN;
421 dsession->refCount = 1;
423 if (server->servertype == SML_DS_CLIENT) {
424 dsession->target = server->
target;
425 smlLocationRef(dsession->target);
428 dsession->location = server->location;
429 smlLocationRef(dsession->location);
431 dsession->pendingMapsLock = g_mutex_new();
433 smlTrace(TRACE_EXIT,
"%s: %p", __func__, dsession);
443 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, dsession);
446 g_atomic_int_inc(&(dsession->refCount));
448 smlTrace(TRACE_EXIT,
"%s: New refcount: %i", __func__, dsession->refCount);
454 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, dsession);
457 if (g_atomic_int_dec_and_test(&(dsession->refCount))) {
458 smlTrace(TRACE_INTERNAL,
"%s: Refcount == 0!", __func__);
460 if (dsession->target)
461 smlLocationUnref(dsession->target);
463 if (dsession->location)
464 smlLocationUnref(dsession->location);
466 if (dsession->alertCommand)
467 smlCommandUnref(dsession->alertCommand);
471 smlCommandUnref(cmd);
475 while (dsession->recvChanges) {
476 SmlCommand *cmd = dsession->recvChanges->data;
477 smlCommandUnref(cmd);
478 dsession->recvChanges = g_list_delete_link(dsession->recvChanges, dsession->recvChanges);
484 if (!g_mutex_trylock(dsession->pendingMapsLock)) {
486 "%s: somebody still uses this object", __func__);
487 g_mutex_lock(dsession->pendingMapsLock);
489 while (dsession->pendingMaps) {
491 _write_context_free(ctx);
492 dsession->pendingMaps = g_list_delete_link(dsession->pendingMaps, dsession->pendingMaps);
494 g_mutex_unlock(dsession->pendingMapsLock);
495 g_mutex_free(dsession->pendingMapsLock);
497 while (dsession->mapItems) {
499 smlMapItemUnref(item);
500 dsession->mapItems = g_list_delete_link(dsession->mapItems, dsession->mapItems);
504 g_mutex_free(dsession->lock);
505 if (dsession->write_lock)
506 g_mutex_free(dsession->write_lock);
508 smlSafeFree((gpointer *)&dsession);
511 smlTrace(TRACE_EXIT,
"%s", __func__);
516 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, dsession);
526 if (!g_mutex_trylock(dsession->lock))
528 smlTrace(TRACE_EXIT,
"%s - DsSession is already locked", __func__);
531 smlTrace(TRACE_INTERNAL,
"%s - locked DsSession successfully", __func__);
534 smlTrace(TRACE_INTERNAL,
"%s: Dispatching alert", __func__);
536 SmlErrorType type = SML_NO_ERROR;
537 if (!dsession->
recvAlertCallback(dsession, dsession->alertCommand->private.alert.type, dsession->alertCommand->private.alert.anchor->last, dsession->alertCommand->private.alert.anchor->next, dsession->recvAlertCallbackUserdata))
538 type = SML_ERROR_REQUIRE_REFRESH;
541 reply = smlCommandNewReply(dsession->alertCommand, type, &error);
549 smlStatusUnref(reply);
551 smlCommandUnref(dsession->alertCommand);
552 dsession->alertCommand = NULL;
559 if (dsession->server->manager && dsession->finalLock)
561 dsession->finalLock = FALSE;
562 smlManagerSessionFinalLockUnref(dsession->server->manager, dsession->session);
566 smlTrace(TRACE_INTERNAL,
"%s: Dispatching sync", __func__);
574 smlTrace(TRACE_INTERNAL,
"%s: answering sync command with cmdRef %i and msgRef %i", __func__, cmd->cmdID, cmd->msgID);
575 reply = smlCommandNewReply(cmd, SML_NO_ERROR, &error);
582 smlStatusUnref(reply);
584 smlCommandUnref(cmd);
588 dsession->syncReply = SML_NO_ERROR;
590 if (!dsession->recvChanges) {
595 dsession->
recvEventCallback(dsession, SML_DS_EVENT_GOTCHANGES, dsession->recvEventCallbackUserdata);
596 smlTrace(TRACE_INTERNAL,
"%s: recvEventCallback no changes in recvSync callback", __func__);
603 if (dsession->server->manager && dsession->finalLock)
605 dsession->finalLock = FALSE;
606 smlManagerSessionFinalLockUnref(dsession->server->manager, dsession->session);
608 smlTrace(TRACE_INTERNAL,
"%s: final handling done", __func__);
610 }
else if (dsession->recvChanges && dsession->changesCallback) {
611 smlTrace(TRACE_INTERNAL,
"%s: Dispatching changes", __func__);
613 while (dsession->recvChanges) {
615 SmlCommand *cmd = dsession->recvChanges->data;
618 if (!cmd->private.change.items ||
619 !g_list_length(cmd->private.change.items))
621 smlErrorSet(&error, SML_ERROR_GENERIC,
"No items found in command.");
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);
638 "Item %i of the command's item list is NULL.", i);
644 if ((!item->source && !item->target)) {
646 "Cannot determine UID because source an target are missing on item %i.", i);
651 unsigned int size = 0;
655 if (!dsession->changesCallback(dsession, cmd->private.change.type, item->target ? item->target->locURI : item->source->locURI, data, size, item->contenttype, dsession->changesCallbackUserdata, &error))
659 if (cmd->private.change.type == SML_CHANGE_ADD)
660 reply = smlCommandNewReply(cmd, SML_ITEM_ADDED, &error);
662 reply = smlCommandNewReply(cmd, SML_NO_ERROR, &error);
670 smlStatusUnref(reply);
672 smlCommandUnref(cmd);
675 dsession->recvChanges = g_list_delete_link(dsession->recvChanges, dsession->recvChanges);
680 dsession->
recvEventCallback(dsession, SML_DS_EVENT_GOTCHANGES, dsession->recvEventCallbackUserdata);
681 smlTrace(TRACE_INTERNAL,
"%s: recvEventCallback all changes sent in recvChanges callback", __func__);
688 if (dsession->server->manager)
690 dsession->finalLock = FALSE;
691 smlManagerSessionFinalLockUnref(dsession->server->manager, dsession->session);
694 smlTrace(TRACE_INTERNAL,
"%s - no manager so should be a test", __func__);
697 smlTrace(TRACE_INTERNAL,
"%s: recvChanges: %p changesCallback: %p", __func__, dsession->recvChanges, dsession->changesCallback);
700 smlTrace(TRACE_EXIT,
"%s()", __func__);
701 g_mutex_unlock(dsession->lock);
707 smlStatusUnref(reply);
708 g_mutex_unlock(dsession->lock);
710 smlErrorDeref(&error);
717 (dsession->recvChanges && dsession->changesCallback))
724 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, cmd, userdata);
727 smlAssert(dsession->location);
729 g_mutex_lock(dsession->lock);
731 if (!cmd->target || !cmd->source) {
732 SmlStatus *reply = smlCommandNewReply(cmd, SML_ERROR_BAD_REQUEST, &error);
737 smlStatusUnref(reply);
741 smlStatusUnref(reply);
743 smlTrace(TRACE_EXIT,
"%s: Alert had no target or source", __func__);
747 if (!smlLocationCompare(NULL, dsession->location, NULL, cmd->target)) {
748 SmlStatus *reply = smlCommandNewReply(cmd, SML_ERROR_NOT_FOUND, &error);
753 smlStatusUnref(reply);
757 smlStatusUnref(reply);
759 smlTrace(TRACE_EXIT,
"%s: Alert does not match our location", __func__);
765 if (!dsession->target) {
766 dsession->target = cmd->source;
767 smlLocationRef(cmd->source);
770 dsession->alertCommand = cmd;
777 if (dsession->server->manager)
779 smlManagerSessionFinalLockRef(dsession->server->manager, session);
780 dsession->finalLock = TRUE;
783 smlTrace(TRACE_INTERNAL,
"%s - no manager so should be a test", __func__);
785 g_mutex_unlock(dsession->lock);
787 smlTrace(TRACE_EXIT,
"%s", __func__);
791 g_mutex_unlock(dsession->lock);
793 smlErrorDeref(&error);
799 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, cmd, userdata);
807 if (g_mutex_trylock(dsession->write_lock))
810 g_mutex_lock(dsession->lock);
811 smlTrace(TRACE_INTERNAL,
"%s - write lock enabled", __func__);
817 if (dsession->server->manager)
819 smlManagerSessionFinalLockRef(dsession->server->manager, session);
820 dsession->finalLock = TRUE;
821 dsession->emptySync = TRUE;
824 smlTrace(TRACE_INTERNAL,
"%s - no manager so should be a test", __func__);
827 if (dsession->finalLock && dsession->emptySync)
829 smlTrace(TRACE_INTERNAL,
"%s - empty sync of moreData ?", __func__);
830 dsession->finalLock = FALSE;
831 smlManagerSessionFinalLockUnref(dsession->server->manager, session);
833 g_mutex_unlock(dsession->lock);
834 g_mutex_unlock(dsession->write_lock);
835 smlTrace(TRACE_EXIT,
"%s - removed write lock", __func__);
839 if (dsession->syncReply == SML_ERROR_UNKNOWN) {
840 smlTrace(TRACE_INTERNAL,
"%s: Storing sync command with cmdRef %i and msgRef %i", __func__, cmd->cmdID, cmd->msgID);
844 smlTrace(TRACE_INTERNAL,
"%s: Using stored sync reply on cmd with cmdRef %i and msgRef %i", __func__, cmd->cmdID, cmd->msgID);
845 SmlStatus *reply = smlCommandNewReply(cmd, dsession->syncReply, &error);
852 smlStatusUnref(reply);
855 smlTrace(TRACE_EXIT,
"%s", __func__);
859 g_mutex_unlock(dsession->lock);
860 g_mutex_unlock(dsession->write_lock);
862 smlErrorDeref(&error);
867 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, cmd, userdata);
873 dsession->recvChanges = g_list_append(dsession->recvChanges, cmd);
877 dsession->emptySync = FALSE;
879 smlTrace(TRACE_EXIT,
"%s", __func__);
884 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, cmd, userdata);
888 g_mutex_lock(dsession->lock);
890 SmlStatus *reply = smlCommandNewReply(cmd, SML_NO_ERROR, &error);
897 smlStatusUnref(reply);
900 for (m = cmd->private.map.items; m; m = m->next) {
908 dsession->recvMappingCallbackUserdata);
910 SmlWriteContext *ctx = _write_context_find(dsession, item->target->locURI, SML_CHANGE_ADD);
912 ctx->newuid = g_strdup(item->source->locURI);
913 _write_context_dispatch(dsession, ctx);
915 smlTrace(TRACE_ERROR,
"%s: Unknown map ... %s => %s",
917 VA_STRING(item->target->locURI),
918 VA_STRING(item->source->locURI));
923 g_mutex_unlock(dsession->lock);
925 smlTrace(TRACE_EXIT,
"%s", __func__);
929 g_mutex_unlock(dsession->lock);
931 smlErrorDeref(&error);
948 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, dsession, callback, userdata);
953 dsession->recvAlertCallbackUserdata = userdata;
955 smlDsSessionDispatch(dsession);
957 smlTrace(TRACE_EXIT,
"%s", __func__);
974 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %s, %s, %p)", __func__, dsession, type, VA_STRING(last), VA_STRING(next), error);
978 SmlCommand *alert = smlCommandNewAlert(type, dsession->target, dsession->location, next, last, NULL, error);
983 dsession->sentAlertCallbackUserdata = userdata;
988 smlCommandUnref(alert);
990 smlTrace(TRACE_EXIT,
"%s", __func__);
998 void smlDsSessionGetMapping(
1000 SmlDsSessionMapCb mapCallback,
1003 smlTrace(TRACE_ENTRY,
"%s", __func__);
1005 dsession->recvMappingCallbackUserdata = userdata;
1006 smlTrace(TRACE_EXIT,
"%s", __func__);
1024 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, dsession, chgCallback, userdata);
1025 smlAssert(dsession);
1026 smlAssert(chgCallback);
1028 dsession->changesCallback = chgCallback;
1029 dsession->changesCallbackUserdata = userdata;
1031 smlDsSessionDispatch(dsession);
1033 smlTrace(TRACE_EXIT,
"%s", __func__);
1036 void smlDsSessionGetSync(
SmlDsSession *dsession, SmlDsSessionSyncCb syncCallback,
void *userdata)
1038 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, dsession, syncCallback, userdata);
1039 smlAssert(dsession);
1040 smlAssert(syncCallback);
1043 dsession->recvSyncCallbackUserdata = userdata;
1045 smlDsSessionDispatch(dsession);
1047 smlTrace(TRACE_EXIT,
"%s", __func__);
1050 void smlDsSessionGetEvent(
SmlDsSession *dsession, SmlDsSessionEventCb eventCallback,
void *userdata)
1052 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, dsession, eventCallback, userdata);
1053 smlAssert(dsession);
1054 smlAssert(eventCallback);
1057 dsession->recvEventCallbackUserdata = userdata;
1059 smlDsSessionDispatch(dsession);
1061 smlTrace(TRACE_EXIT,
"%s", __func__);
1079 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %p, %p, %p)", __func__, dsession, num_changes, callback, userdata, error);
1080 smlAssert(dsession);
1084 smlErrorSet(error, SML_ERROR_GENERIC,
"There already was a sync command started");
1089 dsession->sentSyncCallbackUserdata = userdata;
1091 dsession->
syncCommand = smlCommandNewSync(dsession->target, dsession->location, num_changes, error);
1098 smlTrace(TRACE_EXIT,
"%s", __func__);
1107 SmlBool smlDsSessionQueueChange(
SmlDsSession *dsession, SmlChangeType type,
const char *uid,
const char *data,
unsigned int size,
const char *contenttype, SmlDsSessionWriteCb callback,
void *userdata,
SmlError **error)
1109 smlTrace(TRACE_ENTRY,
"%s(%p, %i, %s, %p, %i, %s, %p, %p, %p)", __func__, dsession, type, VA_STRING(uid), data, size, VA_STRING(contenttype), callback, userdata, error);
1110 smlAssert(dsession);
1114 smlErrorSet(error, SML_ERROR_GENERIC,
"You have to start a sync command first");
1118 SmlCommand *cmd = smlCommandNewChange(type, uid, data, size, contenttype, error);
1124 goto error_free_cmd;
1126 ctx->callback = callback;
1127 ctx->userdata = userdata;
1128 ctx->uid = g_strdup(uid);
1130 ctx->session = dsession;
1132 g_mutex_lock(dsession->pendingMapsLock);
1133 dsession->pendingMaps = g_list_append(dsession->pendingMaps, ctx);
1134 g_mutex_unlock(dsession->pendingMapsLock);
1137 goto error_free_ctx;
1139 smlCommandUnref(cmd);
1141 smlTrace(TRACE_EXIT,
"%s", __func__);
1145 smlSafeCFree(&(ctx->uid));
1146 smlSafeFree((gpointer *)&ctx);
1148 smlCommandUnref(cmd);
1162 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, dsession, error);
1163 smlAssert(dsession);
1167 smlErrorSet(error, SML_ERROR_GENERIC,
"There already was a sync command started");
1177 smlTrace(TRACE_EXIT,
"%s", __func__);
1185 SmlBool smlDsSessionQueueMap(
SmlDsSession *dsession,
const char *uid,
const char *newuid,
SmlError **error)
1187 smlTrace(TRACE_ENTRY,
"%s(%p, %s, %s, %p)", __func__, dsession, VA_STRING(uid), VA_STRING(newuid), error);
1188 smlAssert(dsession);
1191 SmlMapItem *item = smlMapItemNew(uid, newuid, error);
1195 dsession->mapItems = g_list_append(dsession->mapItems, item);
1197 smlTrace(TRACE_EXIT,
"%s", __func__);
1216 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p)", __func__, dsession, callback, userdata, error);
1217 smlAssert(dsession);
1220 if (!dsession->mapItems) {
1221 smlTrace(TRACE_EXIT,
"%s: No mapitems", __func__);
1225 SmlCommand *cmd = smlCommandNewMap(dsession->server->
target, dsession->server->location, error);
1229 while (dsession->mapItems) {
1231 if (!smlCommandAddMapItem(cmd, item, error))
1232 goto error_free_cmd;
1233 smlMapItemUnref(item);
1235 dsession->mapItems = g_list_remove(dsession->mapItems, item);
1239 goto error_free_cmd;
1241 smlCommandUnref(cmd);
1243 smlTrace(TRACE_EXIT,
"%s", __func__);
1247 smlCommandUnref(cmd);
1253 const char *smlDsSessionGetLocation(
SmlDsSession *dsession)
1255 smlAssert(dsession);
1256 return smlDsServerGetLocation(dsession->server);
1261 smlAssert(dsession);
1262 return dsession->server;
1265 const char *smlDsSessionGetContentType(
SmlDsSession *dsession)
1267 smlAssert(dsession);
1268 return smlDsServerGetContentType(dsession->server);
1273 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, cmd, userdata);
1277 SmlDsSession *dsession = smlDsServerRecvAlert(server, session, cmd);
1281 if (!
smlManagerObjectRegister(server->manager, SML_COMMAND_TYPE_SYNC, session, server->location, NULL, NULL, smlDsSessionRecvSync, smlDsSessionRecvChange, dsession, &error))
1282 goto error_free_dsession;
1284 if (!
smlManagerObjectRegister(server->manager, SML_COMMAND_TYPE_MAP, session, server->location, NULL, NULL, smlDsSessionRecvMap, NULL, dsession, &error))
1285 goto error_free_dsession;
1287 smlTrace(TRACE_EXIT,
"%s", __func__);
1290 error_free_dsession:
1291 smlSafeFree((gpointer *)&dsession);
1295 smlErrorDeref(&error);
1300 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, cmd, userdata);
1305 session->sessionType = SML_SESSION_TYPE_CLIENT;
1308 smlLocationUnref(server->
target);
1309 server->
target = cmd->source;
1310 smlLocationRef(server->
target);
1313 if (server->sanSessionCallback) {
1314 SmlErrorType type = server->sanSessionCallback(
1317 cmd->private.alert.type,
1318 server->sanSessionCallbackUserdata);
1320 SmlStatus *reply = smlCommandNewReply(cmd, type, &error);
1327 smlStatusUnref(reply);
1328 }
else if (server->sanCallback) {
1329 SmlErrorType type = server->sanCallback(server, cmd->private.alert.type, server->sanCallbackUserdata);
1331 SmlStatus *reply = smlCommandNewReply(cmd, type, &error);
1338 smlStatusUnref(reply);
1340 smlTrace(TRACE_INTERNAL,
"%s: SAN ignored", __func__);
1342 SmlStatus *reply = smlCommandNewReply(cmd, SML_ERROR_NOT_IMPLEMENTED, &error);
1349 smlStatusUnref(reply);
1352 smlTrace(TRACE_EXIT,
"%s", __func__);
1358 smlErrorDeref(&error);
1363 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, server, manager, error);
1368 if (!
smlManagerObjectRegister(manager, SML_COMMAND_TYPE_ALERT, NULL, server->location, NULL, NULL, _recv_manager_alert, NULL, server, error))
1371 if (!
smlManagerObjectRegister(manager, SML_COMMAND_TYPE_ALERT, NULL, NULL, NULL,server->contenttype, _recv_manager_san, NULL, server, error))
1374 server->manager = manager;
1376 smlTrace(TRACE_EXIT,
"%s", __func__);
1386 smlAssert(dsession);
1387 return dsession->target;