gchar *
panel_get_ip4_address_as_string (NMIP4Config *ip4_config, const char *what)
{
const GSList *list;
struct in_addr addr;
gchar *str = NULL;
gchar tmp[INET_ADDRSTRLEN];
NMIP4Address *address;
/* get address */
list = nm_ip4_config_get_addresses (ip4_config);
if (list == NULL)
goto out;
/* we only care about one address */
address = list->data;
if (!strcmp (what, "address"))
addr.s_addr = nm_ip4_address_get_address (address);
else if (!strcmp (what, "gateway"))
addr.s_addr = nm_ip4_address_get_gateway (address);
else if (!strcmp (what, "netmask"))
addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (address));
else
goto out;
if (!inet_ntop (AF_INET, &addr, tmp, sizeof(tmp)))
goto out;
if (g_strcmp0 (tmp, "0.0.0.0") == 0)
goto out;
str = g_strdup (tmp);
out:
return str;
}
static void
dump_ip4_config (NMIP4Config *cfg)
{
char *tmp;
const GArray *array;
const GPtrArray *ptr_array;
GSList *iter;
int i;
for (iter = (GSList *) nm_ip4_config_get_addresses (cfg); iter; iter = g_slist_next (iter)) {
NMIP4Address *addr = iter->data;
guint32 u;
tmp = ip4_address_as_string (nm_ip4_address_get_address (addr));
g_print ("IP4 address: %s\n", tmp);
g_free (tmp);
u = nm_ip4_address_get_prefix (addr);
tmp = ip4_address_as_string (nm_utils_ip4_prefix_to_netmask (u));
g_print ("IP4 prefix: %d (%s)\n", u, tmp);
g_free (tmp);
tmp = ip4_address_as_string (nm_ip4_address_get_gateway (addr));
g_print ("IP4 gateway: %s\n\n", tmp);
g_free (tmp);
}
array = nm_ip4_config_get_nameservers (cfg);
if (array) {
g_print ("IP4 DNS:\n");
for (i = 0; i < array->len; i++) {
tmp = ip4_address_as_string (g_array_index (array, guint32, i));
g_print ("\t%s\n", tmp);
g_free (tmp);
}
}
ptr_array = nm_ip4_config_get_domains (cfg);
if (ptr_array) {
g_print ("IP4 domains:\n");
for (i = 0; i < ptr_array->len; i++)
g_print ("\t%s\n", (const char *) g_ptr_array_index (ptr_array, i));
}
array = nm_ip4_config_get_wins_servers (cfg);
if (array) {
g_print ("IP4 WINS:\n");
for (i = 0; i < array->len; i++) {
tmp = ip4_address_as_string (g_array_index (array, guint32, i));
g_print ("\t%s\n", tmp);
g_free (tmp);
}
}
}
static void
print_ip4_info (NMIP4Config * ip4)
{
GSList * addresses;
const GArray * dns;
const GPtrArray * domains;
int i;
if (!ip4)
return;
g_return_if_fail (NM_IS_IP4_CONFIG (ip4));
addresses = (GSList *) nm_ip4_config_get_addresses (ip4);
dns = nm_ip4_config_get_nameservers (ip4);
domains = nm_ip4_config_get_domains (ip4);
g_slist_foreach (addresses, (GFunc) print_ip4_addr, NULL);
if ((domains && domains->len) || (dns && dns->len))
g_print("%-9s ", "");
if (dns && dns->len) {
g_print("DNS:");
for (i = 0; i < dns->len; i++) {
struct in_addr tmp_addr;
char buf[INET_ADDRSTRLEN + 1];
guint32 addr = g_array_index(dns, guint32, i);
tmp_addr.s_addr = addr;
inet_ntop (AF_INET, &tmp_addr, buf, sizeof (buf));
g_print("%s ", buf);
}
g_print (" ");
}
if (domains && domains->len) {
g_print("Domains:");
for (i = 0; i < domains->len; i++) {
char * domain = (char *) g_ptr_array_index(domains, i);
g_print("%s ", domain);
}
}
if ((domains && domains->len) || (dns && dns->len))
g_print("\n");
}
static void
detail_device (gpointer data, gpointer user_data)
{
NMDevice *device = NM_DEVICE (data);
char *tmp;
NMDeviceState state;
guint32 caps;
guint32 speed;
const GArray *array;
gboolean is_default = FALSE;
const char *id = NULL;
NMActiveConnection *active;
active = nm_device_get_active_connection (device);
if (active) {
NMConnection *connection;
NMSettingConnection *s_con;
is_default = nm_active_connection_get_default (active);
connection = get_connection_for_active (active);
if (connection) {
s_con = nm_connection_get_setting_connection (connection);
if (s_con)
id = nm_setting_connection_get_id (s_con);
}
}
print_header ("Device", nm_device_get_iface (device), id);
/* General information */
if (NM_IS_DEVICE_ETHERNET (device))
print_string ("Type", "Wired");
else if (NM_IS_DEVICE_WIFI (device))
print_string ("Type", "802.11 WiFi");
else if (NM_IS_DEVICE_MODEM (device)) {
NMDeviceModemCapabilities modem_caps;
modem_caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (device));
if (modem_caps & NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS)
print_string ("Type", "Mobile Broadband (GSM)");
else if (modem_caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO)
print_string ("Type", "Mobile Broadband (CDMA)");
else
print_string ("Type", "Mobile Broadband (unknown)");
} else if (NM_IS_DEVICE_BT (device))
print_string ("Type", "Bluetooth");
else if (NM_IS_DEVICE_WIMAX (device))
print_string ("Type", "WiMAX");
print_string ("Driver", nm_device_get_driver (device) ? nm_device_get_driver (device) : "(unknown)");
state = nm_device_get_state (device);
print_string ("State", get_dev_state_string (state));
if (is_default)
print_string ("Default", "yes");
else
print_string ("Default", "no");
tmp = NULL;
if (NM_IS_DEVICE_ETHERNET (device))
tmp = g_strdup (nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (device)));
else if (NM_IS_DEVICE_WIFI (device))
tmp = g_strdup (nm_device_wifi_get_hw_address (NM_DEVICE_WIFI (device)));
else if (NM_IS_DEVICE_WIMAX (device))
tmp = g_strdup (nm_device_wimax_get_hw_address (NM_DEVICE_WIMAX (device)));
if (tmp) {
print_string ("HW Address", tmp);
g_free (tmp);
}
/* Capabilities */
caps = nm_device_get_capabilities (device);
printf ("\n Capabilities:\n");
if (caps & NM_DEVICE_CAP_CARRIER_DETECT)
print_string (" Carrier Detect", "yes");
speed = 0;
if (NM_IS_DEVICE_ETHERNET (device)) {
/* Speed in Mb/s */
speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (device));
} else if (NM_IS_DEVICE_WIFI (device)) {
/* Speed in b/s */
speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device));
speed /= 1000;
}
if (speed) {
char *speed_string;
speed_string = g_strdup_printf ("%u Mb/s", speed);
print_string (" Speed", speed_string);
g_free (speed_string);
}
/* Wireless specific information */
if ((NM_IS_DEVICE_WIFI (device))) {
guint32 wcaps;
NMAccessPoint *active_ap = NULL;
const char *active_bssid = NULL;
const GPtrArray *aps;
printf ("\n Wireless Properties\n");
wcaps = nm_device_wifi_get_capabilities (NM_DEVICE_WIFI (device));
if (wcaps & (NM_WIFI_DEVICE_CAP_CIPHER_WEP40 | NM_WIFI_DEVICE_CAP_CIPHER_WEP104))
print_string (" WEP Encryption", "yes");
if (wcaps & NM_WIFI_DEVICE_CAP_WPA)
print_string (" WPA Encryption", "yes");
if (wcaps & NM_WIFI_DEVICE_CAP_RSN)
print_string (" WPA2 Encryption", "yes");
if (nm_device_get_state (device) == 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_hw_address (active_ap) : NULL;
}
printf ("\n Wireless Access Points %s\n", active_ap ? "(* = current AP)" : "");
aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (device));
if (aps && aps->len)
g_ptr_array_foreach ((GPtrArray *) aps, detail_access_point, (gpointer) active_bssid);
} else if (NM_IS_DEVICE_ETHERNET (device)) {
printf ("\n Wired Properties\n");
if (nm_device_ethernet_get_carrier (NM_DEVICE_ETHERNET (device)))
print_string (" Carrier", "on");
else
print_string (" Carrier", "off");
} else if (NM_IS_DEVICE_WIMAX (device)) {
NMDeviceWimax *wimax = NM_DEVICE_WIMAX (device);
NMWimaxNsp *active_nsp = NULL;
const char *active_name = NULL;
const GPtrArray *nsps;
if (nm_device_get_state (device) == NM_DEVICE_STATE_ACTIVATED) {
guint tmp_uint;
gint tmp_int;
const char *tmp_str;
active_nsp = nm_device_wimax_get_active_nsp (wimax);
active_name = active_nsp ? nm_wimax_nsp_get_name (active_nsp) : NULL;
printf ("\n Link Status\n");
tmp_uint = nm_device_wimax_get_center_frequency (wimax);
if (tmp_uint)
tmp = g_strdup_printf ("%'.1f MHz", (double) tmp_uint / 1000.0);
else
tmp = g_strdup ("(unknown)");
print_string (" Center Freq.", tmp);
g_free (tmp);
tmp_int = nm_device_wimax_get_rssi (wimax);
if (tmp_int)
tmp = g_strdup_printf ("%d dBm", tmp_int);
else
tmp = g_strdup ("(unknown)");
print_string (" RSSI", tmp);
g_free (tmp);
tmp_int = nm_device_wimax_get_cinr (wimax);
if (tmp_int)
tmp = g_strdup_printf ("%d dB", tmp_int);
else
tmp = g_strdup ("(unknown)");
print_string (" CINR", tmp);
g_free (tmp);
tmp_int = nm_device_wimax_get_tx_power (wimax);
if (tmp_int)
tmp = g_strdup_printf ("%'.2f dBm", (float) tmp_int / 2.0);
else
tmp = g_strdup ("(unknown)");
print_string (" TX Power", tmp);
g_free (tmp);
tmp_str = nm_device_wimax_get_bsid (wimax);
if (tmp_str)
print_string (" BSID", tmp_str);
else
print_string (" BSID", "(unknown)");
}
printf ("\n WiMAX NSPs %s\n", active_nsp ? "(* current NSP)" : "");
nsps = nm_device_wimax_get_nsps (NM_DEVICE_WIMAX (device));
if (nsps && nsps->len)
g_ptr_array_foreach ((GPtrArray *) nsps, detail_nsp, (gpointer) active_name);
}
/* IP Setup info */
if (state == NM_DEVICE_STATE_ACTIVATED) {
NMIP4Config *cfg4 = nm_device_get_ip4_config (device);
NMIP6Config *cfg6 = nm_device_get_ip6_config (device);
GSList *iter;
if (cfg4) {
printf ("\n IPv4 Settings:\n");
for (iter = (GSList *) nm_ip4_config_get_addresses (cfg4); iter; iter = g_slist_next (iter)) {
NMIP4Address *addr = (NMIP4Address *) iter->data;
guint32 prefix = nm_ip4_address_get_prefix (addr);
char *tmp2;
tmp = ip4_address_as_string (nm_ip4_address_get_address (addr));
print_string (" Address", tmp);
g_free (tmp);
tmp2 = ip4_address_as_string (nm_utils_ip4_prefix_to_netmask (prefix));
tmp = g_strdup_printf ("%d (%s)", prefix, tmp2);
g_free (tmp2);
print_string (" Prefix", tmp);
g_free (tmp);
tmp = ip4_address_as_string (nm_ip4_address_get_gateway (addr));
print_string (" Gateway", tmp);
g_free (tmp);
printf ("\n");
}
array = nm_ip4_config_get_nameservers (cfg4);
if (array) {
int i;
for (i = 0; i < array->len; i++) {
tmp = ip4_address_as_string (g_array_index (array, guint32, i));
print_string (" DNS", tmp);
g_free (tmp);
}
}
}
if (cfg6) {
printf ("\n IPv6 Settings:\n");
for (iter = (GSList *) nm_ip6_config_get_addresses (cfg6); iter; iter = g_slist_next (iter)) {
NMIP6Address *addr = (NMIP6Address *) iter->data;
guint32 prefix = nm_ip6_address_get_prefix (addr);
tmp = ip6_address_as_string (nm_ip6_address_get_address (addr));
print_string (" Address", tmp);
g_free (tmp);
tmp = g_strdup_printf ("%d", prefix);
print_string (" Prefix", tmp);
g_free (tmp);
tmp = ip6_address_as_string (nm_ip6_address_get_gateway (addr));
print_string (" Gateway", tmp);
g_free (tmp);
printf ("\n");
}
for (iter = (GSList *) nm_ip6_config_get_nameservers (cfg6); iter; iter = g_slist_next (iter)) {
tmp = ip6_address_as_string (iter->data);
print_string (" DNS", tmp);
g_free (tmp);
}
}
}
printf ("\n\n");
}
gboolean
print_ip4_config (NMIP4Config *cfg4, NmCli *nmc, const char *group_prefix)
{
GSList *list, *iter;
const GArray *array;
const GPtrArray *ptr_array;
char **addr_arr = NULL;
char **route_arr = NULL;
char **dns_arr = NULL;
char **domain_arr = NULL;
char **wins_arr = NULL;
int i = 0;
guint32 mode_flag = (nmc->print_output == NMC_PRINT_PRETTY) ? NMC_PF_FLAG_PRETTY : (nmc->print_output == NMC_PRINT_TERSE) ? NMC_PF_FLAG_TERSE : 0;
guint32 multiline_flag = nmc->multiline_output ? NMC_PF_FLAG_MULTILINE : 0;
guint32 escape_flag = nmc->escape_values ? NMC_PF_FLAG_ESCAPE : 0;
if (cfg4 == NULL)
return FALSE;
nmc->allowed_fields = nmc_fields_ip4_config;
nmc->print_fields.flags = multiline_flag | mode_flag | escape_flag | NMC_PF_FLAG_FIELD_NAMES;
nmc->print_fields.indices = parse_output_fields (NMC_FIELDS_IP4_CONFIG_ALL, nmc->allowed_fields, NULL);
print_fields (nmc->print_fields, nmc->allowed_fields); /* Print header */
/* addresses */
list = (GSList *) nm_ip4_config_get_addresses (cfg4);
addr_arr = g_new (char *, g_slist_length (list) + 1);
for (iter = list; iter; iter = g_slist_next (iter)) {
NMIP4Address *addr = (NMIP4Address *) iter->data;
guint32 prefix;
char *ip_str, *gw_str;
ip_str = nmc_ip4_address_as_string (nm_ip4_address_get_address (addr), NULL);
prefix = nm_ip4_address_get_prefix (addr);
gw_str = nmc_ip4_address_as_string (nm_ip4_address_get_gateway (addr), NULL);
addr_arr[i++] = g_strdup_printf ("ip = %s/%u, gw = %s", ip_str, prefix, gw_str);
g_free (ip_str);
g_free (gw_str);
}
addr_arr[i] = NULL;
/* routes */
list = (GSList *) nm_ip4_config_get_routes (cfg4);
route_arr = g_new (char *, g_slist_length (list) + 1);
i = 0;
for (iter = list; iter; iter = g_slist_next (iter)) {
NMIP4Route *route = (NMIP4Route *) iter->data;
guint32 prefix, metric;
char *dest_str, *nexthop_str;
dest_str = nmc_ip4_address_as_string (nm_ip4_route_get_dest (route), NULL);
nexthop_str = nmc_ip4_address_as_string (nm_ip4_route_get_next_hop (route), NULL);
prefix = nm_ip4_route_get_prefix (route);
metric = nm_ip4_route_get_metric (route);
route_arr[i++] = g_strdup_printf ("dst = %s/%u, nh = %s, mt = %u", dest_str, prefix, nexthop_str, metric);
g_free (dest_str);
g_free (nexthop_str);
}
route_arr[i] = NULL;
/* DNS */
array = nm_ip4_config_get_nameservers (cfg4);
if (array) {
dns_arr = g_new (char *, array->len + 1);
for (i = 0; i < array->len; i++)
dns_arr[i] = nmc_ip4_address_as_string (g_array_index (array, guint32, i), NULL);
dns_arr[i] = NULL;
}
/* domains */
ptr_array = nm_ip4_config_get_domains (cfg4);
if (ptr_array) {
domain_arr = g_new (char *, ptr_array->len + 1);
for (i = 0; i < ptr_array->len; i++)
domain_arr[i] = g_ptr_array_index (ptr_array, i);
domain_arr[i] = NULL;
}
/* WINS */
array = nm_ip4_config_get_wins_servers (cfg4);
if (array) {
wins_arr = g_new (char *, array->len + 1);
for (i = 0; i < array->len; i++)
wins_arr[i] = nmc_ip4_address_as_string (g_array_index (array, guint32, i), NULL);
wins_arr[i] = NULL;
}
set_val_str (nmc->allowed_fields, 0, group_prefix);
set_val_arr (nmc->allowed_fields, 1, (const char **) addr_arr);
set_val_arr (nmc->allowed_fields, 2, (const char **) route_arr);
set_val_arr (nmc->allowed_fields, 3, (const char **) dns_arr);
set_val_arr (nmc->allowed_fields, 4, (const char **) domain_arr);
set_val_arr (nmc->allowed_fields, 5, (const char **) wins_arr);
nmc->print_fields.flags = multiline_flag | mode_flag | escape_flag | NMC_PF_FLAG_SECTION_PREFIX;
print_fields (nmc->print_fields, nmc->allowed_fields); /* Print values */
g_strfreev (addr_arr);
g_strfreev (route_arr);
g_strfreev (dns_arr);
g_free (domain_arr);
g_strfreev (wins_arr);
return TRUE;
}
static void
synchronize_device (Network *self,
NMDevice *device)
{
const char *iface_name = nm_device_get_iface (device);
Netinterface *iface;
NMIP4Config *ip4config;
NMIP6Config *ip6config;
iface = g_hash_table_lookup (self->ifname_to_netinterface,
iface_name);
g_assert (iface);
cockpit_network_netinterface_set_name (COCKPIT_NETWORK_NETINTERFACE (iface), iface_name);
ip4config = nm_device_get_ip4_config (device);
if (ip4config)
{
const GSList *addresses = nm_ip4_config_get_addresses (ip4config);
const GSList *iter;
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(yyyyu)"));
for (iter = addresses; iter; iter = iter->next)
{
NMIP4Address *ip4addr = iter->data;
guint32 ipaddr = ntohl (nm_ip4_address_get_address (ip4addr));
guint32 prefix = nm_ip4_address_get_prefix (ip4addr);
g_variant_builder_add_value (&builder, ip4_addr_variant_new (ipaddr, prefix));
}
cockpit_network_netinterface_set_ip4_addresses (COCKPIT_NETWORK_NETINTERFACE (iface), g_variant_builder_end (&builder));
}
ip6config = nm_device_get_ip6_config (device);
if (ip6config)
{
const GSList *addresses = nm_ip6_config_get_addresses (ip6config);
const GSList *iter;
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(yyyyyyyyyyyyyyyyu)"));
for (iter = addresses; iter; iter = iter->next)
{
NMIP6Address *ip6addr = iter->data;
g_variant_builder_add_value (&builder, ip6_addr_variant_new (nm_ip6_address_get_address (ip6addr),
nm_ip6_address_get_prefix (ip6addr)));
}
cockpit_network_netinterface_set_ip6_addresses (COCKPIT_NETWORK_NETINTERFACE (iface), g_variant_builder_end (&builder));
}
synchronize_device_config (self, iface, device);
switch (nm_device_get_device_type (device))
{
case NM_DEVICE_TYPE_ETHERNET:
synchronize_device_ethernet (self, iface, NM_DEVICE_ETHERNET (device));
break;
case NM_DEVICE_TYPE_WIFI:
synchronize_device_wifi (self, iface, NM_DEVICE_WIFI (device));
break;
default:
break;
}
}
static void
info_dialog_add_page (GtkNotebook *notebook,
NMConnection *connection,
gboolean is_default,
NMDevice *device)
{
GtkTable *table;
guint32 speed = 0;
char *str;
const char *iface;
NMIP4Config *ip4_config;
const GArray *dns;
NMIP4Address *def_addr = NULL;
guint32 hostmask, network, bcast, netmask;
int row = 0;
SpeedInfo* info = NULL;
GtkWidget* speed_label;
const GSList *addresses;
table = GTK_TABLE (gtk_table_new (12, 2, FALSE));
gtk_table_set_col_spacings (table, 12);
gtk_table_set_row_spacings (table, 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
/* Interface */
iface = nm_device_get_iface (device);
if (NM_IS_DEVICE_ETHERNET (device))
str = g_strdup_printf (_("Ethernet (%s)"), iface);
else if (NM_IS_DEVICE_WIFI (device))
str = g_strdup_printf (_("802.11 WiFi (%s)"), iface);
else if (NM_IS_GSM_DEVICE (device))
str = g_strdup_printf (_("GSM (%s)"), iface);
else if (NM_IS_CDMA_DEVICE (device))
str = g_strdup_printf (_("CDMA (%s)"), iface);
else
str = g_strdup (iface);
gtk_table_attach_defaults (table,
create_info_label (_("Interface:"), FALSE),
0, 1, row, row + 1);
gtk_table_attach_defaults (table,
create_info_label (str, TRUE),
1, 2, row, row + 1);
g_free (str);
row++;
/* Hardware address */
str = NULL;
if (NM_IS_DEVICE_ETHERNET (device))
str = g_strdup (nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (device)));
else if (NM_IS_DEVICE_WIFI (device))
str = g_strdup (nm_device_wifi_get_hw_address (NM_DEVICE_WIFI (device)));
gtk_table_attach_defaults (table,
create_info_label (_("Hardware Address:"), FALSE),
0, 1, row, row + 1);
gtk_table_attach_defaults (table,
create_info_label (str, TRUE),
1, 2, row, row + 1);
g_free (str);
row++;
/* Driver */
gtk_table_attach_defaults (table,
create_info_label (_("Driver:"), FALSE),
0, 1, row, row + 1);
gtk_table_attach_defaults (table,
create_info_label (nm_device_get_driver (device), TRUE),
1, 2, row, row + 1);
row++;
speed_label = create_info_label ("", TRUE);
/* Speed */
str = NULL;
if (NM_IS_DEVICE_ETHERNET (device)) {
/* Wired speed in Mb/s */
speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (device));
} else if (NM_IS_DEVICE_WIFI (device)) {
/* Wireless speed in Kb/s */
speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device)) / 1000;
/* Listen for wifi speed changes */
info = g_malloc0 (sizeof (SpeedInfo));
info->device = device;
info->label = speed_label;
info->id = g_signal_connect (device,
"notify::" NM_DEVICE_WIFI_BITRATE,
G_CALLBACK (bitrate_changed_cb),
speed_label);
g_object_weak_ref (G_OBJECT(speed_label), label_destroyed, info);
g_object_weak_ref (G_OBJECT(device), device_destroyed, info);
}
if (speed)
str = g_strdup_printf (_("%u Mb/s"), speed);
gtk_label_set_text (GTK_LABEL(speed_label), str ? str : _("Unknown"));
g_free (str);
gtk_table_attach_defaults (table,
create_info_label (_("Speed:"), FALSE),
0, 1, row, row + 1);
gtk_table_attach_defaults (table,
speed_label,
1, 2, row, row + 1);
row++;
/* Security */
gtk_table_attach_defaults (table,
create_info_label (_("Security:"), FALSE),
0, 1, row, row + 1);
gtk_table_attach_defaults (table,
create_info_label_security (connection),
1, 2, row, row + 1);
row++;
/* Empty line */
gtk_table_attach_defaults (table,
gtk_label_new (""),
0, 2, row, row + 1);
row++;
/* IP4 */
ip4_config = nm_device_get_ip4_config (device);
addresses = nm_ip4_config_get_addresses (ip4_config);
if (g_slist_length ((GSList *) addresses))
def_addr = addresses->data;
/* Address */
gtk_table_attach_defaults (table,
create_info_label (_("IP Address:"), FALSE),
0, 1, row, row + 1);
str = def_addr ? ip4_address_as_string (nm_ip4_address_get_address (def_addr)) : g_strdup (_("Unknown"));
gtk_table_attach_defaults (table,
create_info_label (str, TRUE),
1, 2, row, row + 1);
g_free (str);
row++;
/* Broadcast */
if (def_addr) {
netmask = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (def_addr));
network = ntohl (nm_ip4_address_get_address (def_addr)) & ntohl (netmask);
hostmask = ~ntohl (netmask);
bcast = htonl (network | hostmask);
}
gtk_table_attach_defaults (table,
create_info_label (_("Broadcast Address:"), FALSE),
0, 1, row, row + 1);
str = def_addr ? ip4_address_as_string (bcast) : g_strdup (_("Unknown"));
gtk_table_attach_defaults (table,
create_info_label (str, TRUE),
1, 2, row, row + 1);
g_free (str);
row++;
/* Prefix */
gtk_table_attach_defaults (table,
create_info_label (_("Subnet Mask:"), FALSE),
0, 1, row, row + 1);
str = def_addr ? ip4_address_as_string (netmask) : g_strdup (_("Unknown"));
gtk_table_attach_defaults (table,
create_info_label (str, TRUE),
1, 2, row, row + 1);
g_free (str);
row++;
/* Gateway */
if (def_addr && nm_ip4_address_get_gateway (def_addr)) {
gtk_table_attach_defaults (table,
create_info_label (_("Default Route:"), FALSE),
0, 1, row, row + 1);
str = ip4_address_as_string (nm_ip4_address_get_gateway (def_addr));
gtk_table_attach_defaults (table,
create_info_label (str, TRUE),
1, 2, row, row + 1);
g_free (str);
row++;
}
/* DNS */
dns = def_addr ? nm_ip4_config_get_nameservers (ip4_config) : NULL;
if (dns && dns->len) {
gtk_table_attach_defaults (table,
create_info_label (_("Primary DNS:"), FALSE),
0, 1, row, row + 1);
str = ip4_address_as_string (g_array_index (dns, guint32, 0));
gtk_table_attach_defaults (table,
create_info_label (str, TRUE),
1, 2, row, row + 1);
g_free (str);
row++;
if (dns->len > 1) {
gtk_table_attach_defaults (table,
create_info_label (_("Secondary DNS:"), FALSE),
0, 1, row, row + 1);
str = ip4_address_as_string (g_array_index (dns, guint32, 1));
gtk_table_attach_defaults (table,
create_info_label (str, TRUE),
1, 2, row, row + 1);
g_free (str);
row++;
}
}
gtk_notebook_append_page (notebook, GTK_WIDGET (table),
create_info_notebook_label (connection, is_default));
gtk_widget_show_all (GTK_WIDGET (table));
}
gboolean
print_ip4_config (NMIP4Config *cfg4,
NmCli *nmc,
const char *group_prefix,
const char *one_field)
{
GSList *list, *iter;
const GArray *array;
const GPtrArray *ptr_array;
char **addr_arr = NULL;
char **route_arr = NULL;
char **dns_arr = NULL;
char **domain_arr = NULL;
char **wins_arr = NULL;
int i = 0;
NmcOutputField *tmpl, *arr;
size_t tmpl_len;
if (cfg4 == NULL)
return FALSE;
tmpl = nmc_fields_ip4_config;
tmpl_len = sizeof (nmc_fields_ip4_config);
nmc->print_fields.indices = parse_output_fields (one_field ? one_field : NMC_FIELDS_IP4_CONFIG_ALL,
tmpl, FALSE, NULL, NULL);
arr = nmc_dup_fields_array (tmpl, tmpl_len, NMC_OF_FLAG_FIELD_NAMES);
g_ptr_array_add (nmc->output_data, arr);
/* addresses */
list = (GSList *) nm_ip4_config_get_addresses (cfg4);
addr_arr = g_new (char *, g_slist_length (list) + 1);
for (iter = list; iter; iter = g_slist_next (iter)) {
NMIP4Address *addr = (NMIP4Address *) iter->data;
guint32 prefix;
char *ip_str, *gw_str;
ip_str = nmc_ip4_address_as_string (nm_ip4_address_get_address (addr), NULL);
prefix = nm_ip4_address_get_prefix (addr);
gw_str = nmc_ip4_address_as_string (nm_ip4_address_get_gateway (addr), NULL);
addr_arr[i++] = g_strdup_printf ("ip = %s/%u, gw = %s", ip_str, prefix, gw_str);
g_free (ip_str);
g_free (gw_str);
}
addr_arr[i] = NULL;
/* routes */
list = (GSList *) nm_ip4_config_get_routes (cfg4);
route_arr = g_new (char *, g_slist_length (list) + 1);
i = 0;
for (iter = list; iter; iter = g_slist_next (iter)) {
NMIP4Route *route = (NMIP4Route *) iter->data;
guint32 prefix, metric;
char *dest_str, *nexthop_str;
dest_str = nmc_ip4_address_as_string (nm_ip4_route_get_dest (route), NULL);
nexthop_str = nmc_ip4_address_as_string (nm_ip4_route_get_next_hop (route), NULL);
prefix = nm_ip4_route_get_prefix (route);
metric = nm_ip4_route_get_metric (route);
route_arr[i++] = g_strdup_printf ("dst = %s/%u, nh = %s, mt = %u", dest_str, prefix, nexthop_str, metric);
g_free (dest_str);
g_free (nexthop_str);
}
route_arr[i] = NULL;
/* DNS */
array = nm_ip4_config_get_nameservers (cfg4);
if (array) {
dns_arr = g_new (char *, array->len + 1);
for (i = 0; i < array->len; i++)
dns_arr[i] = nmc_ip4_address_as_string (g_array_index (array, guint32, i), NULL);
dns_arr[i] = NULL;
}
/* domains */
ptr_array = nm_ip4_config_get_domains (cfg4);
if (ptr_array) {
domain_arr = g_new (char *, ptr_array->len + 1);
for (i = 0; i < ptr_array->len; i++)
domain_arr[i] = g_strdup (g_ptr_array_index (ptr_array, i));
domain_arr[i] = NULL;
}
/* WINS */
array = nm_ip4_config_get_wins_servers (cfg4);
if (array) {
wins_arr = g_new (char *, array->len + 1);
for (i = 0; i < array->len; i++)
wins_arr[i] = nmc_ip4_address_as_string (g_array_index (array, guint32, i), NULL);
wins_arr[i] = NULL;
}
arr = nmc_dup_fields_array (tmpl, tmpl_len, NMC_OF_FLAG_SECTION_PREFIX);
set_val_strc (arr, 0, group_prefix);
set_val_arr (arr, 1, addr_arr);
set_val_arr (arr, 2, route_arr);
set_val_arr (arr, 3, dns_arr);
set_val_arr (arr, 4, domain_arr);
set_val_arr (arr, 5, wins_arr);
g_ptr_array_add (nmc->output_data, arr);
print_data (nmc); /* Print all data */
/* Remove any previous data */
nmc_empty_output_fields (nmc);
return TRUE;
}
/*
* Given an interface name (e.g., eth0) and address family (e.g., AF_INET),
* return the IP address in human readable format (i.e., the output from
* inet_ntop()). Return NULL for no match or error.
*/
char *iface_ip2str(char *ifname, int family) {
int i;
NMClient *client = NULL;
NMIP4Config *ip4config = NULL;
NMIP4Address *ipaddr = NULL;
NMDevice *candidate = NULL;
struct in_addr tmp_addr;
const GPtrArray *devices;
const char *iface;
char ipstr[INET_ADDRSTRLEN+1];
if (ifname == NULL) {
return NULL;
}
/* DCFIXME: add IPv6 once NM gains support */
if (family != AF_INET) {
return NULL;
}
#if !defined(GLIB_VERSION_2_36)
g_type_init();
#endif
client = nm_client_new();
if (!client) {
return NULL;
}
if (nm_client_get_state(client) != NM_STATE_CONNECTED) {
g_object_unref(client);
return NULL;
}
devices = nm_client_get_devices(client);
for (i=0; i < devices->len; i++) {
candidate = g_ptr_array_index(devices, i);
iface = nm_device_get_iface(candidate);
if (nm_device_get_state(candidate) != NM_DEVICE_STATE_ACTIVATED)
continue;
if (!iface || strcmp(iface, ifname))
continue;
if (!(ip4config = nm_device_get_ip4_config(candidate)))
continue;
if (!(ipaddr = nm_ip4_config_get_addresses(ip4config)->data))
continue;
memset(&ipstr, '\0', sizeof(ipstr));
tmp_addr.s_addr = nm_ip4_address_get_address(ipaddr);
if (inet_ntop(AF_INET, &tmp_addr, ipstr, INET_ADDRSTRLEN) == NULL) {
g_object_unref(client);
return NULL;
}
g_object_unref(client);
return g_strdup(ipstr);
}
g_object_unref(client);
return NULL;
}
static void
detail_device (gpointer data, gpointer user_data)
{
NMDevice *device = NM_DEVICE (data);
struct cb_info *info = user_data;
char *tmp;
NMDeviceState state;
guint32 caps;
guint32 speed;
const GArray *array;
int j;
gboolean is_default = FALSE;
const char *id = NULL;
state = nm_device_get_state (device);
for (j = 0; info->active && (j < info->active->len); j++) {
NMActiveConnection *candidate = g_ptr_array_index (info->active, j);
const GPtrArray *devices = nm_active_connection_get_devices (candidate);
NMDevice *candidate_dev;
NMConnection *connection;
NMSettingConnection *s_con;
if (!devices || !devices->len)
continue;
candidate_dev = g_ptr_array_index (devices, 0);
if (candidate_dev == device) {
if (nm_active_connection_get_default (candidate))
is_default = TRUE;
connection = get_connection_for_active (candidate);
if (!connection)
break;
s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION);
if (s_con)
id = nm_setting_connection_get_id (s_con);
break;
}
}
print_header ("Device", nm_device_get_iface (device), id);
/* General information */
if (NM_IS_DEVICE_ETHERNET (device))
print_string ("Type", "Wired");
else if (NM_IS_DEVICE_WIFI (device))
print_string ("Type", "802.11 WiFi");
else if (NM_IS_GSM_DEVICE (device))
print_string ("Type", "Mobile Broadband (GSM)");
else if (NM_IS_CDMA_DEVICE (device))
print_string ("Type", "Mobile Broadband (CDMA)");
else if (NM_IS_DEVICE_BT (device))
print_string ("Type", "Bluetooth");
print_string ("Driver", nm_device_get_driver (device) ? nm_device_get_driver (device) : "(unknown)");
print_string ("State", get_dev_state_string (state));
if (is_default)
print_string ("Default", "yes");
else
print_string ("Default", "no");
tmp = NULL;
if (NM_IS_DEVICE_ETHERNET (device))
tmp = g_strdup (nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (device)));
else if (NM_IS_DEVICE_WIFI (device))
tmp = g_strdup (nm_device_wifi_get_hw_address (NM_DEVICE_WIFI (device)));
if (tmp) {
print_string ("HW Address", tmp);
g_free (tmp);
}
/* Capabilities */
caps = nm_device_get_capabilities (device);
printf ("\n Capabilities:\n");
if (caps & NM_DEVICE_CAP_CARRIER_DETECT)
print_string (" Carrier Detect", "yes");
speed = 0;
if (NM_IS_DEVICE_ETHERNET (device)) {
/* Speed in Mb/s */
speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (device));
} else if (NM_IS_DEVICE_WIFI (device)) {
/* Speed in b/s */
speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device));
speed /= 1000;
}
if (speed) {
char *speed_string;
speed_string = g_strdup_printf ("%u Mb/s", speed);
print_string (" Speed", speed_string);
g_free (speed_string);
}
/* Wireless specific information */
if ((NM_IS_DEVICE_WIFI (device))) {
guint32 wcaps;
NMAccessPoint *active_ap = NULL;
const char *active_bssid = NULL;
const GPtrArray *aps;
printf ("\n Wireless Properties\n");
wcaps = nm_device_wifi_get_capabilities (NM_DEVICE_WIFI (device));
if (wcaps & (NM_WIFI_DEVICE_CAP_CIPHER_WEP40 | NM_WIFI_DEVICE_CAP_CIPHER_WEP104))
print_string (" WEP Encryption", "yes");
if (wcaps & NM_WIFI_DEVICE_CAP_WPA)
print_string (" WPA Encryption", "yes");
if (wcaps & NM_WIFI_DEVICE_CAP_RSN)
print_string (" WPA2 Encryption", "yes");
if (nm_device_get_state (device) == 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_hw_address (active_ap) : NULL;
}
printf ("\n Wireless Access Points %s\n", active_ap ? "(* = current AP)" : "");
aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (device));
if (aps && aps->len)
g_ptr_array_foreach ((GPtrArray *) aps, detail_access_point, (gpointer) active_bssid);
} else if (NM_IS_DEVICE_ETHERNET (device)) {
printf ("\n Wired Properties\n");
if (nm_device_ethernet_get_carrier (NM_DEVICE_ETHERNET (device)))
print_string (" Carrier", "on");
else
print_string (" Carrier", "off");
}
/* IP Setup info */
if (state == NM_DEVICE_STATE_ACTIVATED) {
NMIP4Config *cfg = nm_device_get_ip4_config (device);
GSList *iter;
printf ("\n IPv4 Settings:\n");
for (iter = (GSList *) nm_ip4_config_get_addresses (cfg); iter; iter = g_slist_next (iter)) {
NMIP4Address *addr = (NMIP4Address *) iter->data;
guint32 prefix = nm_ip4_address_get_prefix (addr);
char *tmp2;
tmp = ip4_address_as_string (nm_ip4_address_get_address (addr));
print_string (" Address", tmp);
g_free (tmp);
tmp2 = ip4_address_as_string (nm_utils_ip4_prefix_to_netmask (prefix));
tmp = g_strdup_printf ("%d (%s)", prefix, tmp2);
g_free (tmp2);
print_string (" Prefix", tmp);
g_free (tmp);
tmp = ip4_address_as_string (nm_ip4_address_get_gateway (addr));
print_string (" Gateway", tmp);
g_free (tmp);
printf ("\n");
}
array = nm_ip4_config_get_nameservers (cfg);
if (array) {
int i;
for (i = 0; i < array->len; i++) {
tmp = ip4_address_as_string (g_array_index (array, guint32, i));
print_string (" DNS", tmp);
g_free (tmp);
}
}
}
printf ("\n\n");
}
static void
get_devices (NAApplication *application)
{
int i;
NMClient *nm_client = nm_client_new ();
const GPtrArray *nm_connections = nm_client_get_active_connections (nm_client);
for (i = 0; i < nm_connections->len; i++)
{
NMActiveConnection *active_conn = NM_ACTIVE_CONNECTION (g_ptr_array_index (nm_connections, i));
g_debug ("Active connection: %s", nm_active_connection_get_connection (active_conn));
}
const GPtrArray *nm_devices = nm_client_get_devices (nm_client);
for (i = 0; i < nm_devices->len; i++)
{
NMDevice *nm_device = NM_DEVICE (g_ptr_array_index (nm_devices, i));
if (nm_device_get_state (nm_device) == NM_DEVICE_STATE_ACTIVATED)
{
const char *iface = nm_device_get_iface (nm_device);
const char *ip_iface = nm_device_get_ip_iface (nm_device);
g_debug ("Active device found: %s with ip iface %s", iface, ip_iface);
NMIP4Config *ip4_config = nm_device_get_ip4_config (nm_device);
if (ip4_config != NULL)
{
const GSList *ip4_addresses = nm_ip4_config_get_addresses (ip4_config);
const GSList *iter = ip4_addresses;
while (iter != NULL)
{
guint32 address = nm_ip4_address_get_address ((NMIP4Address *)iter->data);
struct in_addr addr = { address, };
char *str_addr = g_new (char, INET_ADDRSTRLEN);
inet_ntop (AF_INET, &addr, str_addr, INET_ADDRSTRLEN);
add_local_address (str_addr);
g_debug ("Adding local IP4 address %s", str_addr);
iter = iter->next;
}
}
NMIP6Config *ip6_config = nm_device_get_ip6_config (nm_device);
if (ip6_config != NULL)
{
const GSList *ip6_addresses = nm_ip6_config_get_addresses (ip6_config);
const GSList *iter = ip6_addresses;
while (iter != NULL)
{
const struct in6_addr *address = nm_ip6_address_get_address ((NMIP6Address *)iter->data);
char *str_addr = g_new (char, INET6_ADDRSTRLEN);
inet_ntop (AF_INET6, address, str_addr, INET6_ADDRSTRLEN);
add_local_address (str_addr);
g_debug ("Adding local IP6 address %s", str_addr);
iter = iter->next;
}
}
GError *error = NULL;
NAPCapHandle *handle = na_pcap_open (iface, &error);
if (handle != NULL)
{
application->priv->iface_handles = g_slist_append (application->priv->iface_handles, handle);
}
else
{
g_debug ("Error opening handler for interface %s: %s\n", iface, error->message);
g_error_free (error);
}
}
}
}
