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);
}
