← Back to branch summary

~ubuntu-branches/ubuntu/lucid/wpasupplicant/lucid-updates

« back to all changes in this revision

Viewing changes to driver_ndis_.c

  • Committer: Bazaar Package Importer
  • Author(s): Kel Modderman
  • Date: 2006-10-05 08:04:01 UTC
  • mfrom: (1.1.5 upstream) (3 etch)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20061005080401-r8lqlix4390yos7b
Tags: 0.5.5-2
http://bugs.debian.org/388316
* Update madwifi headers to latest SVN. (Closes: #388316)
* Remove failed attempt at action locking. [debian/functions.sh,
  debian/wpa_action.sh]
* Add hysteresis checking functions, to avoid "event loops" while
  using wpa-roam. [debian/functions.sh, debian/wpa_action.sh]
* Change of co-maintainer email address.
* Add ishex() function to functions.sh to determine wpa-psk value type in
  plaintext or hex. This effectively eliminates the need for the bogus and
  somewhat confusing wpa-passphrase contruct specific to our scripts and
  allows wpa-psk to work with either a 8 to 63 character long plaintext
  string or 64 character long hex string.
* Adjust README.modes to not refer to the redundant wpa-passphrase stuff.
* Add big fat NOTE about acceptable wpa-psk's to top of example gallery.
* Strip surrounding quotes from wpa-ssid if present, instead of just whining
  about them.
* Update email address in copyright blurb of functions.sh, ifupdown.sh and
  wpa_action.sh.  

Show diffs side-by-side

added added

removed removed

Lines of Context:
driver_ndis_.c
42
42
 
43
43
/* Event data:
44
44
 * enum event_types (as int, i.e., 4 octets)
45
 
 * InstanceName length (1 octet)
46
 
 * InstanceName (variable len)
47
 
 * data length (1 octet, optional)
 
45
 * data length (2 octets (big endian), optional)
48
46
 * data (variable len, optional)
49
47
 */
50
48
 
53
51
                                          u8 *buf, size_t len)
54
52
{
55
53
        u8 *pos, *data = NULL;
56
 
        int i, desc_len;
57
54
        enum event_types type;
58
 
        unsigned char instance_len;
59
 
        char *instance;
60
55
        size_t data_len = 0;
61
56
 
62
57
        wpa_hexdump(MSG_MSGDUMP, "NDIS: received event data", buf, len);
63
 
        if (len < sizeof(int) + 1)
 
58
        if (len < sizeof(int))
64
59
                return;
65
60
        type = *((int *) buf);
66
61
        pos = buf + sizeof(int);
67
62
        wpa_printf(MSG_DEBUG, "NDIS: event - type %d", type);
68
 
        instance_len = *pos++;
69
 
        if (instance_len > buf + len - pos) {
70
 
                wpa_printf(MSG_DEBUG, "NDIS: event InstanceName overflow");
71
 
                return;
72
 
        }
73
 
        instance = pos;
74
 
        pos += instance_len;
75
 
        wpa_hexdump_ascii(MSG_MSGDUMP, "NDIS: event InstanceName",
76
 
                          instance, instance_len);
77
63
 
78
 
        if (buf + len - pos > 1) {
79
 
                data_len = *pos++;
 
64
        if (buf + len - pos > 2) {
 
65
                data_len = (int) *pos++ << 8;
 
66
                data_len += *pos++;
80
67
                if (data_len > (size_t) (buf + len - pos)) {
81
68
                        wpa_printf(MSG_DEBUG, "NDIS: event data overflow");
82
69
                        return;
85
72
                wpa_hexdump(MSG_MSGDUMP, "NDIS: event data", data, data_len);
86
73
        }
87
74
 
88
 
        if (drv->adapter_desc) {
89
 
                desc_len = strlen(drv->adapter_desc);
90
 
                if (instance_len < desc_len ||
91
 
                    strncmp(drv->adapter_desc, instance, desc_len)) {
92
 
                        wpa_printf(MSG_DEBUG, "NDIS: ignored event for "
93
 
                                   "another adapter");
94
 
                        return;
95
 
                }
96
 
 
97
 
                /* InstanceName:
98
 
                 * <driver desc> #<num>
99
 
                 * <driver desc> #<num> - <intermediate drv name> Miniport
100
 
                 */
101
 
                for (i = desc_len + 1; i < instance_len; i++) {
102
 
                        if (instance[i] == '-') {
103
 
                                wpa_printf(MSG_DEBUG, "NDIS: ignored event "
104
 
                                           "for intermediate miniport");
105
 
                                return;
106
 
                        }
107
 
                }
108
 
        }
109
 
 
110
75
        switch (type) {
111
76
        case EVENT_CONNECT:
112
77
                wpa_driver_ndis_event_connect(drv);
127
92
}
128
93
 
129
94
 
130
 
#ifdef CONFIG_NDIS_EVENTS_INTEGRATED
131
 
 
132
95
void wpa_driver_ndis_event_pipe_cb(void *eloop_data, void *user_data)
133
96
{
134
97
        struct wpa_driver_ndis_data *drv = eloop_data;
143
106
                           (int) GetLastError());
144
107
        }
145
108
}
146
 
 
147
 
#else /* CONFIG_NDIS_EVENTS_INTEGRATED */
148
 
 
149
 
static void wpa_driver_ndis_event_cb(int sock, void *eloop_ctx, void *sock_ctx)
150
 
{
151
 
        struct wpa_driver_ndis_data *drv = eloop_ctx;
152
 
        u8 buf[512];
153
 
        int res;
154
 
 
155
 
        res = recv(sock, buf, sizeof(buf), 0);
156
 
        if (res < 0) {
157
 
                perror("wpa_driver_ndis_event_cb - recv");
158
 
                return;
159
 
        }
160
 
        wpa_driver_ndis_event_process(drv, buf, (size_t) res);
161
 
}
162
 
 
163
 
 
164
 
int wpa_driver_register_event_cb(struct wpa_driver_ndis_data *drv)
165
 
{
166
 
        struct sockaddr_in addr;
167
 
 
168
 
        drv->event_sock = socket(PF_INET, SOCK_DGRAM, 0);
169
 
        if (drv->event_sock < 0) {
170
 
                perror("socket");
171
 
                return -1;
172
 
        }
173
 
 
174
 
        /* These events are received from an external program, ndis_events,
175
 
         * which is converting WMI events to more "UNIX-like" input for
176
 
         * wpa_supplicant, i.e., UDP packets that can be received through the
177
 
         * eloop mechanism. */
178
 
        memset(&addr, 0, sizeof(addr));
179
 
        addr.sin_family = AF_INET;
180
 
        addr.sin_addr.s_addr = htonl((127 << 24) | 1);
181
 
        addr.sin_port = htons(9876);
182
 
        if (bind(drv->event_sock, (struct sockaddr *) &addr, sizeof(addr)) < 0)
183
 
        {
184
 
                perror("bind");
185
 
                close(drv->event_sock);
186
 
                drv->event_sock = -1;
187
 
                return -1;
188
 
        }
189
 
 
190
 
        eloop_register_read_sock(drv->event_sock, wpa_driver_ndis_event_cb,
191
 
                                 drv, NULL);
192
 
 
193
 
        return 0;
194
 
}
195
 
 
196
 
#endif /* CONFIG_NDIS_EVENTS_INTEGRATED */