fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-03-04 06:00:33 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

2007-09-02 Dan Williams <dcbw@redhat.com>

Browse source 
* test/Makefile.am
	  test/nminfotest.c
		- Remove, no longer useful



git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@2760 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
This commit is contained in:
Dan Williams 2007-09-02 23:57:56 +00:00
parent c4194f501e
commit a461ac3b84
3 changed files with 6 additions and 332 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
ChangeLog
View file

@ -1,3 +1,9 @@
2007-09-02 Dan Williams <dcbw@redhat.com>
* test/Makefile.am
test/nminfotest.c
- Remove, no longer useful
2007-08-30 Dan Williams <dcbw@redhat.com>
* src/Makefile.am

5
test/Makefile.am
View file

@ -18,7 +18,6 @@ AM_CPPFLAGS = \
noinst_PROGRAMS = nm-tool \
nm-online \
nminfotest \
nmtestdevices \
libnm_glib_test
@ -31,10 +30,6 @@ nm_online_SOURCES = nm-online.c
nm_online_LDADD = $(DBUS_LIBS) $(GTHREAD_LIBS) $(HAL_LIBS) \
$(top_builddir)/utils/libnmutils.la
nminfotest_SOURCES = nminfotest.c
nminfotest_LDADD = $(DBUS_LIBS) $(GTHREAD_LIBS) \
$(top_builddir)/utils/libnmutils.la
nmtestdevices_SOURCES = nmtestdevices.c
nmtestdevices_LDADD = $(DBUS_LIBS) $(GTHREAD_LIBS) \
$(top_builddir)/utils/libnmutils.la

327
test/nminfotest.c
View file

