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 */
}
