static gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMSettingGsm *s_gsm; NMSettingCdma *s_cdma; NMDeviceModemCapabilities current_caps; if (!NM_DEVICE_CLASS (nm_device_modem_parent_class)->connection_compatible (device, connection, error)) return FALSE; if ( !nm_connection_is_type (connection, NM_SETTING_GSM_SETTING_NAME) && !nm_connection_is_type (connection, NM_SETTING_CDMA_SETTING_NAME)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The connection was not a modem connection.")); return FALSE; } s_gsm = nm_connection_get_setting_gsm (connection); s_cdma = nm_connection_get_setting_cdma (connection); if (!s_cdma && !s_gsm) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INVALID_CONNECTION, _("The connection was not a valid modem connection.")); return FALSE; } current_caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (device)); if (!(s_gsm && MODEM_CAPS_3GPP (current_caps)) && !(s_cdma && MODEM_CAPS_3GPP2 (current_caps))) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The device is lacking capabilities required by the connection.")); return FALSE; } return TRUE; }
/* return value must be freed by caller with g_free() */ static gchar * get_mac_address_of_connection (NMConnection *connection) { const GByteArray *mac = NULL; if (!connection) return NULL; /* check the connection type */ if (nm_connection_is_type (connection, NM_SETTING_WIRELESS_SETTING_NAME)) { /* check wireless settings */ NMSettingWireless *s_wireless = nm_connection_get_setting_wireless (connection); if (!s_wireless) return NULL; mac = nm_setting_wireless_get_mac_address (s_wireless); if (mac) return nm_utils_hwaddr_ntoa (mac->data, ARPHRD_ETHER); } else if (nm_connection_is_type (connection, NM_SETTING_WIRED_SETTING_NAME)) { /* check wired settings */ NMSettingWired *s_wired = nm_connection_get_setting_wired (connection); if (!s_wired) return NULL; mac = nm_setting_wired_get_mac_address (s_wired); if (mac) return nm_utils_hwaddr_ntoa (mac->data, ARPHRD_ETHER); } else if (nm_connection_is_type (connection, NM_SETTING_WIMAX_SETTING_NAME)) { /* check wimax settings */ NMSettingWimax *s_wimax = nm_connection_get_setting_wimax (connection); if (!s_wimax) return NULL; mac = nm_setting_wimax_get_mac_address (s_wimax); if (mac) return nm_utils_hwaddr_ntoa (mac->data, ARPHRD_ETHER); } else if (nm_connection_is_type (connection, NM_SETTING_INFINIBAND_SETTING_NAME)) { /* check infiniband settings */ NMSettingInfiniband *s_infiniband = \ nm_connection_get_setting_infiniband (connection); if (!s_infiniband) return NULL; mac = nm_setting_infiniband_get_mac_address (s_infiniband); if (mac) return nm_utils_hwaddr_ntoa (mac->data, ARPHRD_INFINIBAND); } /* no MAC address found */ return NULL; }
NMDevice * nm_device_factory_create_device (NMDeviceFactory *factory, const char *iface, const NMPlatformLink *plink, NMConnection *connection, gboolean *out_ignore, GError **error) { NMDeviceFactoryInterface *interface; const NMLinkType *link_types = NULL; const char **setting_types = NULL; int i; g_return_val_if_fail (factory, NULL); g_return_val_if_fail (iface && *iface, NULL); g_return_val_if_fail (plink || connection, NULL); g_return_val_if_fail (!plink || !connection, NULL); nm_device_factory_get_supported_types (factory, &link_types, &setting_types); if (plink) { g_return_val_if_fail (strcmp (iface, plink->name) == 0, NULL); for (i = 0; link_types[i] > NM_LINK_TYPE_UNKNOWN; i++) { if (plink->type == link_types[i]) break; } if (link_types[i] == NM_LINK_TYPE_UNKNOWN) { g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_CREATION_FAILED, "Device factory %s does not support link type %s (%d)", G_OBJECT_TYPE_NAME (factory), plink->kind, plink->type); return NULL; } } else if (connection) { for (i = 0; setting_types && setting_types[i]; i++) { if (nm_connection_is_type (connection, setting_types[i])) break; } if (!setting_types[i]) { g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, "Device factory %s does not support connection type %s", G_OBJECT_TYPE_NAME (factory), nm_connection_get_connection_type (connection)); return NULL; } } interface = NM_DEVICE_FACTORY_GET_INTERFACE (factory); if (!interface->create_device) { g_set_error (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED, "Device factory %s cannot manage new devices", G_OBJECT_TYPE_NAME (factory)); return NULL; } return interface->create_device (factory, iface, plink, connection, out_ignore); }
static gboolean connection_compatible (NMBluezDevice *self, NMConnection *connection) { NMBluezDevicePrivate *priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self); NMSettingBluetooth *s_bt; const char *bt_type; const char *bdaddr; if (!nm_connection_is_type (connection, NM_SETTING_BLUETOOTH_SETTING_NAME)) return FALSE; s_bt = nm_connection_get_setting_bluetooth (connection); if (!s_bt) return FALSE; if (!priv->address) return FALSE; bdaddr = nm_setting_bluetooth_get_bdaddr (s_bt); if (!bdaddr) return FALSE; if (!nm_utils_hwaddr_matches (bdaddr, -1, priv->address, -1)) return FALSE; bt_type = nm_setting_bluetooth_get_connection_type (s_bt); if ( g_str_equal (bt_type, NM_SETTING_BLUETOOTH_TYPE_DUN) && !(priv->capabilities & NM_BT_CAPABILITY_DUN)) return FALSE; if ( g_str_equal (bt_type, NM_SETTING_BLUETOOTH_TYPE_PANU) && !(priv->capabilities & NM_BT_CAPABILITY_NAP)) return FALSE; return TRUE; }
static gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMSettingWimax *s_wimax; const char *hwaddr, *setting_hwaddr; if (!NM_DEVICE_CLASS (nm_device_wimax_parent_class)->connection_compatible (device, connection, error)) return FALSE; if (!nm_connection_is_type (connection, NM_SETTING_WIMAX_SETTING_NAME)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The connection was not a WiMAX connection.")); return FALSE; } /* Check MAC address */ hwaddr = nm_device_wimax_get_hw_address (NM_DEVICE_WIMAX (device)); if (hwaddr) { if (!nm_utils_hwaddr_valid (hwaddr, ETH_ALEN)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED, _("Invalid device MAC address.")); return FALSE; } s_wimax = nm_connection_get_setting_wimax (connection); setting_hwaddr = nm_setting_wimax_get_mac_address (s_wimax); if (setting_hwaddr && !nm_utils_hwaddr_matches (setting_hwaddr, -1, hwaddr, -1)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The MACs of the device and the connection didn't match.")); return FALSE; } } return TRUE; }
static gboolean check_connection_compatible (NMDevice *device, NMConnection *connection) { NMSettingInfiniband *s_infiniband; if (!NM_DEVICE_CLASS (nm_device_infiniband_parent_class)->check_connection_compatible (device, connection)) return FALSE; if (!nm_connection_is_type (connection, NM_SETTING_INFINIBAND_SETTING_NAME)) return FALSE; s_infiniband = nm_connection_get_setting_infiniband (connection); if (!s_infiniband) return FALSE; if (s_infiniband) { const char *mac; mac = nm_setting_infiniband_get_mac_address (s_infiniband); if (mac && !nm_utils_hwaddr_matches (mac, -1, nm_device_get_hw_address (device), -1)) return FALSE; } return TRUE; }
static gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMSettingInfiniband *s_infiniband; const char *hwaddr, *setting_hwaddr; if (!NM_DEVICE_CLASS (nm_device_infiniband_parent_class)->connection_compatible (device, connection, error)) return FALSE; if (!nm_connection_is_type (connection, NM_SETTING_INFINIBAND_SETTING_NAME)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The connection was not an InfiniBand connection.")); return FALSE; } hwaddr = nm_device_infiniband_get_hw_address (NM_DEVICE_INFINIBAND (device)); if (hwaddr) { if (!nm_utils_hwaddr_valid (hwaddr, INFINIBAND_ALEN)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED, _("Invalid device MAC address.")); return FALSE; } s_infiniband = nm_connection_get_setting_infiniband (connection); setting_hwaddr = nm_setting_infiniband_get_mac_address (s_infiniband); if (setting_hwaddr && !nm_utils_hwaddr_matches (setting_hwaddr, -1, hwaddr, -1)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The MACs of the device and the connection didn't match.")); return FALSE; } } return TRUE; }
static GSList * append_nmt_devices_for_vpns (GSList *nmt_devices, GSList *connections) { NmtConnectDevice *nmtdev; GSList *iter; NMConnection *conn; NmtConnectConnection *nmtconn; nmtdev = g_slice_new0 (NmtConnectDevice); nmtdev->name = g_strdup (_("VPN")); nmtdev->sort_order = 100; for (iter = connections; iter; iter = iter->next) { conn = iter->data; if (!nm_connection_is_type (conn, NM_SETTING_VPN_SETTING_NAME)) continue; nmtconn = g_slice_new0 (NmtConnectConnection); nmtconn->name = nm_connection_get_id (conn); nmtconn->conn = g_object_ref (conn); nmtdev->conns = g_slist_insert_sorted (nmtdev->conns, nmtconn, sort_connections); } if (nmtdev->conns) nmt_devices = g_slist_prepend (nmt_devices, nmtdev); else nmt_connect_device_free (nmtdev); return nmt_devices; }
static GSList * append_nmt_devices_for_vpns (GSList *nmt_devices, const GPtrArray *connections) { NmtConnectDevice *nmtdev; int i; NMConnection *conn; NmtConnectConnection *nmtconn; nmtdev = g_slice_new0 (NmtConnectDevice); nmtdev->name = g_strdup (_("VPN")); nmtdev->sort_order = 100; for (i = 0; i < connections->len; i++) { conn = connections->pdata[i]; if (!nm_connection_is_type (conn, NM_SETTING_VPN_SETTING_NAME)) continue; nmtconn = g_slice_new0 (NmtConnectConnection); nmtconn->name = nm_connection_get_id (conn); nmtconn->conn = g_object_ref (conn); nmtdev->conns = g_slist_insert_sorted (nmtdev->conns, nmtconn, sort_connections); } if (nmtdev->conns) nmt_devices = g_slist_prepend (nmt_devices, nmtdev); else nmt_connect_device_free (nmtdev); return nmt_devices; }
static gboolean check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { const char *iface; NMSettingBridge *s_bridge; if (!NM_DEVICE_CLASS (nm_device_bridge_parent_class)->check_connection_compatible (device, connection, error)) return FALSE; s_bridge = nm_connection_get_setting_bridge (connection); if (!s_bridge || !nm_connection_is_type (connection, NM_SETTING_BRIDGE_SETTING_NAME)) { g_set_error (error, NM_BRIDGE_ERROR, NM_BRIDGE_ERROR_CONNECTION_NOT_BRIDGE, "The connection was not a bridge connection."); return FALSE; } /* Bridge connections must specify the virtual interface name */ iface = nm_connection_get_virtual_iface_name (connection); if (!iface || strcmp (nm_device_get_iface (device), iface)) { g_set_error (error, NM_BRIDGE_ERROR, NM_BRIDGE_ERROR_CONNECTION_INVALID, "The bridge connection virtual interface name did not match."); return FALSE; } return TRUE; }
static NMDevice * create_virtual_device_for_connection (NMDeviceFactory *factory, NMConnection *connection, NMDevice *parent, GError **error) { const char *iface; if (!nm_connection_is_type (connection, NM_SETTING_BOND_SETTING_NAME)) return NULL; iface = nm_connection_get_interface_name (connection); g_return_val_if_fail (iface != NULL, NULL); if ( !nm_platform_bond_add (iface) && nm_platform_get_error () != NM_PLATFORM_ERROR_EXISTS) { nm_log_warn (LOGD_DEVICE | LOGD_BOND, "(%s): failed to create bonding master interface for '%s': %s", iface, nm_connection_get_id (connection), nm_platform_get_error_msg ()); return NULL; } return (NMDevice *) g_object_new (NM_TYPE_DEVICE_BOND, NM_DEVICE_IFACE, iface, NM_DEVICE_DRIVER, "bonding", NM_DEVICE_TYPE_DESC, "Bond", NM_DEVICE_DEVICE_TYPE, NM_DEVICE_TYPE_BOND, NM_DEVICE_IS_MASTER, TRUE, NULL); }
static gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMDeviceTunPrivate *priv = NM_DEVICE_TUN_GET_PRIVATE (device); NMSettingTunMode mode; NMSettingTun *s_tun; if (!NM_DEVICE_CLASS (nm_device_tun_parent_class)->connection_compatible (device, connection, error)) return FALSE; if (!nm_connection_is_type (connection, NM_SETTING_TUN_SETTING_NAME)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The connection was not a tun connection.")); return FALSE; } s_tun = nm_connection_get_setting_tun (connection); mode = tun_mode_from_string (priv->mode); if (s_tun && mode != nm_setting_tun_get_mode (s_tun)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The mode of the device and the connection didn't match")); return FALSE; } return TRUE; }
static gboolean check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { const char *iface; NMSettingBond *s_bond; if (!NM_DEVICE_CLASS (nm_device_bond_parent_class)->check_connection_compatible (device, connection, error)) return FALSE; s_bond = nm_connection_get_setting_bond (connection); if (!s_bond || !nm_connection_is_type (connection, NM_SETTING_BOND_SETTING_NAME)) { g_set_error (error, NM_BOND_ERROR, NM_BOND_ERROR_CONNECTION_NOT_BOND, "The connection was not a bond connection."); return FALSE; } /* Bond connections must specify the virtual interface name */ iface = nm_connection_get_virtual_iface_name (connection); if (!iface || strcmp (nm_device_get_iface (device), iface)) { g_set_error (error, NM_BOND_ERROR, NM_BOND_ERROR_CONNECTION_NOT_BOND, "The bond connection virtual interface name did not match."); return FALSE; } /* FIXME: match bond properties like mode, etc? */ return TRUE; }
static NMConnection * get_best_auto_connection (NMDevice *device, GSList *connections, char **specific_object) { NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE (device); GSList *iter; for (iter = connections; iter; iter = g_slist_next (iter)) { NMConnection *connection = NM_CONNECTION (iter->data); guint32 bt_type; if (!nm_connection_is_type (connection, NM_SETTING_BLUETOOTH_SETTING_NAME)) continue; bt_type = get_connection_bt_type (connection); if (!(bt_type & priv->capabilities)) continue; /* Can't auto-activate a DUN connection without ModemManager */ if (bt_type == NM_BT_CAPABILITY_DUN && priv->mm_running == FALSE) continue; return connection; } return NULL; }
static char * get_virtual_iface_name (NMDeviceFactory *factory, NMConnection *connection, const char *parent_iface) { const char *ifname; NMSettingVlan *s_vlan; g_return_val_if_fail (nm_connection_is_type (connection, NM_SETTING_VLAN_SETTING_NAME), NULL); s_vlan = nm_connection_get_setting_vlan (connection); g_assert (s_vlan); if (!parent_iface) return NULL; ifname = nm_connection_get_interface_name (connection); if (ifname) return g_strdup (ifname); /* If the connection doesn't specify the interface name for the VLAN * device, we create one for it using the VLAN ID and the parent * interface's name. */ return nm_utils_new_vlan_name (parent_iface, nm_setting_vlan_get_id (s_vlan)); }
static void slaves_changed (GObject *object, GParamSpec *pspec, gpointer user_data) { NmtPageBond *bond = NMT_PAGE_BOND (user_data); NmtPageBondPrivate *priv = NMT_PAGE_BOND_GET_PRIVATE (bond); GPtrArray *slaves; g_object_get (object, "connections", &slaves, NULL); if (slaves->len == 0) { if (priv->slave_type == G_TYPE_NONE) return; priv->slave_type = G_TYPE_NONE; } else { NMConnection *slave = slaves->pdata[0]; if (priv->slave_type != G_TYPE_NONE) return; if (nm_connection_is_type (slave, NM_SETTING_INFINIBAND_SETTING_NAME)) priv->slave_type = NM_TYPE_SETTING_INFINIBAND; else priv->slave_type = NM_TYPE_SETTING_WIRED; } if (priv->slave_type == NM_TYPE_SETTING_INFINIBAND) { nmt_newt_popup_set_active_id (priv->mode, "active-backup"); nmt_newt_component_set_sensitive (NMT_NEWT_COMPONENT (priv->mode), FALSE); } else nmt_newt_component_set_sensitive (NMT_NEWT_COMPONENT (priv->mode), TRUE); }
static NMConnection * connection_match_config (NMDevice *self, const GSList *connections) { const GSList *iter; GSList *infiniband_matches; NMConnection *match; /* First narrow @connections down to those that match in their * NMSettingInfiniband configuration. */ infiniband_matches = NULL; for (iter = connections; iter; iter = iter->next) { NMConnection *candidate = NM_CONNECTION (iter->data); if (!nm_connection_is_type (candidate, NM_SETTING_INFINIBAND_SETTING_NAME)) continue; if (!infiniband_match_config (self, candidate)) continue; infiniband_matches = g_slist_prepend (infiniband_matches, candidate); } /* Now pass those to the super method, which will check IP config */ infiniband_matches = g_slist_reverse (infiniband_matches); match = NM_DEVICE_CLASS (nm_device_infiniband_parent_class)->connection_match_config (self, infiniband_matches); g_slist_free (infiniband_matches); return match; }
static gboolean complete_connection (NMDevice *device, NMConnection *connection, const char *specific_object, const GSList *existing_connections, GError **error) { NMSettingBridge *s_bridge, *tmp; guint32 i = 0; char *name; const GSList *iter; gboolean found; nm_utils_complete_generic (connection, NM_SETTING_BRIDGE_SETTING_NAME, existing_connections, _("Bridge connection %d"), NULL, TRUE); s_bridge = nm_connection_get_setting_bridge (connection); if (!s_bridge) { s_bridge = (NMSettingBridge *) nm_setting_bridge_new (); nm_connection_add_setting (connection, NM_SETTING (s_bridge)); } /* Grab the first name that doesn't exist in either our connections * or a device on the system. */ while (i < 500 && !nm_setting_bridge_get_interface_name (s_bridge)) { name = g_strdup_printf ("br%u", i); /* check interface names */ if (!nm_platform_link_exists (name)) { /* check existing bridge connections */ for (iter = existing_connections, found = FALSE; iter; iter = g_slist_next (iter)) { NMConnection *candidate = iter->data; tmp = nm_connection_get_setting_bridge (candidate); if (tmp && nm_connection_is_type (candidate, NM_SETTING_BRIDGE_SETTING_NAME)) { if (g_strcmp0 (nm_setting_bridge_get_interface_name (tmp), name) == 0) { found = TRUE; break; } } } if (!found) g_object_set (G_OBJECT (s_bridge), NM_SETTING_BRIDGE_INTERFACE_NAME, name, NULL); } g_free (name); i++; } return TRUE; }
static gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMSettingWired *s_wired; gboolean is_pppoe = FALSE; if (!NM_DEVICE_CLASS (nm_device_ethernet_parent_class)->connection_compatible (device, connection, error)) return FALSE; if (nm_connection_is_type (connection, NM_SETTING_PPPOE_SETTING_NAME)) is_pppoe = TRUE; else if (!nm_connection_is_type (connection, NM_SETTING_WIRED_SETTING_NAME)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The connection was not an Ethernet or PPPoE connection.")); return FALSE; } s_wired = nm_connection_get_setting_wired (connection); /* Wired setting optional for PPPoE */ if (s_wired) { const char *perm_addr, *setting_addr; /* FIXME: filter using s390 subchannels when they are exported over the bus */ /* Check MAC address */ perm_addr = nm_device_ethernet_get_permanent_hw_address (NM_DEVICE_ETHERNET (device)); if (perm_addr) { if (!nm_utils_hwaddr_valid (perm_addr, ETH_ALEN)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED, _("Invalid device MAC address.")); return FALSE; } setting_addr = nm_setting_wired_get_mac_address (s_wired); if (setting_addr && !nm_utils_hwaddr_matches (setting_addr, -1, perm_addr, -1)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The MACs of the device and the connection didn't match.")); return FALSE; } } } return TRUE; }
void bond_connection_new (GtkWindow *parent, const char *detail, NMRemoteSettings *settings, PageNewConnectionResultFunc result_func, gpointer user_data) { NMConnection *connection; int bond_num, max_bond_num, num; GSList *connections, *iter; NMConnection *conn2; NMSettingBond *s_bond; const char *iface; char *my_iface; connection = ce_page_new_connection (_("Bond connection %d"), NM_SETTING_BOND_SETTING_NAME, TRUE, settings, user_data); nm_connection_add_setting (connection, nm_setting_bond_new ()); /* Find an available interface name */ bond_num = max_bond_num = 0; connections = nm_remote_settings_list_connections (settings); for (iter = connections; iter; iter = iter->next) { conn2 = iter->data; if (!nm_connection_is_type (conn2, NM_SETTING_BOND_SETTING_NAME)) continue; s_bond = nm_connection_get_setting_bond (conn2); if (!s_bond) continue; iface = nm_setting_bond_get_interface_name (s_bond); if (!iface || strncmp (iface, "bond", 4) != 0 || !g_ascii_isdigit (iface[4])) continue; num = atoi (iface + 4); if (num > max_bond_num) max_bond_num = num; if (num == bond_num) bond_num = max_bond_num + 1; } g_slist_free (connections); my_iface = g_strdup_printf ("bond%d", bond_num); s_bond = nm_connection_get_setting_bond (connection); g_object_set (G_OBJECT (s_bond), NM_SETTING_BOND_INTERFACE_NAME, my_iface, NULL); g_free (my_iface); (*result_func) (connection, FALSE, NULL, user_data); }
static const char * get_connection_parent (NMDeviceFactory *factory, NMConnection *connection) { NMSettingIPTunnel *s_ip_tunnel; g_return_val_if_fail (nm_connection_is_type (connection, NM_SETTING_IP_TUNNEL_SETTING_NAME), NULL); s_ip_tunnel = nm_connection_get_setting_ip_tunnel (connection); g_assert (s_ip_tunnel); return nm_setting_ip_tunnel_get_parent (s_ip_tunnel); }
static const char * get_connection_parent (NMDeviceFactory *factory, NMConnection *connection) { NMSettingVxlan *s_vxlan; g_return_val_if_fail (nm_connection_is_type (connection, NM_SETTING_VXLAN_SETTING_NAME), NULL); s_vxlan = nm_connection_get_setting_vxlan (connection); g_assert (s_vxlan); return nm_setting_vxlan_get_parent (s_vxlan); }
static gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { if (!NM_DEVICE_CLASS (nm_device_olpc_mesh_parent_class)->connection_compatible (device, connection, error)) return FALSE; if (!nm_connection_is_type (connection, NM_SETTING_OLPC_MESH_SETTING_NAME)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The connection was not an OLPC Mesh connection.")); return FALSE; } return TRUE; }
static void connection_added (CEPageMaster *master, NMConnection *connection) { CEPageBond *self = CE_PAGE_BOND (master); CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self); if (nm_connection_is_type (connection, NM_SETTING_INFINIBAND_SETTING_NAME)) { priv->slave_arptype = ARPHRD_INFINIBAND; gtk_combo_box_set_active (priv->mode, MODE_ACTIVE_BACKUP); gtk_widget_set_sensitive (GTK_WIDGET (priv->mode), FALSE); } else { priv->slave_arptype = ARPHRD_ETHER; gtk_widget_set_sensitive (GTK_WIDGET (priv->mode), TRUE); } }
static NMConnection * get_best_auto_connection (NMModem *modem, GSList *connections, char **specific_object) { GSList *iter; for (iter = connections; iter; iter = g_slist_next (iter)) { NMConnection *connection = NM_CONNECTION (iter->data); if (nm_connection_is_type (connection, NM_SETTING_GSM_SETTING_NAME)) return connection; } return NULL; }
static gboolean check_connection_compatible (NMDevice *device, NMConnection *connection) { NMSettingTeam *s_team; if (!NM_DEVICE_CLASS (nm_device_team_parent_class)->check_connection_compatible (device, connection)) return FALSE; s_team = nm_connection_get_setting_team (connection); if (!s_team || !nm_connection_is_type (connection, NM_SETTING_TEAM_SETTING_NAME)) return FALSE; /* FIXME: match team properties like mode, etc? */ return TRUE; }
static gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { if (!NM_DEVICE_CLASS (nm_device_team_parent_class)->connection_compatible (device, connection, error)) return FALSE; if (!nm_connection_is_type (connection, NM_SETTING_TEAM_SETTING_NAME)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INVALID_CONNECTION, _("The connection was not a team connection.")); return FALSE; } /* FIXME: check slaves? */ return TRUE; }
static gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { if (!NM_DEVICE_CLASS (nm_device_bridge_parent_class)->connection_compatible (device, connection, error)) return FALSE; if (!nm_connection_is_type (connection, NM_SETTING_BRIDGE_SETTING_NAME)) { g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION, _("The connection was not a bridge connection.")); return FALSE; } /* FIXME: check ports? */ return TRUE; }
static gboolean check_connection_compatible (NMDevice *device, NMConnection *connection) { NMSettingBond *s_bond; if (!NM_DEVICE_CLASS (nm_device_bond_parent_class)->check_connection_compatible (device, connection)) return FALSE; s_bond = nm_connection_get_setting_bond (connection); if (!s_bond || !nm_connection_is_type (connection, NM_SETTING_BOND_SETTING_NAME)) return FALSE; /* FIXME: match bond properties like mode, etc? */ return TRUE; }
void bond_connection_new (GtkWindow *parent, const char *detail, NMClient *client, PageNewConnectionResultFunc result_func, gpointer user_data) { NMConnection *connection; NMSettingConnection *s_con; int bond_num = 0, num, i; const GPtrArray *connections; NMConnection *conn2; const char *iface; char *my_iface; connection = ce_page_new_connection (_("Bond connection %d"), NM_SETTING_BOND_SETTING_NAME, TRUE, client, user_data); nm_connection_add_setting (connection, nm_setting_bond_new ()); /* Find an available interface name */ connections = nm_client_get_connections (client); for (i = 0; i < connections->len; i++) { conn2 = connections->pdata[i]; if (!nm_connection_is_type (conn2, NM_SETTING_BOND_SETTING_NAME)) continue; iface = nm_connection_get_interface_name (conn2); if (!iface || strncmp (iface, "bond", 4) != 0 || !g_ascii_isdigit (iface[4])) continue; num = atoi (iface + 4); if (bond_num <= num) bond_num = num + 1; } s_con = nm_connection_get_setting_connection (connection); my_iface = g_strdup_printf ("bond%d", bond_num); g_object_set (G_OBJECT (s_con), NM_SETTING_CONNECTION_INTERFACE_NAME, my_iface, NULL); g_free (my_iface); (*result_func) (connection, FALSE, NULL, user_data); }