colin/NetworkManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

2008-04-07 Dan Williams <dcbw@redhat.com>

Browse Source 
* include/NetworkManager.h
		- Remove the DOWN and CANCELLED device states
		- Add UNMANAGED and UNAVAILABLE device states
		- Document the device states

	* introspection/nm-device.xml
	  src/nm-device-interface.c
	  src/nm-device-interface.h
		- Add the 'managed' property

	* test/nm-tool.c
		- (detail_device): print out device state

	* src/NetworkManagerSystem.h
	  src/backends/NetworkManagerArch.c
	  src/backends/NetworkManagerDebian.c
	  src/backends/NetworkManagerFrugalware.c
	  src/backends/NetworkManagerGentoo.c
	  src/backends/NetworkManagerMandriva.c
	  src/backends/NetworkManagerPaldo.c
	  src/backends/NetworkManagerRedHat.c
	  src/backends/NetworkManagerSlackware.c
	  src/backends/NetworkManagerSuSE.c
		- (nm_system_device_get_system_config, nm_system_device_get_disabled
		   nm_system_device_free_system_config): remove; they were unused and
			their functionality should be re-implemented in each distro's
			system settings service plugin 

	* src/nm-gsm-device.c
	  src/nm-gsm-device.h
	  src/nm-cdma-device.c
	  src/nm-cdma-device.h
		- (*_new): take the 'managed' argument

	* src/nm-device.c
		- (nm_device_set_address): remove, fold into nm_device_bring_up()
		- (nm_device_init): start in unmanaged state, not disconnected
		- (constructor): don't start device until the system settings service
			has had a chance to figure out if the device is managed or not
		- (nm_device_deactivate, nm_device_bring_up, nm_device_bring_down):
			don't set device state here, let callers handle that as appropriate
		- (nm_device_dispose): don't touch the device if it's not managed
		- (set_property, get_property, nm_device_class_init): implement the
			'managed' property
		- (nm_device_state_changed): bring the device up if its now managed,
			and deactivate it if it used to be active
		- (nm_device_get_managed, nm_device_set_managed): do the right thing
			with the managed state

	* src/nm-hal-manager.c
		- (wired_device_creator, wireless_device_creator, modem_device_creator):
			take initial managed state and pass it along to device constructors
		- (create_device_and_add_to_list): get managed state and pass to
			type creators

	* src/nm-device-802-11-wireless.c
		- (real_can_activate): fold in most of
			nm_device_802_11_wireless_can_activate()
		- (can_scan): can't scan in UNAVAILABLE or UNMANAGED
		- (link_timeout_cb): instead of deactivating, change device state and
			let the device state handler to it
		- (real_update_hw_address): clean up
		- (state_changed_cb): when entering UNAVAILABLE state, schedule an idle
			handler to transition to DISCONNECTED if the device isn't rfkilled

	* src/nm-device-802-3-ethernet.c
		- (set_carrier): move above callers and get rid of prototype
		- (device_state_changed): when entering UNAVAILABLE state, schedule an
			idle handler to transition to DISCONNECTED if the device has a
			carrier
		- (real_update_hw_address): clean up
		- (link_timeout_cb, ppp_state_changed): change state instead of calling
			deactivation directly as deactivation doesn't change state anymore

	* src/NetworkManagerPolicy.c
		- (schedule_activate_check): yay, remove wireless_enabled hack since
			the NMManager and wireless devices work that out themselves now
		- (device_state_changed): change to a switch and update for new device
			states
		- (device_carrier_changed): remove; device handles this now through
			state changes
		- (device_added): don't care about carrier any more; the initial
			activation check will happen when the device transitions to
			DISCONNECTED

	* src/nm-manager.c
		- (dispose): clear unmanaged devices
		- (handle_unmanaged_devices): update unmanaged device list and toggle
			the managed property on each device when needed
		- (system_settings_properties_changed_cb): handle signals from the
			system settings service
		- (system_settings_get_unmanaged_devices_cb): handle callback from
			getting the unmanaged device list method call
		- (query_unmanaged_devices): ask the system settings service for its
			list of unmanaged devices
		- (nm_manager_name_owner_changed, initial_get_connections): get unmanaged
			devices
		- (manager_set_wireless_enabled): push rfkill state down to wireless
			devices directly and let them handle the necessary state transitions
		- (manager_device_state_changed): update for new device states
		- (nm_manager_add_device): set initial rfkill state on wireless devices
		- (nm_manager_remove_device): don't touch the device if it's unmanaged
		- (nm_manager_activate_connection): return error if the device is
			unmanaged
		- (nm_manager_sleep): handle new device states correctly; don't change
			the state of unavailable/unmanaged devices

	* libnm-glib/nm-device-802-11-wireless.c
		- (state_changed_cb): update for new device states



