void notify(DBusMessage * dmsg) { DBusMessage *reply; DBusMessageIter args; DBusMessageIter hints; DBusMessageIter hint; char *hint_name; int i; int id; const char *appname = NULL; const char *summary = NULL; const char *body = NULL; const char *icon = NULL; const char *fgcolor = NULL; const char *bgcolor = NULL; int urgency = 1; int progress = -1; notification *n = malloc(sizeof(notification)); dbus_uint32_t replaces_id = 0; dbus_int32_t expires = -1; dbus_serial++; dbus_message_iter_init(dmsg, &args); _extract_basic(DBUS_TYPE_STRING, &args, &appname); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_UINT32, &args, &replaces_id); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_STRING, &args, &icon); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_STRING, &args, &summary); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_STRING, &args, &body); dbus_message_iter_next(&args); dbus_message_iter_next(&args); dbus_message_iter_recurse(&args, &hints); dbus_message_iter_next(&args); _extract_basic(DBUS_TYPE_INT32, &args, &expires); while (dbus_message_iter_get_arg_type(&hints) != DBUS_TYPE_INVALID) { dbus_message_iter_recurse(&hints, &hint); while (dbus_message_iter_get_arg_type(&hint) != DBUS_TYPE_INVALID) { if (dbus_message_iter_get_arg_type(&hint) != DBUS_TYPE_STRING) { dbus_message_iter_next(&hint); continue; } dbus_message_iter_get_basic(&hint, &hint_name); _extract_hint(DBUS_TYPE_BYTE, "urgency", hint_name, &hint, &urgency); _extract_hint(DBUS_TYPE_STRING, "fgcolor", hint_name, &hint, &fgcolor); _extract_hint(DBUS_TYPE_STRING, "bgcolor", hint_name, &hint, &bgcolor); _extract_hint(DBUS_TYPE_INT32, "value", hint_name, &hint, &progress); if (!progress) _extract_hint(DBUS_TYPE_UINT32, "value", hint_name, &hint, &progress); dbus_message_iter_next(&hint); } dbus_message_iter_next(&hints); } if (expires > 0) { /* do some rounding */ expires = (expires + 500) / 1000; if (expires < 1) { expires = 1; } } n->appname = appname != NULL ? strdup(appname) : ""; n->summary = summary != NULL ? strdup(summary) : ""; n->body = body != NULL ? strdup(body) : ""; n->icon = icon != NULL ? strdup(icon) : ""; n->timeout = expires; n->progress = (progress < 0 || progress > 100) ? 0 : progress + 1; n->urgency = urgency; n->dbus_client = strdup(dbus_message_get_sender(dmsg)); for (i = 0; i < ColLast; i++) { n->color_strings[i] = NULL; } n->color_strings[ColFG] = fgcolor == NULL ? NULL : strdup(fgcolor); n->color_strings[ColBG] = bgcolor == NULL ? NULL : strdup(bgcolor); id = init_notification(n, replaces_id); if (id > 0) map_win(); reply = dbus_message_new_method_return(dmsg); dbus_message_iter_init_append(reply, &args); dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &id); dbus_connection_send(dbus_conn, reply, &dbus_serial); dbus_message_unref(reply); }
/** * Write a Json configuration to @a json_txt of available network devices. * Only Wifi and Ethernet devices are represented as the other device cannot be * configured at the moment. @a json_txt needs to be a pointer ot a char buffer * of the size MAX_JSON_LEN +1. * * @retval 1 success * @retval 2 error * * https://developer.gnome.org/NetworkManager/unstable/spec.html * GetDevices() → ao * * Dbus messages: * http://dbus.freedesktop.org/doc/api/html/group__DBusMessage.html * DBUS_EXPORT int dbus_message_iter_get_arg_type(DBusMessageIter * iter) */ int qaul_network_devices_json(DBusConnection* dbus_connection, char* json_txt) { DBusMessage* msg; DBusMessageIter iter, iter_array; int current_type, json_pos, i; const char* device_path_ptr; qaul_dbus_device_properties device; printf("qaul_network_devices_json\n"); i = 0; msg = networkmanager_dbus_method_call("GetDevices"); if(msg == NULL) return 0; dbus_message_iter_init_append(msg, &iter); if(!networkmanager_dbus_send(&msg, dbus_connection)) { printf("qaul_network_devices_json networkmanager_dbus_send error\n"); return 0; } if(!dbus_message_iter_init(msg, &iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) { printf("qaul_network_devices_json dbus_message_iter_init | DBUS_TYPE_ARRAY error\n"); dbus_message_unref(msg); return 0; } // loop recursively over the array json_pos = 0; strncpy(json_txt +json_pos, "", MAX_JSON_LEN -json_pos); dbus_message_iter_recurse (&iter, &iter_array); while((current_type = dbus_message_iter_get_arg_type(&iter_array)) != DBUS_TYPE_INVALID) { if(current_type == DBUS_TYPE_OBJECT_PATH) { dbus_message_iter_get_basic(&iter_array, &device_path_ptr); strncpy(device.dbus_device_path, device_path_ptr, sizeof(device.dbus_device_path)); // get interface name and interface type // dbus low level: dbus_message_new_method_call interface:"org.freedesktop.DBus.Properties" method:"Get" property:"(String)Interface, (UInt32)DeviceType" if(networkmanager_device_properties(dbus_connection, &device)) { // only wifi and ethernet connections can be handled at the moment if(device.type == 2 || device.type == 1) { if(i > 0) { json_pos = strlen(json_txt); strncpy(json_txt +json_pos, ",", MAX_JSON_LEN -json_pos); } i++; // write to json json_pos = strlen(json_txt); strncpy(json_txt +json_pos, "{\"name\":\"", MAX_JSON_LEN -json_pos); json_pos = strlen(json_txt); strncpy(json_txt +json_pos, device.interface, MAX_JSON_LEN -json_pos); json_pos = strlen(json_txt); if(device.type == 2) { strncpy(json_txt +json_pos, "\",\"ui_name\":\"WIFI (", MAX_JSON_LEN -json_pos); json_pos = strlen(json_txt); strncpy(json_txt +json_pos, device.interface, MAX_JSON_LEN -json_pos); json_pos = strlen(json_txt); strncpy(json_txt +json_pos, ")\",\"type\":1", MAX_JSON_LEN -json_pos); } else if(device.type == 1) { strncpy(json_txt +json_pos, "\",\"ui_name\":\"ETHERNET (", MAX_JSON_LEN -json_pos); json_pos = strlen(json_txt); strncpy(json_txt +json_pos, device.interface, MAX_JSON_LEN -json_pos); json_pos = strlen(json_txt); strncpy(json_txt +json_pos, ")\",\"type\":2", MAX_JSON_LEN -json_pos); } json_pos = strlen(json_txt); strncpy(json_txt +json_pos, "}", MAX_JSON_LEN -json_pos); } } else printf("qaul_network_devices_json networkmanager_device_get_property failed\n"); } else printf("qaul_network_devices_json Unknown current type [%i]\n", current_type); dbus_message_iter_next(&iter_array); } dbus_message_unref(msg); return 1; }
static DBusHandlerResult request_navit_set_attr(DBusConnection *connection, DBusMessage *message) { struct navit *navit; DBusMessageIter iter, iterattr; struct attr attr; char *attr_type; navit = object_get_from_message(message, "navit"); if (! navit) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; dbus_message_iter_init(message, &iter); dbus_message_iter_get_basic(&iter, &attr_type); attr.type = attr_from_name(attr_type); dbg(0, "attr value: 0x%x string: %s\n", attr.type, attr_type); if (attr.type == attr_none) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; dbus_message_iter_next(&iter); dbus_message_iter_recurse(&iter, &iterattr); dbg(0, "seems valid. signature: %s\n", dbus_message_iter_get_signature(&iterattr)); if (attr.type > attr_type_item_begin && attr.type < attr_type_item_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if (attr.type > attr_type_int_begin && attr.type < attr_type_boolean_begin) { if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_INT32) { dbus_message_iter_get_basic(&iterattr, &attr.u.num); if (navit_set_attr(navit, &attr)) return empty_reply(connection, message); } } else if(attr.type > attr_type_boolean_begin && attr.type < attr_type_int_end) { if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_BOOLEAN) { dbus_message_iter_get_basic(&iterattr, &attr.u.num); if (navit_set_attr(navit, &attr)) return empty_reply(connection, message); } } #if 0 else if(attr.type > attr_type_string_begin && attr.type < attr_type_string_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if(attr.type > attr_type_special_begin && attr.type < attr_type_special_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if(attr.type > attr_type_double_begin && attr.type < attr_type_double_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if(attr.type > attr_type_coord_geo_begin && attr.type < attr_type_coord_geo_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if(attr.type > attr_type_color_begin && attr.type < attr_type_color_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if(attr.type > attr_type_object_begin && attr.type < attr_type_object_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if(attr.type > attr_type_coord_begin && attr.type < attr_type_coord_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if(attr.type > attr_type_pcoord_begin && attr.type < attr_type_pcoord_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; else if(attr.type > attr_type_callback_begin && attr.type < attr_type_callback_end) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; #endif else { dbg(0, "zomg really unhandled111\n"); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
static DBusMessage *change_session(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct connman_session *session = user_data; struct session_info *info = session->info; DBusMessageIter iter, value; const char *name; const char *val; GSList *allowed_bearers; int err; DBG("session %p", session); if (dbus_message_iter_init(msg, &iter) == FALSE) return __connman_error_invalid_arguments(msg); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return __connman_error_invalid_arguments(msg); dbus_message_iter_get_basic(&iter, &name); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) return __connman_error_invalid_arguments(msg); dbus_message_iter_recurse(&iter, &value); switch (dbus_message_iter_get_arg_type(&value)) { case DBUS_TYPE_ARRAY: if (g_str_equal(name, "AllowedBearers") == TRUE) { err = parse_bearers(&value, &allowed_bearers); if (err < 0) return __connman_error_failed(msg, err); g_slist_free(info->config.allowed_bearers); session->user_allowed_bearers = allowed_bearers; err = apply_policy_on_bearers( session->policy_config->allowed_bearers, session->user_allowed_bearers, &info->config.allowed_bearers); if (err < 0) return __connman_error_failed(msg, err); } else { goto err; } break; case DBUS_TYPE_STRING: if (g_str_equal(name, "ConnectionType") == TRUE) { dbus_message_iter_get_basic(&value, &val); info->config.type = apply_policy_on_type( session->policy_config->type, connman_session_parse_connection_type(val)); } else { goto err; } break; default: goto err; } session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING); return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); err: return __connman_error_invalid_arguments(msg); }
/** * get @a property via @a dbus_connection . * org.freedesktop.DBus.Properties * Get (String interface, String propname) -> (Variant value) */ static int networkmanager_get_property(DBusConnection* dbus_connection, networkmanager_property* property) { DBusMessage* msg; DBusMessageIter iter, iter_variant; DBusPendingCall* pending; int success; char* value_str_ptr; msg = dbus_message_new_method_call( "org.freedesktop.NetworkManager", property->dbus_path, "org.freedesktop.DBus.Properties", "Get" ); if(msg == NULL) { printf("networkmanager_get_property msg error\n"); return 0; } dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &property->dbus_interface); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &property->dbus_property_name); // send dbus message // -1 is the default time out. Other time outs can be configured in milli seconds. success = dbus_connection_send_with_reply(dbus_connection, msg, &pending, -1); if(!success) { printf("networkmanager_get_property dbus send error\n"); return 0; } if(pending == NULL) { printf ("networkmanager_get_property dbus calling error\n"); return 0; } dbus_connection_flush(dbus_connection); dbus_message_unref(msg); dbus_pending_call_block(pending); msg = dbus_pending_call_steal_reply(pending); dbus_pending_call_unref(pending); if(msg == NULL) { printf("networkmanager_get_property msg error 2\n"); return 0; } if(!dbus_message_iter_init(msg, &iter)) { printf("networkmanager_get_property dbus_message_iter_init error\n"); dbus_message_unref(msg); return 0; } if(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_VARIANT) { dbus_message_iter_recurse(&iter, &iter_variant); if(dbus_message_iter_get_arg_type(&iter_variant) == DBUS_TYPE_STRING) { dbus_message_iter_get_basic(&iter_variant, &value_str_ptr); strncpy(property->value_string, value_str_ptr, property->value_string_len); printf("networkmanager_get_property %s %s: %s\n", property->dbus_path, property->dbus_property_name, value_str_ptr); } else if(dbus_message_iter_get_arg_type(&iter_variant) == DBUS_TYPE_UINT32) { dbus_message_iter_get_basic(&iter_variant, &property->value_int); printf("networkmanager_get_property %s %s: %i\n", property->dbus_path, property->dbus_property_name, property->value_int); } else { printf("networkmanager_get_property dbus_message_iter_get_arg_type error\n"); dbus_message_unref(msg); return 0; } } else { printf("networkmanager_get_property dbus_message_iter_get_arg_type not variant error\n"); dbus_message_unref(msg); return 0; } dbus_message_unref(msg); return 1; }
static void handle_message (DBusMessage *msg, struct cb_data *data) { char *cb_decision_name; int found = 0, i = 0; struct transaction_data *trans_data = NULL; /* parse the message to ep_decision array */ dbus_uint32_t txid; char *actname; DBusMessageIter msgit; DBusMessageIter arrit; DBusMessageIter entit; DBusMessageIter actit; DBusMessageIter structit; DBusMessageIter structfieldit; DBusMessageIter variantit; int success = TRUE; /* printf("libep: parsing the message\n"); */ /** * This is really complicated and nasty. Idea is that the message is * supposed to look something like this: * * uint32 0 * array [ * dict entry( * string "com.nokia.policy.audio_route" * array [ * array [ * struct { * string "type" * variant string "source" * } * struct { * string "device" * variant string "headset" * } * ] * array [ * struct { * string "type" * variant string "sink" * } * struct { * string "device" * variant string "headset" * } * ] * ] * ) * ] * */ dbus_message_iter_init(msg, &msgit); if (dbus_message_iter_get_arg_type(&msgit) != DBUS_TYPE_UINT32) return; dbus_message_iter_get_basic(&msgit, (void *)&txid); if (txid != 0) { trans_data = calloc(1, sizeof(struct transaction_data)); if (!trans_data) goto send_signal; trans_data->txid = txid; if (!ep_list_append(&transaction_list, trans_data)) { success = FALSE; goto send_signal; } } /* printf("libep: txid: %u\n", txid); */ if (!dbus_message_iter_next(&msgit) || dbus_message_iter_get_arg_type(&msgit) != DBUS_TYPE_ARRAY) { success = FALSE; goto send_signal; } dbus_message_iter_recurse(&msgit, &arrit); do { if (dbus_message_iter_get_arg_type(&arrit) != DBUS_TYPE_DICT_ENTRY) { success = FALSE; continue; } dbus_message_iter_recurse(&arrit, &entit); do { struct ep_decision **decisions = NULL; struct ep_list_head_s decision_list; memset(&decision_list, 0, sizeof(struct ep_list_head_s)); if (dbus_message_iter_get_arg_type(&entit) != DBUS_TYPE_STRING) { success = FALSE; continue; } dbus_message_iter_get_basic(&entit, (void *)&actname); /* printf("libep: decision set name '%s'\n", actname); */ if (!dbus_message_iter_next(&entit) || dbus_message_iter_get_arg_type(&entit) != DBUS_TYPE_ARRAY) { success = FALSE; continue; } dbus_message_iter_recurse(&entit, &actit); /* gather the decisions to the decision set */ do { struct ep_decision *decision = calloc(1, sizeof(struct ep_decision)); struct ep_list_head_s pair_list; memset(&pair_list, 0, sizeof(struct ep_list_head_s)); if (dbus_message_iter_get_arg_type(&actit) != DBUS_TYPE_ARRAY) { success = FALSE; free(decision); continue; } dbus_message_iter_recurse(&actit, &structit); /* gather the key-value pairs to the decision */ do { struct ep_key_value_pair *pair = calloc(1, sizeof(struct ep_key_value_pair)); void *tmp = NULL; char *key = NULL; if (dbus_message_iter_get_arg_type(&structit) != DBUS_TYPE_STRUCT) { success = FALSE; free(pair); continue; } dbus_message_iter_recurse(&structit, &structfieldit); /* there are two fields inside the struct: one * string and one variant */ if (dbus_message_iter_get_arg_type(&structfieldit) != DBUS_TYPE_STRING) { success = FALSE; free(pair); continue; } dbus_message_iter_get_basic(&structfieldit, (void *)&key); pair->key = strdup(key); /* printf("libep: key: '%s'\n", pair->key); */ if (!dbus_message_iter_next(&structfieldit)) { success = FALSE; free(pair); continue; } if (dbus_message_iter_get_arg_type(&structfieldit) != DBUS_TYPE_VARIANT) { success = FALSE; free(pair); continue; } dbus_message_iter_recurse(&structfieldit, &variantit); dbus_message_iter_get_basic(&variantit, (void *)&tmp); switch (dbus_message_iter_get_arg_type(&variantit)) { case DBUS_TYPE_INT32: pair->value = malloc(sizeof(int)); memcpy(pair->value, &tmp, sizeof(int)); pair->type = EP_VALUE_INT; /* printf("libep: value (int) '%i'\n", *(int *) pair->value); */ break; case DBUS_TYPE_DOUBLE: pair->value = malloc(sizeof(double)); memcpy(pair->value, &tmp, sizeof(double)); pair->type = EP_VALUE_FLOAT; /* printf("libep: value (float) '%f'\n", *(float *) pair->value); */ break; case DBUS_TYPE_STRING: pair->value = strdup(tmp); pair->type = EP_VALUE_STRING; /* printf("libep: value (string) '%s'\n", (char *) pair->value); */ break; default: /* printf("libep: value is unknown D-Bus type '%i'\n", dbus_message_iter_get_arg_type(&variantit)); */ break; } ep_list_append(&pair_list, pair); } while (dbus_message_iter_next(&structit)); decision->pairs = (struct ep_key_value_pair **) ep_list_convert_to_array(&pair_list); ep_list_free_all(&pair_list); ep_list_append(&decision_list, decision); } while (dbus_message_iter_next(&entit)); decisions = (struct ep_decision **) ep_list_convert_to_array(&decision_list); ep_list_free_all(&decision_list); /* count the callbacks if a transaction is needed */ if (trans_data) { if (data->decision_names[0]) { i = 0; cb_decision_name = data->decision_names[i]; while (cb_decision_name) { if (strcmp(cb_decision_name, actname) == 0) { trans_data->refcount++; #if 0 printf("libep: increased transaction data '%p' refcount to %u for name '%s'\n", trans_data, trans_data->refcount, cb_decision_name); #endif } cb_decision_name = data->decision_names[++i]; } } else { /* subscribe to all decisions */ trans_data->refcount++; } } if (data->decision_names[0]) { i = 0; cb_decision_name = data->decision_names[i]; /* send the decisions */ while (cb_decision_name) { if (strcmp(cb_decision_name, actname) == 0) { data->cb(actname, decisions, ep_ready, txid, data->user_data); found = TRUE; } cb_decision_name = data->decision_names[++i]; } } else { /* call the callback for all decisions */ data->cb(actname, decisions, ep_ready, txid, data->user_data); found = TRUE; } free_decisions(decisions); } while (dbus_message_iter_next(&entit)); } while (dbus_message_iter_next(&arrit)); if (txid == 0) { /* no ack is needed, go to send_signal for cleanup */ goto send_signal; } if (found) { /* It's possible that the callbacks have had errors, and the * NACK is already sent. In this case the transaction is already * removed from the list and freed. See if this is the case. */ trans_data = ep_get_transaction(txid); if (!trans_data) { return; } /* the ACK signal is now ready to be sent */ trans_data->ready = TRUE; send_if_done(trans_data); #if 0 printf("libep: signal handling success, waiting for callbacks\n"); #endif return; /* success */ } send_signal: /* no-one is interested or everything failed, just send the signal * and be done with it */ /* TODO: free all memory */ if (trans_data) { ep_list_remove(&transaction_list, trans_data); free(trans_data); trans_data = NULL; } /* printf("libep: not waiting for handlers to return, parsing %s a success\n", success ? "was" : "was not"); */ send_signal(txid, success); }
static void request_input_reply(DBusMessage *reply, void *user_data) { struct request_input_reply *l2tp_reply = user_data; const char *error = NULL; char *username = NULL, *password = NULL; char *key; DBusMessageIter iter, dict; DBG("provider %p", l2tp_reply->provider); if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { error = dbus_message_get_error_name(reply); goto done; } if (vpn_agent_check_reply_has_dict(reply) == FALSE) goto done; dbus_message_iter_init(reply, &iter); dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry, value; const char *str; dbus_message_iter_recurse(&dict, &entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&entry, &key); if (g_str_equal(key, "Username")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&value, &str); username = g_strdup(str); } if (g_str_equal(key, "Password")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&value, &str); password = g_strdup(str); } dbus_message_iter_next(&dict); } done: l2tp_reply->callback(l2tp_reply->provider, username, password, error, l2tp_reply->user_data); g_free(username); g_free(password); g_free(l2tp_reply); }
static DBusMessage *cf_set_property(DBusConnection *conn, DBusMessage *msg, void *data) { struct ofono_call_forwarding *cf = data; struct ofono_modem *modem = __ofono_atom_get_modem(cf->atom); DBusMessageIter iter; DBusMessageIter var; const char *property; int cls; int type; if (ofono_modem_get_online(modem) == FALSE) return __ofono_error_not_available(msg); if (__ofono_call_forwarding_is_busy(cf) || __ofono_ussd_is_busy(cf->ussd)) return __ofono_error_busy(msg); if (!dbus_message_iter_init(msg, &iter)) return __ofono_error_invalid_args(msg); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&iter, &property); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) return __ofono_error_invalid_args(msg); dbus_message_iter_recurse(&iter, &var); if (cf_condition_timeout_property(property, &cls)) { dbus_uint16_t timeout; GSList *l; struct ofono_call_forwarding_condition *c; type = CALL_FORWARDING_TYPE_NO_REPLY; if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_UINT16) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&var, &timeout); if (timeout < 1 || timeout > 30) return __ofono_error_invalid_format(msg); l = g_slist_find_custom(cf->cf_conditions[type], GINT_TO_POINTER(cls), cf_condition_find_with_cls); if (l == NULL) return __ofono_error_failed(msg); c = l->data; return set_property_request(cf, msg, type, cls, &c->phone_number, timeout); } else if (cf_condition_enabled_property(cf, property, &type, &cls)) { struct ofono_phone_number ph; const char *number; int timeout; ph.number[0] = '\0'; ph.type = 129; if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&var, &number); if (strlen(number) > 0 && !valid_phone_number_format(number)) return __ofono_error_invalid_format(msg); if (number[0] != '\0') string_to_phone_number(number, &ph); timeout = cf_find_timeout(cf->cf_conditions[type], cls); return set_property_request(cf, msg, type, cls, &ph, timeout); } return __ofono_error_invalid_args(msg); }
inline QVariant qIterGet(DBusMessageIter *it) { DBusMessageIter sub; dbus_message_iter_recurse(it, &sub); return QDBusTypeHelper<QVariant>::toVariant(qFetchParameter(&sub)); }
static int oc_notify(DBusMessage *msg, struct vpn_provider *provider) { DBusMessageIter iter, dict; const char *reason, *key, *value; char *domain = NULL; char *addressv4 = NULL, *addressv6 = NULL; char *netmask = NULL, *gateway = NULL; unsigned char prefix_len = 0; struct connman_ipaddress *ipaddress; dbus_message_iter_init(msg, &iter); dbus_message_iter_get_basic(&iter, &reason); dbus_message_iter_next(&iter); if (!provider) { connman_error("No provider found"); return VPN_STATE_FAILURE; } if (strcmp(reason, "connect")) return VPN_STATE_DISCONNECT; domain = g_strdup(vpn_provider_get_string(provider, "VPN.Domain")); dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry; dbus_message_iter_recurse(&dict, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_get_basic(&entry, &value); if (strcmp(key, "CISCO_CSTP_OPTIONS")) DBG("%s = %s", key, value); if (!strcmp(key, "VPNGATEWAY")) gateway = g_strdup(value); if (!strcmp(key, "INTERNAL_IP4_ADDRESS")) addressv4 = g_strdup(value); if (!strcmp(key, "INTERNAL_IP6_ADDRESS")) { addressv6 = g_strdup(value); prefix_len = 128; } if (!strcmp(key, "INTERNAL_IP4_NETMASK")) netmask = g_strdup(value); if (!strcmp(key, "INTERNAL_IP6_NETMASK")) { char *sep; /* The netmask contains the address and the prefix */ sep = strchr(value, '/'); if (sep != NULL) { unsigned char ip_len = sep - value; addressv6 = g_strndup(value, ip_len); prefix_len = (unsigned char) strtol(sep + 1, NULL, 10); } } if (!strcmp(key, "INTERNAL_IP4_DNS") || !strcmp(key, "INTERNAL_IP6_DNS")) vpn_provider_set_nameservers(provider, value); if (!strcmp(key, "CISCO_PROXY_PAC")) vpn_provider_set_pac(provider, value); if (domain == NULL && !strcmp(key, "CISCO_DEF_DOMAIN")) { g_free(domain); domain = g_strdup(value); } if (g_str_has_prefix(key, "CISCO_SPLIT_INC") == TRUE || g_str_has_prefix(key, "CISCO_IPV6_SPLIT_INC") == TRUE) vpn_provider_append_route(provider, key, value); dbus_message_iter_next(&dict); } DBG("%p %p", addressv4, addressv6); if (addressv4 != NULL) ipaddress = connman_ipaddress_alloc(AF_INET); else if (addressv6 != NULL) ipaddress = connman_ipaddress_alloc(AF_INET6); else ipaddress = NULL; if (ipaddress == NULL) { g_free(addressv4); g_free(addressv6); g_free(netmask); g_free(gateway); g_free(domain); return VPN_STATE_FAILURE; } if (addressv4 != NULL) connman_ipaddress_set_ipv4(ipaddress, addressv4, netmask, gateway); else connman_ipaddress_set_ipv6(ipaddress, addressv6, prefix_len, gateway); vpn_provider_set_ipaddress(provider, ipaddress); vpn_provider_set_domain(provider, domain); g_free(addressv4); g_free(addressv6); g_free(netmask); g_free(gateway); g_free(domain); connman_ipaddress_free(ipaddress); return VPN_STATE_CONNECT; }
static DBusMessage *radio_set_property(DBusConnection *conn, DBusMessage *msg, void *data) { struct ofono_radio_settings *rs = data; DBusMessageIter iter; DBusMessageIter var; const char *property; if (rs->pending) return __ofono_error_busy(msg); if (!dbus_message_iter_init(msg, &iter)) return __ofono_error_invalid_args(msg); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&iter, &property); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) return __ofono_error_invalid_args(msg); dbus_message_iter_recurse(&iter, &var); if (g_strcmp0(property, "TechnologyPreference") == 0) { const char *value; enum ofono_radio_access_mode mode; if (rs->driver->set_rat_mode == NULL) return __ofono_error_not_implemented(msg); if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&var, &value); if (radio_access_mode_from_string(value, &mode) == FALSE) return __ofono_error_invalid_args(msg); if (rs->mode == mode) return dbus_message_new_method_return(msg); rs->pending = dbus_message_ref(msg); rs->pending_mode = mode; rs->driver->set_rat_mode(rs, mode, radio_mode_set_callback, rs); return NULL; } else if (g_strcmp0(property, "GsmBand") == 0) { const char *value; enum ofono_radio_band_gsm band; if (rs->driver->set_band == NULL) return __ofono_error_not_implemented(msg); if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&var, &value); if (radio_band_gsm_from_string(value, &band) == FALSE) return __ofono_error_invalid_args(msg); if (rs->band_gsm == band) return dbus_message_new_method_return(msg); rs->pending = dbus_message_ref(msg); rs->pending_band_gsm = band; rs->driver->set_band(rs, band, rs->band_umts, radio_band_set_callback, rs); return NULL; } else if (g_strcmp0(property, "UmtsBand") == 0) { const char *value; enum ofono_radio_band_umts band; if (rs->driver->set_band == NULL) return __ofono_error_not_implemented(msg); if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&var, &value); if (radio_band_umts_from_string(value, &band) == FALSE) return __ofono_error_invalid_args(msg); if (rs->band_umts == band) return dbus_message_new_method_return(msg); rs->pending = dbus_message_ref(msg); rs->pending_band_umts = band; rs->driver->set_band(rs, rs->band_gsm, band, radio_band_set_callback, rs); return NULL; } else if (g_strcmp0(property, "FastDormancy") == 0) { dbus_bool_t value; int target; if (rs->driver->set_fast_dormancy == NULL) return __ofono_error_not_implemented(msg); if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&var, &value); target = value; if (rs->fast_dormancy_pending == target) return dbus_message_new_method_return(msg); rs->pending = dbus_message_ref(msg); rs->fast_dormancy_pending = target; rs->driver->set_fast_dormancy(rs, target, radio_fast_dormancy_set_callback, rs); return NULL; } return __ofono_error_invalid_args(msg); }
static void request_input_cookie_reply(DBusMessage *reply, void *user_data) { struct oc_private_data *data = user_data; char *cookie = NULL, *servercert = NULL, *vpnhost = NULL; char *key; DBusMessageIter iter, dict; DBG("provider %p", data->provider); if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) { goto err; } if (vpn_agent_check_reply_has_dict(reply) == FALSE) goto err; dbus_message_iter_init(reply, &iter); dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry, value; dbus_message_iter_recurse(&dict, &entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&entry, &key); if (g_str_equal(key, "OpenConnect.Cookie")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&value, &cookie); vpn_provider_set_string_hide_value(data->provider, key, cookie); } else if (g_str_equal(key, "OpenConnect.ServerCert")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&value, &servercert); vpn_provider_set_string(data->provider, key, servercert); } else if (g_str_equal(key, "OpenConnect.VPNHost")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&value, &vpnhost); vpn_provider_set_string(data->provider, key, vpnhost); } dbus_message_iter_next(&dict); } if (cookie == NULL || servercert == NULL || vpnhost == NULL) goto err; run_connect(data->provider, data->task, data->if_name, data->cb, data->user_data); free_private_data(data); return; err: vpn_provider_indicate_error(data->provider, VPN_PROVIDER_ERROR_AUTH_FAILED); free_private_data(data); }
static vlc_keystore_entry* kwallet_read_password_list( vlc_keystore* p_keystore, char* psz_entry_name, unsigned int* pi_count ) { vlc_keystore_sys* p_sys = p_keystore->p_sys; DBusMessage* msg = NULL; DBusMessage* repmsg = NULL; DBusMessageIter args; DBusMessageIter sub_iter; DBusMessageIter dict_iter; DBusMessageIter var_iter; vlc_keystore_entry* p_entries = NULL; size_t i_size; uint8_t* p_secret_decoded; char* p_reply; char* p_secret; int i = 0; /* init */ *pi_count = 0; if ( !( msg = vlc_dbus_new_method( p_keystore, "readPasswordList" ) ) ) { msg_Err( p_keystore, "kwallet_read_password_list : vlc_dbus_new_method failed" ); goto error; } /* argument init */ dbus_message_iter_init_append( msg, &args ); if ( !dbus_message_iter_append_basic( &args, DBUS_TYPE_INT32, &p_sys->i_handle ) || !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &psz_folder ) || !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &psz_entry_name ) || !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &p_sys->psz_app_id ) ) goto error; /* sending message */ if ( !( repmsg = vlc_dbus_send_message( p_keystore, msg ) ) ) { msg_Err( p_keystore, "kwallet_read_password_list : vlc_dbus_send_message failed" ); goto error; } /* handling reply */ if ( !dbus_message_iter_init( repmsg, &args ) ) { msg_Err( p_keystore, "kwallet_read_password_list : Message has no arguments" ); goto error; } else if ( dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY ) { msg_Err( p_keystore, "kwallet_read_password_list : Wrong reply type" ); goto error; } else { /* calculating p_entries's size */ dbus_message_iter_recurse( &args, &sub_iter ); do { if ( dbus_message_iter_get_arg_type( &sub_iter ) != DBUS_TYPE_DICT_ENTRY ) continue; dbus_message_iter_recurse( &sub_iter, &dict_iter ); if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_STRING ) continue; dbus_message_iter_next(&dict_iter); if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_VARIANT ) continue; ++( *pi_count ); } while ( dbus_message_iter_next( &sub_iter ) ); if ( *pi_count == 0 ) goto error; if ( !( p_entries = calloc( *pi_count, sizeof( vlc_keystore_entry ) ) ) ) goto error; dbus_message_iter_init( repmsg, &args ); /* recurse into the reply array */ dbus_message_iter_recurse( &args, &sub_iter ); do { if ( dbus_message_iter_get_arg_type( &sub_iter ) != DBUS_TYPE_DICT_ENTRY ) { msg_Err( p_keystore, "Wrong type not DBUS_TYPE_DICT_ENTRY" ); continue; } /* recurse into the dict-entry in the array */ dbus_message_iter_recurse( &sub_iter, &dict_iter ); if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_STRING ) { msg_Err( p_keystore, "First type of Dict-Entry is not a string" ); continue; } dbus_message_iter_get_basic( &dict_iter, &p_reply ); dbus_message_iter_next(&dict_iter); if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_VARIANT ) { msg_Err( p_keystore, "Second type of Dict-Entry is not a variant" ); continue; } /* recurse into the variant in the dict-entry */ dbus_message_iter_recurse( &dict_iter, &var_iter ); dbus_message_iter_get_basic( &var_iter, &p_secret ); i_size = vlc_b64_decode_binary( &p_secret_decoded, p_secret); if ( key2values( p_reply, &p_entries[i] ) ) goto error; if ( ( vlc_keystore_entry_set_secret( &p_entries[i], p_secret_decoded, i_size ) ) ) goto error; free(p_secret_decoded); i += 1; } while ( dbus_message_iter_next( &sub_iter ) ); } dbus_message_unref( msg ); dbus_message_unref( repmsg ); return p_entries; error: *pi_count = 0; vlc_keystore_release_entries( p_entries, i ); if ( msg ) dbus_message_unref( msg ); if ( repmsg ) dbus_message_unref( repmsg ); return NULL; }
static int show_status(DBusConnection *bus, char **args, unsigned n) { _cleanup_dbus_message_unref_ DBusMessage *reply = NULL; const char *interface = ""; int r; DBusMessageIter iter, sub, sub2, sub3; StatusInfo info = {}; assert(args); r = bus_method_call_with_reply( bus, "org.freedesktop.locale1", "/org/freedesktop/locale1", "org.freedesktop.DBus.Properties", "GetAll", &reply, NULL, DBUS_TYPE_STRING, &interface, DBUS_TYPE_INVALID); if (r < 0) return r; if (!dbus_message_iter_init(reply, &iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY) { log_error("Failed to parse reply."); return -EIO; } dbus_message_iter_recurse(&iter, &sub); while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) { const char *name; if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) { log_error("Failed to parse reply."); return -EIO; } dbus_message_iter_recurse(&sub, &sub2); if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) { log_error("Failed to parse reply."); return -EIO; } if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) { log_error("Failed to parse reply."); return -EIO; } dbus_message_iter_recurse(&sub2, &sub3); r = status_property(name, &sub3, &info); if (r < 0) { log_error("Failed to parse reply."); return r; } dbus_message_iter_next(&sub); } print_status_info(&info); strv_free(info.locale); return 0; }
/*id的范围是1至ACIPLIST_NUM-1*/ int show_ac_ip_list_one_cmd(int instance_id,char *id, DCLI_AC_IP_LIST_API_GROUP **IPLIST)/*返回0表示失败,返回1表示成功,返回-1表示unknown id format*/ /*返回-2表示AC IP LIST id should be 1 to ACIPLIST_NUM-1*/ /*返回-3表示id does not exist,返回-4表示error*/ { if(NULL == id) { *IPLIST = NULL; return 0; } int ret; unsigned char ID = 0; #if 0 int i = 0; unsigned int num = 0; struct wid_ac_ip **iplist; char en[] = "enable"; char dis[] = "disable"; DBusMessage *query, *reply; DBusMessageIter iter; DBusMessageIter iter_array; DBusError err; #endif int retu; ret = parse_char_ID((char*)id, &ID); if(ret != WID_DBUS_SUCCESS){ return -1; } if(ID >= ACIPLIST_NUM || ID == 0){ return -2; } int index; #if 0 char BUSNAME[PATH_LEN]; char OBJPATH[PATH_LEN]; char INTERFACE[PATH_LEN]; #endif /*if(vty->node == CONFIG_NODE){ index = 0; }else if(vty->node == HANSI_NODE){ index = vty->index; }*/ index = instance_id; #if 0 ReInitDbusPath(index,WID_DBUS_BUSNAME,BUSNAME); ReInitDbusPath(index,WID_DBUS_ACIPLIST_OBJPATH,OBJPATH); ReInitDbusPath(index,WID_DBUS_ACIPLIST_INTERFACE,INTERFACE); query = dbus_message_new_method_call(BUSNAME,OBJPATH,INTERFACE,WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST_ONE); /* query = dbus_message_new_method_call(WID_DBUS_BUSNAME,WID_DBUS_ACIPLIST_OBJPATH,\ WID_DBUS_ACIPLIST_INTERFACE,WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST_ONE);*/ dbus_error_init(&err); dbus_message_append_args(query, DBUS_TYPE_BYTE,&ID, DBUS_TYPE_INVALID); reply = dbus_connection_send_with_reply_and_block (dcli_dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply) { vty_out(vty,"<error> failed get reply.\n"); if (dbus_error_is_set(&err)) { vty_out(vty,"%s raised: %s",err.name,err.message); dbus_error_free(&err); } return CMD_SUCCESS; } dbus_message_iter_init(reply,&iter); dbus_message_iter_get_basic(&iter,&ret); if(ret == 0 ) { AC_IP_LIST = (wid_ac_ip_group *)malloc(sizeof(wid_ac_ip_group)); dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,&AC_IP_LIST->GroupID); dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,&AC_IP_LIST->ifname); dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,&num); iplist = malloc(num* sizeof(struct wid_ac_ip *)); memset(iplist, 0, num*sizeof(struct wid_ac_ip*)); dbus_message_iter_next(&iter); dbus_message_iter_recurse(&iter,&iter_array); for (i = 0; i < num; i++) { DBusMessageIter iter_struct; iplist[i] = (struct wid_ac_ip *)malloc(sizeof(struct wid_ac_ip)); dbus_message_iter_recurse(&iter_array,&iter_struct); dbus_message_iter_get_basic(&iter_struct,&(iplist[i]->ip)); dbus_message_iter_next(&iter_struct); dbus_message_iter_get_basic(&iter_struct,&(iplist[i]->priority)); dbus_message_iter_next(&iter_array); } } dbus_message_unref(reply); #endif void*(*dcli_init_func)( int , unsigned char , unsigned int , unsigned int* , unsigned char *, DBusConnection *, char * ); *IPLIST = NULL; if(NULL != ccgi_dl_handle) { dcli_init_func = dlsym(ccgi_dl_handle,"dcli_ac_ip_list_show_api_group"); if(NULL != dcli_init_func) { *IPLIST =(*dcli_init_func) ( index, ID, 0, &ret, 0, ccgi_dbus_connection, WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST_ONE ); } else { return 0; } } else { return 0; } if(ret == -1) { retu = 0; } if((ret == 0)&&(*IPLIST)) { retu = 1; } else if(ret == WID_EBR_NOT_EXIST) { retu = -3; } else { retu = -4; } return retu; }
static QVariant qFetchParameter(DBusMessageIter *it) { switch (dbus_message_iter_get_arg_type(it)) { case DBUS_TYPE_BYTE: return qVariantFromValue(qIterGet<unsigned char>(it)); case DBUS_TYPE_INT16: return qVariantFromValue(qIterGet<dbus_int16_t>(it)); case DBUS_TYPE_UINT16: return qVariantFromValue(qIterGet<dbus_uint16_t>(it)); case DBUS_TYPE_INT32: return qIterGet<dbus_int32_t>(it); case DBUS_TYPE_UINT32: return qIterGet<dbus_uint32_t>(it); case DBUS_TYPE_DOUBLE: return qIterGet<double>(it); case DBUS_TYPE_BOOLEAN: return bool(qIterGet<dbus_bool_t>(it)); case DBUS_TYPE_INT64: return static_cast<qlonglong>(qIterGet<dbus_int64_t>(it)); case DBUS_TYPE_UINT64: return static_cast<qulonglong>(qIterGet<dbus_uint64_t>(it)); case DBUS_TYPE_STRING: case DBUS_TYPE_OBJECT_PATH: case DBUS_TYPE_SIGNATURE: return QString::fromUtf8(qIterGet<char *>(it)); case DBUS_TYPE_VARIANT: return qIterGet<QVariant>(it); case DBUS_TYPE_ARRAY: { int arrayType = dbus_message_iter_get_element_type(it); switch (arrayType) { case DBUS_TYPE_BYTE: { // QByteArray DBusMessageIter sub; dbus_message_iter_recurse(it, &sub); int len = dbus_message_iter_get_array_len(&sub); char* data; dbus_message_iter_get_fixed_array(&sub,&data,&len); return QByteArray(data,len); } case DBUS_TYPE_INT16: return qFetchList<dbus_int16_t, short>(it); case DBUS_TYPE_UINT16: return qFetchList<dbus_uint16_t, ushort>(it); case DBUS_TYPE_INT32: return qFetchList<dbus_int32_t, int>(it); case DBUS_TYPE_UINT32: return qFetchList<dbus_uint32_t, uint>(it); case DBUS_TYPE_BOOLEAN: return qFetchList<dbus_bool_t, bool>(it); case DBUS_TYPE_DOUBLE: return qFetchList<double, double>(it); case DBUS_TYPE_INT64: return qFetchList<dbus_int64_t, qlonglong>(it); case DBUS_TYPE_UINT64: return qFetchList<dbus_uint64_t, qulonglong>(it); case DBUS_TYPE_STRING: case DBUS_TYPE_OBJECT_PATH: case DBUS_TYPE_SIGNATURE: return qFetchStringList(it); case DBUS_TYPE_VARIANT: return qFetchList<QVariant, QVariant>(it); case DBUS_TYPE_DICT_ENTRY: { // ### support other types of maps? QMap<QString, QVariant> map; DBusMessageIter sub; dbus_message_iter_recurse(it, &sub); if (dbus_message_iter_get_array_len(&sub) == 0) // empty map return map; do { DBusMessageIter itemIter; dbus_message_iter_recurse(&sub, &itemIter); Q_ASSERT(dbus_message_iter_has_next(&itemIter)); QString key = qFetchParameter(&itemIter).toString(); dbus_message_iter_next(&itemIter); map.insertMulti(key, qFetchParameter(&itemIter)); } while (dbus_message_iter_next(&sub)); return map; } } } // fall through // common handling for structs and lists of lists (for now) case DBUS_TYPE_STRUCT: { QList<QVariant> list; DBusMessageIter sub; dbus_message_iter_recurse(it, &sub); if (dbus_message_iter_get_array_len(&sub) == 0) return list; do { list.append(qFetchParameter(&sub)); } while (dbus_message_iter_next(&sub)); return list; } default: qWarning("Don't know how to handle type %d '%c'", dbus_message_iter_get_arg_type(it), dbus_message_iter_get_arg_type(it)); return QVariant(); break; } }
static DBusMessage *set_property(DBusConnection *conn, DBusMessage *msg, void *data) { struct connman_technology *technology = data; DBusMessageIter iter, value; const char *name; int type; DBG("conn %p", conn); if (dbus_message_iter_init(msg, &iter) == FALSE) return __connman_error_invalid_arguments(msg); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return __connman_error_invalid_arguments(msg); dbus_message_iter_get_basic(&iter, &name); dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) return __connman_error_invalid_arguments(msg); dbus_message_iter_recurse(&iter, &value); type = dbus_message_iter_get_arg_type(&value); DBG("property %s", name); if (g_str_equal(name, "Tethering") == TRUE) { int err; connman_bool_t tethering; if (type != DBUS_TYPE_BOOLEAN) return __connman_error_invalid_arguments(msg); dbus_message_iter_get_basic(&value, &tethering); if (technology->tethering == tethering) { if (tethering == FALSE) return __connman_error_already_disabled(msg); else return __connman_error_already_enabled(msg); } err = set_tethering(technology, tethering); if (err < 0) return __connman_error_failed(msg, -err); } else if (g_str_equal(name, "TetheringIdentifier") == TRUE) { const char *str; dbus_message_iter_get_basic(&value, &str); if (technology->type != CONNMAN_SERVICE_TYPE_WIFI) return __connman_error_not_supported(msg); if (strlen(str) < 1 || strlen(str) > 32) return __connman_error_invalid_arguments(msg); if (g_strcmp0(technology->tethering_ident, str) != 0) { g_free(technology->tethering_ident); technology->tethering_ident = g_strdup(str); technology_save(technology); connman_dbus_property_changed_basic(technology->path, CONNMAN_TECHNOLOGY_INTERFACE, "TetheringIdentifier", DBUS_TYPE_STRING, &technology->tethering_ident); } } else if (g_str_equal(name, "TetheringPassphrase") == TRUE) { const char *str; dbus_message_iter_get_basic(&value, &str); if (technology->type != CONNMAN_SERVICE_TYPE_WIFI) return __connman_error_not_supported(msg); if (strlen(str) < 8 || strlen(str) > 63) return __connman_error_passphrase_required(msg); if (g_strcmp0(technology->tethering_passphrase, str) != 0) { g_free(technology->tethering_passphrase); technology->tethering_passphrase = g_strdup(str); technology_save(technology); connman_dbus_property_changed_basic(technology->path, CONNMAN_TECHNOLOGY_INTERFACE, "TetheringPassphrase", DBUS_TYPE_STRING, &technology->tethering_passphrase); } } else if (g_str_equal(name, "Powered") == TRUE) { connman_bool_t enable; if (type != DBUS_TYPE_BOOLEAN) return __connman_error_invalid_arguments(msg); dbus_message_iter_get_basic(&value, &enable); return set_powered(technology, msg, enable); } else return __connman_error_invalid_property(msg); return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); }
static int ov_notify(DBusMessage *msg, struct connman_provider *provider) { DBusMessageIter iter, dict; const char *reason, *key, *value; char *nameservers = NULL; char *address = NULL, *gateway = NULL, *peer = NULL; struct connman_ipaddress *ipaddress; dbus_message_iter_init(msg, &iter); dbus_message_iter_get_basic(&iter, &reason); dbus_message_iter_next(&iter); if (!provider) { connman_error("No provider found"); return VPN_STATE_FAILURE; } if (strcmp(reason, "up")) return VPN_STATE_DISCONNECT; dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry; dbus_message_iter_recurse(&dict, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_get_basic(&entry, &value); DBG("%s = %s", key, value); if (!strcmp(key, "trusted_ip")) { connman_provider_set_string(provider, "Gateway", value); gateway = g_strdup(value); } if (!strcmp(key, "ifconfig_local")) { connman_provider_set_string(provider, "Address", value); address = g_strdup(value); } if (!strcmp(key, "ifconfig_remote")) { connman_provider_set_string(provider, "Peer", value); peer = g_strdup(value); } if (g_str_has_prefix(key, "route_") == TRUE) connman_provider_append_route(provider, key, value); ov_append_dns_entries(key, value, &nameservers); dbus_message_iter_next(&dict); } ipaddress = connman_ipaddress_alloc(AF_INET); if (ipaddress == NULL) { g_free(nameservers); g_free(address); g_free(gateway); g_free(peer); return VPN_STATE_FAILURE; } connman_ipaddress_set_ipv4(ipaddress, address, NULL, gateway); connman_ipaddress_set_peer(ipaddress, peer); connman_provider_set_ipaddress(provider, ipaddress); connman_provider_set_nameservers(provider, nameservers); g_free(nameservers); g_free(address); g_free(gateway); g_free(peer); connman_ipaddress_free(ipaddress); return VPN_STATE_CONNECT; }
static int l2tp_notify(DBusMessage *msg, struct vpn_provider *provider) { DBusMessageIter iter, dict; const char *reason, *key, *value; char *addressv4 = NULL, *netmask = NULL, *gateway = NULL; char *ifname = NULL, *nameservers = NULL; struct connman_ipaddress *ipaddress = NULL; dbus_message_iter_init(msg, &iter); dbus_message_iter_get_basic(&iter, &reason); dbus_message_iter_next(&iter); if (!provider) { connman_error("No provider found"); return VPN_STATE_FAILURE; } if (strcmp(reason, "auth failed") == 0) { DBG("authentication failure"); vpn_provider_set_string(provider, "L2TP.User", NULL); vpn_provider_set_string(provider, "L2TP.Password", NULL); return VPN_STATE_AUTH_FAILURE; } if (strcmp(reason, "connect")) return VPN_STATE_DISCONNECT; dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry; dbus_message_iter_recurse(&dict, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_get_basic(&entry, &value); DBG("%s = %s", key, value); if (!strcmp(key, "INTERNAL_IP4_ADDRESS")) { vpn_provider_set_string(provider, "Address", value); addressv4 = g_strdup(value); } if (!strcmp(key, "INTERNAL_IP4_NETMASK")) { vpn_provider_set_string(provider, "Netmask", value); netmask = g_strdup(value); } if (!strcmp(key, "INTERNAL_IP4_DNS")) { vpn_provider_set_string(provider, "DNS", value); nameservers = g_strdup(value); } if (!strcmp(key, "INTERNAL_IFNAME")) ifname = g_strdup(value); dbus_message_iter_next(&dict); } if (vpn_set_ifname(provider, ifname) < 0) { g_free(ifname); g_free(addressv4); g_free(netmask); g_free(nameservers); return VPN_STATE_FAILURE; } if (addressv4 != NULL) ipaddress = connman_ipaddress_alloc(AF_INET); g_free(ifname); if (ipaddress == NULL) { connman_error("No IP address for provider"); g_free(addressv4); g_free(netmask); g_free(nameservers); return VPN_STATE_FAILURE; } value = vpn_provider_get_string(provider, "HostIP"); if (value != NULL) { vpn_provider_set_string(provider, "Gateway", value); gateway = g_strdup(value); } if (addressv4 != NULL) connman_ipaddress_set_ipv4(ipaddress, addressv4, netmask, gateway); vpn_provider_set_ipaddress(provider, ipaddress); vpn_provider_set_nameservers(provider, nameservers); g_free(addressv4); g_free(netmask); g_free(gateway); g_free(nameservers); connman_ipaddress_free(ipaddress); return VPN_STATE_CONNECT; }
GList * systemd_unit_listall(void) { int nfiles = 0; GList *units = NULL; DBusMessageIter args; DBusMessageIter unit; DBusMessageIter elem; DBusMessage *reply = NULL; if (systemd_init() == FALSE) { return NULL; } /* " <method name=\"ListUnitFiles\">\n" \ " <arg name=\"files\" type=\"a(ss)\" direction=\"out\"/>\n" \ " </method>\n" \ */ reply = systemd_call_simple_method("ListUnitFiles"); if (reply == NULL) { return NULL; } if (!dbus_message_iter_init(reply, &args)) { crm_err("Could not list systemd unit files: systemd reply has no arguments"); dbus_message_unref(reply); return NULL; } if (!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY, __FUNCTION__, __LINE__)) { crm_err("Could not list systemd unit files: systemd reply has invalid arguments"); dbus_message_unref(reply); return NULL; } dbus_message_iter_recurse(&args, &unit); for (; dbus_message_iter_get_arg_type(&unit) != DBUS_TYPE_INVALID; dbus_message_iter_next(&unit)) { DBusBasicValue value; const char *match = NULL; char *unit_name = NULL; char *basename = NULL; if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_STRUCT, __FUNCTION__, __LINE__)) { crm_debug("ListUnitFiles reply has unexpected type"); continue; } dbus_message_iter_recurse(&unit, &elem); if(!pcmk_dbus_type_check(reply, &elem, DBUS_TYPE_STRING, __FUNCTION__, __LINE__)) { crm_debug("ListUnitFiles reply does not contain a string"); continue; } dbus_message_iter_get_basic(&elem, &value); if (value.str == NULL) { crm_debug("ListUnitFiles reply did not provide a string"); continue; } crm_trace("DBus ListUnitFiles listed: %s", value.str); match = systemd_unit_extension(value.str); if (match == NULL) { // Unit files always have an extension, so skip if not present crm_debug("ListUnitFiles entry '%s' does not have an extension", value.str); continue; } // ListUnitFiles returns full path names basename = strrchr(value.str, '/'); if (basename) { basename = basename + 1; } else { basename = value.str; } /* Unit files will include types (such as .target) that we can't manage, * so filter the replies here. */ if (!strcmp(match, ".service")) { // Service is the "default" unit type, so strip it unit_name = strndup(basename, match - basename); } else if (!strcmp(match, ".mount") || !strcmp(match, ".socket")) { unit_name = strdup(basename); } if (unit_name == NULL) { crm_trace("ListUnitFiles entry '%s' is not manageable", value.str); continue; } nfiles++; units = g_list_prepend(units, unit_name); } dbus_message_unref(reply); crm_trace("Found %d manageable systemd unit files", nfiles); units = g_list_sort(units, crm_alpha_sort); return units; }
DBusHandlerResult avahi_service_resolver_event (AvahiClient *client, AvahiResolverEvent event, DBusMessage *message) { AvahiServiceResolver *r = NULL; DBusError error; const char *path; AvahiStringList *strlst = NULL; assert(client); assert(message); dbus_error_init (&error); if (!(path = dbus_message_get_path(message))) goto fail; for (r = client->service_resolvers; r; r = r->service_resolvers_next) if (strcmp (r->path, path) == 0) break; if (!r) goto fail; switch (event) { case AVAHI_RESOLVER_FOUND: { int j; int32_t interface, protocol, aprotocol; uint32_t flags; char *name, *type, *domain, *host, *address; uint16_t port; DBusMessageIter iter, sub; AvahiAddress a; if (!dbus_message_get_args( message, &error, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &type, DBUS_TYPE_STRING, &domain, DBUS_TYPE_STRING, &host, DBUS_TYPE_INT32, &aprotocol, DBUS_TYPE_STRING, &address, DBUS_TYPE_UINT16, &port, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } dbus_message_iter_init(message, &iter); for (j = 0; j < 9; j++) dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY) { fprintf(stderr, "Error parsing service resolving message\n"); goto fail; } strlst = NULL; dbus_message_iter_recurse(&iter, &sub); for (;;) { DBusMessageIter sub2; int at; const uint8_t *k; int n; if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID) break; assert(at == DBUS_TYPE_ARRAY); if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) { fprintf(stderr, "Error parsing service resolving message\n"); goto fail; } dbus_message_iter_recurse(&sub, &sub2); k = NULL; n = 0; dbus_message_iter_get_fixed_array(&sub2, &k, &n); if (k && n > 0) strlst = avahi_string_list_add_arbitrary(strlst, k, n); dbus_message_iter_next(&sub); } dbus_message_iter_next(&iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } dbus_message_iter_get_basic(&iter, &flags); assert(address); if (address[0] == 0) address = NULL; else avahi_address_parse(address, (AvahiProtocol) aprotocol, &a); r->callback(r, (AvahiIfIndex) interface, (AvahiProtocol) protocol, AVAHI_RESOLVER_FOUND, name, type, domain, host, address ? &a : NULL, port, strlst, (AvahiLookupResultFlags) flags, r->userdata); avahi_string_list_free(strlst); break; } case AVAHI_RESOLVER_FAILURE: { char *etxt; if (!dbus_message_get_args( message, &error, DBUS_TYPE_STRING, &etxt, DBUS_TYPE_INVALID) || dbus_error_is_set (&error)) { fprintf(stderr, "Failed to parse resolver event.\n"); goto fail; } avahi_client_set_errno(r->client, avahi_error_dbus_to_number(etxt)); r->callback(r, r->interface, r->protocol, event, r->name, r->type, r->domain, NULL, NULL, 0, NULL, 0, r->userdata); break; } } return DBUS_HANDLER_RESULT_HANDLED; fail: dbus_error_free (&error); avahi_string_list_free(strlst); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
int bridge_request_json_params_parse(bridge_request_t *self, DBusMessageIter *it, struct json_object **result, const char **key) { int ret; const char *unused; int type = dbus_message_iter_get_arg_type(it); *key = 0; *result = 0; switch (type) { case DBUS_TYPE_STRING: case DBUS_TYPE_SIGNATURE: case DBUS_TYPE_OBJECT_PATH: { char *value; dbus_message_iter_get_basic(it, &value); *result = json_object_new_string(value); break; } case DBUS_TYPE_UINT16: case DBUS_TYPE_UINT32: case DBUS_TYPE_UINT64: { uint64_t value = 0; dbus_message_iter_get_basic(it, &value); *result = json_object_new_int64(value); break; } case DBUS_TYPE_INT16: case DBUS_TYPE_INT32: case DBUS_TYPE_INT64: case DBUS_TYPE_BYTE: { int64_t value = 0; dbus_message_iter_get_basic(it, &value); *result = json_object_new_int64(value); break; } case DBUS_TYPE_DOUBLE: { double value; dbus_message_iter_get_basic(it, &value); *result = json_object_new_double(value); break; } case DBUS_TYPE_BOOLEAN: { int value; dbus_message_iter_get_basic(it, &value); *result = json_object_new_boolean(value); break; } case DBUS_TYPE_ARRAY: case DBUS_TYPE_STRUCT: case DBUS_TYPE_VARIANT: { DBusMessageIter args; dbus_message_iter_recurse(it, &args); ret = bridge_request_json_params(self, &args, result, ((type == DBUS_TYPE_ARRAY) || (type == DBUS_TYPE_STRUCT))); if (ret != 0) return ret; break; } case DBUS_TYPE_DICT_ENTRY: { DBusMessageIter args; dbus_message_iter_recurse(it, &args); if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_STRING) { bridge_request_error(self, "dictionary with non-string keys not supported."); return EINVAL; } dbus_message_iter_get_basic(&args, key); if (!dbus_message_iter_has_next(&args)) break; dbus_message_iter_next(&args); ret = bridge_request_json_params_parse(self, &args, result, &unused); if (ret != 0) return ret; break; } default: break; } if (!*result) { bridge_request_error(self, "Unexpected error while parsing D-Bus arguments."); FCGX_FPrintF(self->request.err, "arg: %i\n", dbus_message_iter_get_arg_type(it)); return EINVAL; } return 0; }
int __connman_session_create(DBusMessage *msg) { const char *owner, *notify_path; char *session_path = NULL; DBusMessageIter iter, array; struct connman_session *session = NULL; struct user_config *user_config = NULL; connman_bool_t user_allowed_bearers = FALSE; connman_bool_t user_connection_type = FALSE; int err; owner = dbus_message_get_sender(msg); DBG("owner %s", owner); if (ecall_session != NULL && ecall_session->ecall == TRUE) { /* * If there is an emergency call already going on, * ignore session creation attempt */ err = -EBUSY; goto err; } user_config = g_try_new0(struct user_config, 1); if (user_config == NULL) { err = -ENOMEM; goto err; } user_config->pending = dbus_message_ref(msg); dbus_message_iter_init(msg, &iter); dbus_message_iter_recurse(&iter, &array); while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry, value; const char *key, *val; dbus_message_iter_recurse(&array, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_recurse(&entry, &value); switch (dbus_message_iter_get_arg_type(&value)) { case DBUS_TYPE_ARRAY: if (g_str_equal(key, "AllowedBearers") == TRUE) { err = parse_bearers(&value, &user_config->allowed_bearers); if (err < 0) goto err; user_allowed_bearers = TRUE; } else { err = -EINVAL; goto err; } break; case DBUS_TYPE_STRING: if (g_str_equal(key, "ConnectionType") == TRUE) { dbus_message_iter_get_basic(&value, &val); user_config->type = connman_session_parse_connection_type(val); user_connection_type = TRUE; } else { err = -EINVAL; goto err; } } dbus_message_iter_next(&array); } /* * If the user hasn't provided a configuration, we set * the default configuration. * * For AllowedBearers this is '*', ... */ if (user_allowed_bearers == FALSE) { user_config->allowed_bearers = g_slist_append(NULL, GINT_TO_POINTER(CONNMAN_SERVICE_TYPE_UNKNOWN)); if (user_config->allowed_bearers == NULL) { err = -ENOMEM; goto err; } } /* ... and for ConnectionType it is 'any'. */ if (user_connection_type == FALSE) user_config->type = CONNMAN_SESSION_TYPE_ANY; dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter, ¬ify_path); if (notify_path == NULL) { err = -EINVAL; goto err; } session_path = g_strdup_printf("/sessions%s", notify_path); if (session_path == NULL) { err = -ENOMEM; goto err; } session = g_hash_table_lookup(session_hash, session_path); if (session != NULL) { g_free(session_path); session = NULL; err = -EEXIST; goto err; } session = g_try_new0(struct connman_session, 1); if (session == NULL) { g_free(session_path); err = -ENOMEM; goto err; } session->session_path = session_path; session->info = g_try_new0(struct session_info, 1); if (session->info == NULL) { err = -ENOMEM; goto err; } session->info_last = g_try_new0(struct session_info, 1); if (session->info_last == NULL) { err = -ENOMEM; goto err; } session->owner = g_strdup(owner); session->notify_path = g_strdup(notify_path); session->notify_watch = g_dbus_add_disconnect_watch(connection, session->owner, owner_disconnect, session, NULL); err = assign_policy_plugin(session); if (err < 0) goto err; err = create_policy_config(session, session_create_cb, user_config); if (err < 0 && err != -EINPROGRESS) return err; return -EINPROGRESS; err: connman_error("Failed to create session"); free_session(session); cleanup_user_config(user_config); return err; }
static void request_input_passphrase_reply(DBusPendingCall *call, void *user_data) { struct request_input_reply *passphrase_reply = user_data; connman_bool_t wps = FALSE; char *identity = NULL; char *passphrase = NULL; char *wpspin = NULL; char *key; DBusMessageIter iter, dict; DBusMessage *reply = dbus_pending_call_steal_reply(call); if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) goto done; dbus_message_iter_init(reply, &iter); dbus_message_iter_recurse(&iter, &dict); while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) { DBusMessageIter entry, value; dbus_message_iter_recurse(&dict, &entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) break; dbus_message_iter_get_basic(&entry, &key); if (g_str_equal(key, "Identity")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); dbus_message_iter_get_basic(&value, &identity); } else if (g_str_equal(key, "Passphrase")) { dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); dbus_message_iter_get_basic(&value, &passphrase); } else if (g_str_equal(key, "WPS")) { wps = TRUE; dbus_message_iter_next(&entry); if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) break; dbus_message_iter_recurse(&entry, &value); dbus_message_iter_get_basic(&value, &wpspin); break; } dbus_message_iter_next(&dict); } if (wps == TRUE) { struct connman_network *network; network = __connman_service_get_network( passphrase_reply->service); if (network == NULL) goto done; connman_network_set_bool(network, "WiFi.UseWPS", wps); if (wpspin != NULL && strlen(wpspin) > 0) connman_network_set_string(network, "WiFi.PinWPS", wpspin); else connman_network_set_string(network, "WiFi.PinWPS", NULL); } done: passphrase_reply->callback(passphrase_reply->service, identity, passphrase, passphrase_reply->user_data); connman_service_unref(passphrase_reply->service); dbus_message_unref(reply); g_free(passphrase_reply); }
/** * get all properties of @a dbus_device_path as @a value struct via dbus @a connection * * network manager dbus methods are documented here: * https://developer.gnome.org/NetworkManager/unstable/spec.html#org.freedesktop.NetworkManager.Device */ static int networkmanager_device_properties(DBusConnection* dbus_connection, qaul_dbus_device_properties* device) { DBusMessage* msg; DBusMessageIter iter, iter_array, iter_dict, iter_prop; DBusPendingCall* pending; int success, set_Type, set_Interface, set_State, current_type; char* property_ptr; char* key_ptr; networkmanager_property device_property; const char* dbus_interface = "org.freedesktop.NetworkManager.Device"; // reset values set_Type = 0; set_Interface = 0; set_State = 0; device->type = 0; device->state = 0; strncpy(device->interface, "", sizeof(device->interface)); msg = dbus_message_new_method_call( "org.freedesktop.NetworkManager", device->dbus_device_path, "org.freedesktop.DBus.Properties", "GetAll" ); if(msg == NULL) { printf("networkmanager_device_properties msg error\n"); return 0; } dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &dbus_interface); // send dbus message // -1 is the default time out. Other time outs can be configured in milli seconds. success = dbus_connection_send_with_reply(dbus_connection, msg, &pending, -1); if(!success) { printf("networkmanager_device_properties dbus send error\n"); return 0; } if(pending == NULL) { printf ("networkmanager_device_properties dbus calling error\n"); return 0; } dbus_connection_flush(dbus_connection); dbus_message_unref(msg); dbus_pending_call_block(pending); msg = dbus_pending_call_steal_reply(pending); dbus_pending_call_unref(pending); if(msg == NULL) { printf("networkmanager_device_properties msg error 2\n"); return 0; } if(!dbus_message_iter_init(msg, &iter)) { printf("networkmanager_device_properties dbus_message_iter_init error\n"); dbus_message_unref(msg); return 0; } if(dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) { printf("networkmanager_device_properties dbus_message_iter_get_arg_type return is not a DBUS_TYPE_ARRAY %i\n", dbus_message_iter_get_arg_type(&iter)); if(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING) { dbus_message_iter_get_basic(&iter, &property_ptr); printf("networkmanager_device_properties error msg: %s\n", property_ptr); } dbus_message_unref(msg); return 0; } // loop over the array dbus_message_iter_recurse(&iter, &iter_array); while((current_type = dbus_message_iter_get_arg_type(&iter_array)) != DBUS_TYPE_INVALID) { // check if it is a dict entry if(dbus_message_iter_get_arg_type(&iter_array) == DBUS_TYPE_DICT_ENTRY) { dbus_message_iter_recurse(&iter_array, &iter_dict); // get key dbus_message_iter_get_basic(&iter_dict, &key_ptr); // get property if(dbus_message_iter_next(&iter_dict)) { dbus_message_iter_recurse(&iter_dict, &iter_prop); if (strcmp(key_ptr, "Interface") == 0) { if(dbus_message_iter_get_arg_type(&iter_prop) == DBUS_TYPE_STRING) { dbus_message_iter_get_basic(&iter_prop, &property_ptr); strncpy(device->interface, property_ptr, sizeof(device->interface)); printf("networkmanager_device_get_property interface %s\n", property_ptr); set_Interface = 1; } else printf("networkmanager_device_properties Interface not DBUS_TYPE_STRING %i\n", dbus_message_iter_get_arg_type(&iter_prop)); } else if(strcmp(key_ptr, "DeviceType") == 0) { if(dbus_message_iter_get_arg_type(&iter_prop) == DBUS_TYPE_UINT32) { dbus_message_iter_get_basic(&iter_prop, &device->type); printf("networkmanager_device_get_property DeviceType %i\n", device->type); set_Type = 1; } else printf("networkmanager_device_properties DeviceType not DBUS_TYPE_UINT32 %i\n", dbus_message_iter_get_arg_type(&iter_prop)); } else if(strcmp(key_ptr, "State") == 0) { if(dbus_message_iter_get_arg_type(&iter_prop) == DBUS_TYPE_UINT32) { dbus_message_iter_get_basic(&iter_prop, &device->state); printf("networkmanager_device_get_property State %i\n", device->state); set_State = 1; } else printf("networkmanager_device_properties state not DBUS_TYPE_UINT32 %i\n", dbus_message_iter_get_arg_type(&iter_prop)); } } } dbus_message_iter_next(&iter_array); } dbus_message_unref(msg); // store dbus path printf("networkmanager_device_properties device_property.dbus_path\n"); device_property.dbus_path = device->dbus_device_path; printf("networkmanager_device_properties device_property.dbus_interface\n"); if(device->type == 2) device_property.dbus_interface = "org.freedesktop.NetworkManager.Device.Wireless"; else if(device->type == 1) device_property.dbus_interface = "org.freedesktop.NetworkManager.Device.Wired"; else device_property.dbus_interface = ""; // retrieve Hardware address property only for known device types if(device->type == 1 || device->type == 2) { printf("networkmanager_device_properties device->mac\n"); device_property.dbus_property_name = "PermHwAddress"; device_property.value_string = device->mac; device_property.value_string_len = sizeof(device->mac); } if(strlen(device_property.dbus_interface)>0) { if(!networkmanager_get_property(dbus_connection, &device_property)) printf("qaul_network_device_get_by_interface get %s property error\n", device_property.dbus_property_name); } else printf("qaul_network_device_get_by_interface no supported type for Hardware MAC address\n"); if(!set_Type) printf("networkmanager_device_properties Device type not set.\n"); if(!set_Interface) printf("networkmanager_device_properties Interface name not set\n"); if(!set_State) printf("networkmanager_device_properties Device state not set\n"); return 1; }
GList * systemd_unit_listall(void) { int lpc = 0; GList *units = NULL; DBusMessageIter args; DBusMessageIter unit; DBusMessageIter elem; DBusMessage *reply = NULL; if (systemd_init() == FALSE) { return NULL; } /* " <method name=\"ListUnits\">\n" \ " <arg name=\"units\" type=\"a(ssssssouso)\" direction=\"out\"/>\n" \ " </method>\n" \ */ reply = systemd_call_simple_method("ListUnits"); if (reply == NULL) { return NULL; } if (!dbus_message_iter_init(reply, &args)) { crm_err("Could not list systemd units: systemd reply has no arguments"); dbus_message_unref(reply); return NULL; } if (!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY, __FUNCTION__, __LINE__)) { crm_err("Could not list systemd units: systemd reply has invalid arguments"); dbus_message_unref(reply); return NULL; } dbus_message_iter_recurse(&args, &unit); while (dbus_message_iter_get_arg_type (&unit) != DBUS_TYPE_INVALID) { DBusBasicValue value; if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_STRUCT, __FUNCTION__, __LINE__)) { continue; } dbus_message_iter_recurse(&unit, &elem); if(!pcmk_dbus_type_check(reply, &elem, DBUS_TYPE_STRING, __FUNCTION__, __LINE__)) { continue; } dbus_message_iter_get_basic(&elem, &value); crm_trace("DBus ListUnits listed: %s", value.str); if(value.str) { const char *match = systemd_unit_extension(value.str); if (match) { char *unit_name; if (!strcmp(match, ".service")) { /* service is the "default" unit type, so strip it */ unit_name = strndup(value.str, match - value.str); } else { unit_name = strdup(value.str); } lpc++; units = g_list_append(units, unit_name); } } dbus_message_iter_next (&unit); } dbus_message_unref(reply); crm_trace("Found %d systemd services", lpc); return units; }
/** * find the first wifi device * * @retval 1 wifi device found, properties set * @retval 0 no wifi device found, properties not set */ int qaul_network_find_wifi(DBusConnection* dbus_connection, qaul_dbus_device_properties* device) { DBusMessage* msg; DBusMessageIter iter, iter_array; int current_type; const char* device_path_ptr; printf("qaul_network_find_wifi\n"); msg = networkmanager_dbus_method_call("GetDevices"); if(msg == NULL) return 0; dbus_message_iter_init_append(msg, &iter); if(!networkmanager_dbus_send(&msg, dbus_connection)) { printf("qaul_network_find_wifi networkmanager_dbus_send error\n"); return 0; } if(!dbus_message_iter_init(msg, &iter) || dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) { printf("qaul_network_find_wifi dbus_message_iter_init | DBUS_TYPE_ARRAY error\n"); dbus_message_unref(msg); return 0; } // loop recursively over the array dbus_message_iter_recurse (&iter, &iter_array); while((current_type = dbus_message_iter_get_arg_type(&iter_array)) != DBUS_TYPE_INVALID) { if(current_type == DBUS_TYPE_OBJECT_PATH) { dbus_message_iter_get_basic(&iter_array, &device_path_ptr); strncpy(device->dbus_device_path, device_path_ptr, sizeof(device->dbus_device_path)); // get interface name, type // dbus low level: dbus_message_new_method_call interface:"org.freedesktop.DBus.Properties" method:"Get" property:"(String)Interface, (UInt32)DeviceType" if(networkmanager_device_properties(dbus_connection, device)) { if(device->type == 2 && device->state > 20) { printf("qaul_network_find_wifi wifi found: %s\n", device->interface); dbus_message_unref(msg); return 1; } } else printf("qaul_network_find_wifi networkmanager_device_get_property failed for %s\n", device->dbus_device_path); } else printf("qaul_network_find_wifi Unknown current type [%i]\n", current_type); dbus_message_iter_next(&iter_array); } dbus_message_unref(msg); printf("qaul_network_find_wifi no wifi device found\n"); return 0; }
/*返回1时,调用Free_show_ac_ip_list()释放空间*/ int show_ac_ip_list_cmd(int instance_id,DCLI_AC_IP_LIST_API_GROUP **IPLIST)/*返回0表示失败,返回1表示成功*/ { int ret; #if 0 int i = 0; int num = 0; wid_ac_ip_group *ACIPLIST[ACIPLIST_NUM]; DBusMessage *query, *reply; DBusMessageIter iter; DBusMessageIter iter_array; DBusError err; char en[] = "enable"; char dis[] = "disable"; #endif int retu; int index; #if 0 char BUSNAME[PATH_LEN]; char OBJPATH[PATH_LEN]; char INTERFACE[PATH_LEN]; #endif /*if(vty->node == CONFIG_NODE){ index = 0; }else if(vty->node == HANSI_NODE){ index = vty->index; }*/ index = instance_id; #if 0 ReInitDbusPath(index,WID_DBUS_BUSNAME,BUSNAME); ReInitDbusPath(index,WID_DBUS_ACIPLIST_OBJPATH,OBJPATH); ReInitDbusPath(index,WID_DBUS_ACIPLIST_INTERFACE,INTERFACE); query = dbus_message_new_method_call(BUSNAME,OBJPATH,INTERFACE,WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST); /* query = dbus_message_new_method_call(WID_DBUS_BUSNAME,WID_DBUS_ACIPLIST_OBJPATH,\ WID_DBUS_ACIPLIST_INTERFACE,WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST);*/ dbus_error_init(&err); reply = dbus_connection_send_with_reply_and_block (dcli_dbus_connection,query,-1, &err); dbus_message_unref(query); if (NULL == reply) { vty_out(vty,"<error> failed get reply.\n"); if (dbus_error_is_set(&err)) { vty_out(vty,"%s raised: %s",err.name,err.message); dbus_error_free(&err); } return CMD_SUCCESS; } dbus_message_iter_init(reply,&iter); dbus_message_iter_get_basic(&iter,&ret); if(ret == 0 ) { dbus_message_iter_next(&iter); dbus_message_iter_get_basic(&iter,&num); dbus_message_iter_next(&iter); dbus_message_iter_recurse(&iter,&iter_array); for (i = 0; i < num; i++) { DBusMessageIter iter_struct; ACIPLIST[i] = (wid_ac_ip_group *)malloc(sizeof(wid_ac_ip_group)); dbus_message_iter_recurse(&iter_array,&iter_struct); dbus_message_iter_get_basic(&iter_struct,&(ACIPLIST[i]->GroupID)); dbus_message_iter_next(&iter_struct); dbus_message_iter_get_basic(&iter_struct,&(ACIPLIST[i]->ifname)); dbus_message_iter_next(&iter_array); } } dbus_message_unref(reply); #endif void*(*dcli_init_func)( int , unsigned char , unsigned int , unsigned int* , unsigned char *, DBusConnection *, char * ); *IPLIST = NULL; if(NULL != ccgi_dl_handle) { dcli_init_func = dlsym(ccgi_dl_handle,"dcli_ac_ip_list_show_api_group"); if(NULL != dcli_init_func) { *IPLIST =(*dcli_init_func) ( index, 0, 0, &ret, 0, ccgi_dbus_connection, WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST ); } else { return 0; } } else { return 0; } if(ret == -1) { retu = 0; } if((ret == 0)&&(*IPLIST)) { retu = 1; } return retu; }
GList * upstart_job_listall(void) { GList *units = NULL; DBusMessageIter args; DBusMessageIter unit; DBusMessage *msg = NULL; DBusMessage *reply = NULL; const char *method = "GetAllJobs"; DBusError error; int lpc = 0; if (upstart_init() == FALSE) { return NULL; } /* com.ubuntu.Upstart0_6.GetAllJobs (out <Array of ObjectPath> jobs) */ dbus_error_init(&error); msg = dbus_message_new_method_call(BUS_NAME, // target for the method call BUS_PATH, // object to call on UPSTART_06_API, // interface to call on method); // method name CRM_ASSERT(msg != NULL); reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, DBUS_TIMEOUT_USE_DEFAULT); dbus_message_unref(msg); if (dbus_error_is_set(&error)) { crm_err("Call to %s failed: %s", method, error.message); dbus_error_free(&error); return NULL; } else if (!dbus_message_iter_init(reply, &args)) { crm_err("Call to %s failed: Message has no arguments", method); dbus_message_unref(reply); return NULL; } if(!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY, __FUNCTION__, __LINE__)) { crm_err("Call to %s failed: Message has invalid arguments", method); dbus_message_unref(reply); return NULL; } dbus_message_iter_recurse(&args, &unit); while (dbus_message_iter_get_arg_type (&unit) != DBUS_TYPE_INVALID) { DBusBasicValue value; const char *job = NULL; char *path = NULL; if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_OBJECT_PATH, __FUNCTION__, __LINE__)) { continue; } dbus_message_iter_get_basic(&unit, &value); if(value.str) { int llpc = 0; path = value.str; job = value.str; while (path[llpc] != 0) { if (path[llpc] == '/') { job = path + llpc + 1; } llpc++; } lpc++; crm_trace("%s -> %s", path, job); units = g_list_append(units, fix_upstart_name(job)); } dbus_message_iter_next (&unit); } dbus_message_unref(reply); crm_trace("Found %d upstart jobs", lpc); return units; }
bool dp_unpack_pam_response(DBusMessage *msg, struct pam_data *pd, DBusError *dbus_error) { DBusMessageIter iter; DBusMessageIter array_iter; DBusMessageIter struct_iter; DBusMessageIter sub_iter; int type; int len; const uint8_t *data; if (!dbus_message_iter_init(msg, &iter)) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response has no arguments.\n"); return false; } if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_get_basic(&iter, &(pd->pam_status)); if (!dbus_message_iter_next(&iter)) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response has too few arguments.\n"); return false; } if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_get_basic(&iter, &(pd->account_locked)); if (!dbus_message_iter_next(&iter)) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response has too few arguments.\n"); return false; } /* After this point will be an array of pam data */ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); DEBUG(SSSDBG_CRIT_FAILURE, "Type was %c\n", (char)dbus_message_iter_get_arg_type(&iter)); return false; } if (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_recurse(&iter, &array_iter); while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID) { /* Read in a pam data struct */ if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_STRUCT) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_recurse(&array_iter, &struct_iter); /* PAM data struct contains a type and a byte-array of data */ /* Get the pam data type */ if (dbus_message_iter_get_arg_type(&struct_iter) != DBUS_TYPE_UINT32) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_get_basic(&struct_iter, &type); if (!dbus_message_iter_next(&struct_iter)) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } /* Get the byte array */ if (dbus_message_iter_get_arg_type(&struct_iter) != DBUS_TYPE_ARRAY || dbus_message_iter_get_element_type(&struct_iter) != DBUS_TYPE_BYTE) { DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n"); return false; } dbus_message_iter_recurse(&struct_iter, &sub_iter); dbus_message_iter_get_fixed_array(&sub_iter, &data, &len); if (pam_add_response(pd, type, len, data) != EOK) { DEBUG(SSSDBG_CRIT_FAILURE, "pam_add_response failed.\n"); return false; } dbus_message_iter_next(&array_iter); } return true; }