GNUnet  0.11.x
plugin_transport_wlan.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2010-2014 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
30 #include "platform.h"
31 #include "gnunet_util_lib.h"
32 #include "gnunet_hello_lib.h"
33 #include "gnunet_protocols.h"
37 #include "plugin_transport_wlan.h"
39 #include "gnunet_constants.h"
40 
41 
42 #if BUILD_WLAN
43 /* begin case wlan */
44 #define PLUGIN_NAME "wlan"
45 #define CONFIG_NAME "transport-wlan"
46 #define HELPER_NAME "gnunet-helper-transport-wlan"
47 #define DUMMY_HELPER_NAME "gnunet-helper-transport-wlan-dummy"
48 #define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_wlan_init
49 #define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_wlan_done
50 #define LOG(kind, ...) GNUNET_log_from (kind, "transport-wlan", __VA_ARGS__)
51 
52 
56 #define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply ( \
57  GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2)
58 
64 #define HELLO_BEACON_SCALING_FACTOR GNUNET_TIME_relative_multiply ( \
65  GNUNET_TIME_UNIT_SECONDS, 2)
66 
67 
68 /* end case wlan */
69 #elif BUILD_BLUETOOTH
70 /* begin case bluetooth */
71 
72 #define PLUGIN_NAME "bluetooth"
73 #define CONFIG_NAME "transport-bluetooth"
74 #define HELPER_NAME "gnunet-helper-transport-bluetooth"
75 /* yes, this is correct, we use the same dummy driver as 'wlan' */
76 #define DUMMY_HELPER_NAME "gnunet-helper-transport-wlan-dummy"
77 #define LIBGNUNET_PLUGIN_TRANSPORT_INIT \
78  libgnunet_plugin_transport_bluetooth_init
79 #define LIBGNUNET_PLUGIN_TRANSPORT_DONE \
80  libgnunet_plugin_transport_bluetooth_done
81 #define LOG(kind, ...) GNUNET_log_from (kind, "transport-bluetooth", \
82  __VA_ARGS__)
83 
87 #define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply ( \
88  GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 60)
89 
90 
96 #define HELLO_BEACON_SCALING_FACTOR GNUNET_TIME_relative_multiply ( \
97  GNUNET_TIME_UNIT_SECONDS, 60)
98 
99 /* end case bluetooth */
100 #else
101 #error need to build wlan or bluetooth
102 #endif
103 
104 
117 typedef int
119  void *client,
120  const struct
121  GNUNET_MessageHeader *message);
122 
123 
124 /* Include legacy message stream tokenizer that was removed from util (for now) */
125 #include "tcp_server_mst_legacy.c"
126 
127 
131 #define WLAN_MTU 1430
132 
133 
137 #if BUILD_WLAN
138 static const enum GNUNET_NetworkType scope = GNUNET_NT_WLAN;
139 #else
140 static const enum GNUNET_NetworkType scope = GNUNET_NT_BT;
141 #endif
142 
143 
147 #define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 2
148 
153 #define WLAN_LLC_DSAP_FIELD 0x1f
154 #define WLAN_LLC_SSAP_FIELD 0x1f
155 
156 
165 {
170 
174  uint32_t crc GNUNET_PACKED;
175 
180 
185 
186  /* followed by payload, possibly including
187  multiple messages! */
188 };
189 
190 
195 {
200 
205 };
206 
207 
209 
210 
215 struct PendingMessage
216 {
220  struct PendingMessage *next;
221 
225  struct PendingMessage *prev;
226 
230  struct WlanHeader *msg;
231 
238 
242  void *transmit_cont_cls;
243 
248 };
249 
250 
254 struct GNUNET_ATS_Session
255 {
260  struct GNUNET_PeerIdentity target;
261 
266  struct GNUNET_ATS_Session *next;
267 
272  struct GNUNET_ATS_Session *prev;
273 
277  struct MacEndpoint *mac;
278 
283 
288 
293 };
294 
295 
300 {
305 
310 
315 
320 
326 
330  struct GNUNET_PeerIdentity target;
331 
336 
341 
346 
352 
356  void *cont_cls;
357 
361  size_t size_payload;
362 
366  size_t size_on_wire;
367 };
368 
369 
374 {
378  struct MacEndpoint *next;
379 
383  struct MacEndpoint *prev;
384 
388  struct Plugin *plugin;
389 
394 
399 
404 
409 
414 
419 
424 
429 
433  struct WlanAddress wlan_addr;
434 
438  struct GNUNET_TIME_Relative msg_delay;
439 
443  struct GNUNET_TIME_Relative ack_delay;
444 
448  uint16_t tx_power;
449 
453  uint8_t rate;
454 
458  uint8_t antenna;
459 };
460 
461 
465 struct Plugin
466 {
471 
476 
481 
485  void *sic_cls;
486 
491  char *helper_argv[3];
492 
497 
503 
508 
513 
518 
523 
528 
532  struct GNUNET_BANDWIDTH_Tracker tracker;
533 
538 
542  int have_mac;
543 
547  unsigned int mac_count;
548 
552  uint32_t options;
553 };
554 
555 
562 {
567 
572 };
573 
574 
583 static const char *
585 {
586  static char macstr[20];
587 
588  GNUNET_snprintf (macstr,
589  sizeof(macstr),
590  "%.2X:%.2X:%.2X:%.2X:%.2X:%.2X",
591  mac->mac[0], mac->mac[1],
592  mac->mac[2], mac->mac[3],
593  mac->mac[4], mac->mac[5]);
594  return macstr;
595 }
596 
597 
609 static const char *
611  const void *addr,
612  size_t addrlen)
613 {
615  static char macstr[36];
616 
617  if (sizeof(struct WlanAddress) != addrlen)
618  {
619  GNUNET_break (0);
620  return NULL;
621  }
622  mac = &((struct WlanAddress *) addr)->mac;
623  GNUNET_snprintf (macstr,
624  sizeof(macstr),
625  "%s.%u.%s",
626  PLUGIN_NAME,
627  ntohl (((struct WlanAddress *) addr)->options),
628  mac_to_string (mac));
629  return macstr;
630 }
631 
632 
641 static void
643  struct GNUNET_ATS_Session *session,
645 {
646  struct GNUNET_TRANSPORT_SessionInfo info;
647 
648  if (NULL == plugin->sic)
649  return;
650  memset (&info, 0, sizeof(info));
651  info.state = state;
652  info.is_inbound = GNUNET_SYSERR; /* hard to say */
653  info.num_msg_pending = 0; /* we queue per MAC, not per peer */
654  info.num_bytes_pending = 0; /* we queue per MAC, not per peer */
655  info.receive_delay = GNUNET_TIME_UNIT_ZERO_ABS; /* not supported by WLAN */
656  info.session_timeout = session->timeout;
657  info.address = session->address;
658  plugin->sic (plugin->sic_cls,
659  session,
660  &info);
661 }
662 
663 
671 static void
674  uint16_t size)
675 {
677  header->header.size = ntohs (size);
678  if (NULL != endpoint)
679  {
680  header->rate = endpoint->rate;
681  header->tx_power = endpoint->tx_power;
682  header->antenna = endpoint->antenna;
683  }
684  else
685  {
686  header->rate = 255;
687  header->tx_power = 0;
688  header->antenna = 0;
689  }
690 }
691 
692 
701 static void
704  const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr,
705  unsigned int size)
706 {
707  const int rate = 11000000;
708 
709  header->frame_control = htons (IEEE80211_FC0_TYPE_DATA);
710  header->addr1 = *to_mac_addr;
711  header->addr2 = plugin->mac_address;
712  header->addr3 = mac_bssid_gnunet;
713  header->duration = GNUNET_htole16 ((size * 1000000) / rate + 290);
714  header->sequence_control = 0; // FIXME?
715  header->llc[0] = WLAN_LLC_DSAP_FIELD;
716  header->llc[1] = WLAN_LLC_SSAP_FIELD;
717  header->llc[2] = 0; // FIXME?
718  header->llc[3] = 0; // FIXME?
719 }
720 
721 
729 static void
730 send_ack (void *cls,
731  uint32_t msg_id,
732  const struct GNUNET_MessageHeader *hdr)
733 {
734  struct MacEndpoint *endpoint = cls;
735  struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage*radio_header;
736  uint16_t msize = ntohs (hdr->size);
737  size_t size = sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)
738  + msize;
739  char buf[size];
740 
741  if (NULL == endpoint)
742  {
743  GNUNET_break (0);
744  return;
745  }
746  if (size >= GNUNET_MAX_MESSAGE_SIZE)
747  {
748  GNUNET_break (0);
749  return;
750  }
752  "Sending ACK to %s\n",
753  mac_to_string (&endpoint->wlan_addr.mac));
754  radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) buf;
755  get_radiotap_header (endpoint, radio_header, size);
756  get_wlan_header (endpoint->plugin,
757  &radio_header->frame,
758  &endpoint->wlan_addr.mac,
759  sizeof(endpoint->wlan_addr.mac));
760  GNUNET_memcpy (&radio_header[1], hdr, msize);
761  if (NULL !=
763  &radio_header->header,
764  GNUNET_NO /* dropping ACKs is bad */,
765  NULL, NULL))
766  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
767  _ ("# ACKs sent"),
768  1, GNUNET_NO);
769 }
770 
771 
778 static void
780  const struct GNUNET_MessageHeader *hdr)
781 {
782  struct MacEndpoint *endpoint = cls;
783  struct Plugin *plugin = endpoint->plugin;
784  struct MacAndSession mas;
785 
786  GNUNET_STATISTICS_update (plugin->env->stats,
787  _ ("# Messages defragmented"),
788  1,
789  GNUNET_NO);
790  mas.session = NULL;
791  mas.endpoint = endpoint;
793  &mas,
794  (const char *) hdr,
795  ntohs (hdr->size),
797 }
798 
799 
806 static int
808  struct GNUNET_ATS_Session *session)
809 {
810  struct MacEndpoint *endpoint = session->mac;
811  struct Plugin *plugin = endpoint->plugin;
812 
813  plugin->env->session_end (plugin->env->cls,
814  session->address,
815  session);
816  notify_session_monitor (plugin,
817  session,
820  endpoint->sessions_tail,
821  session);
822  if (session->timeout_task != NULL)
823  {
825  session->timeout_task = NULL;
826  }
827  GNUNET_STATISTICS_update (plugin->env->stats,
828  _ ("# Sessions allocated"),
829  -1,
830  GNUNET_NO);
832  GNUNET_free (session);
833  return GNUNET_OK;
834 }
835 
836 
845 static unsigned int
847 {
848  return 3;
849 }
850 
851 
857 static void
858 session_timeout (void *cls)
859 {
860  struct GNUNET_ATS_Session *session = cls;
861  struct GNUNET_TIME_Relative left;
862 
863  session->timeout_task = NULL;
865  if (0 != left.rel_value_us)
866  {
867  session->timeout_task =
870  session);
871  return;
872  }
874  session);
875 }
876 
877 
885 static struct GNUNET_ATS_Session *
886 lookup_session (struct MacEndpoint *endpoint,
887  const struct GNUNET_PeerIdentity *peer)
888 {
889  struct GNUNET_ATS_Session *session;
890 
891  for (session = endpoint->sessions_head; NULL != session; session =
892  session->next)
893  if (0 == memcmp (peer, &session->target, sizeof(struct
895  return session;
896  return NULL;
897 }
898 
899 
907 static struct GNUNET_ATS_Session *
908 create_session (struct MacEndpoint *endpoint,
909  const struct GNUNET_PeerIdentity *peer)
910 {
911  struct GNUNET_ATS_Session *session;
912 
913  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
914  _ ("# Sessions allocated"),
915  1,
916  GNUNET_NO);
917  session = GNUNET_new (struct GNUNET_ATS_Session);
919  endpoint->sessions_tail,
920  session);
921  session->address = GNUNET_HELLO_address_allocate (peer,
922  PLUGIN_NAME,
923  &endpoint->wlan_addr,
924  sizeof(endpoint->wlan_addr),
926  session->mac = endpoint;
927  session->target = *peer;
930  session->timeout_task =
933  session);
934  notify_session_monitor (endpoint->plugin,
935  session,
937  notify_session_monitor (endpoint->plugin,
938  session,
941  "Created new session %p for peer `%s' with endpoint %s\n",
942  session,
943  GNUNET_i2s (peer),
944  mac_to_string (&endpoint->wlan_addr.mac));
945 
946  return session;
947 }
948 
949 
957 static struct GNUNET_ATS_Session *
958 get_session (struct MacEndpoint *endpoint,
959  const struct GNUNET_PeerIdentity *peer)
960 {
961  struct GNUNET_ATS_Session *session;
962 
963  if (NULL != (session = lookup_session (endpoint, peer)))
964  return session;
965  return create_session (endpoint, peer);
966 }
967 
968 
979 static void
981  int result)
982 {
983  struct FragmentMessage *fm = cls;
984 
985  fm->sh = NULL;
987 }
988 
989 
996 static void
997 transmit_fragment (void *cls,
998  const struct GNUNET_MessageHeader *hdr)
999 {
1000  struct FragmentMessage *fm = cls;
1001  struct MacEndpoint *endpoint = fm->macendpoint;
1002  size_t size;
1003  uint16_t msize;
1004 
1005  if (NULL == endpoint)
1006  {
1007  GNUNET_break (0);
1008  return;
1009  }
1010  msize = ntohs (hdr->size);
1011  size = sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize;
1012  {
1013  char buf[size];
1014  struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radio_header;
1015 
1016  radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) buf;
1017  get_radiotap_header (endpoint, radio_header, size);
1019  "Sending %u bytes of data to MAC `%s'\n",
1020  (unsigned int) msize,
1021  mac_to_string (&endpoint->wlan_addr.mac));
1022 
1023  get_wlan_header (endpoint->plugin,
1024  &radio_header->frame,
1025  &endpoint->wlan_addr.mac,
1026  sizeof(endpoint->wlan_addr.mac));
1027  GNUNET_memcpy (&radio_header[1], hdr, msize);
1028  GNUNET_assert (NULL == fm->sh);
1029  fm->sh = GNUNET_HELPER_send (endpoint->plugin->suid_helper,
1030  &radio_header->header,
1031  GNUNET_NO,
1033  fm->size_on_wire += size;
1034  if (NULL != fm->sh)
1035  {
1036  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
1037  _ ("# message fragments sent"),
1038  1,
1039  GNUNET_NO);
1040  }
1041  else
1042  {
1044  }
1045  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
1046  "# bytes currently in buffers",
1047  -msize, GNUNET_NO);
1048  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
1049  "# bytes transmitted",
1050  msize, GNUNET_NO);
1051  }
1052 }
1053 
1054 
1060 static void
1062 {
1063  struct MacEndpoint *endpoint = fm->macendpoint;
1064 
1065  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
1066  _ ("# messages pending (with fragmentation)"),
1067  -1, GNUNET_NO);
1069  endpoint->sending_messages_tail,
1070  fm);
1071  if (NULL != fm->sh)
1072  {
1074  fm->sh = NULL;
1075  }
1076  if (NULL != fm->msg)
1077  {
1078  GNUNET_free (fm->msg);
1079  fm->msg = NULL;
1080  }
1081  if (NULL != fm->fragcontext)
1082  {
1084  &endpoint->msg_delay,
1085  &endpoint->ack_delay);
1086  fm->fragcontext = NULL;
1087  }
1088  if (NULL != fm->timeout_task)
1089  {
1091  fm->timeout_task = NULL;
1092  }
1093  GNUNET_free (fm);
1094 }
1095 
1096 
1102 static void
1104 {
1105  struct FragmentMessage *fm = cls;
1106 
1107  fm->timeout_task = NULL;
1108  if (NULL != fm->cont)
1109  {
1110  fm->cont (fm->cont_cls,
1111  &fm->target,
1112  GNUNET_SYSERR,
1113  fm->size_payload,
1114  fm->size_on_wire);
1115  fm->cont = NULL;
1116  }
1117  free_fragment_message (fm);
1118 }
1119 
1120 
1135 static void
1138  const struct GNUNET_PeerIdentity *target,
1139  const struct GNUNET_MessageHeader *msg,
1140  size_t payload_size,
1142  void *cont_cls)
1143 
1144 {
1145  struct FragmentMessage *fm;
1146  struct Plugin *plugin;
1147 
1148  plugin = endpoint->plugin;
1149  fm = GNUNET_new (struct FragmentMessage);
1150  fm->macendpoint = endpoint;
1151  fm->target = *target;
1152  fm->size_payload = payload_size;
1153  fm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
1154  fm->cont = cont;
1155  fm->cont_cls = cont_cls;
1156  /* 1 MBit/s typical data rate, 1430 byte fragments => ~100 ms per message */
1157  fm->timeout_task =
1160  fm);
1161  if (GNUNET_YES == plugin->have_mac)
1162  {
1163  fm->fragcontext =
1164  GNUNET_FRAGMENT_context_create (plugin->env->stats,
1165  WLAN_MTU,
1166  &plugin->tracker,
1167  fm->macendpoint->msg_delay,
1168  fm->macendpoint->ack_delay,
1169  msg,
1170  &transmit_fragment, fm);
1171  }
1172  else
1173  {
1174  fm->msg = GNUNET_copy_message (msg);
1175  }
1177  endpoint->sending_messages_tail,
1178  fm);
1179 }
1180 
1181 
1187 static void
1188 free_macendpoint (struct MacEndpoint *endpoint)
1189 {
1190  struct Plugin *plugin = endpoint->plugin;
1191  struct FragmentMessage *fm;
1192  struct GNUNET_ATS_Session *session;
1193 
1194  GNUNET_STATISTICS_update (plugin->env->stats,
1195  _ ("# MAC endpoints allocated"),
1196  -1,
1197  GNUNET_NO);
1198  while (NULL != (session = endpoint->sessions_head))
1200  session);
1201  while (NULL != (fm = endpoint->sending_messages_head))
1202  free_fragment_message (fm);
1204  plugin->mac_tail,
1205  endpoint);
1206 
1207  if (NULL != endpoint->defrag)
1208  {
1210  endpoint->defrag = NULL;
1211  }
1212 
1213  plugin->mac_count--;
1214  if (NULL != endpoint->timeout_task)
1215  {
1217  endpoint->timeout_task = NULL;
1218  }
1219  GNUNET_free (endpoint);
1220 }
1221 
1222 
1228 static void
1230 {
1231  struct MacEndpoint *endpoint = cls;
1232  struct GNUNET_TIME_Relative timeout;
1233 
1234  endpoint->timeout_task = NULL;
1235  timeout = GNUNET_TIME_absolute_get_remaining (endpoint->timeout);
1236  if (0 == timeout.rel_value_us)
1237  {
1238  free_macendpoint (endpoint);
1239  return;
1240  }
1241  endpoint->timeout_task =
1244  endpoint);
1245 }
1246 
1247 
1255 static struct MacEndpoint *
1257  struct WlanAddress *mac)
1258 {
1259  struct MacEndpoint *pos;
1260 
1261  for (pos = plugin->mac_head; NULL != pos; pos = pos->next)
1262  if (0 == memcmp (mac, &pos->wlan_addr, sizeof(pos->wlan_addr)))
1263  return pos;
1264  pos = GNUNET_new (struct MacEndpoint);
1265  pos->wlan_addr = (*mac);
1266  pos->plugin = plugin;
1267  pos->defrag =
1268  GNUNET_DEFRAGMENT_context_create (plugin->env->stats,
1269  WLAN_MTU,
1271  pos,
1273  &send_ack);
1274 
1277  100);
1278  pos->timeout = GNUNET_TIME_relative_to_absolute (MACENDPOINT_TIMEOUT);
1279  pos->timeout_task =
1280  GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout,
1281  pos);
1283  plugin->mac_tail,
1284  pos);
1285  plugin->mac_count++;
1286  GNUNET_STATISTICS_update (plugin->env->stats,
1287  _ ("# MAC endpoints allocated"),
1288  1, GNUNET_NO);
1290  "New MAC endpoint `%s'\n",
1292  &pos->wlan_addr,
1293  sizeof(struct WlanAddress)));
1294  return pos;
1295 }
1296 
1297 
1305 static enum GNUNET_NetworkType
1307  struct GNUNET_ATS_Session *session)
1308 {
1309 #if BUILD_WLAN
1310  return GNUNET_NT_WLAN;
1311 #else
1312  return GNUNET_NT_BT;
1313 #endif
1314 }
1315 
1316 
1324 static enum GNUNET_NetworkType
1326  const struct GNUNET_HELLO_Address *address)
1327 {
1328 #if BUILD_WLAN
1329  return GNUNET_NT_WLAN;
1330 #else
1331  return GNUNET_NT_BT;
1332 #endif
1333 }
1334 
1335 
1344 static struct GNUNET_ATS_Session *
1346  const struct GNUNET_HELLO_Address *address)
1347 {
1348  struct Plugin *plugin = cls;
1349  struct MacEndpoint *endpoint;
1350 
1351  if (NULL == address)
1352  return NULL;
1353  if (sizeof(struct WlanAddress) != address->address_length)
1354  {
1355  GNUNET_break (0);
1356  return NULL;
1357  }
1359  "Service asked to create session for peer `%s' with MAC `%s'\n",
1360  GNUNET_i2s (&address->peer),
1362  address->address,
1363  address->address_length));
1364  endpoint = create_macendpoint (plugin,
1365  (struct WlanAddress *) address->address);
1366  return get_session (endpoint, &address->peer);
1367 }
1368 
1369 
1378 static void
1380  const struct GNUNET_PeerIdentity *target)
1381 {
1382  struct Plugin *plugin = cls;
1383  struct GNUNET_ATS_Session *session;
1384  struct MacEndpoint *endpoint;
1385 
1386  for (endpoint = plugin->mac_head; NULL != endpoint; endpoint = endpoint->next)
1387  for (session = endpoint->sessions_head; NULL != session; session =
1388  session->next)
1389  if (0 == memcmp (target, &session->target,
1390  sizeof(struct GNUNET_PeerIdentity)))
1391  {
1392  wlan_plugin_disconnect_session (plugin, session);
1393  break; /* inner-loop only (in case peer has another MAC as well!) */
1394  }
1395 }
1396 
1397 
1425 static ssize_t
1426 wlan_plugin_send (void *cls,
1427  struct GNUNET_ATS_Session *session,
1428  const char *msgbuf, size_t msgbuf_size,
1429  unsigned int priority,
1430  struct GNUNET_TIME_Relative to,
1431  GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
1432 {
1433  struct Plugin *plugin = cls;
1434  struct WlanHeader *wlanheader;
1435  size_t size = msgbuf_size + sizeof(struct WlanHeader);
1436  char buf[size] GNUNET_ALIGN;
1437 
1439  "Transmitting %u bytes of payload to peer `%s' (starting with %u byte message of type %u)\n",
1440  msgbuf_size,
1441  GNUNET_i2s (&session->target),
1442  (unsigned int) ntohs (((struct GNUNET_MessageHeader*) msgbuf)->size),
1443  (unsigned int) ntohs (((struct GNUNET_MessageHeader*) msgbuf)->type));
1444  wlanheader = (struct WlanHeader *) buf;
1445  wlanheader->header.size = htons (msgbuf_size + sizeof(struct WlanHeader));
1446  wlanheader->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA);
1447  wlanheader->sender = *plugin->env->my_identity;
1448  wlanheader->target = session->target;
1449  wlanheader->crc = htonl (GNUNET_CRYPTO_crc32_n (msgbuf, msgbuf_size));
1450  GNUNET_memcpy (&wlanheader[1],
1451  msgbuf,
1452  msgbuf_size);
1453  GNUNET_STATISTICS_update (plugin->env->stats,
1454  "# bytes currently in buffers",
1455  msgbuf_size,
1456  GNUNET_NO);
1457  send_with_fragmentation (session->mac,
1458  to,
1459  &session->target,
1460  &wlanheader->header,
1461  msgbuf_size,
1462  cont, cont_cls);
1463  return size;
1464 }
1465 
1466 
1475 static int
1476 process_data (void *cls,
1477  void *client,
1478  const struct GNUNET_MessageHeader *hdr)
1479 {
1480  struct Plugin *plugin = cls;
1481  struct GNUNET_HELLO_Address *address;
1482  struct MacAndSession *mas = client;
1483  struct FragmentMessage *fm;
1484  struct GNUNET_PeerIdentity tmpsource;
1485  const struct WlanHeader *wlanheader;
1486  int ret;
1487  uint16_t msize;
1488 
1489  msize = ntohs (hdr->size);
1490 
1491  GNUNET_STATISTICS_update (plugin->env->stats,
1492  "# bytes received",
1493  msize, GNUNET_NO);
1494 
1495  switch (ntohs (hdr->type))
1496  {
1498 
1499  if (GNUNET_OK !=
1500  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) hdr,
1501  &tmpsource))
1502  {
1503  GNUNET_break_op (0);
1504  break;
1505  }
1506  if (NULL == mas->endpoint)
1507  {
1508  GNUNET_break (0);
1509  break;
1510  }
1511 
1513  "Processing %u bytes of HELLO from peer `%s' at MAC %s\n",
1514  (unsigned int) msize,
1515  GNUNET_i2s (&tmpsource),
1517  &mas->endpoint->wlan_addr,
1518  sizeof(mas->endpoint->wlan_addr)));
1519 
1520  GNUNET_STATISTICS_update (plugin->env->stats,
1521  _ ("# HELLO messages received"), 1,
1522  GNUNET_NO);
1523  address = GNUNET_HELLO_address_allocate (&tmpsource,
1524  PLUGIN_NAME,
1525  &mas->endpoint->wlan_addr,
1526  sizeof(mas->endpoint->wlan_addr),
1528  mas->session = lookup_session (mas->endpoint,
1529  &tmpsource);
1530  if (NULL == mas->session)
1531  {
1532  mas->session = create_session (mas->endpoint,
1533  &tmpsource);
1534  plugin->env->session_start (plugin->env->cls,
1535  address,
1536  mas->session,
1537  scope);
1538  }
1539  plugin->env->receive (plugin->env->cls,
1540  address,
1541  mas->session,
1542  hdr);
1543  GNUNET_HELLO_address_free (address);
1544  break;
1545 
1547  if (NULL == mas->endpoint)
1548  {
1549  GNUNET_break (0);
1550  break;
1551  }
1553  "Processing %u bytes of FRAGMENT from MAC %s\n",
1554  (unsigned int) msize,
1556  &mas->endpoint->wlan_addr,
1557  sizeof(mas->endpoint->wlan_addr)));
1558  GNUNET_STATISTICS_update (plugin->env->stats,
1559  _ ("# fragments received"),
1560  1,
1561  GNUNET_NO);
1563  hdr);
1564  break;
1565 
1567  if (NULL == mas->endpoint)
1568  {
1569  GNUNET_break (0);
1570  break;
1571  }
1572  GNUNET_STATISTICS_update (plugin->env->stats,
1573  _ ("# ACKs received"),
1574  1, GNUNET_NO);
1575  for (fm = mas->endpoint->sending_messages_head; NULL != fm; fm = fm->next)
1576  {
1577  ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr);
1578  if (GNUNET_OK == ret)
1579  {
1581  "Got last ACK, finished message transmission to `%s' (%p)\n",
1583  &mas->endpoint->wlan_addr,
1584  sizeof(mas->endpoint->wlan_addr)),
1585  fm);
1587  MACENDPOINT_TIMEOUT);
1588  if (NULL != fm->cont)
1589  {
1590  fm->cont (fm->cont_cls,
1591  &fm->target,
1592  GNUNET_OK,
1593  fm->size_payload,
1594  fm->size_on_wire);
1595  fm->cont = NULL;
1596  }
1597  free_fragment_message (fm);
1598  break;
1599  }
1600  if (GNUNET_NO == ret)
1601  {
1603  "Got an ACK, message transmission to `%s' not yet finished\n",
1605  &mas->endpoint->wlan_addr,
1606  sizeof(mas->endpoint->wlan_addr)));
1607  break;
1608  }
1609  }
1610  if (NULL == fm)
1612  "ACK not matched against any active fragmentation with MAC `%s'\n",
1614  &mas->endpoint->wlan_addr,
1615  sizeof(mas->endpoint->wlan_addr)));
1616  break;
1617 
1619  if (NULL == mas->endpoint)
1620  {
1621  GNUNET_break (0);
1622  break;
1623  }
1624  if (msize < sizeof(struct WlanHeader))
1625  {
1626  GNUNET_break (0);
1627  break;
1628  }
1629  wlanheader = (const struct WlanHeader *) hdr;
1630  if (0 != memcmp (&wlanheader->target,
1631  plugin->env->my_identity,
1632  sizeof(struct GNUNET_PeerIdentity)))
1633  {
1635  "Data for `%s', not for me, ignoring\n",
1636  GNUNET_i2s (&wlanheader->target));
1637  break;
1638  }
1639  if (ntohl (wlanheader->crc) !=
1640  GNUNET_CRYPTO_crc32_n (&wlanheader[1],
1641  msize - sizeof(struct WlanHeader)))
1642  {
1643  GNUNET_STATISTICS_update (plugin->env->stats,
1644  _ (
1645  "# DATA messages discarded due to CRC32 error"),
1646  1,
1647  GNUNET_NO);
1648  break;
1649  }
1650  mas->session = lookup_session (mas->endpoint,
1651  &wlanheader->sender);
1652  if (NULL == mas->session)
1653  {
1654  mas->session = create_session (mas->endpoint,
1655  &wlanheader->sender);
1656  address = GNUNET_HELLO_address_allocate (&wlanheader->sender,
1657  PLUGIN_NAME,
1658  &mas->endpoint->wlan_addr,
1659  sizeof(struct WlanAddress),
1661  plugin->env->session_start (plugin->env->cls,
1662  address,
1663  mas->session,
1664  scope);
1666  "Notifying transport about peer `%s''s new session %p \n",
1667  GNUNET_i2s (&wlanheader->sender),
1668  mas->session);
1669  GNUNET_HELLO_address_free (address);
1670  }
1672  "Processing %u bytes of DATA from peer `%s'\n",
1673  (unsigned int) msize,
1674  GNUNET_i2s (&wlanheader->sender));
1678  mas,
1679  (const char *) &wlanheader[1],
1680  msize - sizeof(struct WlanHeader),
1681  GNUNET_YES,
1682  GNUNET_NO);
1683  break;
1684 
1685  default:
1686  if (NULL == mas->endpoint)
1687  {
1688  GNUNET_break (0);
1689  break;
1690  }
1691  if (NULL == mas->session)
1692  {
1693  GNUNET_break (0);
1694  break;
1695  }
1697  "Received packet with %u bytes of type %u from peer %s\n",
1698  (unsigned int) msize,
1699  (unsigned int) ntohs (hdr->type),
1700  GNUNET_i2s (&mas->session->target));
1701  plugin->env->receive (plugin->env->cls,
1702  mas->session->address,
1703  mas->session,
1704  hdr);
1705  break;
1706  }
1707  return GNUNET_OK;
1708 }
1709 
1710 
1716 static void
1718 {
1719  struct Plugin *plugin = cls;
1720  uint16_t size;
1721  uint16_t hello_size;
1722  struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radioHeader;
1723  const struct GNUNET_MessageHeader *hello;
1724 
1725  hello = plugin->env->get_our_hello ();
1726  if (NULL != hello)
1727  {
1728  hello_size = GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello);
1729  GNUNET_assert (sizeof(struct WlanHeader) + hello_size <= WLAN_MTU);
1730  size = sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)
1731  + hello_size;
1732  {
1733  char buf[size] GNUNET_ALIGN;
1734 
1736  "Sending %u byte HELLO beacon\n",
1737  (unsigned int) size);
1738  radioHeader = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage*) buf;
1739  get_radiotap_header (NULL, radioHeader, size);
1741  "Broadcasting %u bytes of data to MAC `%s'\n",
1742  (unsigned int) size,
1744  get_wlan_header (plugin, &radioHeader->frame, &bc_all_mac, size);
1745  GNUNET_memcpy (&radioHeader[1], hello, hello_size);
1746  if (NULL !=
1748  &radioHeader->header,
1749  GNUNET_YES /* can drop */,
1750  NULL, NULL))
1751  GNUNET_STATISTICS_update (plugin->env->stats,
1752  _ ("# HELLO beacons sent"),
1753  1, GNUNET_NO);
1754  }
1755  }
1756  plugin->beacon_task =
1758  (HELLO_BEACON_SCALING_FACTOR,
1759  plugin->mac_count + 1),
1761  plugin);
1762 }
1763 
1764 
1771 static int
1773  const struct GNUNET_MessageHeader *hdr)
1774 {
1775  struct Plugin *plugin = cls;
1776  struct GNUNET_HELLO_Address *my_address;
1777  const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo;
1779  struct WlanAddress wa;
1780  struct MacAndSession mas;
1781  uint16_t msize;
1782  struct FragmentMessage *fm;
1783  struct MacEndpoint *endpoint;
1784 
1785  msize = ntohs (hdr->size);
1786  switch (ntohs (hdr->type))
1787  {
1789  if (msize != sizeof(struct GNUNET_TRANSPORT_WLAN_HelperControlMessage))
1790  {
1791  GNUNET_break (0);
1792  break;
1793  }
1794  cm = (const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *) hdr;
1795  if (GNUNET_YES == plugin->have_mac)
1796  {
1797  if (0 == memcmp (&plugin->mac_address,
1798  &cm->mac,
1799  sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)))
1800  break; /* no change */
1801  /* remove old address */
1802  memset (&wa, 0, sizeof(struct WlanAddress));
1803  wa.mac = plugin->mac_address;
1804  wa.options = htonl (plugin->options);
1805  my_address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
1806  PLUGIN_NAME,
1807  &wa, sizeof(wa),
1809  plugin->env->notify_address (plugin->env->cls,
1810  GNUNET_NO,
1811  my_address);
1812  GNUNET_HELLO_address_free (my_address);
1813  plugin->mac_address = cm->mac;
1814  }
1815  else
1816  {
1817  plugin->mac_address = cm->mac;
1818  plugin->have_mac = GNUNET_YES;
1819  for (endpoint = plugin->mac_head; NULL != endpoint; endpoint =
1820  endpoint->next)
1821  {
1822  for (fm = endpoint->sending_messages_head; NULL != fm; fm = fm->next)
1823  {
1824  if (NULL != fm->fragcontext)
1825  {
1826  GNUNET_break (0); /* should not happen */
1827  continue;
1828  }
1829  fm->fragcontext =
1830  GNUNET_FRAGMENT_context_create (plugin->env->stats,
1831  WLAN_MTU,
1832  &plugin->tracker,
1833  fm->macendpoint->msg_delay,
1834  fm->macendpoint->ack_delay,
1835  fm->msg,
1836  &transmit_fragment, fm);
1837  GNUNET_free (fm->msg);
1838  fm->msg = NULL;
1839  }
1840  }
1841  GNUNET_break (NULL == plugin->beacon_task);
1843  plugin);
1844  }
1845 
1846  memset (&wa, 0, sizeof(struct WlanAddress));
1847  wa.mac = plugin->mac_address;
1848  wa.options = htonl (plugin->options);
1849  my_address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
1850  PLUGIN_NAME,
1851  &wa, sizeof(wa),
1853 
1855  "Received WLAN_HELPER_CONTROL message with MAC address `%s' for peer `%s'\n",
1856  mac_to_string (&cm->mac),
1857  GNUNET_i2s (plugin->env->my_identity));
1858  plugin->env->notify_address (plugin->env->cls,
1859  GNUNET_YES,
1860  my_address);
1861  GNUNET_HELLO_address_free (my_address);
1862  break;
1863 
1866  "Got data message from helper with %u bytes\n",
1867  msize);
1868  GNUNET_STATISTICS_update (plugin->env->stats,
1869  _ ("# DATA messages received"), 1,
1870  GNUNET_NO);
1871  if (msize < sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage))
1872  {
1874  "Size of packet is too small (%u bytes < %u)\n",
1875  msize, sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage));
1876  break;
1877  }
1878  rxinfo = (const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) hdr;
1879 
1880  /* check if message is actually for us */
1881  if (0 != memcmp (&rxinfo->frame.addr3, &mac_bssid_gnunet,
1882  sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)))
1883  {
1884  /* Not the GNUnet BSSID */
1885  break;
1886  }
1887  if ((0 != memcmp (&rxinfo->frame.addr1, &bc_all_mac,
1888  sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress))) &&
1889  (0 != memcmp (&rxinfo->frame.addr1, &plugin->mac_address,
1890  sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress))))
1891  {
1892  /* Neither broadcast nor specifically for us */
1893  break;
1894  }
1895  if (0 == memcmp (&rxinfo->frame.addr2, &plugin->mac_address,
1896  sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)))
1897  {
1898  /* packet is FROM us, thus not FOR us */
1899  break;
1900  }
1901 
1902  GNUNET_STATISTICS_update (plugin->env->stats,
1903  _ ("# DATA messages processed"),
1904  1, GNUNET_NO);
1906  "Receiving %u bytes of data from MAC `%s'\n",
1907  (unsigned int) (msize - sizeof(struct
1909  mac_to_string (&rxinfo->frame.addr2));
1911  "Receiving %u bytes of data to MAC `%s'\n",
1912  (unsigned int) (msize - sizeof(struct
1914  mac_to_string (&rxinfo->frame.addr1));
1916  "Receiving %u bytes of data with BSSID MAC `%s'\n",
1917  (unsigned int) (msize - sizeof(struct
1919  mac_to_string (&rxinfo->frame.addr3));
1920  wa.mac = rxinfo->frame.addr2;
1921  wa.options = htonl (0);
1922  mas.endpoint = create_macendpoint (plugin, &wa);
1923  mas.session = NULL;
1925  &mas,
1926  (const char*) &rxinfo[1],
1927  msize - sizeof(struct
1930  break;
1931 
1932  default:
1933  GNUNET_break (0);
1935  "Unexpected message of type %u (%u bytes)",
1936  ntohs (hdr->type),
1937  ntohs (hdr->size));
1938  break;
1939  }
1940  return GNUNET_OK;
1941 }
1942 
1943 
1956 static int
1958  const void *addr,
1959  size_t addrlen)
1960 {
1961  struct Plugin *plugin = cls;
1962  struct WlanAddress *wa = (struct WlanAddress *) addr;
1963 
1964  if (addrlen != sizeof(struct WlanAddress))
1965  {
1966  GNUNET_break_op (0);
1967  return GNUNET_SYSERR;
1968  }
1969  if (GNUNET_YES != plugin->have_mac)
1970  {
1972  "Rejecting MAC `%s': I don't know my MAC!\n",
1973  mac_to_string (addr));
1974  return GNUNET_NO; /* don't know my MAC */
1975  }
1976  if (0 != memcmp (&wa->mac,
1977  &plugin->mac_address,
1978  sizeof(wa->mac)))
1979  {
1981  "Rejecting MAC `%s': not my MAC!\n",
1982  mac_to_string (addr));
1983  return GNUNET_NO; /* not my MAC */
1984  }
1985  return GNUNET_OK;
1986 }
1987 
1988 
2002 static void
2004  const char *type,
2005  const void *addr,
2006  size_t addrlen,
2007  int numeric,
2010  void *asc_cls)
2011 {
2012  const char *ret;
2013 
2014  if (sizeof(struct WlanAddress) == addrlen)
2015  ret = wlan_plugin_address_to_string (NULL,
2016  addr,
2017  addrlen);
2018  else
2019  ret = NULL;
2020  asc (asc_cls,
2021  ret,
2022  (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
2023  asc (asc_cls, NULL, GNUNET_OK);
2024 }
2025 
2026 
2032 void *
2034 {
2035  struct WlanAddress wa;
2036  struct GNUNET_HELLO_Address *address;
2037  struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
2038  struct Plugin *plugin = api->cls;
2039  struct MacEndpoint *endpoint;
2040  struct MacEndpoint *endpoint_next;
2041 
2042  if (NULL == plugin)
2043  {
2044  GNUNET_free (api);
2045  return NULL;
2046  }
2047  if (GNUNET_YES == plugin->have_mac)
2048  {
2049  memset (&wa, 0, sizeof(wa));
2050  wa.options = htonl (plugin->options);
2051  wa.mac = plugin->mac_address;
2052  address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
2053  PLUGIN_NAME,
2054  &wa, sizeof(struct WlanAddress),
2056 
2057  plugin->env->notify_address (plugin->env->cls,
2058  GNUNET_NO,
2059  address);
2060  plugin->have_mac = GNUNET_NO;
2061  GNUNET_HELLO_address_free (address);
2062  }
2063 
2064  if (NULL != plugin->beacon_task)
2065  {
2067  plugin->beacon_task = NULL;
2068  }
2069  if (NULL != plugin->suid_helper)
2070  {
2072  GNUNET_NO);
2073  plugin->suid_helper = NULL;
2074  }
2075  endpoint_next = plugin->mac_head;
2076  while (NULL != (endpoint = endpoint_next))
2077  {
2078  endpoint_next = endpoint->next;
2079  free_macendpoint (endpoint);
2080  }
2081  if (NULL != plugin->fragment_data_tokenizer)
2082  {
2084  plugin->fragment_data_tokenizer = NULL;
2085  }
2086  if (NULL != plugin->wlan_header_payload_tokenizer)
2087  {
2089  plugin->wlan_header_payload_tokenizer = NULL;
2090  }
2091  if (NULL != plugin->helper_payload_tokenizer)
2092  {
2094  plugin->helper_payload_tokenizer = NULL;
2095  }
2097  GNUNET_free (plugin);
2098  GNUNET_free (api);
2099  return NULL;
2100 }
2101 
2102 
2115 static int
2117  const char *addr,
2118  uint16_t addrlen,
2119  void **buf,
2120  size_t *added)
2121 {
2122  struct WlanAddress *wa;
2123  unsigned int a[6];
2124  unsigned int i;
2125  char plugin[5];
2126  uint32_t options;
2127 
2128  if ((NULL == addr) || (0 == addrlen))
2129  {
2130  GNUNET_break (0);
2131  return GNUNET_SYSERR;
2132  }
2133  if ('\0' != addr[addrlen - 1])
2134  {
2135  GNUNET_break (0);
2136  return GNUNET_SYSERR;
2137  }
2138  if (strlen (addr) != addrlen - 1)
2139  {
2140  GNUNET_break (0);
2141  return GNUNET_SYSERR;
2142  }
2143 
2144  if (8 != sscanf (addr,
2145  "%4s.%u.%X:%X:%X:%X:%X:%X",
2146  plugin, &options,
2147  &a[0], &a[1], &a[2],
2148  &a[3], &a[4], &a[5]))
2149  {
2150  GNUNET_break (0);
2151  return GNUNET_SYSERR;
2152  }
2153  wa = GNUNET_new (struct WlanAddress);
2154  for (i = 0; i < 6; i++)
2155  wa->mac.mac[i] = a[i];
2156  wa->options = htonl (0);
2157  *buf = wa;
2158  *added = sizeof(struct WlanAddress);
2159  return GNUNET_OK;
2160 }
2161 
2162 
2175 static void
2178  void *sic_cls)
2179 {
2180  struct Plugin *plugin = cls;
2181  struct MacEndpoint *mac;
2182  struct GNUNET_ATS_Session *session;
2183 
2184  plugin->sic = sic;
2185  plugin->sic_cls = sic_cls;
2186  if (NULL != sic)
2187  {
2188  for (mac = plugin->mac_head; NULL != mac; mac = mac->next)
2189  for (session = mac->sessions_head; NULL != session; session =
2190  session->next)
2191  {
2192  notify_session_monitor (plugin,
2193  session,
2195  notify_session_monitor (plugin,
2196  session,
2198  }
2199  sic (sic_cls, NULL, NULL);
2200  }
2201 }
2202 
2203 
2213 static void
2215  const struct GNUNET_PeerIdentity *peer,
2216  struct GNUNET_ATS_Session *session)
2217 {
2218  GNUNET_assert (NULL != session->timeout_task);
2221 }
2222 
2223 
2234 static void
2236  const struct GNUNET_PeerIdentity *peer,
2237  struct GNUNET_ATS_Session *session,
2238  struct GNUNET_TIME_Relative delay)
2239 {
2240  /* does nothing, as inbound delay is not supported by WLAN */
2241 }
2242 
2243 
2250 void *
2252 {
2255  struct Plugin *plugin;
2256  char *wlan_interface;
2257  unsigned long long testmode;
2258  char *binary;
2259 
2260  /* check for 'special' mode */
2261  if (NULL == env->receive)
2262  {
2263  /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
2264  initialze the plugin or the API */
2266  api->cls = NULL;
2270  return api;
2271  }
2272 
2273  testmode = 0;
2274  /* check configuration */
2275  if ((GNUNET_YES ==
2277  CONFIG_NAME,
2278  "TESTMODE")) &&
2279  ((GNUNET_SYSERR ==
2281  CONFIG_NAME,
2282  "TESTMODE",
2283  &testmode)) ||
2284  (testmode > 2)))
2285  {
2287  CONFIG_NAME,
2288  "TESTMODE");
2289  return NULL;
2290  }
2291  binary = GNUNET_OS_get_libexec_binary_path (HELPER_NAME);
2292  if ((0 == testmode) &&
2293  (GNUNET_YES !=
2295  GNUNET_YES,
2296  NULL)))
2297  {
2299  _ ("Helper binary `%s' not SUID, cannot run WLAN transport\n"),
2300  HELPER_NAME);
2301  GNUNET_free (binary);
2302  return NULL;
2303  }
2304  GNUNET_free (binary);
2305  if (GNUNET_YES !=
2307  CONFIG_NAME,
2308  "INTERFACE",
2309  &wlan_interface))
2310  {
2312  CONFIG_NAME,
2313  "INTERFACE");
2314  return NULL;
2315  }
2316 
2317  plugin = GNUNET_new (struct Plugin);
2318  plugin->wlan_interface = wlan_interface;
2319  plugin->env = env;
2320  GNUNET_STATISTICS_set (plugin->env->stats,
2321  _ ("# sessions allocated"),
2322  0, GNUNET_NO);
2323  GNUNET_STATISTICS_set (plugin->env->stats,
2324  _ ("# MAC endpoints allocated"),
2325  0, 0);
2326  GNUNET_BANDWIDTH_tracker_init (&plugin->tracker, NULL, NULL,
2327  GNUNET_BANDWIDTH_value_init (100 * 1024
2328  * 1024 / 8),
2329  100);
2331  plugin);
2333  &process_data,
2334  plugin);
2336  plugin);
2337 
2338  plugin->options = 0;
2339 
2340  /* some compilers do not like switch on 'long long'... */
2341  switch ((unsigned int) testmode)
2342  {
2343  case 0: /* normal */
2344  plugin->helper_argv[0] = (char *) HELPER_NAME;
2345  plugin->helper_argv[1] = wlan_interface;
2346  plugin->helper_argv[2] = NULL;
2348  HELPER_NAME,
2349  plugin->helper_argv,
2351  NULL,
2352  plugin);
2353  break;
2354 
2355  case 1: /* testmode, peer 1 */
2356  plugin->helper_argv[0] = (char *) DUMMY_HELPER_NAME;
2357  plugin->helper_argv[1] = (char *) "1";
2358  plugin->helper_argv[2] = NULL;
2360  DUMMY_HELPER_NAME,
2361  plugin->helper_argv,
2363  NULL,
2364  plugin);
2365  break;
2366 
2367  case 2: /* testmode, peer 2 */
2368  plugin->helper_argv[0] = (char *) DUMMY_HELPER_NAME;
2369  plugin->helper_argv[1] = (char *) "2";
2370  plugin->helper_argv[2] = NULL;
2372  DUMMY_HELPER_NAME,
2373  plugin->helper_argv,
2375  NULL,
2376  plugin);
2377  break;
2378 
2379  default:
2380  GNUNET_assert (0);
2381  }
2382 
2384  api->cls = plugin;
2385  api->send = &wlan_plugin_send;
2399  return api;
2400 }
2401 
2402 
2403 /* end of plugin_transport_wlan.c */
static struct GNUNET_ATS_Session * create_session(struct MacEndpoint *endpoint, const struct GNUNET_PeerIdentity *peer)
Create a new session.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static int handle_helper_message(void *cls, const struct GNUNET_MessageHeader *hdr)
Function used for to process the data from the suid process.
size_t address_length
Number of bytes in address.
Session is being torn down and about to disappear.
static void session_timeout(void *cls)
A session is timing out.
GNUNET_TRANSPORT_SessionInfoCallback sic
Function to call about session status changes.
GNUNET_TRANSPORT_TransmitContinuation cont
Continuation to call when we&#39;re done with this message.
int GNUNET_HELLO_get_id(const struct GNUNET_HELLO_Message *hello, struct GNUNET_PeerIdentity *peer)
Get the peer identity from a HELLO message.
Definition: hello.c:671
struct GNUNET_HELPER_Handle * suid_helper
Handle to helper process for priviledged operations.
#define GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL
Control message between the gnunet-wlan-helper and the daemon (with the MAC).
uint32_t num_bytes_pending
Number of bytes pending transmission for this session.
char * helper_argv[3]
ARGV-vector for the helper (all helpers take only the binary name, one actual argument, plus the NULL terminator for &#39;argv&#39;).
static void notify_session_monitor(struct Plugin *plugin, struct GNUNET_ATS_Session *session, enum GNUNET_TRANSPORT_SessionState state)
If a session monitor is attached, notify it about the new session state.
A HELLO message is used to exchange information about transports with other peers.
#define WLAN_LLC_SSAP_FIELD
uint32_t crc
CRC32 checksum (only over the payload), in NBO.
struct MacEndpoint * endpoint
MAC address of the other peer, NULL if not known.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
GNUNET_TRANSPORT_CreateSession get_session
Function that will be called tell the plugin to create a session object.
static void wlan_plugin_update_session_timeout(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session)
Function that will be called whenever the transport service wants to notify the plugin that a session...
GNUNET_TRANSPORT_AddressToString address_to_string
Function that will be called to convert a binary address to a string (numeric conversion only)...
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
static int wlan_plugin_string_to_address(void *cls, const char *addr, uint16_t addrlen, void **buf, size_t *added)
Function called to convert a string address to a binary address.
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
void GNUNET_BANDWIDTH_tracker_init(struct GNUNET_BANDWIDTH_Tracker *av, GNUNET_BANDWIDTH_TrackerUpdateCallback update_cb, void *update_cb_cls, struct GNUNET_BANDWIDTH_Value32NBO bytes_per_second_limit, uint32_t max_carry_s)
Initialize bandwidth tracker.
Definition: bandwidth.c:302
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
uint64_t rel_value_us
The actual value.
const void * address
Binary representation of the address (plugin-specific).
static void wlan_plugin_setup_monitor(void *cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void *sic_cls)
Begin monitoring sessions of a plugin.
int have_mac
Have we received a control message with our MAC address yet?
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
uint8_t antenna
Antenna we should use for this MAC.
static struct GNUNET_ATS_Session * lookup_session(struct MacEndpoint *endpoint, const struct GNUNET_PeerIdentity *peer)
Lookup a new session.
static void wlan_plugin_update_inbound_delay(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session, struct GNUNET_TIME_Relative delay)
Function that will be called whenever the transport service wants to notify the plugin that the inbou...
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
int32_t GNUNET_CRYPTO_crc32_n(const void *buf, size_t len)
Compute the CRC32 checksum for the first len bytes of the buffer.
Definition: crypto_crc.c:106
Address format for WLAN.
static void get_radiotap_header(struct MacEndpoint *endpoint, struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header, uint16_t size)
Fill the radiotap header.
struct MacEndpoint * prev
We keep all MACs in a DLL in the plugin.
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
static void free_fragment_message(struct FragmentMessage *fm)
Frees the space of a message in the fragment queue (send queue)
void * cont_cls
Closure for cont.
struct MacEndpoint * macendpoint
MAC endpoint this message belongs to.
uint8_t antenna
Antenna; the first antenna is 0.
The handle to a helper process.
Definition: helper.c:78
struct GNUNET_HELPER_Handle * GNUNET_HELPER_start(int with_control_pipe, const char *binary_name, char *const binary_argv[], GNUNET_MessageTokenizerCallback cb, GNUNET_HELPER_ExceptionCallback exp_cb, void *cb_cls)
Starts a helper and begins reading from it.
Definition: helper.c:489
struct GNUNET_ATS_Session * next
Stored in a linked list.
GNUNET_TRANSPORT_TransmitFunction send
Function that the transport service will use to transmit data to another peer.
GNUNET_TRANSPORT_DisconnectPeerFunction disconnect_peer
Function that can be used to force the plugin to disconnect from the given peer and cancel all previo...
int is_inbound
GNUNET_YES if this is an inbound connection, GNUNET_NO if this is an outbound connection, GNUNET_SYSERR if connections of this plugin are so fundamentally bidirectional that they have no &#39;initiator&#39;
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
struct GNUNET_DEFRAGMENT_Context * GNUNET_DEFRAGMENT_context_create(struct GNUNET_STATISTICS_Handle *stats, uint16_t mtu, unsigned int num_msgs, void *cls, GNUNET_FRAGMENT_MessageProcessor proc, GNUNET_DEFRAGMENT_AckProcessor ackp)
Create a defragmentation context.
static unsigned int wlan_plugin_query_keepalive_factor(void *cls)
Function that is called to get the keepalive factor.
enum GNUNET_TRANSPORT_SessionState state
New state of the session.
struct GNUNET_SERVER_MessageStreamTokenizer * helper_payload_tokenizer
Tokenizer for demultiplexing of data packets received from the suid helper.
struct GNUNET_ATS_Session * prev
Stored in a linked list.
#define LOG(kind,...)
Definition: abd_api.c:38
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
uint32_t options
Options for addresses.
unsigned int mac_count
Number of connections.
GNUNET_TRANSPORT_DisconnectSessionFunction disconnect_session
Function that can be used to force the plugin to disconnect from the given peer and cancel all previo...
static void transmit_fragment(void *cls, const struct GNUNET_MessageHeader *hdr)
Transmit a fragment of a message.
struct GNUNET_HELPER_SendHandle * sh
Transmission handle to helper (to cancel if the frag context is destroyed early for some reason)...
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
Header for messages which need fragmentation.
GNUNET_TRANSPORT_SessionMonitorSetup setup_monitor
Function to monitor the sessions managed by the plugin.
struct MacEndpoint * next
We keep all MACs in a DLL in the plugin.
void GNUNET_HELPER_stop(struct GNUNET_HELPER_Handle *h, int soft_kill)
Kills the helper, closes the pipe, frees the handle and calls wait() on the helper process...
Definition: helper.c:565
static int wlan_plugin_address_suggested(void *cls, const void *addr, size_t addrlen)
Another peer has suggested an address for this peer and transport plugin.
struct GNUNET_PeerIdentity sender
Sender of the message.
struct GNUNET_SERVER_MessageStreamTokenizer * fragment_data_tokenizer
Tokenizer for demultiplexing of data packets resulting from defragmentation.
void * LIBGNUNET_PLUGIN_TRANSPORT_INIT(void *cls)
Entry point for the plugin.
struct GNUNET_FRAGMENT_Context * GNUNET_FRAGMENT_context_create(struct GNUNET_STATISTICS_Handle *stats, uint16_t mtu, struct GNUNET_BANDWIDTH_Tracker *tracker, struct GNUNET_TIME_Relative msg_delay, struct GNUNET_TIME_Relative ack_delay, const struct GNUNET_MessageHeader *msg, GNUNET_FRAGMENT_MessageProcessor proc, void *proc_cls)
Create a fragmentation context for the given message.
Entry in the queue of messages we need to transmit to the helper.
Definition: helper.c:36
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
struct PendingMessage * next
DLL next, prev.
Struct to track available bandwidth.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
static ssize_t wlan_plugin_send(void *cls, struct GNUNET_ATS_Session *session, const char *msgbuf, size_t msgbuf_size, unsigned int priority, struct GNUNET_TIME_Relative to, GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
Function that can be used by the transport service to transmit a message using the plugin...
#define GNUNET_NO
Definition: gnunet_common.h:78
static int numeric
Option -n.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Wireless LAN (i.e.
Definition: gnunet_nt_lib.h:60
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
int GNUNET_OS_check_helper_binary(const char *binary, int check_suid, const char *params)
Check whether an executable exists and possibly if the suid bit is set on the file.
void GNUNET_SERVER_mst_destroy(struct GNUNET_SERVER_MessageStreamTokenizer *mst)
Destroys a tokenizer.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HELLO_Address * address
Address.
static char * helper_argv[8]
Command-line arguments we are giving to the hijacker process.
#define WLAN_LLC_DSAP_FIELD
Link layer control fields for better compatibility (i.e.
int GNUNET_SERVER_mst_receive(struct GNUNET_SERVER_MessageStreamTokenizer *mst, void *client_identity, const char *buf, size_t size, int purge, int one_shot)
Add incoming data to the receive buffer and call the callback for all complete messages.
static void wlan_data_message_handler(void *cls, const struct GNUNET_MessageHeader *hdr)
Handles the data after all fragments are put together.
u_int8_t llc[4]
Link layer control (LLC).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define IEEE80211_FC0_TYPE_DATA
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
const struct GNUNET_HELLO_Address * address
Address used by the session.
#define GNUNET_MESSAGE_TYPE_FRAGMENT_ACK
Acknowledgement of a FRAGMENT of a larger message.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
uint32_t num_msg_pending
Number of messages pending transmission for this session.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static enum GNUNET_NetworkType wlan_plugin_get_network_for_address(void *cls, const struct GNUNET_HELLO_Address *address)
Function obtain the network type for an address.
uint8_t rate
Desired transmission rate for this MAC.
#define GNUNET_NETWORK_STRUCT_BEGIN
Define as empty, GNUNET_PACKED should suffice, but this won&#39;t work on W32.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
struct GNUNET_TIME_Absolute receive_delay
Until when does this plugin refuse to receive to manage staying within the inbound quota...
struct MacEndpoint * mac_head
Head of list of open connections.
void GNUNET_FRAGMENT_context_transmission_done(struct GNUNET_FRAGMENT_Context *fc)
Continuation to call from the &#39;proc&#39; function after the fragment has been transmitted (and hence the ...
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
Format of a WLAN Control Message.
struct Plugin * plugin
Pointer to the global plugin struct.
Handle to a message stream tokenizer.
GNUNET_TRANSPORT_PluginReceiveCallback receive
Function that should be called by the transport plugin whenever a message is received.
int(* GNUNET_SERVER_MessageTokenizerCallback)(void *cls, void *client, const struct GNUNET_MessageHeader *message)
Functions with this signature are called whenever a complete message is received by the tokenizer...
Message from the WLAN helper to the plugin: we have received the given message with the given perform...
struct GNUNET_TRANSPORT_WLAN_MacAddress mac
MAC Address of the local WLAN interface.
GNUNET_TRANSPORT_UpdateSessionTimeout update_session_timeout
Function that will be called whenever the transport service wants to notify the plugin that a session...
Information about a plugin&#39;s session.
Bluetooth LAN.
Definition: gnunet_nt_lib.h:65
Fragmentation context.
Definition: fragmentation.c:41
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
struct GNUNET_ATS_Session * sessions_head
Head of sessions that use this MAC.
struct FragmentMessage * next
This is a doubly-linked list.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct GNUNET_SCHEDULER_Task * timeout_task
Timeout task (for this message).
void * cls
Closure for the various callbacks.
enum State state
current state of profiling
void GNUNET_HELPER_send_cancel(struct GNUNET_HELPER_SendHandle *sh)
Cancel a GNUNET_HELPER_send operation.
Definition: helper.c:695
void * cls
Closure for all of the callbacks.
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
void GNUNET_DEFRAGMENT_context_destroy(struct GNUNET_DEFRAGMENT_Context *dc)
Destroy the given defragmentation context.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
void(* GNUNET_TRANSPORT_AddressStringCallback)(void *cls, const char *address, int res)
Function called by the pretty printer for the resolved address for each human-readable address obtain...
GNUNET_TRANSPORT_StringToAddress string_to_address
Function that will be called to convert a string address to binary (numeric conversion only)...
char * wlan_interface
The interface of the wlan card given to us by the user.
Session handle for connections.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
The transport service will pass a pointer to a struct of this type as the first and only argument to ...
static enum GNUNET_NetworkType scope
Which network scope do we belong to?
int GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Test if we have a value for a particular option.
GNUNET_TRANSPORT_GetNetworkType get_network
Function to obtain the network type for a session.
static void wlan_plugin_disconnect_peer(void *cls, const struct GNUNET_PeerIdentity *target)
Function that can be used to force the plugin to disconnect from the given peer and cancel all previo...
static struct GNUNET_ATS_Session * get_session(struct MacEndpoint *endpoint, const struct GNUNET_PeerIdentity *peer)
Look up a session for a peer and create a new session if none is found.
static char buf[2048]
struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame frame
IEEE Frame.
void(* GNUNET_TRANSPORT_SessionInfoCallback)(void *cls, struct GNUNET_ATS_Session *session, const struct GNUNET_TRANSPORT_SessionInfo *info)
Function called by the plugin with information about the current sessions managed by the plugin (for ...
struct GNUNET_SERVER_MessageStreamTokenizer * wlan_header_payload_tokenizer
Tokenizer for demultiplexing of data packets that follow the WLAN Header.
static int result
Global testing status.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
static GNUNET_NETWORK_STRUCT_END const struct GNUNET_TRANSPORT_WLAN_MacAddress mac_bssid_gnunet
GNUnet bssid.
struct MacEndpoint * mac_tail
Tail of list of open connections.
struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame frame
IEEE Frame to transmit (the sender MAC address will be overwritten by the helper as it does not trust...
struct GNUNET_TIME_Absolute session_timeout
At what time will this session timeout (unless activity happens)?
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
GNUNET_TRANSPORT_UpdateInboundDelay update_inbound_delay
Function that will be called whenever the transport service wants to notify the plugin that the inbou...
#define GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER
Type of data messages from the plugin to the gnunet-wlan-helper.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
static char * plugin
Solver plugin name as string.
#define GNUNET_htole16(x)
int GNUNET_FRAGMENT_process_ack(struct GNUNET_FRAGMENT_Context *fc, const struct GNUNET_MessageHeader *msg)
Process an acknowledgement message we got from the other side (to control re-transmits).
struct GNUNET_PeerIdentity target
Target of the message.
struct FragmentMessage * sending_messages_head
Head of messages we are currently sending to this MAC.
struct GNUNET_SCHEDULER_Task * beacon_task
Task that periodically sends a HELLO beacon via the helper.
static void send_ack(void *cls, uint32_t msg_id, const struct GNUNET_MessageHeader *hdr)
Send an ACK for a fragment we received.
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
Defragmentation context (one per connection).
static void free_macendpoint(struct MacEndpoint *endpoint)
Free a MAC endpoint.
uint16_t tx_power
Desired transmission power for this MAC.
struct FragmentMessage * prev
This is a doubly-linked list.
struct PendingMessage * prev
This is a doubly-linked list.
Struct for messages that are being fragmented in a MAC&#39;s transmission queue.
uint16_t frame_control
802.11 Frame Control field.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
#define GNUNET_MESSAGE_TYPE_WLAN_DATA
Type of messages for data over the wlan.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_MessageHeader header
Message type is GNUNET_MESSAGE_TYPE_WLAN_DATA.
struct MacEndpoint * mac
MAC endpoint with the address of this peer.
struct GNUNET_FRAGMENT_Context * fragcontext
Fragmentation context.
static struct MacEndpoint * create_macendpoint(struct Plugin *plugin, struct WlanAddress *mac)
Find (or create) a MacEndpoint with a specific MAC address.
static void fragmentmessage_timeout(void *cls)
A FragmentMessage has timed out.
struct GNUNET_TIME_Absolute timeout
Timeout value for the message.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_ATS_Session * sessions_tail
Tail of sessions that use this MAC.
void(* GNUNET_TRANSPORT_TransmitContinuation)(void *cls, const struct GNUNET_PeerIdentity *target, int result, size_t size_payload, size_t size_on_wire)
Function called by the GNUNET_TRANSPORT_TransmitFunction upon "completion".
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void * LIBGNUNET_PLUGIN_TRANSPORT_DONE(void *cls)
Exit point from the plugin.
static struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run on timeout.
Definition: gnunet-arm.c:124
struct GNUNET_MessageHeader header
Type is &#39;GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER&#39;.
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
struct GNUNET_PeerIdentity peer
For which peer is this an address?
struct GNUNET_BANDWIDTH_Value32NBO GNUNET_BANDWIDTH_value_init(uint32_t bytes_per_second)
Create a new bandwidth value.
Definition: bandwidth.c:39
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
struct WlanAddress wlan_addr
peer MAC address
struct GNUNET_TRANSPORT_WLAN_MacAddress mac_address
The mac_address of the wlan card given to us by the helper.
struct GNUNET_TRANSPORT_WLAN_MacAddress mac
WLAN addresses using MACs.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
struct GNUNET_DEFRAGMENT_Context * defrag
Defrag context for this MAC.
struct WlanHeader * msg
The pending message.
struct FragmentMessage * sending_messages_tail
Tail of messages we are currently sending to this MAC.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don&#39;t receive messages from the peer...
#define GNUNET_NETWORK_STRUCT_END
Define as empty, GNUNET_PACKED should suffice, but this won&#39;t work on W32;.
uint16_t sequence_control
802.11 sequence control field; contains fragment number an sequence number (we set this to all zeros)...
GNUNET_TRANSPORT_QueryKeepaliveFactorFunction query_keepalive_factor
Function that is used to query keepalive factor.
The identity of the host (wraps the signing key of the peer).
No additional information.
uint16_t duration
Microseconds to reserve link (duration), 0 by default.
static const char * wlan_plugin_address_to_string(void *cls, const void *addr, size_t addrlen)
Function called for a quick conversion of the binary address to a numeric address.
size_t size_on_wire
Number of bytes used to transmit message.
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to &#39;struct&#39;s...
struct GNUNET_SCHEDULER_Task * timeout_task
Timeout task.
struct GNUNET_TIME_Relative ack_delay
ACK delay for fragmentation context.
#define GNUNET_PACKED
gcc-ism to get packed structs.
size_t size_payload
Size of original message.
#define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC
Maximum number of messages in defragmentation queue per MAC.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_PeerIdentity target
To whom are we talking to.
#define PLUGIN_NAME
generic definitions for IEEE 802.11 frames
unsigned int fragment_messages_out_count
count of messages in the fragment out queue for this mac endpoint
static void macendpoint_timeout(void *cls)
A MAC endpoint is timing out.
An address for communicating with a peer.
struct GNUNET_HELPER_SendHandle * GNUNET_HELPER_send(struct GNUNET_HELPER_Handle *h, const struct GNUNET_MessageHeader *msg, int can_drop, GNUNET_HELPER_Continuation cont, void *cont_cls)
Send an message to the helper.
Definition: helper.c:655
struct GNUNET_TIME_Relative msg_delay
Message delay for fragmentation context.
static const char * mac_to_string(const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac)
Print MAC addresses nicely.
The session was created (first call for each session object).
Entry in list of pending tasks.
Definition: scheduler.c:134
header for transport plugin and the helper for wlan
List containing all messages that are yet to be send.
uint16_t GNUNET_HELLO_size(const struct GNUNET_HELLO_Message *hello)
Return the size of the given HELLO message.
Definition: hello.c:652
char * GNUNET_OS_get_libexec_binary_path(const char *progname)
Given the name of a gnunet-helper, gnunet-service or gnunet-daemon binary, try to prefix it with the ...
static void send_hello_beacon(void *cls)
Task to (periodically) send a HELLO beacon.
struct GNUNET_TIME_Absolute timeout
When should this endpoint time out?
static int wlan_plugin_disconnect_session(void *cls, struct GNUNET_ATS_Session *session)
Free a session.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
void * cls
Closure to use for callbacks.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
GNUNET_TRANSPORT_AddressPrettyPrinter address_pretty_printer
Function to pretty-print addresses.
Header for all communications.
int GNUNET_DEFRAGMENT_process_fragment(struct GNUNET_DEFRAGMENT_Context *dc, const struct GNUNET_MessageHeader *msg)
We have received a fragment.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_TRANSPORT_WLAN_MacAddress addr3
Address 3: BSSID in ad-hoc mode, Destination if station, source if AP.
struct GNUNET_PeerIdentity target
Intended recipient.
Struct to represent one network card connection.
#define GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER
Type of data messages from the gnunet-wlan-helper to the plugin.
struct GNUNET_SCHEDULER_Task * timeout_task
Timeout task.
struct GNUNET_BANDWIDTH_Tracker tracker
Bandwidth tracker to limit global UDP traffic.
#define GNUNET_MESSAGE_TYPE_FRAGMENT
FRAGMENT of a larger message.
static const struct GNUNET_TRANSPORT_WLAN_MacAddress bc_all_mac
Broadcast MAC.
uint32_t options
Options set for the WLAN, in NBO.
static void send_with_fragmentation(struct MacEndpoint *endpoint, struct GNUNET_TIME_Relative timeout, const struct GNUNET_PeerIdentity *target, const struct GNUNET_MessageHeader *msg, size_t payload_size, GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
Transmit a message to the given destination with fragmentation.
struct GNUNET_MessageHeader * msg
Message we need to fragment and transmit, NULL after the fragmentcontext has been created...
#define GNUNET_MESSAGE_TYPE_HELLO
HELLO message with friend only flag used for communicating peer addresses.
GNUNET_TRANSPORT_CheckAddress check_address
Function that will be called to check if a binary address for this plugin is well-formed and correspo...
Information associated with a message.
GNUNET_TRANSPORT_SessionState
Possible states of a session in a plugin.
void GNUNET_FRAGMENT_context_destroy(struct GNUNET_FRAGMENT_Context *fc, struct GNUNET_TIME_Relative *msg_delay, struct GNUNET_TIME_Relative *ack_delay)
Destroy the given fragmentation context (stop calling &#39;proc&#39;, free resources).
Message from the plugin to the WLAN helper: send the given message with the given connection paramete...
static char * address
GNS address for this phone.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_TRANSPORT_WLAN_MacAddress addr2
Address 2: source address if in ad-hoc-mode or station, BSSID if AP.
#define GNUNET_HELLO_address_free(addr)
Free an address.
struct GNUNET_TRANSPORT_WLAN_MacAddress addr1
Address 1: destination address in ad-hoc mode or AP, BSSID if station,.
void * sic_cls
Closure for sic.
struct GNUNET_SERVER_MessageStreamTokenizer * GNUNET_SERVER_mst_create(GNUNET_SERVER_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
uint16_t tx_power
Transmit power expressed as unitless distance from max power set at factory calibration.
static void fragment_transmission_done(void *cls, int result)
Function called once we have successfully given the fragment message to the SUID helper process and w...
static enum GNUNET_NetworkType wlan_plugin_get_network(void *cls, struct GNUNET_ATS_Session *session)
Function obtain the network type for a session.
static struct GNUNET_ATS_Session * wlan_plugin_get_session(void *cls, const struct GNUNET_HELLO_Address *address)
Creates a new outbound session the transport service will use to send data to the peer...
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_ATS_Session * session
NULL if the identity of the other peer is not known.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
GNUNET_TRANSPORT_GetNetworkTypeForAddress get_network_for_address
Function to obtain the network type for an address.
static int process_data(void *cls, void *client, const struct GNUNET_MessageHeader *hdr)
We have received data from the WLAN via some session.
#define WLAN_MTU
Max size of packet (that we give to the WLAN driver for transmission)
static void wlan_plugin_address_pretty_printer(void *cls, const char *type, const void *addr, size_t addrlen, int numeric, struct GNUNET_TIME_Relative timeout, GNUNET_TRANSPORT_AddressStringCallback asc, void *asc_cls)
Convert the transports address to a nice, human-readable format.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
static void get_wlan_header(struct Plugin *plugin, struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *header, const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr, unsigned int size)
Generate the WLAN hardware header for one packet.