static gboolean set_ip_config_common (NMPPPManager *self, GVariant *config_dict, const char *iface_prop, guint32 *out_mtu) { NMPPPManagerPrivate *priv = NM_PPP_MANAGER_GET_PRIVATE (self); NMConnection *applied_connection; NMSettingPpp *s_ppp; const char *iface; if (!g_variant_lookup (config_dict, iface_prop, "&s", &iface)) { _LOGE ("no interface received!"); return FALSE; } if (priv->ip_iface == NULL) priv->ip_iface = g_strdup (iface); /* Got successful IP config; obviously the secrets worked */ applied_connection = nm_act_request_get_applied_connection (priv->act_req); g_object_set_data (G_OBJECT (applied_connection), PPP_MANAGER_SECRET_TRIES, NULL); if (out_mtu) { /* Get any custom MTU */ s_ppp = nm_connection_get_setting_ppp (applied_connection); *out_mtu = s_ppp ? nm_setting_ppp_get_mtu (s_ppp) : 0; } monitor_stats (self); return TRUE; }
CEPage * ce_page_ppp_new (NMConnection *connection, GtkWindow *parent_window, NMClient *client, const char **out_secrets_setting_name, GError **error) { CEPagePpp *self; CEPagePppPrivate *priv; NMSettingConnection *s_con; self = CE_PAGE_PPP (ce_page_new (CE_TYPE_PAGE_PPP, connection, parent_window, client, UIDIR "/ce-page-ppp.ui", "PppPage", _("PPP Settings"))); if (!self) { g_set_error_literal (error, NMA_ERROR, NMA_ERROR_GENERIC, _("Could not load PPP user interface.")); return NULL; } ppp_private_init (self); priv = CE_PAGE_PPP_GET_PRIVATE (self); priv->setting = nm_connection_get_setting_ppp (connection); if (!priv->setting) { priv->setting = NM_SETTING_PPP (nm_setting_ppp_new ()); g_object_set (G_OBJECT (priv->setting), NM_SETTING_PPP_LCP_ECHO_FAILURE, 5, NM_SETTING_PPP_LCP_ECHO_INTERVAL, 30, NULL); nm_connection_add_setting (connection, NM_SETTING (priv->setting)); } priv->window_group = gtk_window_group_new (); s_con = nm_connection_get_setting_connection (connection); g_assert (s_con); priv->connection_id = g_strdup (nm_setting_connection_get_id (s_con)); g_signal_connect (self, "initialized", G_CALLBACK (finish_setup), NULL); *out_secrets_setting_name = NM_SETTING_PPP_SETTING_NAME; return CE_PAGE (self); }
static gboolean complete_connection (NMModem *modem, NMConnection *connection, const GSList *existing_connections, GError **error) { NMSettingGsm *s_gsm; NMSettingPPP *s_ppp; s_gsm = nm_connection_get_setting_gsm (connection); if (!s_gsm || !nm_setting_gsm_get_apn (s_gsm)) { /* Need an APN at least */ g_set_error_literal (error, NM_SETTING_GSM_ERROR, NM_SETTING_GSM_ERROR_MISSING_PROPERTY, NM_SETTING_GSM_APN); return FALSE; } if (!nm_setting_gsm_get_number (s_gsm)) g_object_set (G_OBJECT (s_gsm), NM_SETTING_GSM_NUMBER, "*99#", NULL); s_ppp = nm_connection_get_setting_ppp (connection); if (!s_ppp) { s_ppp = (NMSettingPPP *) nm_setting_ppp_new (); g_object_set (G_OBJECT (s_ppp), NM_SETTING_PPP_LCP_ECHO_FAILURE, 5, NM_SETTING_PPP_LCP_ECHO_INTERVAL, 30, NULL); nm_connection_add_setting (connection, NM_SETTING (s_ppp)); } nm_utils_complete_generic (connection, NM_SETTING_GSM_SETTING_NAME, existing_connections, _("GSM connection %d"), NULL, FALSE); /* No IPv6 yet by default */ return TRUE; }
static void nmt_page_ppp_constructed (GObject *object) { NmtPagePpp *ppp = NMT_PAGE_PPP (object); NmtPagePppPrivate *priv = NMT_PAGE_PPP_GET_PRIVATE (ppp); NmtEditorSection *section; NmtEditorGrid *grid; NMSettingPpp *s_ppp; NmtNewtWidget *widget, *use_mppe; NmtNewtGrid *auth_grid, *mppe_grid; NmtNewtSection *auth_section, *mppe_section; NMConnection *conn; conn = nmt_editor_page_get_connection (NMT_EDITOR_PAGE (ppp)); s_ppp = nm_connection_get_setting_ppp (conn); if (s_ppp) { priv->lcp_echo_interval = nm_setting_ppp_get_lcp_echo_interval (s_ppp); priv->lcp_echo_failure = nm_setting_ppp_get_lcp_echo_failure (s_ppp); } else { s_ppp = (NMSettingPpp *) nm_setting_ppp_new (); nm_connection_add_setting (conn, (NMSetting *) s_ppp); priv->lcp_echo_interval = 30; priv->lcp_echo_failure = 5; } section = nmt_editor_section_new (_("PPP CONFIGURATION"), NULL, TRUE); grid = nmt_editor_section_get_body (section); /* Auth methods */ widget = nmt_newt_section_new (FALSE); auth_section = NMT_NEWT_SECTION (widget); g_object_set (auth_section, "open", TRUE, NULL); nmt_editor_grid_append (grid, NULL, widget, NULL); widget = nmt_newt_label_new (_("Allowed authentication methods:")); nmt_newt_section_set_header (auth_section, widget); widget = nmt_newt_grid_new (); auth_grid = NMT_NEWT_GRID (widget); nmt_newt_section_set_body (auth_section, widget); widget = nmt_newt_checkbox_new (_("EAP")); g_object_bind_property (s_ppp, NM_SETTING_PPP_REFUSE_EAP, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (auth_grid, widget, 0, 0); widget = nmt_newt_checkbox_new (_("PAP")); g_object_bind_property (s_ppp, NM_SETTING_PPP_REFUSE_PAP, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (auth_grid, widget, 0, 1); widget = nmt_newt_checkbox_new (_("CHAP")); g_object_bind_property (s_ppp, NM_SETTING_PPP_REFUSE_CHAP, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (auth_grid, widget, 0, 2); widget = nmt_newt_checkbox_new (_("MSCHAPv2")); g_object_bind_property (s_ppp, NM_SETTING_PPP_REFUSE_MSCHAPV2, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (auth_grid, widget, 0, 3); widget = nmt_newt_checkbox_new (_("MSCHAP")); g_object_bind_property (s_ppp, NM_SETTING_PPP_REFUSE_MSCHAP, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (auth_grid, widget, 0, 4); nmt_editor_grid_append (grid, NULL, nmt_newt_separator_new (), NULL); /* MPPE */ widget = nmt_newt_section_new (FALSE); mppe_section = NMT_NEWT_SECTION (widget); g_object_set (mppe_section, "open", TRUE, NULL); nmt_editor_grid_append (grid, NULL, widget, NULL); widget = nmt_newt_checkbox_new (_("Use point-to-point encryption (MPPE)")); g_object_bind_property (s_ppp, NM_SETTING_PPP_REQUIRE_MPPE, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); use_mppe = widget; nmt_newt_section_set_header (mppe_section, widget); widget = nmt_newt_grid_new (); mppe_grid = NMT_NEWT_GRID (widget); nmt_newt_section_set_body (mppe_section, widget); widget = nmt_newt_checkbox_new (_("Require 128-bit encryption")); g_object_bind_property (use_mppe, "active", widget, "sensitive", G_BINDING_SYNC_CREATE); g_object_bind_property (s_ppp, NM_SETTING_PPP_REQUIRE_MPPE_128, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (mppe_grid, widget, 0, 0); widget = nmt_newt_checkbox_new (_("Use stateful MPPE")); g_object_bind_property (use_mppe, "active", widget, "sensitive", G_BINDING_SYNC_CREATE); g_object_bind_property (s_ppp, NM_SETTING_PPP_MPPE_STATEFUL, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); nmt_newt_grid_add (mppe_grid, widget, 0, 1); nmt_editor_grid_append (grid, NULL, nmt_newt_separator_new (), NULL); widget = nmt_newt_checkbox_new (_("Allow BSD data compression")); g_object_bind_property (s_ppp, NM_SETTING_PPP_NOBSDCOMP, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE); nmt_editor_grid_append (grid, NULL, widget, NULL); widget = nmt_newt_checkbox_new (_("Allow Deflate data compression")); g_object_bind_property (s_ppp, NM_SETTING_PPP_NODEFLATE, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE); nmt_editor_grid_append (grid, NULL, widget, NULL); widget = nmt_newt_checkbox_new (_("Use TCP header compression")); g_object_bind_property (s_ppp, NM_SETTING_PPP_NO_VJ_COMP, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE); nmt_editor_grid_append (grid, NULL, widget, NULL); nmt_editor_grid_append (grid, NULL, nmt_newt_separator_new (), NULL); widget = nmt_newt_checkbox_new (_("Send PPP echo packets")); g_object_bind_property_full (s_ppp, NM_SETTING_PPP_LCP_ECHO_INTERVAL, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE, transform_lcp_echo_properties_to_checkbox, transform_checkbox_to_lcp_echo_interval, ppp, NULL); g_object_bind_property_full (s_ppp, NM_SETTING_PPP_LCP_ECHO_FAILURE, widget, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE, transform_lcp_echo_properties_to_checkbox, transform_checkbox_to_lcp_echo_failure, ppp, NULL); nmt_editor_grid_append (grid, NULL, widget, NULL); nmt_editor_page_add_section (NMT_EDITOR_PAGE (ppp), section); G_OBJECT_CLASS (nmt_page_ppp_parent_class)->constructed (object); }
static GHashTable * create_connect_properties (NMConnection *connection) { NMSettingGsm *setting; NMSettingPPP *s_ppp; GHashTable *properties; const char *str; setting = nm_connection_get_setting_gsm (connection); properties = value_hash_create (); str = nm_setting_gsm_get_number (setting); if (str) value_hash_add_str (properties, "number", str); str = nm_setting_gsm_get_apn (setting); if (str) value_hash_add_str (properties, "apn", str); str = nm_setting_gsm_get_network_id (setting); if (str) value_hash_add_str (properties, "network_id", str); str = nm_setting_gsm_get_pin (setting); if (str) value_hash_add_str (properties, "pin", str); str = nm_setting_gsm_get_username (setting); if (str) value_hash_add_str (properties, "username", str); str = nm_setting_gsm_get_password (setting); if (str) value_hash_add_str (properties, "password", str); /* Add both old and new preferred modes */ switch (nm_setting_gsm_get_network_type (setting)) { case NM_SETTING_GSM_NETWORK_TYPE_UMTS_HSPA: value_hash_add_uint (properties, "network_mode", MM_MODEM_GSM_NETWORK_DEPRECATED_MODE_3G_ONLY); value_hash_add_uint (properties, "allowed_mode", MM_MODEM_GSM_ALLOWED_MODE_3G_ONLY); break; case NM_SETTING_GSM_NETWORK_TYPE_GPRS_EDGE: value_hash_add_uint (properties, "network_mode", MM_MODEM_GSM_NETWORK_DEPRECATED_MODE_2G_ONLY); value_hash_add_uint (properties, "allowed_mode", MM_MODEM_GSM_ALLOWED_MODE_2G_ONLY); break; case NM_SETTING_GSM_NETWORK_TYPE_PREFER_UMTS_HSPA: value_hash_add_uint (properties, "network_mode", MM_MODEM_GSM_NETWORK_DEPRECATED_MODE_3G_PREFERRED); value_hash_add_uint (properties, "allowed_mode", MM_MODEM_GSM_ALLOWED_MODE_3G_PREFERRED); break; case NM_SETTING_GSM_NETWORK_TYPE_PREFER_GPRS_EDGE: value_hash_add_uint (properties, "network_mode", MM_MODEM_GSM_NETWORK_DEPRECATED_MODE_2G_PREFERRED); value_hash_add_uint (properties, "allowed_mode", MM_MODEM_GSM_ALLOWED_MODE_2G_PREFERRED); break; case NM_SETTING_GSM_NETWORK_TYPE_PREFER_4G: /* deprecated modes not extended for 4G, so no need to set them here */ value_hash_add_uint (properties, "allowed_mode", MM_MODEM_GSM_ALLOWED_MODE_4G_PREFERRED); break; case NM_SETTING_GSM_NETWORK_TYPE_4G: /* deprecated modes not extended for 4G, so no need to set them here */ value_hash_add_uint (properties, "allowed_mode", MM_MODEM_GSM_ALLOWED_MODE_4G_ONLY); break; default: value_hash_add_uint (properties, "network_mode", MM_MODEM_GSM_NETWORK_DEPRECATED_MODE_ANY); value_hash_add_uint (properties, "allowed_mode", MM_MODEM_GSM_ALLOWED_MODE_ANY); break; } /* Roaming */ if (nm_setting_gsm_get_home_only (setting)) value_hash_add_bool (properties, "home_only", TRUE); /* For IpMethod == STATIC or DHCP */ s_ppp = nm_connection_get_setting_ppp (connection); if (s_ppp) { guint32 auth = MM_MODEM_GSM_ALLOWED_AUTH_UNKNOWN; if (nm_setting_ppp_get_noauth (s_ppp)) auth |= MM_MODEM_GSM_ALLOWED_AUTH_NONE; if (!nm_setting_ppp_get_refuse_pap (s_ppp)) auth |= MM_MODEM_GSM_ALLOWED_AUTH_PAP; if (!nm_setting_ppp_get_refuse_chap (s_ppp)) auth |= MM_MODEM_GSM_ALLOWED_AUTH_CHAP; if (!nm_setting_ppp_get_refuse_mschap (s_ppp)) auth |= MM_MODEM_GSM_ALLOWED_AUTH_MSCHAP; if (!nm_setting_ppp_get_refuse_mschapv2 (s_ppp)) auth |= MM_MODEM_GSM_ALLOWED_AUTH_MSCHAPV2; if (!nm_setting_ppp_get_refuse_eap (s_ppp)) auth |= MM_MODEM_GSM_ALLOWED_AUTH_EAP; if (auth != MM_MODEM_GSM_ALLOWED_AUTH_UNKNOWN) value_hash_add_uint (properties, "allowed_auth", auth); } return properties; }
gboolean nm_ppp_manager_start (NMPPPManager *manager, NMActRequest *req, const char *ppp_name, guint32 timeout_secs, GError **err) { NMPPPManagerPrivate *priv; NMConnection *connection; NMSettingPpp *s_ppp; gboolean s_ppp_created = FALSE; NMSettingPppoe *pppoe_setting; NMSettingAdsl *adsl_setting; NMCmdLine *ppp_cmd; char *cmd_str; struct stat st; g_return_val_if_fail (NM_IS_PPP_MANAGER (manager), FALSE); g_return_val_if_fail (NM_IS_ACT_REQUEST (req), FALSE); priv = NM_PPP_MANAGER_GET_PRIVATE (manager); #if !WITH_PPP /* PPP support disabled */ g_set_error_literal (err, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED, "PPP support is not enabled."); return FALSE; #endif priv->pid = 0; /* Make sure /dev/ppp exists (bgo #533064) */ if (stat ("/dev/ppp", &st) || !S_ISCHR (st.st_mode)) nm_utils_modprobe (NULL, FALSE, "ppp_generic", NULL); connection = nm_act_request_get_applied_connection (req); g_assert (connection); s_ppp = nm_connection_get_setting_ppp (connection); if (!s_ppp) { /* If the PPP settings are all default we may not have a PPP setting yet, * so just make a default one here. */ s_ppp = NM_SETTING_PPP (nm_setting_ppp_new ()); s_ppp_created = TRUE; } pppoe_setting = nm_connection_get_setting_pppoe (connection); if (pppoe_setting) pppoe_fill_defaults (s_ppp); adsl_setting = (NMSettingAdsl *) nm_connection_get_setting (connection, NM_TYPE_SETTING_ADSL); ppp_cmd = create_pppd_cmd_line (manager, s_ppp, pppoe_setting, adsl_setting, ppp_name, err); if (!ppp_cmd) goto out; g_ptr_array_add (ppp_cmd->array, NULL); _LOGI ("starting PPP connection"); cmd_str = nm_cmd_line_to_str (ppp_cmd); _LOGD ("command line: %s", cmd_str); g_free (cmd_str); priv->pid = 0; if (!g_spawn_async (NULL, (char **) ppp_cmd->array->pdata, NULL, G_SPAWN_DO_NOT_REAP_CHILD, nm_utils_setpgid, NULL, &priv->pid, err)) { goto out; } _LOGI ("pppd started with pid %d", priv->pid); priv->ppp_watch_id = g_child_watch_add (priv->pid, (GChildWatchFunc) ppp_watch_cb, manager); priv->ppp_timeout_handler = g_timeout_add_seconds (timeout_secs, pppd_timed_out, manager); priv->act_req = g_object_ref (req); out: if (s_ppp_created) g_object_unref (s_ppp); if (ppp_cmd) nm_cmd_line_destroy (ppp_cmd); return priv->pid > 0; }
static gboolean complete_connection (NMDevice *device, NMConnection *connection, const char *specific_object, const GSList *existing_connections, GError **error) { NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE (device); NMSettingBluetooth *s_bt; const GByteArray *setting_bdaddr; struct ether_addr *devaddr = ether_aton (priv->bdaddr); const char *ctype; gboolean is_dun = FALSE, is_pan = FALSE; NMSettingGsm *s_gsm; NMSettingCdma *s_cdma; NMSettingSerial *s_serial; NMSettingPPP *s_ppp; const char *format = NULL, *preferred = NULL; s_gsm = nm_connection_get_setting_gsm (connection); s_cdma = nm_connection_get_setting_cdma (connection); s_serial = nm_connection_get_setting_serial (connection); s_ppp = nm_connection_get_setting_ppp (connection); s_bt = nm_connection_get_setting_bluetooth (connection); if (!s_bt) { s_bt = (NMSettingBluetooth *) nm_setting_bluetooth_new (); nm_connection_add_setting (connection, NM_SETTING (s_bt)); } ctype = nm_setting_bluetooth_get_connection_type (s_bt); if (ctype) { if (!strcmp (ctype, NM_SETTING_BLUETOOTH_TYPE_DUN)) is_dun = TRUE; else if (!strcmp (ctype, NM_SETTING_BLUETOOTH_TYPE_PANU)) is_pan = TRUE; } else { if (s_gsm || s_cdma) is_dun = TRUE; else if (priv->capabilities & NM_BT_CAPABILITY_NAP) is_pan = TRUE; } if (is_pan) { /* Make sure the device supports PAN */ if (!(priv->capabilities & NM_BT_CAPABILITY_NAP)) { g_set_error_literal (error, NM_SETTING_BLUETOOTH_ERROR, NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY, "PAN required but Bluetooth device does not support NAP"); return FALSE; } /* PAN can't use any DUN-related settings */ if (s_gsm || s_cdma || s_serial || s_ppp) { g_set_error_literal (error, NM_SETTING_BLUETOOTH_ERROR, NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY, "PAN incompatible with GSM, CDMA, or serial settings"); return FALSE; } g_object_set (G_OBJECT (s_bt), NM_SETTING_BLUETOOTH_TYPE, NM_SETTING_BLUETOOTH_TYPE_PANU, NULL); format = _("PAN connection %d"); } else if (is_dun) { /* Make sure the device supports PAN */ if (!(priv->capabilities & NM_BT_CAPABILITY_DUN)) { g_set_error_literal (error, NM_SETTING_BLUETOOTH_ERROR, NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY, "DUN required but Bluetooth device does not support DUN"); return FALSE; } /* Need at least a GSM or a CDMA setting */ if (!s_gsm && !s_cdma) { g_set_error_literal (error, NM_SETTING_BLUETOOTH_ERROR, NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY, "Setting requires DUN but no GSM or CDMA setting is present"); return FALSE; } g_object_set (G_OBJECT (s_bt), NM_SETTING_BLUETOOTH_TYPE, NM_SETTING_BLUETOOTH_TYPE_DUN, NULL); if (s_gsm) { format = _("GSM connection %d"); if (!nm_setting_gsm_get_number (s_gsm)) g_object_set (G_OBJECT (s_gsm), NM_SETTING_GSM_NUMBER, "*99#", NULL); } else if (s_cdma) { format = _("CDMA connection %d"); if (!nm_setting_cdma_get_number (s_cdma)) g_object_set (G_OBJECT (s_cdma), NM_SETTING_GSM_NUMBER, "#777", NULL); } else format = _("DUN connection %d"); } else { g_set_error_literal (error, NM_SETTING_BLUETOOTH_ERROR, NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY, "Unknown/unhandled Bluetooth connection type"); return FALSE; } nm_utils_complete_generic (connection, NM_SETTING_BLUETOOTH_SETTING_NAME, existing_connections, format, preferred, is_dun ? FALSE : TRUE); /* No IPv6 yet for DUN */ setting_bdaddr = nm_setting_bluetooth_get_bdaddr (s_bt); if (setting_bdaddr) { /* Make sure the setting BT Address (if any) matches the device's */ if (memcmp (setting_bdaddr->data, devaddr->ether_addr_octet, ETH_ALEN)) { g_set_error_literal (error, NM_SETTING_BLUETOOTH_ERROR, NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY, NM_SETTING_BLUETOOTH_BDADDR); return FALSE; } } else { GByteArray *bdaddr; const guint8 null_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 }; /* Lock the connection to this device by default */ if (memcmp (devaddr->ether_addr_octet, null_mac, ETH_ALEN)) { bdaddr = g_byte_array_sized_new (ETH_ALEN); g_byte_array_append (bdaddr, devaddr->ether_addr_octet, ETH_ALEN); g_object_set (G_OBJECT (s_bt), NM_SETTING_BLUETOOTH_BDADDR, bdaddr, NULL); g_byte_array_free (bdaddr, TRUE); } } return TRUE; }