00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "data_sync_callbacks.h"
00022 #include "libsyncml/syncml_internals.h"
00023 #include "libsyncml/sml_support.h"
00024 #include "libsyncml/sml_error_internals.h"
00025 #include <string.h>
00026 #include <strings.h>
00027 #include "defines.h"
00028 #include "data_sync_devinf.h"
00029 #include "libsyncml/objects/sml_ds_server_internals.h"
00030 #include "libsyncml/sml_manager_internals.h"
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043 void smlDataSyncEventCallback(
00044 SmlManager *manager,
00045 SmlManagerEventType type,
00046 SmlSession *session,
00047 SmlError *error,
00048 void *userdata)
00049 {
00050 smlTrace(TRACE_ENTRY, "%s(%p, %i, %p, %p, %p)", __func__, manager, type, session, error, userdata);
00051 SmlDataSyncObject *dsObject = userdata;
00052 smlAssert(dsObject);
00053 GList *o = NULL;
00054
00055
00056
00057 g_mutex_lock(dsObject->managerMutex);
00058
00059 switch (type) {
00060 case SML_MANAGER_SESSION_FLUSH:
00061 case SML_MANAGER_CONNECT_DONE:
00062 smlTrace(TRACE_INTERNAL, "%s: ignored event %d ", __func__, type);
00063 dsObject->internalState = SML_DATA_SYNC_STATE_CONNECTED;
00064 break;
00065 case SML_MANAGER_SESSION_ESTABLISHED:
00066 smlTrace(TRACE_INTERNAL, "%s: session established", __func__);
00067 dsObject->internalState = SML_DATA_SYNC_STATE_SESSION_READY;
00068 smlDataSyncSendEvent(
00069 dsObject, SML_DATA_SYNC_EVENT_CONNECT,
00070 dsObject->eventUserdata, NULL);
00071 break;
00072 case SML_MANAGER_DISCONNECT_DONE:
00073 smlTrace(TRACE_INTERNAL, "%s: connection with device has ended", __func__);
00074
00075
00076
00077
00078 if (dsObject->internalState < SML_DATA_SYNC_STATE_CONNECTED)
00079 {
00080 smlTrace(TRACE_INTERNAL,
00081 "%s: ignored disconnect because never connected",
00082 __func__);
00083 break;
00084 }
00085
00086 if (dsObject->setAnchorCallback)
00087 {
00088 o = dsObject->datastores;
00089 for (; o; o = o->next) {
00090 SmlDataSyncDatastore *datastore = o->data;
00091
00092 char *anchor = g_strdup_printf(
00093 "localanchor%s",
00094 smlDsSessionGetLocation(datastore->session));
00095 if (!dsObject->setAnchorCallback(
00096 dsObject,
00097 anchor, datastore->localNext,
00098 dsObject->setAnchorUserdata,
00099 &error))
00100 goto error;
00101 anchor = g_strdup_printf(
00102 "remoteanchor%s",
00103 smlDsSessionGetLocation(datastore->session));
00104 if (!dsObject->setAnchorCallback(
00105 dsObject,
00106 anchor, datastore->remoteNext,
00107 dsObject->setAnchorUserdata,
00108 &error))
00109 goto error;
00110 }
00111 }
00112
00113 dsObject->internalState = SML_DATA_SYNC_STATE_DISCONNECTED;
00114 smlDataSyncSendEvent(
00115 dsObject, SML_DATA_SYNC_EVENT_DISCONNECT,
00116 dsObject->eventUserdata, NULL);
00117 smlDataSyncSendEvent(
00118 dsObject, SML_DATA_SYNC_EVENT_FINISHED,
00119 dsObject->eventUserdata, NULL);
00120 break;
00121 case SML_MANAGER_TRANSPORT_ERROR:
00122 smlTrace(TRACE_INTERNAL,
00123 "There was an error in the transport: %s",
00124 smlErrorPrint(&error));
00125 if (SML_DATA_SYNC_STATE_CONNECTED <= dsObject->internalState &&
00126 dsObject->internalState < SML_DATA_SYNC_STATE_DISCONNECTED) {
00127 if (dsObject->internalState < SML_DATA_SYNC_STATE_DISCONNECT_IN_PROGRESS) {
00128 dsObject->internalState = SML_DATA_SYNC_STATE_DISCONNECT_IN_PROGRESS;
00129 SmlError *locerror = NULL;
00130 SmlLink *link_ = smlManagerSessionGetLink(
00131 dsObject->manager,
00132 dsObject->session,
00133 &locerror);
00134 if (link_ || !locerror)
00135 smlTransportDisconnect(
00136 dsObject->tsp,
00137 link_,
00138 &locerror);
00139 if (link_)
00140 smlLinkDeref(link_);
00141
00142
00143
00144 if (locerror)
00145 smlErrorDeref(&locerror);
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163 } else {
00164
00165 dsObject->internalState = SML_DATA_SYNC_STATE_DISCONNECTED;
00166 }
00167 }
00168 goto error;
00169 break;
00170 case SML_MANAGER_SESSION_NEW:
00171 smlTrace(TRACE_INTERNAL, "%s: Just received a new session with ID %s",
00172 __func__, VA_STRING(smlSessionGetSessionID(session)));
00173 if (dsObject->session) {
00174 smlTrace(TRACE_INTERNAL,
00175 "%s: WARNING: There was an old session %s in the environment.",
00176 __func__, VA_STRING(smlSessionGetSessionID(dsObject->session)));
00177 smlSessionUnref(dsObject->session);
00178 dsObject->session = NULL;
00179 }
00180 smlSessionUseStringTable(session, dsObject->useStringTable);
00181 smlSessionUseOnlyReplace(session, dsObject->onlyReplace);
00182 smlSessionUseNumberOfChanges(session, dsObject->useNumberOfChanges);
00183
00184 smlTrace(TRACE_INTERNAL, "%s: maxObjSize %d",
00185 __func__, dsObject->maxObjSize);
00186
00187 dsObject->session = session;
00188 smlSessionRef(session);
00189
00190
00191 if (dsObject->dsType == SML_SESSION_TYPE_CLIENT &&
00192 (dsObject->username || dsObject->password))
00193 {
00194
00195 SmlCred *cred = smlCredNewAuth(dsObject->authType,
00196 dsObject->username, dsObject->password,
00197 &error);
00198 if (!cred)
00199 goto error;
00200 smlSessionRegisterCred(dsObject->session, cred);
00201 smlTrace(TRACE_INTERNAL, "%s: credential initialized", __func__);
00202 }
00203
00204 break;
00205 case SML_MANAGER_SESSION_FINAL:
00206 smlTrace(TRACE_INTERNAL, "%s: Session %s reported final",
00207 __func__, VA_STRING(smlSessionGetSessionID(session)));
00208
00209
00210
00211 if (dsObject->dsType == SML_SESSION_TYPE_CLIENT)
00212 {
00213
00214 if (dsObject->actualPackage < SML_PACKAGE_1)
00215 dsObject->actualPackage = SML_PACKAGE_1;
00216 else
00217 dsObject->actualPackage += 2;
00218 } else {
00219
00220 if (dsObject->actualPackage < SML_PACKAGE_2)
00221 dsObject->actualPackage = SML_PACKAGE_2;
00222 else
00223 dsObject->actualPackage += 2;
00224 }
00225 smlTrace(TRACE_INTERNAL, "%s: package == %d", __func__, dsObject->actualPackage);
00226
00227
00228
00229 switch(dsObject->actualPackage)
00230 {
00231 case SML_PACKAGE_1:
00232
00233
00234
00235
00236
00237
00238 if (!smlDataSyncManageDevInf(dsObject, TRUE, &error))
00239 goto error;
00240 if (!smlSessionFlush(dsObject->session, TRUE, &error))
00241 goto error;
00242 break;
00243 case SML_PACKAGE_2:
00244
00245
00246
00247
00248
00249
00250 if (!smlDataSyncManageDevInf(dsObject, TRUE, &error))
00251 goto error;
00252
00253 if (!smlSessionFlush(dsObject->session, TRUE, &error))
00254 goto error;
00255
00256 smlDataSyncSendEvent(
00257 dsObject, SML_DATA_SYNC_EVENT_GOT_ALL_ALERTS,
00258 dsObject->eventUserdata, NULL);
00259 break;
00260 case SML_PACKAGE_3:
00261 smlDataSyncSendEvent(
00262 dsObject, SML_DATA_SYNC_EVENT_GOT_ALL_ALERTS,
00263 dsObject->eventUserdata, NULL);
00264 break;
00265 case SML_PACKAGE_4:
00266 smlDataSyncSendEvent(
00267 dsObject, SML_DATA_SYNC_EVENT_GOT_ALL_CHANGES,
00268 dsObject->eventUserdata, NULL);
00269 break;
00270 case SML_PACKAGE_5:
00271 if (!smlDataSyncSendMap(dsObject, &error))
00272 goto error;
00273 if (!smlSessionFlush(dsObject->session, TRUE, &error))
00274 goto error;
00275 smlDataSyncSendEvent(
00276 dsObject, SML_DATA_SYNC_EVENT_GOT_ALL_CHANGES,
00277 dsObject->eventUserdata, NULL);
00278 break;
00279 case SML_PACKAGE_6:
00280 if (!smlSessionFlush(dsObject->session, TRUE, &error))
00281 goto error;
00282 break;
00283 case SML_PACKAGE_END:
00284
00285
00286 break;
00287 default:
00288 smlErrorSet(&error, SML_ERROR_NOT_IMPLEMENTED,
00289 "The package %d is actually not supported.",
00290 dsObject->actualPackage);
00291 goto error;
00292 }
00293 break;
00294 case SML_MANAGER_SESSION_END:
00295 smlTrace(TRACE_INTERNAL, "%s: Session %s has ended",
00296 __func__, VA_STRING(smlSessionGetSessionID(session)));
00297 SmlLink *link_ = smlManagerSessionGetLink(
00298 dsObject->manager,
00299 dsObject->session,
00300 &error);
00301 if (!link_ && error)
00302 goto error;
00303
00304
00305
00306
00307
00308
00309
00310 if (!smlTransportDisconnect(dsObject->tsp, link_, &error))
00311 {
00312 if (link_)
00313 smlLinkDeref(link_);
00314 goto error;
00315 }
00316 if (link_)
00317 smlLinkDeref(link_);
00318 break;
00319 case SML_MANAGER_SESSION_ERROR:
00320 if (session)
00321 smlTrace(TRACE_INTERNAL,
00322 "There was an error in the session %s: %s",
00323 VA_STRING(smlSessionGetSessionID(session)),
00324 smlErrorPrint(&error));
00325 else
00326 smlTrace(TRACE_INTERNAL,
00327 "There was a general error in the manager. %s",
00328 smlErrorPrint(&error));
00329
00330 goto error;
00331 break;
00332 case SML_MANAGER_SESSION_WARNING:
00333 g_warning("WARNING: %s\n", smlErrorPrint(&error));
00334 break;
00335 default:
00336 g_warning("%s: Unknown event received: %d.", __func__, type);
00337 break;
00338 }
00339
00340 g_mutex_unlock(dsObject->managerMutex);
00341 smlTrace(TRACE_EXIT, "%s", __func__);
00342 return;
00343
00344 error:
00345 g_mutex_unlock(dsObject->managerMutex);
00346 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00347 smlDataSyncSendEvent(
00348 dsObject, SML_DATA_SYNC_EVENT_ERROR,
00349 dsObject->eventUserdata, error);
00350 }
00351
00352
00353
00354
00355
00356 void smlDataSyncDatastoreConnectCallback(
00357 SmlDsSession *dsession,
00358 void *userdata)
00359 {
00360 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, dsession, userdata);
00361 smlAssert(dsession);
00362 smlAssert(userdata);
00363
00364 SmlDataSyncDatastore *datastore = userdata;
00365 SmlDataSyncObject *dsObject = datastore->dsObject;
00366
00367
00368
00369
00370
00371
00372 while (!dsObject->session) {
00373 smlManagerDispatch(dsObject->manager);
00374 }
00375
00376
00377 if (!datastore->session || datastore->session != dsession)
00378 {
00379 smlTrace(TRACE_INTERNAL, "%s: should be an OMA DS server", __func__);
00380 smlAssert(dsObject->funcDatastoreAlert);
00381 datastore->session = dsession;
00382 smlDsSessionGetAlert(datastore->session, dsObject->funcDatastoreAlert, datastore);
00383 if (dsObject->changeCallback) {
00384 smlDsSessionGetSync(datastore->session,
00385 smlDataSyncSyncCallback, datastore);
00386 smlDsSessionGetChanges(datastore->session,
00387 smlDataSyncChangeCallback, datastore);
00388 smlDsSessionGetMapping(datastore->session,
00389 smlDataSyncMappingCallback, datastore);
00390 }
00391 smlDsSessionRef(dsession);
00392 }
00393
00394 smlTrace(TRACE_EXIT, "%s", __func__);
00395 return;
00396
00397 #if 0
00398 error:
00399 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00400 smlDataSyncSendEvent(
00401 dsObject, SML_DATA_SYNC_EVENT_ERROR,
00402 dsObject->eventUserdata, error);
00403 #endif
00404 }
00405
00406
00407
00408
00409
00410
00411 void smlDataSyncAlertStatusCallback(
00412 SmlSession *session,
00413 SmlStatus *status,
00414 void *userdata)
00415 {
00416 smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, session, status, userdata);
00417
00418 SmlDataSyncDatastore *datastore = userdata;
00419
00420
00421
00422
00423
00424
00425
00426
00427
00428 unsigned int code = smlStatusGetCode(status);
00429 if (code >= 300 && code != SML_ERROR_REQUIRE_REFRESH)
00430 {
00431
00432 SmlError *error = NULL;
00433 smlErrorSet(&error, SML_ERROR_GENERIC,
00434 "The alert response signals an error - %d.", code);
00435 smlErrorRef(&error);
00436 smlDataSyncSendEvent(
00437 datastore->dsObject, SML_DATA_SYNC_EVENT_ERROR,
00438 datastore->dsObject->eventUserdata, error);
00439 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00440 smlErrorDeref(&error);
00441 } else {
00442 smlTrace(TRACE_EXIT, "%s", __func__);
00443 }
00444 }
00445
00446
00447
00448
00449
00450 void smlDataSyncSyncCallback(
00451 SmlDsSession *dsession,
00452 unsigned int numchanges,
00453 void *userdata)
00454 {
00455 smlTrace(TRACE_ENTRY, "%s(%p, %i, %p)", __func__, dsession, numchanges, userdata);
00456 SmlDataSyncDatastore *datastore = userdata;
00457 SmlError *error = NULL;
00458
00459
00460
00461
00462
00463
00464 if (!smlDataSyncManageDevInf(datastore->dsObject, FALSE, &error))
00465 goto error;
00466
00467 smlTrace(TRACE_EXIT, "%s", __func__);
00468 return;
00469 error:
00470 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00471 smlDataSyncSendEvent(
00472 datastore->dsObject, SML_DATA_SYNC_EVENT_ERROR,
00473 datastore->dsObject->eventUserdata, error);
00474 }
00475
00476 void smlDataSyncSyncStatusCallback(
00477 SmlSession *session,
00478 SmlStatus *status,
00479 void *userdata)
00480 {
00481 smlTrace(TRACE_ENTRY, "%s(%p, %p)", __func__, session, status, userdata);
00482 SmlDataSyncDatastore *datastore = userdata;
00483
00484 if (smlStatusGetClass(status) != SML_ERRORCLASS_SUCCESS)
00485 {
00486
00487 smlTrace(TRACE_INTERNAL, "%s: The synchronisation request failed.", __func__);
00488 smlTrace(TRACE_INTERNAL, "%s: Location => %s", __func__, VA_STRING(datastore->dsObject->url));
00489 smlTrace(TRACE_INTERNAL, "%s: Database => %s", __func__, VA_STRING(datastore->sourceUri));
00490 smlTrace(TRACE_INTERNAL, "%s: Error => %d", __func__, smlStatusGetCode(status));
00491 if (smlStatusGetCode(status) == SML_ERROR_SERVICE_UNAVAILABLE &&
00492 (strstr(datastore->dsObject->url, "ocst") ||
00493 strstr(datastore->dsObject->url, "ocas")))
00494 {
00495
00496
00497 smlTrace(TRACE_INTERNAL,
00498 "%s: Oracle Collaboration Suite detected.",
00499 __func__);
00500 smlTrace(TRACE_INTERNAL,
00501 "%s: Typical undefined error from OCS (503 - SyncML timeout error).",
00502 __func__);
00503 smlTrace(TRACE_INTERNAL,
00504 "%s: Please wait 5 minutes before retry - default session timeout.",
00505 __func__);
00506 }
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518 SmlError *error = NULL;
00519 smlErrorSet(&error, smlStatusGetCode(status),
00520 "Sync failed with error %d.",
00521 smlStatusGetCode(status));
00522 smlErrorRef(&error);
00523 smlDataSyncSendEvent(
00524 datastore->dsObject, SML_DATA_SYNC_EVENT_ERROR,
00525 datastore->dsObject->eventUserdata, error);
00526 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00527 smlErrorDeref(&error);
00528 } else {
00529 smlTrace(TRACE_EXIT, "%s", __func__);
00530 }
00531 }
00532
00533
00534
00535
00536
00537 SmlBool smlDataSyncChangeCallback(
00538 SmlDsSession *dsession,
00539 SmlChangeType type,
00540 const char *uid,
00541 char *data,
00542 unsigned int size,
00543 const char *contenttype,
00544 void *userdata,
00545 SmlError **error)
00546 {
00547 smlTrace(TRACE_ENTRY, "%s(%p, %i, %s, %p, %i, %s, %p, %p)", __func__, dsession, type, VA_STRING(uid), data, size, VA_STRING(contenttype), userdata, error);
00548 CHECK_ERROR_REF
00549
00550 SmlDataSyncDatastore *datastore = userdata;
00551
00552 smlAssert(type);
00553 smlAssert(datastore);
00554 smlAssert(datastore->dsObject);
00555 smlAssert(datastore->dsObject->changeCallback);
00556
00557
00558 if (datastore->alertType == SML_ALERT_SLOW_SYNC &&
00559 type == SML_CHANGE_REPLACE)
00560 type = SML_CHANGE_ADD;
00561
00562
00563 size_t appClassLength = ((size_t) index(datastore->contentType, '/')) -
00564 ((size_t) datastore->contentType);
00565 if ( ( strstr(datastore->contentType, SML_CONTENT_TYPE_APPLICATION) == datastore->contentType &&
00566 appClassLength == strlen(SML_CONTENT_TYPE_APPLICATION) ) ||
00567 ( strstr(datastore->contentType, SML_CONTENT_TYPE_AUDIO) == datastore->contentType &&
00568 appClassLength == strlen(SML_CONTENT_TYPE_AUDIO) ) ||
00569 ( strstr(datastore->contentType, SML_CONTENT_TYPE_IMAGE) == datastore->contentType &&
00570 appClassLength == strlen(SML_CONTENT_TYPE_IMAGE) ) ||
00571 ( strstr(datastore->contentType, SML_CONTENT_TYPE_MESSAGE) == datastore->contentType &&
00572 appClassLength == strlen(SML_CONTENT_TYPE_MESSAGE) ) ||
00573 ( strstr(datastore->contentType, SML_CONTENT_TYPE_VIDEO) == datastore->contentType &&
00574 appClassLength == strlen(SML_CONTENT_TYPE_AUDIO) ) )
00575 {
00576
00577 char *b64data = data;
00578 size_t length = 0;
00579 data = (char *) g_base64_decode(b64data, &length);
00580 size = length;
00581 smlSafeCFree(&b64data);
00582 if (!data) {
00583 smlErrorSet(error, SML_ERROR_GENERIC,
00584 "The base 64 decoding of glib failed.");
00585 goto error;
00586 }
00587 }
00588
00589
00590 if (!datastore->dsObject->changeCallback(
00591 datastore->dsObject, datastore->sourceUri,
00592 type, uid, data, size,
00593 datastore->dsObject->changeUserdata,
00594 error))
00595 goto error;
00596
00597
00598
00599 smlTrace(TRACE_EXIT, "%s", __func__);
00600 return TRUE;
00601 error:
00602 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(error));
00603 return FALSE;
00604 }
00605
00606 void smlDataSyncChangeStatusCallback(
00607 SmlDsSession *dsession,
00608 SmlStatus *status,
00609 const char *newuid,
00610 void *userdata)
00611 {
00612 smlTrace(TRACE_ENTRY, "%s(%p, %p, %s, %p)", __func__, dsession, status, VA_STRING(newuid), userdata);
00613 SmlError *error = NULL;
00614
00615 smlAssert(userdata);
00616 SmlDataSyncChange *change = userdata;
00617 SmlDataSyncDatastore *datastore = change->datastore;
00618 SmlDataSyncObject *dsObject = datastore->dsObject;
00619
00620 smlAssert(dsObject);
00621 if (dsObject->changeStatusCallback &&
00622 !dsObject->changeStatusCallback(
00623 dsObject,
00624 smlStatusGetCode(status),
00625 newuid,
00626 change->userdata, &error))
00627 goto error;
00628
00629 smlTrace(TRACE_EXIT, "%s", __func__);
00630 return;
00631 error:
00632 smlErrorRef(&error);
00633 smlDataSyncSendEvent(
00634 dsObject, SML_DATA_SYNC_EVENT_ERROR,
00635 dsObject->eventUserdata, error);
00636 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00637 smlErrorDeref(&error);
00638 }
00639
00640 void smlDataSyncMappingCallback(
00641 SmlDsSession *dsession,
00642 SmlLocation *orig,
00643 SmlLocation *newuid,
00644 void *userdata)
00645 {
00646 smlTrace(TRACE_ENTRY, "%s(%p, %s, %s, %p)", __func__, dsession, VA_STRING(smlLocationGetURI(orig)), VA_STRING(smlLocationGetURI(newuid)), userdata);
00647
00648 SmlError *error = NULL;
00649 SmlDataSyncDatastore *datastore = userdata;
00650
00651 smlAssert(datastore);
00652 smlAssert(datastore->dsObject);
00653 smlAssert(datastore->dsObject->mappingCallback);
00654
00655
00656 if (!datastore->dsObject->mappingCallback(
00657 datastore->dsObject, datastore->sourceUri,
00658 smlLocationGetURI(orig),
00659 smlLocationGetURI(newuid),
00660 datastore->dsObject->mappingUserdata,
00661 &error))
00662 goto error;
00663
00664 smlTrace(TRACE_EXIT, "%s", __func__);
00665 return;
00666 error:
00667 smlErrorRef(&error);
00668 smlDataSyncSendEvent(
00669 datastore->dsObject, SML_DATA_SYNC_EVENT_ERROR,
00670 datastore->dsObject->eventUserdata, error);
00671 smlTrace(TRACE_EXIT_ERROR, "%s - %s", __func__, smlErrorPrint(&error));
00672 smlErrorDeref(&error);
00673 }
00674
00675
00676
00677
00678
00679 void smlDataSyncMapStatusCallback(
00680 SmlSession *session,
00681 SmlStatus *status,
00682 void *userdata)
00683 {
00684 smlTrace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, session, status, userdata);
00685 if (smlStatusGetClass(status) != SML_ERRORCLASS_SUCCESS)
00686 {
00687 SmlDataSyncDatastore *datastore = userdata;
00688 SmlError *error = NULL;
00689 smlErrorSet(&error, smlStatusGetCode(status),
00690 "Map of datastore %s was rejected with error code %d",
00691 datastore->sourceUri, smlStatusGetCode(status));
00692 smlDataSyncSendEvent(
00693 datastore->dsObject, SML_DATA_SYNC_EVENT_ERROR,
00694 datastore->dsObject->eventUserdata, error);
00695 }
00696 smlTrace(TRACE_EXIT, "%s", __func__);
00697 }
00698
00699
00700
00701
00702
00703 SmlBool smlDataSyncVerifyUserCallback(
00704 SmlChal *chal,
00705 SmlCred *cred,
00706 const char *username,
00707 void *userdata,
00708 SmlError **error)
00709 {
00710 smlTrace(TRACE_ENTRY, "%s(%p, %p, %s, %p)", __func__, chal, cred, VA_STRING(username), userdata);
00711 CHECK_ERROR_REF
00712
00713 SmlDataSyncObject *dsObject = userdata;
00714
00715
00716 smlTrace(TRACE_EXIT, "%s", __func__);
00717 return smlAuthVerify(chal, cred, dsObject->username, dsObject->password, error);
00718 }
00719