aboutsummaryrefslogtreecommitdiff
path: root/src/transport/gnunet-transport-wlan-helper.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/transport/gnunet-transport-wlan-helper.c')
-rw-r--r--src/transport/gnunet-transport-wlan-helper.c1103
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?
111int getChannelFromFrequency(int frequency); 111int getChannelFromFrequency (int frequency);
112 112
113// FIXME: make nice... 113// FIXME: make nice...
114static unsigned long 114static unsigned long
115calc_crc_osdep(unsigned char * buf, int len) 115calc_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...
128static int 128static int
129check_crc_buf_osdep(unsigned char *buf, int len) 129check_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...
144static int 146static int
145linux_get_channel(struct Hardware_Infos *dev) 147linux_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...
175static ssize_t 177static ssize_t
176linux_read (struct Hardware_Infos *dev, 178linux_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 */
499static int 482static int
500wlaninit (struct Hardware_Infos *dev, 483wlaninit (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 */
557static int 531static int
558mac_test (const struct ieee80211_frame *u8aIeeeHeader, 532mac_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 */
576static void 550static void
577mac_set (struct ieee80211_frame *u8aIeeeHeader, 551mac_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
599static void 569static void
600stdin_send_hw (void *cls, 570stdin_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
659static int 629static int
660maketest(unsigned char * buf, struct Hardware_Infos * dev) 630maketest (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)
744static int 716static int
745send_mac_to_plugin(char * buffer, uint8_t * mac) 717send_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
757static int 729static int
758hardwaremode (int argc, 730hardwaremode (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
935int 891int
936main(int argc, char *argv[]) 892main (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}