dbus_bool_t emit_property_changed(DBusConnection *conn, const char *path, const char *interface, const char *name, int type, void *value) { DBusMessage *signal; DBusMessageIter iter; signal = dbus_message_new_signal(path, interface, "PropertyChanged"); if (!signal) { error("Unable to allocate new %s.PropertyChanged signal", interface); return FALSE; } dbus_message_iter_init_append(signal, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); append_variant(&iter, type, value); return g_dbus_send_message(conn, signal); }
void dbus_append_dict_entry(DBusMessageIter *iter, const char *property, int type, const void *value) { DBusMessageIter dict_entry; dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry); append_variant(&dict_entry, property, type, value); dbus_message_iter_close_container(iter, &dict_entry); }
static jboolean setCharacteristicPropertyNative(JNIEnv *env, jobject object, jstring path, jstring property, void *value, jint type) { #ifdef HAVE_BLUETOOTH LOGV("%s", __FUNCTION__); native_data_t *nat = get_native_data(env, object); if (nat) { DBusMessage *msg; DBusMessageIter iter; DBusError err; dbus_error_init(&err); const char *c_path = env->GetStringUTFChars(path, NULL); const char *c_key = env->GetStringUTFChars(property, NULL); dbus_bool_t reply = JNI_FALSE; LOGE("%s c_path=%s",__FUNCTION__, c_path); msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, c_path, DBUS_CHAR_IFACE, "SetProperty"); if (!msg) { LOGE("%s: Can't allocate new method call for device SetProperty!", __FUNCTION__); env->ReleaseStringUTFChars(path, c_path); env->ReleaseStringUTFChars(property, c_key); return JNI_FALSE; } dbus_message_append_args(msg, DBUS_TYPE_STRING, &c_key, DBUS_TYPE_INVALID); dbus_message_iter_init_append(msg, &iter); append_variant(&iter, type, value); reply = dbus_connection_send_with_reply(nat->conn, msg, NULL, -1); if (!reply) { if (dbus_error_is_set(&err)) { LOG_AND_FREE_DBUS_ERROR(&err); } else { LOGE("DBus reply is NULL in function %s", __FUNCTION__); } } dbus_message_unref(msg); env->ReleaseStringUTFChars(path, c_path); env->ReleaseStringUTFChars(property, c_key); return reply ? JNI_TRUE : JNI_FALSE; } #endif return JNI_FALSE; }
static jboolean setAdapterPropertyNative(JNIEnv *env, jobject object, jstring key, void *value, jint type) { #ifdef HAVE_BLUETOOTH LOGV(__FUNCTION__); native_data_t *nat = get_native_data(env, object); if (nat) { DBusMessage *reply, *msg; DBusMessageIter iter; DBusError err; const char *c_key = env->GetStringUTFChars(key, NULL); dbus_error_init(&err); msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, get_adapter_path(env, object), DBUS_ADAPTER_IFACE, "SetProperty"); if (!msg) { LOGE("%s: Can't allocate new method call for GetProperties!", __FUNCTION__); env->ReleaseStringUTFChars(key, c_key); return JNI_FALSE; } dbus_message_append_args(msg, DBUS_TYPE_STRING, &c_key, DBUS_TYPE_INVALID); dbus_message_iter_init_append(msg, &iter); append_variant(&iter, type, value); reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err); dbus_message_unref(msg); env->ReleaseStringUTFChars(key, c_key); if (!reply) { if (dbus_error_is_set(&err)) { LOG_AND_FREE_DBUS_ERROR(&err); } else LOGE("DBus reply is NULL in function %s", __FUNCTION__); return JNI_FALSE; } return JNI_TRUE; } #endif return JNI_FALSE; }
void dict_append_entry(DBusMessageIter *dict, const char *key, int type, void *val) { DBusMessageIter entry; if (type == DBUS_TYPE_STRING) { const char *str = *((const char **) val); if (str == NULL) return; } dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, NULL, &entry); dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); append_variant(&entry, type, val); dbus_message_iter_close_container(dict, &entry); }
void ofono_dbus_dict_append(DBusMessageIter *dict, const char *key, int type, void *value) { DBusMessageIter keyiter; if (type == DBUS_TYPE_STRING) { const char *str = *((const char **) value); if (str == NULL) return; } dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, NULL, &keyiter); dbus_message_iter_append_basic(&keyiter, DBUS_TYPE_STRING, &key); append_variant(&keyiter, type, value); dbus_message_iter_close_container(dict, &keyiter); }
int dbus_set_property(DBusConnection *connection, const char *path, const char *interface, connman_dbus_method_return_func_t cb, void * user_data, const char *property, int type, const void *value) { DBusMessage *message; DBusMessageIter iter; message = dbus_message_new_method_call("net.connman", path, interface, "SetProperty"); if (!message) return -ENOMEM; dbus_message_iter_init_append(message, &iter); if (append_variant(&iter, property, type, value) < 0) { dbus_message_unref(message); return -EINVAL; } return send_method_call(connection, message, cb, user_data); }
static void set_property(DBusConnection *conn, const char *name, struct ADAPTER_PROPERTIES *p) { DBusError err; DBusMessage *msg; DBusMessageIter iter; char s[255]; memset(&s, 0, 255); dbus_error_init(&err); msg = dbus_message_new_method_call(DBUS_NAME,DBUS_PATH, DBUS_INTERFACE_APAPTER, "SetProperty"); if (msg == NULL) { printf("%s %d msg is null\n", __func__, __LINE__); exit(1); } /* append data */ dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); // printf("%s %d\n", __func__, __LINE__); if (!strcmp(name, "Name")) { // printf("SynergyDBusAdapter::SetProperty('%s', %s)\n", name, p->Name); strcpy(s, p->Name); append_variant(&iter, DBUS_TYPE_STRING, &s); } else if (!strcmp(name, "Powered")) { // printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->Powered); append_variant(&iter, DBUS_TYPE_BOOLEAN, &p->Powered); } else if (!strcmp(name, "DiscoverableTimeout")) { // printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->DiscoverableTimeout); append_variant(&iter, DBUS_TYPE_UINT32, &p->DiscoverableTimeout); } else if (!strcmp(name, "Discoverable")) { // printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->Discoverable); append_variant(&iter, DBUS_TYPE_BOOLEAN, &p->Discoverable); } else if (!strcmp(name, "PairableTimeout")) { // printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->PairableTimeout); append_variant(&iter, DBUS_TYPE_UINT32, &p->PairableTimeout); } else if (!strcmp(name, "Pairable")) { // printf("SynergyDBusAdapter::SetProperty('%s', %d)\n", name, p->Pairable); append_variant(&iter, DBUS_TYPE_BOOLEAN, &p->Pairable); } else { printf("SynergyDBusAdapter::SetProperty('%s') is not supported)\n", name); dbus_connection_flush(conn); dbus_message_unref(msg); exit(1); } msg = excute_method_a(conn, msg); dbus_message_unref(msg); dbus_error_free(&err); }
/** * Activate the network interface * */ int usb_network_up(struct mode_list_elem *data) { char *ip = NULL, *gateway = NULL; int ret = -1; #if CONNMAN_WORKS_BETTER DBusConnection *dbus_conn_connman = NULL; DBusMessage *msg = NULL, *reply = NULL; DBusMessageIter iter, variant, dict; DBusMessageIter msg_iter; DBusMessageIter dict_entry; DBusError error; const char *service = NULL; /* make sure connman will recognize the gadget interface NEEDED? */ //system("/bin/dbus-send --print-reply --type=method_call --system --dest=net.connman /net/connman/technology/gadget net.connman.Technology.SetProperty string:Powered variant:boolean:true"); //system("/sbin/ifconfig rndis0 up"); log_debug("waiting for connman to pick up interface\n"); sleep(1); dbus_error_init(&error); if( (dbus_conn_connman = dbus_bus_get(DBUS_BUS_SYSTEM, &error)) == 0 ) { log_err("Could not connect to dbus for connman\n"); } /* get list of services so we can find out which one is the usb gadget */ if ((msg = dbus_message_new_method_call("net.connman", "/", "net.connman.Manager", "GetServices")) != NULL) { if ((reply = dbus_connection_send_with_reply_and_block(dbus_conn_connman, msg, -1, NULL)) != NULL) { service = connman_parse_manager_reply(reply, "gadget"); dbus_message_unref(reply); } dbus_message_unref(msg); } if(service == NULL) return(1); log_debug("gadget = %s\n", service); /* now we need to configure the connection */ if ((msg = dbus_message_new_method_call("net.connman", service, "net.connman.Service", "SetProperty")) != NULL) { log_debug("iter init\n"); dbus_message_iter_init_append(msg, &msg_iter); log_debug("iter append\n"); // TODO: crashes here, need to rework this whole bit, connman dbus is hell dbus_message_iter_append_basic(&msg_iter, DBUS_TYPE_STRING, "IPv4.Configuration"); log_debug("iter open container\n"); dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_VARIANT, DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &variant); log_debug("iter open container 2\n"); dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); log_debug("Set Method\n"); dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry); append_variant(&dict_entry, "Method", DBUS_TYPE_STRING, "manual"); dbus_message_iter_close_container(&dict, &dict_entry); log_debug("Set ip\n"); ip = get_network_ip(); if(ip == NULL) ip = strdup("192.168.2.15"); dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry); append_variant(&dict_entry, "Address", DBUS_TYPE_STRING, ip); dbus_message_iter_close_container(&dict, &dict_entry); log_debug("Set netmask\n"); dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry); append_variant(&dict_entry, "Netmask", DBUS_TYPE_STRING, "255.255.255.0"); dbus_message_iter_close_container(&dict, &dict_entry); log_debug("set gateway\n"); gateway = get_network_gateway(); if(gateway) { dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry); append_variant(&dict_entry, "Gateway", DBUS_TYPE_STRING, gateway); dbus_message_iter_close_container(&dict, &dict_entry); } dbus_message_iter_close_container(&variant, &dict); dbus_message_iter_close_container(&msg_iter, &variant); } log_debug("Connect gadget\n"); /* Finally we can bring it up */ if ((msg = dbus_message_new_method_call("net.connman", service, "net.connman.Service", "Connect")) != NULL) { /* we don't care for the reply, which is empty anyway if all goes well */ ret = !dbus_connection_send(dbus_conn_connman, msg, NULL); /* make sure the message is sent before cleaning up and closing the connection */ dbus_connection_flush(dbus_conn_connman); dbus_message_unref(msg); } dbus_connection_unref(dbus_conn_connman); dbus_error_free(&error); free(service); if(ip) free(ip); if(gateway) free(gateway); return(ret); #else char command[128]; const char *interface; interface = get_interface(data); ip = get_network_ip(); gateway = get_network_gateway(); if(ip == NULL) { sprintf(command,"ifconfig %s 192.168.2.15", interface); system(command); goto clean; } else if(!strcmp(ip, "dhcp")) { sprintf(command, "dhclient -d %s\n", interface); ret = system(command); if(ret != 0) { sprintf(command, "udhcpc -i %s\n", interface); system(command); } } else { sprintf(command, "ifconfig %s %s\n", interface, ip); system(command); } /* TODO: Check first if there is a gateway set */ if(gateway) { sprintf(command, "route add default gw %s\n", gateway); system(command); } clean: free((char *)interface); free((char *)gateway); free((char *)ip); return(0); #endif /* CONNMAN */ }