/** * @brief Optionally prints a trace of a D-Bus message depending on the "level". * * @param [in] level Trace mask controlling whether trace appears. * @param [in] msg The D-Bus message to trace. */ void l2dbus_traceMessage ( unsigned level, struct DBusMessage* msg ) { const cdbus_Char* msgTypeStr ="UNKNOWN"; cdbus_Int32 msgType = DBUS_MESSAGE_TYPE_INVALID; const cdbus_Char* path = NULL; const cdbus_Char* intf = NULL; const cdbus_Char* name = NULL; const cdbus_Char* dest = NULL; const cdbus_Char* errName = NULL; if ( NULL != msg ) { msgType = dbus_message_get_type(msg); msgTypeStr = dbus_message_type_to_string(msgType); if ( (DBUS_MESSAGE_TYPE_METHOD_CALL == msgType) || (DBUS_MESSAGE_TYPE_SIGNAL == msgType) ) { path = dbus_message_get_path(msg); intf = dbus_message_get_interface(msg); name = dbus_message_get_member(msg); l2dbus_trace(level, "(Ser=%u) [%s] <%s> %s%s%s", dbus_message_get_serial(msg), msgTypeStr, path ? path : "", intf ? intf : "", intf ? "." : "", name ? name : ""); } else if (DBUS_MESSAGE_TYPE_METHOD_RETURN == msgType) { dest = dbus_message_get_destination(msg); l2dbus_trace(level, "(RSer=%u) [%s] -> %s", dbus_message_get_reply_serial(msg), msgTypeStr, dest ? dest : ""); } else if (DBUS_MESSAGE_TYPE_ERROR == msgType ) { errName = dbus_message_get_error_name(msg); l2dbus_trace(level, "(RSer=%u) [%s] %s", dbus_message_get_reply_serial(msg), msgTypeStr, errName ? errName : ""); } else { l2dbus_trace(level, "(Ser=%u) [%s]", dbus_message_get_serial(msg), msgTypeStr); } } }
PendingCall StubBase::send_request(const char* method_name, std::function<void(DBusMessageIter&)>&& f, bool is_oneway) { message_ptr_t msg = make_message(dbus_message_new_method_call(busname().c_str(), objectpath(), iface(), method_name)); DBusPendingCall* pending = nullptr; DBusMessageIter iter; dbus_message_iter_init_append(msg.get(), &iter); f(iter); if (!is_oneway) { int timeout = disp().request_timeout(); if (detail::request_specific_timeout.count() > 0) timeout = detail::request_specific_timeout.count(); dbus_connection_send_with_reply(disp().conn_, msg.get(), &pending, timeout); } else { // otherwise server would stop reading requests after a while dbus_message_set_no_reply(msg.get(), TRUE); dbus_connection_send(disp().conn_, msg.get(), nullptr); dbus_connection_flush(disp().conn_); } detail::request_specific_timeout = std::chrono::milliseconds(0); return PendingCall(dbus_message_get_serial(msg.get()), pending); }
static int ldbus_message_get_serial(lua_State *L) { DBusMessage *message = check_DBusMessage(L, 1); lua_pushinteger(L, dbus_message_get_serial(message)); return 1; }
static void profile_print_with_attrs (const char *type, DBusMessage *message, struct timeval *t, ProfileAttributeFlags attrs) { printf (PROFILE_TIMED_FORMAT, type, t->tv_sec, t->tv_usec); if (attrs & PROFILE_ATTRIBUTE_FLAG_SERIAL) printf ("\t%u", dbus_message_get_serial (message)); if (attrs & PROFILE_ATTRIBUTE_FLAG_REPLY_SERIAL) printf ("\t%u", dbus_message_get_reply_serial (message)); if (attrs & PROFILE_ATTRIBUTE_FLAG_SENDER) printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_sender (message))); if (attrs & PROFILE_ATTRIBUTE_FLAG_DESTINATION) printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_destination (message))); if (attrs & PROFILE_ATTRIBUTE_FLAG_PATH) printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_path (message))); if (attrs & PROFILE_ATTRIBUTE_FLAG_INTERFACE) printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_interface (message))); if (attrs & PROFILE_ATTRIBUTE_FLAG_MEMBER) printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_member (message))); if (attrs & PROFILE_ATTRIBUTE_FLAG_ERROR_NAME) printf ("\t%s", TRAP_NULL_STRING (dbus_message_get_error_name (message))); printf ("\n"); }
static DBusHandlerResult default_message_filter ( DBusConnection *connection, DBusMessage *message, void *p ) { DBusConnectionState *cs = p; uint32_t type =dbus_message_get_type( message ), serial =dbus_message_get_serial( message ); uint8_t reply =dbus_message_get_no_reply( message )==0; const char *path = dbus_message_get_path( message ), *dest = dbus_message_get_destination( message ), *member = dbus_message_get_member( message ), *interface=dbus_message_get_interface( message ), *sender =dbus_message_get_sender( message ), *signature=dbus_message_get_signature( message ); connection = connection; if(cs->mf) return (*(cs->mf))( cs, type, reply, serial, dest, path, member, interface, 0L, sender, signature, message, 0L, 0L, 0L, cs->def_mf_obj ) ; return HANDLED; }
guint whiteboard_cmd_response_get_serial(WhiteBoardCmdResponse* self) { g_return_val_if_fail(self != NULL, 0); g_return_val_if_fail(self->msg != NULL, 0); return dbus_message_get_serial(self->msg); }
static int DBus_EventHandler(Tcl_Event *evPtr, int flags) { Tcl_DBusEvent *ev; DBusMessageIter iter; Tcl_Obj *script, *result; int rc; if (!(flags & TCL_IDLE_EVENTS)) return 0; ev = (Tcl_DBusEvent *) evPtr; script = ev->script; if (Tcl_IsShared(script)) script = Tcl_DuplicateObj(script); Tcl_ListObjAppendElement(ev->interp, script, DBus_MessageInfo(ev->interp, ev->msg)); /* read the parameters and append to the script */ if (dbus_message_iter_init(ev->msg, &iter)) { Tcl_ListObjAppendList(ev->interp, script, DBus_IterList(ev->interp, &iter, (ev->flags & DBUSFLAG_DETAILS) != 0)); } /* Excute the constructed Tcl command */ rc = Tcl_EvalObjEx(ev->interp, script, TCL_EVAL_GLOBAL); if (rc != TCL_ERROR) { /* Report success only if noreply == 0 and async == 0 */ if (!(ev->flags & DBUSFLAG_NOREPLY) && !(ev->flags & DBUSFLAG_ASYNC)) { /* read the parameters and append to the script */; result = Tcl_GetObjResult(ev->interp); DBus_SendMessage(ev->interp, ev->conn, DBUS_MESSAGE_TYPE_METHOD_RETURN, NULL, NULL, NULL, dbus_message_get_sender(ev->msg), dbus_message_get_serial(ev->msg), NULL, 1, &result); } } else { /* Always report failures if noreply == 0 */ if (!(ev->flags & DBUSFLAG_NOREPLY)) { result = Tcl_GetObjResult(ev->interp); DBus_Error(ev->interp, ev->conn, NULL, dbus_message_get_sender(ev->msg), dbus_message_get_serial(ev->msg), Tcl_GetString(result)); } } dbus_message_unref(ev->msg); Tcl_DecrRefCount(ev->script); /* The event structure will be cleaned up by Tcl_ServiceEvent */ return 1; }
void print_message (DBusMessage *message, dbus_bool_t literal) { DBusMessageIter iter; const char *sender; const char *destination; int message_type; message_type = dbus_message_get_type (message); sender = dbus_message_get_sender (message); destination = dbus_message_get_destination (message); if (!literal) { printf ("%s sender=%s -> dest=%s", type_to_name (message_type), sender ? sender : "(null sender)", destination ? destination : "(null destination)"); switch (message_type) { case DBUS_MESSAGE_TYPE_METHOD_CALL: case DBUS_MESSAGE_TYPE_SIGNAL: printf (" serial=%u path=%s; interface=%s; member=%s\n", dbus_message_get_serial (message), dbus_message_get_path (message), dbus_message_get_interface (message), dbus_message_get_member (message)); break; case DBUS_MESSAGE_TYPE_METHOD_RETURN: printf (" reply_serial=%u\n", dbus_message_get_reply_serial (message)); break; case DBUS_MESSAGE_TYPE_ERROR: printf (" error_name=%s reply_serial=%u\n", dbus_message_get_error_name (message), dbus_message_get_reply_serial (message)); break; default: printf ("\n"); break; } } dbus_message_iter_init (message, &iter); print_iter (&iter, literal, 1); fflush (stdout); }
static Eldbus_Message * _eldbus_message_error_get(const Eldbus_Message *msg, const char *error_name, const char *error_msg) { int32_t serial; serial = dbus_message_get_serial(msg->dbus_msg); if (serial == 0) { return NULL; } return eldbus_message_error_new(msg, error_name, error_msg); }
PendingCall StubBase::get_property_async(const char* name) { message_ptr_t msg = make_message(dbus_message_new_method_call(busname().c_str(), objectpath(), "org.freedesktop.DBus.Properties", "Get")); DBusPendingCall* pending = nullptr; DBusMessageIter iter; dbus_message_iter_init_append(msg.get(), &iter); encode(iter, iface(), name); dbus_connection_send_with_reply(conn(), msg.get(), &pending, DBUS_TIMEOUT_USE_DEFAULT); return PendingCall(dbus_message_get_serial(msg.get()), pending); }
PendingCall StubBase::set_property_async(const char* name, std::function<void(DBusMessageIter&)>&& f) { message_ptr_t msg = make_message(dbus_message_new_method_call(busname().c_str(), objectpath(), "org.freedesktop.DBus.Properties", "Set")); DBusMessageIter iter; dbus_message_iter_init_append(msg.get(), &iter); encode(iter, iface(), name); f(iter); // and now serialize the variant DBusPendingCall* pending = nullptr; dbus_connection_send_with_reply(disp().conn_, msg.get(), &pending, DBUS_TIMEOUT_USE_DEFAULT); return PendingCall(dbus_message_get_serial(msg.get()), pending); }
static DBusHandlerResult handle_message(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct dbusif *dbusif = (struct dbusif *)user_data; struct tonegend *tonegend = dbusif->tonegend; DBusMessage *reply = NULL; uint32_t ser; int (*method)(DBusMessage *, struct tonegend *); const char *intf; const char *memb; const char *sig; gchar *key; const char *errname; char errdesc[256]; int success; (void)conn; if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_METHOD_CALL) TRACE("%s(): ignoring non method_call's", __FUNCTION__); else { intf = dbus_message_get_interface(msg); memb = dbus_message_get_member(msg); sig = dbus_message_get_signature(msg); ser = dbus_message_get_serial(msg); #if 0 TRACE("%s(): message no #%u received: '%s', '%s', '%s'", __FUNCTION__, ser, intf, memb, sig); #endif key = create_key((gchar *)memb, (gchar *)sig, (gchar *)intf); method = g_hash_table_lookup(dbusif->hash, key); g_free(key); success = method ? method(msg, tonegend) : FALSE; if (success) reply = dbus_message_new_method_return(msg); else { if (method) { errname = DBUS_ERROR_FAILED; snprintf(errdesc, sizeof(errdesc), "Internal error"); } else { errname = DBUS_ERROR_NOT_SUPPORTED; snprintf(errdesc, sizeof(errdesc), "Method '%s(%s)' " "not supported", memb, sig); } reply = dbus_message_new_error(msg, errname, errdesc); } dbus_message_set_reply_serial(msg, ser); if (!dbus_connection_send(dbusif->conn, reply, NULL)) LOG_ERROR("%s(): D-Bus message reply failure", __FUNCTION__); #if 0 else TRACE("%s(): message no #%u replied", __FUNCTION__, ser); #endif dbus_message_unref(reply); } return DBUS_HANDLER_RESULT_HANDLED; }
/** * @ingroup DBusMessageInternals * Unit test for DBusMessage. * * @returns #TRUE on success. */ dbus_bool_t _dbus_message_test (const char *test_data_dir) { DBusMessage *message, *message_without_unix_fds; DBusMessageLoader *loader; int i; const char *data; DBusMessage *copy; const char *name1; const char *name2; const dbus_uint32_t our_uint32_array[] = { 0x12345678, 0x23456781, 0x34567812, 0x45678123 }; const dbus_int32_t our_int32_array[] = { 0x12345678, -0x23456781, 0x34567812, -0x45678123 }; const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array; const dbus_int32_t *v_ARRAY_INT32 = our_int32_array; #ifdef DBUS_HAVE_INT64 const dbus_uint64_t our_uint64_array[] = { 0x12345678, 0x23456781, 0x34567812, 0x45678123 }; const dbus_int64_t our_int64_array[] = { 0x12345678, -0x23456781, 0x34567812, -0x45678123 }; const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array; const dbus_int64_t *v_ARRAY_INT64 = our_int64_array; #endif const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" }; const char **v_ARRAY_STRING = our_string_array; const double our_double_array[] = { 0.1234, 9876.54321, -300.0 }; const double *v_ARRAY_DOUBLE = our_double_array; const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 }; const unsigned char *v_ARRAY_BYTE = our_byte_array; const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE }; const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array; char sig[64]; const char *s; const char *v_STRING; double v_DOUBLE; dbus_int16_t v_INT16; dbus_uint16_t v_UINT16; dbus_int32_t v_INT32; dbus_uint32_t v_UINT32; #ifdef DBUS_HAVE_INT64 dbus_int64_t v_INT64; dbus_uint64_t v_UINT64; #endif unsigned char v_BYTE; unsigned char v2_BYTE; dbus_bool_t v_BOOLEAN; DBusMessageIter iter, array_iter, struct_iter; #ifdef HAVE_UNIX_FD_PASSING int v_UNIX_FD; #endif char **decomposed; message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", "/org/freedesktop/TestPath", "Foo.TestInterface", "TestMethod"); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface", "TestMethod")); _dbus_assert (strcmp (dbus_message_get_path (message), "/org/freedesktop/TestPath") == 0); dbus_message_set_serial (message, 1234); /* string length including nul byte not a multiple of 4 */ if (!dbus_message_set_sender (message, "org.foo.bar1")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (dbus_message_has_sender (message, "org.foo.bar1")); dbus_message_set_reply_serial (message, 5678); _dbus_verbose_bytes_of_string (&message->header.data, 0, _dbus_string_get_length (&message->header.data)); _dbus_verbose_bytes_of_string (&message->body, 0, _dbus_string_get_length (&message->body)); if (!dbus_message_set_sender (message, NULL)) _dbus_assert_not_reached ("out of memory"); _dbus_verbose_bytes_of_string (&message->header.data, 0, _dbus_string_get_length (&message->header.data)); _dbus_verbose_bytes_of_string (&message->body, 0, _dbus_string_get_length (&message->body)); _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1")); _dbus_assert (dbus_message_get_serial (message) == 1234); _dbus_assert (dbus_message_get_reply_serial (message) == 5678); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); _dbus_assert (dbus_message_get_no_reply (message) == FALSE); dbus_message_set_no_reply (message, TRUE); _dbus_assert (dbus_message_get_no_reply (message) == TRUE); dbus_message_set_no_reply (message, FALSE); _dbus_assert (dbus_message_get_no_reply (message) == FALSE); /* Set/get some header fields */ if (!dbus_message_set_path (message, "/foo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_path (message), "/foo") == 0); if (!dbus_message_set_interface (message, "org.Foo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_interface (message), "org.Foo") == 0); if (!dbus_message_set_member (message, "Bar")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_member (message), "Bar") == 0); /* Set/get them with longer values */ if (!dbus_message_set_path (message, "/foo/bar")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_path (message), "/foo/bar") == 0); if (!dbus_message_set_interface (message, "org.Foo.Bar")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_interface (message), "org.Foo.Bar") == 0); if (!dbus_message_set_member (message, "BarFoo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_member (message), "BarFoo") == 0); /* Realloc shorter again */ if (!dbus_message_set_path (message, "/foo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_path (message), "/foo") == 0); if (!dbus_message_set_interface (message, "org.Foo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_interface (message), "org.Foo") == 0); if (!dbus_message_set_member (message, "Bar")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_member (message), "Bar") == 0); /* Path decomposing */ dbus_message_set_path (message, NULL); dbus_message_get_path_decomposed (message, &decomposed); _dbus_assert (decomposed == NULL); dbus_free_string_array (decomposed); dbus_message_set_path (message, "/"); dbus_message_get_path_decomposed (message, &decomposed); _dbus_assert (decomposed != NULL); _dbus_assert (decomposed[0] == NULL); dbus_free_string_array (decomposed); dbus_message_set_path (message, "/a/b"); dbus_message_get_path_decomposed (message, &decomposed); _dbus_assert (decomposed != NULL); _dbus_assert (strcmp (decomposed[0], "a") == 0); _dbus_assert (strcmp (decomposed[1], "b") == 0); _dbus_assert (decomposed[2] == NULL); dbus_free_string_array (decomposed); dbus_message_set_path (message, "/spam/eggs"); dbus_message_get_path_decomposed (message, &decomposed); _dbus_assert (decomposed != NULL); _dbus_assert (strcmp (decomposed[0], "spam") == 0); _dbus_assert (strcmp (decomposed[1], "eggs") == 0); _dbus_assert (decomposed[2] == NULL); dbus_free_string_array (decomposed); dbus_message_unref (message); /* Test the vararg functions */ message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", "/org/freedesktop/TestPath", "Foo.TestInterface", "TestMethod"); dbus_message_set_serial (message, 1); dbus_message_set_reply_serial (message, 5678); v_INT16 = -0x123; v_UINT16 = 0x123; v_INT32 = -0x12345678; v_UINT32 = 0x12300042; #ifdef DBUS_HAVE_INT64 v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd); v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd); #endif v_STRING = "Test string"; v_DOUBLE = 3.14159; v_BOOLEAN = TRUE; v_BYTE = 42; v2_BYTE = 24; #ifdef HAVE_UNIX_FD_PASSING v_UNIX_FD = 1; #endif dbus_message_append_args (message, DBUS_TYPE_INT16, &v_INT16, DBUS_TYPE_UINT16, &v_UINT16, DBUS_TYPE_INT32, &v_INT32, DBUS_TYPE_UINT32, &v_UINT32, #ifdef DBUS_HAVE_INT64 DBUS_TYPE_INT64, &v_INT64, DBUS_TYPE_UINT64, &v_UINT64, #endif DBUS_TYPE_STRING, &v_STRING, DBUS_TYPE_DOUBLE, &v_DOUBLE, DBUS_TYPE_BOOLEAN, &v_BOOLEAN, DBUS_TYPE_BYTE, &v_BYTE, DBUS_TYPE_BYTE, &v2_BYTE, DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32, _DBUS_N_ELEMENTS (our_uint32_array), DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32, _DBUS_N_ELEMENTS (our_int32_array), #ifdef DBUS_HAVE_INT64 DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64, _DBUS_N_ELEMENTS (our_uint64_array), DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64, _DBUS_N_ELEMENTS (our_int64_array), #endif DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE, _DBUS_N_ELEMENTS (our_double_array), DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE, _DBUS_N_ELEMENTS (our_byte_array), DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN, _DBUS_N_ELEMENTS (our_boolean_array), DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING, _DBUS_N_ELEMENTS (our_string_array), DBUS_TYPE_INVALID); i = 0; sig[i++] = DBUS_TYPE_INT16; sig[i++] = DBUS_TYPE_UINT16; sig[i++] = DBUS_TYPE_INT32; sig[i++] = DBUS_TYPE_UINT32; #ifdef DBUS_HAVE_INT64 sig[i++] = DBUS_TYPE_INT64; sig[i++] = DBUS_TYPE_UINT64; #endif sig[i++] = DBUS_TYPE_STRING; sig[i++] = DBUS_TYPE_DOUBLE; sig[i++] = DBUS_TYPE_BOOLEAN; sig[i++] = DBUS_TYPE_BYTE; sig[i++] = DBUS_TYPE_BYTE; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_UINT32; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_INT32; #ifdef DBUS_HAVE_INT64 sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_UINT64; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_INT64; #endif sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_DOUBLE; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_BYTE; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_BOOLEAN; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_STRING; message_without_unix_fds = dbus_message_copy(message); _dbus_assert(message_without_unix_fds); #ifdef HAVE_UNIX_FD_PASSING dbus_message_append_args (message, DBUS_TYPE_UNIX_FD, &v_UNIX_FD, DBUS_TYPE_INVALID); sig[i++] = DBUS_TYPE_UNIX_FD; #endif sig[i++] = DBUS_TYPE_INVALID; _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig)); _dbus_verbose ("HEADER\n"); _dbus_verbose_bytes_of_string (&message->header.data, 0, _dbus_string_get_length (&message->header.data)); _dbus_verbose ("BODY\n"); _dbus_verbose_bytes_of_string (&message->body, 0, _dbus_string_get_length (&message->body)); _dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n", sig, dbus_message_get_signature (message)); s = dbus_message_get_signature (message); _dbus_assert (dbus_message_has_signature (message, sig)); _dbus_assert (strcmp (s, sig) == 0); verify_test_message (message); copy = dbus_message_copy (message); _dbus_assert (dbus_message_get_reply_serial (message) == dbus_message_get_reply_serial (copy)); _dbus_assert (message->header.padding == copy->header.padding); _dbus_assert (_dbus_string_get_length (&message->header.data) == _dbus_string_get_length (©->header.data)); _dbus_assert (_dbus_string_get_length (&message->body) == _dbus_string_get_length (©->body)); verify_test_message (copy); name1 = dbus_message_get_interface (message); name2 = dbus_message_get_interface (copy); _dbus_assert (strcmp (name1, name2) == 0); name1 = dbus_message_get_member (message); name2 = dbus_message_get_member (copy); _dbus_assert (strcmp (name1, name2) == 0); dbus_message_unref (copy); /* Message loader test */ dbus_message_lock (message); loader = _dbus_message_loader_new (); /* check ref/unref */ _dbus_message_loader_ref (loader); _dbus_message_loader_unref (loader); /* Write the header data one byte at a time */ data = _dbus_string_get_const_data (&message->header.data); for (i = 0; i < _dbus_string_get_length (&message->header.data); i++) { DBusString *buffer; _dbus_message_loader_get_buffer (loader, &buffer); _dbus_string_append_byte (buffer, data[i]); _dbus_message_loader_return_buffer (loader, buffer, 1); } /* Write the body data one byte at a time */ data = _dbus_string_get_const_data (&message->body); for (i = 0; i < _dbus_string_get_length (&message->body); i++) { DBusString *buffer; _dbus_message_loader_get_buffer (loader, &buffer); _dbus_string_append_byte (buffer, data[i]); _dbus_message_loader_return_buffer (loader, buffer, 1); } #ifdef HAVE_UNIX_FD_PASSING { int *unix_fds; unsigned n_unix_fds; /* Write unix fd */ _dbus_message_loader_get_unix_fds(loader, &unix_fds, &n_unix_fds); _dbus_assert(n_unix_fds > 0); _dbus_assert(message->n_unix_fds == 1); unix_fds[0] = _dbus_dup(message->unix_fds[0], NULL); _dbus_assert(unix_fds[0] >= 0); _dbus_message_loader_return_unix_fds(loader, unix_fds, 1); } #endif dbus_message_unref (message); /* Now pop back the message */ if (!_dbus_message_loader_queue_messages (loader)) _dbus_assert_not_reached ("no memory to queue messages"); if (_dbus_message_loader_get_is_corrupted (loader)) _dbus_assert_not_reached ("message loader corrupted"); message = _dbus_message_loader_pop_message (loader); if (!message) _dbus_assert_not_reached ("received a NULL message"); if (dbus_message_get_reply_serial (message) != 5678) _dbus_assert_not_reached ("reply serial fields differ"); dbus_message_unref (message); /* ovveride the serial, since it was reset by dbus_message_copy() */ dbus_message_set_serial(message_without_unix_fds, 8901); dbus_message_lock (message_without_unix_fds); verify_test_message (message_without_unix_fds); { /* Marshal and demarshal the message. */ DBusMessage *message2; DBusError error = DBUS_ERROR_INIT; char *marshalled = NULL; int len = 0; char garbage_header[DBUS_MINIMUM_HEADER_SIZE] = "xxx"; if (!dbus_message_marshal (message_without_unix_fds, &marshalled, &len)) _dbus_assert_not_reached ("failed to marshal message"); _dbus_assert (len != 0); _dbus_assert (marshalled != NULL); _dbus_assert (dbus_message_demarshal_bytes_needed (marshalled, len) == len); message2 = dbus_message_demarshal (marshalled, len, &error); _dbus_assert (message2 != NULL); _dbus_assert (!dbus_error_is_set (&error)); verify_test_message (message2); dbus_message_unref (message2); dbus_free (marshalled); /* Demarshal invalid message. */ message2 = dbus_message_demarshal ("invalid", 7, &error); _dbus_assert (message2 == NULL); _dbus_assert (dbus_error_is_set (&error)); dbus_error_free (&error); /* Demarshal invalid (empty) message. */ message2 = dbus_message_demarshal ("", 0, &error); _dbus_assert (message2 == NULL); _dbus_assert (dbus_error_is_set (&error)); dbus_error_free (&error); /* Bytes needed to demarshal empty message: 0 (more) */ _dbus_assert (dbus_message_demarshal_bytes_needed ("", 0) == 0); /* Bytes needed to demarshal invalid message: -1 (error). */ _dbus_assert (dbus_message_demarshal_bytes_needed (garbage_header, DBUS_MINIMUM_HEADER_SIZE) == -1); } dbus_message_unref (message_without_unix_fds); _dbus_message_loader_unref (loader); check_memleaks (); _dbus_check_fdleaks(); /* Check that we can abandon a container */ message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", "/org/freedesktop/TestPath", "Foo.TestInterface", "Method"); dbus_message_iter_init_append (message, &iter); _dbus_assert (dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, (DBUS_STRUCT_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_STRUCT_END_CHAR_AS_STRING), &array_iter)); _dbus_assert (dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter)); s = "peaches"; _dbus_assert (dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING, &s)); /* uh-oh, error, try and unwind */ dbus_message_iter_abandon_container (&array_iter, &struct_iter); dbus_message_iter_abandon_container (&array_iter, &iter); dbus_message_unref (message); /* Load all the sample messages from the message factory */ { DBusMessageDataIter diter; DBusMessageData mdata; int count; reset_validities_seen (); count = 0; _dbus_message_data_iter_init (&diter); while (_dbus_message_data_iter_get_and_next (&diter, &mdata)) { if (!dbus_internal_do_not_use_try_message_data (&mdata.data, mdata.expected_validity)) { _dbus_warn ("expected validity %d and did not get it\n", mdata.expected_validity); _dbus_assert_not_reached ("message data failed"); } _dbus_message_data_free (&mdata); count += 1; } printf ("%d sample messages tested\n", count); print_validities_seen (FALSE); print_validities_seen (TRUE); } check_memleaks (); _dbus_check_fdleaks(); /* Now load every message in test_data_dir if we have one */ if (test_data_dir == NULL) return TRUE; return dbus_internal_do_not_use_foreach_message_file (test_data_dir, (DBusForeachMessageFileFunc) dbus_internal_do_not_use_try_message_file, NULL); }
/* returns an error message or NULL */ static DBusMessage * invoke_js_async_from_dbus(SeedContext ctx, DBusBusType bus_type, DBusMessage *method_call, SeedObject this_obj, SeedObject method_obj, SeedException *exception) { DBusMessage *reply; int argc; SeedValue *argv; DBusMessageIter arg_iter; GArray *values; SeedObject callback_object; SeedValue sender_string, signature_string; gboolean thrown; SeedValue ignored; const char *signature; reply = NULL; thrown = FALSE; argc = 0; argv = NULL; if (!seed_js_values_from_dbus(ctx, &arg_iter, &values, exception)) { if (!dbus_reply_from_exception(ctx, method_call, &reply, exception)) g_warning ("conversion of dbus method arg failed but no exception was set?"); return reply; } /* we will add an argument, the callback */ callback_object = seed_make_function(ctx, async_call_callback, "" /* anonymous */); g_assert(callback_object); g_array_append_val(values, callback_object); /* We attach the DBus sender and serial as properties to * callback, so we don't need to bother with memory managing them * if the callback is never called and just discarded.*/ sender_string = seed_value_from_string (ctx, dbus_message_get_sender (method_call), exception); if (!sender_string) { thrown = TRUE; goto out; } seed_object_set_property (ctx, callback_object, "_dbusSender", sender_string); seed_object_set_property (ctx, callback_object, "_dbusSerial", seed_value_from_int (ctx, dbus_message_get_serial (method_call), exception)); seed_object_set_property (ctx, callback_object, "_dbusBusType", seed_value_from_int (ctx, bus_type, exception)); if (!signature_from_method(ctx, method_obj, &signature, exception)) { thrown = TRUE; goto out; } signature_string = seed_value_from_string (ctx, signature, exception); if (!signature_string) { thrown = TRUE; goto out; } seed_object_set_property (ctx, callback_object, "_dbusOutSignature", signature_string); argc = values->len; argv = (SeedValue *)values->data; seed_object_call (ctx, method_obj, this_obj, argc, argv, &ignored); out: if (thrown) { if (!dbus_reply_from_exception(ctx, method_call, &reply, exception)) g_warning("conversion of dbus method arg failed but no exception was set?"); } g_array_free (values, TRUE); return reply; }
/*! Returns the unique serial number assigned to this message or 0 if the message was not sent yet. */ int QDBusMessage::serialNumber() const { if (!d->msg) return 0; return dbus_message_get_serial(d->msg); }
/** * @ingroup DBusMessageInternals * Unit test for DBusMessage. * * @returns #TRUE on success. */ dbus_bool_t _dbus_message_test (const char *test_data_dir) { DBusMessage *message; DBusMessageLoader *loader; int i; const char *data; DBusMessage *copy; const char *name1; const char *name2; const dbus_uint32_t our_uint32_array[] = { 0x12345678, 0x23456781, 0x34567812, 0x45678123 }; const dbus_int32_t our_int32_array[] = { 0x12345678, -0x23456781, 0x34567812, -0x45678123 }; const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array; const dbus_int32_t *v_ARRAY_INT32 = our_int32_array; #ifdef DBUS_HAVE_INT64 const dbus_uint64_t our_uint64_array[] = { 0x12345678, 0x23456781, 0x34567812, 0x45678123 }; const dbus_int64_t our_int64_array[] = { 0x12345678, -0x23456781, 0x34567812, -0x45678123 }; const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array; const dbus_int64_t *v_ARRAY_INT64 = our_int64_array; #endif const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" }; const char **v_ARRAY_STRING = our_string_array; const double our_double_array[] = { 0.1234, 9876.54321, -300.0 }; const double *v_ARRAY_DOUBLE = our_double_array; const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 }; const unsigned char *v_ARRAY_BYTE = our_byte_array; const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE }; const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array; char sig[64]; const char *s; const char *v_STRING; double v_DOUBLE; dbus_int16_t v_INT16; dbus_uint16_t v_UINT16; dbus_int32_t v_INT32; dbus_uint32_t v_UINT32; #ifdef DBUS_HAVE_INT64 dbus_int64_t v_INT64; dbus_uint64_t v_UINT64; #endif unsigned char v_BYTE; unsigned char v2_BYTE; dbus_bool_t v_BOOLEAN; message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", "/org/freedesktop/TestPath", "Foo.TestInterface", "TestMethod"); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); _dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface", "TestMethod")); _dbus_assert (strcmp (dbus_message_get_path (message), "/org/freedesktop/TestPath") == 0); _dbus_message_set_serial (message, 1234); /* string length including nul byte not a multiple of 4 */ if (!dbus_message_set_sender (message, "org.foo.bar1")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (dbus_message_has_sender (message, "org.foo.bar1")); dbus_message_set_reply_serial (message, 5678); _dbus_verbose_bytes_of_string (&message->header.data, 0, _dbus_string_get_length (&message->header.data)); _dbus_verbose_bytes_of_string (&message->body, 0, _dbus_string_get_length (&message->body)); if (!dbus_message_set_sender (message, NULL)) _dbus_assert_not_reached ("out of memory"); _dbus_verbose_bytes_of_string (&message->header.data, 0, _dbus_string_get_length (&message->header.data)); _dbus_verbose_bytes_of_string (&message->body, 0, _dbus_string_get_length (&message->body)); _dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1")); _dbus_assert (dbus_message_get_serial (message) == 1234); _dbus_assert (dbus_message_get_reply_serial (message) == 5678); _dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService")); _dbus_assert (dbus_message_get_no_reply (message) == FALSE); dbus_message_set_no_reply (message, TRUE); _dbus_assert (dbus_message_get_no_reply (message) == TRUE); dbus_message_set_no_reply (message, FALSE); _dbus_assert (dbus_message_get_no_reply (message) == FALSE); /* Set/get some header fields */ if (!dbus_message_set_path (message, "/foo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_path (message), "/foo") == 0); if (!dbus_message_set_interface (message, "org.Foo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_interface (message), "org.Foo") == 0); if (!dbus_message_set_member (message, "Bar")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_member (message), "Bar") == 0); /* Set/get them with longer values */ if (!dbus_message_set_path (message, "/foo/bar")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_path (message), "/foo/bar") == 0); if (!dbus_message_set_interface (message, "org.Foo.Bar")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_interface (message), "org.Foo.Bar") == 0); if (!dbus_message_set_member (message, "BarFoo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_member (message), "BarFoo") == 0); /* Realloc shorter again */ if (!dbus_message_set_path (message, "/foo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_path (message), "/foo") == 0); if (!dbus_message_set_interface (message, "org.Foo")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_interface (message), "org.Foo") == 0); if (!dbus_message_set_member (message, "Bar")) _dbus_assert_not_reached ("out of memory"); _dbus_assert (strcmp (dbus_message_get_member (message), "Bar") == 0); dbus_message_unref (message); /* Test the vararg functions */ message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", "/org/freedesktop/TestPath", "Foo.TestInterface", "TestMethod"); _dbus_message_set_serial (message, 1); dbus_message_set_reply_serial (message, 5678); v_INT16 = -0x123; v_UINT16 = 0x123; v_INT32 = -0x12345678; v_UINT32 = 0x12300042; #ifdef DBUS_HAVE_INT64 v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd); v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd); #endif v_STRING = "Test string"; v_DOUBLE = 3.14159; v_BOOLEAN = TRUE; v_BYTE = 42; v2_BYTE = 24; dbus_message_append_args (message, DBUS_TYPE_INT16, &v_INT16, DBUS_TYPE_UINT16, &v_UINT16, DBUS_TYPE_INT32, &v_INT32, DBUS_TYPE_UINT32, &v_UINT32, #ifdef DBUS_HAVE_INT64 DBUS_TYPE_INT64, &v_INT64, DBUS_TYPE_UINT64, &v_UINT64, #endif DBUS_TYPE_STRING, &v_STRING, DBUS_TYPE_DOUBLE, &v_DOUBLE, DBUS_TYPE_BOOLEAN, &v_BOOLEAN, DBUS_TYPE_BYTE, &v_BYTE, DBUS_TYPE_BYTE, &v2_BYTE, DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32, _DBUS_N_ELEMENTS (our_uint32_array), DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32, _DBUS_N_ELEMENTS (our_int32_array), #ifdef DBUS_HAVE_INT64 DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64, _DBUS_N_ELEMENTS (our_uint64_array), DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64, _DBUS_N_ELEMENTS (our_int64_array), #endif DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE, _DBUS_N_ELEMENTS (our_double_array), DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE, _DBUS_N_ELEMENTS (our_byte_array), DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN, _DBUS_N_ELEMENTS (our_boolean_array), DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING, _DBUS_N_ELEMENTS (our_string_array), DBUS_TYPE_INVALID); i = 0; sig[i++] = DBUS_TYPE_INT16; sig[i++] = DBUS_TYPE_UINT16; sig[i++] = DBUS_TYPE_INT32; sig[i++] = DBUS_TYPE_UINT32; #ifdef DBUS_HAVE_INT64 sig[i++] = DBUS_TYPE_INT64; sig[i++] = DBUS_TYPE_UINT64; #endif sig[i++] = DBUS_TYPE_STRING; sig[i++] = DBUS_TYPE_DOUBLE; sig[i++] = DBUS_TYPE_BOOLEAN; sig[i++] = DBUS_TYPE_BYTE; sig[i++] = DBUS_TYPE_BYTE; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_UINT32; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_INT32; #ifdef DBUS_HAVE_INT64 sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_UINT64; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_INT64; #endif sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_DOUBLE; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_BYTE; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_BOOLEAN; sig[i++] = DBUS_TYPE_ARRAY; sig[i++] = DBUS_TYPE_STRING; sig[i++] = DBUS_TYPE_INVALID; _dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig)); _dbus_verbose ("HEADER\n"); _dbus_verbose_bytes_of_string (&message->header.data, 0, _dbus_string_get_length (&message->header.data)); _dbus_verbose ("BODY\n"); _dbus_verbose_bytes_of_string (&message->body, 0, _dbus_string_get_length (&message->body)); _dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n", sig, dbus_message_get_signature (message)); s = dbus_message_get_signature (message); _dbus_assert (dbus_message_has_signature (message, sig)); _dbus_assert (strcmp (s, sig) == 0); verify_test_message (message); copy = dbus_message_copy (message); _dbus_assert (dbus_message_get_reply_serial (message) == dbus_message_get_reply_serial (copy)); _dbus_assert (message->header.padding == copy->header.padding); _dbus_assert (_dbus_string_get_length (&message->header.data) == _dbus_string_get_length (©->header.data)); _dbus_assert (_dbus_string_get_length (&message->body) == _dbus_string_get_length (©->body)); verify_test_message (copy); name1 = dbus_message_get_interface (message); name2 = dbus_message_get_interface (copy); _dbus_assert (strcmp (name1, name2) == 0); name1 = dbus_message_get_member (message); name2 = dbus_message_get_member (copy); _dbus_assert (strcmp (name1, name2) == 0); dbus_message_unref (copy); /* Message loader test */ _dbus_message_lock (message); loader = _dbus_message_loader_new (); /* check ref/unref */ _dbus_message_loader_ref (loader); _dbus_message_loader_unref (loader); /* Write the header data one byte at a time */ data = _dbus_string_get_const_data (&message->header.data); for (i = 0; i < _dbus_string_get_length (&message->header.data); i++) { DBusString *buffer; _dbus_message_loader_get_buffer (loader, &buffer); _dbus_string_append_byte (buffer, data[i]); _dbus_message_loader_return_buffer (loader, buffer, 1); } /* Write the body data one byte at a time */ data = _dbus_string_get_const_data (&message->body); for (i = 0; i < _dbus_string_get_length (&message->body); i++) { DBusString *buffer; _dbus_message_loader_get_buffer (loader, &buffer); _dbus_string_append_byte (buffer, data[i]); _dbus_message_loader_return_buffer (loader, buffer, 1); } dbus_message_unref (message); /* Now pop back the message */ if (!_dbus_message_loader_queue_messages (loader)) _dbus_assert_not_reached ("no memory to queue messages"); if (_dbus_message_loader_get_is_corrupted (loader)) _dbus_assert_not_reached ("message loader corrupted"); message = _dbus_message_loader_pop_message (loader); if (!message) _dbus_assert_not_reached ("received a NULL message"); if (dbus_message_get_reply_serial (message) != 5678) _dbus_assert_not_reached ("reply serial fields differ"); verify_test_message (message); dbus_message_unref (message); _dbus_message_loader_unref (loader); check_memleaks (); /* Load all the sample messages from the message factory */ { DBusMessageDataIter diter; DBusMessageData mdata; int count; reset_validities_seen (); count = 0; _dbus_message_data_iter_init (&diter); while (_dbus_message_data_iter_get_and_next (&diter, &mdata)) { if (!dbus_internal_do_not_use_try_message_data (&mdata.data, mdata.expected_validity)) { _dbus_warn ("expected validity %d and did not get it\n", mdata.expected_validity); _dbus_assert_not_reached ("message data failed"); } _dbus_message_data_free (&mdata); count += 1; } printf ("%d sample messages tested\n", count); print_validities_seen (FALSE); print_validities_seen (TRUE); } check_memleaks (); /* Now load every message in test_data_dir if we have one */ if (test_data_dir == NULL) return TRUE; return dbus_internal_do_not_use_foreach_message_file (test_data_dir, (DBusForeachMessageFileFunc) dbus_internal_do_not_use_try_message_file, NULL); }
static errno_t sbus_request_switch_reply(DBusMessage *reply, struct tevent_req *req, sbus_request_messages_fn messages_fn) { DBusMessage *client_message; DBusMessage **reply_pointer; TALLOC_CTX *reply_mem_ctx; const char *sender; dbus_uint32_t serial; dbus_bool_t dbret; errno_t ret; ret = messages_fn(req, &reply_mem_ctx, &client_message, &reply_pointer); if (ret != EOK) { return ret; } /* Copy reply to location in a state of this request. */ *reply_pointer = dbus_message_copy(reply); if (*reply_pointer == NULL) { return ENOMEM; } ret = sbus_message_bound(reply_mem_ctx, *reply_pointer); if (ret != EOK) { goto done; } if (client_message == NULL) { ret = EOK; goto done; } /* We set destination and serial in reply to point to the original * client request. */ sender = dbus_message_get_sender(client_message); serial = dbus_message_get_serial(client_message); dbret = dbus_message_set_destination(*reply_pointer, sender); if (dbret == false) { DEBUG(SSSDBG_CRIT_FAILURE, "Unable to set reply sender!\n"); ret = EIO; goto done; } dbret = dbus_message_set_reply_serial(*reply_pointer, serial); if (dbret == false) { DEBUG(SSSDBG_CRIT_FAILURE, "Unable to set reply serial!\n"); ret = EIO; goto done; } ret = EOK; done: if (ret != EOK) { dbus_message_unref(*reply_pointer); *reply_pointer = NULL; } return ret; }
guint32 ibus_message_get_serial (IBusMessage *message) { return dbus_message_get_serial (message); }
static DBusMessage* invoke_js_from_dbus(SeedContext ctx, DBusMessage *method_call, SeedObject this_obj, SeedObject method_obj, SeedException *exception) { DBusMessage *reply; int argc; SeedValue *argv; SeedValue rval; DBusMessageIter arg_iter; GArray *values; const char *signature; reply = NULL; dbus_message_iter_init(method_call, &arg_iter); if (!seed_js_values_from_dbus(ctx, &arg_iter, &values, exception)) { if (!dbus_reply_from_exception(ctx, method_call, &reply, exception)) g_warning("conversion of dbus method arg failed but no exception was set?"); return reply; } argc = values->len; argv = (SeedValue *)values->data; seed_js_add_dbus_props(ctx, method_call, argv[0], exception); rval = seed_object_call (ctx, method_obj, NULL, argc, argv, exception); if (!seed_value_is_null (ctx, *exception) && seed_value_is_object (ctx, *exception)) { g_warning("dbus method invocation failed"); if (!dbus_reply_from_exception(ctx, method_call, &reply, exception)) g_warning("dbus method invocation failed but no exception was set?"); goto out; } if (dbus_reply_from_exception(ctx, method_call, &reply, exception)) { g_warning("Closure invocation succeeded but an exception was set?"); goto out; } if (!signature_from_method(ctx, method_obj, &signature, exception)) { if (!dbus_reply_from_exception(ctx, method_call, &reply, exception)) g_warning("dbus method invocation failed but no exception was set?"); goto out; } reply = build_reply_from_jsval(ctx, signature, dbus_message_get_sender(method_call), dbus_message_get_serial(method_call), rval, exception); out: g_array_free(values, TRUE); if (reply) g_warning ("Sending %s reply to dbus method %s", dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN ? "normal" : "error", dbus_message_get_member(method_call)); else g_warning ("Failed to create reply to dbus method %s", dbus_message_get_member(method_call)); return reply; }