colin/NetworkManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b16f8eea161f40d95ddee9c88786fca6b51f4976
NetworkManager/test/nm-tool.c
Robert Love e92a2cc651 2006-03-02 Robert Love <rml@novell.com> 
Add support for retrieving both the per-device speed and the
	per-network maximum supported rate.  Then change the getProperties
	DBUS API for both networks and devices to report this informaiton.
	Finally, display the information via both nm-applet and nm-tool:
	* gnome/applet/applet-dbus-devices.c: Grab the speed from getProperties
	  and set it.
	* gnome/applet/applet.c: Display the device's speed in the 'Connection
	  Information' dialog.
	* gnome/applet/applet.glade: Update the UI to show per-device speed.
	* gnome/applet/nm-device.c, gnome/applet/nm-device.h: Add interfaces
	  network_device_get_speed() and network_device_set_speed() for
	  retrieving and setting, respectively, a network device's current
	  speed.
	* src/nm-dbus-device.c: Send the device's speed on getProperties.
	* src/nm-device-802-11-wireless.c: Return the rate in Mb/s, not Kb/s,
	  in the function nm_device_802_11_wireless_get_bitrate() -- it does
	  not matter (yet) what the units are, because we only feed it its own
	  output.  Implement SIOCGIRATE and set the per-network maximum
	  supported rate during scanning.
	* src/nm-device-802-11-wireless.h: Export the function
	  nm_device_802_11_wireless_get_bitrate().
	* src/nm-device-802-3-ethernet.c, src/nm-device-802-3-ethernet.h: Add
	  function nm_device_802_3_ethernet_get_speed() for returning an
	  802.3's current speed, in Mb/s.
	* test/nm-tool.c: Display the per-device current speed, if available,
	  and the per-network maximum rate.


git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@1540 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
2006-03-02 23:01:33 +00:00

485 lines
13 KiB
C
Raw Blame History