git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@3540 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
This commit is contained in:
Dan Williams
2008-04-08 02:58:02 +00:00
parent d773c8986a
commit 54aac18883
32 changed files with 711 additions and 1878 deletions
Download Patch File Download Diff File Expand all files Collapse all files

280
src/backends/NetworkManagerSuSE.c
View File

@@ -249,286 +249,6 @@ void nm_system_device_add_ip6_link_address (NMDevice *dev)
nm_generic_device_add_ip6_link_address (dev);
}
typedef struct SuSEDeviceConfigData
{
NMIP4Config * config;
gboolean use_dhcp;
gboolean system_disabled;
guint32 mtu;
} SuSEDeviceConfigData;
/*
* nm_system_device_get_system_config
*
* Read in the config file for a device.
*
* SuSE stores this information in /etc/sysconfig/network/ifcfg-*-<MAC address>
*
*/
void *nm_system_device_get_system_config (NMDevice *dev)
{
char *cfg_file_path = NULL;
char mac[18];
struct stat statbuf;
shvarFile *file;
char *buf = NULL;
SuSEDeviceConfigData *sys_data = NULL;
struct ether_addr hw_addr;
FILE *f = NULL;
char buffer[512];
gboolean error = FALSE;
int i, len;
struct in_addr temp_addr;
char *ip_str;
g_return_val_if_fail (dev != NULL, NULL);
sys_data = g_malloc0 (sizeof (SuSEDeviceConfigData));
sys_data->use_dhcp = TRUE;
if (NM_IS_DEVICE_802_3_ETHERNET (dev))
nm_device_802_3_ethernet_get_address (NM_DEVICE_802_3_ETHERNET (dev), &hw_addr);
else if (NM_IS_DEVICE_802_11_WIRELESS (dev))
nm_device_802_11_wireless_get_address (NM_DEVICE_802_11_WIRELESS (dev), &hw_addr);
sprintf (mac, "%02x:%02x:%02x:%02x:%02x:%02x",
hw_addr.ether_addr_octet[0], hw_addr.ether_addr_octet[1],
hw_addr.ether_addr_octet[2], hw_addr.ether_addr_octet[3],
hw_addr.ether_addr_octet[4], hw_addr.ether_addr_octet[5]);
cfg_file_path = g_strdup_printf (SYSCONFDIR"/sysconfig/network/ifcfg-eth-id-%s", mac);
if (!cfg_file_path)
return sys_data;
if (stat(cfg_file_path, &statbuf) == 0)
goto found;
g_free(cfg_file_path);
cfg_file_path = g_strdup_printf (SYSCONFDIR"/sysconfig/network/ifcfg-wlan-id-%s", mac);
if (!cfg_file_path)
return sys_data;
if (stat(cfg_file_path, &statbuf) == 0)
goto found;
g_free(cfg_file_path);
cfg_file_path = g_strdup_printf (SYSCONFDIR"/sysconfig/network/ifcfg-%s", nm_device_get_iface (dev));
if (!cfg_file_path)
return sys_data;
if (stat(cfg_file_path, &statbuf) == 0)
goto found;
g_free (cfg_file_path);
return sys_data;
found:
nm_debug ("found config '%s' for interface '%s'", cfg_file_path, nm_device_get_iface (dev));
if (!(file = svNewFile (cfg_file_path)))
{
g_free (cfg_file_path);
return sys_data;
}
g_free (cfg_file_path);
if ((buf = svGetValue (file, "BOOTPROTO")))
{
nm_debug ("BOOTPROTO=%s", buf);
if (strcasecmp (buf, "dhcp"))
sys_data->use_dhcp = FALSE;
free (buf);
}
if ((buf = svGetValue (file, "NM_CONTROLLED")))
{
nm_debug ("NM_CONTROLLED=%s", buf);
if (!strcasecmp (buf, "no"))
{
nm_info ("System configuration disables device %s", nm_device_get_iface (dev));
sys_data->system_disabled = TRUE;
}
free (buf);
}
if ((buf = svGetValue (file, "MTU")))
{
guint32 mtu;
errno = 0;
mtu = strtoul (buf, NULL, 10);
if (!errno && mtu > 500 && mtu < INT_MAX)
sys_data->mtu = mtu;
free (buf);
}
sys_data->config = nm_ip4_config_new ();
if (!sys_data->use_dhcp || sys_data->system_disabled)
{
buf = svGetValue (file, "IPADDR");
if (buf)
{
struct in_addr ip;
int ret;
ret = inet_aton (buf, &ip);
if (ret)
nm_ip4_config_set_address (sys_data->config, ip.s_addr);
else
error = TRUE;
free (buf);
}
else
error = TRUE;
if (error)
{
nm_warning ("Network configuration for device '%s' was invalid: Non-DHCP configuration, "
"but no IP address specified. Will use DHCP instead.", nm_device_get_iface (dev));
goto out;
}
if ((buf = svGetValue (file, "NETMASK")))
{
nm_ip4_config_set_netmask (sys_data->config, inet_addr (buf));
free (buf);
}
else
{
guint32 ip4addr = nm_ip4_config_get_address (sys_data->config);
/* Make a default netmask if we have an IP address */
if (((ntohl (ip4addr) & 0xFF000000) >> 24) <= 127)
nm_ip4_config_set_netmask (sys_data->config, htonl (0xFF000000));
else if (((ntohl (ip4addr) & 0xFF000000) >> 24) <= 191)
nm_ip4_config_set_netmask (sys_data->config, htonl (0xFFFF0000));
else
nm_ip4_config_set_netmask (sys_data->config, htonl (0xFFFFFF00));
}
if ((buf = svGetValue (file, "BROADCAST")))
{
nm_ip4_config_set_broadcast (sys_data->config, inet_addr (buf));
free (buf);
}
else
{
guint32 broadcast = ((nm_ip4_config_get_address (sys_data->config) & nm_ip4_config_get_netmask (sys_data->config))
| ~nm_ip4_config_get_netmask (sys_data->config));
nm_ip4_config_set_broadcast (sys_data->config, broadcast);
}
nm_ip4_config_set_mtu (sys_data->config, sys_data->mtu);
buf = NULL;
if ((f = fopen (SYSCONFDIR"/sysconfig/network/routes", "r")))
{
while (fgets (buffer, 512, f) && !feof (f))
{
buf = strtok(buffer, " ");
if (strcmp(buf, "default") == 0)
{
buf = strtok(NULL, " ");
if (buf)
nm_ip4_config_set_gateway (sys_data->config, inet_addr (buf));
break;
}
}
fclose (f);
}
if (!buf)
nm_info ("Network configuration for device '%s' does not specify a gateway but is "
"statically configured (non-DHCP).", nm_device_get_iface (dev));
nm_generic_set_ip4_config_from_resolv_conf (SYSCONFDIR"/resolv.conf", sys_data->config);
}
out:
svCloseFile (file);
if (error)
{
nm_debug ("error, enable dhcp");
sys_data->use_dhcp = TRUE;
/* Clear out the config */
g_object_unref (sys_data->config);
sys_data->config = NULL;
}
nm_debug ("------ Config (%s)", nm_device_get_iface (dev));
nm_debug ("dhcp=%u", sys_data->use_dhcp);
temp_addr.s_addr = nm_ip4_config_get_address (sys_data->config);
ip_str = g_strdup (inet_ntoa (temp_addr));
nm_debug ("addr=%s", ip_str);
g_free (ip_str);
temp_addr.s_addr = nm_ip4_config_get_gateway (sys_data->config);
ip_str = g_strdup (inet_ntoa (temp_addr));
nm_debug ("gw=%s", ip_str);
g_free (ip_str);
temp_addr.s_addr = nm_ip4_config_get_netmask (sys_data->config);
ip_str = g_strdup (inet_ntoa (temp_addr));
nm_debug ("mask=%s", ip_str);
g_free (ip_str);
if (sys_data->mtu)
nm_debug ("mtu=%u", sys_data->mtu);
len = nm_ip4_config_get_num_nameservers (sys_data->config);
for (i = 0; i < len; i++)
{
guint ns_addr = nm_ip4_config_get_nameserver (sys_data->config, i);
temp_addr.s_addr = ns_addr;
ip_str = g_strdup (inet_ntoa (temp_addr));
nm_debug ("ns_%u=%s", i, ip_str);
g_free (ip_str);
}
nm_debug ("---------------------\n");
return sys_data;
}
/*
* nm_system_device_free_system_config
*
* Free stored system config data
*
*/
void nm_system_device_free_system_config (NMDevice *dev, void *system_config_data)
{
SuSEDeviceConfigData *sys_data = (SuSEDeviceConfigData *)system_config_data;
g_return_if_fail (dev != NULL);
if (!sys_data)
return;
if (sys_data->config)
g_object_unref (sys_data->config);
}
/*
* nm_system_device_get_disabled
*
* Return whether the distribution has flagged this device as disabled.
*
*/
gboolean nm_system_device_get_disabled (NMDevice *dev)
{
SuSEDeviceConfigData *sys_data;
g_return_val_if_fail (dev != NULL, FALSE);
if ((sys_data = nm_device_get_system_config_data (dev)))
return sys_data->system_disabled;
return FALSE;
}
/*
* nm_system_activate_nis
*