static void append_route(DBusMessageIter *iter, void *user_data) { struct vpn_route *route = user_data; DBusMessageIter item; int family = 0; connman_dbus_dict_open(iter, &item); if (route == NULL) goto empty_dict; if (route->family == AF_INET) family = 4; else if (route->family == AF_INET6) family = 6; if (family != 0) connman_dbus_dict_append_basic(&item, "ProtocolFamily", DBUS_TYPE_INT32, &family); if (route->network != NULL) connman_dbus_dict_append_basic(&item, "Network", DBUS_TYPE_STRING, &route->network); if (route->netmask != NULL) connman_dbus_dict_append_basic(&item, "Netmask", DBUS_TYPE_STRING, &route->netmask); if (route->gateway != NULL) connman_dbus_dict_append_basic(&item, "Gateway", DBUS_TYPE_STRING, &route->gateway); empty_dict: connman_dbus_dict_close(iter, &item); }
static DBusMessage *get_properties(DBusConnection *conn, DBusMessage *msg, void *data) { DBusMessage *reply; DBusMessageIter array, dict; dbus_bool_t offlinemode; const char *str; DBG("conn %p", conn); reply = dbus_message_new_method_return(msg); if (!reply) return NULL; dbus_message_iter_init_append(reply, &array); connman_dbus_dict_open(&array, &dict); str = __connman_notifier_get_state(); connman_dbus_dict_append_basic(&dict, "State", DBUS_TYPE_STRING, &str); offlinemode = __connman_technology_get_offlinemode(); connman_dbus_dict_append_basic(&dict, "OfflineMode", DBUS_TYPE_BOOLEAN, &offlinemode); connman_dbus_dict_append_basic(&dict, "SessionMode", DBUS_TYPE_BOOLEAN, &sessionmode); connman_dbus_dict_close(&array, &dict); return reply; }
static DBusMessage *get_properties(DBusConnection *conn, DBusMessage *msg, void *data) { DBusMessage *reply; DBusMessageIter array, dict; connman_bool_t offlinemode, sessionmode; const char *str; DBG("conn %p", conn); reply = dbus_message_new_method_return(msg); if (reply == NULL) return NULL; dbus_message_iter_init_append(reply, &array); connman_dbus_dict_open(&array, &dict); connman_dbus_dict_append_array(&dict, "Services", DBUS_TYPE_OBJECT_PATH, __connman_service_list, NULL); connman_dbus_dict_append_array(&dict, "Technologies", DBUS_TYPE_OBJECT_PATH, __connman_technology_list, NULL); str = __connman_notifier_get_state(); connman_dbus_dict_append_basic(&dict, "State", DBUS_TYPE_STRING, &str); offlinemode = __connman_technology_get_offlinemode(); connman_dbus_dict_append_basic(&dict, "OfflineMode", DBUS_TYPE_BOOLEAN, &offlinemode); connman_dbus_dict_append_array(&dict, "AvailableTechnologies", DBUS_TYPE_STRING, __connman_notifier_list_registered, NULL); connman_dbus_dict_append_array(&dict, "EnabledTechnologies", DBUS_TYPE_STRING, __connman_notifier_list_enabled, NULL); connman_dbus_dict_append_array(&dict, "ConnectedTechnologies", DBUS_TYPE_STRING, __connman_notifier_list_connected, NULL); str = __connman_service_default(); if (str != NULL) connman_dbus_dict_append_basic(&dict, "DefaultTechnology", DBUS_TYPE_STRING, &str); connman_dbus_dict_append_array(&dict, "AvailableDebugs", DBUS_TYPE_STRING, __connman_debug_list_available, NULL); connman_dbus_dict_append_array(&dict, "EnabledDebugs", DBUS_TYPE_STRING, __connman_debug_list_enabled, NULL); sessionmode = __connman_session_mode(); connman_dbus_dict_append_basic(&dict, "SessionMode", DBUS_TYPE_BOOLEAN, &sessionmode); connman_dbus_dict_close(&array, &dict); return reply; }
static void request_input_append_ssid(DBusMessageIter *iter, void *user_data) { const char *str = "ssid"; connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &str); str = "alternate"; connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &str); }
static void request_input_append_identity(DBusMessageIter *iter, void *user_data) { char *str = "string"; connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &str); str = "Mandatory"; connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &str); }
static void request_input_append_password(DBusMessageIter *iter, void *user_data) { char *str = "passphrase"; connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &str); str = "mandatory"; connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &str); }
static void request_input_append_name(DBusMessageIter *iter, void *user_data) { const char *str = "string"; connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &str); str = "mandatory"; connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &str); connman_dbus_dict_append_array(iter, "Alternates", DBUS_TYPE_STRING, request_input_append_alternates, "SSID"); }
static void request_input_append_previouspassphrase(DBusMessageIter *iter, void *user_data) { struct previous_passphrase_data *data = user_data; const char *requirement = "informational"; connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &data->type); connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &requirement); connman_dbus_dict_append_basic(iter, "Value", DBUS_TYPE_STRING, &data->passphrase); }
static void request_input_append_informational(DBusMessageIter *iter, void *user_data) { const char *str; str = "string"; connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &str); str = "informational"; connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &str); str = user_data; connman_dbus_dict_append_basic(iter, "Value", DBUS_TYPE_STRING, &str); }
void __connman_provider_append_properties(struct connman_provider *provider, DBusMessageIter *iter) { if (provider->host != NULL) connman_dbus_dict_append_basic(iter, "Host", DBUS_TYPE_STRING, &provider->host); if (provider->domain != NULL) connman_dbus_dict_append_basic(iter, "Domain", DBUS_TYPE_STRING, &provider->domain); if (provider->type != NULL) connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &provider->type); }
dbus_bool_t connman_dbus_setting_changed_basic(const char *owner, const char *path, const char *key, int type, void *val) { DBusMessage *msg; DBusMessageIter array, dict; if (!owner || !path) return FALSE; msg = dbus_message_new_method_call(owner, path, CONNMAN_NOTIFICATION_INTERFACE, "Update"); if (!msg) return FALSE; dbus_message_iter_init_append(msg, &array); connman_dbus_dict_open(&array, &dict); connman_dbus_dict_append_basic(&dict, key, type, val); connman_dbus_dict_close(&array, &dict); g_dbus_send_message(connection, msg); return TRUE; }
static DBusMessage *get_properties(DBusConnection *conn, DBusMessage *msg, void *data) { DBusMessage *reply; DBusMessageIter array, dict; struct timeval tv; const char *str; DBG("conn %p", conn); reply = dbus_message_new_method_return(msg); if (!reply) return NULL; dbus_message_iter_init_append(reply, &array); connman_dbus_dict_open(&array, &dict); if (gettimeofday(&tv, NULL) == 0) { dbus_uint64_t val = tv.tv_sec; connman_dbus_dict_append_basic(&dict, "Time", DBUS_TYPE_UINT64, &val); } str = time_updates2string(time_updates_config); if (str) connman_dbus_dict_append_basic(&dict, "TimeUpdates", DBUS_TYPE_STRING, &str); if (timezone_config) connman_dbus_dict_append_basic(&dict, "Timezone", DBUS_TYPE_STRING, &timezone_config); str = timezone_updates2string(timezone_updates_config); if (str) connman_dbus_dict_append_basic(&dict, "TimezoneUpdates", DBUS_TYPE_STRING, &str); connman_dbus_dict_append_array(&dict, "Timeservers", DBUS_TYPE_STRING, append_timeservers, NULL); connman_dbus_dict_close(&array, &dict); return reply; }
static void append_properties(DBusMessageIter *iter, struct connman_peer *peer) { const char *state = state2string(peer->state); DBusMessageIter dict; connman_dbus_dict_open(iter, &dict); connman_dbus_dict_append_basic(&dict, "State", DBUS_TYPE_STRING, &state); connman_dbus_dict_append_basic(&dict, "Name", DBUS_TYPE_STRING, &peer->name); connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4, peer); connman_dbus_dict_append_array(&dict, "Services", DBUS_TYPE_DICT_ENTRY, append_peer_services, peer); connman_dbus_dict_close(iter, &dict); }
static void request_input_append_passphrase(DBusMessageIter *iter, void *user_data) { struct connman_service *service = user_data; char *value; const char *phase2; switch (__connman_service_get_security(service)) { case CONNMAN_SERVICE_SECURITY_WEP: value = "wep"; break; case CONNMAN_SERVICE_SECURITY_PSK: value = "psk"; break; case CONNMAN_SERVICE_SECURITY_8021X: phase2 = __connman_service_get_phase2(service); if (phase2 && ( g_str_has_suffix(phase2, "GTC") || g_str_has_suffix(phase2, "OTP"))) value = "response"; else value = "passphrase"; break; default: value = "string"; break; } connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &value); value = "mandatory"; connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING, &value); if (__connman_service_wps_enabled(service)) { connman_dbus_dict_append_array(iter, "Alternates", DBUS_TYPE_STRING, request_input_append_alternates, "WPS"); } }
static void append_dhcp_server_ipv4(DBusMessageIter *iter, void *user_data) { struct connman_peer *peer = user_data; const char *str = "dhcp"; const char *gateway; const char *subnet; if (!peer->ip_pool) return; gateway = __connman_ippool_get_gateway(peer->ip_pool); subnet = __connman_ippool_get_subnet_mask(peer->ip_pool); connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str); connman_dbus_dict_append_basic(iter, "Address", DBUS_TYPE_STRING, &gateway); connman_dbus_dict_append_basic(iter, "Netmask", DBUS_TYPE_STRING, &subnet); connman_dbus_dict_append_basic(iter, "Gateway", DBUS_TYPE_STRING, &gateway); }
static DBusMessage *get_properties(DBusConnection *conn, DBusMessage *message, void *user_data) { struct connman_technology *technology = user_data; DBusMessage *reply; DBusMessageIter array, dict; const char *str; reply = dbus_message_new_method_return(message); if (reply == NULL) return NULL; dbus_message_iter_init_append(reply, &array); connman_dbus_dict_open(&array, &dict); str = state2string(technology->state); if (str != NULL) connman_dbus_dict_append_basic(&dict, "State", DBUS_TYPE_STRING, &str); str = get_name(technology->type); if (str != NULL) connman_dbus_dict_append_basic(&dict, "Name", DBUS_TYPE_STRING, &str); str = __connman_service_type2string(technology->type); if (str != NULL) connman_dbus_dict_append_basic(&dict, "Type", DBUS_TYPE_STRING, &str); connman_dbus_dict_append_basic(&dict, "Tethering", DBUS_TYPE_BOOLEAN, &technology->tethering); if (technology->tethering_ident != NULL) connman_dbus_dict_append_basic(&dict, "TetheringIdentifier", DBUS_TYPE_STRING, &technology->tethering_ident); if (technology->tethering_passphrase != NULL) connman_dbus_dict_append_basic(&dict, "TetheringPassphrase", DBUS_TYPE_STRING, &technology->tethering_passphrase); connman_dbus_dict_close(&array, &dict); return reply; }
static void append_properties(DBusMessageIter *iter, struct connman_technology *technology) { DBusMessageIter dict; const char *str; connman_dbus_dict_open(iter, &dict); str = get_name(technology->type); if (str != NULL) connman_dbus_dict_append_basic(&dict, "Name", DBUS_TYPE_STRING, &str); str = __connman_service_type2string(technology->type); if (str != NULL) connman_dbus_dict_append_basic(&dict, "Type", DBUS_TYPE_STRING, &str); __sync_synchronize(); connman_dbus_dict_append_basic(&dict, "Powered", DBUS_TYPE_BOOLEAN, &technology->enabled); connman_dbus_dict_append_basic(&dict, "Connected", DBUS_TYPE_BOOLEAN, &technology->connected); connman_dbus_dict_append_basic(&dict, "Tethering", DBUS_TYPE_BOOLEAN, &technology->tethering); if (technology->tethering_ident != NULL) connman_dbus_dict_append_basic(&dict, "TetheringIdentifier", DBUS_TYPE_STRING, &technology->tethering_ident); if (technology->tethering_passphrase != NULL) connman_dbus_dict_append_basic(&dict, "TetheringPassphrase", DBUS_TYPE_STRING, &technology->tethering_passphrase); connman_dbus_dict_close(iter, &dict); }
void session_append_settings(DBusMessageIter *dict, struct test_session_info *info) { const char *policy; connman_dbus_dict_append_basic(dict, "Priority", DBUS_TYPE_BOOLEAN, &info->priority); connman_dbus_dict_append_array(dict, "AllowedBearers", DBUS_TYPE_STRING, append_allowed_bearers, info); connman_dbus_dict_append_basic(dict, "AvoidHandover", DBUS_TYPE_BOOLEAN, &info->avoid_handover); connman_dbus_dict_append_basic(dict, "StayConnected", DBUS_TYPE_BOOLEAN, &info->stay_connected); connman_dbus_dict_append_basic(dict, "PeriodicConnect", DBUS_TYPE_UINT32, &info->periodic_connect); connman_dbus_dict_append_basic(dict, "IdleTimeout", DBUS_TYPE_UINT32, &info->idle_timeout); connman_dbus_dict_append_basic(dict, "EmergencyCall", DBUS_TYPE_BOOLEAN, &info->ecall); policy = roamingpolicy2string(info->roaming_policy); connman_dbus_dict_append_basic(dict, "RoamingPolicy", DBUS_TYPE_STRING, &policy); }
static void create_proxy_configuration(void) { DBusMessage *msg; DBusMessageIter iter, dict; DBusPendingCall *call; dbus_bool_t result; char *interface; const char *method; const char *str; char **str_list; if (default_service == NULL) return; DBG(""); msg = dbus_message_new_method_call(PACRUNNER_SERVICE, PACRUNNER_PATH, PACRUNNER_INTERFACE, "CreateProxyConfiguration"); if (msg == NULL) return; dbus_message_set_auto_start(msg, FALSE); dbus_message_iter_init_append(msg, &iter); connman_dbus_dict_open(&iter, &dict); switch(connman_service_get_proxy_method(default_service)) { case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN: goto done; case CONNMAN_SERVICE_PROXY_METHOD_DIRECT: method= "direct"; break; case CONNMAN_SERVICE_PROXY_METHOD_MANUAL: method = "manual"; str_list = connman_service_get_proxy_servers(default_service); if (str_list == NULL) goto done; connman_dbus_dict_append_array(&dict, "Servers", DBUS_TYPE_STRING, append_string_list, str_list); g_strfreev(str_list); str_list = connman_service_get_proxy_excludes(default_service); if (str_list == NULL) break; connman_dbus_dict_append_array(&dict, "Excludes", DBUS_TYPE_STRING, append_string_list, str_list); g_strfreev(str_list); break; case CONNMAN_SERVICE_PROXY_METHOD_AUTO: method = "auto"; str = connman_service_get_proxy_url(default_service); if (str == NULL) { str = connman_service_get_proxy_autoconfig( default_service); if (str == NULL) goto done; } connman_dbus_dict_append_basic(&dict, "URL", DBUS_TYPE_STRING, &str); break; } connman_dbus_dict_append_basic(&dict, "Method", DBUS_TYPE_STRING, &method); interface = connman_service_get_interface(default_service); if (interface != NULL) { connman_dbus_dict_append_basic(&dict, "Interface", DBUS_TYPE_STRING, &interface); g_free(interface); } str = connman_service_get_domainname(default_service); if (str != NULL) connman_dbus_dict_append_array(&dict, "Domains", DBUS_TYPE_STRING, append_string, &str); str_list = connman_service_get_nameservers(default_service); if (str_list != NULL) connman_dbus_dict_append_array(&dict, "Nameservers", DBUS_TYPE_STRING, append_string_list, str_list); connman_dbus_dict_close(&iter, &dict); result = dbus_connection_send_with_reply(connection, msg, &call, DBUS_TIMEOUT); if (result == FALSE || call == NULL) goto done; dbus_pending_call_set_notify(call, create_config_reply, NULL, NULL); dbus_pending_call_unref(call); done: dbus_message_unref(msg); }
static void setup_tun_interface(unsigned int flags, unsigned change, void *data) { struct connman_private_network *pn = data; unsigned char prefixlen; DBusMessageIter array, dict; int err; DBG("index %d flags %d change %d", pn->index, flags, change); if (flags & IFF_UP) return; prefixlen = __connman_ipconfig_netmask_prefix_len(PRIVATE_NETWORK_NETMASK); if ((__connman_inet_modify_address(RTM_NEWADDR, NLM_F_REPLACE | NLM_F_ACK, pn->index, AF_INET, pn->server_ip, pn->peer_ip, prefixlen, NULL)) < 0) { DBG("address setting failed"); return; } connman_inet_ifup(pn->index); err = enable_nat(default_interface); if (err < 0) { connman_error("failed to enable NAT on %s", default_interface); goto error; } dbus_message_iter_init_append(pn->reply, &array); dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH, &pn->path); connman_dbus_dict_open(&array, &dict); connman_dbus_dict_append_basic(&dict, "ServerIPv4", DBUS_TYPE_STRING, &pn->server_ip); connman_dbus_dict_append_basic(&dict, "PeerIPv4", DBUS_TYPE_STRING, &pn->peer_ip); connman_dbus_dict_append_basic(&dict, "PrimaryDNS", DBUS_TYPE_STRING, &pn->primary_dns); connman_dbus_dict_append_basic(&dict, "SecondaryDNS", DBUS_TYPE_STRING, &pn->secondary_dns); connman_dbus_dict_close(&array, &dict); dbus_message_iter_append_basic(&array, DBUS_TYPE_UNIX_FD, &pn->fd); g_dbus_send_message(connection, pn->reply); return; error: pn->reply = __connman_error_failed(pn->msg, -err); g_dbus_send_message(connection, pn->reply); g_hash_table_remove(pn_hash, pn->path); }
static void append_notify(DBusMessageIter *dict, struct connman_session *session) { struct session_info *info = session->info; struct session_info *info_last = session->info_last; struct connman_service *service; const char *name, *ifname, *bearer; if (session->append_all == TRUE || info->state != info_last->state) { const char *state = state2string(info->state); connman_dbus_dict_append_basic(dict, "State", DBUS_TYPE_STRING, &state); info_last->state = info->state; } if (session->append_all == TRUE || info->entry != info_last->entry) { if (info->entry == NULL) { name = ""; ifname = ""; service = NULL; bearer = ""; } else { name = info->entry->name; ifname = info->entry->ifname; service = info->entry->service; bearer = info->entry->bearer; } connman_dbus_dict_append_basic(dict, "Name", DBUS_TYPE_STRING, &name); connman_dbus_dict_append_dict(dict, "IPv4", append_ipconfig_ipv4, service); connman_dbus_dict_append_dict(dict, "IPv6", append_ipconfig_ipv6, service); connman_dbus_dict_append_basic(dict, "Interface", DBUS_TYPE_STRING, &ifname); connman_dbus_dict_append_basic(dict, "Bearer", DBUS_TYPE_STRING, &bearer); info_last->entry = info->entry; } if (session->append_all == TRUE || info->config.type != info_last->config.type) { const char *type = type2string(info->config.type); connman_dbus_dict_append_basic(dict, "ConnectionType", DBUS_TYPE_STRING, &type); info_last->config.type = info->config.type; } if (session->append_all == TRUE || info->config.allowed_bearers != info_last->config.allowed_bearers) { connman_dbus_dict_append_array(dict, "AllowedBearers", DBUS_TYPE_STRING, append_allowed_bearers, info); info_last->config.allowed_bearers = info->config.allowed_bearers; } session->append_all = FALSE; }
static int create_configuration(DBusMessage *msg, connection_ready_cb callback) { DBusMessage *new_msg = NULL; DBusPendingCall *call; DBusMessageIter iter, array, new_iter, new_dict; const char *type = NULL, *name = NULL; const char *host = NULL, *domain = NULL; char *ident, *me = NULL; int err = 0; dbus_bool_t result; struct connection_data *data; struct config_create_data *user_data = NULL; GSList *networks = NULL; /* * We copy the old message data into new message. We cannot * just use the old message as is because the user route * information is not in the same format in vpnd. */ new_msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL); dbus_message_iter_init_append(new_msg, &new_iter); connman_dbus_dict_open(&new_iter, &new_dict); 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; void *item_value; const char *key; int value_type; dbus_message_iter_recurse(&array, &entry); dbus_message_iter_get_basic(&entry, &key); dbus_message_iter_next(&entry); dbus_message_iter_recurse(&entry, &value); value_type = dbus_message_iter_get_arg_type(&value); item_value = NULL; switch (value_type) { case DBUS_TYPE_STRING: dbus_message_iter_get_basic(&value, &item_value); if (g_str_equal(key, "Type") == TRUE) { type = (const char *)item_value; } else if (g_str_equal(key, "Name") == TRUE) { name = (const char *)item_value; } else if (g_str_equal(key, "Host") == TRUE) { host = (const char *)item_value; } else if (g_str_equal(key, "VPN.Domain") == TRUE) { domain = (const char *)item_value; } DBG("%s %s", key, (char *)item_value); if (item_value != NULL) connman_dbus_dict_append_basic(&new_dict, key, value_type, &item_value); break; case DBUS_TYPE_ARRAY: if (g_str_equal(key, "Networks") == TRUE) { networks = get_user_networks(&value); connman_dbus_dict_append_array(&new_dict, "UserRoutes", DBUS_TYPE_DICT_ENTRY, append_routes, networks); } break; } dbus_message_iter_next(&array); } connman_dbus_dict_close(&new_iter, &new_dict); DBG("VPN type %s name %s host %s domain %s networks %p", type, name, host, domain, networks); if (host == NULL || domain == NULL) { err = -EINVAL; goto done; } if (type == NULL || name == NULL) { err = -EOPNOTSUPP; goto done; } ident = g_strdup_printf("%s_%s", host, domain); set_dbus_ident(ident); DBG("ident %s", ident); data = g_hash_table_lookup(vpn_connections, ident); if (data != NULL) { if (data->call != NULL || data->cb_data != NULL) { DBG("create configuration call already pending"); err = -EINPROGRESS; goto done; } } else { char *path = g_strdup_printf("%s/connection/%s", VPN_PATH, ident); data = create_connection_data(path); g_free(path); if (data == NULL) { err = -ENOMEM; goto done; } g_hash_table_insert(vpn_connections, g_strdup(ident), data); } /* * User called net.connman.Manager.ConnectProvider if we are here. * So use the data from original message in the new msg. */ me = g_strdup(dbus_message_get_destination(msg)); dbus_message_set_interface(new_msg, VPN_MANAGER_INTERFACE); dbus_message_set_path(new_msg, "/"); dbus_message_set_destination(new_msg, VPN_SERVICE); dbus_message_set_sender(new_msg, me); dbus_message_set_member(new_msg, "Create"); user_data = g_try_new0(struct config_create_data, 1); if (user_data == NULL) { err = -ENOMEM; goto done; } user_data->callback = callback; user_data->message = dbus_message_ref(msg); user_data->path = NULL; DBG("cb %p msg %p", user_data, msg); result = dbus_connection_send_with_reply(connection, new_msg, &call, DBUS_TIMEOUT); if (result == FALSE || call == NULL) { err = -EIO; goto done; } dbus_pending_call_set_notify(call, configuration_create_reply, user_data, NULL); data->call = call; done: if (new_msg != NULL) dbus_message_unref(new_msg); if (networks != NULL) g_slist_free_full(networks, destroy_route); g_free(me); return err; }
static void append_notify(DBusMessageIter *dict, struct connman_session *session) { struct session_info *info = session->info; struct session_info *info_last = session->info_last; struct connman_service *service; enum connman_service_type type; const char *name, *bearer; char *ifname; int idx; if (session->append_all || info->state != info_last->state) { const char *state = state2string(info->state); connman_dbus_dict_append_basic(dict, "State", DBUS_TYPE_STRING, &state); info_last->state = info->state; } if (session->append_all || session->service != session->service_last) { if (session->service) { service = session->service; name = __connman_service_get_name(service); idx = __connman_service_get_index(service); ifname = connman_inet_ifname(idx); if (!ifname) ifname = g_strdup(""); type = connman_service_get_type(service); bearer = service2bearer(type); } else { service = NULL; name = ""; ifname = g_strdup(""); bearer = ""; } connman_dbus_dict_append_basic(dict, "Name", DBUS_TYPE_STRING, &name); connman_dbus_dict_append_dict(dict, "IPv4", append_ipconfig_ipv4, service); connman_dbus_dict_append_dict(dict, "IPv6", append_ipconfig_ipv6, service); connman_dbus_dict_append_basic(dict, "Interface", DBUS_TYPE_STRING, &ifname); connman_dbus_dict_append_basic(dict, "Bearer", DBUS_TYPE_STRING, &bearer); g_free(ifname); session->service_last = session->service; } if (session->append_all || info->config.type != info_last->config.type) { const char *type = type2string(info->config.type); connman_dbus_dict_append_basic(dict, "ConnectionType", DBUS_TYPE_STRING, &type); info_last->config.type = info->config.type; } if (session->append_all || info->config.allowed_bearers != info_last->config.allowed_bearers) { connman_dbus_dict_append_array(dict, "AllowedBearers", DBUS_TYPE_STRING, append_allowed_bearers, info); info_last->config.allowed_bearers = info->config.allowed_bearers; } session->append_all = false; }
static void setup_tun_interface(unsigned int flags, unsigned change, void *data) { struct connman_private_network *pn = data; unsigned char prefixlen; DBusMessageIter array, dict; const char *server_ip; const char *peer_ip; const char *subnet_mask; int err; DBG("index %d flags %d change %d", pn->index, flags, change); if (flags & IFF_UP) return; subnet_mask = __connman_ippool_get_subnet_mask(pn->pool); server_ip = __connman_ippool_get_start_ip(pn->pool); peer_ip = __connman_ippool_get_end_ip(pn->pool); prefixlen = connman_ipaddress_calc_netmask_len(subnet_mask); if ((__connman_inet_modify_address(RTM_NEWADDR, NLM_F_REPLACE | NLM_F_ACK, pn->index, AF_INET, server_ip, peer_ip, prefixlen, NULL)) < 0) { DBG("address setting failed"); return; } connman_inet_ifup(pn->index); err = __connman_nat_enable(BRIDGE_NAME, server_ip, prefixlen); if (err < 0) { connman_error("failed to enable NAT"); goto error; } dbus_message_iter_init_append(pn->reply, &array); dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH, &pn->path); connman_dbus_dict_open(&array, &dict); connman_dbus_dict_append_basic(&dict, "ServerIPv4", DBUS_TYPE_STRING, &server_ip); connman_dbus_dict_append_basic(&dict, "PeerIPv4", DBUS_TYPE_STRING, &peer_ip); if (pn->primary_dns) connman_dbus_dict_append_basic(&dict, "PrimaryDNS", DBUS_TYPE_STRING, &pn->primary_dns); if (pn->secondary_dns) connman_dbus_dict_append_basic(&dict, "SecondaryDNS", DBUS_TYPE_STRING, &pn->secondary_dns); connman_dbus_dict_close(&array, &dict); dbus_message_iter_append_basic(&array, DBUS_TYPE_UNIX_FD, &pn->fd); g_dbus_send_message(connection, pn->reply); return; error: pn->reply = __connman_error_failed(pn->msg, -err); g_dbus_send_message(connection, pn->reply); g_hash_table_remove(pn_hash, pn->path); }