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

2007-08-14 Dan Williams <dcbw@redhat.com>

Browse Source 
* include/NetworkManagerVPN.h
	  src/vpn-manager/nm-dbus-vpn.c
	  src/vpn-manager/nm-dbus-vpn.h
	  src/vpn-manager/nm-vpn-act-request.c
	  src/vpn-manager/nm-vpn-act-request.h
	  src/vpn-manager/nm-vpn-service.c
	  src/vpn-manager/nm-vpn-service.h
	  libnm-glib/nm-vpn-connection.c
	  libnm-glib/nm-vpn-connection.h
	  libnm-glib/nm-client.h
		- Rename NM_VPN_STATE_* -> NM_VPN_SERVICE_STATE_* and NMVPNState -> 
			NMVPNServiceState to clarify what they apply to
		- Rename NM_VPN_ACT_STAGE_* -> NM_VPN_CONNECTION_STATE_* and
			NMVPNActStage -> NMVPNConnectionState for the same reason

	* libnm-glib/nm-client.c
		- Constant + type renames from above
		- Properly handle NameOwnerChanged/manager_running signals
			for NM service; only emit when state really changes
		- Use hash tables correctly so that the key (which was previously owned
			by the D-Bus message) now has the same lifetime as the value, since
			the key is now taken from the the NMVPNConnection itself.  This
			really fixes the double-VPN names in the applet



git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@2677 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
This commit is contained in:
Dan Williams
2007-08-14 14:09:57 +00:00
parent d02e8b4886
commit e3d15a5f73
12 changed files with 250 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
ChangeLog
View File

@@ -1,3 +1,29 @@
2007-08-14 Dan Williams <dcbw@redhat.com>
* include/NetworkManagerVPN.h
src/vpn-manager/nm-dbus-vpn.c
src/vpn-manager/nm-dbus-vpn.h
src/vpn-manager/nm-vpn-act-request.c
src/vpn-manager/nm-vpn-act-request.h
src/vpn-manager/nm-vpn-service.c
src/vpn-manager/nm-vpn-service.h
libnm-glib/nm-vpn-connection.c
libnm-glib/nm-vpn-connection.h
libnm-glib/nm-client.h
- Rename NM_VPN_STATE_* -> NM_VPN_SERVICE_STATE_* and NMVPNState ->
NMVPNServiceState to clarify what they apply to
- Rename NM_VPN_ACT_STAGE_* -> NM_VPN_CONNECTION_STATE_* and
NMVPNActStage -> NMVPNConnectionState for the same reason
* libnm-glib/nm-client.c
- Constant + type renames from above
- Properly handle NameOwnerChanged/manager_running signals
for NM service; only emit when state really changes
- Use hash tables correctly so that the key (which was previously owned
by the D-Bus message) now has the same lifetime as the value, since
the key is now taken from the the NMVPNConnection itself. This
really fixes the double-VPN names in the applet
2007-08-13 Dan Williams <dcbw@redhat.com> 2007-08-13 Dan Williams <dcbw@redhat.com>
Patch from Michael Biebl <biebl@debian.org> Patch from Michael Biebl <biebl@debian.org>

40
include/NetworkManagerVPN.h
View File

@@ -59,32 +59,32 @@
/* /*
* VPN daemon states * VPN daemon states
*/ */
typedef enum NMVPNState typedef enum NMVPNServiceState
{ {
NM_VPN_STATE_UNKNOWN = 0, NM_VPN_SERVICE_STATE_UNKNOWN = 0,
NM_VPN_STATE_INIT, NM_VPN_SERVICE_STATE_INIT,
NM_VPN_STATE_SHUTDOWN, NM_VPN_SERVICE_STATE_SHUTDOWN,
NM_VPN_STATE_STARTING, NM_VPN_SERVICE_STATE_STARTING,
NM_VPN_STATE_STARTED, NM_VPN_SERVICE_STATE_STARTED,
NM_VPN_STATE_STOPPING, NM_VPN_SERVICE_STATE_STOPPING,
NM_VPN_STATE_STOPPED NM_VPN_SERVICE_STATE_STOPPED
} NMVPNState; } NMVPNServiceState;
/* /*
* VPN connection activation stages * VPN connection states
*/ */
typedef enum NMVPNActStage typedef enum NMVPNConnectionState
{ {
NM_VPN_ACT_STAGE_UNKNOWN = 0, NM_VPN_CONNECTION_STATE_UNKNOWN = 0,
NM_VPN_ACT_STAGE_DISCONNECTED, NM_VPN_CONNECTION_STATE_DISCONNECTED,
NM_VPN_ACT_STAGE_PREPARE, NM_VPN_CONNECTION_STATE_PREPARE,
NM_VPN_ACT_STAGE_CONNECT, NM_VPN_CONNECTION_STATE_CONNECT,
NM_VPN_ACT_STAGE_IP_CONFIG_GET, NM_VPN_CONNECTION_STATE_IP_CONFIG_GET,
NM_VPN_ACT_STAGE_ACTIVATED, NM_VPN_CONNECTION_STATE_ACTIVATED,
NM_VPN_ACT_STAGE_FAILED, NM_VPN_CONNECTION_STATE_FAILED,
NM_VPN_ACT_STAGE_CANCELED NM_VPN_CONNECTION_STATE_CANCELED
} NMVPNActStage; } NMVPNConnectionState;
#endif /* NETWORK_MANAGER_VPN_H */ #endif /* NETWORK_MANAGER_VPN_H */

66
libnm-glib/nm-client.c
View File