/* nm-tool - information tool for NetworkManager
*
* Dan Williams <dcbw@redhat.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* (C) Copyright 2005 Red Hat, Inc.
*/
#include <glib.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iwlib.h>
#include "NetworkManager.h"
#include "nm-utils.h"
static gboolean get_nm_state (DBusConnection *connection)
{
dbus_uint32_t uint32_state;
char * state_string = NULL;
gboolean success = TRUE;
DBusMessage * message = NULL;
DBusMessage * reply = NULL;
if (!(message = dbus_message_new_method_call (NM_DBUS_SERVICE, NM_DBUS_PATH, NM_DBUS_INTERFACE, "state")))
{
fprintf (stderr, "get_nm_state(): couldn't create new dbus message.\n");
return FALSE;
}
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, NULL);
dbus_message_unref (message);
if (!reply)
{
fprintf (stderr, "get_nm_state(): didn't get a reply from NetworkManager.\n");
return FALSE;
}
if (!dbus_message_get_args (reply, NULL, DBUS_TYPE_UINT32, &uint32_state, DBUS_TYPE_INVALID))
{
fprintf (stderr, "get_nm_state(): unexpected reply from NetworkManager.\n");
return FALSE;
}
switch ((NMState) uint32_state)
{
case NM_STATE_ASLEEP:
state_string = "asleep";
break;
case NM_STATE_CONNECTING:
state_string = "connecting";
break;
case NM_STATE_CONNECTED:
state_string = "connected";
break;
case NM_STATE_DISCONNECTED:
state_string = "disconnected";
break;
case NM_STATE_UNKNOWN:
default:
state_string = "unknown";
success = FALSE;
break;
}
fprintf (stderr, "State: %s\n\n", state_string);
return success;
}
static void print_string (const char *label, const char *data)
{
#define SPACING 18
int label_len = 0;
char spaces[50];
int i;
g_return_if_fail (label != NULL);
g_return_if_fail (data != NULL);
label_len = strlen (label);
if (label_len > SPACING)
label_len = SPACING - 1;
for (i = 0; i < (SPACING - label_len); i++)
spaces[i] = 0x20;
spaces[i] = 0x00;
printf (" %s:%s%s\n", label, &spaces[0], data);
}
static void detail_network (DBusConnection *connection, const char *path, const char *active_path)
{
DBusMessage * message = NULL;
DBusMessage * reply = NULL;
const char * op = NULL;
const char * essid = NULL;
const char * hw_addr = NULL;
dbus_int32_t strength = -1;
double freq = 0;
dbus_int32_t rate = 0;
dbus_int32_t capabilities = NM_802_11_CAP_NONE;
dbus_uint32_t mode = 0;
gboolean broadcast = TRUE;
g_return_if_fail (connection != NULL);
g_return_if_fail (path != NULL);
if (!(message = dbus_message_new_method_call (NM_DBUS_SERVICE, path, NM_DBUS_INTERFACE_DEVICES, "getProperties")))
{
fprintf (stderr, "detail_network(): couldn't create new dbus message.\n");
return;
}
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, NULL);
dbus_message_unref (message);
if (!reply)
{
fprintf (stderr, "detail_network(): didn't get a reply from NetworkManager for device %s.\n", path);
return;
}
if (dbus_message_get_args (reply, NULL, DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_STRING, &essid,
DBUS_TYPE_STRING, &hw_addr,
DBUS_TYPE_INT32, &strength,
DBUS_TYPE_DOUBLE, &freq,
DBUS_TYPE_INT32, &rate,
DBUS_TYPE_INT32, &mode,
DBUS_TYPE_INT32, &capabilities,
DBUS_TYPE_BOOLEAN, &broadcast,
DBUS_TYPE_INVALID))
{
char *temp = NULL;
char *temp_essid = NULL;
float flt_freq = freq / 1000000000;
gboolean active = (active_path && !strcmp (active_path, path)) ? TRUE : FALSE;
GString *enc_string = g_string_new (NULL);
if (capabilities & NM_802_11_CAP_PROTO_WEP)
enc_string = g_string_append (enc_string, "WEP");
if (capabilities & NM_802_11_CAP_PROTO_WPA)
{
if (enc_string->str && (strlen (enc_string->str) > 0))
enc_string = g_string_append_c (enc_string, ' ');
enc_string = g_string_append (enc_string, "WPA");
}
if (capabilities & NM_802_11_CAP_PROTO_WPA2)
{
if (enc_string->str && (strlen (enc_string->str) > 0))
enc_string = g_string_append_c (enc_string, ' ');
enc_string = g_string_append (enc_string, "WPA2");
}
if (capabilities & NM_802_11_CAP_KEY_MGMT_802_1X)
{
if (enc_string->str && (strlen (enc_string->str) > 0))
enc_string = g_string_append_c (enc_string, ' ');
enc_string = g_string_append (enc_string, "Enterprise");
}
if (enc_string->str && (strlen (enc_string->str) > 0))
{
enc_string = g_string_prepend (enc_string, ", Encrypted (");
enc_string = g_string_append (enc_string, ")");
}
temp = g_strdup_printf ("%s Mode, Freq %.3f MHz, Rate %d Mb/s, Strength %d%%%s%s",
(mode == IW_MODE_INFRA) ? "Infrastructure" : "Ad-Hoc",
flt_freq,
rate / 1024,
strength,
(enc_string && strlen (enc_string->str)) ? enc_string->str : "",
!broadcast ? ", Hidden" : "");
temp_essid = g_strdup_printf (" %s%s", active ? "*" : "", essid);
print_string (temp_essid, temp);
g_string_free (enc_string, TRUE);
g_free (temp_essid);
g_free (temp);
}
else
fprintf (stderr, "detail_network(): unexpected reply from NetworkManager for device %s.\n", path);
dbus_message_unref (reply);
}
static char *
get_driver_name (DBusConnection *connection, const char *path)
{
DBusMessage * message;
DBusMessage * reply;
char * driver = NULL;
DBusError error;
g_return_val_if_fail (path != NULL, NULL);
if (!(message = dbus_message_new_method_call (NM_DBUS_SERVICE, path, NM_DBUS_INTERFACE_DEVICES, "getDriver")))
{
nm_warning ("%s(): Couldn't allocate the dbus message", __func__);
return NULL;
}
dbus_error_init (&error);
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error);
dbus_message_unref (message);
if (dbus_error_is_set (&error))
dbus_error_free (&error);
else if (reply)
{
if (dbus_message_get_args (reply, NULL, DBUS_TYPE_STRING, &driver, DBUS_TYPE_INVALID))
driver = g_strdup (driver);
dbus_message_unref (reply);
}
return driver;
}
static void detail_device (DBusConnection *connection, const char *path)
{
DBusMessage * message = NULL;
DBusMessage * reply = NULL;
char * op = NULL;
const char * iface = NULL;
dbus_uint32_t type = 0;
const char * udi = NULL;
dbus_bool_t active = FALSE;
const char * ip4_address = NULL;
const char * broadcast = NULL;
const char * subnetmask = NULL;
const char * hw_addr = NULL;
const char * route = NULL;
const char * primary_dns = NULL;
const char * secondary_dns = NULL;
dbus_uint32_t mode = 0;
dbus_int32_t strength = -1;
char * active_network_path = NULL;
dbus_bool_t link_active = FALSE;
dbus_int32_t speed = 0;
dbus_uint32_t caps = NM_DEVICE_CAP_NONE;
dbus_uint32_t type_caps = NM_DEVICE_CAP_NONE;
char ** networks = NULL;
int num_networks = 0;
NMActStage act_stage = NM_ACT_STAGE_UNKNOWN;
g_return_if_fail (connection != NULL);
g_return_if_fail (path != NULL);
if (!(message = dbus_message_new_method_call (NM_DBUS_SERVICE, path, NM_DBUS_INTERFACE_DEVICES, "getProperties")))
{
fprintf (stderr, "detail_device(): couldn't create new dbus message.\n");
return;
}
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, NULL);
dbus_message_unref (message);
if (!reply)
{
fprintf (stderr, "detail_device(): didn't get a reply from NetworkManager for device %s.\n", path);
return;
}
if (dbus_message_get_args (reply, NULL, DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_STRING, &iface,
DBUS_TYPE_UINT32, &type,
DBUS_TYPE_STRING, &udi,
DBUS_TYPE_BOOLEAN,&active,
DBUS_TYPE_UINT32, &act_stage,
DBUS_TYPE_STRING, &ip4_address,
DBUS_TYPE_STRING, &subnetmask,
DBUS_TYPE_STRING, &broadcast,
DBUS_TYPE_STRING, &hw_addr,
DBUS_TYPE_STRING, &route,
DBUS_TYPE_STRING, &primary_dns,
DBUS_TYPE_STRING, &secondary_dns,
DBUS_TYPE_INT32, &mode,
DBUS_TYPE_INT32, &strength,
DBUS_TYPE_BOOLEAN,&link_active,
DBUS_TYPE_INT32, &speed,
DBUS_TYPE_UINT32, &caps,
DBUS_TYPE_UINT32, &type_caps,
DBUS_TYPE_STRING, &active_network_path,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &networks, &num_networks,
DBUS_TYPE_INVALID))
{
char * driver;
printf ("- Device: %s ----------------------------------------------------------------\n", iface);
/* General information */
print_string ("NM Path", op);
if (type == DEVICE_TYPE_802_11_WIRELESS)
print_string ("Type", "802.11 Wireless");
else if (type == DEVICE_TYPE_802_3_ETHERNET)
print_string ("Type", "Wired");
if ((driver = get_driver_name (connection, path)))
print_string ("Driver", driver);
else
print_string ("Driver", "(unknown)");
if (active)
print_string ("Active", "yes");
else
print_string ("Active", "no");
print_string ("HW Address", hw_addr);
/* Capabilities */
fprintf (stderr, "\n Capabilities:\n");
if (caps & NM_DEVICE_CAP_NM_SUPPORTED)
print_string (" Supported", "yes");
else
print_string (" Supported", "no");
if (caps & NM_DEVICE_CAP_CARRIER_DETECT)
print_string (" Carrier Detect", "yes");
if (speed)
{
char *speed_string;
speed_string = g_strdup_printf ("%d Mb/s", speed);
print_string (" Speed", speed_string);
g_free (speed_string);
}
/* Wireless specific information */
if (type == DEVICE_TYPE_802_11_WIRELESS)
{
int i;
printf ("\n Wireless Settings\n");
if (caps & NM_DEVICE_CAP_WIRELESS_SCAN)
print_string (" Scanning", "yes");
if (type_caps & NM_802_11_CAP_PROTO_WEP)
print_string (" WEP Encryption", "yes");
if (type_caps & NM_802_11_CAP_PROTO_WPA)
print_string (" WPA Encryption", "yes");
if (type_caps & NM_802_11_CAP_PROTO_WPA2)
print_string (" WPA2 Encryption", "yes");
/*
printf ("\n Wireless Settings\n");
if (mode == IW_MODE_INFRA)
print_string (" Mode", "Infrastructure");
else if (mode == IW_MODE_ADHOC)
print_string (" Mode", "Ad-Hoc");
str_strength = g_strdup_printf ("%d%%", strength);
print_string (" Strength", str_strength);
g_free (str_strength);
*/
printf ("\n Wireless Networks (* = Current Network)\n");
for (i = 0; i < num_networks; i++)
detail_network (connection, networks[i], active_network_path);
}
else if (type == DEVICE_TYPE_802_3_ETHERNET)
{
printf ("\n Wired Settings\n");
if (link_active)
print_string (" Hardware Link", "yes");
else
print_string (" Hardware Link", "no");
}
/* IP Setup info */
if (active)
{
printf ("\n IP Settings:\n");
print_string (" IP Address", ip4_address);
print_string (" Subnet Mask", subnetmask);
print_string (" Broadcast", broadcast);
print_string (" Gateway", route);
print_string (" Primary DNS", primary_dns);
print_string (" Secondary DNS", secondary_dns);
}
printf ("\n\n");
dbus_free_string_array (networks);
}
else
fprintf (stderr, "detail_device(): unexpected reply from NetworkManager for device %s.\n", path);
dbus_message_unref (reply);
}
static void print_devices (DBusConnection *connection)
{
DBusMessage * message = NULL;
DBusMessage * reply = NULL;
DBusError error;
char ** paths = NULL;
int num = -1;
int i;
if (!(message = dbus_message_new_method_call (NM_DBUS_SERVICE, NM_DBUS_PATH, NM_DBUS_INTERFACE, "getDevices")))
{
fprintf (stderr, "print_devices(): couldn't create new dbus message.\n");
return;
}
dbus_error_init (&error);
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error);
dbus_message_unref (message);
if (!reply)
{
fprintf (stderr, "print_devices(): didn't get a reply from NetworkManager.\n");
if (dbus_error_is_set (&error))
{
if (dbus_error_has_name (&error, NM_DBUS_NO_DEVICES_ERROR))
fprintf (stderr, "There are no available network devices.\n");
}
else
fprintf (stderr, "print_devices(): NetworkManager returned an error: '%s'\n", error.message);
return;
}
if (!dbus_message_get_args (reply, NULL, DBUS_TYPE_ARRAY, DBUS_TYPE_OBJECT_PATH, &paths, &num, DBUS_TYPE_INVALID))
{
fprintf (stderr, "print_devices(): unexpected reply from NetworkManager.\n");
dbus_message_unref (reply);
return;
}
for (i = 0; i < num; i++)
detail_device (connection, paths[i]);
dbus_free_string_array (paths);
dbus_message_unref (reply);
}
int main( int argc, char *argv[] )
{
DBusConnection *connection;
DBusError error;
g_type_init ();
dbus_error_init (&error);
connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
if (connection == NULL)
{
fprintf (stderr, "Error connecting to system bus: %s\n", error.message);
dbus_error_free (&error);
return 1;
}
printf ("\nNetworkManager Tool\n\n");
if (!get_nm_state (connection))
{
fprintf (stderr, "\n\nNetworkManager appears not to be running (could not get its state).\n");
exit (1);
}
print_devices (connection);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink