27e2d51abc
NetworkManager will reject scan requests, if it is currently scanning. That is very wrong. Even if NetworkManager wants to ratelimit scan requests or not scan at critical moments, it should never reject a request, but remember and start scanning as soon as it can. That should be fixed. But regardless, also nmcli can do better. If you issue $ nmcli device wifi list --rescan yes once, it works as expected. If you issue it again right after, the scan request of nmcli will be rejected. But nmcli cannot just merely complete and print the result. Instead, it will wait in the hope that a scan result will be present soon. But if the request was simply rejected, then the result will never come, and nmcli hangs for the 15 seconds timeout. Instead, repeatedly re-trigger scan requests, in the hope that as soon as possible we will be ready.
4768 lines
159 KiB
C
4768 lines
159 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (C) 2010 - 2018 Red Hat, Inc.
|
|
*/
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include "devices.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <readline/readline.h>
|
|
|
|
#include "nm-glib-aux/nm-secret-utils.h"
|
|
#include "common.h"
|
|
#include "connections.h"
|
|
#include "nm-client-utils.h"
|
|
#include "nm-secret-agent-simple.h"
|
|
#include "polkit-agent.h"
|
|
#include "utils.h"
|
|
|
|
/* define some prompts */
|
|
#define PROMPT_INTERFACE _("Interface: ")
|
|
#define PROMPT_INTERFACES _("Interface(s): ")
|
|
|
|
/*****************************************************************************/
|
|
|
|
static char *
|
|
ap_wpa_rsn_flags_to_string (NM80211ApSecurityFlags flags, NMMetaAccessorGetType get_type)
|
|
{
|
|
char *flags_str[16];
|
|
int i = 0;
|
|
|
|
if (flags & NM_802_11_AP_SEC_PAIR_WEP40)
|
|
flags_str[i++] = "pair_wpe40";
|
|
if (flags & NM_802_11_AP_SEC_PAIR_WEP104)
|
|
flags_str[i++] = "pair_wpe104";
|
|
if (flags & NM_802_11_AP_SEC_PAIR_TKIP)
|
|
flags_str[i++] = "pair_tkip";
|
|
if (flags & NM_802_11_AP_SEC_PAIR_CCMP)
|
|
flags_str[i++] = "pair_ccmp";
|
|
if (flags & NM_802_11_AP_SEC_GROUP_WEP40)
|
|
flags_str[i++] = "group_wpe40";
|
|
if (flags & NM_802_11_AP_SEC_GROUP_WEP104)
|
|
flags_str[i++] = "group_wpe104";
|
|
if (flags & NM_802_11_AP_SEC_GROUP_TKIP)
|
|
flags_str[i++] = "group_tkip";
|
|
if (flags & NM_802_11_AP_SEC_GROUP_CCMP)
|
|
flags_str[i++] = "group_ccmp";
|
|
if (flags & NM_802_11_AP_SEC_KEY_MGMT_PSK)
|
|
flags_str[i++] = "psk";
|
|
if (flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)
|
|
flags_str[i++] = "802.1X";
|
|
if (flags & NM_802_11_AP_SEC_KEY_MGMT_SAE)
|
|
flags_str[i++] = "sae";
|
|
if (flags & NM_802_11_AP_SEC_KEY_MGMT_OWE)
|
|
flags_str[i++] = "owe";
|
|
|
|
/* Make sure you grow flags_str when adding items here. */
|
|
nm_assert (i < G_N_ELEMENTS (flags_str));
|
|
|
|
if (i == 0) {
|
|
if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY)
|
|
return g_strdup (_("(none)"));
|
|
return g_strdup ("(none)");
|
|
}
|
|
|
|
flags_str[i] = NULL;
|
|
return g_strjoinv (" ", flags_str);
|
|
}
|
|
|
|
static NMMetaColor
|
|
wifi_signal_to_color (guint8 strength)
|
|
{
|
|
if (strength > 80)
|
|
return NM_META_COLOR_WIFI_SIGNAL_EXCELLENT;
|
|
else if (strength > 55)
|
|
return NM_META_COLOR_WIFI_SIGNAL_GOOD;
|
|
else if (strength > 30)
|
|
return NM_META_COLOR_WIFI_SIGNAL_FAIR;
|
|
else if (strength > 5)
|
|
return NM_META_COLOR_WIFI_SIGNAL_POOR;
|
|
else
|
|
return NM_META_COLOR_WIFI_SIGNAL_UNKNOWN;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gconstpointer
|
|
_metagen_device_status_get_fcn (NMC_META_GENERIC_INFO_GET_FCN_ARGS)
|
|
{
|
|
NMDevice *d = target;
|
|
NMActiveConnection *ac;
|
|
|
|
NMC_HANDLE_COLOR (nmc_device_state_to_color (nm_device_get_state (d)));
|
|
|
|
switch (info->info_type) {
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_DEVICE:
|
|
return nm_device_get_iface (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_TYPE:
|
|
return nm_device_get_type_description (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_STATE:
|
|
return nmc_meta_generic_get_str_i18n (nmc_device_state_to_string (nm_device_get_state (d)),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_IP4_CONNECTIVITY:
|
|
return nmc_meta_generic_get_str_i18n (nm_connectivity_to_string (nm_device_get_connectivity (d, AF_INET)),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_IP6_CONNECTIVITY:
|
|
return nmc_meta_generic_get_str_i18n (nm_connectivity_to_string (nm_device_get_connectivity (d, AF_INET6)),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_DBUS_PATH:
|
|
return nm_object_get_path (NM_OBJECT (d));
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_CONNECTION:
|
|
ac = nm_device_get_active_connection (d);
|
|
return ac ? nm_active_connection_get_id (ac) : NULL;
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_CON_UUID:
|
|
ac = nm_device_get_active_connection (d);
|
|
return ac ? nm_active_connection_get_uuid (ac) : NULL;
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_CON_PATH:
|
|
ac = nm_device_get_active_connection (d);
|
|
return ac ? nm_object_get_path (NM_OBJECT (ac)) : NULL;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
}
|
|
|
|
const NmcMetaGenericInfo *const metagen_device_status[_NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_NUM + 1] = {
|
|
#define _METAGEN_DEVICE_STATUS(type, name) \
|
|
[type] = NMC_META_GENERIC(name, .info_type = type, .get_fcn = _metagen_device_status_get_fcn)
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_DEVICE, "DEVICE"),
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_TYPE, "TYPE"),
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_STATE, "STATE"),
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_IP4_CONNECTIVITY, "IP4-CONNECTIVITY"),
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_IP6_CONNECTIVITY, "IP6-CONNECTIVITY"),
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_DBUS_PATH, "DBUS-PATH"),
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_CONNECTION, "CONNECTION"),
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_CON_UUID, "CON-UUID"),
|
|
_METAGEN_DEVICE_STATUS (NMC_GENERIC_INFO_TYPE_DEVICE_STATUS_CON_PATH, "CON-PATH"),
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gconstpointer
|
|
_metagen_device_detail_general_get_fcn (NMC_META_GENERIC_INFO_GET_FCN_ARGS)
|
|
{
|
|
NMDevice *d = target;
|
|
NMActiveConnection *ac;
|
|
NMDeviceState state;
|
|
NMDeviceStateReason state_reason;
|
|
NMConnectivityState connectivity;
|
|
const char *s;
|
|
|
|
NMC_HANDLE_COLOR (NM_META_COLOR_NONE);
|
|
|
|
switch (info->info_type) {
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_DEVICE:
|
|
return nm_device_get_iface (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_TYPE:
|
|
return nm_device_get_type_description (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_NM_TYPE:
|
|
return G_OBJECT_TYPE_NAME (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_DBUS_PATH:
|
|
return nm_object_get_path (NM_OBJECT (d));
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_VENDOR:
|
|
return nm_device_get_vendor (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_PRODUCT:
|
|
return nm_device_get_product (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_DRIVER:
|
|
s = nm_device_get_driver (d);
|
|
return s ?: nmc_meta_generic_get_str_i18n (N_("(unknown)"), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_DRIVER_VERSION:
|
|
return nm_device_get_driver_version (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_FIRMWARE_VERSION:
|
|
return nm_device_get_firmware_version (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_HWADDR:
|
|
s = nm_device_get_hw_address (d);
|
|
return s ?: nmc_meta_generic_get_str_i18n (N_("(unknown)"), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_MTU:
|
|
return (*out_to_free = g_strdup_printf ("%u", (guint) nm_device_get_mtu (d)));
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_STATE:
|
|
state = nm_device_get_state (d);
|
|
return (*out_to_free = nmc_meta_generic_get_enum_with_detail (NMC_META_GENERIC_GET_ENUM_TYPE_PARENTHESES,
|
|
state,
|
|
nmc_device_state_to_string (state),
|
|
get_type));
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_REASON:
|
|
state_reason = nm_device_get_state_reason (d);
|
|
return (*out_to_free = nmc_meta_generic_get_enum_with_detail (NMC_META_GENERIC_GET_ENUM_TYPE_PARENTHESES,
|
|
state_reason,
|
|
nmc_device_reason_to_string (state_reason),
|
|
get_type));
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_IP4_CONNECTIVITY:
|
|
connectivity = nm_device_get_connectivity (d, AF_INET);
|
|
return (*out_to_free = nmc_meta_generic_get_enum_with_detail (NMC_META_GENERIC_GET_ENUM_TYPE_PARENTHESES,
|
|
connectivity,
|
|
nm_connectivity_to_string (connectivity),
|
|
get_type));
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_IP6_CONNECTIVITY:
|
|
connectivity = nm_device_get_connectivity (d, AF_INET6);
|
|
return (*out_to_free = nmc_meta_generic_get_enum_with_detail (NMC_META_GENERIC_GET_ENUM_TYPE_PARENTHESES,
|
|
connectivity,
|
|
nm_connectivity_to_string (connectivity),
|
|
get_type));
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_UDI:
|
|
return nm_device_get_udi (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_IP_IFACE:
|
|
return nm_device_get_ip_iface (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_IS_SOFTWARE:
|
|
return nmc_meta_generic_get_bool (nm_device_is_software (d), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_NM_MANAGED:
|
|
return nmc_meta_generic_get_bool (nm_device_get_managed (d), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_AUTOCONNECT:
|
|
return nmc_meta_generic_get_bool (nm_device_get_autoconnect (d), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_FIRMWARE_MISSING:
|
|
return nmc_meta_generic_get_bool (nm_device_get_firmware_missing (d), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_NM_PLUGIN_MISSING:
|
|
return nmc_meta_generic_get_bool (nm_device_get_nm_plugin_missing (d), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_PHYS_PORT_ID:
|
|
return nm_device_get_physical_port_id (d);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_CONNECTION:
|
|
ac = nm_device_get_active_connection (d);
|
|
return ac ? nm_active_connection_get_id (ac) : NULL;
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_CON_UUID:
|
|
ac = nm_device_get_active_connection (d);
|
|
return ac ? nm_active_connection_get_uuid (ac) : NULL;
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_CON_PATH:
|
|
ac = nm_device_get_active_connection (d);
|
|
return ac ? nm_object_get_path (NM_OBJECT (ac)) : NULL;
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_METERED:
|
|
return nmc_meta_generic_get_str_i18n (nmc_device_metered_to_string (nm_device_get_metered (d)),
|
|
get_type);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
}
|
|
|
|
const NmcMetaGenericInfo *const metagen_device_detail_general[_NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_NUM + 1] = {
|
|
#define _METAGEN_DEVICE_DETAIL_GENERAL(type, name) \
|
|
[type] = NMC_META_GENERIC(name, .info_type = type, .get_fcn = _metagen_device_detail_general_get_fcn)
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_DEVICE, "DEVICE"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_TYPE, "TYPE"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_NM_TYPE, "NM-TYPE"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_DBUS_PATH, "DBUS-PATH"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_VENDOR, "VENDOR"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_PRODUCT, "PRODUCT"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_DRIVER, "DRIVER"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_DRIVER_VERSION, "DRIVER-VERSION"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_FIRMWARE_VERSION, "FIRMWARE-VERSION"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_HWADDR, "HWADDR"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_MTU, "MTU"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_STATE, "STATE"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_REASON, "REASON"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_IP4_CONNECTIVITY, "IP4-CONNECTIVITY"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_IP6_CONNECTIVITY, "IP6-CONNECTIVITY"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_UDI, "UDI"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_IP_IFACE, "IP-IFACE"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_IS_SOFTWARE, "IS-SOFTWARE"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_NM_MANAGED, "NM-MANAGED"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_AUTOCONNECT, "AUTOCONNECT"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_FIRMWARE_MISSING, "FIRMWARE-MISSING"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_NM_PLUGIN_MISSING, "NM-PLUGIN-MISSING"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_PHYS_PORT_ID, "PHYS-PORT-ID"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_CONNECTION, "CONNECTION"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_CON_UUID, "CON-UUID"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_CON_PATH, "CON-PATH"),
|
|
_METAGEN_DEVICE_DETAIL_GENERAL (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_GENERAL_METERED, "METERED"),
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
static NMRemoteConnection **
|
|
_device_get_available_connections (NMDevice *d, guint *out_len)
|
|
{
|
|
NMRemoteConnection **avail_cons;
|
|
const GPtrArray *avail_cons_arr;
|
|
|
|
avail_cons_arr = nm_device_get_available_connections (d);
|
|
if (!avail_cons_arr || avail_cons_arr->len == 0) {
|
|
*out_len = 0;
|
|
return NULL;
|
|
}
|
|
|
|
avail_cons = (NMRemoteConnection **) nmc_objects_sort_by_path ((const NMObject *const*) avail_cons_arr->pdata,
|
|
avail_cons_arr->len);
|
|
nm_assert (avail_cons_arr->len == NM_PTRARRAY_LEN (avail_cons));
|
|
*out_len = avail_cons_arr->len;
|
|
return avail_cons;
|
|
}
|
|
|
|
static gconstpointer
|
|
_metagen_device_detail_connections_get_fcn (NMC_META_GENERIC_INFO_GET_FCN_ARGS)
|
|
{
|
|
NMDevice *d = target;
|
|
gs_free NMRemoteConnection **avail_cons = NULL;
|
|
guint avail_cons_len;
|
|
guint i, j;
|
|
char **arr = NULL;
|
|
GString *str;
|
|
gboolean had_prefix, has_prefix;
|
|
|
|
NMC_HANDLE_COLOR (NM_META_COLOR_NONE);
|
|
|
|
switch (info->info_type) {
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CONNECTIONS_AVAILABLE_CONNECTIONS:
|
|
if (!NM_FLAGS_HAS (get_flags, NM_META_ACCESSOR_GET_FLAGS_ACCEPT_STRV))
|
|
return NULL;
|
|
|
|
avail_cons = _device_get_available_connections (d, &avail_cons_len);
|
|
if (avail_cons_len == 0)
|
|
goto arr_out;
|
|
|
|
arr = g_new (char *, avail_cons_len + 1);
|
|
j = 0;
|
|
for (i = 0; i < avail_cons_len; i++) {
|
|
NMRemoteConnection *ac = avail_cons[i];
|
|
const char *ac_id = nm_connection_get_id (NM_CONNECTION (ac));
|
|
const char *ac_uuid = nm_connection_get_uuid (NM_CONNECTION (ac));
|
|
|
|
if (!ac_id || !ac_uuid) {
|
|
const char *ac_path = nm_connection_get_path (NM_CONNECTION (ac));
|
|
|
|
if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY) {
|
|
arr[j++] = ac_path
|
|
? g_strdup_printf (_("<invisible> | %s"), ac_path)
|
|
: g_strdup (_("<invisible>"));
|
|
} else {
|
|
arr[j++] = ac_path
|
|
? g_strdup_printf ("<invisible> | %s", ac_path)
|
|
: g_strdup ("<invisible>");
|
|
}
|
|
} else
|
|
arr[j++] = g_strdup_printf ("%s | %s", ac_uuid, ac_id);
|
|
}
|
|
arr[j] = NULL;
|
|
goto arr_out;
|
|
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CONNECTIONS_AVAILABLE_CONNECTION_PATHS:
|
|
|
|
avail_cons = _device_get_available_connections (d, &avail_cons_len);
|
|
if (avail_cons_len == 0)
|
|
return NULL;
|
|
|
|
str = g_string_new (NULL);
|
|
|
|
had_prefix = FALSE;
|
|
for (i = 0; i < avail_cons_len; i++) {
|
|
NMRemoteConnection *ac = avail_cons[i];
|
|
const char *p = nm_connection_get_path (NM_CONNECTION (ac));
|
|
|
|
if (!p)
|
|
continue;
|
|
|
|
has_prefix = g_str_has_prefix (p, NM_DBUS_PATH_SETTINGS_CONNECTION"/")
|
|
&& p[NM_STRLEN (NM_DBUS_PATH_SETTINGS_CONNECTION"/")];
|
|
|
|
if (str->len > 0) {
|
|
if ( had_prefix
|
|
&& !has_prefix)
|
|
g_string_append_c (str, '}');
|
|
g_string_append_c (str, ',');
|
|
}
|
|
|
|
if (!has_prefix)
|
|
g_string_append (str, p);
|
|
else {
|
|
if (!had_prefix)
|
|
g_string_printf (str, "%s/{", NM_DBUS_PATH_SETTINGS_CONNECTION);
|
|
g_string_append (str, &p[NM_STRLEN (NM_DBUS_PATH_SETTINGS_CONNECTION"/")]);
|
|
}
|
|
had_prefix = has_prefix;
|
|
}
|
|
if (had_prefix)
|
|
g_string_append_c (str, '}');
|
|
|
|
return (*out_to_free = g_string_free (str, FALSE));
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
|
|
arr_out:
|
|
NM_SET_OUT (out_is_default, !arr || !arr[0]);
|
|
*out_flags |= NM_META_ACCESSOR_GET_OUT_FLAGS_STRV;
|
|
*out_to_free = arr;
|
|
return arr;
|
|
}
|
|
|
|
const NmcMetaGenericInfo *const metagen_device_detail_connections[_NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CONNECTIONS_NUM + 1] = {
|
|
#define _METAGEN_DEVICE_DETAIL_CONNECTIONS(type, name) \
|
|
[type] = NMC_META_GENERIC(name, .info_type = type, .get_fcn = _metagen_device_detail_connections_get_fcn)
|
|
_METAGEN_DEVICE_DETAIL_CONNECTIONS (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CONNECTIONS_AVAILABLE_CONNECTION_PATHS, "AVAILABLE-CONNECTION-PATHS"),
|
|
_METAGEN_DEVICE_DETAIL_CONNECTIONS (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CONNECTIONS_AVAILABLE_CONNECTIONS, "AVAILABLE-CONNECTIONS"),
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gconstpointer
|
|
_metagen_device_detail_capabilities_get_fcn (NMC_META_GENERIC_INFO_GET_FCN_ARGS)
|
|
{
|
|
NMDevice *d = target;
|
|
NMDeviceCapabilities caps;
|
|
guint32 speed;
|
|
|
|
NMC_HANDLE_COLOR (NM_META_COLOR_NONE);
|
|
|
|
caps = nm_device_get_capabilities (d);
|
|
|
|
switch (info->info_type) {
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_CARRIER_DETECT:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (caps, NM_DEVICE_CAP_CARRIER_DETECT), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_SPEED:
|
|
speed = 0;
|
|
if (NM_IS_DEVICE_ETHERNET (d)) {
|
|
/* Speed in Mb/s */
|
|
speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (d));
|
|
} else if (NM_IS_DEVICE_WIFI (d)) {
|
|
/* Speed in b/s */
|
|
speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (d));
|
|
speed /= 1000;
|
|
}
|
|
|
|
if (speed) {
|
|
if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY)
|
|
return (*out_to_free = g_strdup_printf (_("%u Mb/s"), (guint) speed));
|
|
return (*out_to_free = g_strdup_printf ("%u Mb/s", (guint) speed));
|
|
}
|
|
return nmc_meta_generic_get_str_i18n (N_("unknown"), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_IS_SOFTWARE:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (caps, NM_DEVICE_CAP_IS_SOFTWARE), get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_SRIOV:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (caps, NM_DEVICE_CAP_SRIOV), get_type);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
}
|
|
|
|
const NmcMetaGenericInfo *const metagen_device_detail_capabilities[_NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_NUM + 1] = {
|
|
#define _METAGEN_DEVICE_DETAIL_CAPABILITIES(type, name) \
|
|
[type] = NMC_META_GENERIC(name, .info_type = type, .get_fcn = _metagen_device_detail_capabilities_get_fcn)
|
|
_METAGEN_DEVICE_DETAIL_CAPABILITIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_CARRIER_DETECT, "CARRIER-DETECT"),
|
|
_METAGEN_DEVICE_DETAIL_CAPABILITIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_SPEED, "SPEED"),
|
|
_METAGEN_DEVICE_DETAIL_CAPABILITIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_IS_SOFTWARE, "IS-SOFTWARE"),
|
|
_METAGEN_DEVICE_DETAIL_CAPABILITIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_CAPABILITIES_SRIOV, "SRIOV"),
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gconstpointer
|
|
_metagen_device_detail_wired_properties_get_fcn (NMC_META_GENERIC_INFO_GET_FCN_ARGS)
|
|
{
|
|
NMDevice *d = target;
|
|
|
|
NMC_HANDLE_COLOR (NM_META_COLOR_NONE);
|
|
|
|
switch (info->info_type) {
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIRED_PROPERTIES_CARRIER:
|
|
return nmc_meta_generic_get_bool_onoff (nm_device_ethernet_get_carrier (NM_DEVICE_ETHERNET (d)),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIRED_PROPERTIES_S390_SUBCHANNELS:
|
|
if (!NM_FLAGS_HAS (get_flags, NM_META_ACCESSOR_GET_FLAGS_ACCEPT_STRV))
|
|
return NULL;
|
|
*out_flags |= NM_META_ACCESSOR_GET_OUT_FLAGS_STRV;
|
|
return nm_device_ethernet_get_s390_subchannels (NM_DEVICE_ETHERNET (d));
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
}
|
|
|
|
const NmcMetaGenericInfo *const metagen_device_detail_wired_properties[_NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIRED_PROPERTIES_NUM + 1] = {
|
|
#define _METAGEN_DEVICE_DETAIL_WIRED_PROPERTIES(type, name) \
|
|
[type] = NMC_META_GENERIC(name, .info_type = type, .get_fcn = _metagen_device_detail_wired_properties_get_fcn)
|
|
_METAGEN_DEVICE_DETAIL_WIRED_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIRED_PROPERTIES_CARRIER, "CARRIER"),
|
|
_METAGEN_DEVICE_DETAIL_WIRED_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIRED_PROPERTIES_S390_SUBCHANNELS, "S390-SUBCHANNELS"),
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gconstpointer
|
|
_metagen_device_detail_wifi_properties_get_fcn (NMC_META_GENERIC_INFO_GET_FCN_ARGS)
|
|
{
|
|
NMDevice *d = target;
|
|
NMDeviceWifiCapabilities wcaps;
|
|
|
|
NMC_HANDLE_COLOR (NM_META_COLOR_NONE);
|
|
|
|
wcaps = nm_device_wifi_get_capabilities (NM_DEVICE_WIFI (d));
|
|
|
|
switch (info->info_type) {
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_WEP:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_ANY (wcaps, NM_WIFI_DEVICE_CAP_CIPHER_WEP40 | NM_WIFI_DEVICE_CAP_CIPHER_WEP104),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_WPA:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_WPA),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_WPA2:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_RSN),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_TKIP:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_CIPHER_TKIP),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_CCMP:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_CIPHER_CCMP),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_AP:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_AP),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_ADHOC:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_ADHOC),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_2GHZ:
|
|
return nmc_meta_generic_get_str_i18n ( NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_FREQ_VALID)
|
|
? ( NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_FREQ_2GHZ)
|
|
? N_("yes")
|
|
: N_("no"))
|
|
: N_("unknown"),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_5GHZ:
|
|
return nmc_meta_generic_get_str_i18n ( NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_FREQ_VALID)
|
|
? ( NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_FREQ_5GHZ)
|
|
? N_("yes")
|
|
: N_("no"))
|
|
: N_("unknown"),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_MESH:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_MESH),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_IBSS_RSN:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (wcaps, NM_WIFI_DEVICE_CAP_IBSS_RSN),
|
|
get_type);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
}
|
|
|
|
const NmcMetaGenericInfo *const metagen_device_detail_wifi_properties[_NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_NUM + 1] = {
|
|
#define _METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES(type, name) \
|
|
[type] = NMC_META_GENERIC(name, .info_type = type, .get_fcn = _metagen_device_detail_wifi_properties_get_fcn)
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_WEP, "WEP"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_WPA, "WPA"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_WPA2, "WPA2"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_TKIP, "TKIP"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_CCMP, "CCMP"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_AP, "AP"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_ADHOC, "ADHOC"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_2GHZ, "2GHZ"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_5GHZ, "5GHZ"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_MESH, "MESH"),
|
|
_METAGEN_DEVICE_DETAIL_WIFI_PROPERTIES (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_WIFI_PROPERTIES_IBSS_RSN, "IBSS-RSN"),
|
|
};
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gconstpointer
|
|
_metagen_device_detail_interface_flags_get_fcn (NMC_META_GENERIC_INFO_GET_FCN_ARGS)
|
|
{
|
|
NMDevice *d = target;
|
|
NMDeviceInterfaceFlags flags;
|
|
|
|
NMC_HANDLE_COLOR (NM_META_COLOR_NONE);
|
|
|
|
flags = nm_device_get_interface_flags (d);
|
|
|
|
switch (info->info_type) {
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_INTERFACE_FLAGS_UP:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (flags, NM_DEVICE_INTERFACE_FLAG_UP),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_INTERFACE_FLAGS_LOWER_UP:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (flags, NM_DEVICE_INTERFACE_FLAG_LOWER_UP),
|
|
get_type);
|
|
case NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_INTERFACE_FLAGS_CARRIER:
|
|
return nmc_meta_generic_get_bool (NM_FLAGS_HAS (flags, NM_DEVICE_INTERFACE_FLAG_CARRIER),
|
|
get_type);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_return_val_if_reached (NULL);
|
|
}
|
|
|
|
const NmcMetaGenericInfo *const metagen_device_detail_interface_flags[_NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_INTERFACE_FLAGS_NUM + 1] = {
|
|
#define _METAGEN_DEVICE_DETAIL_INTERFACE_FLAGS(type, name) \
|
|
[type] = NMC_META_GENERIC(name, .info_type = type, .get_fcn = _metagen_device_detail_interface_flags_get_fcn)
|
|
_METAGEN_DEVICE_DETAIL_INTERFACE_FLAGS (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_INTERFACE_FLAGS_UP, "UP"),
|
|
_METAGEN_DEVICE_DETAIL_INTERFACE_FLAGS (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_INTERFACE_FLAGS_LOWER_UP, "LOWER-UP"),
|
|
_METAGEN_DEVICE_DETAIL_INTERFACE_FLAGS (NMC_GENERIC_INFO_TYPE_DEVICE_DETAIL_INTERFACE_FLAGS_CARRIER, "CARRIER"),
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
const NmcMetaGenericInfo *const metagen_device_detail_wimax_properties[] = {
|
|
NMC_META_GENERIC ("CTR-FREQ"),
|
|
NMC_META_GENERIC ("RSSI"),
|
|
NMC_META_GENERIC ("CINR"),
|
|
NMC_META_GENERIC ("TX-POW"),
|
|
NMC_META_GENERIC ("BSID"),
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
|
|
const NmcMetaGenericInfo *const nmc_fields_dev_wifi_list[] = {
|
|
NMC_META_GENERIC ("NAME"), /* 0 */
|
|
NMC_META_GENERIC ("SSID"), /* 1 */
|
|
NMC_META_GENERIC ("SSID-HEX"), /* 2 */
|
|
NMC_META_GENERIC ("BSSID"), /* 3 */
|
|
NMC_META_GENERIC ("MODE"), /* 4 */
|
|
NMC_META_GENERIC ("CHAN"), /* 5 */
|
|
NMC_META_GENERIC ("FREQ"), /* 6 */
|
|
NMC_META_GENERIC ("RATE"), /* 7 */
|
|
NMC_META_GENERIC ("SIGNAL"), /* 8 */
|
|
NMC_META_GENERIC ("BARS"), /* 9 */
|
|
NMC_META_GENERIC ("SECURITY"), /* 10 */
|
|
NMC_META_GENERIC ("WPA-FLAGS"), /* 11 */
|
|
NMC_META_GENERIC ("RSN-FLAGS"), /* 12 */
|
|
NMC_META_GENERIC ("DEVICE"), /* 13 */
|
|
NMC_META_GENERIC ("ACTIVE"), /* 14 */
|
|
NMC_META_GENERIC ("IN-USE"), /* 15 */
|
|
NMC_META_GENERIC ("DBUS-PATH"), /* 16 */
|
|
NULL,
|
|
};
|
|
#define NMC_FIELDS_DEV_WIFI_LIST_COMMON "IN-USE,BSSID,SSID,MODE,CHAN,RATE,SIGNAL,BARS,SECURITY"
|
|
#define NMC_FIELDS_DEV_WIFI_LIST_FOR_DEV_LIST "NAME,"NMC_FIELDS_DEV_WIFI_LIST_COMMON
|
|
|
|
const NmcMetaGenericInfo *const nmc_fields_dev_wimax_list[] = {
|
|
NMC_META_GENERIC ("NAME"), /* 0 */
|
|
NMC_META_GENERIC ("NSP"), /* 1 */
|
|
NMC_META_GENERIC ("SIGNAL"), /* 2 */
|
|
NMC_META_GENERIC ("TYPE"), /* 3 */
|
|
NMC_META_GENERIC ("DEVICE"), /* 4 */
|
|
NMC_META_GENERIC ("ACTIVE"), /* 5 */
|
|
NMC_META_GENERIC ("DBUS-PATH"), /* 6 */
|
|
NULL,
|
|
};
|
|
#define NMC_FIELDS_DEV_WIMAX_LIST_COMMON "NSP,SIGNAL,TYPE,DEVICE,ACTIVE"
|
|
#define NMC_FIELDS_DEV_WIMAX_LIST_FOR_DEV_LIST "NAME,"NMC_FIELDS_DEV_WIMAX_LIST_COMMON
|
|
|
|
const NmcMetaGenericInfo *const nmc_fields_dev_show_master_prop[] = {
|
|
NMC_META_GENERIC ("NAME"), /* 0 */
|
|
NMC_META_GENERIC ("SLAVES"), /* 1 */
|
|
NULL,
|
|
};
|
|
#define NMC_FIELDS_DEV_SHOW_MASTER_PROP_COMMON "NAME,SLAVES"
|
|
|
|
const NmcMetaGenericInfo *const nmc_fields_dev_show_team_prop[] = {
|
|
NMC_META_GENERIC ("NAME"), /* 0 */
|
|
NMC_META_GENERIC ("SLAVES"), /* 1 */
|
|
NMC_META_GENERIC ("CONFIG"), /* 2 */
|
|
NULL,
|
|
};
|
|
#define NMC_FIELDS_DEV_SHOW_TEAM_PROP_COMMON "NAME,SLAVES,CONFIG"
|
|
|
|
const NmcMetaGenericInfo *const nmc_fields_dev_show_vlan_prop[] = {
|
|
NMC_META_GENERIC ("NAME"), /* 0 */
|
|
NMC_META_GENERIC ("PARENT"), /* 1 */
|
|
NMC_META_GENERIC ("ID"), /* 2 */
|
|
NULL,
|
|
};
|
|
#define NMC_FIELDS_DEV_SHOW_VLAN_PROP_COMMON "NAME,PARENT,ID"
|
|
|
|
const NmcMetaGenericInfo *const nmc_fields_dev_show_bluetooth[] = {
|
|
NMC_META_GENERIC ("NAME"), /* 0 */
|
|
NMC_META_GENERIC ("CAPABILITIES"), /* 1 */
|
|
NULL,
|
|
};
|
|
#define NMC_FIELDS_DEV_SHOW_BLUETOOTH_COMMON "NAME,CAPABILITIES"
|
|
|
|
/* Available sections for 'device show' */
|
|
const NmcMetaGenericInfo *const nmc_fields_dev_show_sections[] = {
|
|
NMC_META_GENERIC_WITH_NESTED ("GENERAL", metagen_device_detail_general), /* 0 */
|
|
NMC_META_GENERIC_WITH_NESTED ("CAPABILITIES", metagen_device_detail_capabilities), /* 1 */
|
|
NMC_META_GENERIC_WITH_NESTED ("INTERFACE-FLAGS", metagen_device_detail_interface_flags), /* 2 */
|
|
NMC_META_GENERIC_WITH_NESTED ("WIFI-PROPERTIES", metagen_device_detail_wifi_properties), /* 3 */
|
|
NMC_META_GENERIC_WITH_NESTED ("AP", nmc_fields_dev_wifi_list + 1), /* 4 */
|
|
NMC_META_GENERIC_WITH_NESTED ("WIRED-PROPERTIES", metagen_device_detail_wired_properties), /* 5 */
|
|
NMC_META_GENERIC_WITH_NESTED ("WIMAX-PROPERTIES", metagen_device_detail_wimax_properties), /* 6 */
|
|
NMC_META_GENERIC_WITH_NESTED ("NSP", nmc_fields_dev_wimax_list + 1), /* 7 */
|
|
NMC_META_GENERIC_WITH_NESTED ("IP4", metagen_ip4_config), /* 8 */
|
|
NMC_META_GENERIC_WITH_NESTED ("DHCP4", metagen_dhcp_config), /* 9 */
|
|
NMC_META_GENERIC_WITH_NESTED ("IP6", metagen_ip6_config), /* 10 */
|
|
NMC_META_GENERIC_WITH_NESTED ("DHCP6", metagen_dhcp_config), /* 11 */
|
|
NMC_META_GENERIC_WITH_NESTED ("BOND", nmc_fields_dev_show_master_prop + 1), /* 12 */
|
|
NMC_META_GENERIC_WITH_NESTED ("TEAM", nmc_fields_dev_show_team_prop + 1), /* 13 */
|
|
NMC_META_GENERIC_WITH_NESTED ("BRIDGE", nmc_fields_dev_show_master_prop + 1), /* 14 */
|
|
NMC_META_GENERIC_WITH_NESTED ("VLAN", nmc_fields_dev_show_vlan_prop + 1), /* 15 */
|
|
NMC_META_GENERIC_WITH_NESTED ("BLUETOOTH", nmc_fields_dev_show_bluetooth + 1), /* 16 */
|
|
NMC_META_GENERIC_WITH_NESTED ("CONNECTIONS", metagen_device_detail_connections), /* 17 */
|
|
NULL,
|
|
};
|
|
#define NMC_FIELDS_DEV_SHOW_SECTIONS_COMMON "GENERAL.DEVICE,GENERAL.TYPE,GENERAL.HWADDR,GENERAL.MTU,GENERAL.STATE,"\
|
|
"GENERAL.CONNECTION,GENERAL.CON-PATH,WIRED-PROPERTIES,IP4,IP6"
|
|
|
|
const NmcMetaGenericInfo *const nmc_fields_dev_lldp_list[] = {
|
|
NMC_META_GENERIC ("NAME"), /* 0 */
|
|
NMC_META_GENERIC ("DEVICE"), /* 1 */
|
|
NMC_META_GENERIC ("CHASSIS-ID"), /* 2 */
|
|
NMC_META_GENERIC ("PORT-ID"), /* 3 */
|
|
NMC_META_GENERIC ("PORT-DESCRIPTION"), /* 4 */
|
|
NMC_META_GENERIC ("SYSTEM-NAME"), /* 5 */
|
|
NMC_META_GENERIC ("SYSTEM-DESCRIPTION"), /* 6 */
|
|
NMC_META_GENERIC ("SYSTEM-CAPABILITIES"), /* 7 */
|
|
NMC_META_GENERIC ("IEEE-802-1-PVID"), /* 8 */
|
|
NMC_META_GENERIC ("IEEE-802-1-PPVID"), /* 9 */
|
|
NMC_META_GENERIC ("IEEE-802-1-PPVID-FLAGS"), /* 10 */
|
|
NMC_META_GENERIC ("IEEE-802-1-VID"), /* 11 */
|
|
NMC_META_GENERIC ("IEEE-802-1-VLAN-NAME"), /* 12 */
|
|
NMC_META_GENERIC ("DESTINATION"), /* 13 */
|
|
NMC_META_GENERIC ("CHASSIS-ID-TYPE"), /* 14 */
|
|
NMC_META_GENERIC ("PORT-ID-TYPE"), /* 15 */
|
|
NULL,
|
|
};
|
|
#define NMC_FIELDS_DEV_LLDP_LIST_COMMON "DEVICE,CHASSIS-ID,PORT-ID,PORT-DESCRIPTION,SYSTEM-NAME,SYSTEM-DESCRIPTION," \
|
|
"SYSTEM-CAPABILITIES"
|
|
|
|
static guint progress_id = 0; /* ID of event source for displaying progress */
|
|
|
|
static void
|
|
usage (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device { COMMAND | help }\n\n"
|
|
"COMMAND := { status | show | set | connect | reapply | modify | disconnect | delete | monitor | wifi | lldp }\n\n"
|
|
" status\n\n"
|
|
" show [<ifname>]\n\n"
|
|
" set [ifname] <ifname> [autoconnect yes|no] [managed yes|no]\n\n"
|
|
" connect <ifname>\n\n"
|
|
" reapply <ifname>\n\n"
|
|
" modify <ifname> ([+|-]<setting>.<property> <value>)+\n\n"
|
|
" disconnect <ifname> ...\n\n"
|
|
" delete <ifname> ...\n\n"
|
|
" monitor <ifname> ...\n\n"
|
|
" wifi [list [ifname <ifname>] [bssid <BSSID>] [--rescan yes|no|auto]]\n\n"
|
|
" wifi connect <(B)SSID> [password <password>] [wep-key-type key|phrase] [ifname <ifname>]\n"
|
|
" [bssid <BSSID>] [name <name>] [private yes|no] [hidden yes|no]\n\n"
|
|
" wifi hotspot [ifname <ifname>] [con-name <name>] [ssid <SSID>] [band a|bg] [channel <channel>] [password <password>]\n\n"
|
|
" wifi rescan [ifname <ifname>] [[ssid <SSID to scan>] ...]\n\n"
|
|
" wifi show-password [ifname <ifname>]\n\n"
|
|
" lldp [list [ifname <ifname>]]\n\n"
|
|
));
|
|
}
|
|
|
|
static void
|
|
usage_device_status (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device status { help }\n"
|
|
"\n"
|
|
"Show status for all devices.\n"
|
|
"By default, the following columns are shown:\n"
|
|
" DEVICE - interface name\n"
|
|
" TYPE - device type\n"
|
|
" STATE - device state\n"
|
|
" CONNECTION - connection activated on device (if any)\n"
|
|
"Displayed columns can be changed using '--fields' global option. 'status' is\n"
|
|
"the default command, which means 'nmcli device' calls 'nmcli device status'.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_show (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device show { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"ARGUMENTS := [<ifname>]\n"
|
|
"\n"
|
|
"Show details of device(s).\n"
|
|
"The command lists details for all devices, or for a given device.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_connect (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device connect { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"ARGUMENTS := <ifname>\n"
|
|
"\n"
|
|
"Connect the device.\n"
|
|
"NetworkManager will try to find a suitable connection that will be activated.\n"
|
|
"It will also consider connections that are not set to auto-connect.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_reapply (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device reapply { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"ARGUMENTS := <ifname>\n"
|
|
"\n"
|
|
"Attempts to update device with changes to the currently active connection\n"
|
|
"made since it was last applied.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_modify (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device modify { ARGUMENTS | --help }\n"
|
|
"\n"
|
|
"ARGUMENTS := <ifname> ([+|-]<setting>.<property> <value>)+\n"
|
|
"\n"
|
|
"Modify one or more properties currently active on the device without modifying\n"
|
|
"the connection profile. The changes have immediate effect. For multi-valued\n"
|
|
"properties you can use optional '+' or '-' prefix to the property name.\n"
|
|
"The '+' sign allows appending items instead of overwriting the whole value.\n"
|
|
"The '-' sign allows removing selected items instead of the whole value.\n"
|
|
"\n"
|
|
"Examples:\n"
|
|
"nmcli dev mod em1 ipv4.method manual ipv4.addr \"192.168.1.2/24, 10.10.1.5/8\"\n"
|
|
"nmcli dev mod em1 +ipv4.dns 8.8.4.4\n"
|
|
"nmcli dev mod em1 -ipv4.dns 1\n"
|
|
"nmcli dev mod em1 -ipv6.addr \"abbe::cafe/56\"\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_disconnect (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device disconnect { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"ARGUMENTS := <ifname> ...\n"
|
|
"\n"
|
|
"Disconnect devices.\n"
|
|
"The command disconnects the device and prevents it from auto-activating\n"
|
|
"further connections without user/manual intervention.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_delete (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device delete { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"ARGUMENTS := <ifname> ...\n"
|
|
"\n"
|
|
"Delete the software devices.\n"
|
|
"The command removes the interfaces. It only works for software devices\n"
|
|
"(like bonds, bridges, etc.). Hardware devices cannot be deleted by the\n"
|
|
"command.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_set (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device set { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"ARGUMENTS := DEVICE { PROPERTY [ PROPERTY ... ] }\n"
|
|
"DEVICE := [ifname] <ifname> \n"
|
|
"PROPERTY := { autoconnect { yes | no } |\n"
|
|
" { managed { yes | no }\n"
|
|
"\n"
|
|
"Modify device properties.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_monitor (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device monitor { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"ARGUMENTS := [<ifname>] ...\n"
|
|
"\n"
|
|
"Monitor device activity.\n"
|
|
"This command prints a line whenever the specified devices change state.\n"
|
|
"Monitors all devices in case no interface is specified.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_wifi (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device wifi { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"Perform operation on Wi-Fi devices.\n"
|
|
"\n"
|
|
"ARGUMENTS := [list [ifname <ifname>] [bssid <BSSID>] [--rescan yes|no|auto]]\n"
|
|
"\n"
|
|
"List available Wi-Fi access points. The 'ifname' and 'bssid' options can be\n"
|
|
"used to list APs for a particular interface, or with a specific BSSID. The\n"
|
|
"--rescan flag tells whether a new Wi-Fi scan should be triggered.\n"
|
|
"\n"
|
|
"ARGUMENTS := connect <(B)SSID> [password <password>] [wep-key-type key|phrase] [ifname <ifname>]\n"
|
|
" [bssid <BSSID>] [name <name>] [private yes|no] [hidden yes|no]\n"
|
|
"\n"
|
|
"Connect to a Wi-Fi network specified by SSID or BSSID. The command finds a\n"
|
|
"matching connection or creates one and then activates it on a device. This\n"
|
|
"is a command-line counterpart of clicking an SSID in a GUI client. If a\n"
|
|
"connection for the network already exists, it is possible to bring up the\n"
|
|
"existing profile as follows: nmcli con up id <name>. Note that only open,\n"
|
|
"WEP and WPA-PSK networks are supported if no previous connection exists.\n"
|
|
"It is also assumed that IP configuration is obtained via DHCP.\n"
|
|
"\n"
|
|
"ARGUMENTS := hotspot [ifname <ifname>] [con-name <name>] [ssid <SSID>]\n"
|
|
" [band a|bg] [channel <channel>] [password <password>]\n"
|
|
"\n"
|
|
"Create a Wi-Fi hotspot. Use 'connection down' or 'device disconnect'\n"
|
|
"to stop the hotspot.\n"
|
|
"Parameters of the hotspot can be influenced by the optional parameters:\n"
|
|
"ifname - Wi-Fi device to use\n"
|
|
"con-name - name of the created hotspot connection profile\n"
|
|
"ssid - SSID of the hotspot\n"
|
|
"band - Wi-Fi band to use\n"
|
|
"channel - Wi-Fi channel to use\n"
|
|
"password - password to use for the hotspot\n"
|
|
"\n"
|
|
"ARGUMENTS := rescan [ifname <ifname>] [[ssid <SSID to scan>] ...]\n"
|
|
"\n"
|
|
"Request that NetworkManager immediately re-scan for available access points.\n"
|
|
"NetworkManager scans Wi-Fi networks periodically, but in some cases it might\n"
|
|
"be useful to start scanning manually. 'ssid' allows scanning for a specific\n"
|
|
"SSID, which is useful for APs with hidden SSIDs. More 'ssid' parameters can be\n"
|
|
"given. Note that this command does not show the APs,\n"
|
|
"use 'nmcli device wifi list' for that.\n\n"));
|
|
}
|
|
|
|
static void
|
|
usage_device_lldp (void)
|
|
{
|
|
g_printerr (_("Usage: nmcli device lldp { ARGUMENTS | help }\n"
|
|
"\n"
|
|
"ARGUMENTS := [list [ifname <ifname>]]\n"
|
|
"\n"
|
|
"List neighboring devices discovered through LLDP. The 'ifname' option can be\n"
|
|
"used to list neighbors for a particular interface.\n\n"));
|
|
}
|
|
|
|
static void
|
|
quit (void)
|
|
{
|
|
if (nm_clear_g_source (&progress_id))
|
|
nmc_terminal_erase_line ();
|
|
g_main_loop_quit (loop);
|
|
}
|
|
|
|
static int
|
|
compare_devices (const void *a, const void *b)
|
|
{
|
|
NMDevice *da = *(NMDevice **)a;
|
|
NMDevice *db = *(NMDevice **)b;
|
|
NMActiveConnection *da_ac = nm_device_get_active_connection (da);
|
|
NMActiveConnection *db_ac = nm_device_get_active_connection (db);
|
|
|
|
NM_CMP_DIRECT (nm_device_get_state (db), nm_device_get_state (da));
|
|
NM_CMP_RETURN (nmc_active_connection_cmp (db_ac, da_ac));
|
|
NM_CMP_DIRECT_STRCMP0 (nm_device_get_type_description (da),
|
|
nm_device_get_type_description (db));
|
|
NM_CMP_DIRECT_STRCMP0 (nm_device_get_iface (da),
|
|
nm_device_get_iface (db));
|
|
NM_CMP_DIRECT_STRCMP0 (nm_object_get_path (NM_OBJECT (da)),
|
|
nm_object_get_path (NM_OBJECT (db)));
|
|
|
|
g_return_val_if_reached (0);
|
|
}
|
|
|
|
NMDevice **
|
|
nmc_get_devices_sorted (NMClient *client)
|
|
{
|
|
const GPtrArray *devs;
|
|
NMDevice **sorted;
|
|
|
|
devs = nm_client_get_devices (client);
|
|
|
|
sorted = g_new (NMDevice *, devs->len + 1);
|
|
memcpy (sorted, devs->pdata, devs->len * sizeof (NMDevice *));
|
|
sorted[devs->len] = NULL;
|
|
|
|
qsort (sorted, devs->len, sizeof (NMDevice *), compare_devices);
|
|
return sorted;
|
|
}
|
|
|
|
static void
|
|
complete_device (NMDevice **devices, const char *prefix, gboolean wifi_only)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; devices[i]; i++) {
|
|
const char *iface = nm_device_get_iface (devices[i]);
|
|
|
|
if (wifi_only && !NM_IS_DEVICE_WIFI (devices[i]))
|
|
continue;
|
|
|
|
if (g_str_has_prefix (iface, prefix))
|
|
g_print ("%s\n", iface);
|
|
}
|
|
}
|
|
|
|
void
|
|
nmc_complete_device (NMClient *client, const char *prefix, gboolean wifi_only)
|
|
{
|
|
gs_free NMDevice **devices = NULL;
|
|
|
|
devices = nmc_get_devices_sorted (client);
|
|
complete_device (devices, prefix, wifi_only);
|
|
}
|
|
|
|
static GSList *
|
|
get_device_list (NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
int arg_num = argc;
|
|
gs_strfreev char **arg_arr = NULL;
|
|
const char *const*arg_ptr = argv;
|
|
NMDevice **devices;
|
|
GSList *queue = NULL;
|
|
NMDevice *device;
|
|
int i;
|
|
|
|
if (argc == 0) {
|
|
if (nmc->ask) {
|
|
gs_free char *line = NULL;
|
|
|
|
line = nmc_readline (&nmc->nmc_config,
|
|
PROMPT_INTERFACES);
|
|
nmc_string_to_arg_array (line, NULL, FALSE, &arg_arr, &arg_num);
|
|
arg_ptr = (const char *const*) arg_arr;
|
|
}
|
|
if (arg_num == 0) {
|
|
g_string_printf (nmc->return_text, _("Error: No interface specified."));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
devices = nmc_get_devices_sorted (nmc->client);
|
|
while (arg_num > 0) {
|
|
if (arg_num == 1 && nmc->complete)
|
|
complete_device (devices, *arg_ptr, FALSE);
|
|
|
|
device = NULL;
|
|
for (i = 0; devices[i]; i++) {
|
|
if (!g_strcmp0 (nm_device_get_iface (devices[i]), *arg_ptr)) {
|
|
device = devices[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (device) {
|
|
if (!g_slist_find (queue, device))
|
|
queue = g_slist_prepend (queue, device);
|
|
else
|
|
g_printerr (_("Warning: argument '%s' is duplicated.\n"), *arg_ptr);
|
|
} else {
|
|
if (!nmc->complete)
|
|
g_printerr (_("Error: Device '%s' not found.\n"), *arg_ptr);
|
|
g_string_printf (nmc->return_text, _("Error: not all devices found."));
|
|
nmc->return_value = NMC_RESULT_ERROR_NOT_FOUND;
|
|
}
|
|
|
|
/* Take next argument */
|
|
next_arg (nmc->ask ? NULL : nmc, &arg_num, &arg_ptr, NULL);
|
|
}
|
|
g_free (devices);
|
|
|
|
error:
|
|
g_strfreev (arg_arr);
|
|
|
|
return queue;
|
|
}
|
|
|
|
static NMDevice *
|
|
get_device (NmCli *nmc, int *argc, const char *const**argv, GError **error)
|
|
{
|
|
gs_free NMDevice **devices = NULL;
|
|
gs_free char *ifname_ask = NULL;
|
|
const char *ifname = NULL;
|
|
int i;
|
|
|
|
if (*argc == 0) {
|
|
if (nmc->ask) {
|
|
ifname = ifname_ask = nmc_readline (&nmc->nmc_config,
|
|
PROMPT_INTERFACE);
|
|
}
|
|
|
|
if (!ifname_ask) {
|
|
g_set_error_literal (error, NMCLI_ERROR, NMC_RESULT_ERROR_USER_INPUT,
|
|
_("No interface specified"));
|
|
return NULL;
|
|
}
|
|
} else {
|
|
ifname = **argv;
|
|
next_arg (nmc, argc, argv, NULL);
|
|
}
|
|
|
|
devices = nmc_get_devices_sorted (nmc->client);
|
|
for (i = 0; devices[i]; i++) {
|
|
if (!g_strcmp0 (nm_device_get_iface (devices[i]), ifname))
|
|
break;
|
|
}
|
|
|
|
if (nmc->complete && !*argc)
|
|
complete_device (devices, ifname, FALSE);
|
|
|
|
if (devices[i] == NULL) {
|
|
g_set_error (error, NMCLI_ERROR, NMC_RESULT_ERROR_NOT_FOUND,
|
|
_("Device '%s' not found"), ifname);
|
|
}
|
|
|
|
return devices[i];
|
|
}
|
|
|
|
static int
|
|
compare_aps (gconstpointer a, gconstpointer b, gpointer user_data)
|
|
{
|
|
NMAccessPoint *apa = *(NMAccessPoint **)a;
|
|
NMAccessPoint *apb = *(NMAccessPoint **)b;
|
|
|
|
NM_CMP_DIRECT (nm_access_point_get_strength (apb), nm_access_point_get_strength (apa));
|
|
NM_CMP_DIRECT (nm_access_point_get_frequency (apa), nm_access_point_get_frequency (apb));
|
|
NM_CMP_DIRECT (nm_access_point_get_max_bitrate (apb), nm_access_point_get_max_bitrate (apa));
|
|
|
|
/* as fallback, just give it some stable order and use the D-Bus path (literally). */
|
|
NM_CMP_DIRECT_STRCMP0 (nm_object_get_path (NM_OBJECT (apa)),
|
|
nm_object_get_path (NM_OBJECT (apb)));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static GPtrArray *
|
|
sort_access_points (const GPtrArray *aps)
|
|
{
|
|
GPtrArray *sorted;
|
|
guint i;
|
|
|
|
g_return_val_if_fail (aps, NULL);
|
|
|
|
sorted = g_ptr_array_sized_new (aps->len);
|
|
g_ptr_array_set_free_func (sorted, nm_g_object_unref);
|
|
for (i = 0; i < aps->len; i++)
|
|
g_ptr_array_add (sorted, g_object_ref (aps->pdata[i]));
|
|
g_ptr_array_sort_with_data (sorted, compare_aps, NULL);
|
|
return sorted;
|
|
}
|
|
|
|
typedef struct {
|
|
NmCli *nmc;
|
|
int index;
|
|
guint32 output_flags;
|
|
const char* active_bssid;
|
|
const char* device;
|
|
GPtrArray *output_data;
|
|
} APInfo;
|
|
|
|
static void
|
|
fill_output_access_point (gpointer data, gpointer user_data)
|
|
{
|
|
NMAccessPoint *ap = NM_ACCESS_POINT (data);
|
|
APInfo *info = (APInfo *) user_data;
|
|
NmcOutputField *arr;
|
|
gboolean active = FALSE;
|
|
NM80211ApFlags flags;
|
|
NM80211ApSecurityFlags wpa_flags, rsn_flags;
|
|
guint32 freq, bitrate;
|
|
guint8 strength;
|
|
GBytes *ssid;
|
|
const char *bssid;
|
|
NM80211Mode mode;
|
|
char *channel_str, *freq_str, *ssid_str = NULL, *ssid_hex_str = NULL,
|
|
*bitrate_str, *strength_str, *wpa_flags_str, *rsn_flags_str;
|
|
GString *security_str;
|
|
char *ap_name;
|
|
const char *sig_bars;
|
|
NMMetaColor color;
|
|
|
|
if (info->active_bssid) {
|
|
const char *current_bssid = nm_access_point_get_bssid (ap);
|
|
if (current_bssid && !strcmp (current_bssid, info->active_bssid))
|
|
active = TRUE;
|
|
}
|
|
|
|
/* Get AP properties */
|
|
flags = nm_access_point_get_flags (ap);
|
|
wpa_flags = nm_access_point_get_wpa_flags (ap);
|
|
rsn_flags = nm_access_point_get_rsn_flags (ap);
|
|
ssid = nm_access_point_get_ssid (ap);
|
|
bssid = nm_access_point_get_bssid (ap);
|
|
freq = nm_access_point_get_frequency (ap);
|
|
mode = nm_access_point_get_mode (ap);
|
|
bitrate = nm_access_point_get_max_bitrate (ap);
|
|
strength = MIN (nm_access_point_get_strength (ap), 100);
|
|
|
|
/* Convert to strings */
|
|
if (ssid) {
|
|
const guint8 *ssid_data;
|
|
gsize ssid_len;
|
|
|
|
ssid_data = g_bytes_get_data (ssid, &ssid_len);
|
|
ssid_str = nm_utils_ssid_to_utf8 (ssid_data, ssid_len);
|
|
ssid_hex_str = ssid_to_hex ((const char *) ssid_data, ssid_len);
|
|
}
|
|
channel_str = g_strdup_printf ("%u", nm_utils_wifi_freq_to_channel (freq));
|
|
freq_str = g_strdup_printf (_("%u MHz"), freq);
|
|
bitrate_str = g_strdup_printf (_("%u Mbit/s"), bitrate/1000);
|
|
strength_str = g_strdup_printf ("%u", strength);
|
|
wpa_flags_str = ap_wpa_rsn_flags_to_string (wpa_flags, NM_META_ACCESSOR_GET_TYPE_PRETTY);
|
|
rsn_flags_str = ap_wpa_rsn_flags_to_string (rsn_flags, NM_META_ACCESSOR_GET_TYPE_PRETTY);
|
|
sig_bars = nmc_wifi_strength_bars (strength);
|
|
|
|
security_str = g_string_new (NULL);
|
|
|
|
if ( (flags & NM_802_11_AP_FLAGS_PRIVACY)
|
|
&& (wpa_flags == NM_802_11_AP_SEC_NONE)
|
|
&& (rsn_flags == NM_802_11_AP_SEC_NONE)) {
|
|
g_string_append (security_str, "WEP ");
|
|
}
|
|
if (wpa_flags != NM_802_11_AP_SEC_NONE) {
|
|
g_string_append (security_str, "WPA1 ");
|
|
}
|
|
if ( (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK)
|
|
|| (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)) {
|
|
g_string_append (security_str, "WPA2 ");
|
|
}
|
|
if (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_SAE) {
|
|
g_string_append (security_str, "WPA3 ");
|
|
}
|
|
if (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_OWE) {
|
|
g_string_append (security_str, "OWE ");
|
|
}
|
|
if ( (wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)
|
|
|| (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)) {
|
|
g_string_append (security_str, "802.1X ");
|
|
}
|
|
|
|
if (security_str->len > 0)
|
|
g_string_truncate (security_str, security_str->len-1); /* Chop off last space */
|
|
|
|
arr = nmc_dup_fields_array ((const NMMetaAbstractInfo *const*) nmc_fields_dev_wifi_list,
|
|
info->output_flags);
|
|
|
|
ap_name = g_strdup_printf ("AP[%d]", info->index++); /* AP */
|
|
set_val_str (arr, 0, ap_name);
|
|
set_val_str (arr, 1, ssid_str);
|
|
set_val_str (arr, 2, ssid_hex_str);
|
|
set_val_strc (arr, 3, bssid);
|
|
set_val_strc (arr, 4, mode == NM_802_11_MODE_ADHOC ? _("Ad-Hoc")
|
|
: mode == NM_802_11_MODE_INFRA ? _("Infra")
|
|
: mode == NM_802_11_MODE_MESH ? _("Mesh")
|
|
: _("N/A"));
|
|
set_val_str (arr, 5, channel_str);
|
|
set_val_str (arr, 6, freq_str);
|
|
set_val_str (arr, 7, bitrate_str);
|
|
set_val_str (arr, 8, strength_str);
|
|
set_val_strc (arr, 9, sig_bars);
|
|
set_val_str (arr, 10, security_str->str);
|
|
set_val_str (arr, 11, wpa_flags_str);
|
|
set_val_str (arr, 12, rsn_flags_str);
|
|
set_val_strc (arr, 13, info->device);
|
|
set_val_strc (arr, 14, active ? _("yes") : _("no"));
|
|
set_val_strc (arr, 15, active ? "*" : " ");
|
|
set_val_strc (arr, 16, nm_object_get_path (NM_OBJECT (ap)));
|
|
|
|
/* Set colors */
|
|
color = wifi_signal_to_color (strength);
|
|
set_val_color_all (arr, color);
|
|
if (active)
|
|
arr[15].color = NM_META_COLOR_CONNECTION_ACTIVATED;
|
|
|
|
g_ptr_array_add (info->output_data, arr);
|
|
|
|
g_string_free (security_str, FALSE);
|
|
}
|
|
|
|
static char *
|
|
bluetooth_caps_to_string (NMBluetoothCapabilities caps)
|
|
{
|
|
char *caps_str[8]; /* Enough space for caps and terminating NULL */
|
|
char *ret_str;
|
|
int i = 0;
|
|
|
|
if (caps & NM_BT_CAPABILITY_DUN)
|
|
caps_str[i++] = g_strdup ("DUN");
|
|
if (caps & NM_BT_CAPABILITY_NAP)
|
|
caps_str[i++] = g_strdup ("NAP");
|
|
|
|
if (i == 0)
|
|
caps_str[i++] = g_strdup (_("(none)"));
|
|
|
|
caps_str[i] = NULL;
|
|
|
|
ret_str = g_strjoinv (" ", caps_str);
|
|
|
|
i = 0;
|
|
while (caps_str[i])
|
|
g_free (caps_str[i++]);
|
|
|
|
return ret_str;
|
|
}
|
|
|
|
static char *
|
|
construct_header_name (const char *base, const char *spec)
|
|
{
|
|
if (spec == NULL)
|
|
return g_strdup (base);
|
|
|
|
return g_strdup_printf ("%s (%s)", base, spec);
|
|
}
|
|
|
|
static gboolean
|
|
print_bond_bridge_info (NMDevice *device,
|
|
NmCli *nmc,
|
|
const char *group_prefix,
|
|
const char *one_field)
|
|
{
|
|
const GPtrArray *slaves = NULL;
|
|
GString *slaves_str;
|
|
int idx;
|
|
const NMMetaAbstractInfo *const*tmpl;
|
|
NmcOutputField *arr;
|
|
NMC_OUTPUT_DATA_DEFINE_SCOPED (out);
|
|
|
|
if (NM_IS_DEVICE_BOND (device))
|
|
slaves = nm_device_bond_get_slaves (NM_DEVICE_BOND (device));
|
|
else if (NM_IS_DEVICE_BRIDGE (device))
|
|
slaves = nm_device_bridge_get_slaves (NM_DEVICE_BRIDGE (device));
|
|
else
|
|
g_return_val_if_reached (FALSE);
|
|
|
|
slaves_str = g_string_new (NULL);
|
|
for (idx = 0; slaves && idx < slaves->len; idx++) {
|
|
NMDevice *slave = g_ptr_array_index (slaves, idx);
|
|
const char *iface = nm_device_get_iface (slave);
|
|
|
|
if (iface) {
|
|
g_string_append (slaves_str, iface);
|
|
g_string_append_c (slaves_str, ' ');
|
|
}
|
|
}
|
|
if (slaves_str->len > 0)
|
|
g_string_truncate (slaves_str, slaves_str->len-1); /* Chop off last space */
|
|
|
|
tmpl = (const NMMetaAbstractInfo *const*) nmc_fields_dev_show_master_prop;
|
|
out_indices = parse_output_fields (one_field,
|
|
tmpl, FALSE, NULL, NULL);
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_FIELD_NAMES);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_SECTION_PREFIX);
|
|
set_val_strc (arr, 0, group_prefix); /* i.e. BOND, TEAM, BRIDGE */
|
|
set_val_str (arr, 1, slaves_str->str);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
print_data_prepare_width (out.output_data);
|
|
print_data (&nmc->nmc_config, &nmc->pager_data, out_indices, NULL, 0, &out);
|
|
|
|
g_string_free (slaves_str, FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static char *
|
|
sanitize_team_config (const char *config)
|
|
{
|
|
char *ret;
|
|
int i;
|
|
|
|
if (!config)
|
|
return NULL;
|
|
|
|
ret = g_strdup (config);
|
|
|
|
for (i = 0; i < strlen (ret); i++) {
|
|
if (ret[i] == '\n')
|
|
ret[i] = ' ';
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
print_team_info (NMDevice *device,
|
|
NmCli *nmc,
|
|
const char *group_prefix,
|
|
const char *one_field)
|
|
{
|
|
const GPtrArray *slaves = NULL;
|
|
GString *slaves_str;
|
|
int idx;
|
|
const NMMetaAbstractInfo *const* tmpl;
|
|
NmcOutputField *arr;
|
|
NMC_OUTPUT_DATA_DEFINE_SCOPED (out);
|
|
|
|
if (NM_IS_DEVICE_TEAM (device))
|
|
slaves = nm_device_team_get_slaves (NM_DEVICE_TEAM (device));
|
|
else
|
|
g_return_val_if_reached (FALSE);
|
|
|
|
slaves_str = g_string_new (NULL);
|
|
for (idx = 0; slaves && idx < slaves->len; idx++) {
|
|
NMDevice *slave = g_ptr_array_index (slaves, idx);
|
|
const char *iface = nm_device_get_iface (slave);
|
|
|
|
if (iface) {
|
|
g_string_append (slaves_str, iface);
|
|
g_string_append_c (slaves_str, ' ');
|
|
}
|
|
}
|
|
if (slaves_str->len > 0)
|
|
g_string_truncate (slaves_str, slaves_str->len-1); /* Chop off last space */
|
|
|
|
tmpl = (const NMMetaAbstractInfo *const*) nmc_fields_dev_show_team_prop;
|
|
out_indices = parse_output_fields (one_field,
|
|
tmpl, FALSE, NULL, NULL);
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_FIELD_NAMES);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_SECTION_PREFIX);
|
|
set_val_strc (arr, 0, group_prefix); /* TEAM */
|
|
set_val_str (arr, 1, slaves_str->str);
|
|
set_val_str (arr, 2, sanitize_team_config (nm_device_team_get_config (NM_DEVICE_TEAM (device))));
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
print_data_prepare_width (out.output_data);
|
|
print_data (&nmc->nmc_config, &nmc->pager_data, out_indices, NULL, 0, &out);
|
|
|
|
g_string_free (slaves_str, FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
show_device_info (NMDevice *device, NmCli *nmc)
|
|
{
|
|
GError *error = NULL;
|
|
NMDeviceState state = NM_DEVICE_STATE_UNKNOWN;
|
|
GArray *sections_array;
|
|
int k;
|
|
const char *fields_str = NULL;
|
|
const NMMetaAbstractInfo *const*tmpl;
|
|
NmcOutputField *arr;
|
|
gboolean was_output = FALSE;
|
|
NMIPConfig *cfg4, *cfg6;
|
|
NMDhcpConfig *dhcp4, *dhcp6;
|
|
const char *base_hdr = _("Device details");
|
|
GPtrArray *fields_in_section = NULL;
|
|
|
|
if (!nmc->required_fields || g_ascii_strcasecmp (nmc->required_fields, "common") == 0)
|
|
fields_str = NMC_FIELDS_DEV_SHOW_SECTIONS_COMMON;
|
|
else if (g_ascii_strcasecmp (nmc->required_fields, "all") == 0) {
|
|
} else
|
|
fields_str = nmc->required_fields;
|
|
|
|
sections_array = parse_output_fields (fields_str, (const NMMetaAbstractInfo *const*) nmc_fields_dev_show_sections, TRUE, &fields_in_section, &error);
|
|
if (error) {
|
|
g_string_printf (nmc->return_text, _("Error: 'device show': %s"), error->message);
|
|
g_error_free (error);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return FALSE;
|
|
}
|
|
|
|
{
|
|
gs_unref_array GArray *out_indices = NULL;
|
|
gs_free char *header_name = NULL;
|
|
gs_free NmcOutputField *row = NULL;
|
|
int i;
|
|
|
|
/* Main header (pretty only) */
|
|
header_name = construct_header_name (base_hdr, nm_device_get_iface (device));
|
|
|
|
/* Lazy way to retrieve sorted array from 0 to the number of dev fields */
|
|
out_indices = parse_output_fields (NULL,
|
|
(const NMMetaAbstractInfo *const*) metagen_device_detail_general,
|
|
FALSE, NULL, NULL);
|
|
|
|
row = g_new0 (NmcOutputField, G_N_ELEMENTS (metagen_device_detail_general));
|
|
for (i = 0; i < G_N_ELEMENTS (metagen_device_detail_general); i++)
|
|
row[i].info = (const NMMetaAbstractInfo *) &metagen_device_detail_general[i];
|
|
|
|
print_required_fields (&nmc->nmc_config,
|
|
&nmc->pager_data,
|
|
NMC_OF_FLAG_MAIN_HEADER_ONLY,
|
|
out_indices,
|
|
header_name,
|
|
0,
|
|
row);
|
|
}
|
|
|
|
/* Loop through the required sections and print them. */
|
|
for (k = 0; k < sections_array->len; k++) {
|
|
int section_idx = g_array_index (sections_array, int, k);
|
|
char *section_fld = (char *) g_ptr_array_index (fields_in_section, k);
|
|
|
|
if ( NM_IN_SET (nmc->nmc_config.print_output, NMC_PRINT_NORMAL, NMC_PRINT_PRETTY)
|
|
&& !nmc->nmc_config.multiline_output
|
|
&& was_output)
|
|
g_print ("\n"); /* Print empty line between groups in tabular mode */
|
|
|
|
was_output = FALSE;
|
|
|
|
state = nm_device_get_state (device);
|
|
|
|
if (nmc_fields_dev_show_sections[section_idx]->nested == metagen_device_detail_general) {
|
|
gs_free char *f = section_fld ? g_strdup_printf ("GENERAL.%s", section_fld) : NULL;
|
|
|
|
nmc_print (&nmc->nmc_config,
|
|
(gpointer[]) { device, NULL },
|
|
NULL,
|
|
NULL,
|
|
NMC_META_GENERIC_GROUP ("GENERAL", metagen_device_detail_general, N_("NAME")),
|
|
f,
|
|
NULL);
|
|
was_output = TRUE;
|
|
continue;
|
|
}
|
|
|
|
if (nmc_fields_dev_show_sections[section_idx]->nested == metagen_device_detail_capabilities) {
|
|
gs_free char *f = section_fld ? g_strdup_printf ("CAPABILITIES.%s", section_fld) : NULL;
|
|
|
|
nmc_print (&nmc->nmc_config,
|
|
(gpointer[]) { device, NULL },
|
|
NULL,
|
|
NULL,
|
|
NMC_META_GENERIC_GROUP ("CAPABILITIES", metagen_device_detail_capabilities, N_("NAME")),
|
|
f,
|
|
NULL);
|
|
was_output = TRUE;
|
|
continue;
|
|
}
|
|
|
|
if (nmc_fields_dev_show_sections[section_idx]->nested == metagen_device_detail_interface_flags) {
|
|
gs_free char *f = section_fld ? g_strdup_printf ("INTERFACE-FLAGS.%s", section_fld) : NULL;
|
|
|
|
nmc_print (&nmc->nmc_config,
|
|
(gpointer[]) { device, NULL },
|
|
NULL,
|
|
NULL,
|
|
NMC_META_GENERIC_GROUP ("INTERFACE-FLAGS", metagen_device_detail_interface_flags, N_("NAME")),
|
|
f,
|
|
NULL);
|
|
was_output = TRUE;
|
|
continue;
|
|
}
|
|
|
|
if (nmc_fields_dev_show_sections[section_idx]->nested == metagen_device_detail_wifi_properties) {
|
|
if (NM_IS_DEVICE_WIFI (device)) {
|
|
gs_free char *f = section_fld ? g_strdup_printf ("WIFI-PROPERTIES.%s", section_fld) : NULL;
|
|
|
|
nmc_print (&nmc->nmc_config,
|
|
(gpointer[]) { device, NULL },
|
|
NULL,
|
|
NULL,
|
|
NMC_META_GENERIC_GROUP ("WIFI-PROPERTIES", metagen_device_detail_wifi_properties, N_("NAME")),
|
|
f,
|
|
NULL);
|
|
was_output = TRUE;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* Wireless specific information */
|
|
if ((NM_IS_DEVICE_WIFI (device))) {
|
|
NMAccessPoint *active_ap = NULL;
|
|
const char *active_bssid = NULL;
|
|
|
|
/* section AP */
|
|
if (!g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[4]->name)) {
|
|
NMC_OUTPUT_DATA_DEFINE_SCOPED (out);
|
|
|
|
if (state == NM_DEVICE_STATE_ACTIVATED) {
|
|
active_ap = nm_device_wifi_get_active_access_point (NM_DEVICE_WIFI (device));
|
|
active_bssid = active_ap ? nm_access_point_get_bssid (active_ap) : NULL;
|
|
}
|
|
|
|
tmpl = (const NMMetaAbstractInfo *const*) nmc_fields_dev_wifi_list;
|
|
out_indices = parse_output_fields (section_fld ?: NMC_FIELDS_DEV_WIFI_LIST_FOR_DEV_LIST,
|
|
tmpl, FALSE, NULL, NULL);
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_FIELD_NAMES);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
{
|
|
gs_unref_ptrarray GPtrArray *aps = NULL;
|
|
APInfo info = {
|
|
.nmc = nmc,
|
|
.index = 1,
|
|
.output_flags = NMC_OF_FLAG_SECTION_PREFIX,
|
|
.active_bssid = active_bssid,
|
|
.device = nm_device_get_iface (device),
|
|
.output_data = out.output_data,
|
|
};
|
|
|
|
aps = sort_access_points (nm_device_wifi_get_access_points (NM_DEVICE_WIFI (device)));
|
|
g_ptr_array_foreach (aps, fill_output_access_point, &info);
|
|
}
|
|
|
|
print_data_prepare_width (out.output_data);
|
|
print_data (&nmc->nmc_config, &nmc->pager_data, out_indices, NULL, 0, &out);
|
|
was_output = TRUE;
|
|
}
|
|
}
|
|
|
|
if (nmc_fields_dev_show_sections[section_idx]->nested == metagen_device_detail_wired_properties) {
|
|
if ((NM_IS_DEVICE_ETHERNET (device))) {
|
|
gs_free char *f = section_fld ? g_strdup_printf ("WIRED-PROPERTIES.%s", section_fld) : NULL;
|
|
|
|
nmc_print (&nmc->nmc_config,
|
|
(gpointer[]) { device, NULL },
|
|
NULL,
|
|
NULL,
|
|
NMC_META_GENERIC_GROUP ("WIRED-PROPERTIES", metagen_device_detail_wired_properties, N_("NAME")),
|
|
f,
|
|
NULL);
|
|
was_output = TRUE;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
/* IP configuration info */
|
|
cfg4 = nm_device_get_ip4_config (device);
|
|
cfg6 = nm_device_get_ip6_config (device);
|
|
dhcp4 = nm_device_get_dhcp4_config (device);
|
|
dhcp6 = nm_device_get_dhcp6_config (device);
|
|
|
|
/* IP4 */
|
|
if (cfg4 && !g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[8]->name))
|
|
was_output = print_ip_config (cfg4, AF_INET, &nmc->nmc_config, section_fld);
|
|
|
|
/* DHCP4 */
|
|
if (dhcp4 && !g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[9]->name))
|
|
was_output = print_dhcp_config (dhcp4, AF_INET, &nmc->nmc_config, section_fld);
|
|
|
|
/* IP6 */
|
|
if (cfg6 && !g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[10]->name))
|
|
was_output = print_ip_config (cfg6, AF_INET6, &nmc->nmc_config, section_fld);
|
|
|
|
/* DHCP6 */
|
|
if (dhcp6 && !g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[11]->name))
|
|
was_output = print_dhcp_config (dhcp6, AF_INET6, &nmc->nmc_config, section_fld);
|
|
|
|
/* Bond specific information */
|
|
if (NM_IS_DEVICE_BOND (device)) {
|
|
if (!g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[12]->name))
|
|
was_output = print_bond_bridge_info (device, nmc, nmc_fields_dev_show_sections[12]->name, section_fld);
|
|
}
|
|
|
|
/* Team specific information */
|
|
if (NM_IS_DEVICE_TEAM (device)) {
|
|
if (!g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[13]->name))
|
|
was_output = print_team_info (device, nmc, nmc_fields_dev_show_sections[13]->name, section_fld);
|
|
}
|
|
|
|
/* Bridge specific information */
|
|
if (NM_IS_DEVICE_BRIDGE (device)) {
|
|
if (!g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[14]->name))
|
|
was_output = print_bond_bridge_info (device, nmc, nmc_fields_dev_show_sections[14]->name, section_fld);
|
|
}
|
|
|
|
/* VLAN-specific information */
|
|
if ((NM_IS_DEVICE_VLAN (device))) {
|
|
if (!g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[15]->name)) {
|
|
char * vlan_id_str = g_strdup_printf ("%u", nm_device_vlan_get_vlan_id (NM_DEVICE_VLAN (device)));
|
|
NMDevice *parent = nm_device_vlan_get_parent (NM_DEVICE_VLAN (device));
|
|
NMC_OUTPUT_DATA_DEFINE_SCOPED (out);
|
|
|
|
tmpl = (const NMMetaAbstractInfo *const*) nmc_fields_dev_show_vlan_prop;
|
|
out_indices = parse_output_fields (section_fld,
|
|
tmpl, FALSE, NULL, NULL);
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_FIELD_NAMES);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_SECTION_PREFIX);
|
|
set_val_strc (arr, 0, nmc_fields_dev_show_sections[15]->name); /* "VLAN" */
|
|
set_val_strc (arr, 1, parent ? nm_device_get_iface (parent) : NULL);
|
|
set_val_str (arr, 2, vlan_id_str);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
print_data_prepare_width (out.output_data);
|
|
print_data (&nmc->nmc_config, &nmc->pager_data, out_indices, NULL, 0, &out);
|
|
|
|
was_output = TRUE;
|
|
}
|
|
}
|
|
|
|
if (NM_IS_DEVICE_BT (device)) {
|
|
if (!g_ascii_strcasecmp (nmc_fields_dev_show_sections[section_idx]->name, nmc_fields_dev_show_sections[16]->name)) {
|
|
NMC_OUTPUT_DATA_DEFINE_SCOPED (out);
|
|
|
|
tmpl = (const NMMetaAbstractInfo *const*) nmc_fields_dev_show_bluetooth;
|
|
out_indices = parse_output_fields (section_fld,
|
|
tmpl, FALSE, NULL, NULL);
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_FIELD_NAMES);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_SECTION_PREFIX);
|
|
set_val_strc (arr, 0, nmc_fields_dev_show_sections[16]->name); /* "BLUETOOTH" */
|
|
set_val_str (arr, 1, bluetooth_caps_to_string (nm_device_bt_get_capabilities (NM_DEVICE_BT (device))));
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
print_data_prepare_width (out.output_data);
|
|
print_data (&nmc->nmc_config, &nmc->pager_data, out_indices, NULL, 0, &out);
|
|
was_output = TRUE;
|
|
}
|
|
}
|
|
|
|
if (nmc_fields_dev_show_sections[section_idx]->nested == metagen_device_detail_connections) {
|
|
gs_free char *f = section_fld ? g_strdup_printf ("CONNECTIONS.%s", section_fld) : NULL;
|
|
|
|
nmc_print (&nmc->nmc_config,
|
|
(gpointer[]) { device, NULL },
|
|
NULL,
|
|
NULL,
|
|
NMC_META_GENERIC_GROUP ("CONNECTIONS", metagen_device_detail_connections, N_("NAME")),
|
|
f,
|
|
NULL);
|
|
was_output = TRUE;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (sections_array)
|
|
g_array_free (sections_array, TRUE);
|
|
if (fields_in_section)
|
|
g_ptr_array_free (fields_in_section, TRUE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
NMMetaColor
|
|
nmc_device_state_to_color (NMDeviceState state)
|
|
{
|
|
if (state <= NM_DEVICE_STATE_UNAVAILABLE)
|
|
return NM_META_COLOR_DEVICE_UNAVAILABLE;
|
|
else if (state == NM_DEVICE_STATE_DISCONNECTED)
|
|
return NM_META_COLOR_DEVICE_DISCONNECTED;
|
|
else if (state >= NM_DEVICE_STATE_PREPARE && state <= NM_DEVICE_STATE_SECONDARIES)
|
|
return NM_META_COLOR_DEVICE_ACTIVATING;
|
|
else if (state == NM_DEVICE_STATE_ACTIVATED)
|
|
return NM_META_COLOR_DEVICE_ACTIVATED;
|
|
|
|
return NM_META_COLOR_DEVICE_UNKNOWN;
|
|
}
|
|
|
|
static void
|
|
do_devices_status (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
GError *error = NULL;
|
|
gs_free NMDevice **devices = NULL;
|
|
const char *fields_str = NULL;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
if (argc) {
|
|
g_string_printf (nmc->return_text, _("Error: invalid extra argument '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
if (!nmc->required_fields || g_ascii_strcasecmp (nmc->required_fields, "common") == 0)
|
|
fields_str = "DEVICE,TYPE,STATE,CONNECTION";
|
|
else if (!nmc->required_fields || g_ascii_strcasecmp (nmc->required_fields, "all") == 0) {
|
|
} else
|
|
fields_str = nmc->required_fields;
|
|
|
|
devices = nmc_get_devices_sorted (nmc->client);
|
|
|
|
if (!nmc_print (&nmc->nmc_config,
|
|
(gpointer *) devices,
|
|
NULL,
|
|
N_("Status of devices"),
|
|
(const NMMetaAbstractInfo *const*) metagen_device_status,
|
|
fields_str,
|
|
&error)) {
|
|
g_string_printf (nmc->return_text, _("Error: 'device status': %s"), error->message);
|
|
g_error_free (error);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void
|
|
do_device_show (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
gs_free_error GError *error = NULL;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
if (!nmc->mode_specified)
|
|
nmc->nmc_config_mutable.multiline_output = TRUE; /* multiline mode is default for 'device show' */
|
|
|
|
if (argc) {
|
|
NMDevice *device;
|
|
|
|
device = get_device (nmc, &argc, &argv, &error);
|
|
if (!device) {
|
|
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
|
|
nmc->return_value = error->code;
|
|
return;
|
|
}
|
|
|
|
if (argc) {
|
|
g_string_printf (nmc->return_text, _("Error: invalid extra argument '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
show_device_info (device, nmc);
|
|
} else {
|
|
NMDevice **devices = nmc_get_devices_sorted (nmc->client);
|
|
int i;
|
|
|
|
/* nmc_do_cmd() should not call this with argc=0. */
|
|
nm_assert (!nmc->complete);
|
|
|
|
/* Show details for all devices */
|
|
for (i = 0; devices[i]; i++) {
|
|
if (!show_device_info (devices[i], nmc))
|
|
break;
|
|
if (devices[i + 1])
|
|
g_print ("\n"); /* Empty line */
|
|
}
|
|
|
|
g_free (devices);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
timeout_cb (gpointer user_data)
|
|
{
|
|
/* Time expired -> exit nmcli */
|
|
|
|
NmCli *nmc = (NmCli *) user_data;
|
|
|
|
g_string_printf (nmc->return_text, _("Error: Timeout %d sec expired."), nmc->timeout);
|
|
nmc->return_value = NMC_RESULT_ERROR_TIMEOUT_EXPIRED;
|
|
quit ();
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
progress_cb (gpointer user_data)
|
|
{
|
|
NMDevice *device = (NMDevice *) user_data;
|
|
|
|
nmc_terminal_show_progress (device ? gettext (nmc_device_state_to_string (nm_device_get_state (device))) : "");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
typedef struct {
|
|
NmCli *nmc;
|
|
NMDevice *device;
|
|
NMActiveConnection *active;
|
|
char *specific_object;
|
|
bool hotspot:1;
|
|
bool create:1;
|
|
} AddAndActivateInfo;
|
|
|
|
static AddAndActivateInfo *
|
|
add_and_activate_info_new (NmCli *nmc,
|
|
NMDevice *device,
|
|
gboolean hotspot,
|
|
gboolean create,
|
|
const char *specific_object)
|
|
{
|
|
AddAndActivateInfo *info;
|
|
|
|
info = g_slice_new (AddAndActivateInfo);
|
|
*info = (AddAndActivateInfo) {
|
|
.nmc = nmc,
|
|
.device = g_object_ref (device),
|
|
.hotspot = hotspot,
|
|
.create = create,
|
|
.specific_object = g_strdup (specific_object),
|
|
};
|
|
return info;
|
|
}
|
|
|
|
static void
|
|
add_and_activate_info_free (AddAndActivateInfo *info)
|
|
{
|
|
g_object_unref (info->device);
|
|
g_clear_object (&info->active);
|
|
g_free (info->specific_object);
|
|
nm_g_slice_free (info);
|
|
}
|
|
|
|
NM_AUTO_DEFINE_FCN0 (AddAndActivateInfo *, _nm_auto_free_add_and_activate_info, add_and_activate_info_free)
|
|
#define nm_auto_free_add_and_activate_info nm_auto (_nm_auto_free_add_and_activate_info)
|
|
|
|
static void
|
|
connected_state_cb (AddAndActivateInfo *info)
|
|
{
|
|
NMDeviceState state;
|
|
NMDeviceStateReason reason;
|
|
NMActiveConnectionState ac_state;
|
|
|
|
state = nm_device_get_state (info->device);
|
|
ac_state = nm_active_connection_get_state (info->active);
|
|
|
|
if (ac_state == NM_ACTIVE_CONNECTION_STATE_ACTIVATING)
|
|
return;
|
|
|
|
if (state == NM_DEVICE_STATE_ACTIVATED) {
|
|
nmc_terminal_erase_line ();
|
|
g_print (_("Device '%s' successfully activated with '%s'.\n"),
|
|
nm_device_get_iface (info->device),
|
|
nm_active_connection_get_uuid (info->active));
|
|
|
|
if (info->hotspot)
|
|
g_print (_("Hint: \"nmcli dev wifi show-password\" shows the Wi-Fi name and password.\n"));
|
|
} else if ( state <= NM_DEVICE_STATE_DISCONNECTED
|
|
|| state >= NM_DEVICE_STATE_DEACTIVATING) {
|
|
reason = nm_device_get_state_reason (info->device);
|
|
g_print (_("Error: Connection activation failed: (%d) %s.\n"),
|
|
reason, gettext (nmc_device_reason_to_string (reason)));
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
g_signal_handlers_disconnect_by_func (info->active, G_CALLBACK (connected_state_cb), info);
|
|
g_signal_handlers_disconnect_by_func (info->device, G_CALLBACK (connected_state_cb), info);
|
|
add_and_activate_info_free (info);
|
|
|
|
quit ();
|
|
}
|
|
|
|
static void
|
|
add_and_activate_cb (GObject *client,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
nm_auto_free_add_and_activate_info AddAndActivateInfo *info = user_data;
|
|
NmCli *nmc = info->nmc;
|
|
gs_unref_object NMActiveConnection *active = NULL;
|
|
gs_free_error GError *error = NULL;
|
|
|
|
if (info->create)
|
|
active = nm_client_add_and_activate_connection_finish (NM_CLIENT (client), result, &error);
|
|
else
|
|
active = nm_client_activate_connection_finish (NM_CLIENT (client), result, &error);
|
|
|
|
if (error) {
|
|
if (info->hotspot) {
|
|
g_string_printf (nmc->return_text, _("Error: Failed to setup a Wi-Fi hotspot: %s"),
|
|
error->message);
|
|
} else if (info->create) {
|
|
g_string_printf (nmc->return_text, _("Error: Failed to add/activate new connection: %s"),
|
|
error->message);
|
|
} else {
|
|
g_string_printf (nmc->return_text, _("Error: Failed to activate connection: %s"),
|
|
error->message);
|
|
}
|
|
nmc->return_value = NMC_RESULT_ERROR_CON_ACTIVATION;
|
|
quit ();
|
|
return;
|
|
}
|
|
|
|
if (nmc->nowait_flag) {
|
|
quit ();
|
|
return;
|
|
}
|
|
|
|
if (nmc->nmc_config.print_output == NMC_PRINT_PRETTY)
|
|
progress_id = g_timeout_add (120, progress_cb, info->device);
|
|
|
|
info->active = g_steal_pointer (&active);
|
|
g_signal_connect_swapped (info->device, "notify::state", G_CALLBACK (connected_state_cb), info);
|
|
g_signal_connect_swapped (info->active, "notify::state", G_CALLBACK (connected_state_cb), info);
|
|
connected_state_cb (g_steal_pointer (&info));
|
|
|
|
g_timeout_add_seconds (nmc->timeout, timeout_cb, nmc); /* Exit if timeout expires */
|
|
}
|
|
|
|
static void
|
|
create_connect_connection_for_device (AddAndActivateInfo *info)
|
|
{
|
|
NMConnection *connection;
|
|
NMSettingConnection *s_con;
|
|
|
|
/* Create new connection and tie it to the device */
|
|
connection = nm_simple_connection_new ();
|
|
s_con = (NMSettingConnection *) nm_setting_connection_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_con));
|
|
g_object_set (s_con,
|
|
NM_SETTING_CONNECTION_ID, nm_device_get_iface (info->device),
|
|
NULL);
|
|
|
|
nm_client_add_and_activate_connection_async (info->nmc->client,
|
|
connection,
|
|
info->device,
|
|
NULL,
|
|
NULL,
|
|
add_and_activate_cb,
|
|
info);
|
|
}
|
|
|
|
static void
|
|
connect_device_cb (GObject *client, GAsyncResult *result, gpointer user_data)
|
|
{
|
|
nm_auto_free_add_and_activate_info AddAndActivateInfo *info = user_data;
|
|
NmCli *nmc = info->nmc;
|
|
gs_unref_object NMActiveConnection *active = NULL;
|
|
GError *error = NULL;
|
|
|
|
active = nm_client_activate_connection_finish (NM_CLIENT (client), result, &error);
|
|
|
|
if (error) {
|
|
/* If no connection existed for the device, create one and activate it */
|
|
if (g_error_matches (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_UNKNOWN_CONNECTION)) {
|
|
info->create = TRUE;
|
|
create_connect_connection_for_device (g_steal_pointer (&info));
|
|
return;
|
|
}
|
|
|
|
g_string_printf (nmc->return_text, _("Error: Device activation failed: %s"),
|
|
error->message);
|
|
g_error_free (error);
|
|
nmc->return_value = NMC_RESULT_ERROR_CON_ACTIVATION;
|
|
quit ();
|
|
return;
|
|
}
|
|
|
|
nm_assert (NM_IS_ACTIVE_CONNECTION (active));
|
|
|
|
if (nmc->nowait_flag) {
|
|
quit ();
|
|
return;
|
|
}
|
|
|
|
if (nmc->secret_agent) {
|
|
NMRemoteConnection *connection = nm_active_connection_get_connection (active);
|
|
|
|
nm_secret_agent_simple_enable (nmc->secret_agent,
|
|
nm_connection_get_path (NM_CONNECTION (connection)));
|
|
}
|
|
|
|
info->active = g_steal_pointer (&active);
|
|
g_signal_connect_swapped (info->device, "notify::state", G_CALLBACK (connected_state_cb), info);
|
|
g_signal_connect_swapped (info->active, "notify::state", G_CALLBACK (connected_state_cb), info);
|
|
connected_state_cb (g_steal_pointer (&info));
|
|
|
|
/* Start timer not to loop forever if "notify::state" signal is not issued */
|
|
g_timeout_add_seconds (nmc->timeout, timeout_cb, nmc);
|
|
}
|
|
|
|
static void
|
|
do_device_connect (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
NMDevice *device = NULL;
|
|
AddAndActivateInfo *info;
|
|
gs_free_error GError *error = NULL;
|
|
|
|
/* Set default timeout for connect operation. */
|
|
if (nmc->timeout == -1)
|
|
nmc->timeout = 90;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
device = get_device (nmc, &argc, &argv, &error);
|
|
if (!device) {
|
|
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
|
|
nmc->return_value = error->code;
|
|
return;
|
|
}
|
|
|
|
if (*argv) {
|
|
g_string_printf (nmc->return_text, _("Error: extra argument not allowed: '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
/*
|
|
* Use nowait_flag instead of should_wait, because exiting has to be postponed
|
|
* till connect_device_cb() is called, giving NM time to check our permissions.
|
|
*/
|
|
nmc->nowait_flag = (nmc->timeout == 0);
|
|
nmc->should_wait++;
|
|
|
|
/* Create secret agent */
|
|
nmc->secret_agent = nm_secret_agent_simple_new ("nmcli-connect");
|
|
if (nmc->secret_agent) {
|
|
g_signal_connect (nmc->secret_agent,
|
|
NM_SECRET_AGENT_SIMPLE_REQUEST_SECRETS,
|
|
G_CALLBACK (nmc_secrets_requested),
|
|
nmc);
|
|
}
|
|
|
|
info = add_and_activate_info_new (nmc, device, FALSE, FALSE, NULL);
|
|
|
|
nm_client_activate_connection_async (nmc->client,
|
|
NULL, /* let NM find a connection automatically */
|
|
device,
|
|
NULL,
|
|
NULL,
|
|
connect_device_cb,
|
|
info);
|
|
|
|
/* Start progress indication */
|
|
if (nmc->nmc_config.print_output == NMC_PRINT_PRETTY)
|
|
progress_id = g_timeout_add (120, progress_cb, device);
|
|
}
|
|
|
|
typedef struct {
|
|
NmCli *nmc;
|
|
GSList *queue;
|
|
guint timeout_id;
|
|
gboolean cmd_disconnect;
|
|
GCancellable *cancellable;
|
|
} DeviceCbInfo;
|
|
|
|
static void device_cb_info_finish (DeviceCbInfo *info, NMDevice *device);
|
|
|
|
static gboolean
|
|
device_op_timeout_cb (gpointer user_data)
|
|
{
|
|
DeviceCbInfo *info = user_data;
|
|
|
|
timeout_cb (info->nmc);
|
|
device_cb_info_finish (info, NULL);
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
|
|
static void
|
|
device_removed_cb (NMClient *client, NMDevice *device, DeviceCbInfo *info)
|
|
{
|
|
/* Success: device has been removed.
|
|
* It can also happen when disconnecting a software device.
|
|
*/
|
|
if (!g_slist_find (info->queue, device))
|
|
return;
|
|
|
|
if (info->cmd_disconnect)
|
|
g_print (_("Device '%s' successfully disconnected.\n"),
|
|
nm_device_get_iface (device));
|
|
else
|
|
g_print (_("Device '%s' successfully removed.\n"),
|
|
nm_device_get_iface (device));
|
|
device_cb_info_finish (info, device);
|
|
}
|
|
|
|
static void
|
|
disconnect_state_cb (NMDevice *device, GParamSpec *pspec, DeviceCbInfo *info)
|
|
{
|
|
if (!g_slist_find (info->queue, device))
|
|
return;
|
|
|
|
if (nm_device_get_state (device) <= NM_DEVICE_STATE_DISCONNECTED) {
|
|
g_print (_("Device '%s' successfully disconnected.\n"),
|
|
nm_device_get_iface (device));
|
|
device_cb_info_finish (info, device);
|
|
}
|
|
}
|
|
|
|
static void
|
|
destroy_queue_element (gpointer data)
|
|
{
|
|
g_signal_handlers_disconnect_matched (data, G_SIGNAL_MATCH_FUNC, 0, 0, 0,
|
|
disconnect_state_cb, NULL);
|
|
g_object_unref (data);
|
|
}
|
|
|
|
static void
|
|
device_cb_info_finish (DeviceCbInfo *info, NMDevice *device)
|
|
{
|
|
if (device) {
|
|
GSList *elem = g_slist_find (info->queue, device);
|
|
if (!elem)
|
|
return;
|
|
info->queue = g_slist_delete_link (info->queue, elem);
|
|
destroy_queue_element (device);
|
|
} else {
|
|
g_slist_free_full (info->queue, destroy_queue_element);
|
|
info->queue = NULL;
|
|
}
|
|
|
|
if (info->queue)
|
|
return;
|
|
|
|
if (info->timeout_id)
|
|
g_source_remove (info->timeout_id);
|
|
|
|
g_signal_handlers_disconnect_by_func (info->nmc->client, device_removed_cb, info);
|
|
nm_clear_g_cancellable (&info->cancellable);
|
|
|
|
g_slice_free (DeviceCbInfo, info);
|
|
quit ();
|
|
}
|
|
|
|
static void
|
|
reapply_device_cb (GObject *object, GAsyncResult *result, gpointer user_data)
|
|
{
|
|
NMDevice *device = NM_DEVICE (object);
|
|
DeviceCbInfo *info = (DeviceCbInfo *) user_data;
|
|
NmCli *nmc = info->nmc;
|
|
GError *error = NULL;
|
|
|
|
if (!nm_device_reapply_finish (device, result, &error)) {
|
|
g_string_printf (nmc->return_text, _("Error: Reapplying connection to device '%s' (%s) failed: %s"),
|
|
nm_device_get_iface (device),
|
|
nm_object_get_path (NM_OBJECT (device)),
|
|
error->message);
|
|
g_error_free (error);
|
|
nmc->return_value = NMC_RESULT_ERROR_DEV_DISCONNECT;
|
|
device_cb_info_finish (info, device);
|
|
} else {
|
|
if (nmc->nmc_config.print_output == NMC_PRINT_PRETTY)
|
|
nmc_terminal_erase_line ();
|
|
g_print (_("Connection successfully reapplied to device '%s'.\n"),
|
|
nm_device_get_iface (device));
|
|
device_cb_info_finish (info, device);
|
|
}
|
|
}
|
|
|
|
static void
|
|
do_device_reapply (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
NMDevice *device;
|
|
DeviceCbInfo *info = NULL;
|
|
gs_free_error GError *error = NULL;
|
|
|
|
/* Set default timeout for reapply operation. */
|
|
if (nmc->timeout == -1)
|
|
nmc->timeout = 10;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
device = get_device (nmc, &argc, &argv, &error);
|
|
if (!device) {
|
|
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
|
|
nmc->return_value = error->code;
|
|
return;
|
|
}
|
|
|
|
if (argc) {
|
|
g_string_printf (nmc->return_text, _("Error: invalid extra argument '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
nmc->nowait_flag = (nmc->timeout == 0);
|
|
nmc->should_wait++;
|
|
|
|
info = g_slice_new0 (DeviceCbInfo);
|
|
info->nmc = nmc;
|
|
info->queue = g_slist_prepend (info->queue, g_object_ref (device));
|
|
|
|
/* Now reapply the connection to the device */
|
|
nm_device_reapply_async (device, NULL, 0, 0, NULL, reapply_device_cb, info);
|
|
}
|
|
|
|
typedef struct {
|
|
NmCli *nmc;
|
|
int argc;
|
|
char **argv;
|
|
} ModifyInfo;
|
|
|
|
static void
|
|
modify_reapply_cb (GObject *object, GAsyncResult *result, gpointer user_data)
|
|
{
|
|
NMDevice *device = NM_DEVICE (object);
|
|
ModifyInfo *info = user_data;
|
|
NmCli *nmc = info->nmc;
|
|
GError *error = NULL;
|
|
|
|
if (!nm_device_reapply_finish (device, result, &error)) {
|
|
g_string_printf (nmc->return_text, _("Error: Reapplying connection to device '%s' (%s) failed: %s"),
|
|
nm_device_get_iface (device),
|
|
nm_object_get_path (NM_OBJECT (device)),
|
|
error->message);
|
|
g_error_free (error);
|
|
nmc->return_value = NMC_RESULT_ERROR_DEV_DISCONNECT;
|
|
} else {
|
|
if (nmc->nmc_config.print_output == NMC_PRINT_PRETTY)
|
|
nmc_terminal_erase_line ();
|
|
g_print (_("Connection successfully reapplied to device '%s'.\n"),
|
|
nm_device_get_iface (device));
|
|
}
|
|
|
|
g_slice_free (ModifyInfo, info);
|
|
quit ();
|
|
}
|
|
|
|
static void
|
|
modify_get_applied_cb (GObject *object,
|
|
GAsyncResult *result,
|
|
gpointer user_data)
|
|
{
|
|
NMDevice *device = NM_DEVICE (object);
|
|
ModifyInfo *info = user_data;
|
|
NmCli *nmc = info->nmc;
|
|
gs_free_error GError *error = NULL;
|
|
NMConnection *connection;
|
|
guint64 version_id;
|
|
int argc;
|
|
const char *const*argv;
|
|
|
|
connection = nm_device_get_applied_connection_finish (device,
|
|
result,
|
|
&version_id,
|
|
&error);
|
|
if (!connection) {
|
|
g_string_printf (nmc->return_text, _("Error: Reading applied connection from device '%s' (%s) failed: %s"),
|
|
nm_device_get_iface (device),
|
|
nm_object_get_path (NM_OBJECT (device)),
|
|
error->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
g_slice_free (ModifyInfo, info);
|
|
quit ();
|
|
return;
|
|
}
|
|
|
|
argc = info->argc;
|
|
argv = (const char *const*) info->argv;
|
|
|
|
if (!nmc_process_connection_properties (info->nmc, connection, &argc, &argv, TRUE, &error)) {
|
|
g_string_assign (nmc->return_text, error->message);
|
|
nmc->return_value = error->code;
|
|
g_slice_free (ModifyInfo, info);
|
|
quit ();
|
|
return;
|
|
}
|
|
|
|
if (nmc->complete)
|
|
quit ();
|
|
else
|
|
nm_device_reapply_async (device, connection, version_id, 0, NULL, modify_reapply_cb, info);
|
|
}
|
|
|
|
static void
|
|
do_device_modify (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
NMDevice *device = NULL;
|
|
ModifyInfo *info = NULL;
|
|
gs_free_error GError *error = NULL;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
device = get_device (nmc, &argc, &argv, &error);
|
|
if (!device) {
|
|
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
|
|
nmc->return_value = error->code;
|
|
return;
|
|
}
|
|
|
|
if (nmc->timeout == -1)
|
|
nmc->timeout = 10;
|
|
|
|
nmc->nowait_flag = (nmc->timeout == 0);
|
|
nmc->should_wait++;
|
|
|
|
info = g_slice_new0 (ModifyInfo);
|
|
info->nmc = nmc;
|
|
info->argc = argc;
|
|
info->argv = nm_utils_strv_dup ((char **) argv, argc, TRUE);
|
|
|
|
nm_device_get_applied_connection_async (device, 0, NULL, modify_get_applied_cb, info);
|
|
}
|
|
|
|
static void
|
|
disconnect_device_cb (GObject *object, GAsyncResult *result, gpointer user_data)
|
|
{
|
|
NMDevice *device = NM_DEVICE (object);
|
|
DeviceCbInfo *info = (DeviceCbInfo *) user_data;
|
|
NmCli *nmc;
|
|
NMDeviceState state;
|
|
GError *error = NULL;
|
|
|
|
if (!nm_device_disconnect_finish (device, result, &error)) {
|
|
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
|
|
return;
|
|
nmc = info->nmc;
|
|
g_string_printf (nmc->return_text, _("Error: not all devices disconnected."));
|
|
g_printerr (_("Error: Device '%s' (%s) disconnecting failed: %s\n"),
|
|
nm_device_get_iface (device),
|
|
nm_object_get_path (NM_OBJECT (device)),
|
|
error->message);
|
|
g_error_free (error);
|
|
nmc->return_value = NMC_RESULT_ERROR_DEV_DISCONNECT;
|
|
device_cb_info_finish (info, device);
|
|
} else {
|
|
nmc = info->nmc;
|
|
state = nm_device_get_state (device);
|
|
if (nmc->nowait_flag || state <= NM_DEVICE_STATE_DISCONNECTED) {
|
|
/* Don't want to wait or device already disconnected */
|
|
if (state <= NM_DEVICE_STATE_DISCONNECTED) {
|
|
if (nmc->nmc_config.print_output == NMC_PRINT_PRETTY)
|
|
nmc_terminal_erase_line ();
|
|
g_print (_("Device '%s' successfully disconnected.\n"),
|
|
nm_device_get_iface (device));
|
|
}
|
|
device_cb_info_finish (info, device);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
do_devices_disconnect (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
NMDevice *device;
|
|
DeviceCbInfo *info = NULL;
|
|
GSList *queue, *iter;
|
|
|
|
/* Set default timeout for disconnect operation. */
|
|
if (nmc->timeout == -1)
|
|
nmc->timeout = 10;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
queue = get_device_list (nmc, argc, argv);
|
|
if (!queue)
|
|
return;
|
|
if (nmc->complete)
|
|
goto out;
|
|
queue = g_slist_reverse (queue);
|
|
|
|
info = g_slice_new0 (DeviceCbInfo);
|
|
info->nmc = nmc;
|
|
info->cmd_disconnect = TRUE;
|
|
info->cancellable = g_cancellable_new ();
|
|
if (nmc->timeout > 0)
|
|
info->timeout_id = g_timeout_add_seconds (nmc->timeout, device_op_timeout_cb, info);
|
|
|
|
g_signal_connect (nmc->client, NM_CLIENT_DEVICE_REMOVED,
|
|
G_CALLBACK (device_removed_cb), info);
|
|
|
|
nmc->nowait_flag = (nmc->timeout == 0);
|
|
nmc->should_wait++;
|
|
|
|
for (iter = queue; iter; iter = g_slist_next (iter)) {
|
|
device = iter->data;
|
|
|
|
info->queue = g_slist_prepend (info->queue, g_object_ref (device));
|
|
g_signal_connect (device, "notify::" NM_DEVICE_STATE,
|
|
G_CALLBACK (disconnect_state_cb), info);
|
|
|
|
/* Now disconnect the device */
|
|
nm_device_disconnect_async (device, info->cancellable, disconnect_device_cb, info);
|
|
}
|
|
|
|
out:
|
|
g_slist_free (queue);
|
|
}
|
|
|
|
static void
|
|
delete_device_cb (GObject *object, GAsyncResult *result, gpointer user_data)
|
|
{
|
|
NMDevice *device = NM_DEVICE (object);
|
|
DeviceCbInfo *info = (DeviceCbInfo *) user_data;
|
|
NmCli *nmc = info->nmc;
|
|
GError *error = NULL;
|
|
|
|
if (!nm_device_delete_finish (device, result, &error)) {
|
|
g_string_printf (nmc->return_text, _("Error: not all devices deleted."));
|
|
g_printerr (_("Error: Device '%s' (%s) deletion failed: %s\n"),
|
|
nm_device_get_iface (device),
|
|
nm_object_get_path (NM_OBJECT (device)),
|
|
error->message);
|
|
g_error_free (error);
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
device_cb_info_finish (info, device);
|
|
} else {
|
|
g_print (_("Device '%s' successfully removed.\n"),
|
|
nm_device_get_iface (device));
|
|
device_cb_info_finish (info, device);
|
|
}
|
|
}
|
|
|
|
static void
|
|
do_devices_delete (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
NMDevice *device;
|
|
DeviceCbInfo *info = NULL;
|
|
GSList *queue, *iter;
|
|
|
|
/* Set default timeout for delete operation. */
|
|
if (nmc->timeout == -1)
|
|
nmc->timeout = 10;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
queue = get_device_list (nmc, argc, argv);
|
|
if (!queue)
|
|
return;
|
|
if (nmc->complete)
|
|
goto out;
|
|
queue = g_slist_reverse (queue);
|
|
|
|
info = g_slice_new0 (DeviceCbInfo);
|
|
info->nmc = nmc;
|
|
if (nmc->timeout > 0)
|
|
info->timeout_id = g_timeout_add_seconds (nmc->timeout, device_op_timeout_cb, info);
|
|
|
|
nmc->nowait_flag = (nmc->timeout == 0);
|
|
nmc->should_wait++;
|
|
|
|
for (iter = queue; iter; iter = g_slist_next (iter)) {
|
|
device = iter->data;
|
|
|
|
info->queue = g_slist_prepend (info->queue, g_object_ref (device));
|
|
|
|
/* Now delete the device */
|
|
nm_device_delete_async (device, NULL, delete_device_cb, info);
|
|
}
|
|
|
|
out:
|
|
g_slist_free (queue);
|
|
}
|
|
|
|
static void
|
|
do_device_set (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
#define DEV_SET_AUTOCONNECT 0
|
|
#define DEV_SET_MANAGED 1
|
|
NMDevice *device = NULL;
|
|
int i;
|
|
struct {
|
|
int idx;
|
|
gboolean value;
|
|
} values[2] = {
|
|
[DEV_SET_AUTOCONNECT] = { -1 },
|
|
[DEV_SET_MANAGED] = { -1 },
|
|
};
|
|
gs_free_error GError *error = NULL;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
if (argc >= 1 && g_strcmp0 (*argv, "ifname") == 0)
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
|
|
device = get_device (nmc, &argc, &argv, &error);
|
|
if (!device) {
|
|
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
|
|
nmc->return_value = error->code;
|
|
return;
|
|
}
|
|
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: No property specified."));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
i = 0;
|
|
do {
|
|
gboolean flag;
|
|
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_strings (*argv, "managed", "autoconnect");
|
|
|
|
if (matches (*argv, "managed")) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: '%s' argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_bool (*argv);
|
|
if (!nmc_string_to_bool (*argv, &flag, &error)) {
|
|
g_string_printf (nmc->return_text, _("Error: 'managed': %s."),
|
|
error->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
values[DEV_SET_MANAGED].idx = ++i;
|
|
values[DEV_SET_MANAGED].value = flag;
|
|
}
|
|
else if (matches (*argv, "autoconnect")) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: '%s' argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_bool (*argv);
|
|
if (!nmc_string_to_bool (*argv, &flag, &error)) {
|
|
g_string_printf (nmc->return_text, _("Error: 'autoconnect': %s."),
|
|
error->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
values[DEV_SET_AUTOCONNECT].idx = ++i;
|
|
values[DEV_SET_AUTOCONNECT].value = flag;
|
|
}
|
|
else {
|
|
g_string_printf (nmc->return_text, _("Error: property '%s' is not known."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
} while (next_arg (nmc, &argc, &argv, NULL) == 0);
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
/* when multiple properties are specified, set them in the order as they
|
|
* are specified on the command line. */
|
|
if ( values[DEV_SET_AUTOCONNECT].idx >= 0
|
|
&& values[DEV_SET_MANAGED].idx >= 0
|
|
&& values[DEV_SET_MANAGED].idx < values[DEV_SET_AUTOCONNECT].idx) {
|
|
nm_device_set_managed (device, values[DEV_SET_MANAGED].value);
|
|
values[DEV_SET_MANAGED].idx = -1;
|
|
}
|
|
if (values[DEV_SET_AUTOCONNECT].idx >= 0)
|
|
nm_device_set_autoconnect (device, values[DEV_SET_AUTOCONNECT].value);
|
|
if (values[DEV_SET_MANAGED].idx >= 0)
|
|
nm_device_set_managed (device, values[DEV_SET_MANAGED].value);
|
|
}
|
|
|
|
static void
|
|
device_state (NMDevice *device, GParamSpec *pspec, NmCli *nmc)
|
|
{
|
|
NMDeviceState state = nm_device_get_state (device);
|
|
NMMetaColor color;
|
|
char *str;
|
|
|
|
color = nmc_device_state_to_color (state);
|
|
str = nmc_colorize (&nmc->nmc_config, color, "%s: %s\n",
|
|
nm_device_get_iface (device),
|
|
gettext (nmc_device_state_to_string (state)));
|
|
|
|
g_print ("%s", str);
|
|
g_free (str);
|
|
}
|
|
|
|
static void
|
|
device_ac (NMDevice *device, GParamSpec *pspec, NmCli *nmc)
|
|
{
|
|
NMActiveConnection *ac = nm_device_get_active_connection (device);
|
|
const char *id = ac ? nm_active_connection_get_id (ac) : NULL;
|
|
|
|
if (!id)
|
|
return;
|
|
|
|
g_print (_("%s: using connection '%s'\n"), nm_device_get_iface (device), id);
|
|
}
|
|
|
|
static void
|
|
device_watch (NmCli *nmc, NMDevice *device)
|
|
{
|
|
nmc->should_wait++;
|
|
g_signal_connect (device, "notify::" NM_DEVICE_STATE, G_CALLBACK (device_state), nmc);
|
|
g_signal_connect (device, "notify::" NM_DEVICE_ACTIVE_CONNECTION, G_CALLBACK (device_ac), nmc);
|
|
}
|
|
|
|
static void
|
|
device_unwatch (NmCli *nmc, NMDevice *device)
|
|
{
|
|
g_signal_handlers_disconnect_by_func (device, device_state, nmc);
|
|
if (g_signal_handlers_disconnect_by_func (device, device_ac, nmc))
|
|
nmc->should_wait--;
|
|
|
|
/* Terminate if all the watched devices disappeared. */
|
|
if (!nmc->should_wait)
|
|
quit ();
|
|
}
|
|
|
|
static void
|
|
device_added (NMClient *client, NMDevice *device, NmCli *nmc)
|
|
{
|
|
g_print (_("%s: device created\n"), nm_device_get_iface (device));
|
|
device_watch (nmc, NM_DEVICE (device));
|
|
}
|
|
|
|
static void
|
|
device_removed (NMClient *client, NMDevice *device, NmCli *nmc)
|
|
{
|
|
g_print (_("%s: device removed\n"), nm_device_get_iface (device));
|
|
device_unwatch (nmc, device);
|
|
}
|
|
|
|
static void
|
|
do_devices_monitor (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
if (argc == 0) {
|
|
/* No devices specified. Monitor all. */
|
|
const GPtrArray *devices = nm_client_get_devices (nmc->client);
|
|
int i;
|
|
|
|
for (i = 0; i < devices->len; i++)
|
|
device_watch (nmc, g_ptr_array_index (devices, i));
|
|
|
|
/* We'll watch the device additions too, never exit. */
|
|
nmc->should_wait++;
|
|
g_signal_connect (nmc->client, NM_CLIENT_DEVICE_ADDED, G_CALLBACK (device_added), nmc);
|
|
} else {
|
|
GSList *queue = get_device_list (nmc, argc, argv);
|
|
GSList *iter;
|
|
|
|
/* Monitor the specified devices. */
|
|
for (iter = queue; iter; iter = g_slist_next (iter))
|
|
device_watch (nmc, NM_DEVICE (iter->data));
|
|
g_slist_free (queue);
|
|
}
|
|
|
|
g_signal_connect (nmc->client, NM_CLIENT_DEVICE_REMOVED, G_CALLBACK (device_removed), nmc);
|
|
}
|
|
|
|
/*
|
|
* Find a Wi-Fi device with 'iface' in 'devices' array. If 'iface' is NULL,
|
|
* the first Wi-Fi device is returned. 'idx' parameter is updated to the point
|
|
* where the function finished so that the function can be called repeatedly
|
|
* to get next matching device.
|
|
* Returns: found device or NULL
|
|
*/
|
|
static NMDevice *
|
|
find_wifi_device_by_iface (NMDevice **devices, const char *iface, int *idx)
|
|
{
|
|
int i;
|
|
|
|
for (i = idx ? *idx : 0; devices[i]; i++) {
|
|
const char *dev_iface = nm_device_get_iface (devices[i]);
|
|
|
|
if (!NM_IS_DEVICE_WIFI (devices[i]))
|
|
continue;
|
|
|
|
if (iface) {
|
|
/* If a iface was specified then use it. */
|
|
if (g_strcmp0 (dev_iface, iface) == 0)
|
|
break;
|
|
} else {
|
|
/* Else return the first Wi-Fi device. */
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (idx)
|
|
*idx = i + 1;
|
|
return devices[i];
|
|
}
|
|
|
|
/*
|
|
* Find AP on 'device' according to 'bssid' and 'ssid' parameters.
|
|
* Returns: found AP or NULL
|
|
*/
|
|
static NMAccessPoint *
|
|
find_ap_on_device (NMDevice *device, const char *bssid, const char *ssid, gboolean complete)
|
|
{
|
|
const GPtrArray *aps;
|
|
NMAccessPoint *ap = NULL;
|
|
int i;
|
|
|
|
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
|
|
|
|
aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (device));
|
|
for (i = 0; i < aps->len; i++) {
|
|
NMAccessPoint *candidate_ap = g_ptr_array_index (aps, i);
|
|
|
|
if (bssid) {
|
|
const char *candidate_bssid = nm_access_point_get_bssid (candidate_ap);
|
|
|
|
if (!candidate_bssid)
|
|
continue;
|
|
|
|
/* Compare BSSIDs */
|
|
if (complete) {
|
|
if (g_str_has_prefix (candidate_bssid, bssid))
|
|
g_print ("%s\n", candidate_bssid);
|
|
} else if (strcmp (bssid, candidate_bssid) != 0)
|
|
continue;
|
|
}
|
|
|
|
if (ssid) {
|
|
/* Parameter is SSID */
|
|
GBytes *candidate_ssid;
|
|
char *ssid_tmp;
|
|
|
|
candidate_ssid = nm_access_point_get_ssid (candidate_ap);
|
|
if (!candidate_ssid)
|
|
continue;
|
|
|
|
ssid_tmp = nm_utils_ssid_to_utf8 (g_bytes_get_data (candidate_ssid, NULL),
|
|
g_bytes_get_size (candidate_ssid));
|
|
|
|
/* Compare SSIDs */
|
|
if (complete) {
|
|
if (g_str_has_prefix (ssid_tmp, ssid))
|
|
g_print ("%s\n", ssid_tmp);
|
|
} else if (strcmp (ssid, ssid_tmp) != 0) {
|
|
g_free (ssid_tmp);
|
|
continue;
|
|
}
|
|
g_free (ssid_tmp);
|
|
}
|
|
|
|
if (complete)
|
|
continue;
|
|
|
|
ap = candidate_ap;
|
|
break;
|
|
}
|
|
|
|
return ap;
|
|
}
|
|
|
|
static void
|
|
show_access_point_info (NMDeviceWifi *wifi, NmCli *nmc, NmcOutputData *out)
|
|
{
|
|
NMAccessPoint *active_ap = NULL;
|
|
const char *active_bssid = NULL;
|
|
NmcOutputField *arr;
|
|
|
|
if (nm_device_get_state (NM_DEVICE (wifi)) == NM_DEVICE_STATE_ACTIVATED) {
|
|
active_ap = nm_device_wifi_get_active_access_point (wifi);
|
|
active_bssid = active_ap ? nm_access_point_get_bssid (active_ap) : NULL;
|
|
}
|
|
|
|
arr = nmc_dup_fields_array ((const NMMetaAbstractInfo *const*) nmc_fields_dev_wifi_list,
|
|
NMC_OF_FLAG_MAIN_HEADER_ADD | NMC_OF_FLAG_FIELD_NAMES);
|
|
g_ptr_array_add (out->output_data, arr);
|
|
|
|
{
|
|
gs_unref_ptrarray GPtrArray *aps = NULL;
|
|
APInfo info = {
|
|
.nmc = nmc,
|
|
.index = 1,
|
|
.output_flags = 0,
|
|
.active_bssid = active_bssid,
|
|
.device = nm_device_get_iface (NM_DEVICE (wifi)),
|
|
.output_data = out->output_data,
|
|
};
|
|
|
|
aps = sort_access_points (nm_device_wifi_get_access_points (wifi));
|
|
g_ptr_array_foreach (aps, fill_output_access_point, &info);
|
|
}
|
|
|
|
print_data_prepare_width (out->output_data);
|
|
}
|
|
|
|
static void
|
|
wifi_print_aps (NMDeviceWifi *wifi,
|
|
NmCli *nmc,
|
|
GArray *_out_indices,
|
|
const NMMetaAbstractInfo *const*tmpl,
|
|
const char *bssid_user,
|
|
gboolean *bssid_found)
|
|
{
|
|
NMAccessPoint *ap = NULL;
|
|
const GPtrArray *aps;
|
|
APInfo *info;
|
|
guint i;
|
|
NmcOutputField *arr;
|
|
const char *base_hdr = _("Wi-Fi scan list");
|
|
NMC_OUTPUT_DATA_DEFINE_SCOPED (out);
|
|
gs_free char *header_name = NULL;
|
|
static gboolean empty_line = FALSE;
|
|
|
|
if (empty_line)
|
|
g_print ("\n"); /* Empty line between devices' APs */
|
|
|
|
/* Main header name */
|
|
header_name = construct_header_name (base_hdr, nm_device_get_iface (NM_DEVICE (wifi)));
|
|
|
|
out_indices = g_array_ref (_out_indices);
|
|
|
|
if (bssid_user) {
|
|
/* Specific AP requested - list only that */
|
|
aps = nm_device_wifi_get_access_points (wifi);
|
|
for (i = 0; i < aps->len; i++) {
|
|
NMAccessPoint *candidate_ap = g_ptr_array_index (aps, i);
|
|
|
|
if (nm_utils_hwaddr_matches (bssid_user,
|
|
-1,
|
|
nm_access_point_get_bssid (candidate_ap),
|
|
-1))
|
|
ap = candidate_ap;
|
|
}
|
|
if (ap) {
|
|
/* Add headers (field names) */
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_MAIN_HEADER_ADD | NMC_OF_FLAG_FIELD_NAMES);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
info = g_malloc0 (sizeof (APInfo));
|
|
info->nmc = nmc;
|
|
info->index = 1;
|
|
info->output_flags = 0;
|
|
info->active_bssid = NULL;
|
|
info->device = nm_device_get_iface (NM_DEVICE (wifi));
|
|
info->output_data = out.output_data;
|
|
|
|
fill_output_access_point (ap, info);
|
|
|
|
print_data_prepare_width (out.output_data);
|
|
print_data (&nmc->nmc_config, &nmc->pager_data, out_indices, header_name, 0, &out);
|
|
g_free (info);
|
|
|
|
*bssid_found = TRUE;
|
|
empty_line = TRUE;
|
|
}
|
|
} else {
|
|
show_access_point_info (wifi, nmc, &out);
|
|
print_data (&nmc->nmc_config, &nmc->pager_data, out_indices, header_name, 0, &out);
|
|
empty_line = TRUE;
|
|
}
|
|
}
|
|
|
|
static gint64
|
|
_device_wifi_get_last_scan (NMDeviceWifi *wifi)
|
|
{
|
|
gint64 timestamp;
|
|
|
|
timestamp = nm_device_wifi_get_last_scan (wifi);
|
|
if (timestamp == -1)
|
|
return G_MININT64;
|
|
return timestamp;
|
|
}
|
|
|
|
typedef struct {
|
|
NmCli *nmc;
|
|
NMDevice **devices;
|
|
const NMMetaAbstractInfo *const *tmpl;
|
|
char *bssid_user;
|
|
GArray *out_indices;
|
|
gint64 rescan_cutoff_msec;
|
|
guint pending;
|
|
} ScanInfo;
|
|
|
|
typedef struct {
|
|
ScanInfo *scan_info;
|
|
NMDeviceWifi *wifi;
|
|
gulong last_scan_id;
|
|
guint timeout_id;
|
|
GCancellable *scan_cancellable;
|
|
} WifiListData;
|
|
|
|
static void
|
|
wifi_list_finish (WifiListData *wifi_list_data,
|
|
gboolean force_finished)
|
|
{
|
|
ScanInfo *scan_info = wifi_list_data->scan_info;
|
|
NmCli *nmc = scan_info->nmc;
|
|
gboolean bssid_found = FALSE;
|
|
guint i;
|
|
|
|
if ( !force_finished
|
|
&& scan_info->rescan_cutoff_msec > _device_wifi_get_last_scan (wifi_list_data->wifi)) {
|
|
/* wait longer... */
|
|
return;
|
|
}
|
|
|
|
nm_clear_g_signal_handler (wifi_list_data->wifi, &wifi_list_data->last_scan_id);
|
|
nm_clear_g_source (&wifi_list_data->timeout_id);
|
|
nm_clear_g_cancellable (&wifi_list_data->scan_cancellable);
|
|
nm_g_slice_free (wifi_list_data);
|
|
|
|
if (--scan_info->pending > 0)
|
|
return;
|
|
|
|
for (i = 0; scan_info->devices[i]; i++) {
|
|
wifi_print_aps (NM_DEVICE_WIFI (scan_info->devices[i]),
|
|
nmc,
|
|
scan_info->out_indices,
|
|
scan_info->tmpl,
|
|
scan_info->bssid_user,
|
|
&bssid_found);
|
|
}
|
|
|
|
if ( scan_info->bssid_user
|
|
&& !bssid_found) {
|
|
nmc->return_value = NMC_RESULT_ERROR_NOT_FOUND;
|
|
g_string_printf (nmc->return_text, _("Error: Access point with bssid '%s' not found."),
|
|
scan_info->bssid_user);
|
|
}
|
|
|
|
for (i = 0; scan_info->devices[i]; i++)
|
|
g_object_unref (scan_info->devices[i]);
|
|
g_free (scan_info->devices);
|
|
g_array_unref (scan_info->out_indices);
|
|
g_free (scan_info->bssid_user);
|
|
nm_g_slice_free (scan_info);
|
|
|
|
nmc->should_wait--;
|
|
g_main_loop_quit (loop);
|
|
}
|
|
|
|
static void
|
|
wifi_last_scan_updated (GObject *gobject, GParamSpec *pspec, gpointer user_data)
|
|
{
|
|
wifi_list_finish (user_data, FALSE);
|
|
}
|
|
|
|
static void wifi_list_rescan_cb (GObject *source_object, GAsyncResult *res, gpointer user_data);
|
|
|
|
static void
|
|
wifi_list_rescan_retry_cb (gpointer user_data,
|
|
GCancellable *cancellable)
|
|
{
|
|
WifiListData *wifi_list_data;
|
|
|
|
if (g_cancellable_is_cancelled (cancellable))
|
|
return;
|
|
|
|
wifi_list_data = user_data;
|
|
nm_device_wifi_request_scan_async (wifi_list_data->wifi,
|
|
wifi_list_data->scan_cancellable,
|
|
wifi_list_rescan_cb,
|
|
wifi_list_data);
|
|
}
|
|
|
|
static void
|
|
wifi_list_rescan_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
|
|
{
|
|
NMDeviceWifi *wifi = NM_DEVICE_WIFI (source_object);
|
|
gs_free_error GError *error = NULL;
|
|
WifiListData *wifi_list_data;
|
|
gboolean force_finished;
|
|
gboolean done;
|
|
|
|
nm_device_wifi_request_scan_finish (wifi, res, &error);
|
|
if (nm_utils_error_is_cancelled (error))
|
|
return;
|
|
|
|
wifi_list_data = user_data;
|
|
|
|
if (g_error_matches (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_NOT_ALLOWED)) {
|
|
if (nm_device_get_state (NM_DEVICE (wifi)) < NM_DEVICE_STATE_DISCONNECTED) {
|
|
/* the device is either unmanaged or unavailable.
|
|
*
|
|
* If it's unmanaged, we don't expect any scan result and are done.
|
|
* If it's unavailable, that usually means that we wait for wpa_supplicant
|
|
* to start. In that case, also quit (without scan results). */
|
|
force_finished = TRUE;
|
|
done = TRUE;
|
|
} else {
|
|
/* This likely means that scanning is already in progress. There's
|
|
* a good chance we'll get updated results soon; wait for them.
|
|
*
|
|
* But also, NetworkManager ratelimits (and rejects requests). That
|
|
* means, possibly we were just ratelimited, so waiting will not lead
|
|
* to a new scan result. Instead, repeatedly ask new scans... */
|
|
nm_utils_invoke_on_timeout (1000,
|
|
wifi_list_data->scan_cancellable,
|
|
wifi_list_rescan_retry_cb,
|
|
wifi_list_data);
|
|
force_finished = FALSE;
|
|
done = FALSE;
|
|
}
|
|
} else if (error) {
|
|
force_finished = TRUE;
|
|
done = TRUE;
|
|
} else {
|
|
force_finished = FALSE;
|
|
done = TRUE;
|
|
}
|
|
|
|
if (done)
|
|
g_clear_object (&wifi_list_data->scan_cancellable);
|
|
wifi_list_finish (wifi_list_data, force_finished);
|
|
}
|
|
|
|
static gboolean
|
|
wifi_list_scan_timeout (gpointer user_data)
|
|
{
|
|
WifiListData *wifi_list_data = user_data;
|
|
|
|
wifi_list_data->timeout_id = 0;
|
|
wifi_list_finish (user_data, TRUE);
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
|
|
static void
|
|
complete_aps (NMDevice **devices, const char *ifname,
|
|
const char *bssid_prefix, const char *ssid_prefix)
|
|
{
|
|
int devices_idx = 0;
|
|
NMDevice *device;
|
|
|
|
while ((device = find_wifi_device_by_iface (devices, ifname, &devices_idx)))
|
|
find_ap_on_device (device, bssid_prefix, ssid_prefix, TRUE);
|
|
}
|
|
|
|
void
|
|
nmc_complete_bssid (NMClient *client, const char *ifname, const char *bssid_prefix)
|
|
{
|
|
gs_free NMDevice **devices = NULL;
|
|
|
|
devices = nmc_get_devices_sorted (client);
|
|
complete_aps (devices, ifname, bssid_prefix, NULL);
|
|
}
|
|
|
|
static void
|
|
do_device_wifi_list (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
GError *error = NULL;
|
|
NMDevice *device = NULL;
|
|
const char *ifname = NULL;
|
|
const char *bssid_user = NULL;
|
|
const char *rescan = NULL;
|
|
gs_free NMDevice **devices = NULL;
|
|
const char *fields_str = NULL;
|
|
const NMMetaAbstractInfo *const*tmpl;
|
|
gs_unref_array GArray *out_indices = NULL;
|
|
int option;
|
|
gint64 rescan_cutoff_msec;
|
|
ScanInfo *scan_info = NULL;
|
|
gboolean ifname_handled;
|
|
NMDevice *ifname_handled_candidate;
|
|
guint i, j;
|
|
|
|
devices = nmc_get_devices_sorted (nmc->client);
|
|
|
|
while ((option = next_arg (nmc, &argc, &argv, "ifname", "hwaddr", "bssid", "--rescan", NULL)) > 0) {
|
|
switch (option) {
|
|
case 1: /* ifname */
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
ifname = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
complete_device (devices, ifname, TRUE);
|
|
break;
|
|
case 2: /* hwaddr is deprecated and will be removed later */
|
|
case 3: /* bssid */
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
bssid_user = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
complete_aps (devices, NULL, bssid_user, NULL);
|
|
break;
|
|
case 4: /* --rescan */
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
rescan = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_strings (rescan, "auto", "no", "yes");
|
|
break;
|
|
default:
|
|
nm_assert_not_reached();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
if (!nmc->required_fields || g_ascii_strcasecmp (nmc->required_fields, "common") == 0)
|
|
fields_str = NMC_FIELDS_DEV_WIFI_LIST_COMMON;
|
|
else if (!nmc->required_fields || g_ascii_strcasecmp (nmc->required_fields, "all") == 0) {
|
|
} else
|
|
fields_str = nmc->required_fields;
|
|
|
|
tmpl = (const NMMetaAbstractInfo *const*) nmc_fields_dev_wifi_list;
|
|
out_indices = parse_output_fields (fields_str, tmpl, FALSE, NULL, &error);
|
|
|
|
if (error) {
|
|
g_string_printf (nmc->return_text, _("Error: 'device wifi': %s"), error->message);
|
|
g_error_free (error);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
if (argc) {
|
|
g_string_printf (nmc->return_text, _("Error: invalid extra argument '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
if (NM_IN_STRSET (rescan, NULL, "auto"))
|
|
rescan_cutoff_msec = nm_utils_get_timestamp_msec () - (30 * NM_UTILS_MSEC_PER_SEC);
|
|
else if (nm_streq (rescan, "no"))
|
|
rescan_cutoff_msec = G_MININT64;
|
|
else if (nm_streq (rescan, "yes"))
|
|
rescan_cutoff_msec = nm_utils_get_timestamp_msec ();
|
|
else {
|
|
g_string_printf (nmc->return_text, _("Error: invalid rescan argument: '%s' not among [auto, no, yes]"), rescan);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
ifname_handled = (ifname == NULL);
|
|
ifname_handled_candidate = NULL;
|
|
|
|
j = 0;
|
|
for (i = 0; devices[i]; i++) {
|
|
const char *dev_iface;
|
|
|
|
device = devices[i];
|
|
dev_iface = nm_device_get_iface (device);
|
|
|
|
if (ifname) {
|
|
if (!nm_streq0 (ifname, dev_iface))
|
|
continue;
|
|
if (!NM_IS_DEVICE_WIFI (device)) {
|
|
if ( nm_device_get_device_type (device) == NM_DEVICE_TYPE_GENERIC
|
|
&& nm_streq0 (nm_device_get_type_description (device), "wifi"))
|
|
ifname_handled_candidate = device;
|
|
else if (!ifname_handled_candidate)
|
|
ifname_handled_candidate = device;
|
|
continue;
|
|
}
|
|
ifname_handled = TRUE;
|
|
} else {
|
|
if (!NM_IS_DEVICE_WIFI (device))
|
|
continue;
|
|
}
|
|
|
|
devices[j++] = device;
|
|
}
|
|
devices[j] = NULL;
|
|
|
|
if (!ifname_handled) {
|
|
if (!ifname_handled_candidate) {
|
|
g_string_printf (nmc->return_text,
|
|
_("Error: Device '%s' not found."),
|
|
ifname);
|
|
} else if ( nm_device_get_device_type (ifname_handled_candidate) == NM_DEVICE_TYPE_GENERIC
|
|
&& nm_streq0 (nm_device_get_type_description (ifname_handled_candidate), "wifi")) {
|
|
g_string_printf (nmc->return_text,
|
|
_("Error: Device '%s' was not recognized as a Wi-Fi device, check NetworkManager Wi-Fi plugin."),
|
|
ifname);
|
|
} else {
|
|
g_string_printf (nmc->return_text,
|
|
_("Error: Device '%s' is not a Wi-Fi device."),
|
|
ifname);
|
|
}
|
|
nmc->return_value = NMC_RESULT_ERROR_NOT_FOUND;
|
|
return;
|
|
}
|
|
|
|
if (!devices[0]) {
|
|
if (bssid_user) {
|
|
nmc->return_value = NMC_RESULT_ERROR_NOT_FOUND;
|
|
g_string_printf (nmc->return_text, _("Error: Access point with bssid '%s' not found."),
|
|
bssid_user);
|
|
nmc->return_value = NMC_RESULT_ERROR_NOT_FOUND;
|
|
}
|
|
return;
|
|
}
|
|
|
|
scan_info = g_slice_new (ScanInfo);
|
|
*scan_info = (ScanInfo) {
|
|
.out_indices = g_array_ref (out_indices),
|
|
.tmpl = tmpl,
|
|
.bssid_user = g_strdup (bssid_user),
|
|
.nmc = nmc,
|
|
.rescan_cutoff_msec = rescan_cutoff_msec,
|
|
};
|
|
|
|
for (i = 0; devices[i]; i++)
|
|
g_object_ref (devices[i]);
|
|
|
|
for (i = 0; devices[i]; i++) {
|
|
NMDeviceWifi *wifi = NM_DEVICE_WIFI (devices[i]);
|
|
WifiListData *wifi_list_data;
|
|
int timeout_msec;
|
|
|
|
if (rescan_cutoff_msec <= _device_wifi_get_last_scan (wifi))
|
|
timeout_msec = 0;
|
|
else
|
|
timeout_msec = 15000;
|
|
|
|
wifi_list_data = g_slice_new (WifiListData);
|
|
*wifi_list_data = (WifiListData) {
|
|
.wifi = wifi,
|
|
.scan_info = scan_info,
|
|
.timeout_id = g_timeout_add (timeout_msec,
|
|
wifi_list_scan_timeout,
|
|
wifi_list_data),
|
|
};
|
|
|
|
scan_info->pending++;
|
|
|
|
if (timeout_msec > 0) {
|
|
wifi_list_data->last_scan_id = g_signal_connect (wifi,
|
|
"notify::" NM_DEVICE_WIFI_LAST_SCAN,
|
|
G_CALLBACK (wifi_last_scan_updated),
|
|
wifi_list_data),
|
|
wifi_list_data->scan_cancellable = g_cancellable_new (),
|
|
nm_device_wifi_request_scan_async (wifi, wifi_list_data->scan_cancellable, wifi_list_rescan_cb, wifi_list_data);
|
|
}
|
|
}
|
|
|
|
scan_info->devices = g_steal_pointer (&devices);
|
|
|
|
nmc->should_wait++;
|
|
}
|
|
|
|
static void
|
|
activate_update2_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
|
|
{
|
|
NMRemoteConnection *remote_con = NM_REMOTE_CONNECTION (source_object);
|
|
AddAndActivateInfo *info = user_data;
|
|
NmCli *nmc = info->nmc;
|
|
gs_unref_variant GVariant *ret = NULL;
|
|
GError *error = NULL;
|
|
|
|
ret = nm_remote_connection_update2_finish (remote_con, res, &error);
|
|
|
|
if (!ret) {
|
|
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
g_error_free (error);
|
|
quit ();
|
|
add_and_activate_info_free (info);
|
|
return;
|
|
}
|
|
|
|
nm_client_activate_connection_async (nmc->client,
|
|
NM_CONNECTION (remote_con),
|
|
info->device,
|
|
info->specific_object,
|
|
NULL,
|
|
add_and_activate_cb,
|
|
info);
|
|
}
|
|
|
|
static void
|
|
save_and_activate_connection (NmCli *nmc,
|
|
NMDevice *device,
|
|
NMConnection *connection,
|
|
gboolean hotspot,
|
|
const char *specific_object)
|
|
{
|
|
AddAndActivateInfo *info;
|
|
|
|
info = add_and_activate_info_new (nmc, device, hotspot,
|
|
!NM_IS_REMOTE_CONNECTION (connection),
|
|
specific_object);
|
|
|
|
if (NM_IS_REMOTE_CONNECTION (connection)) {
|
|
nm_remote_connection_update2 (NM_REMOTE_CONNECTION (connection),
|
|
nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL),
|
|
NM_SETTINGS_UPDATE2_FLAG_BLOCK_AUTOCONNECT,
|
|
NULL,
|
|
NULL,
|
|
activate_update2_cb,
|
|
info);
|
|
} else {
|
|
nm_client_add_and_activate_connection_async (nmc->client,
|
|
connection,
|
|
info->device,
|
|
info->specific_object,
|
|
NULL,
|
|
add_and_activate_cb,
|
|
info);
|
|
}
|
|
}
|
|
|
|
static void
|
|
do_device_wifi_connect (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
NMDevice *device = NULL;
|
|
NMAccessPoint *ap = NULL;
|
|
NM80211ApFlags ap_flags;
|
|
NM80211ApSecurityFlags ap_wpa_flags;
|
|
NM80211ApSecurityFlags ap_rsn_flags;
|
|
gs_unref_object NMConnection *connection = NULL;
|
|
NMSettingConnection *s_con;
|
|
NMSettingWireless *s_wifi;
|
|
const char *param_user = NULL;
|
|
const char *ifname = NULL;
|
|
const char *bssid = NULL;
|
|
const char *password = NULL;
|
|
const char *con_name = NULL;
|
|
gboolean private = FALSE;
|
|
gboolean hidden = FALSE;
|
|
gboolean wep_passphrase = FALSE;
|
|
GByteArray *bssid1_arr = NULL;
|
|
GByteArray *bssid2_arr = NULL;
|
|
gs_free NMDevice **devices = NULL;
|
|
int devices_idx;
|
|
char *ssid_ask = NULL;
|
|
char *passwd_ask = NULL;
|
|
const GPtrArray *avail_cons;
|
|
gboolean name_match = FALSE;
|
|
int i;
|
|
|
|
/* Set default timeout waiting for operation completion. */
|
|
if (nmc->timeout == -1)
|
|
nmc->timeout = 90;
|
|
|
|
devices = nmc_get_devices_sorted (nmc->client);
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
/* Get the first compulsory argument (SSID or BSSID) */
|
|
if (argc > 0) {
|
|
param_user = *argv;
|
|
bssid1_arr = nm_utils_hwaddr_atoba (param_user, ETH_ALEN);
|
|
|
|
if (argc == 1 && nmc->complete)
|
|
complete_aps (devices, NULL, param_user, param_user);
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
} else {
|
|
/* nmc_do_cmd() should not call this with argc=0. */
|
|
nm_assert (!nmc->complete);
|
|
|
|
if (nmc->ask) {
|
|
ssid_ask = nmc_readline (&nmc->nmc_config, _("SSID or BSSID: "));
|
|
param_user = ssid_ask ?: "";
|
|
bssid1_arr = nm_utils_hwaddr_atoba (param_user, ETH_ALEN);
|
|
}
|
|
if (!ssid_ask) {
|
|
g_string_printf (nmc->return_text, _("Error: SSID or BSSID are missing."));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
}
|
|
|
|
/* Get the rest of the parameters */
|
|
while (argc > 0) {
|
|
if (argc == 1 && nmc->complete) {
|
|
nmc_complete_strings (*argv, "ifname", "bssid", "password", "wep-key-type",
|
|
"name", "private", "hidden");
|
|
}
|
|
|
|
if (strcmp (*argv, "ifname") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
ifname = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
complete_device (devices, ifname, TRUE);
|
|
} else if (strcmp (*argv, "bssid") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
bssid = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
complete_aps (devices, NULL, bssid, NULL);
|
|
bssid2_arr = nm_utils_hwaddr_atoba (bssid, ETH_ALEN);
|
|
if (!bssid2_arr) {
|
|
g_string_printf (nmc->return_text, _("Error: bssid argument value '%s' is not a valid BSSID."),
|
|
bssid);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
} else if (strcmp (*argv, "password") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
password = *argv;
|
|
} else if (strcmp (*argv, "wep-key-type") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_strings (*argv, "key", "phrase");
|
|
if (strcmp (*argv, "key") == 0)
|
|
wep_passphrase = FALSE;
|
|
else if (strcmp (*argv, "phrase") == 0)
|
|
wep_passphrase = TRUE;
|
|
else {
|
|
g_string_printf (nmc->return_text,
|
|
_("Error: wep-key-type argument value '%s' is invalid, use 'key' or 'phrase'."),
|
|
*argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
} else if (strcmp (*argv, "name") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
con_name = *argv;
|
|
} else if (strcmp (*argv, "private") == 0) {
|
|
GError *err_tmp = NULL;
|
|
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_bool (*argv);
|
|
if (!nmc_string_to_bool (*argv, &private, &err_tmp)) {
|
|
g_string_printf (nmc->return_text, _("Error: %s: %s."), *(argv-1), err_tmp->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
g_clear_error (&err_tmp);
|
|
goto finish;
|
|
}
|
|
} else if (strcmp (*argv, "hidden") == 0) {
|
|
GError *err_tmp = NULL;
|
|
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_bool (*argv);
|
|
if (!nmc_string_to_bool (*argv, &hidden, &err_tmp)) {
|
|
g_string_printf (nmc->return_text, _("Error: %s: %s."), *(argv-1), err_tmp->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
g_clear_error (&err_tmp);
|
|
goto finish;
|
|
}
|
|
} else if (!nmc->complete) {
|
|
g_string_printf (nmc->return_text, _("Error: invalid extra argument '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
}
|
|
|
|
if (nmc->complete)
|
|
goto finish;
|
|
|
|
/* Verify SSID/BSSID parameters */
|
|
if (bssid1_arr && bssid2_arr && memcmp (bssid1_arr->data, bssid2_arr->data, ETH_ALEN)) {
|
|
g_string_printf (nmc->return_text, _("Error: BSSID to connect to (%s) differs from bssid argument (%s)."),
|
|
param_user, bssid);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
if (!bssid1_arr && strlen (param_user) > 32) {
|
|
g_string_printf (nmc->return_text, _("Error: Parameter '%s' is neither SSID nor BSSID."), param_user);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
goto finish;
|
|
}
|
|
|
|
/* Find a device to activate the connection on */
|
|
devices_idx = 0;
|
|
device = find_wifi_device_by_iface (devices, ifname, &devices_idx);
|
|
|
|
if (!device) {
|
|
if (ifname)
|
|
g_string_printf (nmc->return_text, _("Error: Device '%s' is not a Wi-Fi device."), ifname);
|
|
else
|
|
g_string_printf (nmc->return_text, _("Error: No Wi-Fi device found."));
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
goto finish;
|
|
}
|
|
|
|
/* For hidden SSID first scan it so that NM learns about the AP */
|
|
if (hidden) {
|
|
GVariantBuilder builder, array_builder;
|
|
GVariant *options;
|
|
GError *scan_err = NULL;
|
|
|
|
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
|
|
g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aay"));
|
|
g_variant_builder_add (&array_builder, "@ay",
|
|
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, param_user, strlen (param_user), 1));
|
|
g_variant_builder_add (&builder, "{sv}", "ssids", g_variant_builder_end (&array_builder));
|
|
options = g_variant_builder_end (&builder);
|
|
|
|
nm_device_wifi_request_scan_options (NM_DEVICE_WIFI (device), options, NULL, &scan_err);
|
|
if (scan_err) {
|
|
g_string_printf (nmc->return_text, _("Error: Failed to scan hidden SSID: %s."),
|
|
scan_err->message);
|
|
g_clear_error (&scan_err);
|
|
nmc->return_value = NMC_RESULT_ERROR_NOT_FOUND;
|
|
goto finish;
|
|
}
|
|
}
|
|
|
|
/* Find an AP to connect to */
|
|
ap = find_ap_on_device (device, bssid1_arr ? param_user : bssid,
|
|
bssid1_arr ? NULL : param_user, FALSE);
|
|
if (!ap && !ifname) {
|
|
NMDevice *dev;
|
|
|
|
/* AP not found, ifname was not specified, so try finding the AP on another device. */
|
|
while ((dev = find_wifi_device_by_iface (devices, NULL, &devices_idx)) != NULL) {
|
|
ap = find_ap_on_device (dev, bssid1_arr ? param_user : bssid,
|
|
bssid1_arr ? NULL : param_user, FALSE);
|
|
if (ap) {
|
|
device = dev;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!ap) {
|
|
if (!bssid1_arr)
|
|
g_string_printf (nmc->return_text, _("Error: No network with SSID '%s' found."), param_user);
|
|
else
|
|
g_string_printf (nmc->return_text, _("Error: No access point with BSSID '%s' found."), param_user);
|
|
nmc->return_value = NMC_RESULT_ERROR_NOT_FOUND;
|
|
goto finish;
|
|
}
|
|
|
|
avail_cons = nm_device_get_available_connections (device);
|
|
for (i = 0; i < avail_cons->len; i++) {
|
|
NMConnection *avail_con = g_ptr_array_index (avail_cons, i);
|
|
const char *id = nm_connection_get_id (NM_CONNECTION (avail_con));
|
|
|
|
if (con_name) {
|
|
if (!id || strcmp (id, con_name))
|
|
continue;
|
|
|
|
name_match = TRUE;
|
|
}
|
|
|
|
if (nm_access_point_connection_valid (ap, NM_CONNECTION (avail_con))) {
|
|
/* ap has been checked against bssid1, bssid2 and the ssid
|
|
* and now avail_con has been checked against ap.
|
|
*/
|
|
connection = g_object_ref (avail_con);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (name_match && !connection) {
|
|
g_string_printf (nmc->return_text, _("Error: Connection '%s' exists but properties don't match."), con_name);
|
|
nmc->return_value = NMC_RESULT_ERROR_NOT_FOUND;
|
|
goto finish;
|
|
}
|
|
|
|
if (!connection) {
|
|
/* If there are some connection data from user, create a connection and
|
|
* fill them into proper settings. */
|
|
if (con_name || private || bssid2_arr || hidden)
|
|
connection = nm_simple_connection_new ();
|
|
|
|
if (con_name || private) {
|
|
s_con = (NMSettingConnection *) nm_setting_connection_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_con));
|
|
|
|
/* Set user provided connection name */
|
|
if (con_name)
|
|
g_object_set (s_con, NM_SETTING_CONNECTION_ID, con_name, NULL);
|
|
|
|
/* Connection will only be visible to this user when 'private' is specified */
|
|
if (private)
|
|
nm_setting_connection_add_permission (s_con, "user", g_get_user_name (), NULL);
|
|
}
|
|
if (bssid2_arr || hidden) {
|
|
s_wifi = (NMSettingWireless *) nm_setting_wireless_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_wifi));
|
|
|
|
/* 'bssid' parameter is used to restrict the connection only to the BSSID */
|
|
if (bssid2_arr)
|
|
g_object_set (s_wifi, NM_SETTING_WIRELESS_BSSID, bssid2_arr, NULL);
|
|
|
|
/* 'hidden' parameter is used to indicate that SSID is not broadcasted */
|
|
if (hidden) {
|
|
GBytes *ssid = g_bytes_new (param_user, strlen (param_user));
|
|
|
|
g_object_set (s_wifi,
|
|
NM_SETTING_WIRELESS_SSID, ssid,
|
|
NM_SETTING_WIRELESS_HIDDEN, hidden,
|
|
NULL);
|
|
g_bytes_unref (ssid);
|
|
|
|
/* Warn when the provided AP identifier looks like BSSID instead of SSID */
|
|
if (bssid1_arr)
|
|
g_printerr (_("Warning: '%s' should be SSID for hidden APs; but it looks like a BSSID.\n"),
|
|
param_user);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* handle password */
|
|
ap_flags = nm_access_point_get_flags (ap);
|
|
ap_wpa_flags = nm_access_point_get_wpa_flags (ap);
|
|
ap_rsn_flags = nm_access_point_get_rsn_flags (ap);
|
|
|
|
/* Set password for WEP or WPA-PSK. */
|
|
if ( (ap_flags & NM_802_11_AP_FLAGS_PRIVACY)
|
|
|| (ap_wpa_flags != NM_802_11_AP_SEC_NONE && !(ap_wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_OWE))
|
|
|| (ap_rsn_flags != NM_802_11_AP_SEC_NONE && !(ap_rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_OWE))) {
|
|
const char *con_password = NULL;
|
|
NMSettingWirelessSecurity *s_wsec = NULL;
|
|
|
|
if (connection) {
|
|
s_wsec = nm_connection_get_setting_wireless_security (connection);
|
|
if (s_wsec) {
|
|
if (ap_wpa_flags == NM_802_11_AP_SEC_NONE && ap_rsn_flags == NM_802_11_AP_SEC_NONE) {
|
|
/* WEP */
|
|
con_password = nm_setting_wireless_security_get_wep_key (s_wsec, 0);
|
|
} else if ( (ap_wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK)
|
|
|| (ap_rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK)
|
|
|| (ap_rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_SAE)) {
|
|
/* WPA PSK */
|
|
con_password = nm_setting_wireless_security_get_psk (s_wsec);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Ask for missing password when one is expected and '--ask' is used */
|
|
if (!password && !con_password && nmc->ask) {
|
|
password = passwd_ask = nmc_readline_echo (&nmc->nmc_config,
|
|
nmc->nmc_config.show_secrets,
|
|
_("Password: "));
|
|
}
|
|
|
|
if (password) {
|
|
if (!connection)
|
|
connection = nm_simple_connection_new ();
|
|
if (!s_wsec) {
|
|
s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_wsec));
|
|
}
|
|
|
|
if (ap_wpa_flags == NM_802_11_AP_SEC_NONE && ap_rsn_flags == NM_802_11_AP_SEC_NONE) {
|
|
/* WEP */
|
|
nm_setting_wireless_security_set_wep_key (s_wsec, 0, password);
|
|
g_object_set (G_OBJECT (s_wsec),
|
|
NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,
|
|
wep_passphrase ? NM_WEP_KEY_TYPE_PASSPHRASE: NM_WEP_KEY_TYPE_KEY,
|
|
NULL);
|
|
} else if ( (ap_wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK)
|
|
|| (ap_rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK)
|
|
|| (ap_rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_SAE)) {
|
|
/* WPA PSK */
|
|
g_object_set (s_wsec, NM_SETTING_WIRELESS_SECURITY_PSK, password, NULL);
|
|
}
|
|
}
|
|
}
|
|
// FIXME: Creating WPA-Enterprise connections is not supported yet.
|
|
// We are not able to determine and fill all the parameters for
|
|
// 802.1X authentication automatically without user providing
|
|
// the data. Adding nmcli options for the 8021x setting would
|
|
// clutter the command. However, that could be solved later by
|
|
// implementing add/edit connections support for nmcli.
|
|
|
|
/* nowait_flag indicates user input. should_wait says whether quit in start().
|
|
* We have to delay exit after add_and_activate_cb() is called, even if
|
|
* the user doesn't want to wait, in order to give NM time to check our
|
|
* permissions. */
|
|
nmc->nowait_flag = (nmc->timeout == 0);
|
|
nmc->should_wait++;
|
|
|
|
save_and_activate_connection (nmc, device, connection, FALSE,
|
|
nm_object_get_path (NM_OBJECT (ap)));
|
|
|
|
finish:
|
|
if (bssid1_arr)
|
|
g_byte_array_free (bssid1_arr, TRUE);
|
|
if (bssid2_arr)
|
|
g_byte_array_free (bssid2_arr, TRUE);
|
|
g_free (ssid_ask);
|
|
nm_free_secret (passwd_ask);
|
|
}
|
|
|
|
static GBytes *
|
|
generate_ssid_for_hotspot (void)
|
|
{
|
|
GBytes *ssid_bytes;
|
|
char *ssid = NULL;
|
|
|
|
ssid = g_strdup_printf ("Hotspot-%s", g_get_host_name ());
|
|
if (strlen (ssid) > 32)
|
|
ssid[32] = '\0';
|
|
ssid_bytes = g_bytes_new (ssid, strlen (ssid));
|
|
g_free (ssid);
|
|
|
|
return ssid_bytes;
|
|
}
|
|
|
|
#define WPA_PASSKEY_SIZE 8
|
|
static void
|
|
generate_wpa_key (char *key, size_t len)
|
|
{
|
|
guint i;
|
|
|
|
g_return_if_fail (key);
|
|
g_return_if_fail (len > WPA_PASSKEY_SIZE);
|
|
|
|
/* generate a 8-chars ASCII WPA key */
|
|
for (i = 0; i < WPA_PASSKEY_SIZE; i++) {
|
|
int c;
|
|
c = g_random_int_range (33, 126);
|
|
/* too many non alphanumeric characters are hard to remember for humans */
|
|
while (!g_ascii_isalnum (c))
|
|
c = g_random_int_range (33, 126);
|
|
|
|
key[i] = (char) c;
|
|
}
|
|
key[WPA_PASSKEY_SIZE] = '\0';
|
|
}
|
|
|
|
static void
|
|
generate_wep_key (char *key, size_t len)
|
|
{
|
|
int i;
|
|
const char *hexdigits = "0123456789abcdef";
|
|
|
|
g_return_if_fail (key);
|
|
g_return_if_fail (len > 10);
|
|
|
|
/* generate a 10-digit hex WEP key */
|
|
for (i = 0; i < 10; i++) {
|
|
int digit;
|
|
digit = g_random_int_range (0, 16);
|
|
key[i] = hexdigits[digit];
|
|
}
|
|
key[10] = '\0';
|
|
}
|
|
|
|
static gboolean
|
|
set_wireless_security_for_hotspot (NMSettingWirelessSecurity *s_wsec,
|
|
const char *wifi_mode,
|
|
NMDeviceWifiCapabilities caps,
|
|
const char *password,
|
|
gboolean show_password,
|
|
GError **error)
|
|
{
|
|
char generated_key[11];
|
|
const char *key;
|
|
const char *key_mgmt;
|
|
|
|
if (g_strcmp0 (wifi_mode, NM_SETTING_WIRELESS_MODE_AP) == 0) {
|
|
if (caps & NM_WIFI_DEVICE_CAP_RSN) {
|
|
nm_setting_wireless_security_add_proto (s_wsec, "rsn");
|
|
nm_setting_wireless_security_add_pairwise (s_wsec, "ccmp");
|
|
nm_setting_wireless_security_add_group (s_wsec, "ccmp");
|
|
key_mgmt = "wpa-psk";
|
|
} else if (caps & NM_WIFI_DEVICE_CAP_WPA) {
|
|
nm_setting_wireless_security_add_proto (s_wsec, "wpa");
|
|
nm_setting_wireless_security_add_pairwise (s_wsec, "tkip");
|
|
nm_setting_wireless_security_add_group (s_wsec, "tkip");
|
|
key_mgmt = "wpa-psk";
|
|
} else
|
|
key_mgmt = "none";
|
|
} else
|
|
key_mgmt = "none";
|
|
|
|
if (g_strcmp0 (key_mgmt, "wpa-psk") == 0) {
|
|
/* use WPA */
|
|
if (password) {
|
|
if (!nm_utils_wpa_psk_valid (password)) {
|
|
g_set_error (error, NMCLI_ERROR, 0, _("'%s' is not valid WPA PSK"), password);
|
|
return FALSE;
|
|
}
|
|
key = password;
|
|
} else {
|
|
generate_wpa_key (generated_key, sizeof (generated_key));
|
|
key = generated_key;
|
|
}
|
|
g_object_set (s_wsec,
|
|
NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, key_mgmt,
|
|
NM_SETTING_WIRELESS_SECURITY_PSK, key,
|
|
NULL);
|
|
} else {
|
|
/* use WEP */
|
|
if (password) {
|
|
if (!nm_utils_wep_key_valid (password, NM_WEP_KEY_TYPE_KEY)) {
|
|
g_set_error (error, NMCLI_ERROR, 0,
|
|
_("'%s' is not valid WEP key (it should be 5 or 13 ASCII chars)"),
|
|
password);
|
|
return FALSE;
|
|
}
|
|
key = password;
|
|
} else {
|
|
generate_wep_key (generated_key, sizeof (generated_key));
|
|
key = generated_key;
|
|
}
|
|
g_object_set (s_wsec,
|
|
NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, key_mgmt,
|
|
NM_SETTING_WIRELESS_SECURITY_WEP_KEY0, key,
|
|
NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, NM_WEP_KEY_TYPE_KEY,
|
|
NULL);
|
|
}
|
|
if (show_password)
|
|
g_print (_("Hotspot password: %s\n"), key);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static NMConnection *
|
|
find_hotspot_conn (NMDevice *device,
|
|
const GPtrArray *connections,
|
|
const char *con_name,
|
|
GBytes *ssid_bytes,
|
|
const char *wifi_mode,
|
|
const char *band,
|
|
gint64 channel_int)
|
|
{
|
|
NMConnection *connection;
|
|
NMSettingWireless *s_wifi;
|
|
int i;
|
|
|
|
for (i = 0; i < connections->len; i++) {
|
|
connection = NM_CONNECTION (connections->pdata[i]);
|
|
|
|
s_wifi = nm_connection_get_setting_wireless (connection);
|
|
if (!s_wifi)
|
|
continue;
|
|
|
|
if ( channel_int != -1
|
|
&& nm_setting_wireless_get_channel (s_wifi) != channel_int)
|
|
continue;
|
|
|
|
if (g_strcmp0 (nm_setting_wireless_get_mode (s_wifi), wifi_mode) != 0)
|
|
continue;
|
|
|
|
if (band && g_strcmp0 (nm_setting_wireless_get_band (s_wifi), band) != 0)
|
|
continue;
|
|
|
|
if (ssid_bytes && !g_bytes_equal (nm_setting_wireless_get_ssid (s_wifi), ssid_bytes))
|
|
continue;
|
|
|
|
if (!nm_device_connection_compatible (device, connection, NULL))
|
|
continue;
|
|
|
|
return g_object_ref (connection);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static NMConnection *
|
|
create_hotspot_conn (const GPtrArray *connections,
|
|
const char *con_name,
|
|
GBytes *ssid_bytes,
|
|
const char *wifi_mode,
|
|
const char *band,
|
|
gint64 channel_int)
|
|
{
|
|
char *default_name = NULL;
|
|
NMConnection *connection;
|
|
NMSettingConnection *s_con;
|
|
NMSettingWireless *s_wifi;
|
|
NMSettingWirelessSecurity *s_wsec;
|
|
NMSettingIPConfig *s_ip4, *s_ip6;
|
|
NMSettingProxy *s_proxy;
|
|
|
|
connection = nm_simple_connection_new ();
|
|
s_con = (NMSettingConnection *) nm_setting_connection_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_con));
|
|
if (!con_name)
|
|
con_name = default_name = nmc_unique_connection_name (connections, "Hotspot");
|
|
g_object_set (s_con,
|
|
NM_SETTING_CONNECTION_ID, con_name,
|
|
NM_SETTING_CONNECTION_AUTOCONNECT, FALSE,
|
|
NULL);
|
|
g_free (default_name);
|
|
|
|
s_wifi = (NMSettingWireless *) nm_setting_wireless_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_wifi));
|
|
|
|
g_object_set (s_wifi, NM_SETTING_WIRELESS_MODE, wifi_mode,
|
|
NM_SETTING_WIRELESS_SSID, ssid_bytes,
|
|
NULL);
|
|
|
|
if (channel_int != -1) {
|
|
g_object_set (s_wifi,
|
|
NM_SETTING_WIRELESS_CHANNEL, (guint32) channel_int,
|
|
NM_SETTING_WIRELESS_BAND, band,
|
|
NULL);
|
|
}
|
|
|
|
s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_wsec));
|
|
|
|
s_ip4 = (NMSettingIPConfig *) nm_setting_ip4_config_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_ip4));
|
|
g_object_set (s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_SHARED, NULL);
|
|
|
|
s_ip6 = (NMSettingIPConfig *) nm_setting_ip6_config_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_ip6));
|
|
g_object_set (s_ip6, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_IGNORE, NULL);
|
|
|
|
s_proxy = (NMSettingProxy *) nm_setting_proxy_new ();
|
|
nm_connection_add_setting (connection, NM_SETTING (s_proxy));
|
|
g_object_set (s_proxy, NM_SETTING_PROXY_METHOD, (int) NM_SETTING_PROXY_METHOD_NONE, NULL);
|
|
|
|
return connection;
|
|
}
|
|
|
|
static void
|
|
do_device_wifi_hotspot (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
const char *ifname = NULL;
|
|
const char *con_name = NULL;
|
|
gs_unref_bytes GBytes *ssid_bytes = NULL;
|
|
const char *wifi_mode;
|
|
const char *band = NULL;
|
|
const char *channel = NULL;
|
|
gint64 channel_int = -1;
|
|
const char *password = NULL;
|
|
gboolean show_password = FALSE;
|
|
NMDevice *device = NULL;
|
|
gs_free NMDevice **devices = NULL;
|
|
NMDeviceWifiCapabilities caps;
|
|
gs_unref_object NMConnection *connection = NULL;
|
|
const GPtrArray *connections;
|
|
NMSettingWirelessSecurity *s_wsec;
|
|
GError *error = NULL;
|
|
|
|
/* Set default timeout waiting for operation completion. */
|
|
if (nmc->timeout == -1)
|
|
nmc->timeout = 60;
|
|
|
|
devices = nmc_get_devices_sorted (nmc->client);
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
while (argc > 0) {
|
|
if (argc == 1 && nmc->complete) {
|
|
nmc_complete_strings (*argv, "ifname", "con-name", "ssid", "band",
|
|
"channel", "password");
|
|
}
|
|
|
|
if (strcmp (*argv, "ifname") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
ifname = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
complete_device (devices, ifname, TRUE);
|
|
} else if (strcmp (*argv, "con-name") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
con_name = *argv;
|
|
} else if (strcmp (*argv, "ssid") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
if (strlen (*argv) > 32) {
|
|
g_string_printf (nmc->return_text, _("Error: ssid is too long."));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
ssid_bytes = g_bytes_new (*argv, strlen (*argv));
|
|
} else if (strcmp (*argv, "band") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
band = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_strings (band, "a", "bg");
|
|
if (strcmp (band, "a") && strcmp (band, "bg")) {
|
|
g_string_printf (nmc->return_text, _("Error: band argument value '%s' is invalid; use 'a' or 'bg'."),
|
|
band);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
} else if (strcmp (*argv, "channel") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
channel = *argv;
|
|
} else if (strcmp (*argv, "password") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
password = *argv;
|
|
/* --show-password is deprecated in favour of global --show-secrets option */
|
|
/* Keep it here for backwards compatibility */
|
|
} else if (nmc_arg_is_option (*argv, "show-password")) {
|
|
show_password = TRUE;
|
|
} else {
|
|
g_string_printf (nmc->return_text, _("Error: invalid extra argument '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
}
|
|
show_password = nmc->nmc_config.show_secrets || show_password;
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
/* Verify band and channel parameters */
|
|
if (!channel) {
|
|
if (g_strcmp0 (band, "bg") == 0)
|
|
channel = "1";
|
|
if (g_strcmp0 (band, "a") == 0)
|
|
channel = "7";
|
|
}
|
|
if (channel) {
|
|
unsigned long int value;
|
|
|
|
if (!band) {
|
|
g_string_printf (nmc->return_text, _("Error: channel requires band too."));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
if ( !nmc_string_to_uint (channel, TRUE, 1, 5825, &value)
|
|
|| !nm_utils_wifi_is_channel_valid (value, band)) {
|
|
g_string_printf (nmc->return_text, _("Error: channel '%s' not valid for band '%s'."),
|
|
channel, band);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
channel_int = value;
|
|
}
|
|
|
|
/* Find Wi-Fi device. When no ifname is provided, the first Wi-Fi is used. */
|
|
device = find_wifi_device_by_iface (devices, ifname, NULL);
|
|
if (!device) {
|
|
if (ifname)
|
|
g_string_printf (nmc->return_text, _("Error: Device '%s' is not a Wi-Fi device."), ifname);
|
|
else
|
|
g_string_printf (nmc->return_text, _("Error: No Wi-Fi device found."));
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
return;
|
|
}
|
|
|
|
/* Check device supported mode */
|
|
caps = nm_device_wifi_get_capabilities (NM_DEVICE_WIFI (device));
|
|
if (caps & NM_WIFI_DEVICE_CAP_AP)
|
|
wifi_mode = NM_SETTING_WIRELESS_MODE_AP;
|
|
else if (caps & NM_WIFI_DEVICE_CAP_ADHOC)
|
|
wifi_mode = NM_SETTING_WIRELESS_MODE_ADHOC;
|
|
else {
|
|
g_string_printf (nmc->return_text, _("Error: Device '%s' supports neither AP nor Ad-Hoc mode."),
|
|
nm_device_get_iface (device));
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
return;
|
|
}
|
|
|
|
connections = nm_client_get_connections (nmc->client);
|
|
connection = find_hotspot_conn (device, connections, con_name, ssid_bytes,
|
|
wifi_mode, band, channel_int);
|
|
if (!connection) {
|
|
/* Create a connection with appropriate parameters */
|
|
if (!ssid_bytes)
|
|
ssid_bytes = generate_ssid_for_hotspot ();
|
|
connection = create_hotspot_conn (connections, con_name, ssid_bytes,
|
|
wifi_mode, band, channel_int);
|
|
}
|
|
|
|
if (password || !NM_IS_REMOTE_CONNECTION (connection)) {
|
|
s_wsec = nm_connection_get_setting_wireless_security (connection);
|
|
g_return_if_fail (s_wsec);
|
|
|
|
if (!set_wireless_security_for_hotspot (s_wsec, wifi_mode, caps, password, show_password, &error)) {
|
|
g_object_unref (connection);
|
|
g_string_printf (nmc->return_text, _("Error: Invalid 'password': %s."), error->message);
|
|
g_clear_error (&error);
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* Activate the connection now */
|
|
nmc->nowait_flag = (nmc->timeout == 0);
|
|
nmc->should_wait++;
|
|
|
|
save_and_activate_connection (nmc, device, connection, TRUE, NULL);
|
|
}
|
|
|
|
static void
|
|
request_rescan_cb (GObject *object, GAsyncResult *result, gpointer user_data)
|
|
{
|
|
NmCli *nmc = (NmCli *) user_data;
|
|
GError *error = NULL;
|
|
|
|
nm_device_wifi_request_scan_finish (NM_DEVICE_WIFI (object), result, &error);
|
|
if (error) {
|
|
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
g_error_free (error);
|
|
}
|
|
quit ();
|
|
}
|
|
|
|
static void
|
|
do_device_wifi_rescan (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
NMDevice *device;
|
|
const char *ifname = NULL;
|
|
gs_unref_ptrarray GPtrArray *ssids = NULL;
|
|
gs_free NMDevice **devices = NULL;
|
|
GVariantBuilder builder, array_builder;
|
|
GVariant *options;
|
|
int i;
|
|
|
|
ssids = g_ptr_array_new ();
|
|
devices = nmc_get_devices_sorted (nmc->client);
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
/* Get the parameters */
|
|
while (argc > 0) {
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_strings (*argv, "ifname", "ssid");
|
|
|
|
if (strcmp (*argv, "ifname") == 0) {
|
|
if (ifname) {
|
|
g_string_printf (nmc->return_text, _("Error: '%s' cannot repeat."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
ifname = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
complete_device (devices, ifname, TRUE);
|
|
} else if (strcmp (*argv, "ssid") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
g_ptr_array_add (ssids, (gpointer) *argv);
|
|
} else if (!nmc->complete) {
|
|
g_string_printf (nmc->return_text, _("Error: invalid extra argument '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
}
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
/* Find Wi-Fi device to scan on. When no ifname is provided, the first Wi-Fi is used. */
|
|
device = find_wifi_device_by_iface (devices, ifname, NULL);
|
|
|
|
if (!device) {
|
|
if (ifname)
|
|
g_string_printf (nmc->return_text, _("Error: Device '%s' is not a Wi-Fi device."), ifname);
|
|
else
|
|
g_string_printf (nmc->return_text, _("Error: No Wi-Fi device found."));
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
return;
|
|
}
|
|
|
|
if (ssids->len) {
|
|
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
|
|
g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aay"));
|
|
|
|
for (i = 0; i < ssids->len; i++) {
|
|
const char *ssid = g_ptr_array_index (ssids, i);
|
|
|
|
g_variant_builder_add (&array_builder, "@ay",
|
|
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, ssid, strlen (ssid), 1));
|
|
}
|
|
|
|
g_variant_builder_add (&builder, "{sv}", "ssids", g_variant_builder_end (&array_builder));
|
|
options = g_variant_builder_end (&builder);
|
|
|
|
nm_device_wifi_request_scan_options_async (NM_DEVICE_WIFI (device), options,
|
|
NULL, request_rescan_cb, nmc);
|
|
} else
|
|
nm_device_wifi_request_scan_async (NM_DEVICE_WIFI (device),
|
|
NULL, request_rescan_cb, nmc);
|
|
|
|
nmc->should_wait++;
|
|
}
|
|
|
|
static void
|
|
string_append_mecard (GString *string, const char *tag, const char *text)
|
|
{
|
|
const char *p;
|
|
bool is_hex = TRUE;
|
|
int start;
|
|
|
|
if (!text)
|
|
return;
|
|
|
|
g_string_append (string, tag);
|
|
start = string->len;
|
|
|
|
for (p = text; *p; p++) {
|
|
if (!g_ascii_isxdigit (*p))
|
|
is_hex = FALSE;
|
|
if (strchr ("\\\":;,", *p))
|
|
g_string_append_c (string, '\\');
|
|
g_string_append_c (string, *p);
|
|
}
|
|
|
|
if (is_hex) {
|
|
g_string_insert_c (string, start, '\"');
|
|
g_string_append_c (string, '\"');
|
|
}
|
|
g_string_append_c (string, ';');
|
|
}
|
|
|
|
static void
|
|
print_wifi_connection (const NmcConfig *nmc_config, NMConnection *connection)
|
|
{
|
|
NMSettingWireless *s_wireless;
|
|
NMSettingWirelessSecurity *s_wsec;
|
|
const char *key_mgmt = NULL;
|
|
const char *psk = NULL;
|
|
const char *type = NULL;
|
|
GBytes *ssid_bytes;
|
|
char *ssid;
|
|
GString *string;
|
|
|
|
s_wireless = nm_connection_get_setting_wireless (connection);
|
|
g_return_if_fail (s_wireless);
|
|
|
|
ssid_bytes = nm_setting_wireless_get_ssid (s_wireless);
|
|
g_return_if_fail (ssid_bytes);
|
|
ssid = nm_utils_ssid_to_utf8 (g_bytes_get_data (ssid_bytes, NULL),
|
|
g_bytes_get_size (ssid_bytes));
|
|
g_return_if_fail (ssid);
|
|
g_print ("SSID: %s\n", ssid);
|
|
|
|
string = g_string_sized_new (64);
|
|
g_string_append (string, "WIFI:");
|
|
|
|
s_wsec = nm_connection_get_setting_wireless_security (connection);
|
|
if (s_wsec) {
|
|
key_mgmt = nm_setting_wireless_security_get_key_mgmt (s_wsec);
|
|
psk = nm_setting_wireless_security_get_psk (s_wsec);
|
|
}
|
|
|
|
if (key_mgmt == NULL) {
|
|
type = "nopass";
|
|
g_print ("%s: %s\n", _("Security"), _("None"));
|
|
} else if ( strcmp (key_mgmt, "none") == 0
|
|
|| strcmp (key_mgmt, "ieee8021x") == 0) {
|
|
type = "WEP";
|
|
g_print ("%s: WEP\n", _("Security"));
|
|
} else if ( strcmp (key_mgmt, "wpa-none") == 0
|
|
|| strcmp (key_mgmt, "wpa-psk") == 0
|
|
|| strcmp (key_mgmt, "sae") == 0) {
|
|
type = "WPA";
|
|
g_print ("%s: WPA\n", _("Security"));
|
|
} else if ( strcmp (key_mgmt, "owe") == 0) {
|
|
type = "nopass";
|
|
g_print ("%s: OWE\n", _("Security"));
|
|
}
|
|
|
|
if (psk)
|
|
g_print ("%s: %s\n", _("Password"), psk);
|
|
|
|
string_append_mecard(string, "T:", type);
|
|
string_append_mecard(string, "S:", ssid);
|
|
string_append_mecard(string, "P:", psk);
|
|
|
|
if (nm_setting_wireless_get_hidden (s_wireless))
|
|
g_string_append (string, "H:true;");
|
|
|
|
g_string_append_c (string, ';');
|
|
if (nmc_config->use_colors)
|
|
nmc_print_qrcode (string->str);
|
|
g_string_free (string, TRUE);
|
|
|
|
g_print ("\n");
|
|
}
|
|
|
|
static gboolean
|
|
wifi_show_device (const NmcConfig *nmc_config, NMDevice *device, GError **error)
|
|
{
|
|
NMActiveConnection *active_conn;
|
|
gs_unref_object NMConnection *connection = NULL;
|
|
gs_unref_variant GVariant *secrets = NULL;
|
|
|
|
if (!NM_IS_DEVICE_WIFI (device)) {
|
|
g_set_error (error, NMCLI_ERROR, 0,
|
|
_("Error: Device '%s' is not a Wi-Fi device."),
|
|
nm_device_get_iface (device));
|
|
return FALSE;
|
|
}
|
|
|
|
connection = nm_device_get_applied_connection (device, 0, NULL, NULL, error);
|
|
if (!connection)
|
|
return FALSE;
|
|
|
|
active_conn = nm_device_get_active_connection (device);
|
|
if (!active_conn) {
|
|
g_set_error (error, NMCLI_ERROR, 0,
|
|
_("no active connection on device '%s'"),
|
|
nm_device_get_iface (device));
|
|
return FALSE;
|
|
}
|
|
|
|
secrets = nm_remote_connection_get_secrets (nm_active_connection_get_connection (active_conn),
|
|
NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,
|
|
NULL,
|
|
NULL);
|
|
if (secrets && !nm_connection_update_secrets (connection,
|
|
NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,
|
|
secrets,
|
|
error)) {
|
|
return FALSE;
|
|
}
|
|
|
|
print_wifi_connection (nmc_config, connection);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
do_device_wifi_show_password (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
const char *ifname = NULL;
|
|
gs_free NMDevice **devices = NULL;
|
|
gs_free_error GError *error = NULL;
|
|
gboolean found = FALSE;
|
|
int i;
|
|
|
|
devices = nmc_get_devices_sorted (nmc->client);
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
while (argc > 0) {
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_strings (*argv, "ifname");
|
|
|
|
if (strcmp (*argv, "ifname") == 0) {
|
|
if (ifname) {
|
|
g_string_printf (nmc->return_text,
|
|
_("Error: '%s' cannot repeat."),
|
|
*(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text,
|
|
_("Error: %s argument is missing."),
|
|
*(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
ifname = *argv;
|
|
if (argc == 1 && nmc->complete)
|
|
complete_device (devices, ifname, TRUE);
|
|
} else if (!nmc->complete) {
|
|
g_string_printf (nmc->return_text,
|
|
_("Error: invalid extra argument '%s'."),
|
|
*argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
}
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
for (i = 0; devices[i]; i++) {
|
|
if (ifname && g_strcmp0 (nm_device_get_iface (devices[i]), ifname) != 0)
|
|
continue;
|
|
|
|
if (wifi_show_device (&nmc->nmc_config, devices[i], &error)) {
|
|
found = TRUE;
|
|
} else {
|
|
if (ifname) {
|
|
g_string_printf (nmc->return_text,
|
|
_("%s"), error->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
return;
|
|
}
|
|
g_clear_error (&error);
|
|
}
|
|
|
|
if (ifname)
|
|
break;
|
|
}
|
|
|
|
if (!found) {
|
|
g_string_printf (nmc->return_text,
|
|
_("Error: No Wi-Fi device found."));
|
|
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
|
|
return;
|
|
}
|
|
}
|
|
|
|
static NMCCommand device_wifi_cmds[] = {
|
|
{ "list", do_device_wifi_list, NULL, TRUE, TRUE },
|
|
{ "connect", do_device_wifi_connect, NULL, TRUE, TRUE },
|
|
{ "hotspot", do_device_wifi_hotspot, NULL, TRUE, TRUE },
|
|
{ "rescan", do_device_wifi_rescan, NULL, TRUE, TRUE },
|
|
{ "show-password", do_device_wifi_show_password, NULL, TRUE, TRUE },
|
|
{ NULL, do_device_wifi_list, NULL, TRUE, TRUE },
|
|
};
|
|
|
|
static void
|
|
do_device_wifi (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
nmc_do_cmd (nmc, device_wifi_cmds, *argv, argc, argv);
|
|
}
|
|
|
|
static int
|
|
show_device_lldp_list (NMDevice *device, NmCli *nmc, const char *fields_str, int *counter)
|
|
{
|
|
const NMMetaAbstractInfo *const*tmpl;
|
|
NmcOutputField *arr;
|
|
GPtrArray *neighbors;
|
|
const char *str;
|
|
int i;
|
|
NMC_OUTPUT_DATA_DEFINE_SCOPED (out);
|
|
gs_free char *header_name = NULL;
|
|
|
|
neighbors = nm_device_get_lldp_neighbors (device);
|
|
|
|
if (!neighbors || !neighbors->len)
|
|
return 0;
|
|
|
|
tmpl = (const NMMetaAbstractInfo *const*) nmc_fields_dev_lldp_list;
|
|
|
|
/* Main header name */
|
|
header_name = construct_header_name (_("Device LLDP neighbors"),
|
|
nm_device_get_iface (device));
|
|
out_indices = parse_output_fields (fields_str, (const NMMetaAbstractInfo *const*) nmc_fields_dev_lldp_list, FALSE, NULL, NULL);
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_MAIN_HEADER_ADD | NMC_OF_FLAG_FIELD_NAMES);
|
|
g_ptr_array_add (out.output_data, arr);
|
|
|
|
for (i = 0; i < neighbors->len; i++) {
|
|
NMLldpNeighbor *neighbor = neighbors->pdata[i];
|
|
guint value;
|
|
|
|
arr = nmc_dup_fields_array (tmpl, NMC_OF_FLAG_SECTION_PREFIX);
|
|
set_val_str (arr, 0, g_strdup_printf ("NEIGHBOR[%d]", (*counter)++));
|
|
|
|
set_val_strc (arr, 1, nm_device_get_iface (device));
|
|
|
|
if (nm_lldp_neighbor_get_attr_string_value (neighbor, NM_LLDP_ATTR_CHASSIS_ID, &str))
|
|
set_val_strc (arr, 2, str);
|
|
|
|
if (nm_lldp_neighbor_get_attr_string_value (neighbor, NM_LLDP_ATTR_PORT_ID, &str))
|
|
set_val_strc (arr, 3, str);
|
|
|
|
if (nm_lldp_neighbor_get_attr_string_value (neighbor, NM_LLDP_ATTR_PORT_DESCRIPTION, &str))
|
|
set_val_strc (arr, 4, str);
|
|
|
|
if (nm_lldp_neighbor_get_attr_string_value (neighbor, NM_LLDP_ATTR_SYSTEM_NAME, &str))
|
|
set_val_strc (arr, 5, str);
|
|
|
|
if (nm_lldp_neighbor_get_attr_string_value (neighbor, NM_LLDP_ATTR_SYSTEM_DESCRIPTION, &str))
|
|
set_val_strc (arr, 6, str);
|
|
|
|
if (nm_lldp_neighbor_get_attr_uint_value (neighbor, NM_LLDP_ATTR_SYSTEM_CAPABILITIES, &value))
|
|
set_val_str (arr, 7, g_strdup_printf ("%u (%s)", value, nmc_parse_lldp_capabilities (value)));
|
|
|
|
if (nm_lldp_neighbor_get_attr_uint_value (neighbor, NM_LLDP_ATTR_IEEE_802_1_PVID, &value))
|
|
set_val_str (arr, 8, g_strdup_printf ("%u", value));
|
|
|
|
if (nm_lldp_neighbor_get_attr_uint_value (neighbor, NM_LLDP_ATTR_IEEE_802_1_PPVID, &value))
|
|
set_val_str (arr, 9, g_strdup_printf ("%u", value));
|
|
|
|
if (nm_lldp_neighbor_get_attr_uint_value (neighbor, NM_LLDP_ATTR_IEEE_802_1_PPVID_FLAGS, &value))
|
|
set_val_str (arr, 10, g_strdup_printf ("%u", value));
|
|
|
|
if (nm_lldp_neighbor_get_attr_uint_value (neighbor, NM_LLDP_ATTR_IEEE_802_1_VID, &value))
|
|
set_val_str (arr, 11, g_strdup_printf ("%u", value));
|
|
|
|
if (nm_lldp_neighbor_get_attr_string_value (neighbor, NM_LLDP_ATTR_IEEE_802_1_VLAN_NAME, &str))
|
|
set_val_strc (arr, 12, str);
|
|
|
|
if (nm_lldp_neighbor_get_attr_string_value (neighbor, NM_LLDP_ATTR_DESTINATION, &str))
|
|
set_val_strc (arr, 13, str);
|
|
|
|
if (nm_lldp_neighbor_get_attr_uint_value (neighbor, NM_LLDP_ATTR_CHASSIS_ID_TYPE, &value))
|
|
set_val_strc (arr, 14, g_strdup_printf ("%u", value));
|
|
|
|
if (nm_lldp_neighbor_get_attr_uint_value (neighbor, NM_LLDP_ATTR_PORT_ID_TYPE, &value))
|
|
set_val_strc (arr, 15, g_strdup_printf ("%u", value));
|
|
|
|
g_ptr_array_add (out.output_data, arr);
|
|
}
|
|
|
|
print_data_prepare_width (out.output_data);
|
|
print_data (&nmc->nmc_config, &nmc->pager_data, out_indices, header_name, 0, &out);
|
|
|
|
return neighbors->len;
|
|
}
|
|
|
|
static void
|
|
do_device_lldp_list (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
NMDevice *device = NULL;
|
|
gs_free_error GError *error = NULL;
|
|
const char *fields_str = NULL;
|
|
int counter = 0;
|
|
gs_unref_array GArray *out_indices = NULL;
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
while (argc > 0) {
|
|
if (argc == 1 && nmc->complete)
|
|
nmc_complete_strings (*argv, "ifname");
|
|
|
|
if (strcmp (*argv, "ifname") == 0) {
|
|
argc--;
|
|
argv++;
|
|
if (!argc) {
|
|
g_string_printf (nmc->return_text, _("Error: %s argument is missing."), *(argv-1));
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
device = get_device (nmc, &argc, &argv, &error);
|
|
if (!device) {
|
|
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
|
|
nmc->return_value = error->code;
|
|
return;
|
|
}
|
|
} else {
|
|
g_string_printf (nmc->return_text, _("Error: invalid extra argument '%s'."), *argv);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
}
|
|
|
|
if (!nmc->required_fields || g_ascii_strcasecmp (nmc->required_fields, "common") == 0)
|
|
fields_str = NMC_FIELDS_DEV_LLDP_LIST_COMMON;
|
|
else if (!nmc->required_fields || g_ascii_strcasecmp (nmc->required_fields, "all") == 0) {
|
|
} else
|
|
fields_str = nmc->required_fields;
|
|
|
|
out_indices = parse_output_fields (fields_str, (const NMMetaAbstractInfo *const*) nmc_fields_dev_lldp_list, FALSE, NULL, &error);
|
|
|
|
if (error) {
|
|
g_string_printf (nmc->return_text, _("Error: 'device lldp list': %s"), error->message);
|
|
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
|
|
return;
|
|
}
|
|
|
|
if (nmc->complete)
|
|
return;
|
|
|
|
if (device) {
|
|
show_device_lldp_list (device, nmc, fields_str, &counter);
|
|
} else {
|
|
gs_free NMDevice **devices = nmc_get_devices_sorted (nmc->client);
|
|
guint i;
|
|
|
|
for (i = 0; devices[i]; i++)
|
|
show_device_lldp_list (devices[i], nmc, fields_str, &counter);
|
|
}
|
|
}
|
|
|
|
static NMCCommand device_lldp_cmds[] = {
|
|
{ "list", do_device_lldp_list, NULL, TRUE, TRUE },
|
|
{ NULL, do_device_lldp_list, NULL, TRUE, TRUE },
|
|
};
|
|
|
|
static void
|
|
do_device_lldp (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
if (!nmc->mode_specified)
|
|
nmc->nmc_config_mutable.multiline_output = TRUE; /* multiline mode is default for 'device lldp' */
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
nmc_do_cmd (nmc, device_lldp_cmds, *argv, argc, argv);
|
|
}
|
|
|
|
static gboolean
|
|
is_single_word (const char* line)
|
|
{
|
|
size_t n1, n2, n3;
|
|
|
|
n1 = strspn (line, " \t");
|
|
n2 = strcspn (line+n1, " \t\0") + n1;
|
|
n3 = strspn (line+n2, " \t");
|
|
|
|
if (n3 == 0)
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
static char **
|
|
nmcli_device_tab_completion (const char *text, int start, int end)
|
|
{
|
|
char **match_array = NULL;
|
|
rl_compentry_func_t *generator_func = NULL;
|
|
|
|
/* Disable readline's default filename completion */
|
|
rl_attempted_completion_over = 1;
|
|
|
|
if (g_strcmp0 (rl_prompt, PROMPT_INTERFACE) == 0) {
|
|
/* Disable appending space after completion */
|
|
rl_completion_append_character = '\0';
|
|
|
|
if (!is_single_word (rl_line_buffer))
|
|
return NULL;
|
|
|
|
generator_func = nmc_rl_gen_func_ifnames;
|
|
} else if (g_strcmp0 (rl_prompt, PROMPT_INTERFACES) == 0) {
|
|
generator_func = nmc_rl_gen_func_ifnames;
|
|
}
|
|
|
|
if (generator_func)
|
|
match_array = rl_completion_matches (text, generator_func);
|
|
|
|
return match_array;
|
|
}
|
|
|
|
void
|
|
nmc_command_func_device (const NMCCommand *cmd, NmCli *nmc, int argc, const char *const*argv)
|
|
{
|
|
static const NMCCommand cmds[] = {
|
|
{ "status", do_devices_status, usage_device_status, TRUE, TRUE },
|
|
{ "show", do_device_show, usage_device_show, TRUE, TRUE },
|
|
{ "connect", do_device_connect, usage_device_connect, TRUE, TRUE },
|
|
{ "reapply", do_device_reapply, usage_device_reapply, TRUE, TRUE },
|
|
{ "disconnect", do_devices_disconnect, usage_device_disconnect, TRUE, TRUE },
|
|
{ "delete", do_devices_delete, usage_device_delete, TRUE, TRUE },
|
|
{ "set", do_device_set, usage_device_set, TRUE, TRUE },
|
|
{ "monitor", do_devices_monitor, usage_device_monitor, TRUE, TRUE },
|
|
{ "wifi", do_device_wifi, usage_device_wifi, FALSE, FALSE },
|
|
{ "lldp", do_device_lldp, usage_device_lldp, FALSE, FALSE },
|
|
{ "modify", do_device_modify, usage_device_modify, TRUE, TRUE },
|
|
{ NULL, do_devices_status, usage, TRUE, TRUE },
|
|
};
|
|
|
|
next_arg (nmc, &argc, &argv, NULL);
|
|
|
|
nmc_start_polkit_agent_start_try (nmc);
|
|
|
|
rl_attempted_completion_function = (rl_completion_func_t *) nmcli_device_tab_completion;
|
|
|
|
nmc_do_cmd (nmc, cmds, *argv, argc, argv);
|
|
}
|
|
|
|
void
|
|
monitor_devices (NmCli *nmc)
|
|
{
|
|
do_devices_monitor (NULL, nmc, 0, NULL);
|
|
}
|