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