22 #include <libsyncml/syncml.h>
23 #include "sml_devinf_obj.h"
25 #include <libsyncml/syncml_internals.h>
26 #include "sml_devinf_obj_internals.h"
27 #include <libsyncml/sml_session_internals.h>
28 #include <libsyncml/sml_elements_internals.h>
29 #include <libsyncml/sml_command_internals.h>
30 #include "libsyncml/sml_error_internals.h"
35 #include<sys/utsname.h>
54 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, agent, session, error);
58 smlAssert(agent->sessions);
65 g_hash_table_insert(agent->sessions, session, as);
67 smlTrace(TRACE_EXIT,
"%s - %p", __func__, as);
70 smlSafeFree((gpointer *) &as);
79 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, agent, session);
82 smlAssert(agent->sessions);
86 smlTrace(TRACE_EXIT,
"%s - %p", __func__, as);
90 static void _free_session (gpointer data)
92 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, data);
96 smlDevInfUnref(as->recvDevInf);
97 smlSafeFree((gpointer *) &as);
99 smlTrace(TRACE_EXIT,
"%s", __func__);
106 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, status, userdata);
110 if (smlStatusIsResult(status)) {
111 SmlCommand *result = smlStatusGetResult(status);
117 as = _new_session(agent, session, &error);
124 as->recvDevInf = smlDevInfFromResult(result, &error);
130 SmlStatus *reply = smlCommandNewReply(result, SML_NO_ERROR, &error);
135 smlStatusUnref(reply);
139 smlStatusUnref(reply);
142 smlTrace(TRACE_EXIT,
"%s", __func__);
146 smlSessionDispatchEvent(session, SML_SESSION_EVENT_ERROR, NULL, NULL, NULL, error);
148 smlErrorDeref(&error);
153 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, status, userdata);
155 smlTrace(TRACE_EXIT,
"%s", __func__);
160 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p)", __func__, agent, session,
get, error);
172 if (smlSessionGetVersion(session) >= SML_VERSION_11 &&
173 session->sessionType == SML_SESSION_TYPE_SERVER &&
174 !smlDevInfSupportsLargeObjs(agent->devinf))
176 smlErrorSet(error, SML_ERROR_INTERNAL_MISCONFIGURATION,
177 "OMA DS Server must support large object handling if SyncML 1.1 or higher is used.");
184 if (smlDevInfSupportsLargeObjs(agent->devinf))
186 if (smlSessionGetLocalMaxMsgSize(session) < 1)
188 smlErrorSet(error, SML_ERROR_INTERNAL_MISCONFIGURATION,
189 "If large object support is enabled then MaxMsgSize must be set.");
192 if (smlSessionGetLocalMaxObjSize(session) < 1)
194 smlErrorSet(error, SML_ERROR_INTERNAL_MISCONFIGURATION,
195 "If large object support is enabled then MaxObjSize must be set.");
204 as = _new_session(agent, session, error);
211 if (!as->devinfSent) {
213 if (smlSessionGetVersion(session) == SML_VERSION_10)
214 result = smlDevInfNewResult(
get, agent->devinf, SML_DEVINF_VERSION_10, error);
215 else if (smlSessionGetVersion(session) == SML_VERSION_12)
216 result = smlDevInfNewResult(
get, agent->devinf, SML_DEVINF_VERSION_12, error);
218 result = smlDevInfNewResult(
get, agent->devinf, SML_DEVINF_VERSION_11, error);
224 smlCommandUnref(result);
228 smlCommandUnref(result);
230 SmlStatus *reply = smlCommandNewReply(
get, SML_NO_ERROR, error);
235 smlStatusUnref(reply);
239 smlStatusUnref(reply);
241 if (smlSessionGetVersion(session) == SML_VERSION_10)
242 cmd = smlDevInfNewPut(agent->devinf, SML_DEVINF_VERSION_10, error);
243 else if (smlSessionGetVersion(session) == SML_VERSION_12)
244 cmd = smlDevInfNewPut(agent->devinf, SML_DEVINF_VERSION_12, error);
246 cmd = smlDevInfNewPut(agent->devinf, SML_DEVINF_VERSION_11, error);
252 smlCommandUnref(cmd);
256 smlCommandUnref(cmd);
258 as->devinfSent = TRUE;
260 smlTrace(TRACE_INTERNAL,
"%s: Already sent the devinf!", __func__);
265 SmlStatus *reply = smlCommandNewReply(
get, SML_ERROR_GENERIC, error);
270 smlStatusUnref(reply);
274 smlStatusUnref(reply);
285 "%s: libsyncml does not send local device information twice.",
290 smlTrace(TRACE_EXIT,
"%s", __func__);
300 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, cmd, userdata);
304 unsigned int size = 0;
306 if (!
smlItemGetData(cmd->private.access.item, &data, &size, &error))
311 as = _new_session(agent, session, &error);
316 as->recvDevInf = smlDevInfParse(data, size, &error);
320 SmlStatus *reply = smlCommandNewReply(cmd, SML_NO_ERROR, &error);
325 smlStatusUnref(reply);
329 smlStatusUnref(reply);
331 smlTrace(TRACE_EXIT,
"%s", __func__);
335 smlSessionDispatchEvent(session, SML_SESSION_EVENT_ERROR, NULL, NULL, NULL, error);
337 smlErrorDeref(&error);
342 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, session, cmd, userdata);
346 if (!_send_devinf(agent, session, cmd, &error))
349 smlTrace(TRACE_EXIT,
"%s", __func__);
358 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, devinf, error);
366 agent->devinf = devinf;
367 agent->sessions = g_hash_table_new_full(NULL, NULL, NULL, _free_session);
368 if (!agent->sessions) {
369 smlErrorSet(error, SML_ERROR_INTERNAL_NO_MEMORY,
"Cannot create new hash table.");
373 if (!smlDevInfGetManufacturer(devinf))
374 smlDevInfSetManufacturer(devinf,
"OpenSync");
375 if (!smlDevInfGetModel(devinf))
376 smlDevInfSetModel(devinf,
"libsyncml");
377 if (!smlDevInfGetOEM(devinf))
380 smlDevInfSetOEM(devinf,
"Windows");
381 DWORD dwVersion = GetVersion();
382 DWORD dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
383 DWORD dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
385 if (dwVersion < 0x80000000) dwBuild = (DWORD)(HIWORD(dwVersion));
387 char szVersion[1024];
388 sprintf(szVersion,
"%d.%d (%d)", dwMajorVersion, dwMinorVersion, dwBuild);
389 smlDevInfSetFirmwareVersion(devinf, szVersion);
391 struct utsname *buf = malloc(
sizeof(
struct utsname));
394 smlDevInfSetOEM(devinf, buf->sysname);
395 smlDevInfSetFirmwareVersion(devinf, buf->release);
397 smlSafeFree((gpointer *)&buf);
400 if (!smlDevInfGetSoftwareVersion(devinf))
401 smlDevInfSetSoftwareVersion(devinf, VERSION);
403 smlTrace(TRACE_EXIT,
"%s: %p", __func__, agent);
408 smlSafeFree((gpointer *) &agent);
416 smlTrace(TRACE_ENTRY,
"%s(%p)", __func__, agent);
420 smlDevInfUnref(agent->devinf);
421 g_hash_table_destroy(agent->sessions);
422 smlSafeFree((gpointer *)&agent);
424 smlTrace(TRACE_EXIT,
"%s", __func__);
430 smlTrace(TRACE_ERROR,
"%s(%p, %p)", __func__, agent, devinf);
431 smlAssertMsg(NULL,
"This function is a design bug.");
437 smlTrace(TRACE_ERROR,
"%s(%p, %p)", __func__, agent);
438 smlAssertMsg(NULL,
"This function is a design bug.");
443 SmlBool smlDevInfAgentSetSessionDevInf(
449 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p)", __func__, agent, session, devinf, error);
453 smlAssert(agent->sessions);
459 as = _new_session(agent, session, error);
464 as->recvDevInf = devinf;
466 smlTrace(TRACE_EXIT,
"%s", __func__);
476 smlTrace(TRACE_ENTRY,
"%s(%p, %p)", __func__, agent, session);
479 smlAssert(agent->sessions);
485 smlTrace(TRACE_EXIT,
"%s - the session is not cached until now", __func__);
489 smlTrace(TRACE_EXIT,
"%s - %p", __func__, as->recvDevInf);
490 return as->recvDevInf;
496 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, agent, session, error);
500 if (!_send_devinf(agent, session, NULL, error))
503 smlTrace(TRACE_EXIT,
"%s", __func__);
514 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, agent, session, error);
521 as = _new_session(agent, session, error);
526 if (as->recvDevInf) {
527 smlTrace(TRACE_EXIT,
"%s: Already have the devinf", __func__);
531 if (!as->devinfRequested)
533 if (smlSessionGetVersion(session) == SML_VERSION_10)
534 get = smlDevInfNewGet(SML_DEVINF_VERSION_10, error);
535 else if (smlSessionGetVersion(session) == SML_VERSION_12)
536 get = smlDevInfNewGet(SML_DEVINF_VERSION_12, error);
538 get = smlDevInfNewGet(SML_DEVINF_VERSION_11, error);
544 smlCommandUnref(
get);
548 smlCommandUnref(
get);
550 as->devinfRequested = TRUE;
552 smlTrace(TRACE_INTERNAL,
"%s: Already requested the devinf!", __func__);
555 smlTrace(TRACE_EXIT,
"%s", __func__);
565 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p, %p)", __func__, agent, manager, session, error);
570 SmlLocation *devinf12 = smlLocationNew(
"./devinf12", NULL, error);
571 SmlLocation *devinf11 = smlLocationNew(
"./devinf11", NULL, error);
572 SmlLocation *devinf10 = smlLocationNew(
"./devinf10", NULL, error);
574 if (!devinf12 || !devinf11 || !devinf10)
598 smlTrace(TRACE_INTERNAL,
"%s: register callbacks for PUT command", __func__);
600 manager, SML_COMMAND_TYPE_PUT, session,
601 NULL, devinf10, NULL, _recv_devinf, NULL, agent,
605 manager, SML_COMMAND_TYPE_PUT, session,
606 NULL, devinf11, NULL, _recv_devinf, NULL, agent,
610 manager, SML_COMMAND_TYPE_PUT, session,
611 NULL, devinf12, NULL, _recv_devinf, NULL, agent,
635 smlTrace(TRACE_INTERNAL,
"%s: register callbacks for GET command", __func__);
637 manager, SML_COMMAND_TYPE_GET, session,
638 devinf10, NULL, NULL, _request_devinf, NULL, agent,
642 manager, SML_COMMAND_TYPE_GET, session,
643 devinf11, NULL, NULL, _request_devinf, NULL, agent,
647 manager, SML_COMMAND_TYPE_GET, session,
648 devinf12, NULL, NULL, _request_devinf, NULL, agent,
668 smlTrace(TRACE_INTERNAL,
"%s: register callbacks for RESULTS command", __func__);
670 manager, SML_COMMAND_TYPE_RESULTS, session,
671 devinf10, NULL, NULL, _recv_devinf, NULL, agent,
675 manager, SML_COMMAND_TYPE_RESULTS, session,
676 devinf11, NULL, NULL, _recv_devinf, NULL, agent,
680 manager, SML_COMMAND_TYPE_RESULTS, session,
681 devinf12, NULL, NULL, _recv_devinf, NULL, agent,
685 smlLocationUnref(devinf10);
686 smlLocationUnref(devinf11);
687 smlLocationUnref(devinf12);
689 smlTrace(TRACE_EXIT,
"%s", __func__);
694 smlLocationUnref(devinf10);
696 smlLocationUnref(devinf11);
698 smlLocationUnref(devinf12);
706 smlTrace(TRACE_ENTRY,
"%s(%p, %p, %p)", __func__, agent, manager, error);
709 SmlBool retval = smlDevInfAgentRegisterSession(agent, manager, NULL, error);
714 smlTrace(TRACE_EXIT,
"%s", __func__);
SmlBool smlDevInfAgentSendDevInf(SmlDevInfAgent *agent, SmlSession *session, SmlError **error)
SmlBool smlSessionSendReply(SmlSession *session, SmlStatus *status, SmlError **error)
Sends a reply to a command.
const char * smlErrorPrint(SmlError **error)
Returns the message of the error.
SmlBool smlSessionSendCommand(SmlSession *session, SmlCommand *cmd, SmlCommand *parent, SmlStatusReplyCb callback, void *userdata, SmlError **error)
Sends a command with a parent.
SmlBool smlItemGetData(SmlItem *item, char **data, unsigned int *size, SmlError **error)
void smlTrace(SmlTraceType type, const char *message,...)
Used for tracing the application.
SmlBool smlDevInfAgentRequestDevInf(SmlDevInfAgent *agent, SmlSession *session, SmlError **error)
SmlBool smlManagerObjectRegister(SmlManager *manager, SmlCommandType type, SmlSession *session, SmlLocation *location, SmlLocation *source, const char *contentType, SmlCommandCb callback, SmlCommandCb childCallback, void *userdata, SmlError **error)
Register an object with a session.
void * smlTryMalloc0(long n_bytes, SmlError **error)
Safely mallocs.
void smlErrorSet(SmlError **error, SmlErrorType type, const char *format,...)
Sets the error.