char * _nm_dbus_get_object_path_property (DBusGProxy *proxy, const char *interface, const char *prop_name) { GError *err = NULL; char *path = NULL; GValue value = {0,}; g_return_val_if_fail (DBUS_IS_G_PROXY (proxy), NULL); if (dbus_g_proxy_call (proxy, "Get", &err, G_TYPE_STRING, interface, G_TYPE_STRING, prop_name, G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID)) { path = g_strdup (g_value_get_boxed (&value)); } else { g_warning ("Error in device_get_property: %s\n", err->message); g_error_free (err); } return path; }
gint32 _nm_dbus_get_int_property (DBusGProxy *proxy, const char *interface, const char *prop_name) { GError *err = NULL; gint32 i = 0; GValue value = {0,}; g_return_val_if_fail (DBUS_IS_G_PROXY (proxy), 0); if (dbus_g_proxy_call (proxy, "Get", &err, G_TYPE_STRING, interface, G_TYPE_STRING, prop_name, G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID)) { i = g_value_get_int (&value); } else { g_warning ("Error in device_get_property: %s\n", err->message); g_error_free (err); } return i; }
static int get_credentials (char *username, char *password) { char *my_username = NULL; char *my_password = NULL; size_t len; GError *err = NULL; g_message ("nm-sstp-ppp-plugin: passwd-hook, need credentials..."); if (username && !password) { /* pppd is checking pap support; return 1 for supported */ return 1; } g_return_val_if_fail (DBUS_IS_G_PROXY (proxy), -1); g_message ("nm-sstp-ppp-plugin: (%s): passwd-hook, requesting credentials...", __func__); dbus_g_proxy_call (proxy, "NeedSecrets", &err, G_TYPE_INVALID, G_TYPE_STRING, &my_username, G_TYPE_STRING, &my_password, G_TYPE_INVALID); if (err) { g_warning ("nm-sstp-ppp-plugin: (%s): could not get secrets: (%d) %s", __func__, err ? err->code : -1, err->message ? err->message : "(unknown)"); g_error_free (err); return -1; } g_message ("nm-sstp-ppp-plugin: (%s): got credentials from NetworkManager-sstp", __func__); if (my_username) { len = strlen (my_username) + 1; len = len < MAXNAMELEN ? len : MAXNAMELEN; strncpy (username, my_username, len); username[len - 1] = '\0'; g_free (my_username); } if (my_password) { len = strlen (my_password) + 1; len = len < MAXSECRETLEN ? len : MAXSECRETLEN; strncpy (password, my_password, len); password[len - 1] = '\0'; g_free (my_password); } return 1; }
int moonshot_get_identity (const char *nai, const char *password, const char *service, char **nai_out, char **password_out, char **server_certificate_hash_out, char **ca_certificate_out, char **subject_name_constraint_out, char **subject_alt_name_constraint_out, MoonshotError **error) { GError *g_error = NULL; DBusGProxy *dbus_proxy; int success; dbus_proxy = get_dbus_proxy (error); if (*error != NULL) return FALSE; g_return_val_if_fail (DBUS_IS_G_PROXY (dbus_proxy), FALSE); dbus_g_proxy_call_with_timeout (dbus_proxy, "GetIdentity", INFINITE_TIMEOUT, &g_error, G_TYPE_STRING, nai, G_TYPE_STRING, password, G_TYPE_STRING, service, G_TYPE_INVALID, G_TYPE_STRING, nai_out, G_TYPE_STRING, password_out, G_TYPE_STRING, server_certificate_hash_out, G_TYPE_STRING, ca_certificate_out, G_TYPE_STRING, subject_name_constraint_out, G_TYPE_STRING, subject_alt_name_constraint_out, G_TYPE_BOOLEAN, &success, G_TYPE_INVALID); g_object_unref (dbus_proxy); if (g_error != NULL) { *error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR, g_error->message); return FALSE; } if (success == FALSE) { *error = moonshot_error_new (MOONSHOT_ERROR_NO_IDENTITY_SELECTED, "No identity was returned by the Moonshot " "user interface."); return FALSE; } return TRUE; }
/** Tell to a remote instance of Ekiga to show the main window. * You will typically use this function when claim_ownership failed. */ void ekiga_dbus_client_show () { DBusGProxy *proxy = get_ekiga_client_proxy (); g_return_if_fail (DBUS_IS_G_PROXY (proxy)); dbus_g_proxy_call_no_reply (proxy, "Show", G_TYPE_INVALID); g_object_unref (proxy); }
/** Tell to a remote instance of Ekiga to connect to a remote SIP or H.323 * address. * You will typically use this function when claim_ownership failed. */ void ekiga_dbus_client_connect (const gchar *uri) { DBusGProxy *proxy = get_ekiga_client_proxy (); g_return_if_fail (DBUS_IS_G_PROXY (proxy)); dbus_g_proxy_call_no_reply (proxy, "Call", G_TYPE_STRING, uri, G_TYPE_INVALID); g_object_unref (proxy); }
static void nm_exit_notify (void *data, int arg) { g_return_if_fail (DBUS_IS_G_PROXY (proxy)); g_message ("nm-sstp-ppp-plugin: (%s): cleaning up", __func__); g_object_unref (proxy); proxy = NULL; }
gboolean cd_NetworkMonitor_connect_to_bus (void) { cd_debug ("%s ()", __func__); //\_____________ On verifie la presence de NM sur le bus. if (! cairo_dock_dbus_detect_system_application("org.freedesktop.NetworkManager")) return FALSE; dbus_g_object_register_marshaller(g_cclosure_marshal_VOID__GHashTable_GHashTable, G_TYPE_NONE, CD_DBUS_TYPE_HASH_TABLE_OF_HASH_TABLE, G_TYPE_INVALID); // pour la methode GetSettings (il faut le faire avant de recuperer tout proxy, sinon les signaux ne passent plus !) //\_____________ On recupere l'objet principal de NM. myData.dbus_proxy_NM = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager", "org.freedesktop.NetworkManager"); g_return_val_if_fail (DBUS_IS_G_PROXY (myData.dbus_proxy_NM), FALSE); myData.dbus_proxy_NM_prop = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager", "org.freedesktop.DBus.Properties"); g_return_val_if_fail (DBUS_IS_G_PROXY (myData.dbus_proxy_NM_prop), FALSE); //\_____________ On se connecte aux signaux de base : wifi active (WirelessEnabled && WirelessHardwareEnabled ), etat de NM (State). dbus_g_object_register_marshaller(g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, G_TYPE_HASH_TABLE ,G_TYPE_INVALID); // enregistrement d'un marshaller specifique au signal (sinon impossible de le recuperer ni de le voir dbus_g_proxy_add_signal(myData.dbus_proxy_NM, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_NM, "PropertiesChanged", G_CALLBACK(onChangeNMProperties), NULL, NULL); //\_____________ On recupere l'objet des connections. myData.cServiceName = g_strdup ("org.freedesktop.NetworkManagerUserSettings"); myData.dbus_proxy_Settings = cairo_dock_create_new_system_proxy ( myData.cServiceName, "/org/freedesktop/NetworkManagerSettings", "org.freedesktop.NetworkManagerSettings"); dbus_g_proxy_add_signal(myData.dbus_proxy_Settings, "NewConnection", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_Settings, "NewConnection", G_CALLBACK(onNewConnection), NULL, NULL); return TRUE; }
int moonshot_install_id_card (const char *display_name, const char *user_name, const char *password, const char *realm, char *rules_patterns[], int rules_patterns_length, char *rules_always_confirm[], int rules_always_confirm_length, char *services[], int services_length, const char *ca_cert, const char *subject, const char *subject_alt, const char *server_cert, int force_flat_file_store, MoonshotError **error) { GError *g_error = NULL; DBusGProxy *dbus_proxy; int success = FALSE; int i; const char **rules_patterns_strv, **rules_always_confirm_strv, **services_strv; dbus_proxy = get_dbus_proxy (error); if (*error != NULL) return FALSE; g_return_val_if_fail (DBUS_IS_G_PROXY (dbus_proxy), FALSE); g_return_val_if_fail (rules_patterns_length == rules_always_confirm_length, FALSE); /* Marshall array and struct parameters for DBus */ rules_patterns_strv = g_malloc ((rules_patterns_length + 1) * sizeof (const char *)); rules_always_confirm_strv = g_malloc ((rules_patterns_length + 1) * sizeof (const char *)); services_strv = g_malloc ((services_length + 1) * sizeof (const char *)); for (i = 0; i < rules_patterns_length; i ++) { rules_patterns_strv[i] = rules_patterns[i]; rules_always_confirm_strv[i] = rules_always_confirm[i]; } for (i = 0; i < services_length; i ++) services_strv[i] = services[i]; rules_patterns_strv[rules_patterns_length] = NULL; rules_always_confirm_strv[rules_patterns_length] = NULL; services_strv[services_length] = NULL; dbus_g_proxy_call (dbus_proxy, "InstallIdCard", &g_error, G_TYPE_STRING, display_name, G_TYPE_STRING, user_name, G_TYPE_STRING, password, G_TYPE_STRING, realm, G_TYPE_STRV, rules_patterns_strv, G_TYPE_STRV, rules_always_confirm_strv, G_TYPE_STRV, services_strv, G_TYPE_STRING, ca_cert, G_TYPE_STRING, subject, G_TYPE_STRING, subject_alt, G_TYPE_STRING, server_cert, G_TYPE_INT, force_flat_file_store, G_TYPE_INVALID, G_TYPE_BOOLEAN, &success, G_TYPE_INVALID); g_object_unref (dbus_proxy); g_free(rules_patterns_strv); g_free(rules_always_confirm_strv); g_free(services_strv); if (g_error != NULL) { *error = moonshot_error_new (MOONSHOT_ERROR_IPC_ERROR, g_error->message); return FALSE; } return success; }
gboolean cd_NetworkMonitor_get_device (void) { cd_debug ("%s ()", __func__); //\_____________ On recupere la liste des devices. GPtrArray *paDevices = cairo_dock_dbus_get_array (myData.dbus_proxy_NM, "GetDevices"); g_return_val_if_fail (paDevices != NULL, FALSE); //\_____________ On choisit celui defini en conf, ou un par defaut (wifi de preference). cd_debug ("%d devices", paDevices->len); DBusGProxy *dbus_proxy_Device_prop; gchar *cDevice; uint i; for (i = 0; i < paDevices->len; i++) { // on recupere le device. cDevice = (gchar *)g_ptr_array_index(paDevices, i); dbus_proxy_Device_prop = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", cDevice, "org.freedesktop.DBus.Properties"); if (!DBUS_IS_G_PROXY (dbus_proxy_Device_prop)) continue; cd_debug (" device %s", cDevice); // on regarde son type. guint iDeviceType = cairo_dock_dbus_get_property_as_uint (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "DeviceType"); // 1 : ethernet, 2 : wifi cd_debug (" device type : %d", iDeviceType); if (iDeviceType != 1 && iDeviceType != 2) // ne nous insteresse pas. { cd_debug (" useless device type\n"); g_object_unref (dbus_proxy_Device_prop); continue; } // on recupere son interface. gchar *cInterface = cairo_dock_dbus_get_property_as_string (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "Interface"); cd_debug (" interface :%s", cInterface); // on regarde si on doit le selectionner ou pas. if (myData.cDevice != NULL) // on a deja trouve un device, on regarde si celui-ci convient mieux. { if (myConfig.cInterface && cInterface && strcmp (cInterface, myConfig.cInterface) == 0) // c'est celui qu'on veut. { g_free (myData.cDevice); myData.cDevice = NULL; g_free (myData.cInterface); myData.cInterface = NULL; g_object_unref (myData.dbus_proxy_Device_prop); myData.dbus_proxy_Device_prop = NULL; } else if (iDeviceType == 2 && myData.bWiredExt) // c'est un wifi alors que celui qu'on a deja est un ethernet, on le prend a sa place. { g_free (myData.cDevice); myData.cDevice = NULL; g_free (myData.cInterface); myData.cInterface = NULL; g_object_unref (myData.dbus_proxy_Device_prop); myData.dbus_proxy_Device_prop = NULL; } } if (myData.cDevice == NULL) // aucun autre device, on selectionne celui-la. { cd_debug (" on selectionne ce device\n"); myData.dbus_proxy_Device_prop = dbus_proxy_Device_prop; myData.cInterface = cInterface; myData.cDevice = g_strdup (cDevice); myData.bWiredExt = (iDeviceType == 1); myData.bWirelessExt = (iDeviceType == 2); if (myConfig.cInterface && cInterface && strcmp (cInterface, myConfig.cInterface) == 0) { cd_debug (" c'est l'interface qu'on veut\n"); break; } } else { g_free (cInterface); g_object_unref (dbus_proxy_Device_prop); } } g_ptr_array_free (paDevices, TRUE); // on suppose qu'une GDestroyFunc a ete assignee au tableau. g_return_val_if_fail (myData.cDevice != NULL, FALSE); //\_____________ On complete le device. myData.dbus_proxy_Device = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", myData.cDevice, "org.freedesktop.NetworkManager.Device"); /// se conecter au changement de propriete State ?... if (myData.bWirelessExt) { // on se connecte au changement de la propriete ActiveAccessPoint. myData.dbus_proxy_WirelessDevice = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", myData.cDevice, "org.freedesktop.NetworkManager.Device.Wireless"); dbus_g_proxy_add_signal(myData.dbus_proxy_WirelessDevice, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_WirelessDevice, "PropertiesChanged", G_CALLBACK(onChangeWirelessDeviceProperties), NULL, NULL); cd_NetworkMonitor_get_wireless_connection_infos (); } else { // on se connecte au changement de la propriete Carrier. myData.dbus_proxy_WiredDevice = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", myData.cDevice, "org.freedesktop.NetworkManager.Device.Wired"); dbus_g_proxy_add_signal(myData.dbus_proxy_WiredDevice, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_WiredDevice, "PropertiesChanged", G_CALLBACK(onChangeWiredDeviceProperties), NULL, NULL); cd_NetworkMonitor_get_wired_connection_infos (); } return TRUE; }
static GtkWidget * get_config_widgets (const char *bdaddr, const char **uuids) { WidgetInfo *info; NmaBtDevice *device; GtkWidget *vbox, *hbox; gboolean pan = FALSE, dun = FALSE, busy; GtkTreeIter iter; BluetoothClient *btclient; GtkTreeModel *btmodel; guint id; /* Don't allow configuration if NM isn't running; it just confuses people * if they see the checkboxes but the configuration doesn't seem to have * any visible effect since they aren't running NM/nm-applet. */ if (!nm_is_running ()) return NULL; get_capabilities (bdaddr, uuids, &pan, &dun); if (!pan && !dun) return NULL; /* BluetoothClient setup */ btclient = bluetooth_client_new (); btmodel = bluetooth_client_get_model (btclient); g_assert (btmodel); device = get_device (bdaddr); if (!device) { const char *op = NULL; gpointer proxy; char *alias; if (!get_device_iter (btmodel, bdaddr, &iter)) { g_warning ("%s: failed to retrieve device %s from gnome-bluetooth!", __func__, bdaddr); g_object_unref (btmodel); g_object_unref (btclient); return NULL; } gtk_tree_model_get (btmodel, &iter, BLUETOOTH_COLUMN_ALIAS, &alias, BLUETOOTH_COLUMN_PROXY, &proxy, -1); g_assert (proxy); /* At some point gnome-bluetooth switched to gdbus, so we don't know * if the proxy will be a DBusGProxy (dbus-glib) or a GDBusProxy (gdbus). */ if (G_IS_DBUS_PROXY (proxy)) op = g_dbus_proxy_get_object_path (G_DBUS_PROXY (proxy)); else if (DBUS_IS_G_PROXY (proxy)) op = dbus_g_proxy_get_path (DBUS_G_PROXY (proxy)); else g_assert_not_reached (); device = nma_bt_device_new (bdaddr, alias, op, pan, dun); g_free (alias); g_object_unref (proxy); if (!device) { g_warning ("%s: failed to create Bluetooth proxy object!", bdaddr); g_object_unref (btmodel); g_object_unref (btclient); return NULL; } add_device (device); } info = g_malloc0 (sizeof (WidgetInfo)); info->device = g_object_ref (device); info->btclient = btclient; g_signal_connect (G_OBJECT (btclient), "notify::default-adapter", G_CALLBACK (default_adapter_changed), info); g_signal_connect (G_OBJECT (btclient), "notify::default-adapter-powered", G_CALLBACK (default_adapter_powered_changed), info); id = g_signal_connect (device, "notify::" NMA_BT_DEVICE_PAN_ENABLED, G_CALLBACK (device_pan_enabled_cb), info); info->sigids = g_slist_prepend (info->sigids, GUINT_TO_POINTER (id)); id = g_signal_connect (device, "notify::" NMA_BT_DEVICE_DUN_ENABLED, G_CALLBACK (device_dun_enabled_cb), info); info->sigids = g_slist_prepend (info->sigids, GUINT_TO_POINTER (id)); id = g_signal_connect (device, "notify::" NMA_BT_DEVICE_BUSY, G_CALLBACK (device_busy_cb), info); info->sigids = g_slist_prepend (info->sigids, GUINT_TO_POINTER (id)); id = g_signal_connect (device, "notify::" NMA_BT_DEVICE_STATUS, G_CALLBACK (device_status_cb), info); info->sigids = g_slist_prepend (info->sigids, GUINT_TO_POINTER (id)); /* UI setup */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); g_object_set_data_full (G_OBJECT (vbox), "info", info, widget_info_destroy); busy = nma_bt_device_get_busy (device); if (pan) { info->pan_button = gtk_check_button_new_with_label (_("Use your mobile phone as a network device (PAN/NAP)")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (info->pan_button), nma_bt_device_get_pan_enabled (device)); info->pan_toggled_id = g_signal_connect (G_OBJECT (info->pan_button), "toggled", G_CALLBACK (pan_button_toggled), info); gtk_box_pack_start (GTK_BOX (vbox), info->pan_button, FALSE, TRUE, 6); gtk_widget_set_sensitive (info->pan_button, !busy); } if (dun) { info->dun_button = gtk_check_button_new_with_label (_("Access the Internet using your mobile phone (DUN)")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (info->dun_button), nma_bt_device_get_dun_enabled (device)); info->dun_toggled_id = g_signal_connect (G_OBJECT (info->dun_button), "toggled", G_CALLBACK (dun_button_toggled), info); gtk_box_pack_start (GTK_BOX (vbox), info->dun_button, FALSE, TRUE, 6); set_dun_button_sensitive (info, !busy); } hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6); /* Spinner's hbox */ info->hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (hbox), info->hbox, FALSE, FALSE, 0); device_busy_cb (device, NULL, info); /* Status label */ info->status = gtk_label_new (nma_bt_device_get_status (device)); gtk_label_set_max_width_chars (GTK_LABEL (info->status), 80); gtk_label_set_line_wrap (GTK_LABEL (info->status), TRUE); gtk_box_pack_start (GTK_BOX (hbox), info->status, FALSE, TRUE, 6); default_adapter_powered_changed (G_OBJECT (info->btclient), NULL, info); return vbox; }
static void nm_phasechange (void *data, int arg) { NMPPPStatus ppp_status = NM_PPP_STATUS_UNKNOWN; char *ppp_phase; g_return_if_fail (DBUS_IS_G_PROXY (proxy)); switch (arg) { case PHASE_DEAD: ppp_status = NM_PPP_STATUS_DEAD; ppp_phase = "dead"; break; case PHASE_INITIALIZE: ppp_status = NM_PPP_STATUS_INITIALIZE; ppp_phase = "initialize"; break; case PHASE_SERIALCONN: ppp_status = NM_PPP_STATUS_SERIALCONN; ppp_phase = "serial connection"; break; case PHASE_DORMANT: ppp_status = NM_PPP_STATUS_DORMANT; ppp_phase = "dormant"; break; case PHASE_ESTABLISH: ppp_status = NM_PPP_STATUS_ESTABLISH; ppp_phase = "establish"; break; case PHASE_AUTHENTICATE: ppp_status = NM_PPP_STATUS_AUTHENTICATE; ppp_phase = "authenticate"; break; case PHASE_CALLBACK: ppp_status = NM_PPP_STATUS_CALLBACK; ppp_phase = "callback"; break; case PHASE_NETWORK: ppp_status = NM_PPP_STATUS_NETWORK; ppp_phase = "network"; break; case PHASE_RUNNING: ppp_status = NM_PPP_STATUS_RUNNING; ppp_phase = "running"; break; case PHASE_TERMINATE: ppp_status = NM_PPP_STATUS_TERMINATE; ppp_phase = "terminate"; break; case PHASE_DISCONNECT: ppp_status = NM_PPP_STATUS_DISCONNECT; ppp_phase = "disconnect"; break; case PHASE_HOLDOFF: ppp_status = NM_PPP_STATUS_HOLDOFF; ppp_phase = "holdoff"; break; case PHASE_MASTER: ppp_status = NM_PPP_STATUS_MASTER; ppp_phase = "master"; break; default: ppp_phase = "unknown"; break; } g_message ("nm-sstp-ppp-plugin: (%s): status %d / phase '%s'", __func__, ppp_status, ppp_phase); if (ppp_status != NM_PPP_STATUS_UNKNOWN) { dbus_g_proxy_call_no_reply (proxy, "SetState", G_TYPE_UINT, ppp_status, G_TYPE_INVALID, G_TYPE_INVALID); } }
static void nm_ip_up (void *data, int arg) { guint32 pppd_made_up_address = htonl (0x0a404040 + ifunit); ipcp_options opts = ipcp_gotoptions[0]; ipcp_options peer_opts = ipcp_hisoptions[0]; GHashTable *hash; GArray *array; GValue *val; struct sockaddr_in addr; g_return_if_fail (DBUS_IS_G_PROXY (proxy)); g_message ("nm-sstp-ppp-plugin: (%s): ip-up event", __func__); if (!opts.ouraddr) { g_warning ("nm-sstp-ppp-plugin: (%s): didn't receive an internal IP from pppd!", __func__); return; } hash = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, value_destroy); /* Request the address of the server sstpc connected to */ if (0 == nm_sstp_getaddr(&addr)) { /* This will eliminate the need to have nm-sstp-service * insert a new entry for "gateway" as we have already set it. */ g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_EXT_GATEWAY, uint_to_gvalue (addr.sin_addr.s_addr)); } g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV, str_to_gvalue (ifname)); /* Prefer the peer options remote address first, _unless_ pppd made the * address up, at which point prefer the local options remote address, * and if that's not right, use the made-up address as a last resort. */ if (peer_opts.hisaddr && (peer_opts.hisaddr != pppd_made_up_address)) { g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_PTP, uint_to_gvalue (peer_opts.hisaddr)); } else if (opts.hisaddr) { g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_PTP, uint_to_gvalue (opts.hisaddr)); } else if (peer_opts.hisaddr == pppd_made_up_address) { /* As a last resort, use the made-up address */ g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_PTP, uint_to_gvalue (peer_opts.hisaddr)); } g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS, uint_to_gvalue (opts.ouraddr)); g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, uint_to_gvalue (32)); if (opts.dnsaddr[0] || opts.dnsaddr[1]) { array = g_array_new (FALSE, FALSE, sizeof (guint32)); if (opts.dnsaddr[0]) g_array_append_val (array, opts.dnsaddr[0]); if (opts.dnsaddr[1]) g_array_append_val (array, opts.dnsaddr[1]); val = g_slice_new0 (GValue); g_value_init (val, DBUS_TYPE_G_UINT_ARRAY); g_value_set_boxed (val, array); g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_DNS, val); } /* Default MTU to 1400, which is also what Windows XP/Vista use */ g_hash_table_insert (hash, NM_VPN_PLUGIN_IP4_CONFIG_MTU, uint_to_gvalue (1400)); g_message ("nm-sstp-ppp-plugin: (%s): sending Ip4Config to NetworkManager-sstp...", __func__); dbus_g_proxy_call_no_reply (proxy, "SetIp4Config", DBUS_TYPE_G_MAP_OF_VARIANT, hash, G_TYPE_INVALID, G_TYPE_INVALID); g_hash_table_destroy (hash); }