@ -1,327 +0,0 @@
/* nminfotest -- test app for NetworkManagerInfo
*
* 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 2004 Red Hat, Inc.
*/
#include <glib.h>
#include <dbus/dbus.h>
#include <dbus/dbus-glib-lowlevel.h>
#include <dbus/dbus-glib.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "NetworkManager.h"
static char * get_network_string_property (DBusConnection *connection, const char *network, const char *method, NMNetworkType type)
{
DBusMessage *message;
DBusMessage *reply;
DBusError error;
char *string = NULL;
char *ret_string = NULL;
gint32 type_as_int;
message = dbus_message_new_method_call (NMI_DBUS_SERVICE, NMI_DBUS_PATH, NMI_DBUS_INTERFACE, method);
if (message == NULL)
{
fprintf (stderr, "Couldn't allocate the dbus message\n");
return NULL;
}
type_as_int = (gint32) type;
dbus_message_append_args (message, DBUS_TYPE_STRING, &network, DBUS_TYPE_INT32, &type_as_int, DBUS_TYPE_INVALID);
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))
{
fprintf (stderr, "%s raised:\n %s\n\n", error.name, error.message);
dbus_error_free (&error);
return NULL;
}
if (reply == NULL)
{
fprintf( stderr, "dbus reply message was NULL\n" );
return NULL;
}
dbus_error_init (&error);
if (dbus_message_get_args (reply, &error, DBUS_TYPE_STRING, &string, DBUS_TYPE_INVALID) && string)
{
ret_string = g_strdup (string);
}
dbus_message_unref (reply);
if (!string)
fprintf (stderr, "NetworkManagerInfo returned a NULL string for method '%s'", method );
if (dbus_error_is_set (&error))
dbus_error_free (&error);
return (ret_string);
}
static gboolean get_network_trusted (DBusConnection *connection, const char *network, NMNetworkType type)
{
DBusMessage *message;
DBusMessage *reply;
DBusError error;
gboolean trusted = FALSE;
gint32 type_as_int;
g_return_val_if_fail (connection != NULL, -1);
g_return_val_if_fail (network != NULL, -1);
message = dbus_message_new_method_call (NMI_DBUS_SERVICE, NMI_DBUS_PATH, NMI_DBUS_INTERFACE, "getNetworkTrusted");
if (message == NULL)
{
fprintf (stderr, "Couldn't allocate the dbus message\n");
return (-1);
}
dbus_error_init (&error);
type_as_int = (gint32) type;
dbus_message_append_args (message, DBUS_TYPE_STRING, &network, DBUS_TYPE_INT32, &type_as_int, DBUS_TYPE_INVALID);
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error);
dbus_message_unref (message);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "%s raised:\n %s\n\n", error.name, error.message);
dbus_error_free (&error);
dbus_message_unref (reply);
return (-1);
}
if (reply == NULL)
{
fprintf( stderr, "dbus reply message was NULL\n" );
return (-1);
}
/* now analyze reply */
dbus_error_init (&error);
if (!dbus_message_get_args (reply, &error, DBUS_TYPE_BOOLEAN, &trusted, DBUS_TYPE_INVALID))
trusted = FALSE;
if (dbus_error_is_set (&error))
dbus_error_free (&error);
dbus_message_unref (reply);
return (trusted);
}
static void get_networks_of_type (DBusConnection *connection, NMNetworkType type)
{
DBusMessage *message;
DBusMessage *reply;
DBusError error;
gint32 type_as_int;
char **networks;
int num_networks;
int i;
message = dbus_message_new_method_call (NMI_DBUS_SERVICE, NMI_DBUS_PATH, NMI_DBUS_INTERFACE, "getNetworks");
if (message == NULL)
{
fprintf (stderr, "Couldn't allocate the dbus message\n");
return;
}
dbus_error_init (&error);
type_as_int = (gint32) type;
dbus_message_append_args (message, DBUS_TYPE_INT32, &type_as_int, DBUS_TYPE_INVALID);
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error);
dbus_message_unref (message);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "%s raised:\n %s\n\n", error.name, error.message);
dbus_error_free (&error);
return;
}
if (reply == NULL)
{
fprintf( stderr, "dbus reply message was NULL\n" );
return;
}
/* now analyze reply */
dbus_error_init (&error);
if (!dbus_message_get_args (reply, &error, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
&networks, &num_networks, DBUS_TYPE_INVALID))
{
fprintf (stderr, "NetworkManagerInfo returned no network list" );
dbus_message_unref (reply);
return;
}
dbus_message_unref (reply);
if (!networks)
fprintf( stderr, "No networks found\n" );
fprintf( stderr, "Networks of type %d:\n", type );
for (i = 0; i < num_networks; i++)
{
if (strlen (networks[i]) == 0)
{
fprintf( stderr, " No networks found\n" );
break;
}
else
{
char *essid = get_network_string_property (connection, networks[i], "getNetworkEssid", type);
char *key = get_network_string_property (connection, networks[i], "getNetworkKey", type);
fprintf(stderr, " %s\t%s\t%s\n", essid, key, get_network_trusted (connection, networks[i], type) ? "trusted" : "untrusted");
}
}
g_strfreev (networks);
}
static void get_user_key_for_network (DBusConnection *connection)
{
DBusMessage * message;
const char * dev_path = NM_DBUS_PATH_DEVICE"/eth1";
const char * net_path = NM_DBUS_PATH_DEVICE"/Networks/wireless-ap";
const char * essid = "wireless-ap";
const int attempts = 0;
const gboolean new_key = FALSE;
g_return_if_fail (connection != NULL);
message = dbus_message_new_method_call (NMI_DBUS_SERVICE, NMI_DBUS_PATH, NMI_DBUS_INTERFACE, "getKeyForNetwork");
if (message == NULL)
{
fprintf (stderr, "get_user_key_for_network(): Couldn't allocate the dbus message\n");
return;
}
dbus_message_append_args (message, DBUS_TYPE_STRING, &dev_path,
DBUS_TYPE_STRING, &net_path,
DBUS_TYPE_STRING, &essid,
DBUS_TYPE_INT32, &attempts,
DBUS_TYPE_BOOLEAN, &new_key,
DBUS_TYPE_INVALID);
if (!dbus_connection_send (connection, message, NULL))
fprintf (stderr, "get_user_key_for_network(): could not send dbus message\n");
dbus_message_unref (message);
}
static void set_user_key_for_network (DBusConnection *connection, DBusMessage *message, GMainLoop *loop)
{
DBusError error;
char * passphrase;
int key_type = -1;
g_return_if_fail (connection != NULL);
g_return_if_fail (message != NULL);
dbus_error_init (&error);
if (dbus_message_get_args (message, &error,
DBUS_TYPE_STRING, &passphrase,
DBUS_TYPE_STRING, &key_type,
DBUS_TYPE_INVALID))
{
fprintf( stderr, "Passphrase was '%s'\nKey type was %d\n", passphrase, key_type);
g_main_loop_quit (loop);
}
}
static DBusHandlerResult nm_message_handler (DBusConnection *connection, DBusMessage *message, void *user_data)
{
const char *method;
const char *path;
gboolean handled = TRUE;
g_return_val_if_fail (connection != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
g_return_val_if_fail (message != NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
method = dbus_message_get_member (message);
path = dbus_message_get_path (message);
fprintf (stderr, "nm_dbus_nm_message_handler() got method %s for path %s\n", method, path);
if (strcmp ("setKeyForNetwork", method) == 0)
set_user_key_for_network (connection, message, user_data);
else
handled = FALSE;
return (handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
}
int main( int argc, char *argv[] )
{
DBusConnection *connection;
DBusError error;
DBusObjectPathVTable vtable = { NULL, &nm_message_handler, NULL, NULL, NULL, NULL };
dbus_bool_t success = FALSE;
GMainLoop *loop = NULL;
loop = g_main_loop_new (NULL, FALSE);
g_type_init ();
if (!g_thread_supported ())
g_thread_init (NULL);
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);
exit (1);
}
dbus_connection_setup_with_g_main (connection, NULL);
dbus_error_init (&error);
dbus_bus_request_name (connection, NM_DBUS_SERVICE, 0, &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "Could not acquire its service. dbus_bus_request_name() says: '%s'\n", error.message);
exit (1);
}
success = dbus_connection_register_object_path (connection, NM_DBUS_PATH, &vtable, loop);
if (!success)
{
fprintf (stderr, "Could not register a handler for NetworkManager. Not enough memory?\n");
exit (1);
}
get_networks_of_type (connection, NETWORK_TYPE_ALLOWED);
get_networks_of_type (connection, NETWORK_TYPE_DEVICE);
get_user_key_for_network (connection);
g_main_loop_run (loop);
return 0;
}