← Back to branch summary

~dylanmccall/ubuntu/oneiric/network-manager-applet/lp852961-disable-autostart-for-gnome-shell

« back to all changes in this revision

Viewing changes to src/wireless-security-option.c

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Mercatante
  • Date: 2007-06-15 12:46:22 UTC
  • Revision ID: james.westby@ubuntu.com-20070615124622-01cyrnf0uxxun4lz
Tags: upstream-0.6.5
Import upstream version 0.6.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/wireless-security-option.c
 
1
/* NetworkManager Wireless Applet -- Display wireless access points and allow user control
 
2
 *
 
3
 * Dan Williams <dcbw@redhat.com>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * (at your option) any later version.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
18
 *
 
19
 * (C) Copyright 2005 Red Hat, Inc.
 
20
 */
 
21
 
 
22
#include <glib.h>
 
23
#include <glib/gi18n.h>
 
24
#include <gtk/gtk.h>
 
25
#include <string.h>
 
26
#include <glade/glade.h>
 
27
#include <iwlib.h>
 
28
#include <dbus/dbus.h>
 
29
 
 
30
#include "wireless-security-option.h"
 
31
#include "cipher.h"
 
32
#include "wso-private.h"
 
33
#include "NetworkManager.h"
 
34
 
 
35
gboolean wso_is_wso_widget (GtkWidget * widget)
 
36
{
 
37
        gpointer        tag;
 
38
 
 
39
        g_return_val_if_fail (widget != NULL, FALSE);
 
40
 
 
41
        tag = g_object_get_data (G_OBJECT (widget), WS_TAG_NAME);
 
42
        if (tag && (GPOINTER_TO_INT (tag) == WS_TAG_MAGIC))
 
43
                return TRUE;
 
44
        return FALSE;
 
45
}
 
46
 
 
47
const char * wso_get_name (WirelessSecurityOption * opt)
 
48
{
 
49
        g_return_val_if_fail (opt != NULL, NULL);
 
50
 
 
51
        return opt->name;
 
52
}
 
53
 
 
54
GtkWidget * wso_get_widget (WirelessSecurityOption * opt, GtkSignalFunc validate_cb, gpointer user_data)
 
55
{
 
56
        g_return_val_if_fail (opt != NULL, NULL);
 
57
        g_return_val_if_fail (validate_cb != NULL, NULL);
 
58
 
 
59
        if (!opt->widget && opt->widget_create_func)
 
60
                opt->widget = (*(opt->widget_create_func))(opt, validate_cb, user_data);
 
61
        return opt->widget;
 
62
}
 
63
 
 
64
gboolean wso_validate_input (WirelessSecurityOption * opt, const char * ssid, IEEE_802_11_Cipher ** out_cipher)
 
65
{
 
66
        g_return_val_if_fail (opt != NULL, FALSE);
 
67
        g_return_val_if_fail (ssid != NULL, FALSE);
 
68
 
 
69
        if (opt->validate_input_func)
 
70
                return (*(opt->validate_input_func))(opt, ssid, out_cipher);
 
71
        return FALSE;
 
72
}
 
73
 
 
74
gboolean wso_append_dbus_params (WirelessSecurityOption *opt, const char *ssid, DBusMessage *message)
 
75
{
 
76
        g_return_val_if_fail (opt != NULL, FALSE);
 
77
        g_return_val_if_fail (ssid != NULL, FALSE);
 
78
        g_return_val_if_fail (message != NULL, FALSE);
 
79
 
 
80
        g_assert (opt->append_dbus_params_func);
 
81
        return (*(opt->append_dbus_params_func))(opt, ssid, message);
 
82
}
 
83
 
 
84
void wso_free (WirelessSecurityOption * opt)
 
85
{
 
86
        /* Free the option-specific data first */
 
87
        if (opt->data_free_func)
 
88
                (*(opt->data_free_func))(opt);
 
89
 
 
90
        g_free (opt->name);
 
91
        if (opt->uixml)
 
92
                g_object_unref (opt->uixml);
 
93
        if (opt->widget)
 
94
                g_object_unref (opt->widget);
 
95
        g_slist_foreach (opt->ciphers, (GFunc) ieee_802_11_cipher_unref, NULL);
 
96
        g_slist_free (opt->ciphers);
 
97
 
 
98
        memset (opt, 0, sizeof (WirelessSecurityOption));
 
99
        g_free (opt);
 
100
}
 
