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
print_ip4_addr (gpointer object, gpointer user_data)
{
NMIP4Address * address = (NMIP4Address *) object;
guint32 addr = nm_ip4_address_get_address (address);
guint32 prefix = nm_ip4_address_get_prefix (address);
guint32 netmask = nm_utils_ip4_prefix_to_netmask (prefix);
guint32 gateway = nm_ip4_address_get_gateway (address);
struct in_addr tmp_addr;
char buf[INET_ADDRSTRLEN + 1];
g_print ("%-9s ", "");
tmp_addr.s_addr = addr;
inet_ntop (AF_INET, &tmp_addr, buf, sizeof (buf));
g_print ("IPv4:%s ", buf);
tmp_addr.s_addr = netmask;
inet_ntop (AF_INET, &tmp_addr, buf, sizeof (buf));
g_print ("Netmask:%s ", buf);
tmp_addr.s_addr = gateway;
inet_ntop (AF_INET, &tmp_addr, buf, sizeof (buf));
g_print ("Gateway:%s\n", buf);
}
static ip_block *
create_ip4_block (gchar * ip)
{
ip_block *iblock = g_slice_new0 (ip_block);
struct in_addr tmp_ip4_addr;
int i;
guint length;
gchar **ip_mask;
/* prefix format */
if (strstr (ip, "/")) {
gchar *prefix;
ip_mask = g_strsplit (ip, "/", 0);
length = g_strv_length (ip_mask);
if (!inet_pton (AF_INET, ip_mask[0], &tmp_ip4_addr))
goto error;
iblock->ip = tmp_ip4_addr.s_addr;
prefix = ip_mask[1];
i = 0;
while (i < length && isdigit (prefix[i]))
i++;
prefix[i] = '\0';
iblock->netmask = nm_utils_ip4_prefix_to_netmask ((guint32)
atoi (ip_mask
[1]));
} else if (strstr (ip, "netmask")) {
ip_mask = g_strsplit (ip, " ", 0);
length = g_strv_length (ip_mask);
if (!inet_pton (AF_INET, ip_mask[0], &tmp_ip4_addr))
goto error;
iblock->ip = tmp_ip4_addr.s_addr;
i = 0;
while (i < length && !strstr (ip_mask[++i], "netmask")) ;
while (i < length && ip_mask[++i][0] == '\0') ;
if (i >= length)
goto error;
if (!inet_pton (AF_INET, ip_mask[i], &tmp_ip4_addr))
goto error;
iblock->netmask = tmp_ip4_addr.s_addr;
} else {
g_slice_free (ip_block, iblock);
if (!is_ip6_address (ip) && !strstr (ip, "dhcp"))
PLUGIN_WARN (IFNET_PLUGIN_NAME,
"Can't handle ipv4 address: %s, missing netmask or prefix",
ip);
return NULL;
}
g_strfreev (ip_mask);
return iblock;
error:
if (!is_ip6_address (ip))
PLUGIN_WARN (IFNET_PLUGIN_NAME, "Can't handle IPv4 address: %s",
ip);
g_strfreev (ip_mask);
g_slice_free (ip_block, iblock);
return NULL;
}
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
add_routes_section (CEPageIP4 *page)
{
GtkWidget *widget;
GtkWidget *frame;
GtkWidget *list;
gint i;
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "routes_section"));
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (widget), frame);
page->routes_list = list = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (list), cc_list_box_update_header_func, NULL, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (list), (GtkListBoxSortFunc)sort_first_last, NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), list);
page->auto_routes = GTK_SWITCH (gtk_builder_get_object (CE_PAGE (page)->builder, "auto_routes_switch"));
gtk_switch_set_active (page->auto_routes, !nm_setting_ip4_config_get_ignore_auto_routes (page->setting));
g_signal_connect (page->auto_routes, "notify::active", G_CALLBACK (switch_toggled), page);
add_section_toolbar (page, widget, G_CALLBACK (add_empty_route_row));
for (i = 0; i < nm_setting_ip4_config_get_num_routes (page->setting); i++) {
NMIP4Route *route;
struct in_addr tmp_addr;
gchar address[INET_ADDRSTRLEN + 1];
gchar netmask[INET_ADDRSTRLEN + 1];
gchar gateway[INET_ADDRSTRLEN + 1];
gint metric;
route = nm_setting_ip4_config_get_route (page->setting, i);
if (!route)
continue;
tmp_addr.s_addr = nm_ip4_route_get_dest (route);
(void) inet_ntop (AF_INET, &tmp_addr, &address[0], sizeof (address));
tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_route_get_prefix (route));
(void) inet_ntop (AF_INET, &tmp_addr, &netmask[0], sizeof (netmask));
tmp_addr.s_addr = nm_ip4_route_get_next_hop (route);
(void) inet_ntop (AF_INET, &tmp_addr, &gateway[0], sizeof (gateway));
metric = nm_ip4_route_get_metric (route);
add_route_row (page, address, netmask, gateway, metric);
}
if (nm_setting_ip4_config_get_num_routes (page->setting) == 0)
add_empty_route_row (page);
gtk_widget_show_all (widget);
}
static gboolean
gateway_matches_address (const char *gw_str, const char *addr_str, guint32 prefix)
{
struct in_addr gw, addr;
guint32 netmask;
if (!gw_str || inet_pton (AF_INET, gw_str, &gw) != 1)
return FALSE;
if (!addr_str || inet_pton (AF_INET, addr_str, &addr) != 1)
return FALSE;
netmask = nm_utils_ip4_prefix_to_netmask (prefix);
return ((addr.s_addr & netmask) == (gw.s_addr & netmask));
}
gboolean
nm_dnsmasq_utils_get_range (const NMPlatformIP4Address *addr,
char *out_first,
char *out_last,
char **out_error_desc)
{
guint32 host = addr->address;
guint32 prefix = addr->plen;
guint32 netmask = nm_utils_ip4_prefix_to_netmask (prefix);
guint32 first, last, reserved;
g_return_val_if_fail (out_first != NULL, FALSE);
g_return_val_if_fail (out_last != NULL, FALSE);
if (prefix > 30) {
if (out_error_desc)
*out_error_desc = g_strdup_printf ("Address prefix %d is too small for DHCP.", prefix);
return FALSE;
}
/* Find the first available address *after* the local machine's IP */
first = (host & netmask) + htonl (1);
/* Shortcut: allow a max of 253 addresses; the - htonl(1) here is to assure
* that we don't set 'last' to the broadcast address of the network. */
if (prefix < 24)
last = (host | ~nm_utils_ip4_prefix_to_netmask (24)) - htonl (1);
else
last = (host | ~netmask) - htonl(1);
/* Figure out which range (either above the host address or below it)
* has more addresses. Reserve some addresses for static IPs.
*/
if (ntohl (host) - ntohl (first) > ntohl (last) - ntohl (host)) {
/* Range below the host's IP address */
reserved = (guint32) ((ntohl (host) - ntohl (first)) / 10);
last = host - htonl (MIN (reserved, 8)) - htonl (1);
} else {
/* Range above host's IP address */
reserved = (guint32) ((ntohl (last) - ntohl (host)) / 10);
first = host + htonl (MIN (reserved, 8)) + htonl (1);
}
nm_utils_inet4_ntop (first, out_first);
nm_utils_inet4_ntop (last, out_last);
return TRUE;
}
static void
add_address_section (CEPageIP4 *page)
{
GtkWidget *widget;
GtkWidget *frame;
GtkWidget *list;
gint i;
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "address_section"));
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (widget), frame);
page->address_list = list = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (list), cc_list_box_update_header_func, NULL, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (list), (GtkListBoxSortFunc)sort_first_last, NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), list);
add_section_toolbar (page, widget, G_CALLBACK (add_empty_address_row));
for (i = 0; i < nm_setting_ip4_config_get_num_addresses (page->setting); i++) {
NMIP4Address *addr;
struct in_addr tmp_addr;
gchar address[INET_ADDRSTRLEN + 1];
gchar network[INET_ADDRSTRLEN + 1];
gchar gateway[INET_ADDRSTRLEN + 1];
addr = nm_setting_ip4_config_get_address (page->setting, i);
if (!addr)
continue;
tmp_addr.s_addr = nm_ip4_address_get_address (addr);
(void) inet_ntop (AF_INET, &tmp_addr, &address[0], sizeof (address));
tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (addr));
(void) inet_ntop (AF_INET, &tmp_addr, &network[0], sizeof (network));
tmp_addr.s_addr = nm_ip4_address_get_gateway (addr);
(void) inet_ntop (AF_INET, &tmp_addr, &gateway[0], sizeof (gateway));
add_address_row (page, address, network, gateway);
}
if (nm_setting_ip4_config_get_num_addresses (page->setting) == 0)
add_empty_address_row (page);
gtk_widget_show_all (widget);
}
struct rtnl_addr *
nm_ip4_config_to_rtnl_addr (NMIP4Config *config, guint32 i, guint32 flags)
{
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
NMIP4Address *config_addr;
struct rtnl_addr *addr;
gboolean success = TRUE;
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
config_addr = nm_ip4_config_get_address (config, i);
g_return_val_if_fail (config_addr != NULL, NULL);
if (!(addr = rtnl_addr_alloc()))
return NULL;
if (flags & NM_RTNL_ADDR_ADDR)
success = (ip4_addr_to_rtnl_local (nm_ip4_address_get_address (config_addr), addr) >= 0);
if (flags & NM_RTNL_ADDR_PTP_ADDR)
success = (ip4_addr_to_rtnl_peer (priv->ptp_address, addr) >= 0);
if (flags & NM_RTNL_ADDR_PREFIX)
rtnl_addr_set_prefixlen (addr, nm_ip4_address_get_prefix (config_addr));
if (flags & NM_RTNL_ADDR_BROADCAST) {
guint32 hostmask, network, bcast, netmask;
netmask = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (config_addr));
network = ntohl (nm_ip4_address_get_address (config_addr)) & ntohl (netmask);
hostmask = ~ntohl (netmask);
bcast = htonl (network | hostmask);
success = (ip4_addr_to_rtnl_broadcast (bcast, addr) >= 0);
}
if (!success) {
rtnl_addr_put (addr);
addr = NULL;
}
return addr;
}
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");
}
GtkWidget *
ip4_routes_dialog_new (NMSettingIPConfig *s_ip4, gboolean automatic)
{
GtkBuilder *builder;
GtkWidget *dialog, *widget, *ok_button;
GtkListStore *store;
GtkTreeIter model_iter;
GtkTreeSelection *selection;
gint offset;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
int i;
GSList *renderers = NULL;
GError* error = NULL;
/* Initialize temporary storage vars */
g_free (last_edited);
last_edited = NULL;
last_path = NULL;
g_free (last_path);
last_column = -1;
builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, UIDIR "/ce-ip4-routes.ui", &error)) {
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
return NULL;
}
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_routes_dialog"));
if (!dialog) {
g_warning ("%s: Couldn't load ip4 routes dialog from .ui file.", __func__);
g_object_unref (builder);
return NULL;
}
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_object_set_data_full (G_OBJECT (dialog), "builder",
builder, (GDestroyNotify) g_object_unref);
ok_button = GTK_WIDGET (gtk_builder_get_object (builder, "ok_button"));
store = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
/* Add existing routes */
for (i = 0; i < nm_setting_ip_config_get_num_routes (s_ip4); i++) {
NMIPRoute *route = nm_setting_ip_config_get_route (s_ip4, i);
struct in_addr tmp_addr;
char netmask[INET_ADDRSTRLEN], metric[32];
gint64 metric_int;
if (!route) {
g_warning ("%s: empty IP4 route structure!", __func__);
continue;
}
tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip_route_get_prefix (route));
if (!inet_ntop (AF_INET, &tmp_addr, netmask, sizeof (netmask)))
*netmask = '\0';
metric_int = nm_ip_route_get_metric (route);
if (metric_int >= 0 && metric_int <= G_MAXUINT32)
g_snprintf (metric, sizeof (metric), "%lu", (unsigned long) metric_int);
else {
if (metric_int != -1)
g_warning ("invalid metric %lld", (long long int) metric_int);
metric[0] = 0;
}
gtk_list_store_append (store, &model_iter);
gtk_list_store_set (store, &model_iter,
COL_ADDRESS, nm_ip_route_get_dest (route),
COL_PREFIX, netmask,
COL_NEXT_HOP, nm_ip_route_get_next_hop (route),
COL_METRIC, metric,
-1);
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_routes"));
gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (store));
g_object_unref (store);
/* IP Address column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_ADDRESS));
g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder);
renderers = g_slist_append (renderers, renderer);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, _("Address"), renderer,
"text", COL_ADDRESS,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func,
GUINT_TO_POINTER (COL_ADDRESS), NULL);
/* Prefix column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_PREFIX));
g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder);
renderers = g_slist_append (renderers, renderer);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, _("Netmask"), renderer,
"text", COL_PREFIX,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func,
GUINT_TO_POINTER (COL_PREFIX), NULL);
/* Gateway column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_NEXT_HOP));
g_signal_connect (renderer, "editing-started", G_CALLBACK (ip4_cell_editing_started), ok_button);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder);
renderers = g_slist_append (renderers, renderer);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, _("Gateway"), renderer,
"text", COL_NEXT_HOP,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func,
GUINT_TO_POINTER (COL_NEXT_HOP), NULL);
/* Metric column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (cell_edited), builder);
g_object_set_data (G_OBJECT (renderer), "column", GUINT_TO_POINTER (COL_METRIC));
g_signal_connect (renderer, "editing-started", G_CALLBACK (uint_cell_editing_started), ok_button);
g_signal_connect (renderer, "editing-canceled", G_CALLBACK (cell_editing_canceled), builder);
renderers = g_slist_append (renderers, renderer);
offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (widget),
-1, _("Metric"), renderer,
"text", COL_METRIC,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (widget), offset - 1);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer, cell_error_data_func,
GUINT_TO_POINTER (COL_METRIC), NULL);
g_object_set_data_full (G_OBJECT (dialog), "renderers", renderers, (GDestroyNotify) g_slist_free);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
g_signal_connect (selection, "changed",
G_CALLBACK (list_selection_changed),
GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_delete_button")));
g_signal_connect (widget, "button-press-event", G_CALLBACK (tree_view_button_pressed_cb), builder);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_add_button"));
gtk_widget_set_sensitive (widget, TRUE);
g_signal_connect (widget, "clicked", G_CALLBACK (route_add_clicked), builder);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_route_delete_button"));
gtk_widget_set_sensitive (widget, FALSE);
g_signal_connect (widget, "clicked", G_CALLBACK (route_delete_clicked), builder);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_ignore_auto_routes"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
nm_setting_ip_config_get_ignore_auto_routes (s_ip4));
gtk_widget_set_sensitive (widget, automatic);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "ip4_never_default"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
nm_setting_ip_config_get_never_default (s_ip4));
/* Update initial validity */
validate (dialog);
return dialog;
}
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));
}
static void
populate_ui (CEPageIP4 *self)
{
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
NMSettingIP4Config *setting = priv->setting;
GtkListStore *store;
GtkTreeIter model_iter;
int method = IP4_METHOD_AUTO;
GString *string = NULL;
SetMethodInfo info;
const char *str_method;
int i;
/* Method */
gtk_combo_box_set_active (priv->method, 0);
str_method = nm_setting_ip4_config_get_method (setting);
if (str_method) {
if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL))
method = IP4_METHOD_LINK_LOCAL;
else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL))
method = IP4_METHOD_MANUAL;
else if (!strcmp (str_method, NM_SETTING_IP4_CONFIG_METHOD_SHARED))
method = IP4_METHOD_SHARED;
}
if (method == IP4_METHOD_AUTO && nm_setting_ip4_config_get_ignore_auto_dns (setting))
method = IP4_METHOD_AUTO_ADDRESSES;
info.method = method;
info.combo = priv->method;
gtk_tree_model_foreach (GTK_TREE_MODEL (priv->method_store), set_method, &info);
/* Addresses */
store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
for (i = 0; i < nm_setting_ip4_config_get_num_addresses (setting); i++) {
NMIP4Address *addr = nm_setting_ip4_config_get_address (setting, i);
struct in_addr tmp_addr;
char buf[INET_ADDRSTRLEN + 1];
const char *ignored;
if (!addr) {
g_warning ("%s: empty IP4 Address structure!", __func__);
continue;
}
gtk_list_store_append (store, &model_iter);
tmp_addr.s_addr = nm_ip4_address_get_address (addr);
ignored = inet_ntop (AF_INET, &tmp_addr, &buf[0], sizeof (buf));
gtk_list_store_set (store, &model_iter, COL_ADDRESS, buf, -1);
tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (addr));
ignored = inet_ntop (AF_INET, &tmp_addr, &buf[0], sizeof (buf));
gtk_list_store_set (store, &model_iter, COL_PREFIX, buf, -1);
tmp_addr.s_addr = nm_ip4_address_get_gateway (addr);
ignored = inet_ntop (AF_INET, &tmp_addr, &buf[0], sizeof (buf));
gtk_list_store_set (store, &model_iter, COL_GATEWAY, buf, -1);
}
gtk_tree_view_set_model (priv->addr_list, GTK_TREE_MODEL (store));
g_signal_connect_swapped (store, "row-inserted", G_CALLBACK (ce_page_changed), self);
g_signal_connect_swapped (store, "row-deleted", G_CALLBACK (ce_page_changed), self);
g_object_unref (store);
/* DNS servers */
string = g_string_new ("");
for (i = 0; i < nm_setting_ip4_config_get_num_dns (setting); i++) {
struct in_addr tmp_addr;
char buf[INET_ADDRSTRLEN + 1];
const char *ignored;
tmp_addr.s_addr = nm_setting_ip4_config_get_dns (setting, i);
if (!tmp_addr.s_addr)
continue;
ignored = inet_ntop (AF_INET, &tmp_addr, &buf[0], sizeof (buf));
if (string->len)
g_string_append (string, ", ");
g_string_append (string, buf);
}
gtk_entry_set_text (priv->dns_servers, string->str);
g_string_free (string, TRUE);
/* DNS searches */
string = g_string_new ("");
for (i = 0; i < nm_setting_ip4_config_get_num_dns_searches (setting); i++) {
if (string->len)
g_string_append (string, ", ");
g_string_append (string, nm_setting_ip4_config_get_dns_search (setting, i));
}
gtk_entry_set_text (priv->dns_searches, string->str);
g_string_free (string, TRUE);
if ((method == IP4_METHOD_AUTO) || (method = IP4_METHOD_AUTO_ADDRESSES)) {
if (nm_setting_ip4_config_get_dhcp_client_id (setting)) {
gtk_entry_set_text (priv->dhcp_client_id,
nm_setting_ip4_config_get_dhcp_client_id (setting));
}
}
}
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");
}
