diff options
Diffstat (limited to 'src/transport/gnunet-transport-wlan-helper.c')
-rw-r--r-- | src/transport/gnunet-transport-wlan-helper.c | 1103 |
1 files changed, 529 insertions, 574 deletions
diff --git a/src/transport/gnunet-transport-wlan-helper.c b/src/transport/gnunet-transport-wlan-helper.c index a00b28854..1cfcf2c4e 100644 --- a/src/transport/gnunet-transport-wlan-helper.c +++ b/src/transport/gnunet-transport-wlan-helper.c | |||
@@ -108,11 +108,11 @@ struct Hardware_Infos | |||
108 | }; | 108 | }; |
109 | 109 | ||
110 | // FIXME: inline? | 110 | // FIXME: inline? |
111 | int getChannelFromFrequency(int frequency); | 111 | int getChannelFromFrequency (int frequency); |
112 | 112 | ||
113 | // FIXME: make nice... | 113 | // FIXME: make nice... |
114 | static unsigned long | 114 | static unsigned long |
115 | calc_crc_osdep(unsigned char * buf, int len) | 115 | calc_crc_osdep (unsigned char *buf, int len) |
116 | { | 116 | { |
117 | unsigned long crc = 0xFFFFFFFF; | 117 | unsigned long crc = 0xFFFFFFFF; |
118 | 118 | ||
@@ -126,44 +126,46 @@ calc_crc_osdep(unsigned char * buf, int len) | |||
126 | 126 | ||
127 | // FIXME: make nice... | 127 | // FIXME: make nice... |
128 | static int | 128 | static int |
129 | check_crc_buf_osdep(unsigned char *buf, int len) | 129 | check_crc_buf_osdep (unsigned char *buf, int len) |
130 | { | 130 | { |
131 | unsigned long crc; | 131 | unsigned long crc; |
132 | 132 | ||
133 | if (0 > len) | 133 | if (0 > len) |
134 | return 0; | 134 | return 0; |
135 | 135 | ||
136 | crc = calc_crc_osdep(buf, len); | 136 | crc = calc_crc_osdep (buf, len); |
137 | buf += len; | 137 | buf += len; |
138 | return (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] && ((crc | 138 | return (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] && ((crc |
139 | >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3]); | 139 | >> 16) |
140 | & 0xFF) | ||
141 | == buf[2] && ((crc >> 24) & 0xFF) == buf[3]); | ||
140 | } | 142 | } |
141 | 143 | ||
142 | 144 | ||
143 | // FIXME: make nice... | 145 | // FIXME: make nice... |
144 | static int | 146 | static int |
145 | linux_get_channel(struct Hardware_Infos *dev) | 147 | linux_get_channel (struct Hardware_Infos *dev) |
146 | { | 148 | { |
147 | struct iwreq wrq; | 149 | struct iwreq wrq; |
148 | int fd, frequency; | 150 | int fd, frequency; |
149 | int chan = 0; | 151 | int chan = 0; |
150 | 152 | ||
151 | memset(&wrq, 0, sizeof(struct iwreq)); | 153 | memset (&wrq, 0, sizeof (struct iwreq)); |
152 | 154 | ||
153 | strncpy(wrq.ifr_name, dev->iface, IFNAMSIZ ); | 155 | strncpy (wrq.ifr_name, dev->iface, IFNAMSIZ); |
154 | 156 | ||
155 | fd = dev->fd_raw; | 157 | fd = dev->fd_raw; |
156 | if (0 > ioctl(fd, SIOCGIWFREQ, &wrq)) | 158 | if (0 > ioctl (fd, SIOCGIWFREQ, &wrq)) |
157 | return (-1); | 159 | return (-1); |
158 | 160 | ||
159 | frequency = wrq.u.freq.m; | 161 | frequency = wrq.u.freq.m; |
160 | if (100000000 < frequency ) | 162 | if (100000000 < frequency) |
161 | frequency /= 100000; | 163 | frequency /= 100000; |
162 | else if (1000000 < frequency ) | 164 | else if (1000000 < frequency) |
163 | frequency /= 1000; | 165 | frequency /= 1000; |
164 | 166 | ||
165 | if (1000 < frequency) | 167 | if (1000 < frequency) |
166 | chan = getChannelFromFrequency(frequency); | 168 | chan = getChannelFromFrequency (frequency); |
167 | else | 169 | else |
168 | chan = frequency; | 170 | chan = frequency; |
169 | 171 | ||
@@ -173,10 +175,8 @@ linux_get_channel(struct Hardware_Infos *dev) | |||
173 | 175 | ||
174 | // FIXME: make nice... | 176 | // FIXME: make nice... |
175 | static ssize_t | 177 | static ssize_t |
176 | linux_read (struct Hardware_Infos *dev, | 178 | linux_read (struct Hardware_Infos *dev, unsigned char *buf, /* FIXME: void*? */ |
177 | unsigned char *buf, /* FIXME: void*? */ | 179 | size_t buf_size, struct Radiotap_rx *ri) |
178 | size_t buf_size, | ||
179 | struct Radiotap_rx *ri) | ||
180 | { | 180 | { |
181 | unsigned char tmpbuf[buf_size]; | 181 | unsigned char tmpbuf[buf_size]; |
182 | ssize_t caplen; | 182 | ssize_t caplen; |
@@ -184,178 +184,175 @@ linux_read (struct Hardware_Infos *dev, | |||
184 | 184 | ||
185 | n = got_signal = got_noise = got_channel = fcs_removed = 0; | 185 | n = got_signal = got_noise = got_channel = fcs_removed = 0; |
186 | 186 | ||
187 | caplen = read(dev->fd_raw, tmpbuf, buf_size); | 187 | caplen = read (dev->fd_raw, tmpbuf, buf_size); |
188 | if (0 > caplen) | 188 | if (0 > caplen) |
189 | { | ||
190 | if (EAGAIN == errno) | ||
191 | return 0; | ||
192 | fprintf (stderr, "Failed to read from RAW socket: %s\n", strerror (errno)); | ||
193 | return -1; | ||
194 | } | ||
195 | |||
196 | memset (buf, 0, buf_size); | ||
197 | memset (ri, 0, sizeof (*ri)); | ||
198 | |||
199 | switch (dev->arptype_in) | ||
200 | { | ||
201 | case ARPHRD_IEEE80211_PRISM: | ||
202 | { | ||
203 | /* skip the prism header */ | ||
204 | if (tmpbuf[7] == 0x40) | ||
189 | { | 205 | { |
190 | if (EAGAIN == errno) | 206 | /* prism54 uses a different format */ |
191 | return 0; | 207 | ri->ri_power = tmpbuf[0x33]; |
192 | fprintf (stderr, | 208 | ri->ri_noise = *(unsigned int *) (tmpbuf + 0x33 + 12); |
193 | "Failed to read from RAW socket: %s\n", | 209 | ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x33 + 24)) * 500000; |
194 | strerror (errno)); | 210 | got_signal = 1; |
195 | return -1; | 211 | got_noise = 1; |
212 | n = 0x40; | ||
213 | } | ||
214 | else | ||
215 | { | ||
216 | ri->ri_mactime = *(u_int64_t *) (tmpbuf + 0x5C - 48); | ||
217 | ri->ri_channel = *(unsigned int *) (tmpbuf + 0x5C - 36); | ||
218 | ri->ri_power = *(unsigned int *) (tmpbuf + 0x5C); | ||
219 | ri->ri_noise = *(unsigned int *) (tmpbuf + 0x5C + 12); | ||
220 | ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x5C + 24)) * 500000; | ||
221 | got_channel = 1; | ||
222 | got_signal = 1; | ||
223 | got_noise = 1; | ||
224 | n = *(int *) (tmpbuf + 4); | ||
196 | } | 225 | } |
197 | 226 | ||
198 | memset(buf, 0, buf_size); | 227 | if (n < 8 || n >= caplen) |
199 | memset(ri, 0, sizeof(*ri)); | 228 | return (0); |
229 | } | ||
230 | break; | ||
200 | 231 | ||
201 | switch (dev->arptype_in) | 232 | case ARPHRD_IEEE80211_FULL: |
233 | { | ||
234 | struct ieee80211_radiotap_iterator iterator; | ||
235 | struct ieee80211_radiotap_header *rthdr; | ||
236 | |||
237 | rthdr = (struct ieee80211_radiotap_header *) tmpbuf; | ||
238 | |||
239 | if (ieee80211_radiotap_iterator_init (&iterator, rthdr, caplen) < 0) | ||
240 | return (0); | ||
241 | |||
242 | /* go through the radiotap arguments we have been given | ||
243 | * by the driver | ||
244 | */ | ||
245 | |||
246 | while (ieee80211_radiotap_iterator_next (&iterator) >= 0) | ||
202 | { | 247 | { |
203 | case ARPHRD_IEEE80211_PRISM: | ||
204 | { | ||
205 | /* skip the prism header */ | ||
206 | if (tmpbuf[7] == 0x40) | ||
207 | { | ||
208 | /* prism54 uses a different format */ | ||
209 | ri->ri_power = tmpbuf[0x33]; | ||
210 | ri->ri_noise = *(unsigned int *) (tmpbuf + 0x33 + 12); | ||
211 | ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x33 + 24)) * 500000; | ||
212 | got_signal = 1; | ||
213 | got_noise = 1; | ||
214 | n = 0x40; | ||
215 | } | ||
216 | else | ||
217 | { | ||
218 | ri->ri_mactime = *(u_int64_t*) (tmpbuf + 0x5C - 48); | ||
219 | ri->ri_channel = *(unsigned int *) (tmpbuf + 0x5C - 36); | ||
220 | ri->ri_power = *(unsigned int *) (tmpbuf + 0x5C); | ||
221 | ri->ri_noise = *(unsigned int *) (tmpbuf + 0x5C + 12); | ||
222 | ri->ri_rate = (*(unsigned int *) (tmpbuf + 0x5C + 24)) * 500000; | ||
223 | got_channel = 1; | ||
224 | got_signal = 1; | ||
225 | got_noise = 1; | ||
226 | n = *(int *) (tmpbuf + 4); | ||
227 | } | ||
228 | |||
229 | if (n < 8 || n >= caplen) | ||
230 | return (0); | ||
231 | } | ||
232 | break; | ||
233 | 248 | ||
234 | case ARPHRD_IEEE80211_FULL: | 249 | switch (iterator.this_arg_index) |
235 | { | 250 | { |
236 | struct ieee80211_radiotap_iterator iterator; | 251 | |
237 | struct ieee80211_radiotap_header *rthdr; | 252 | case IEEE80211_RADIOTAP_TSFT: |
238 | 253 | ri->ri_mactime = le64_to_cpu (*((uint64_t *) iterator.this_arg)); | |
239 | rthdr = (struct ieee80211_radiotap_header *) tmpbuf; | 254 | break; |
240 | 255 | ||
241 | if (ieee80211_radiotap_iterator_init(&iterator, rthdr, caplen) < 0) | 256 | case IEEE80211_RADIOTAP_DBM_ANTSIGNAL: |
242 | return (0); | 257 | if (!got_signal) |
243 | 258 | { | |
244 | /* go through the radiotap arguments we have been given | 259 | if (*iterator.this_arg < 127) |
245 | * by the driver | 260 | ri->ri_power = *iterator.this_arg; |
246 | */ | 261 | else |
247 | 262 | ri->ri_power = *iterator.this_arg - 255; | |
248 | while (ieee80211_radiotap_iterator_next(&iterator) >= 0) | 263 | |
249 | { | 264 | got_signal = 1; |
250 | 265 | } | |
251 | switch (iterator.this_arg_index) | 266 | break; |
252 | { | 267 | |
253 | 268 | case IEEE80211_RADIOTAP_DB_ANTSIGNAL: | |
254 | case IEEE80211_RADIOTAP_TSFT: | 269 | if (!got_signal) |
255 | ri->ri_mactime = le64_to_cpu(*((uint64_t*) iterator.this_arg)); | 270 | { |
256 | break; | 271 | if (*iterator.this_arg < 127) |
257 | 272 | ri->ri_power = *iterator.this_arg; | |
258 | case IEEE80211_RADIOTAP_DBM_ANTSIGNAL: | 273 | else |
259 | if (!got_signal) | 274 | ri->ri_power = *iterator.this_arg - 255; |
260 | { | 275 | |
261 | if (*iterator.this_arg < 127) | 276 | got_signal = 1; |
262 | ri->ri_power = *iterator.this_arg; | 277 | } |
263 | else | 278 | break; |
264 | ri->ri_power = *iterator.this_arg - 255; | 279 | |
265 | 280 | case IEEE80211_RADIOTAP_DBM_ANTNOISE: | |
266 | got_signal = 1; | 281 | if (!got_noise) |
267 | } | 282 | { |
268 | break; | 283 | if (*iterator.this_arg < 127) |
269 | 284 | ri->ri_noise = *iterator.this_arg; | |
270 | case IEEE80211_RADIOTAP_DB_ANTSIGNAL: | 285 | else |
271 | if (!got_signal) | 286 | ri->ri_noise = *iterator.this_arg - 255; |
272 | { | 287 | |
273 | if (*iterator.this_arg < 127) | 288 | got_noise = 1; |
274 | ri->ri_power = *iterator.this_arg; | 289 | } |
275 | else | 290 | break; |
276 | ri->ri_power = *iterator.this_arg - 255; | 291 | |
277 | 292 | case IEEE80211_RADIOTAP_DB_ANTNOISE: | |
278 | got_signal = 1; | 293 | if (!got_noise) |
279 | } | 294 | { |
280 | break; | 295 | if (*iterator.this_arg < 127) |
281 | 296 | ri->ri_noise = *iterator.this_arg; | |
282 | case IEEE80211_RADIOTAP_DBM_ANTNOISE: | 297 | else |
283 | if (!got_noise) | 298 | ri->ri_noise = *iterator.this_arg - 255; |
284 | { | 299 | |
285 | if (*iterator.this_arg < 127) | 300 | got_noise = 1; |
286 | ri->ri_noise = *iterator.this_arg; | 301 | } |
287 | else | 302 | break; |
288 | ri->ri_noise = *iterator.this_arg - 255; | 303 | |
289 | 304 | case IEEE80211_RADIOTAP_ANTENNA: | |
290 | got_noise = 1; | 305 | ri->ri_antenna = *iterator.this_arg; |
291 | } | 306 | break; |
292 | break; | 307 | |
293 | 308 | case IEEE80211_RADIOTAP_CHANNEL: | |
294 | case IEEE80211_RADIOTAP_DB_ANTNOISE: | 309 | ri->ri_channel = *iterator.this_arg; |
295 | if (!got_noise) | 310 | got_channel = 1; |
296 | { | 311 | break; |
297 | if (*iterator.this_arg < 127) | 312 | |
298 | ri->ri_noise = *iterator.this_arg; | 313 | case IEEE80211_RADIOTAP_RATE: |
299 | else | 314 | ri->ri_rate = (*iterator.this_arg) * 500000; |
300 | ri->ri_noise = *iterator.this_arg - 255; | 315 | break; |
301 | 316 | ||
302 | got_noise = 1; | 317 | case IEEE80211_RADIOTAP_FLAGS: |
303 | } | 318 | /* is the CRC visible at the end? |
304 | break; | 319 | * remove |
305 | 320 | */ | |
306 | case IEEE80211_RADIOTAP_ANTENNA: | 321 | if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) |
307 | ri->ri_antenna = *iterator.this_arg; | 322 | { |
308 | break; | 323 | fcs_removed = 1; |
309 | 324 | caplen -= 4; | |
310 | case IEEE80211_RADIOTAP_CHANNEL: | 325 | } |
311 | ri->ri_channel = *iterator.this_arg; | 326 | |
312 | got_channel = 1; | 327 | if (*iterator.this_arg & IEEE80211_RADIOTAP_F_RX_BADFCS) |
313 | break; | 328 | return (0); |
314 | 329 | ||
315 | case IEEE80211_RADIOTAP_RATE: | 330 | break; |
316 | ri->ri_rate = (*iterator.this_arg) * 500000; | ||
317 | break; | ||
318 | |||
319 | case IEEE80211_RADIOTAP_FLAGS: | ||
320 | /* is the CRC visible at the end? | ||
321 | * remove | ||
322 | */ | ||
323 | if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) | ||
324 | { | ||
325 | fcs_removed = 1; | ||
326 | caplen -= 4; | ||
327 | } | ||
328 | |||
329 | if (*iterator.this_arg & IEEE80211_RADIOTAP_F_RX_BADFCS) | ||
330 | return (0); | ||
331 | |||
332 | break; | ||
333 | } | ||
334 | } | ||
335 | n = le16_to_cpu(rthdr->it_len); | ||
336 | if (n <= 0 || n >= caplen) | ||
337 | return 0; | ||
338 | } | 331 | } |
339 | break; | ||
340 | case ARPHRD_IEEE80211: | ||
341 | /* do nothing? */ | ||
342 | break; | ||
343 | default: | ||
344 | errno = ENOTSUP; | ||
345 | return -1; | ||
346 | } | 332 | } |
333 | n = le16_to_cpu (rthdr->it_len); | ||
334 | if (n <= 0 || n >= caplen) | ||
335 | return 0; | ||
336 | } | ||
337 | break; | ||
338 | case ARPHRD_IEEE80211: | ||
339 | /* do nothing? */ | ||
340 | break; | ||
341 | default: | ||
342 | errno = ENOTSUP; | ||
343 | return -1; | ||
344 | } | ||
347 | 345 | ||
348 | caplen -= n; | 346 | caplen -= n; |
349 | 347 | ||
350 | //detect fcs at the end, even if the flag wasn't set and remove it | 348 | //detect fcs at the end, even if the flag wasn't set and remove it |
351 | if ( (0 == fcs_removed) && | 349 | if ((0 == fcs_removed) && (1 == check_crc_buf_osdep (tmpbuf + n, caplen - 4))) |
352 | (1 == check_crc_buf_osdep(tmpbuf + n, caplen - 4)) ) | 350 | { |
353 | { | 351 | caplen -= 4; |
354 | caplen -= 4; | 352 | } |
355 | } | 353 | memcpy (buf, tmpbuf + n, caplen); |
356 | memcpy(buf, tmpbuf + n, caplen); | 354 | if (!got_channel) |
357 | if (! got_channel) | 355 | ri->ri_channel = linux_get_channel (dev); |
358 | ri->ri_channel = linux_get_channel(dev); | ||
359 | 356 | ||
360 | return caplen; | 357 | return caplen; |
361 | } | 358 | } |
@@ -373,122 +370,108 @@ openraw (struct Hardware_Infos *dev) | |||
373 | struct sockaddr_ll sll; | 370 | struct sockaddr_ll sll; |
374 | 371 | ||
375 | /* find the interface index */ | 372 | /* find the interface index */ |
376 | memset(&ifr, 0, sizeof(ifr)); | 373 | memset (&ifr, 0, sizeof (ifr)); |
377 | strncpy(ifr.ifr_name, dev->iface, IFNAMSIZ); | 374 | strncpy (ifr.ifr_name, dev->iface, IFNAMSIZ); |
378 | if (-1 == ioctl(dev->fd_raw, SIOCGIFINDEX, &ifr)) | 375 | if (-1 == ioctl (dev->fd_raw, SIOCGIFINDEX, &ifr)) |
379 | { | 376 | { |
380 | fprintf (stderr, | 377 | fprintf (stderr, |
381 | "Line: 381 ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n", | 378 | "Line: 381 ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n", |
382 | IFNAMSIZ, | 379 | IFNAMSIZ, dev->iface, strerror (errno)); |
383 | dev->iface, | 380 | return 1; |
384 | strerror (errno)); | 381 | } |
385 | return 1; | ||
386 | } | ||
387 | 382 | ||
388 | /* lookup the hardware type */ | 383 | /* lookup the hardware type */ |
389 | memset (&sll, 0, sizeof(sll)); | 384 | memset (&sll, 0, sizeof (sll)); |
390 | sll.sll_family = AF_PACKET; | 385 | sll.sll_family = AF_PACKET; |
391 | sll.sll_ifindex = ifr.ifr_ifindex; | 386 | sll.sll_ifindex = ifr.ifr_ifindex; |
392 | sll.sll_protocol = htons(ETH_P_ALL); | 387 | sll.sll_protocol = htons (ETH_P_ALL); |
393 | if (-1 == ioctl(dev->fd_raw, SIOCGIFHWADDR, &ifr)) | 388 | if (-1 == ioctl (dev->fd_raw, SIOCGIFHWADDR, &ifr)) |
394 | { | 389 | { |
395 | fprintf (stderr, | 390 | fprintf (stderr, |
396 | "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n", | 391 | "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n", |
397 | IFNAMSIZ, | 392 | IFNAMSIZ, dev->iface, strerror (errno)); |
398 | dev->iface, | 393 | return 1; |
399 | strerror (errno)); | 394 | } |
400 | return 1; | ||
401 | } | ||
402 | 395 | ||
403 | /* lookup iw mode */ | 396 | /* lookup iw mode */ |
404 | memset(&wrq, 0, sizeof(struct iwreq)); | 397 | memset (&wrq, 0, sizeof (struct iwreq)); |
405 | strncpy(wrq.ifr_name, dev->iface, IFNAMSIZ); | 398 | strncpy (wrq.ifr_name, dev->iface, IFNAMSIZ); |
406 | if (-1 == ioctl(dev->fd_raw, SIOCGIWMODE, &wrq)) | 399 | if (-1 == ioctl (dev->fd_raw, SIOCGIWMODE, &wrq)) |
407 | { | 400 | { |
408 | /* most probably not supported (ie for rtap ipw interface) * | 401 | /* most probably not supported (ie for rtap ipw interface) * |
409 | * so just assume its correctly set... */ | 402 | * so just assume its correctly set... */ |
410 | wrq.u.mode = IW_MODE_MONITOR; | 403 | wrq.u.mode = IW_MODE_MONITOR; |
411 | } | 404 | } |
412 | 405 | ||
413 | if ( ( (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) && | 406 | if (((ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) && |
414 | (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) && | 407 | (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) && |
415 | (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL) ) || | 408 | (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL)) || |
416 | (wrq.u.mode != IW_MODE_MONITOR) ) | 409 | (wrq.u.mode != IW_MODE_MONITOR)) |
417 | { | 410 | { |
418 | fprintf (stderr, | 411 | fprintf (stderr, |
419 | "Error: interface `%.*s' is not in monitor mode\n", | 412 | "Error: interface `%.*s' is not in monitor mode\n", |
420 | IFNAMSIZ, | 413 | IFNAMSIZ, dev->iface); |
421 | dev->iface); | 414 | return 1; |
422 | return 1; | 415 | } |
423 | } | ||
424 | 416 | ||
425 | /* Is interface st to up, broadcast & running ? */ | 417 | /* Is interface st to up, broadcast & running ? */ |
426 | if ((ifr.ifr_flags | IFF_UP | IFF_BROADCAST | IFF_RUNNING) != ifr.ifr_flags) | 418 | if ((ifr.ifr_flags | IFF_UP | IFF_BROADCAST | IFF_RUNNING) != ifr.ifr_flags) |
427 | { | 419 | { |
428 | /* Bring interface up*/ | 420 | /* Bring interface up */ |
429 | ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING; | 421 | ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING; |
430 | 422 | ||
431 | if (-1 == ioctl(dev->fd_raw, SIOCSIFFLAGS, &ifr)) | 423 | if (-1 == ioctl (dev->fd_raw, SIOCSIFFLAGS, &ifr)) |
432 | { | ||
433 | fprintf (stderr, | ||
434 | "Line: 434 ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n", | ||
435 | IFNAMSIZ, | ||
436 | dev->iface, | ||
437 | strerror (errno)); | ||
438 | return 1; | ||
439 | } | ||
440 | } | ||
441 | |||
442 | /* bind the raw socket to the interface */ | ||
443 | if (-1 == bind(dev->fd_raw, (struct sockaddr *) &sll, sizeof(sll))) | ||
444 | { | 424 | { |
445 | fprintf (stderr, | 425 | fprintf (stderr, |
446 | "Failed to bind interface `%.*s': %s\n", | 426 | "Line: 434 ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n", |
447 | IFNAMSIZ, | 427 | IFNAMSIZ, dev->iface, strerror (errno)); |
448 | dev->iface, | ||
449 | strerror (errno)); | ||
450 | return 1; | 428 | return 1; |
451 | } | 429 | } |
430 | } | ||
431 | |||
432 | /* bind the raw socket to the interface */ | ||
433 | if (-1 == bind (dev->fd_raw, (struct sockaddr *) &sll, sizeof (sll))) | ||
434 | { | ||
435 | fprintf (stderr, | ||
436 | "Failed to bind interface `%.*s': %s\n", | ||
437 | IFNAMSIZ, dev->iface, strerror (errno)); | ||
438 | return 1; | ||
439 | } | ||
452 | 440 | ||
453 | /* lookup the hardware type */ | 441 | /* lookup the hardware type */ |
454 | if (-1 == ioctl(dev->fd_raw, SIOCGIFHWADDR, &ifr)) | 442 | if (-1 == ioctl (dev->fd_raw, SIOCGIFHWADDR, &ifr)) |
455 | { | 443 | { |
456 | fprintf (stderr, | 444 | fprintf (stderr, |
457 | "Line: 457 ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n", | 445 | "Line: 457 ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n", |
458 | IFNAMSIZ, | 446 | IFNAMSIZ, dev->iface, strerror (errno)); |
459 | dev->iface, | 447 | return 1; |
460 | strerror (errno)); | 448 | } |
461 | return 1; | ||
462 | } | ||
463 | 449 | ||
464 | memcpy (dev->pl_mac, | 450 | memcpy (dev->pl_mac, ifr.ifr_hwaddr.sa_data, MAC_ADDR_SIZE); |
465 | ifr.ifr_hwaddr.sa_data, | ||
466 | MAC_ADDR_SIZE); | ||
467 | dev->arptype_in = ifr.ifr_hwaddr.sa_family; | 451 | dev->arptype_in = ifr.ifr_hwaddr.sa_family; |
468 | if ( (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) && | 452 | if ((ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) && |
469 | (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) && | 453 | (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) && |
470 | (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL) ) | 454 | (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL)) |
471 | { | 455 | { |
472 | fprintf (stderr, | 456 | fprintf (stderr, |
473 | "Unsupported hardware link type %d on interface `%.*s'\n", | 457 | "Unsupported hardware link type %d on interface `%.*s'\n", |
474 | ifr.ifr_hwaddr.sa_family, | 458 | ifr.ifr_hwaddr.sa_family, IFNAMSIZ, dev->iface); |
475 | IFNAMSIZ, | 459 | return 1; |
476 | dev->iface); | 460 | } |
477 | return 1; | ||
478 | } | ||
479 | 461 | ||
480 | /* enable promiscuous mode */ | 462 | /* enable promiscuous mode */ |
481 | memset(&mr, 0, sizeof(mr)); | 463 | memset (&mr, 0, sizeof (mr)); |
482 | mr.mr_ifindex = sll.sll_ifindex; | 464 | mr.mr_ifindex = sll.sll_ifindex; |
483 | mr.mr_type = PACKET_MR_PROMISC; | 465 | mr.mr_type = PACKET_MR_PROMISC; |
484 | if (0 != setsockopt(dev->fd_raw, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mr, sizeof(mr))) | 466 | if (0 != |
485 | { | 467 | setsockopt (dev->fd_raw, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mr, |
486 | fprintf (stderr, | 468 | sizeof (mr))) |
487 | "Failed to enable promiscuous mode on interface `%.*s'\n", | 469 | { |
488 | IFNAMSIZ, | 470 | fprintf (stderr, |
489 | dev->iface); | 471 | "Failed to enable promiscuous mode on interface `%.*s'\n", |
490 | return 1; | 472 | IFNAMSIZ, dev->iface); |
491 | } | 473 | return 1; |
474 | } | ||
492 | 475 | ||
493 | return 0; | 476 | return 0; |
494 | } | 477 | } |
@@ -497,52 +480,43 @@ openraw (struct Hardware_Infos *dev) | |||
497 | * @return 0 on success | 480 | * @return 0 on success |
498 | */ | 481 | */ |
499 | static int | 482 | static int |
500 | wlaninit (struct Hardware_Infos *dev, | 483 | wlaninit (struct Hardware_Infos *dev, const char *iface) |
501 | const char *iface) | ||
502 | { | 484 | { |
503 | char strbuf[512]; | 485 | char strbuf[512]; |
504 | struct stat sbuf; | 486 | struct stat sbuf; |
505 | int ret; | 487 | int ret; |
506 | 488 | ||
507 | dev->fd_raw = socket (PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); | 489 | dev->fd_raw = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL)); |
508 | if (0 > dev->fd_raw) | 490 | if (0 > dev->fd_raw) |
509 | { | 491 | { |
510 | fprintf (stderr, | 492 | fprintf (stderr, "Failed to create raw socket: %s\n", strerror (errno)); |
511 | "Failed to create raw socket: %s\n", | 493 | return 1; |
512 | strerror (errno)); | 494 | } |
513 | return 1; | ||
514 | } | ||
515 | if (dev->fd_raw >= FD_SETSIZE) | 495 | if (dev->fd_raw >= FD_SETSIZE) |
516 | { | 496 | { |
517 | fprintf (stderr, | 497 | fprintf (stderr, |
518 | "File descriptor too large for select (%d > %d)\n", | 498 | "File descriptor too large for select (%d > %d)\n", |
519 | dev->fd_raw, | 499 | dev->fd_raw, FD_SETSIZE); |
520 | FD_SETSIZE); | 500 | close (dev->fd_raw); |
521 | close (dev->fd_raw); | 501 | return 1; |
522 | return 1; | 502 | } |
523 | } | ||
524 | 503 | ||
525 | /* mac80211 stack detection */ | 504 | /* mac80211 stack detection */ |
526 | ret = snprintf(strbuf, | 505 | ret = snprintf (strbuf, |
527 | sizeof(strbuf), | 506 | sizeof (strbuf), |
528 | "/sys/class/net/%s/phy80211/subsystem", | 507 | "/sys/class/net/%s/phy80211/subsystem", iface); |
529 | iface); | 508 | if ((ret < 0) || (ret >= sizeof (strbuf)) || (0 != stat (strbuf, &sbuf))) |
530 | if ( (ret < 0) || | 509 | { |
531 | (ret >= sizeof (strbuf)) || | 510 | fprintf (stderr, "Did not find 802.11 interface `%s'. Exiting.\n", iface); |
532 | (0 != stat(strbuf, &sbuf)) ) | 511 | close (dev->fd_raw); |
533 | { | 512 | return 1; |
534 | fprintf(stderr, | 513 | } |
535 | "Did not find 802.11 interface `%s'. Exiting.\n", | 514 | strncpy (dev->iface, iface, IFNAMSIZ); |
536 | iface); | 515 | if (0 != openraw (dev)) |
537 | close (dev->fd_raw); | 516 | { |
538 | return 1; | 517 | close (dev->fd_raw); |
539 | } | 518 | return 1; |
540 | strncpy(dev->iface, iface, IFNAMSIZ); | 519 | } |
541 | if (0 != openraw(dev)) | ||
542 | { | ||
543 | close(dev->fd_raw); | ||
544 | return 1; | ||
545 | } | ||
546 | return 0; | 520 | return 0; |
547 | } | 521 | } |
548 | 522 | ||
@@ -555,14 +529,14 @@ wlaninit (struct Hardware_Infos *dev, | |||
555 | * @return 0 if mac belongs to us, 1 if mac is for another target | 529 | * @return 0 if mac belongs to us, 1 if mac is for another target |
556 | */ | 530 | */ |
557 | static int | 531 | static int |
558 | mac_test (const struct ieee80211_frame *u8aIeeeHeader, | 532 | mac_test (const struct ieee80211_frame *u8aIeeeHeader, |
559 | const struct Hardware_Infos *dev) | 533 | const struct Hardware_Infos *dev) |
560 | { | 534 | { |
561 | if (0 != memcmp(u8aIeeeHeader->i_addr3, &mac_bssid, MAC_ADDR_SIZE)) | 535 | if (0 != memcmp (u8aIeeeHeader->i_addr3, &mac_bssid, MAC_ADDR_SIZE)) |
562 | return 1; | 536 | return 1; |
563 | if (0 == memcmp(u8aIeeeHeader->i_addr1, dev->pl_mac, MAC_ADDR_SIZE)) | 537 | if (0 == memcmp (u8aIeeeHeader->i_addr1, dev->pl_mac, MAC_ADDR_SIZE)) |
564 | return 0; | 538 | return 0; |
565 | if (0 == memcmp(u8aIeeeHeader->i_addr1, &bc_all_mac, MAC_ADDR_SIZE)) | 539 | if (0 == memcmp (u8aIeeeHeader->i_addr1, &bc_all_mac, MAC_ADDR_SIZE)) |
566 | return 0; | 540 | return 0; |
567 | return 1; | 541 | return 1; |
568 | } | 542 | } |
@@ -574,17 +548,13 @@ mac_test (const struct ieee80211_frame *u8aIeeeHeader, | |||
574 | * @param dev pointer to the Hardware_Infos struct | 548 | * @param dev pointer to the Hardware_Infos struct |
575 | */ | 549 | */ |
576 | static void | 550 | static void |
577 | mac_set (struct ieee80211_frame *u8aIeeeHeader, | 551 | mac_set (struct ieee80211_frame *u8aIeeeHeader, |
578 | const struct Hardware_Infos * dev) | 552 | const struct Hardware_Infos *dev) |
579 | { | 553 | { |
580 | u8aIeeeHeader->i_fc[0] = 0x08; | 554 | u8aIeeeHeader->i_fc[0] = 0x08; |
581 | u8aIeeeHeader->i_fc[1] = 0x00; | 555 | u8aIeeeHeader->i_fc[1] = 0x00; |
582 | memcpy(u8aIeeeHeader->i_addr2, | 556 | memcpy (u8aIeeeHeader->i_addr2, dev->pl_mac, MAC_ADDR_SIZE); |
583 | dev->pl_mac, | 557 | memcpy (u8aIeeeHeader->i_addr3, &mac_bssid, MAC_ADDR_SIZE); |
584 | MAC_ADDR_SIZE); | ||
585 | memcpy(u8aIeeeHeader->i_addr3, | ||
586 | &mac_bssid, | ||
587 | MAC_ADDR_SIZE); | ||
588 | 558 | ||
589 | } | 559 | } |
590 | 560 | ||
@@ -597,138 +567,140 @@ struct RadioTapheader | |||
597 | }; | 567 | }; |
598 | 568 | ||
599 | static void | 569 | static void |
600 | stdin_send_hw (void *cls, | 570 | stdin_send_hw (void *cls, void *client, const struct GNUNET_MessageHeader *hdr) |
601 | void *client, | ||
602 | const struct GNUNET_MessageHeader *hdr) | ||
603 | { | 571 | { |
604 | struct Hardware_Infos * dev = cls; | 572 | struct Hardware_Infos *dev = cls; |
605 | struct sendbuf *write_pout = &dev->write_pout; | 573 | struct sendbuf *write_pout = &dev->write_pout; |
606 | struct Radiotap_Send * header = (struct Radiotap_Send *) &hdr[1]; | 574 | struct Radiotap_Send *header = (struct Radiotap_Send *) &hdr[1]; |
607 | struct ieee80211_frame * wlanheader; | 575 | struct ieee80211_frame *wlanheader; |
608 | size_t sendsize; | 576 | size_t sendsize; |
609 | 577 | ||
610 | // struct? // FIXME: make nice... | 578 | // struct? // FIXME: make nice... |
611 | struct RadioTapheader rtheader; | 579 | struct RadioTapheader rtheader; |
580 | |||
612 | rtheader.header.it_version = 0; | 581 | rtheader.header.it_version = 0; |
613 | rtheader.header.it_len = htole16(0x0c); | 582 | rtheader.header.it_len = htole16 (0x0c); |
614 | rtheader.header.it_present = htole32(0x00008004); | 583 | rtheader.header.it_present = htole32 (0x00008004); |
615 | rtheader.rate = 0x00; | 584 | rtheader.rate = 0x00; |
616 | rtheader.txflags = htole16(IEEE80211_RADIOTAP_F_TX_NOACK | IEEE80211_RADIOTAP_F_TX_NOSEQ); | 585 | rtheader.txflags = |
586 | htole16 (IEEE80211_RADIOTAP_F_TX_NOACK | IEEE80211_RADIOTAP_F_TX_NOSEQ); | ||
617 | 587 | ||
618 | /* { 0x00, 0x00, <-- radiotap version | 588 | /* { 0x00, 0x00, <-- radiotap version |
619 | 0x0c, 0x00, <- radiotap header length | 589 | * 0x0c, 0x00, <- radiotap header length |
620 | 0x04, 0x80, 0x00, 0x00, <-- bitmap | 590 | * 0x04, 0x80, 0x00, 0x00, <-- bitmap |
621 | 0x00, <-- rate | 591 | * 0x00, <-- rate |
622 | 0x00, <-- padding for natural alignment | 592 | * 0x00, <-- padding for natural alignment |
623 | 0x18, 0x00, <-- TX flags | 593 | * 0x18, 0x00, <-- TX flags |
624 | };*/ | 594 | * }; */ |
625 | 595 | ||
626 | sendsize = ntohs(hdr->size); | 596 | sendsize = ntohs (hdr->size); |
627 | if (sendsize < sizeof(struct Radiotap_Send) + sizeof(struct GNUNET_MessageHeader)) | 597 | if (sendsize < |
628 | { | 598 | sizeof (struct Radiotap_Send) + sizeof (struct GNUNET_MessageHeader)) |
629 | fprintf(stderr, | 599 | { |
630 | "Function stdin_send_hw: mailformed packet (too small)\n"); | 600 | fprintf (stderr, "Function stdin_send_hw: mailformed packet (too small)\n"); |
631 | exit (1); | 601 | exit (1); |
632 | } | 602 | } |
633 | sendsize -= sizeof(struct Radiotap_Send) + sizeof(struct GNUNET_MessageHeader); | 603 | sendsize -= |
604 | sizeof (struct Radiotap_Send) + sizeof (struct GNUNET_MessageHeader); | ||
634 | 605 | ||
635 | if (MAXLINE < sendsize) | 606 | if (MAXLINE < sendsize) |
636 | { | 607 | { |
637 | fprintf(stderr, | 608 | fprintf (stderr, "Function stdin_send_hw: Packet too big for buffer\n"); |
638 | "Function stdin_send_hw: Packet too big for buffer\n"); | 609 | exit (1); |
639 | exit(1); | 610 | } |
640 | } | 611 | if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs (hdr->type)) |
641 | if (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA != ntohs(hdr->type)) | 612 | { |
642 | { | 613 | fprintf (stderr, "Function stdin_send: wrong packet type\n"); |
643 | fprintf(stderr, "Function stdin_send: wrong packet type\n"); | 614 | exit (1); |
644 | exit(1); | 615 | } |
645 | } | 616 | |
646 | 617 | rtheader.header.it_len = htole16 (sizeof (rtheader)); | |
647 | rtheader.header.it_len = htole16(sizeof(rtheader)); | ||
648 | rtheader.rate = header->rate; | 618 | rtheader.rate = header->rate; |
649 | memcpy(write_pout->buf, &rtheader, sizeof(rtheader)); | 619 | memcpy (write_pout->buf, &rtheader, sizeof (rtheader)); |
650 | memcpy(write_pout->buf + sizeof(rtheader), &header[1], sendsize); | 620 | memcpy (write_pout->buf + sizeof (rtheader), &header[1], sendsize); |
651 | /* payload contains MAC address, but we don't trust it, so we'll | 621 | /* payload contains MAC address, but we don't trust it, so we'll |
652 | overwrite it with OUR MAC address again to prevent mischief */ | 622 | * overwrite it with OUR MAC address again to prevent mischief */ |
653 | wlanheader = (struct ieee80211_frame *) (write_pout->buf + sizeof(rtheader)); | 623 | wlanheader = (struct ieee80211_frame *) (write_pout->buf + sizeof (rtheader)); |
654 | mac_set(wlanheader, dev); | 624 | mac_set (wlanheader, dev); |
655 | write_pout->size = sendsize + sizeof(rtheader); | 625 | write_pout->size = sendsize + sizeof (rtheader); |
656 | } | 626 | } |
657 | 627 | ||
658 | #if 0 | 628 | #if 0 |
659 | static int | 629 | static int |
660 | maketest(unsigned char * buf, struct Hardware_Infos * dev) | 630 | maketest (unsigned char *buf, struct Hardware_Infos *dev) |
661 | { | 631 | { |
662 | uint16_t * tmp16; | 632 | uint16_t *tmp16; |
663 | static uint16_t seqenz = 0; | 633 | static uint16_t seqenz = 0; |
664 | static int first = 0; | 634 | static int first = 0; |
665 | 635 | ||
666 | const int rate = 11000000; | 636 | const int rate = 11000000; |
667 | static const char | 637 | static const char |
668 | txt[] = | 638 | txt[] = |
669 | "Hallo1Hallo2 Hallo3 Hallo4...998877665544332211Hallo1Hallo2 Hallo3 Hallo4...998877665544332211"; | 639 | "Hallo1Hallo2 Hallo3 Hallo4...998877665544332211Hallo1Hallo2 Hallo3 Hallo4...998877665544332211"; |
670 | 640 | ||
671 | unsigned char u8aRadiotap[] = | 641 | unsigned char u8aRadiotap[] = { 0x00, 0x00, // <-- radiotap version |
672 | { 0x00, 0x00, // <-- radiotap version | 642 | 0x00, 0x00, // <- radiotap header length |
673 | 0x00, 0x00, // <- radiotap header length | 643 | 0x04, 0x80, 0x02, 0x00, // <-- bitmap |
674 | 0x04, 0x80, 0x02, 0x00, // <-- bitmap | 644 | 0x00, // <-- rate |
675 | 0x00, // <-- rate | 645 | 0x00, // <-- padding for natural alignment |
676 | 0x00, // <-- padding for natural alignment | 646 | 0x10, 0x00, // <-- TX flags |
677 | 0x10, 0x00, // <-- TX flags | 647 | 0x04 //retries |
678 | 0x04 //retries | 648 | }; |
679 | }; | ||
680 | 649 | ||
681 | /*uint8_t u8aRadiotap[] = | 650 | /*uint8_t u8aRadiotap[] = |
682 | { | 651 | * { |
683 | 0x00, 0x00, // <-- radiotap version | 652 | * 0x00, 0x00, // <-- radiotap version |
684 | 0x19, 0x00, // <- radiotap header length | 653 | * 0x19, 0x00, // <- radiotap header length |
685 | 0x6f, 0x08, 0x00, 0x00, // <-- bitmap | 654 | * 0x6f, 0x08, 0x00, 0x00, // <-- bitmap |
686 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // <-- timestamp | 655 | * 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // <-- timestamp |
687 | 0x00, // <-- flags (Offset +0x10) | 656 | * 0x00, // <-- flags (Offset +0x10) |
688 | 0x6c, // <-- rate (0ffset +0x11) | 657 | * 0x6c, // <-- rate (0ffset +0x11) |
689 | 0x71, 0x09, 0xc0, 0x00, // <-- channel | 658 | * 0x71, 0x09, 0xc0, 0x00, // <-- channel |
690 | 0xde, // <-- antsignal | 659 | * 0xde, // <-- antsignal |
691 | 0x00, // <-- antnoise | 660 | * 0x00, // <-- antnoise |
692 | 0x01, // <-- antenna | 661 | * 0x01, // <-- antenna |
693 | };*/ | 662 | * }; */ |
694 | 663 | ||
695 | u8aRadiotap[8] = (rate / 500000); | 664 | u8aRadiotap[8] = (rate / 500000); |
696 | u8aRadiotap[2] = htole16(sizeof(u8aRadiotap)); | 665 | u8aRadiotap[2] = htole16 (sizeof (u8aRadiotap)); |
697 | 666 | ||
698 | static struct ieee80211_frame u8aIeeeHeader; | 667 | static struct ieee80211_frame u8aIeeeHeader; |
699 | 668 | ||
700 | uint8_t u8aIeeeHeader_def[] = | 669 | uint8_t u8aIeeeHeader_def[] = { 0x08, 0x00, // Frame Control 0x08= 00001000 -> | b1,2 = 0 -> Version 0; |
701 | { 0x08, 0x00, // Frame Control 0x08= 00001000 -> | b1,2 = 0 -> Version 0; | 670 | // b3,4 = 10 -> Data; b5-8 = 0 -> Normal Data |
702 | // b3,4 = 10 -> Data; b5-8 = 0 -> Normal Data | 671 | // 0x01 = 00000001 -> | b1 = 1 to DS; b2 = 0 not from DS; |
703 | // 0x01 = 00000001 -> | b1 = 1 to DS; b2 = 0 not from DS; | 672 | 0x00, 0x00, // Duration/ID |
704 | 0x00, 0x00, // Duration/ID | 673 | |
705 | 674 | //0x00, 0x1f, 0x3f, 0xd1, 0x8e, 0xe6, // mac1 - in this case receiver | |
706 | //0x00, 0x1f, 0x3f, 0xd1, 0x8e, 0xe6, // mac1 - in this case receiver | 675 | 0x00, 0x1d, 0xe0, 0xb0, 0x17, 0xdf, // mac1 - in this case receiver |
707 | 0x00, 0x1d, 0xe0, 0xb0, 0x17, 0xdf, // mac1 - in this case receiver | 676 | 0xC0, 0x3F, 0x0E, 0x44, 0x2D, 0x51, // mac2 - in this case sender |
708 | 0xC0, 0x3F, 0x0E, 0x44, 0x2D, 0x51, // mac2 - in this case sender | 677 | //0x02, 0x1d, 0xe0, 0x00, 0x01, 0xc4, |
709 | //0x02, 0x1d, 0xe0, 0x00, 0x01, 0xc4, | 678 | 0x13, 0x22, 0x33, 0x44, 0x55, 0x66, // mac3 - in this case bssid |
710 | 0x13, 0x22, 0x33, 0x44, 0x55, 0x66, // mac3 - in this case bssid | 679 | 0x10, 0x86, //Sequence Control |
711 | 0x10, 0x86, //Sequence Control | 680 | }; |
712 | }; | ||
713 | if (0 == first) | 681 | if (0 == first) |
714 | { | 682 | { |
715 | memcpy(&u8aIeeeHeader, u8aIeeeHeader_def, sizeof(struct ieee80211_frame)); | 683 | memcpy (&u8aIeeeHeader, u8aIeeeHeader_def, sizeof (struct ieee80211_frame)); |
716 | memcpy(u8aIeeeHeader.i_addr2, dev->pl_mac, MAC_ADDR_SIZE); | 684 | memcpy (u8aIeeeHeader.i_addr2, dev->pl_mac, MAC_ADDR_SIZE); |
717 | first = 1; | 685 | first = 1; |
718 | } | 686 | } |
719 | 687 | ||
720 | tmp16 = (uint16_t*) u8aIeeeHeader.i_dur; | 688 | tmp16 = (uint16_t *) u8aIeeeHeader.i_dur; |
721 | *tmp16 | 689 | *tmp16 |
722 | = (uint16_t) htole16((sizeof(txt) + sizeof(struct ieee80211_frame) * 1000000) / rate + 290); | 690 | = |
723 | tmp16 = (uint16_t*) u8aIeeeHeader.i_seq; | 691 | (uint16_t) |
724 | *tmp16 = (*tmp16 & IEEE80211_SEQ_FRAG_MASK) | (htole16(seqenz) | 692 | htole16 ((sizeof (txt) + |
725 | << IEEE80211_SEQ_SEQ_SHIFT); | 693 | sizeof (struct ieee80211_frame) * 1000000) / rate + 290); |
694 | tmp16 = (uint16_t *) u8aIeeeHeader.i_seq; | ||
695 | *tmp16 = (*tmp16 & IEEE80211_SEQ_FRAG_MASK) | (htole16 (seqenz) | ||
696 | << IEEE80211_SEQ_SEQ_SHIFT); | ||
726 | seqenz++; | 697 | seqenz++; |
727 | 698 | ||
728 | memcpy(buf, u8aRadiotap, sizeof(u8aRadiotap)); | 699 | memcpy (buf, u8aRadiotap, sizeof (u8aRadiotap)); |
729 | memcpy(buf + sizeof(u8aRadiotap), &u8aIeeeHeader, sizeof(u8aIeeeHeader)); | 700 | memcpy (buf + sizeof (u8aRadiotap), &u8aIeeeHeader, sizeof (u8aIeeeHeader)); |
730 | memcpy(buf + sizeof(u8aRadiotap) + sizeof(u8aIeeeHeader), txt, sizeof(txt)); | 701 | memcpy (buf + sizeof (u8aRadiotap) + sizeof (u8aIeeeHeader), txt, |
731 | return sizeof(u8aRadiotap) + sizeof(u8aIeeeHeader) + sizeof(txt); | 702 | sizeof (txt)); |
703 | return sizeof (u8aRadiotap) + sizeof (u8aIeeeHeader) + sizeof (txt); | ||
732 | 704 | ||
733 | } | 705 | } |
734 | #endif | 706 | #endif |
@@ -742,21 +714,20 @@ maketest(unsigned char * buf, struct Hardware_Infos * dev) | |||
742 | */ | 714 | */ |
743 | // FIXME: use 'struct MacAddress' for 'mac' (everywhere in this file) | 715 | // FIXME: use 'struct MacAddress' for 'mac' (everywhere in this file) |
744 | static int | 716 | static int |
745 | send_mac_to_plugin(char * buffer, uint8_t * mac) | 717 | send_mac_to_plugin (char *buffer, uint8_t * mac) |
746 | { | 718 | { |
747 | struct Wlan_Helper_Control_Message macmsg; | 719 | struct Wlan_Helper_Control_Message macmsg; |
748 | 720 | ||
749 | macmsg.hdr.size = htons(sizeof(struct Wlan_Helper_Control_Message)); | 721 | macmsg.hdr.size = htons (sizeof (struct Wlan_Helper_Control_Message)); |
750 | macmsg.hdr.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); | 722 | macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); |
751 | memcpy(macmsg.mac.mac, mac, sizeof(struct MacAddress)); | 723 | memcpy (macmsg.mac.mac, mac, sizeof (struct MacAddress)); |
752 | memcpy(buffer, &macmsg, sizeof(struct Wlan_Helper_Control_Message)); | 724 | memcpy (buffer, &macmsg, sizeof (struct Wlan_Helper_Control_Message)); |
753 | return sizeof(struct Wlan_Helper_Control_Message); | 725 | return sizeof (struct Wlan_Helper_Control_Message); |
754 | } | 726 | } |
755 | 727 | ||
756 | 728 | ||
757 | static int | 729 | static int |
758 | hardwaremode (int argc, | 730 | hardwaremode (int argc, char *argv[]) |
759 | char *argv[]) | ||
760 | { | 731 | { |
761 | uid_t uid; | 732 | uid_t uid; |
762 | struct Hardware_Infos dev; | 733 | struct Hardware_Infos dev; |
@@ -768,18 +739,16 @@ hardwaremode (int argc, | |||
768 | fd_set wfds; | 739 | fd_set wfds; |
769 | int retval; | 740 | int retval; |
770 | int stdin_open; | 741 | int stdin_open; |
771 | struct GNUNET_SERVER_MessageStreamTokenizer * stdin_mst; | 742 | struct GNUNET_SERVER_MessageStreamTokenizer *stdin_mst; |
772 | 743 | ||
773 | if (0 != wlaninit(&dev, argv[1])) | 744 | if (0 != wlaninit (&dev, argv[1])) |
774 | return 1; | 745 | return 1; |
775 | uid = getuid(); | 746 | uid = getuid (); |
776 | if (0 != setresuid(uid, uid, uid)) | 747 | if (0 != setresuid (uid, uid, uid)) |
777 | { | 748 | { |
778 | fprintf(stderr, | 749 | fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno)); |
779 | "Failed to setresuid: %s\n", | 750 | /* not critical, continue anyway */ |
780 | strerror(errno)); | 751 | } |
781 | /* not critical, continue anyway */ | ||
782 | } | ||
783 | 752 | ||
784 | dev.write_pout.size = 0; | 753 | dev.write_pout.size = 0; |
785 | dev.write_pout.pos = 0; | 754 | dev.write_pout.pos = 0; |
@@ -787,162 +756,148 @@ hardwaremode (int argc, | |||
787 | 756 | ||
788 | /* send mac to STDOUT first */ | 757 | /* send mac to STDOUT first */ |
789 | write_std.pos = 0; | 758 | write_std.pos = 0; |
790 | write_std.size = send_mac_to_plugin((char *) &write_std.buf, dev.pl_mac); | 759 | write_std.size = send_mac_to_plugin ((char *) &write_std.buf, dev.pl_mac); |
791 | stdin_open = 1; | 760 | stdin_open = 1; |
792 | 761 | ||
793 | while (1) | 762 | while (1) |
763 | { | ||
764 | maxfd = -1; | ||
765 | FD_ZERO (&rfds); | ||
766 | if ((0 == dev.write_pout.size) && (1 == stdin_open)) | ||
794 | { | 767 | { |
795 | maxfd = -1; | 768 | FD_SET (STDIN_FILENO, &rfds); |
796 | FD_ZERO (&rfds); | 769 | maxfd = MAX (maxfd, STDIN_FILENO); |
797 | if ( (0 == dev.write_pout.size) && | 770 | } |
798 | (1 == stdin_open) ) | 771 | if (0 == write_std.size) |
799 | { | 772 | { |
800 | FD_SET (STDIN_FILENO, &rfds); | 773 | FD_SET (dev.fd_raw, &rfds); |
801 | maxfd = MAX (maxfd, STDIN_FILENO); | 774 | maxfd = MAX (maxfd, dev.fd_raw); |
802 | } | 775 | } |
803 | if (0 == write_std.size) | 776 | FD_ZERO (&wfds); |
804 | { | 777 | if (0 < write_std.size) |
805 | FD_SET (dev.fd_raw, &rfds); | 778 | { |
806 | maxfd = MAX(maxfd, dev.fd_raw); | 779 | FD_SET (STDOUT_FILENO, &wfds); |
807 | } | 780 | maxfd = MAX (maxfd, STDOUT_FILENO); |
808 | FD_ZERO(&wfds); | 781 | } |
809 | if (0 < write_std.size) | 782 | if (0 < dev.write_pout.size) |
810 | { | 783 | { |
811 | FD_SET (STDOUT_FILENO, &wfds); | 784 | FD_SET (dev.fd_raw, &wfds); |
812 | maxfd = MAX(maxfd, STDOUT_FILENO); | 785 | maxfd = MAX (maxfd, dev.fd_raw); |
813 | } | 786 | } |
814 | if (0 < dev.write_pout.size) | 787 | retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL); |
815 | { | 788 | if ((-1 == retval) && (EINTR == errno)) |
816 | FD_SET(dev.fd_raw, &wfds); | 789 | continue; |
817 | maxfd = MAX(maxfd, dev.fd_raw); | 790 | if (0 > retval) |
818 | } | 791 | { |
819 | retval = select(maxfd + 1, &rfds, &wfds, NULL, NULL); | 792 | fprintf (stderr, "select failed: %s\n", strerror (errno)); |
820 | if ( (-1 == retval) && | 793 | break; |
821 | (EINTR == errno) ) | 794 | } |
822 | continue; | ||
823 | if (0 > retval) | ||
824 | { | ||
825 | fprintf(stderr, | ||
826 | "select failed: %s\n", | ||
827 | strerror(errno)); | ||
828 | break; | ||
829 | } | ||
830 | 795 | ||
831 | if (FD_ISSET(STDOUT_FILENO, &wfds)) | 796 | if (FD_ISSET (STDOUT_FILENO, &wfds)) |
832 | { | 797 | { |
833 | ret = write(STDOUT_FILENO, | 798 | ret = write (STDOUT_FILENO, |
834 | write_std.buf + write_std.pos, | 799 | write_std.buf + write_std.pos, |
835 | write_std.size - write_std.pos); | 800 | write_std.size - write_std.pos); |
836 | if (0 > ret) | 801 | if (0 > ret) |
837 | { | 802 | { |
838 | fprintf (stderr, | 803 | fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno)); |
839 | "Failed to write to STDOUT: %s\n", | 804 | break; |
840 | strerror (errno)); | 805 | } |
841 | break; | 806 | write_std.pos += ret; |
842 | } | 807 | if (write_std.pos == write_std.size) |
843 | write_std.pos += ret; | 808 | { |
844 | if (write_std.pos == write_std.size) | 809 | write_std.pos = 0; |
845 | { | 810 | write_std.size = 0; |
846 | write_std.pos = 0; | 811 | } |
847 | write_std.size = 0; | 812 | } |
848 | } | ||
849 | } | ||
850 | |||
851 | if (FD_ISSET(dev.fd_raw, &wfds)) | ||
852 | { | ||
853 | ret = write (dev.fd_raw, | ||
854 | dev.write_pout.buf, | ||
855 | dev.write_pout.size); | ||
856 | if (0 > ret) | ||
857 | { | ||
858 | fprintf (stderr, | ||
859 | "Line %u: Failed to write to WLAN device: %s, Message-Size: %u\n",__LINE__, | ||
860 | strerror (errno), dev.write_pout.size); | ||
861 | break; | ||
862 | } | ||
863 | dev.write_pout.pos += ret; | ||
864 | if ( (dev.write_pout.pos != dev.write_pout.size) && | ||
865 | (ret != 0) ) | ||
866 | { | ||
867 | fprintf(stderr, | ||
868 | "Line %u: Write error, partial send: %u/%u\n",__LINE__, | ||
869 | dev.write_pout.pos, dev.write_pout.size); | ||
870 | break; | ||
871 | } | ||
872 | if (dev.write_pout.pos == dev.write_pout.size) | ||
873 | { | ||
874 | dev.write_pout.pos = 0; | ||
875 | dev.write_pout.size = 0; | ||
876 | } | ||
877 | } | ||
878 | 813 | ||
879 | if (FD_ISSET(STDIN_FILENO, &rfds)) | 814 | if (FD_ISSET (dev.fd_raw, &wfds)) |
880 | { | 815 | { |
881 | ret = read(STDIN_FILENO, readbuf, sizeof(readbuf)); | 816 | ret = write (dev.fd_raw, dev.write_pout.buf, dev.write_pout.size); |
882 | if (0 > ret) | 817 | if (0 > ret) |
883 | { | 818 | { |
884 | fprintf(stderr, | 819 | fprintf (stderr, |
885 | "Read error from STDIN: %s\n", | 820 | "Line %u: Failed to write to WLAN device: %s, Message-Size: %u\n", |
886 | strerror (errno)); | 821 | __LINE__, strerror (errno), dev.write_pout.size); |
887 | break; | 822 | break; |
888 | } | 823 | } |
889 | if (0 == ret) | 824 | dev.write_pout.pos += ret; |
890 | { | 825 | if ((dev.write_pout.pos != dev.write_pout.size) && (ret != 0)) |
891 | /* stop reading... */ | 826 | { |
892 | stdin_open = 0; | 827 | fprintf (stderr, |
893 | } | 828 | "Line %u: Write error, partial send: %u/%u\n", __LINE__, |
894 | GNUNET_SERVER_mst_receive (stdin_mst, NULL, | 829 | dev.write_pout.pos, dev.write_pout.size); |
895 | readbuf, ret, | 830 | break; |
896 | GNUNET_NO, GNUNET_NO); | 831 | } |
897 | } | 832 | if (dev.write_pout.pos == dev.write_pout.size) |
833 | { | ||
834 | dev.write_pout.pos = 0; | ||
835 | dev.write_pout.size = 0; | ||
836 | } | ||
837 | } | ||
898 | 838 | ||
899 | if (FD_ISSET(dev.fd_raw, &rfds)) | 839 | if (FD_ISSET (STDIN_FILENO, &rfds)) |
900 | { | 840 | { |
901 | struct GNUNET_MessageHeader * header; | 841 | ret = read (STDIN_FILENO, readbuf, sizeof (readbuf)); |
902 | struct Radiotap_rx * rxinfo; | 842 | if (0 > ret) |
903 | struct ieee80211_frame * datastart; | 843 | { |
904 | 844 | fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno)); | |
905 | header = (struct GNUNET_MessageHeader *) write_std.buf; | 845 | break; |
906 | rxinfo = (struct Radiotap_rx *) &header[1]; | 846 | } |
907 | datastart = (struct ieee80211_frame *) &rxinfo[1]; | 847 | if (0 == ret) |
908 | ret = linux_read (&dev, | 848 | { |
909 | (unsigned char *) datastart, | 849 | /* stop reading... */ |
910 | sizeof(write_std.buf) - sizeof(struct Radiotap_rx) - sizeof(struct GNUNET_MessageHeader), | 850 | stdin_open = 0; |
911 | rxinfo); | 851 | } |
912 | if (0 > ret) | 852 | GNUNET_SERVER_mst_receive (stdin_mst, NULL, |
913 | { | 853 | readbuf, ret, GNUNET_NO, GNUNET_NO); |
914 | fprintf(stderr, | 854 | } |
915 | "Read error from raw socket: %s\n", | ||
916 | strerror(errno)); | ||
917 | break; | ||
918 | } | ||
919 | if ( (0 < ret) && | ||
920 | (0 == mac_test(datastart, &dev)) ) | ||
921 | { | ||
922 | write_std.size = ret + sizeof(struct GNUNET_MessageHeader) + sizeof(struct Radiotap_rx); | ||
923 | header->size = htons(write_std.size); | ||
924 | header->type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); | ||
925 | } | ||
926 | } | ||
927 | 855 | ||
856 | if (FD_ISSET (dev.fd_raw, &rfds)) | ||
857 | { | ||
858 | struct GNUNET_MessageHeader *header; | ||
859 | struct Radiotap_rx *rxinfo; | ||
860 | struct ieee80211_frame *datastart; | ||
861 | |||
862 | header = (struct GNUNET_MessageHeader *) write_std.buf; | ||
863 | rxinfo = (struct Radiotap_rx *) &header[1]; | ||
864 | datastart = (struct ieee80211_frame *) &rxinfo[1]; | ||
865 | ret = linux_read (&dev, | ||
866 | (unsigned char *) datastart, | ||
867 | sizeof (write_std.buf) - sizeof (struct Radiotap_rx) - | ||
868 | sizeof (struct GNUNET_MessageHeader), rxinfo); | ||
869 | if (0 > ret) | ||
870 | { | ||
871 | fprintf (stderr, "Read error from raw socket: %s\n", strerror (errno)); | ||
872 | break; | ||
873 | } | ||
874 | if ((0 < ret) && (0 == mac_test (datastart, &dev))) | ||
875 | { | ||
876 | write_std.size = | ||
877 | ret + sizeof (struct GNUNET_MessageHeader) + | ||
878 | sizeof (struct Radiotap_rx); | ||
879 | header->size = htons (write_std.size); | ||
880 | header->type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_DATA); | ||
881 | } | ||
928 | } | 882 | } |
883 | |||
884 | } | ||
929 | /* Error handling, try to clean up a bit at least */ | 885 | /* Error handling, try to clean up a bit at least */ |
930 | GNUNET_SERVER_mst_destroy(stdin_mst); | 886 | GNUNET_SERVER_mst_destroy (stdin_mst); |
931 | close (dev.fd_raw); | 887 | close (dev.fd_raw); |
932 | return 1; | 888 | return 1; |
933 | } | 889 | } |
934 | 890 | ||
935 | int | 891 | int |
936 | main(int argc, char *argv[]) | 892 | main (int argc, char *argv[]) |
937 | { | 893 | { |
938 | if (2 != argc) | 894 | if (2 != argc) |
939 | { | 895 | { |
940 | fprintf (stderr, | 896 | fprintf (stderr, |
941 | "This program must be started with the interface as argument.\nThis program was compiled at ----- %s ----\n", __TIMESTAMP__ ); | 897 | "This program must be started with the interface as argument.\nThis program was compiled at ----- %s ----\n", |
942 | fprintf (stderr, | 898 | __TIMESTAMP__); |
943 | "Usage: interface-name\n" | 899 | fprintf (stderr, "Usage: interface-name\n" "\n"); |
944 | "\n"); | 900 | return 1; |
945 | return 1; | 901 | } |
946 | } | 902 | return hardwaremode (argc, argv); |
947 | return hardwaremode(argc , argv); | ||
948 | } | 903 | } |