101
 
 
102
 
 
103
/**********************************************/
 
104
 
 
105
gboolean wso_validate_helper (WirelessSecurityOption *opt, const char *ssid, const char *input, IEEE_802_11_Cipher ** out_cipher)
 
106
{
 
107
        GSList * elt;
 
108
 
 
109
        g_return_val_if_fail (opt != NULL, FALSE);
 
110
        g_return_val_if_fail (input != NULL, FALSE);
 
111
        g_return_val_if_fail (ssid != NULL, FALSE);
 
112
 
 
113
        if (out_cipher)
 
114
                g_return_val_if_fail (*out_cipher == NULL, FALSE);
 
115
 
 
116
        /* Try each of our ciphers in turn, if one validates that's enough */
 
117
        for (elt = opt->ciphers; elt; elt = g_slist_next (elt))
 
118
        {
 
119
                IEEE_802_11_Cipher * cipher = (IEEE_802_11_Cipher *) (elt->data);
 
120
                if (ieee_802_11_cipher_validate (cipher, ssid, input) == 0)
 
121
                {
 
122
                        if (out_cipher)
 
123
                                *out_cipher = cipher;
 
124
                        return TRUE;
 
125
                }
 
126
        }
 
127
        return FALSE;
 
128
}
 
129
 
 
130
 
 
131
GtkWidget * wso_widget_helper (WirelessSecurityOption *opt)
 
132
{
 
133
        GtkWidget * widget;
 
134
 
 
135
        g_return_val_if_fail (opt != NULL, NULL);
 
136
 
 
137
        widget = glade_xml_get_widget (opt->uixml, opt->widget_name);
 
138
        g_object_ref (G_OBJECT (widget));
 
139
        g_object_set_data (G_OBJECT (widget), WS_TAG_NAME, GINT_TO_POINTER (WS_TAG_MAGIC));
 
140
        return widget;
 
141
}
 
142
 
 
143
 
 
144
#define NAME_COLUMN                     0
 
145
#define AUTH_ALG_COLUMN         1
 
146
void wso_wep_auth_combo_setup (WirelessSecurityOption *opt, GtkComboBox * combo)
 
147
{
 
148
        GtkListStore *  model;
 
149
        GtkTreeIter     iter;
 
150
 
 
151
        g_return_if_fail (opt != NULL);
 
152
        g_return_if_fail (combo != NULL);
 
153
 
 
154
        model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
155
 
 
156
        gtk_list_store_append (model, &iter);
 
157
        gtk_list_store_set (model, &iter, NAME_COLUMN, _("Open System"), AUTH_ALG_COLUMN, IW_AUTH_ALG_OPEN_SYSTEM, -1);
 
158
 
 
159
        gtk_list_store_append (model, &iter);
 
160
        gtk_list_store_set (model, &iter, NAME_COLUMN, _("Shared Key"), AUTH_ALG_COLUMN, IW_AUTH_ALG_SHARED_KEY, -1);
 
161
 
 
162
        g_object_ref (G_OBJECT (model));
 
163
 
 
164
        gtk_combo_box_set_model (combo, GTK_TREE_MODEL (model));
 
165
        gtk_combo_box_set_active (combo, 0);
 
166
}
 
167
 
 
168
int wso_wep_auth_combo_get_auth_alg (WirelessSecurityOption *opt, GtkComboBox * combo)
 
169
{
 
170
        GtkTreeIter     iter;
 
171
        GtkTreeModel *  model;
 
172
        int                     auth_alg;
 
173
 
 
174
        g_return_val_if_fail (opt != NULL, -1);
 
175
        g_return_val_if_fail (combo != NULL, -1);
 
176
 
 
177
        model = gtk_combo_box_get_model (combo);
 
178
        gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter);
 
179
        gtk_tree_model_get (model, &iter, AUTH_ALG_COLUMN, &auth_alg, -1);
 
180
        return auth_alg;
 
181
}
 
182
 
 
183
void wso_wep_auth_combo_cleanup (WirelessSecurityOption *opt, GtkComboBox * combo)
 