@@ -21,7 +21,7 @@ typedef struct {
GHashTable *devices; GHashTable *devices;
DBusGProxy *vpn_proxy; DBusGProxy *vpn_proxy;
NMVPNActStage vpn_state; NMVPNConnectionState vpn_state;
gboolean have_vpn_connections; gboolean have_vpn_connections;
GHashTable *vpn_connections; GHashTable *vpn_connections;
} NMClientPrivate; } NMClientPrivate;
@@ -64,12 +64,9 @@ nm_client_init (NMClient *client)
(GDestroyNotify) g_free, (GDestroyNotify) g_free,
(GDestroyNotify) g_object_unref); (GDestroyNotify) g_object_unref);
priv->vpn_connections = g_hash_table_new_full (g_str_hash, priv->vpn_connections = g_hash_table_new (g_str_hash, g_str_equal);
g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) g_object_unref);
priv->vpn_state = NM_VPN_ACT_STAGE_UNKNOWN; priv->vpn_state = NM_VPN_CONNECTION_STATE_UNKNOWN;
} }
static GObject* static GObject*
@@ -284,13 +281,22 @@ proxy_name_owner_changed (DBusGProxy *proxy,
{ {
if (name && !strcmp (name, NM_DBUS_SERVICE)) { if (name && !strcmp (name, NM_DBUS_SERVICE)) {
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (user_data); NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (user_data);
gboolean old_good = (old_owner && strlen (old_owner));
gboolean new_good = (new_owner && strlen (new_owner));
gboolean new_running = FALSE;
if (new_owner && strlen (new_owner) > 0) if (!old_good && new_good)
priv->manager_running = TRUE; new_running = TRUE;
else else if (old_good && !new_good)
priv->manager_running = FALSE; new_running = FALSE;
g_signal_emit (NM_CLIENT (user_data), signals[MANAGER_RUNNING], 0, priv->manager_running); if (new_running != priv->manager_running) {
priv->manager_running = new_running;
g_signal_emit (NM_CLIENT (user_data),
signals[MANAGER_RUNNING],
0,
priv->manager_running);
}
} }
} }
@@ -499,16 +505,16 @@ nm_client_sleep (NMClient *client, gboolean sleep)
* For the exact state, each connection has it's own state which' changes * For the exact state, each connection has it's own state which' changes
* are also signalled. * are also signalled.
*/ */
static NMVPNActStage static NMVPNConnectionState
nm_client_get_best_vpn_state (NMClient *client) nm_client_get_best_vpn_state (NMClient *client)
{ {
GSList *iter; GSList *iter;
NMVPNActStage state; NMVPNConnectionState state;
NMVPNActStage best_state = NM_VPN_ACT_STAGE_UNKNOWN; NMVPNConnectionState best_state = NM_VPN_CONNECTION_STATE_UNKNOWN;
for (iter = nm_client_get_vpn_connections (client); iter; iter = iter->next) { for (iter = nm_client_get_vpn_connections (client); iter; iter = iter->next) {
state = nm_vpn_connection_get_state (NM_VPN_CONNECTION (iter->data)); state = nm_vpn_connection_get_state (NM_VPN_CONNECTION (iter->data));
if (state > best_state && state < NM_VPN_ACT_STAGE_FAILED) if (state > best_state && state < NM_VPN_CONNECTION_STATE_FAILED)
best_state = state; best_state = state;
} }
@@ -516,12 +522,15 @@ nm_client_get_best_vpn_state (NMClient *client)
} }
static void static void
proxy_vpn_state_change (DBusGProxy *proxy, char *connection_name, NMVPNActStage state, gpointer user_data) proxy_vpn_state_change (DBusGProxy *proxy,
char *connection_name,
NMVPNConnectionState state,
gpointer user_data)
{ {
NMClient *client = NM_CLIENT (user_data); NMClient *client = NM_CLIENT (user_data);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client); NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client);
NMVPNConnection *connection; NMVPNConnection *connection;
NMVPNActStage best_state; NMVPNConnectionState best_state;
connection = nm_client_get_vpn_connection_by_name (client, connection_name); connection = nm_client_get_vpn_connection_by_name (client, connection_name);
if (connection) if (connection)
@@ -540,6 +549,7 @@ proxy_vpn_connection_added (DBusGProxy *proxy, char *name, gpointer user_data)
NMClient *client = NM_CLIENT (user_data); NMClient *client = NM_CLIENT (user_data);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client); NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client);
NMVPNConnection *connection; NMVPNConnection *connection;
const char * vpn_name;
if (g_hash_table_lookup (priv->vpn_connections, name)) if (g_hash_table_lookup (priv->vpn_connections, name))
return; return;
@@ -553,7 +563,11 @@ proxy_vpn_connection_added (DBusGProxy *proxy, char *name, gpointer user_data)
return; return;
} }
g_hash_table_insert (priv->vpn_connections, name, connection); /* Use the vpn connection object's name to insert into the hash table
* so that it's lifetime is the same as the vpn connection object.
*/
vpn_name = nm_vpn_connection_get_name (connection);
g_hash_table_insert (priv->vpn_connections, (char *) vpn_name, connection);
g_signal_emit (client, signals[VPN_CONNECTION_ADDED], 0, connection); g_signal_emit (client, signals[VPN_CONNECTION_ADDED], 0, connection);
} }
@@ -638,8 +652,8 @@ get_connections (NMClient *client)
} }
static void static void
clear_one_vpn_connection (gpointer data, signal_one_vpn_connection_removed (gpointer data,
gpointer user_data) gpointer user_data)
{ {
NMClient * client = NM_CLIENT (user_data); NMClient * client = NM_CLIENT (user_data);
NMVPNConnection * connection = NM_VPN_CONNECTION (data); NMVPNConnection * connection = NM_VPN_CONNECTION (data);
@@ -658,9 +672,9 @@ clear_vpn_connections (NMClient * client)
priv = NM_CLIENT_GET_PRIVATE (client); priv = NM_CLIENT_GET_PRIVATE (client);
list = nm_client_get_vpn_connections (client); list = nm_client_get_vpn_connections (client);
g_hash_table_steal_all (priv->vpn_connections); g_hash_table_remove_all (priv->vpn_connections);
g_slist_foreach (list, clear_one_vpn_connection, client); g_slist_foreach (list, signal_one_vpn_connection_removed, client);
g_slist_foreach (list, (GFunc) g_object_unref, NULL); g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list); g_slist_free (list);
} }
@@ -751,21 +765,21 @@ nm_client_remove_vpn_connection (NMClient *client, NMVPNConnection *connection)
return; return;
} }
g_hash_table_steal (priv->vpn_connections, info.found_key); g_hash_table_remove (priv->vpn_connections, info.found_key);
g_signal_emit (client, signals[VPN_CONNECTION_REMOVED], 0, connection); g_signal_emit (client, signals[VPN_CONNECTION_REMOVED], 0, connection);
g_object_unref (connection); g_object_unref (connection);
} }
NMVPNActStage NMVPNConnectionState
nm_client_get_vpn_state (NMClient *client) nm_client_get_vpn_state (NMClient *client)
{ {
NMClientPrivate *priv; NMClientPrivate *priv;
g_return_val_if_fail (NM_IS_CLIENT (client), NM_VPN_ACT_STAGE_UNKNOWN); g_return_val_if_fail (NM_IS_CLIENT (client), NM_VPN_CONNECTION_STATE_UNKNOWN);
priv = NM_CLIENT_GET_PRIVATE (client); priv = NM_CLIENT_GET_PRIVATE (client);
if (priv->vpn_state == NM_VPN_ACT_STAGE_UNKNOWN) if (priv->vpn_state == NM_VPN_CONNECTION_STATE_UNKNOWN)
priv->vpn_state = nm_client_get_best_vpn_state (client); priv->vpn_state = nm_client_get_best_vpn_state (client);
return priv->vpn_state; return priv->vpn_state;

4
libnm-glib/nm-client.h
View File

@@ -35,7 +35,7 @@ typedef struct {
void (*vpn_connection_added) (NMClient *client, NMVPNConnection *connection); void (*vpn_connection_added) (NMClient *client, NMVPNConnection *connection);
void (*vpn_connection_removed) (NMClient *client, NMVPNConnection *connection); void (*vpn_connection_removed) (NMClient *client, NMVPNConnection *connection);
void (*vpn_state_change) (NMClient *client, NMVPNActStage state); void (*vpn_state_change) (NMClient *client, NMVPNConnectionState state);
} NMClientClass; } NMClientClass;
GType nm_client_get_type (void); GType nm_client_get_type (void);
@@ -62,7 +62,7 @@ NMVPNConnection *nm_client_get_vpn_connection_by_name (NMClient *client,
void nm_client_remove_vpn_connection (NMClient *client, void nm_client_remove_vpn_connection (NMClient *client,
NMVPNConnection *connection); NMVPNConnection *connection);
NMVPNActStage nm_client_get_vpn_state (NMClient *client); NMVPNConnectionState nm_client_get_vpn_state (NMClient *client);
G_END_DECLS G_END_DECLS

26
libnm-glib/nm-vpn-connection.c
View File

@@ -31,7 +31,7 @@ typedef struct {
char *name; char *name;
char *user_name; char *user_name;
char *service; char *service;
NMVPNActStage state; NMVPNConnectionState state;
} NMVPNConnectionPrivate; } NMVPNConnectionPrivate;
enum { enum {
@@ -48,7 +48,7 @@ nm_vpn_connection_init (NMVPNConnection *connection)
{ {
NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection); NMVPNConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (connection);
priv->state = NM_VPN_ACT_STAGE_UNKNOWN; priv->state = NM_VPN_CONNECTION_STATE_UNKNOWN;
} }
static void static void
@@ -99,7 +99,7 @@ update_properties (NMVPNConnection *connection)
char *name = NULL; char *name = NULL;
char *user_name = NULL; char *user_name = NULL;
char *service = NULL; char *service = NULL;
NMVPNActStage state; NMVPNConnectionState state;
GError *err = NULL; GError *err = NULL;
priv = NM_VPN_CONNECTION_GET_PRIVATE (connection); priv = NM_VPN_CONNECTION_GET_PRIVATE (connection);
@@ -125,7 +125,7 @@ update_properties (NMVPNConnection *connection)
priv->user_name = user_name; priv->user_name = user_name;
priv->service = service; priv->service = service;
nm_vpn_connection_set_state (connection, (NMVPNActStage) state); nm_vpn_connection_set_state (connection, (NMVPNConnectionState) state);
return TRUE; return TRUE;
} }
@@ -192,16 +192,16 @@ nm_vpn_connection_get_service (NMVPNConnection *vpn)
return NM_VPN_CONNECTION_GET_PRIVATE (vpn)->service; return NM_VPN_CONNECTION_GET_PRIVATE (vpn)->service;
} }
NMVPNActStage NMVPNConnectionState
nm_vpn_connection_get_state (NMVPNConnection *vpn) nm_vpn_connection_get_state (NMVPNConnection *vpn)
{ {
g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), NM_VPN_ACT_STAGE_UNKNOWN); g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), NM_VPN_CONNECTION_STATE_UNKNOWN);
return NM_VPN_CONNECTION_GET_PRIVATE (vpn)->state; return NM_VPN_CONNECTION_GET_PRIVATE (vpn)->state;
} }
void void
nm_vpn_connection_set_state (NMVPNConnection *vpn, NMVPNActStage state) nm_vpn_connection_set_state (NMVPNConnection *vpn, NMVPNConnectionState state)
{ {
NMVPNConnectionPrivate *priv; NMVPNConnectionPrivate *priv;
@@ -217,14 +217,14 @@ nm_vpn_connection_set_state (NMVPNConnection *vpn, NMVPNActStage state)
gboolean gboolean
nm_vpn_connection_is_activating (NMVPNConnection *vpn) nm_vpn_connection_is_activating (NMVPNConnection *vpn)
{ {
NMVPNActStage state; NMVPNConnectionState state;
g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), FALSE); g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), FALSE);
state = nm_vpn_connection_get_state (vpn); state = nm_vpn_connection_get_state (vpn);
if (state == NM_VPN_ACT_STAGE_PREPARE || if (state == NM_VPN_CONNECTION_STATE_PREPARE ||
state == NM_VPN_ACT_STAGE_CONNECT || state == NM_VPN_CONNECTION_STATE_CONNECT ||
state == NM_VPN_ACT_STAGE_IP_CONFIG_GET) state == NM_VPN_CONNECTION_STATE_IP_CONFIG_GET)
return TRUE; return TRUE;
return FALSE; return FALSE;
@@ -240,7 +240,7 @@ nm_vpn_connection_activate (NMVPNConnection *vpn, GSList *passwords)
g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), FALSE); g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), FALSE);
g_return_val_if_fail (passwords != NULL, FALSE); g_return_val_if_fail (passwords != NULL, FALSE);
if (nm_vpn_connection_get_state (vpn) != NM_VPN_ACT_STAGE_DISCONNECTED) { if (nm_vpn_connection_get_state (vpn) != NM_VPN_CONNECTION_STATE_DISCONNECTED) {
g_warning ("VPN connection is already connected or connecting"); g_warning ("VPN connection is already connected or connecting");
return FALSE; return FALSE;
} }
@@ -269,7 +269,7 @@ nm_vpn_connection_deactivate (NMVPNConnection *vpn)
{ {
g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), FALSE); g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), FALSE);
if (nm_vpn_connection_get_state (vpn) != NM_VPN_ACT_STAGE_ACTIVATED && if (nm_vpn_connection_get_state (vpn) != NM_VPN_CONNECTION_STATE_ACTIVATED &&
!nm_vpn_connection_is_activating (vpn)) { !nm_vpn_connection_is_activating (vpn)) {
g_warning ("VPN connection isn't activated"); g_warning ("VPN connection isn't activated");
return FALSE; return FALSE;

6
libnm-glib/nm-vpn-connection.h
View File

@@ -45,7 +45,7 @@ typedef struct {
/* Signals */ /* Signals */
void (*updated) (NMVPNConnection *connection); void (*updated) (NMVPNConnection *connection);
void (*state_changed) (NMVPNConnection *connection, NMVPNActStage state); void (*state_changed) (NMVPNConnection *connection, NMVPNConnectionState state);
} NMVPNConnectionClass; } NMVPNConnectionClass;
GType nm_vpn_connection_get_type (void); GType nm_vpn_connection_get_type (void);
@@ -57,7 +57,7 @@ gboolean nm_vpn_connection_update (NMVPNConnection *vpn);
const char *nm_vpn_connection_get_name (NMVPNConnection *vpn); const char *nm_vpn_connection_get_name (NMVPNConnection *vpn);
const char *nm_vpn_connection_get_user_name (NMVPNConnection *vpn); const char *nm_vpn_connection_get_user_name (NMVPNConnection *vpn);
const char *nm_vpn_connection_get_service (NMVPNConnection *vpn); const char *nm_vpn_connection_get_service (NMVPNConnection *vpn);
NMVPNActStage nm_vpn_connection_get_state (NMVPNConnection *vpn); NMVPNConnectionState nm_vpn_connection_get_state (NMVPNConnection *vpn);
gboolean nm_vpn_connection_is_activating (NMVPNConnection *vpn); gboolean nm_vpn_connection_is_activating (NMVPNConnection *vpn);
gboolean nm_vpn_connection_activate (NMVPNConnection *vpn, gboolean nm_vpn_connection_activate (NMVPNConnection *vpn,
@@ -65,7 +65,7 @@ gboolean nm_vpn_connection_activate (NMVPNConnection *vpn,
gboolean nm_vpn_connection_deactivate (NMVPNConnection *vpn); gboolean nm_vpn_connection_deactivate (NMVPNConnection *vpn);
void nm_vpn_connection_set_state (NMVPNConnection *vpn, NMVPNActStage state); void nm_vpn_connection_set_state (NMVPNConnection *vpn, NMVPNConnectionState state);
G_END_DECLS G_END_DECLS

14
src/vpn-manager/nm-dbus-vpn.c
View File

@@ -85,11 +85,11 @@ nm_dbus_vpn_signal_vpn_connection_update (DBusConnection *connection,
void void
nm_dbus_vpn_signal_vpn_connection_state_change (DBusConnection *connection, nm_dbus_vpn_signal_vpn_connection_state_change (DBusConnection *connection,
NMVPNConnection *vpn, NMVPNConnection *vpn,
NMVPNActStage new_stage) NMVPNConnectionState new_state)
{ {
DBusMessage * message; DBusMessage * message;
const char * vpn_name; const char * vpn_name;
dbus_uint32_t int_stage = (dbus_uint32_t) new_stage; dbus_uint32_t int_state = (dbus_uint32_t) new_state;
g_return_if_fail (connection != NULL); g_return_if_fail (connection != NULL);
g_return_if_fail (vpn != NULL); g_return_if_fail (vpn != NULL);
@@ -105,7 +105,7 @@ nm_dbus_vpn_signal_vpn_connection_state_change (DBusConnection *connection,
vpn_name = nm_vpn_connection_get_name (vpn); vpn_name = nm_vpn_connection_get_name (vpn);
dbus_message_append_args (message, dbus_message_append_args (message,
DBUS_TYPE_STRING, &vpn_name, DBUS_TYPE_STRING, &vpn_name,
DBUS_TYPE_UINT32, &int_stage, DBUS_TYPE_UINT32, &int_state,
DBUS_TYPE_INVALID); DBUS_TYPE_INVALID);
dbus_connection_send (connection, message, NULL); dbus_connection_send (connection, message, NULL);
dbus_message_unref (message); dbus_message_unref (message);
@@ -753,7 +753,7 @@ nm_dbus_vpn_get_vpn_connection_properties (DBusConnection *connection,
const char * service_name; const char * service_name;
NMVPNService * service; NMVPNService * service;
NMVPNActRequest * req; NMVPNActRequest * req;
dbus_uint32_t stage; dbus_uint32_t state;
g_return_val_if_fail (vpn_mgr != NULL, NULL); g_return_val_if_fail (vpn_mgr != NULL, NULL);
g_return_val_if_fail (connection != NULL, NULL); g_return_val_if_fail (connection != NULL, NULL);
@@ -780,14 +780,14 @@ nm_dbus_vpn_get_vpn_connection_properties (DBusConnection *connection,
goto out; goto out;
req = nm_vpn_manager_get_vpn_act_request (vpn_mgr); req = nm_vpn_manager_get_vpn_act_request (vpn_mgr);
stage = (dbus_uint32_t) NM_VPN_ACT_STAGE_DISCONNECTED; state = (dbus_uint32_t) NM_VPN_CONNECTION_STATE_DISCONNECTED;
if (req && (nm_vpn_act_request_get_connection (req) == vpn)) if (req && (nm_vpn_act_request_get_connection (req) == vpn))
stage = nm_vpn_act_request_get_stage (req); state = nm_vpn_act_request_get_state (req);
dbus_message_append_args (reply, DBUS_TYPE_STRING, &name, dbus_message_append_args (reply, DBUS_TYPE_STRING, &name,
DBUS_TYPE_STRING, &user_name, DBUS_TYPE_STRING, &user_name,
DBUS_TYPE_STRING, &service_name, DBUS_TYPE_STRING, &service_name,
DBUS_TYPE_UINT32, &stage, DBUS_TYPE_UINT32, &state,
DBUS_TYPE_INVALID); DBUS_TYPE_INVALID);
success = TRUE; success = TRUE;

35
src/vpn-manager/nm-dbus-vpn.h
View File

@@ -26,18 +26,33 @@
#include "nm-vpn-manager.h" #include "nm-vpn-manager.h"
#include "nm-vpn-connection.h" #include "nm-vpn-connection.h"
void nm_dbus_vpn_schedule_vpn_connections_update (NMVPNManager *manager); void nm_dbus_vpn_schedule_vpn_connections_update (NMVPNManager *manager);
void nm_dbus_vpn_update_one_vpn_connection (DBusConnection *connection,
NMVPNManager *manager,
const char *vpn);
void nm_dbus_vpn_signal_vpn_connection_update (DBusConnection *con, NMVPNConnection *vpn, const char *signal); void nm_dbus_vpn_update_one_vpn_connection (DBusConnection *connection,
void nm_dbus_vpn_signal_vpn_failed (DBusConnection *con, const char *signal, NMVPNConnection *vpn, const char *error_msg); NMVPNManager *manager,
void nm_dbus_vpn_signal_vpn_login_banner (DBusConnection *con, NMVPNConnection *vpn, const char *banner); const char *vpn);
void nm_dbus_vpn_signal_vpn_connection_state_change (DBusConnection *con, NMVPNConnection *vpn, NMVPNActStage new_stage);
char ** nm_dbus_vpn_get_routes (DBusConnection *connection, NMVPNConnection *vpn, int *num_items); void nm_dbus_vpn_signal_vpn_connection_update (DBusConnection *con,
NMVPNConnection *vpn,
const char *signal);
gboolean nm_dbus_vpn_methods_setup (NMVPNManager *mgr); void nm_dbus_vpn_signal_vpn_failed (DBusConnection *con,
const char *signal,
NMVPNConnection *vpn,
const char *error_msg);
void nm_dbus_vpn_signal_vpn_login_banner (DBusConnection *con,
NMVPNConnection *vpn,
const char *banner);
void nm_dbus_vpn_signal_vpn_connection_state_change (DBusConnection *con,
NMVPNConnection *vpn,
NMVPNConnectionState new_state);
char ** nm_dbus_vpn_get_routes (DBusConnection *connection,
NMVPNConnection *vpn,
int *num_items);
gboolean nm_dbus_vpn_methods_setup (NMVPNManager *mgr);
#endif #endif

56
src/vpn-manager/nm-vpn-act-request.c
View File

@@ -31,7 +31,7 @@
struct NMVPNActRequest struct NMVPNActRequest
{ {
guint refcount; guint refcount;
NMVPNActStage stage; NMVPNConnectionState state;
NMDevice * parent_dev; NMDevice * parent_dev;
NMVPNManager * manager; NMVPNManager * manager;
@@ -51,9 +51,17 @@ struct NMVPNActRequest
}; };
NMVPNActRequest *nm_vpn_act_request_new (NMVPNManager *manager, NMVPNService *service, NMVPNConnection *vpn, NMVPNActRequest *
NMDevice *parent_dev, char **password_items, int password_count, nm_vpn_act_request_new (NMVPNManager *manager,
char **data_items, int data_count, char **user_routes, int user_routes_count) NMVPNService *service,
NMVPNConnection *vpn,
NMDevice *parent_dev,
char **password_items,
int password_count,
char **data_items,
int data_count,
char **user_routes,
int user_routes_count)
{ {
NMVPNActRequest *req; NMVPNActRequest *req;
@@ -66,7 +74,7 @@ NMVPNActRequest *nm_vpn_act_request_new (NMVPNManager *manager, NMVPNService *se
req = g_malloc0 (sizeof (NMVPNActRequest)); req = g_malloc0 (sizeof (NMVPNActRequest));
req->refcount = 1; req->refcount = 1;
req->stage = NM_VPN_ACT_STAGE_PREPARE; req->state = NM_VPN_CONNECTION_STATE_PREPARE;
req->manager = manager; req->manager = manager;
g_object_ref (G_OBJECT (parent_dev)); g_object_ref (G_OBJECT (parent_dev));
@@ -114,17 +122,17 @@ void nm_vpn_act_request_unref (NMVPNActRequest *req)
} }
} }
gboolean nm_vpn_act_request_is_activating (NMVPNActRequest *req) gboolean
nm_vpn_act_request_is_activating (NMVPNActRequest *req)
{ {
gboolean activating = FALSE; gboolean activating = FALSE;
g_return_val_if_fail (req != NULL, FALSE); g_return_val_if_fail (req != NULL, FALSE);
switch (req->stage) switch (req->state) {
{ case NM_VPN_CONNECTION_STATE_PREPARE:
case NM_VPN_ACT_STAGE_PREPARE: case NM_VPN_CONNECTION_STATE_CONNECT:
case NM_VPN_ACT_STAGE_CONNECT: case NM_VPN_CONNECTION_STATE_IP_CONFIG_GET:
case NM_VPN_ACT_STAGE_IP_CONFIG_GET:
activating = TRUE; activating = TRUE;
break; break;
@@ -139,14 +147,14 @@ gboolean nm_vpn_act_request_is_activated (NMVPNActRequest *req)
{ {
g_return_val_if_fail (req != NULL, FALSE); g_return_val_if_fail (req != NULL, FALSE);
return (req->stage == NM_VPN_ACT_STAGE_ACTIVATED) ? TRUE : FALSE; return (req->state == NM_VPN_CONNECTION_STATE_ACTIVATED) ? TRUE : FALSE;
} }
gboolean nm_vpn_act_request_is_failed (NMVPNActRequest *req) gboolean nm_vpn_act_request_is_failed (NMVPNActRequest *req)
{ {
g_return_val_if_fail (req != NULL, FALSE); g_return_val_if_fail (req != NULL, FALSE);
return (req->stage == NM_VPN_ACT_STAGE_FAILED) ? TRUE : FALSE; return (req->state == NM_VPN_CONNECTION_STATE_FAILED) ? TRUE : FALSE;
} }
NMVPNManager *nm_vpn_act_request_get_manager (NMVPNActRequest *req) NMVPNManager *nm_vpn_act_request_get_manager (NMVPNActRequest *req)
@@ -219,32 +227,34 @@ gboolean nm_vpn_act_request_should_cancel (NMVPNActRequest *req)
return req->canceled; return req->canceled;
} }
NMVPNActStage nm_vpn_act_request_get_stage (NMVPNActRequest *req) NMVPNConnectionState
nm_vpn_act_request_get_state (NMVPNActRequest *req)
{ {
g_return_val_if_fail (req != NULL, NM_VPN_ACT_STAGE_UNKNOWN); g_return_val_if_fail (req != NULL, NM_VPN_CONNECTION_STATE_UNKNOWN);
return req->stage; return req->state;
} }
void nm_vpn_act_request_set_stage (NMVPNActRequest *req, NMVPNActStage stage) void
nm_vpn_act_request_set_state (NMVPNActRequest *req,
NMVPNConnectionState state)
{ {
NMVPNActStage old_stage; NMVPNConnectionState old_state;
g_return_if_fail (req != NULL); g_return_if_fail (req != NULL);
old_stage = req->stage; old_state = req->state;
if (old_stage != stage) if (old_state != state) {
{
NMDBusManager *dbus_mgr; NMDBusManager *dbus_mgr;
DBusConnection *dbus_connection; DBusConnection *dbus_connection;
dbus_mgr = nm_dbus_manager_get (); dbus_mgr = nm_dbus_manager_get ();
dbus_connection = nm_dbus_manager_get_dbus_connection (dbus_mgr); dbus_connection = nm_dbus_manager_get_dbus_connection (dbus_mgr);
if (dbus_connection) { if (dbus_connection) {
req->stage = stage; req->state = state;
nm_dbus_vpn_signal_vpn_connection_state_change (dbus_connection, nm_dbus_vpn_signal_vpn_connection_state_change (dbus_connection,
req->vpn, req->vpn,
req->stage); req->state);
} else { } else {
nm_warning ("could not get dbus connection."); nm_warning ("could not get dbus connection.");
} }

4
src/vpn-manager/nm-vpn-act-request.h
View File

@@ -50,8 +50,8 @@ const char ** nm_vpn_act_request_get_user_routes (NMVPNActRequest *req, guint *
void nm_vpn_act_request_cancel (NMVPNActRequest *req); void nm_vpn_act_request_cancel (NMVPNActRequest *req);
gboolean nm_vpn_act_request_should_cancel (NMVPNActRequest *req); gboolean nm_vpn_act_request_should_cancel (NMVPNActRequest *req);
NMVPNActStage nm_vpn_act_request_get_stage (NMVPNActRequest *req); NMVPNConnectionState nm_vpn_act_request_get_state (NMVPNActRequest *req);
void nm_vpn_act_request_set_stage (NMVPNActRequest *req, NMVPNActStage stage); void nm_vpn_act_request_set_state (NMVPNActRequest *req, NMVPNConnectionState state);
guint nm_vpn_act_request_get_daemon_wait_count (NMVPNActRequest *req); guint nm_vpn_act_request_get_daemon_wait_count (NMVPNActRequest *req);
void nm_vpn_act_request_set_daemon_wait_count (NMVPNActRequest *req, guint count); void nm_vpn_act_request_set_daemon_wait_count (NMVPNActRequest *req, guint count);

137
src/vpn-manager/nm-vpn-service.c
View File

@@ -54,7 +54,7 @@ struct NMVPNService
char * name; char * name;
char * service; char * service;
char * program; char * program;
NMVPNState state; NMVPNServiceState state;
}; };
@@ -100,7 +100,7 @@ NMVPNService *nm_vpn_service_new (NMVPNManager *manager, NMData *app_data)
NMVPNService *service = g_malloc0 (sizeof (NMVPNService)); NMVPNService *service = g_malloc0 (sizeof (NMVPNService));
service->refcount = 1; service->refcount = 1;
service->state = NM_VPN_STATE_SHUTDOWN; service->state = NM_VPN_SERVICE_STATE_SHUTDOWN;
service->app_data = app_data; service->app_data = app_data;
service->manager = manager; service->manager = manager;
service->dbus_mgr = nm_dbus_manager_get (); service->dbus_mgr = nm_dbus_manager_get ();
@@ -192,15 +192,18 @@ void nm_vpn_service_set_program (NMVPNService *service, const char *program)
} }
NMVPNState nm_vpn_service_get_state (NMVPNService *service) NMVPNServiceState
nm_vpn_service_get_state (NMVPNService *service)
{ {
g_return_val_if_fail (service != NULL, NM_VPN_STATE_UNKNOWN); g_return_val_if_fail (service != NULL, NM_VPN_SERVICE_STATE_UNKNOWN);
return service->state; return service->state;
} }
static void nm_vpn_service_set_state (NMVPNService *service, const NMVPNState state) static void
nm_vpn_service_set_state (NMVPNService *service,
const NMVPNServiceState state)
{ {
g_return_if_fail (service != NULL); g_return_if_fail (service != NULL);
@@ -243,8 +246,9 @@ static char *construct_op_from_service_name (const char *service_name)
* has failed. * has failed.
* *
*/ */
static void nm_vpn_service_act_request_failed (NMVPNService *service, static void
NMVPNActRequest *req) nm_vpn_service_act_request_failed (NMVPNService *service,
NMVPNActRequest *req)
{ {
NMVPNConnection *vpn; NMVPNConnection *vpn;
@@ -260,7 +264,7 @@ static void nm_vpn_service_act_request_failed (NMVPNService *service,
nm_vpn_service_cancel_callback (service, req); nm_vpn_service_cancel_callback (service, req);
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_FAILED); nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_FAILED);
nm_info ("VPN Activation (%s) failed.", nm_vpn_connection_get_name (vpn)); nm_info ("VPN Activation (%s) failed.", nm_vpn_connection_get_name (vpn));
nm_vpn_act_request_unref (req); nm_vpn_act_request_unref (req);
@@ -268,7 +272,9 @@ static void nm_vpn_service_act_request_failed (NMVPNService *service,
} }
static void nm_vpn_service_activation_success (NMVPNService *service, NMVPNActRequest *req) static void
nm_vpn_service_activation_success (NMVPNService *service,
NMVPNActRequest *req)
{ {
NMVPNConnection * vpn = NULL; NMVPNConnection * vpn = NULL;
@@ -280,7 +286,7 @@ static void nm_vpn_service_activation_success (NMVPNService *service, NMVPNActRe
nm_vpn_service_cancel_callback (service, req); nm_vpn_service_cancel_callback (service, req);
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_ACTIVATED); nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_ACTIVATED);
nm_info ("VPN Activation (%s) successful.", nm_vpn_connection_get_name (vpn)); nm_info ("VPN Activation (%s) successful.", nm_vpn_connection_get_name (vpn));
} }
@@ -291,12 +297,14 @@ static void nm_vpn_service_activation_success (NMVPNService *service, NMVPNActRe
* Kick off the VPN connection process. * Kick off the VPN connection process.
* *
*/ */
void nm_vpn_service_start_connection (NMVPNService *service, NMVPNActRequest *req) void
nm_vpn_service_start_connection (NMVPNService *service,
NMVPNActRequest *req)
{ {
g_return_if_fail (service != NULL); g_return_if_fail (service != NULL);
g_return_if_fail (req != NULL); g_return_if_fail (req != NULL);
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_PREPARE); nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_PREPARE);
nm_vpn_service_add_watch (service); nm_vpn_service_add_watch (service);
/* Start the daemon if it's not already running */ /* Start the daemon if it's not already running */
@@ -387,7 +395,9 @@ out:
} }
static void nm_vpn_service_schedule_stage1_daemon_exec (NMVPNService *service, NMVPNActRequest *req) static void
nm_vpn_service_schedule_stage1_daemon_exec (NMVPNService *service,
NMVPNActRequest *req)
{ {
NMVPNConnection * vpn = NULL; NMVPNConnection * vpn = NULL;
guint id; guint id;
@@ -398,8 +408,8 @@ static void nm_vpn_service_schedule_stage1_daemon_exec (NMVPNService *service, N
vpn = nm_vpn_act_request_get_connection (req); vpn = nm_vpn_act_request_get_connection (req);
g_assert (vpn); g_assert (vpn);
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_PREPARE); nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_PREPARE);
nm_vpn_service_set_state (service, NM_VPN_STATE_SHUTDOWN); nm_vpn_service_set_state (service, NM_VPN_SERVICE_STATE_SHUTDOWN);
id = g_idle_add (nm_vpn_service_stage1_daemon_exec, req); id = g_idle_add (nm_vpn_service_stage1_daemon_exec, req);
nm_vpn_act_request_set_callback_id (req, id); nm_vpn_act_request_set_callback_id (req, id);
@@ -414,7 +424,8 @@ static void nm_vpn_service_schedule_stage1_daemon_exec (NMVPNService *service, N
* Wait until the VPN daemon has become active. * Wait until the VPN daemon has become active.
* *
*/ */
static gboolean nm_vpn_service_stage2_daemon_wait (gpointer user_data) static gboolean
nm_vpn_service_stage2_daemon_wait (gpointer user_data)
{ {
NMVPNActRequest * req = (NMVPNActRequest *) user_data; NMVPNActRequest * req = (NMVPNActRequest *) user_data;
NMVPNService * service; NMVPNService * service;
@@ -436,27 +447,26 @@ static gboolean nm_vpn_service_stage2_daemon_wait (gpointer user_data)
service_exists = nm_dbus_manager_name_has_owner (service->dbus_mgr, service_exists = nm_dbus_manager_name_has_owner (service->dbus_mgr,
service->service); service->service);
if (service_exists && (service->state == NM_VPN_STATE_STOPPED)) if (service_exists && (service->state == NM_VPN_SERVICE_STATE_STOPPED)) {
{
nm_info ("VPN Activation (%s) Stage 2 of 4 (Connection Prepare Wait) " nm_info ("VPN Activation (%s) Stage 2 of 4 (Connection Prepare Wait) "
"complete.", nm_vpn_connection_get_name (vpn)); "complete.", nm_vpn_connection_get_name (vpn));
nm_vpn_service_schedule_stage3_connect (service, req); nm_vpn_service_schedule_stage3_connect (service, req);
} } else if (nm_vpn_act_request_get_daemon_wait_count (req) > 10) {
else if (nm_vpn_act_request_get_daemon_wait_count (req) > 10)
{
/* We only wait 2s (10 * 200 milliseconds) for the service to /* We only wait 2s (10 * 200 milliseconds) for the service to
* become available. * become available.
*/ */
nm_vpn_service_act_request_failed (service, req); nm_vpn_service_act_request_failed (service, req);
} } else {
else
nm_vpn_service_schedule_stage2_daemon_wait (service, req); nm_vpn_service_schedule_stage2_daemon_wait (service, req);
}
return FALSE; return FALSE;
} }
static void nm_vpn_service_schedule_stage2_daemon_wait (NMVPNService *service, NMVPNActRequest *req) static void
nm_vpn_service_schedule_stage2_daemon_wait (NMVPNService *service,
NMVPNActRequest *req)
{ {
NMVPNConnection * vpn = NULL; NMVPNConnection * vpn = NULL;
guint id; guint id;
@@ -467,7 +477,7 @@ static void nm_vpn_service_schedule_stage2_daemon_wait (NMVPNService *service, N
vpn = nm_vpn_act_request_get_connection (req); vpn = nm_vpn_act_request_get_connection (req);
g_assert (vpn); g_assert (vpn);
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_PREPARE); nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_PREPARE);
nm_vpn_act_request_set_daemon_wait_count (req, nm_vpn_act_request_get_daemon_wait_count (req) + 1); nm_vpn_act_request_set_daemon_wait_count (req, nm_vpn_act_request_get_daemon_wait_count (req) + 1);
@@ -479,7 +489,9 @@ static void nm_vpn_service_schedule_stage2_daemon_wait (NMVPNService *service, N
} }
static void nm_vpn_service_stage3_connect_cb (DBusPendingCall *pcall, void *user_data) static void
nm_vpn_service_stage3_connect_cb (DBusPendingCall *pcall,
void *user_data)
{ {
DBusMessage * reply; DBusMessage * reply;
NMVPNActRequest * req = (NMVPNActRequest *) user_data; NMVPNActRequest * req = (NMVPNActRequest *) user_data;
@@ -498,16 +510,14 @@ static void nm_vpn_service_stage3_connect_cb (DBusPendingCall *pcall, void *user
nm_info ("VPN Activation (%s) Stage 3 of 4 (Connect) reply received.", nm_info ("VPN Activation (%s) Stage 3 of 4 (Connect) reply received.",
nm_vpn_connection_get_name (vpn)); nm_vpn_connection_get_name (vpn));
if (!(reply = dbus_pending_call_steal_reply (pcall))) if (!(reply = dbus_pending_call_steal_reply (pcall))) {
{
nm_warning ("(VPN Service %s): could not obtain VPN service's reply.", nm_warning ("(VPN Service %s): could not obtain VPN service's reply.",
service->service); service->service);
nm_vpn_service_act_request_failed (service, req); nm_vpn_service_act_request_failed (service, req);
goto out; goto out;
} }
if (message_is_error (reply)) if (message_is_error (reply)) {
{
const char *member = dbus_message_get_member (reply); const char *member = dbus_message_get_member (reply);
char *message; char *message;
@@ -517,10 +527,8 @@ static void nm_vpn_service_stage3_connect_cb (DBusPendingCall *pcall, void *user
nm_warning ("(VPN Service %s): could not start the VPN '%s'. dbus says: '%s' '%s'.", nm_warning ("(VPN Service %s): could not start the VPN '%s'. dbus says: '%s' '%s'.",
service->service, nm_vpn_connection_get_name (vpn), member, message); service->service, nm_vpn_connection_get_name (vpn), member, message);
nm_vpn_service_act_request_failed (service, req); nm_vpn_service_act_request_failed (service, req);
} } else {
else nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_IP_CONFIG_GET);
{
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_IP_CONFIG_GET);
nm_vpn_service_schedule_stage4_ip_config_get_timeout (service, req); nm_vpn_service_schedule_stage4_ip_config_get_timeout (service, req);
nm_info ("VPN Activation (%s) Stage 3 of 4 (Connect) complete, " nm_info ("VPN Activation (%s) Stage 3 of 4 (Connect) complete, "
"waiting for IP configuration...", nm_vpn_connection_get_name (vpn)); "waiting for IP configuration...", nm_vpn_connection_get_name (vpn));
@@ -641,7 +649,9 @@ out:
} }
static void nm_vpn_service_schedule_stage3_connect (NMVPNService *service, NMVPNActRequest *req) static void
nm_vpn_service_schedule_stage3_connect (NMVPNService *service,
NMVPNActRequest *req)
{ {
NMVPNConnection * vpn = NULL; NMVPNConnection * vpn = NULL;
guint id; guint id;
@@ -652,7 +662,7 @@ static void nm_vpn_service_schedule_stage3_connect (NMVPNService *service, NMVPN
vpn = nm_vpn_act_request_get_connection (req); vpn = nm_vpn_act_request_get_connection (req);
g_assert (vpn); g_assert (vpn);
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_CONNECT); nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_CONNECT);
id = g_idle_add (nm_vpn_service_stage3_connect, req); id = g_idle_add (nm_vpn_service_stage3_connect, req);
nm_vpn_act_request_set_callback_id (req, id); nm_vpn_act_request_set_callback_id (req, id);
@@ -661,7 +671,8 @@ static void nm_vpn_service_schedule_stage3_connect (NMVPNService *service, NMVPN
} }
static gboolean nm_vpn_service_stage4_ip_config_get_timeout (gpointer user_data) static gboolean
nm_vpn_service_stage4_ip_config_get_timeout (gpointer user_data)
{ {
NMVPNActRequest * req = (NMVPNActRequest *) user_data; NMVPNActRequest * req = (NMVPNActRequest *) user_data;
NMVPNService * service; NMVPNService * service;
@@ -680,9 +691,10 @@ static gboolean nm_vpn_service_stage4_ip_config_get_timeout (gpointer user_data)
/* If the activation request's state is still IP_CONFIG_GET and we're /* If the activation request's state is still IP_CONFIG_GET and we're
* in this timeout, cancel activation because it's taken too long. * in this timeout, cancel activation because it's taken too long.
*/ */
if (nm_vpn_act_request_get_stage (req) == NM_VPN_ACT_STAGE_IP_CONFIG_GET) if (nm_vpn_act_request_get_state (req) == NM_VPN_CONNECTION_STATE_IP_CONFIG_GET) {
{ nm_info ("VPN Activation (%s) Stage 4 of 4 (IP Config Get) timeout "
nm_info ("VPN Activation (%s) Stage 4 of 4 (IP Config Get) timeout exceeded.", nm_vpn_connection_get_name (vpn)); "exceeded.",
nm_vpn_connection_get_name (vpn));
nm_vpn_service_act_request_failed (service, req); nm_vpn_service_act_request_failed (service, req);
} }
@@ -690,7 +702,9 @@ static gboolean nm_vpn_service_stage4_ip_config_get_timeout (gpointer user_data)
} }
static void nm_vpn_service_schedule_stage4_ip_config_get_timeout (NMVPNService *service, NMVPNActRequest *req) static void
nm_vpn_service_schedule_stage4_ip_config_get_timeout (NMVPNService *service,
NMVPNActRequest *req)
{ {
NMVPNConnection * vpn = NULL; NMVPNConnection * vpn = NULL;
guint id; guint id;
@@ -701,7 +715,7 @@ static void nm_vpn_service_schedule_stage4_ip_config_get_timeout (NMVPNService *
vpn = nm_vpn_act_request_get_connection (req); vpn = nm_vpn_act_request_get_connection (req);
g_assert (vpn); g_assert (vpn);
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_IP_CONFIG_GET); nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_IP_CONFIG_GET);
/* 20 second timeout waiting for IP config signal from VPN service */ /* 20 second timeout waiting for IP config signal from VPN service */
id = g_timeout_add (20000, nm_vpn_service_stage4_ip_config_get_timeout, req); id = g_timeout_add (20000, nm_vpn_service_stage4_ip_config_get_timeout, req);
@@ -1103,7 +1117,9 @@ nm_vpn_service_stop_connection_internal (NMVPNService *service)
} }
void nm_vpn_service_stop_connection (NMVPNService *service, NMVPNActRequest *req) void
nm_vpn_service_stop_connection (NMVPNService *service,
NMVPNActRequest *req)
{ {
NMVPNConnection *vpn; NMVPNConnection *vpn;
@@ -1114,18 +1130,21 @@ void nm_vpn_service_stop_connection (NMVPNService *service, NMVPNActRequest *req
g_assert (vpn); g_assert (vpn);
nm_vpn_service_cancel_callback (service, req); nm_vpn_service_cancel_callback (service, req);
nm_vpn_act_request_set_stage (req, NM_VPN_ACT_STAGE_DISCONNECTED); nm_vpn_act_request_set_state (req, NM_VPN_CONNECTION_STATE_DISCONNECTED);
/* Ensure we can stop the connection in this state */ /* Ensure we can stop the connection in this state */
if ((service->state != NM_VPN_STATE_STARTED) && (service->state != NM_VPN_STATE_STARTING)) if ( (service->state != NM_VPN_SERVICE_STATE_STARTED)
{ && (service->state != NM_VPN_SERVICE_STATE_STARTING)) {
nm_warning ("(VPN Service %s): could not stop connection '%s' because service was %d.", nm_warning ("(VPN Service %s): could not stop connection '%s' because "
service->service, nm_vpn_connection_get_name (vpn), service->state); " service was %d.",
service->service,
nm_vpn_connection_get_name (vpn),
service->state);
return; return;
} }
nm_vpn_service_stop_connection_internal (service); nm_vpn_service_stop_connection_internal (service);
nm_vpn_service_set_state (service, NM_VPN_STATE_STOPPED); nm_vpn_service_set_state (service, NM_VPN_SERVICE_STATE_STOPPED);
} }
@@ -1198,7 +1217,7 @@ nm_vpn_service_dbus_connection_changed (NMDBusManager *mgr,
gboolean valid_vpn = FALSE; gboolean valid_vpn = FALSE;
/* Kill the VPN service since we can't talk to it anymore anyway */ /* Kill the VPN service since we can't talk to it anymore anyway */
nm_vpn_service_set_state (service, NM_VPN_STATE_SHUTDOWN); nm_vpn_service_set_state (service, NM_VPN_SERVICE_STATE_SHUTDOWN);
nm_vpn_service_remove_watch (service); nm_vpn_service_remove_watch (service);
req = nm_vpn_manager_get_vpn_act_request (service->manager); req = nm_vpn_manager_get_vpn_act_request (service->manager);
@@ -1238,10 +1257,10 @@ nm_vpn_service_name_owner_changed (NMDBusManager *mgr,
if (!old_owner_good && new_owner_good) { if (!old_owner_good && new_owner_good) {
/* VPN service started. */ /* VPN service started. */
nm_vpn_service_add_watch (service); nm_vpn_service_add_watch (service);
nm_vpn_service_set_state (service, NM_VPN_STATE_INIT); nm_vpn_service_set_state (service, NM_VPN_SERVICE_STATE_INIT);
} else if (old_owner_good && !new_owner_good) { } else if (old_owner_good && !new_owner_good) {
/* VPN service went away. */ /* VPN service went away. */
nm_vpn_service_set_state (service, NM_VPN_STATE_SHUTDOWN); nm_vpn_service_set_state (service, NM_VPN_SERVICE_STATE_SHUTDOWN);
nm_vpn_service_remove_watch (service); nm_vpn_service_remove_watch (service);
if (valid_vpn) { if (valid_vpn) {
@@ -1307,8 +1326,8 @@ nm_vpn_service_process_signal (DBusConnection *connection,
DBUS_TYPE_UINT32, &old_state_int, DBUS_TYPE_UINT32, &old_state_int,
DBUS_TYPE_UINT32, &new_state_int, DBUS_TYPE_UINT32, &new_state_int,
DBUS_TYPE_INVALID)) { DBUS_TYPE_INVALID)) {
NMVPNState old_state = (NMVPNState) old_state_int; NMVPNServiceState old_state = (NMVPNServiceState) old_state_int;
NMVPNState new_state = (NMVPNState) new_state_int; NMVPNServiceState new_state = (NMVPNServiceState) new_state_int;
nm_info ("VPN service '%s' signaled state change %d -> %d.", nm_info ("VPN service '%s' signaled state change %d -> %d.",
service->service, service->service,
@@ -1319,11 +1338,11 @@ nm_vpn_service_process_signal (DBusConnection *connection,
/* If the VPN daemon state is now stopped and it was starting, /* If the VPN daemon state is now stopped and it was starting,
* clear the active connection. * clear the active connection.
*/ */
if ( ( (new_state == NM_VPN_STATE_STOPPED) if ( ( (new_state == NM_VPN_SERVICE_STATE_STOPPED)
|| (new_state == NM_VPN_STATE_SHUTDOWN) || (new_state == NM_VPN_SERVICE_STATE_SHUTDOWN)
|| (new_state == NM_VPN_STATE_STOPPING)) || (new_state == NM_VPN_SERVICE_STATE_STOPPING))
&& ( (old_state == NM_VPN_STATE_STARTED) && ( (old_state == NM_VPN_SERVICE_STATE_STARTED)
|| (old_state == NM_VPN_STATE_STARTING)) || (old_state == NM_VPN_SERVICE_STATE_STARTING))
&& valid_vpn) { && valid_vpn) {
nm_vpn_act_request_unref (req); nm_vpn_act_request_unref (req);
nm_vpn_manager_schedule_vpn_connection_died (service->manager, req); nm_vpn_manager_schedule_vpn_connection_died (service->manager, req);

2
src/vpn-manager/nm-vpn-service.h
View File

@@ -46,7 +46,7 @@ void nm_vpn_service_set_service_name (NMVPNService *service, const char *name)
const char * nm_vpn_service_get_program (NMVPNService *service); const char * nm_vpn_service_get_program (NMVPNService *service);
void nm_vpn_service_set_program (NMVPNService *service, const char *program); void nm_vpn_service_set_program (NMVPNService *service, const char *program);
NMVPNState nm_vpn_service_get_state (NMVPNService *service); NMVPNServiceState nm_vpn_service_get_state (NMVPNService *service);
void nm_vpn_service_start_connection (NMVPNService *service, NMVPNActRequest *req); void nm_vpn_service_start_connection (NMVPNService *service, NMVPNActRequest *req);
void nm_vpn_service_stop_connection (NMVPNService *service, NMVPNActRequest *req); void nm_vpn_service_stop_connection (NMVPNService *service, NMVPNActRequest *req);