184
{
 
185
        GtkListStore * model;
 
186
 
 
187
        g_return_if_fail (opt != NULL);
 
188
        g_return_if_fail (combo != NULL);
 
189
 
 
190
        model = GTK_LIST_STORE (gtk_combo_box_get_model (combo));
 
191
        g_object_unref (G_OBJECT (model));
 
192
}
 
193
 
 
194
 
 
195
GtkTreeModel *
 
196
wso_wpa_create_key_type_model (int capabilities, gboolean wpa_eap, int *num_added)
 
197
{
 
198
        GtkListStore *  model;
 
199
        GtkTreeIter     iter;
 
200
        int                     num = 1;
 
201
        const char *    name;
 
202
 
 
203
        g_return_val_if_fail (num_added != NULL, NULL);
 
204
 
 
205
        model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
206
 
 
207
        name = _("Automatic (Default)");
 
208
        gtk_list_store_append (model, &iter);
 
209
        gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
210
                                        WPA_KEY_TYPE_CIPHER_COL, NM_AUTH_TYPE_WPA_PSK_AUTO, -1);
 
211
 
 
212
        if (capabilities & NM_802_11_CAP_CIPHER_CCMP)
 
213
        {
 
214
                name = _("AES-CCMP");
 
215
                gtk_list_store_append (model, &iter);
 
216
                gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
217
                        WPA_KEY_TYPE_CIPHER_COL, IW_AUTH_CIPHER_CCMP, -1);
 
218
                num++;
 
219
        }
 
220
        if (capabilities & NM_802_11_CAP_CIPHER_TKIP)
 
221
        {
 
222
                name = _("TKIP");
 
223
                gtk_list_store_append (model, &iter);
 
224
                gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
225
                        WPA_KEY_TYPE_CIPHER_COL, IW_AUTH_CIPHER_TKIP, -1);
 
226
                num++;
 
227
        }
 
228
        if (wpa_eap && capabilities & NM_802_11_CAP_KEY_MGMT_802_1X)
 
229
        {
 
230
                name = _("Dynamic WEP");
 
231
                gtk_list_store_append (model, &iter);
 
232
                gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
233
                        WPA_KEY_TYPE_CIPHER_COL, IW_AUTH_CIPHER_WEP104, -1);
 
234
                num++;
 
235
        }
 
236
 
 
237
        *num_added = num;
 
238
        return GTK_TREE_MODEL (model);
 
239
}
 
240
 
 
241
GtkTreeModel *
 
242
wso_wpa_create_phase2_type_model (int capabilities, gboolean wpa_eap, int *num_added)
 
243
{
 
244
        GtkListStore *  model;
 
245
        GtkTreeIter     iter;
 
246
        const char *    name;
 
247
 
 
248
        g_return_val_if_fail (num_added != NULL, NULL);
 
249
 
 
250
        model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
251
 
 
252
        name = _("None (Default)");
 
253
        gtk_list_store_append (model, &iter);
 
254
        gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
255
                                        WPA_KEY_TYPE_CIPHER_COL, NM_PHASE2_AUTH_NONE, -1);
 
256
 
 
257
        name = _("PAP");
 
258
        gtk_list_store_append (model, &iter);
 
259
        gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
260
                                        WPA_KEY_TYPE_CIPHER_COL, NM_PHASE2_AUTH_PAP, -1);
 
261
 
 
262
        name = _("MSCHAP");
 
263
        gtk_list_store_append (model, &iter);
 
264
        gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
265
                                        WPA_KEY_TYPE_CIPHER_COL, NM_PHASE2_AUTH_MSCHAP, -1);
 
266
 
 
267
        name = _("MSCHAPV2");
 
268
        gtk_list_store_append (model, &iter);
 
269
        gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
270
                                        WPA_KEY_TYPE_CIPHER_COL, NM_PHASE2_AUTH_MSCHAPV2, -1);
 
271
 
 
272
        name = _("GTC");
 
273
        gtk_list_store_append (model, &iter);
 
274
        gtk_list_store_set (model, &iter, WPA_KEY_TYPE_NAME_COL, name,
 
275
                                        WPA_KEY_TYPE_CIPHER_COL, NM_PHASE2_AUTH_GTC, -1);
 
276
 
 
277
        *num_added = 4;
 
278
        return GTK_TREE_MODEL (model);
 
279
}
 
280