GNUnet  0.10.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 (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2)
57 
63 #define HELLO_BEACON_SCALING_FACTOR GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 2)
64 
65 
66 /* end case wlan */
67 #elif BUILD_BLUETOOTH
68 /* begin case bluetooth */
69 
70 #define PLUGIN_NAME "bluetooth"
71 #define CONFIG_NAME "transport-bluetooth"
72 #define HELPER_NAME "gnunet-helper-transport-bluetooth"
73 /* yes, this is correct, we use the same dummy driver as 'wlan' */
74 #define DUMMY_HELPER_NAME "gnunet-helper-transport-wlan-dummy"
75 #define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_bluetooth_init
76 #define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_bluetooth_done
77 #define LOG(kind,...) GNUNET_log_from (kind, "transport-bluetooth",__VA_ARGS__)
78 
82 #define MACENDPOINT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 60)
83 
84 
90 #define HELLO_BEACON_SCALING_FACTOR GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
91 
92 /* end case bluetooth */
93 #else
94 #error need to build wlan or bluetooth
95 #endif
96 
97 
98 
111 typedef int
113  void *client,
114  const struct GNUNET_MessageHeader *message);
115 
116 
117 /* Include legacy message stream tokenizer that was removed from util (for now) */
118 #include "tcp_server_mst_legacy.c"
119 
120 
124 #define WLAN_MTU 1430
125 
126 
130 #if BUILD_WLAN
131 static const enum GNUNET_NetworkType scope = GNUNET_NT_WLAN;
132 #else
133 static const enum GNUNET_NetworkType scope = GNUNET_NT_BT;
134 #endif
135 
136 
140 #define MESSAGES_IN_DEFRAG_QUEUE_PER_MAC 2
141 
146 #define WLAN_LLC_DSAP_FIELD 0x1f
147 #define WLAN_LLC_SSAP_FIELD 0x1f
148 
149 
158 {
159 
164 
168  uint32_t crc GNUNET_PACKED;
169 
174 
179 
180  /* followed by payload, possibly including
181  multiple messages! */
182 
183 };
184 
185 
190 {
195 
200 };
201 
202 
204 
205 
210 struct PendingMessage
211 {
215  struct PendingMessage *next;
216 
220  struct PendingMessage *prev;
221 
225  struct WlanHeader *msg;
226 
233 
237  void *transmit_cont_cls;
238 
243 
244 };
245 
246 
250 struct GNUNET_ATS_Session
251 {
256  struct GNUNET_PeerIdentity target;
257 
262  struct GNUNET_ATS_Session *next;
263 
268  struct GNUNET_ATS_Session *prev;
269 
273  struct MacEndpoint *mac;
274 
279 
284 
289 
290 };
291 
292 
297 {
298 
303 
308 
313 
318 
324 
328  struct GNUNET_PeerIdentity target;
329 
334 
339 
344 
350 
354  void *cont_cls;
355 
359  size_t size_payload;
360 
364  size_t size_on_wire;
365 
366 };
367 
368 
373 {
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 
462 
466 struct Plugin
467 {
472 
477 
482 
486  void *sic_cls;
487 
492  char *helper_argv[3];
493 
498 
504 
509 
514 
519 
524 
529 
533  struct GNUNET_BANDWIDTH_Tracker tracker;
534 
539 
543  int have_mac;
544 
548  unsigned int mac_count;
549 
553  uint32_t options;
554 
555 };
556 
557 
564 {
569 
574 };
575 
576 
585 static const char *
587 {
588  static char macstr[20];
589 
590  GNUNET_snprintf (macstr,
591  sizeof (macstr),
592  "%.2X:%.2X:%.2X:%.2X:%.2X:%.2X",
593  mac->mac[0], mac->mac[1],
594  mac->mac[2], mac->mac[3],
595  mac->mac[4], mac->mac[5]);
596  return macstr;
597 }
598 
599 
611 static const char *
613  const void *addr,
614  size_t addrlen)
615 {
617  static char macstr[36];
618 
619  if (sizeof (struct WlanAddress) != addrlen)
620  {
621  GNUNET_break (0);
622  return NULL;
623  }
624  mac = &((struct WlanAddress *) addr)->mac;
625  GNUNET_snprintf (macstr,
626  sizeof (macstr),
627  "%s.%u.%s",
628  PLUGIN_NAME,
629  ntohl (((struct WlanAddress *) addr)->options),
630  mac_to_string (mac));
631  return macstr;
632 }
633 
634 
643 static void
645  struct GNUNET_ATS_Session *session,
647 {
648  struct GNUNET_TRANSPORT_SessionInfo info;
649 
650  if (NULL == plugin->sic)
651  return;
652  memset (&info, 0, sizeof (info));
653  info.state = state;
654  info.is_inbound = GNUNET_SYSERR; /* hard to say */
655  info.num_msg_pending = 0; /* we queue per MAC, not per peer */
656  info.num_bytes_pending = 0; /* we queue per MAC, not per peer */
657  info.receive_delay = GNUNET_TIME_UNIT_ZERO_ABS; /* not supported by WLAN */
658  info.session_timeout = session->timeout;
659  info.address = session->address;
660  plugin->sic (plugin->sic_cls,
661  session,
662  &info);
663 }
664 
665 
673 static void
676  uint16_t size)
677 {
679  header->header.size = ntohs (size);
680  if (NULL != endpoint)
681  {
682  header->rate = endpoint->rate;
683  header->tx_power = endpoint->tx_power;
684  header->antenna = endpoint->antenna;
685  }
686  else
687  {
688  header->rate = 255;
689  header->tx_power = 0;
690  header->antenna = 0;
691  }
692 }
693 
694 
703 static void
706  const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr,
707  unsigned int size)
708 {
709  const int rate = 11000000;
710 
711  header->frame_control = htons (IEEE80211_FC0_TYPE_DATA);
712  header->addr1 = *to_mac_addr;
713  header->addr2 = plugin->mac_address;
714  header->addr3 = mac_bssid_gnunet;
715  header->duration = GNUNET_htole16 ((size * 1000000) / rate + 290);
716  header->sequence_control = 0; // FIXME?
717  header->llc[0] = WLAN_LLC_DSAP_FIELD;
718  header->llc[1] = WLAN_LLC_SSAP_FIELD;
719  header->llc[2] = 0; // FIXME?
720  header->llc[3] = 0; // FIXME?
721 }
722 
723 
731 static void
732 send_ack (void *cls,
733  uint32_t msg_id,
734  const struct GNUNET_MessageHeader *hdr)
735 {
736  struct MacEndpoint *endpoint = cls;
737  struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage* radio_header;
738  uint16_t msize = ntohs (hdr->size);
739  size_t size = sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize;
740  char buf[size];
741 
742  if (NULL == endpoint)
743  {
744  GNUNET_break (0);
745  return;
746  }
747  if (size >= GNUNET_MAX_MESSAGE_SIZE)
748  {
749  GNUNET_break (0);
750  return;
751  }
753  "Sending ACK to %s\n",
754  mac_to_string (&endpoint->wlan_addr.mac));
755  radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) buf;
756  get_radiotap_header (endpoint, radio_header, size);
757  get_wlan_header (endpoint->plugin,
758  &radio_header->frame,
759  &endpoint->wlan_addr.mac,
760  sizeof (endpoint->wlan_addr.mac));
761  GNUNET_memcpy (&radio_header[1], hdr, msize);
762  if (NULL !=
764  &radio_header->header,
765  GNUNET_NO /* dropping ACKs is bad */,
766  NULL, NULL))
767  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
768  _("# ACKs sent"),
769  1, GNUNET_NO);
770 }
771 
772 
779 static void
781  const struct GNUNET_MessageHeader *hdr)
782 {
783  struct MacEndpoint *endpoint = cls;
784  struct Plugin *plugin = endpoint->plugin;
785  struct MacAndSession mas;
786 
787  GNUNET_STATISTICS_update (plugin->env->stats,
788  _("# Messages defragmented"),
789  1,
790  GNUNET_NO);
791  mas.session = NULL;
792  mas.endpoint = endpoint;
794  &mas,
795  (const char *) hdr,
796  ntohs (hdr->size),
798 }
799 
800 
807 static int
809  struct GNUNET_ATS_Session *session)
810 {
811  struct MacEndpoint *endpoint = session->mac;
812  struct Plugin *plugin = endpoint->plugin;
813 
814  plugin->env->session_end (plugin->env->cls,
815  session->address,
816  session);
817  notify_session_monitor (plugin,
818  session,
821  endpoint->sessions_tail,
822  session);
823  if (session->timeout_task != NULL)
824  {
826  session->timeout_task = NULL;
827  }
828  GNUNET_STATISTICS_update (plugin->env->stats,
829  _("# Sessions allocated"),
830  -1,
831  GNUNET_NO);
833  GNUNET_free (session);
834  return GNUNET_OK;
835 }
836 
837 
846 static unsigned int
848 {
849  return 3;
850 }
851 
852 
858 static void
859 session_timeout (void *cls)
860 {
861  struct GNUNET_ATS_Session *session = cls;
862  struct GNUNET_TIME_Relative left;
863 
864  session->timeout_task = NULL;
866  if (0 != left.rel_value_us)
867  {
868  session->timeout_task =
871  session);
872  return;
873  }
875  session);
876 }
877 
878 
879 
887 static struct GNUNET_ATS_Session *
888 lookup_session (struct MacEndpoint *endpoint,
889  const struct GNUNET_PeerIdentity *peer)
890 {
891  struct GNUNET_ATS_Session *session;
892 
893  for (session = endpoint->sessions_head; NULL != session; session = session->next)
894  if (0 == memcmp (peer, &session->target, sizeof (struct GNUNET_PeerIdentity)))
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;
929  session->timeout_task =
931  session);
932  notify_session_monitor (endpoint->plugin,
933  session,
935  notify_session_monitor (endpoint->plugin,
936  session,
939  "Created new session %p for peer `%s' with endpoint %s\n",
940  session,
941  GNUNET_i2s (peer),
942  mac_to_string (&endpoint->wlan_addr.mac));
943 
944  return session;
945 }
946 
947 
955 static struct GNUNET_ATS_Session *
956 get_session (struct MacEndpoint *endpoint,
957  const struct GNUNET_PeerIdentity *peer)
958 {
959  struct GNUNET_ATS_Session *session;
960 
961  if (NULL != (session = lookup_session (endpoint, peer)))
962  return session;
963  return create_session (endpoint, peer);
964 }
965 
966 
977 static void
979  int result)
980 {
981  struct FragmentMessage *fm = cls;
982 
983  fm->sh = NULL;
985 }
986 
987 
994 static void
995 transmit_fragment (void *cls,
996  const struct GNUNET_MessageHeader *hdr)
997 {
998  struct FragmentMessage *fm = cls;
999  struct MacEndpoint *endpoint = fm->macendpoint;
1000  size_t size;
1001  uint16_t msize;
1002 
1003  if (NULL == endpoint)
1004  {
1005  GNUNET_break (0);
1006  return;
1007  }
1008  msize = ntohs (hdr->size);
1009  size = sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + msize;
1010  {
1011  char buf[size];
1012  struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radio_header;
1013 
1014  radio_header = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) buf;
1015  get_radiotap_header (endpoint, radio_header, size);
1017  "Sending %u bytes of data to MAC `%s'\n",
1018  (unsigned int) msize,
1019  mac_to_string (&endpoint->wlan_addr.mac));
1020 
1021  get_wlan_header (endpoint->plugin,
1022  &radio_header->frame,
1023  &endpoint->wlan_addr.mac,
1024  sizeof (endpoint->wlan_addr.mac));
1025  GNUNET_memcpy (&radio_header[1], hdr, msize);
1026  GNUNET_assert (NULL == fm->sh);
1027  fm->sh = GNUNET_HELPER_send (endpoint->plugin->suid_helper,
1028  &radio_header->header,
1029  GNUNET_NO,
1031  fm->size_on_wire += size;
1032  if (NULL != fm->sh)
1033  {
1034  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
1035  _("# message fragments sent"),
1036  1,
1037  GNUNET_NO);
1038  }
1039  else
1040  {
1042  }
1043  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
1044  "# bytes currently in buffers",
1045  -msize, GNUNET_NO);
1046  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
1047  "# bytes transmitted",
1048  msize, GNUNET_NO);
1049  }
1050 }
1051 
1052 
1058 static void
1060 {
1061  struct MacEndpoint *endpoint = fm->macendpoint;
1062 
1063  GNUNET_STATISTICS_update (endpoint->plugin->env->stats,
1064  _("# messages pending (with fragmentation)"),
1065  -1, GNUNET_NO);
1067  endpoint->sending_messages_tail,
1068  fm);
1069  if (NULL != fm->sh)
1070  {
1072  fm->sh = NULL;
1073  }
1074  if (NULL != fm->msg)
1075  {
1076  GNUNET_free (fm->msg);
1077  fm->msg = NULL;
1078  }
1079  if (NULL != fm->fragcontext)
1080  {
1082  &endpoint->msg_delay,
1083  &endpoint->ack_delay);
1084  fm->fragcontext = NULL;
1085  }
1086  if (NULL != fm->timeout_task)
1087  {
1089  fm->timeout_task = NULL;
1090  }
1091  GNUNET_free (fm);
1092 }
1093 
1094 
1100 static void
1102 {
1103  struct FragmentMessage *fm = cls;
1104 
1105  fm->timeout_task = NULL;
1106  if (NULL != fm->cont)
1107  {
1108  fm->cont (fm->cont_cls,
1109  &fm->target,
1110  GNUNET_SYSERR,
1111  fm->size_payload,
1112  fm->size_on_wire);
1113  fm->cont = NULL;
1114  }
1115  free_fragment_message (fm);
1116 }
1117 
1118 
1133 static void
1136  const struct GNUNET_PeerIdentity *target,
1137  const struct GNUNET_MessageHeader *msg,
1138  size_t payload_size,
1140  void *cont_cls)
1141 
1142 {
1143  struct FragmentMessage *fm;
1144  struct Plugin *plugin;
1145 
1146  plugin = endpoint->plugin;
1147  fm = GNUNET_new (struct FragmentMessage);
1148  fm->macendpoint = endpoint;
1149  fm->target = *target;
1150  fm->size_payload = payload_size;
1151  fm->timeout = GNUNET_TIME_relative_to_absolute (timeout);
1152  fm->cont = cont;
1153  fm->cont_cls = cont_cls;
1154  /* 1 MBit/s typical data rate, 1430 byte fragments => ~100 ms per message */
1155  fm->timeout_task =
1158  fm);
1159  if (GNUNET_YES == plugin->have_mac)
1160  {
1161  fm->fragcontext =
1162  GNUNET_FRAGMENT_context_create (plugin->env->stats,
1163  WLAN_MTU,
1164  &plugin->tracker,
1165  fm->macendpoint->msg_delay,
1166  fm->macendpoint->ack_delay,
1167  msg,
1168  &transmit_fragment, fm);
1169  }
1170  else
1171  {
1172  fm->msg = GNUNET_copy_message (msg);
1173  }
1175  endpoint->sending_messages_tail,
1176  fm);
1177 }
1178 
1179 
1185 static void
1186 free_macendpoint (struct MacEndpoint *endpoint)
1187 {
1188  struct Plugin *plugin = endpoint->plugin;
1189  struct FragmentMessage *fm;
1190  struct GNUNET_ATS_Session *session;
1191 
1192  GNUNET_STATISTICS_update (plugin->env->stats,
1193  _("# MAC endpoints allocated"),
1194  -1,
1195  GNUNET_NO);
1196  while (NULL != (session = endpoint->sessions_head))
1198  session);
1199  while (NULL != (fm = endpoint->sending_messages_head))
1200  free_fragment_message (fm);
1202  plugin->mac_tail,
1203  endpoint);
1204 
1205  if (NULL != endpoint->defrag)
1206  {
1208  endpoint->defrag = NULL;
1209  }
1210 
1211  plugin->mac_count--;
1212  if (NULL != endpoint->timeout_task)
1213  {
1215  endpoint->timeout_task = NULL;
1216  }
1217  GNUNET_free (endpoint);
1218 }
1219 
1220 
1226 static void
1228 {
1229  struct MacEndpoint *endpoint = cls;
1230  struct GNUNET_TIME_Relative timeout;
1231 
1232  endpoint->timeout_task = NULL;
1233  timeout = GNUNET_TIME_absolute_get_remaining (endpoint->timeout);
1234  if (0 == timeout.rel_value_us)
1235  {
1236  free_macendpoint (endpoint);
1237  return;
1238  }
1239  endpoint->timeout_task =
1242  endpoint);
1243 }
1244 
1245 
1253 static struct MacEndpoint *
1255  struct WlanAddress *mac)
1256 {
1257  struct MacEndpoint *pos;
1258 
1259  for (pos = plugin->mac_head; NULL != pos; pos = pos->next)
1260  if (0 == memcmp (mac, &pos->wlan_addr, sizeof (pos->wlan_addr)))
1261  return pos;
1262  pos = GNUNET_new (struct MacEndpoint);
1263  pos->wlan_addr = (*mac);
1264  pos->plugin = plugin;
1265  pos->defrag =
1266  GNUNET_DEFRAGMENT_context_create (plugin->env->stats,
1267  WLAN_MTU,
1269  pos,
1271  &send_ack);
1272 
1275  pos->timeout = GNUNET_TIME_relative_to_absolute (MACENDPOINT_TIMEOUT);
1276  pos->timeout_task =
1277  GNUNET_SCHEDULER_add_delayed (MACENDPOINT_TIMEOUT, &macendpoint_timeout,
1278  pos);
1280  plugin->mac_tail,
1281  pos);
1282  plugin->mac_count++;
1283  GNUNET_STATISTICS_update (plugin->env->stats,
1284  _("# MAC endpoints allocated"),
1285  1, GNUNET_NO);
1287  "New MAC endpoint `%s'\n",
1289  &pos->wlan_addr,
1290  sizeof (struct WlanAddress)));
1291  return pos;
1292 }
1293 
1294 
1302 static enum GNUNET_NetworkType
1304  struct GNUNET_ATS_Session *session)
1305 {
1306 #if BUILD_WLAN
1307  return GNUNET_NT_WLAN;
1308 #else
1309  return GNUNET_NT_BT;
1310 #endif
1311 }
1312 
1313 
1321 static enum GNUNET_NetworkType
1323  const struct GNUNET_HELLO_Address *address)
1324 {
1325 #if BUILD_WLAN
1326  return GNUNET_NT_WLAN;
1327 #else
1328  return GNUNET_NT_BT;
1329 #endif
1330 }
1331 
1332 
1341 static struct GNUNET_ATS_Session *
1343  const struct GNUNET_HELLO_Address *address)
1344 {
1345  struct Plugin *plugin = cls;
1346  struct MacEndpoint *endpoint;
1347 
1348  if (NULL == address)
1349  return NULL;
1350  if (sizeof (struct WlanAddress) != address->address_length)
1351  {
1352  GNUNET_break (0);
1353  return NULL;
1354  }
1356  "Service asked to create session for peer `%s' with MAC `%s'\n",
1357  GNUNET_i2s (&address->peer),
1359  address->address,
1360  address->address_length));
1361  endpoint = create_macendpoint (plugin,
1362  (struct WlanAddress *) address->address);
1363  return get_session (endpoint, &address->peer);
1364 }
1365 
1366 
1375 static void
1377  const struct GNUNET_PeerIdentity *target)
1378 {
1379  struct Plugin *plugin = cls;
1380  struct GNUNET_ATS_Session *session;
1381  struct MacEndpoint *endpoint;
1382 
1383  for (endpoint = plugin->mac_head; NULL != endpoint; endpoint = endpoint->next)
1384  for (session = endpoint->sessions_head; NULL != session; session = session->next)
1385  if (0 == memcmp (target, &session->target,
1386  sizeof (struct GNUNET_PeerIdentity)))
1387  {
1388  wlan_plugin_disconnect_session (plugin, session);
1389  break; /* inner-loop only (in case peer has another MAC as well!) */
1390  }
1391 }
1392 
1393 
1421 static ssize_t
1422 wlan_plugin_send (void *cls,
1423  struct GNUNET_ATS_Session *session,
1424  const char *msgbuf, size_t msgbuf_size,
1425  unsigned int priority,
1426  struct GNUNET_TIME_Relative to,
1427  GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
1428 {
1429  struct Plugin *plugin = cls;
1430  struct WlanHeader *wlanheader;
1431  size_t size = msgbuf_size + sizeof (struct WlanHeader);
1432  char buf[size] GNUNET_ALIGN;
1433 
1435  "Transmitting %u bytes of payload to peer `%s' (starting with %u byte message of type %u)\n",
1436  msgbuf_size,
1437  GNUNET_i2s (&session->target),
1438  (unsigned int) ntohs (((struct GNUNET_MessageHeader*)msgbuf)->size),
1439  (unsigned int) ntohs (((struct GNUNET_MessageHeader*)msgbuf)->type));
1440  wlanheader = (struct WlanHeader *) buf;
1441  wlanheader->header.size = htons (msgbuf_size + sizeof (struct WlanHeader));
1442  wlanheader->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA);
1443  wlanheader->sender = *plugin->env->my_identity;
1444  wlanheader->target = session->target;
1445  wlanheader->crc = htonl (GNUNET_CRYPTO_crc32_n (msgbuf, msgbuf_size));
1446  GNUNET_memcpy (&wlanheader[1],
1447  msgbuf,
1448  msgbuf_size);
1449  GNUNET_STATISTICS_update (plugin->env->stats,
1450  "# bytes currently in buffers",
1451  msgbuf_size,
1452  GNUNET_NO);
1453  send_with_fragmentation (session->mac,
1454  to,
1455  &session->target,
1456  &wlanheader->header,
1457  msgbuf_size,
1458  cont, cont_cls);
1459  return size;
1460 }
1461 
1462 
1471 static int
1472 process_data (void *cls,
1473  void *client,
1474  const struct GNUNET_MessageHeader *hdr)
1475 {
1476  struct Plugin *plugin = cls;
1477  struct GNUNET_HELLO_Address *address;
1478  struct MacAndSession *mas = client;
1479  struct FragmentMessage *fm;
1480  struct GNUNET_PeerIdentity tmpsource;
1481  const struct WlanHeader *wlanheader;
1482  int ret;
1483  uint16_t msize;
1484 
1485  msize = ntohs (hdr->size);
1486 
1487  GNUNET_STATISTICS_update (plugin->env->stats,
1488  "# bytes received",
1489  msize, GNUNET_NO);
1490 
1491  switch (ntohs (hdr->type))
1492  {
1494 
1495  if (GNUNET_OK !=
1496  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) hdr,
1497  &tmpsource))
1498  {
1499  GNUNET_break_op (0);
1500  break;
1501  }
1502  if (NULL == mas->endpoint)
1503  {
1504  GNUNET_break (0);
1505  break;
1506  }
1507 
1509  "Processing %u bytes of HELLO from peer `%s' at MAC %s\n",
1510  (unsigned int) msize,
1511  GNUNET_i2s (&tmpsource),
1513  &mas->endpoint->wlan_addr,
1514  sizeof (mas->endpoint->wlan_addr)));
1515 
1516  GNUNET_STATISTICS_update (plugin->env->stats,
1517  _("# HELLO messages received"), 1,
1518  GNUNET_NO);
1519  address = GNUNET_HELLO_address_allocate (&tmpsource,
1520  PLUGIN_NAME,
1521  &mas->endpoint->wlan_addr,
1522  sizeof (mas->endpoint->wlan_addr),
1524  mas->session = lookup_session (mas->endpoint,
1525  &tmpsource);
1526  if (NULL == mas->session)
1527  {
1528  mas->session = create_session (mas->endpoint,
1529  &tmpsource);
1530  plugin->env->session_start (plugin->env->cls,
1531  address,
1532  mas->session,
1533  scope);
1534  }
1535  plugin->env->receive (plugin->env->cls,
1536  address,
1537  mas->session,
1538  hdr);
1539  GNUNET_HELLO_address_free (address);
1540  break;
1542  if (NULL == mas->endpoint)
1543  {
1544  GNUNET_break (0);
1545  break;
1546  }
1548  "Processing %u bytes of FRAGMENT from MAC %s\n",
1549  (unsigned int) msize,
1551  &mas->endpoint->wlan_addr,
1552  sizeof (mas->endpoint->wlan_addr)));
1553  GNUNET_STATISTICS_update (plugin->env->stats,
1554  _("# fragments received"),
1555  1,
1556  GNUNET_NO);
1558  hdr);
1559  break;
1561  if (NULL == mas->endpoint)
1562  {
1563  GNUNET_break (0);
1564  break;
1565  }
1566  GNUNET_STATISTICS_update (plugin->env->stats,
1567  _("# ACKs received"),
1568  1, GNUNET_NO);
1569  for (fm = mas->endpoint->sending_messages_head; NULL != fm; fm = fm->next)
1570  {
1571  ret = GNUNET_FRAGMENT_process_ack (fm->fragcontext, hdr);
1572  if (GNUNET_OK == ret)
1573  {
1575  "Got last ACK, finished message transmission to `%s' (%p)\n",
1577  &mas->endpoint->wlan_addr,
1578  sizeof (mas->endpoint->wlan_addr)),
1579  fm);
1580  mas->endpoint->timeout = GNUNET_TIME_relative_to_absolute (MACENDPOINT_TIMEOUT);
1581  if (NULL != fm->cont)
1582  {
1583  fm->cont (fm->cont_cls,
1584  &fm->target,
1585  GNUNET_OK,
1586  fm->size_payload,
1587  fm->size_on_wire);
1588  fm->cont = NULL;
1589  }
1590  free_fragment_message (fm);
1591  break;
1592  }
1593  if (GNUNET_NO == ret)
1594  {
1596  "Got an ACK, message transmission to `%s' not yet finished\n",
1598  &mas->endpoint->wlan_addr,
1599  sizeof (mas->endpoint->wlan_addr)));
1600  break;
1601  }
1602  }
1603  if (NULL == fm)
1605  "ACK not matched against any active fragmentation with MAC `%s'\n",
1607  &mas->endpoint->wlan_addr,
1608  sizeof (mas->endpoint->wlan_addr)));
1609  break;
1611  if (NULL == mas->endpoint)
1612  {
1613  GNUNET_break (0);
1614  break;
1615  }
1616  if (msize < sizeof (struct WlanHeader))
1617  {
1618  GNUNET_break (0);
1619  break;
1620  }
1621  wlanheader = (const struct WlanHeader *) hdr;
1622  if (0 != memcmp (&wlanheader->target,
1623  plugin->env->my_identity,
1624  sizeof (struct GNUNET_PeerIdentity)))
1625  {
1627  "Data for `%s', not for me, ignoring\n",
1628  GNUNET_i2s (&wlanheader->target));
1629  break;
1630  }
1631  if (ntohl (wlanheader->crc) !=
1632  GNUNET_CRYPTO_crc32_n (&wlanheader[1],
1633  msize - sizeof (struct WlanHeader)))
1634  {
1635  GNUNET_STATISTICS_update (plugin->env->stats,
1636  _("# DATA messages discarded due to CRC32 error"),
1637  1,
1638  GNUNET_NO);
1639  break;
1640  }
1641  mas->session = lookup_session (mas->endpoint,
1642  &wlanheader->sender);
1643  if (NULL == mas->session)
1644  {
1645  mas->session = create_session (mas->endpoint,
1646  &wlanheader->sender);
1647  address = GNUNET_HELLO_address_allocate (&wlanheader->sender,
1648  PLUGIN_NAME,
1649  &mas->endpoint->wlan_addr,
1650  sizeof (struct WlanAddress),
1652  plugin->env->session_start (plugin->env->cls,
1653  address,
1654  mas->session,
1655  scope);
1657  "Notifying transport about peer `%s''s new session %p \n",
1658  GNUNET_i2s (&wlanheader->sender),
1659  mas->session);
1660  GNUNET_HELLO_address_free (address);
1661  }
1663  "Processing %u bytes of DATA from peer `%s'\n",
1664  (unsigned int) msize,
1665  GNUNET_i2s (&wlanheader->sender));
1668  mas,
1669  (const char *) &wlanheader[1],
1670  msize - sizeof (struct WlanHeader),
1671  GNUNET_YES,
1672  GNUNET_NO);
1673  break;
1674  default:
1675  if (NULL == mas->endpoint)
1676  {
1677  GNUNET_break (0);
1678  break;
1679  }
1680  if (NULL == mas->session)
1681  {
1682  GNUNET_break (0);
1683  break;
1684  }
1686  "Received packet with %u bytes of type %u from peer %s\n",
1687  (unsigned int) msize,
1688  (unsigned int) ntohs (hdr->type),
1689  GNUNET_i2s (&mas->session->target));
1690  plugin->env->receive (plugin->env->cls,
1691  mas->session->address,
1692  mas->session,
1693  hdr);
1694  break;
1695  }
1696  return GNUNET_OK;
1697 }
1698 
1699 
1705 static void
1707 {
1708  struct Plugin *plugin = cls;
1709  uint16_t size;
1710  uint16_t hello_size;
1711  struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *radioHeader;
1712  const struct GNUNET_MessageHeader *hello;
1713 
1714  hello = plugin->env->get_our_hello ();
1715  if (NULL != hello)
1716  {
1717  hello_size = GNUNET_HELLO_size ((struct GNUNET_HELLO_Message *) hello);
1718  GNUNET_assert (sizeof (struct WlanHeader) + hello_size <= WLAN_MTU);
1719  size = sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + hello_size;
1720  {
1721  char buf[size] GNUNET_ALIGN;
1722 
1724  "Sending %u byte HELLO beacon\n",
1725  (unsigned int) size);
1726  radioHeader = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage*) buf;
1727  get_radiotap_header (NULL, radioHeader, size);
1729  "Broadcasting %u bytes of data to MAC `%s'\n",
1730  (unsigned int) size,
1732  get_wlan_header (plugin, &radioHeader->frame, &bc_all_mac, size);
1733  GNUNET_memcpy (&radioHeader[1], hello, hello_size);
1734  if (NULL !=
1736  &radioHeader->header,
1737  GNUNET_YES /* can drop */,
1738  NULL, NULL))
1739  GNUNET_STATISTICS_update (plugin->env->stats,
1740  _("# HELLO beacons sent"),
1741  1, GNUNET_NO);
1742  } }
1743  plugin->beacon_task =
1745  (HELLO_BEACON_SCALING_FACTOR,
1746  plugin->mac_count + 1),
1748  plugin);
1749 
1750 }
1751 
1752 
1759 static int
1761  const struct GNUNET_MessageHeader *hdr)
1762 {
1763  struct Plugin *plugin = cls;
1764  struct GNUNET_HELLO_Address *my_address;
1765  const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rxinfo;
1767  struct WlanAddress wa;
1768  struct MacAndSession mas;
1769  uint16_t msize;
1770  struct FragmentMessage *fm;
1771  struct MacEndpoint *endpoint;
1772 
1773  msize = ntohs (hdr->size);
1774  switch (ntohs (hdr->type))
1775  {
1777  if (msize != sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage))
1778  {
1779  GNUNET_break (0);
1780  break;
1781  }
1782  cm = (const struct GNUNET_TRANSPORT_WLAN_HelperControlMessage *) hdr;
1783  if (GNUNET_YES == plugin->have_mac)
1784  {
1785  if (0 == memcmp (&plugin->mac_address,
1786  &cm->mac,
1787  sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)))
1788  break; /* no change */
1789  /* remove old address */
1790  memset (&wa, 0, sizeof (struct WlanAddress));
1791  wa.mac = plugin->mac_address;
1792  wa.options = htonl(plugin->options);
1793  my_address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
1794  PLUGIN_NAME,
1795  &wa, sizeof (wa),
1797  plugin->env->notify_address (plugin->env->cls,
1798  GNUNET_NO,
1799  my_address);
1800  GNUNET_HELLO_address_free (my_address);
1801  plugin->mac_address = cm->mac;
1802  }
1803  else
1804  {
1805  plugin->mac_address = cm->mac;
1806  plugin->have_mac = GNUNET_YES;
1807  for (endpoint = plugin->mac_head; NULL != endpoint; endpoint = endpoint->next)
1808  {
1809  for (fm = endpoint->sending_messages_head; NULL != fm; fm = fm->next)
1810  {
1811  if (NULL != fm->fragcontext)
1812  {
1813  GNUNET_break (0); /* should not happen */
1814  continue;
1815  }
1816  fm->fragcontext =
1817  GNUNET_FRAGMENT_context_create (plugin->env->stats,
1818  WLAN_MTU,
1819  &plugin->tracker,
1820  fm->macendpoint->msg_delay,
1821  fm->macendpoint->ack_delay,
1822  fm->msg,
1823  &transmit_fragment, fm);
1824  GNUNET_free (fm->msg);
1825  fm->msg = NULL;
1826  }
1827  }
1828  GNUNET_break (NULL == plugin->beacon_task);
1830  plugin);
1831 
1832  }
1833 
1834  memset (&wa, 0, sizeof (struct WlanAddress));
1835  wa.mac = plugin->mac_address;
1836  wa.options = htonl(plugin->options);
1837  my_address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
1838  PLUGIN_NAME,
1839  &wa, sizeof (wa),
1841 
1843  "Received WLAN_HELPER_CONTROL message with MAC address `%s' for peer `%s'\n",
1844  mac_to_string (&cm->mac),
1845  GNUNET_i2s (plugin->env->my_identity));
1846  plugin->env->notify_address (plugin->env->cls,
1847  GNUNET_YES,
1848  my_address);
1849  GNUNET_HELLO_address_free (my_address);
1850  break;
1853  "Got data message from helper with %u bytes\n",
1854  msize);
1855  GNUNET_STATISTICS_update (plugin->env->stats,
1856  _("# DATA messages received"), 1,
1857  GNUNET_NO);
1858  if (msize < sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage))
1859  {
1861  "Size of packet is too small (%u bytes < %u)\n",
1862  msize, sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage));
1863  break;
1864  }
1865  rxinfo = (const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) hdr;
1866 
1867  /* check if message is actually for us */
1868  if (0 != memcmp (&rxinfo->frame.addr3, &mac_bssid_gnunet,
1869  sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)))
1870  {
1871  /* Not the GNUnet BSSID */
1872  break;
1873  }
1874  if ( (0 != memcmp (&rxinfo->frame.addr1, &bc_all_mac,
1875  sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) &&
1876  (0 != memcmp (&rxinfo->frame.addr1, &plugin->mac_address,
1877  sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress))) )
1878  {
1879  /* Neither broadcast nor specifically for us */
1880  break;
1881  }
1882  if (0 == memcmp (&rxinfo->frame.addr2, &plugin->mac_address,
1883  sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)))
1884  {
1885  /* packet is FROM us, thus not FOR us */
1886  break;
1887  }
1888 
1889  GNUNET_STATISTICS_update (plugin->env->stats,
1890  _("# DATA messages processed"),
1891  1, GNUNET_NO);
1893  "Receiving %u bytes of data from MAC `%s'\n",
1894  (unsigned int) (msize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)),
1895  mac_to_string (&rxinfo->frame.addr2));
1897  "Receiving %u bytes of data to MAC `%s'\n",
1898  (unsigned int) (msize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)),
1899  mac_to_string (&rxinfo->frame.addr1));
1901  "Receiving %u bytes of data with BSSID MAC `%s'\n",
1902  (unsigned int) (msize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage)),
1903  mac_to_string (&rxinfo->frame.addr3));
1904  wa.mac = rxinfo->frame.addr2;
1905  wa.options = htonl (0);
1906  mas.endpoint = create_macendpoint (plugin, &wa);
1907  mas.session = NULL;
1909  &mas,
1910  (const char*) &rxinfo[1],
1911  msize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage),
1912  GNUNET_YES, GNUNET_NO);
1913  break;
1914  default:
1915  GNUNET_break (0);
1917  "Unexpected message of type %u (%u bytes)",
1918  ntohs (hdr->type),
1919  ntohs (hdr->size));
1920  break;
1921  }
1922  return GNUNET_OK;
1923 }
1924 
1925 
1938 static int
1940  const void *addr,
1941  size_t addrlen)
1942 {
1943  struct Plugin *plugin = cls;
1944  struct WlanAddress *wa = (struct WlanAddress *) addr;
1945 
1946  if (addrlen != sizeof (struct WlanAddress))
1947  {
1948  GNUNET_break_op (0);
1949  return GNUNET_SYSERR;
1950  }
1951  if (GNUNET_YES != plugin->have_mac)
1952  {
1954  "Rejecting MAC `%s': I don't know my MAC!\n",
1955  mac_to_string (addr));
1956  return GNUNET_NO; /* don't know my MAC */
1957  }
1958  if (0 != memcmp (&wa->mac,
1959  &plugin->mac_address,
1960  sizeof (wa->mac)))
1961  {
1963  "Rejecting MAC `%s': not my MAC!\n",
1964  mac_to_string (addr));
1965  return GNUNET_NO; /* not my MAC */
1966  }
1967  return GNUNET_OK;
1968 }
1969 
1970 
1984 static void
1986  const char *type,
1987  const void *addr,
1988  size_t addrlen,
1989  int numeric,
1992  void *asc_cls)
1993 {
1994  const char *ret;
1995 
1996  if (sizeof (struct WlanAddress) == addrlen)
1997  ret = wlan_plugin_address_to_string (NULL,
1998  addr,
1999  addrlen);
2000  else
2001  ret = NULL;
2002  asc (asc_cls,
2003  ret,
2004  (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
2005  asc (asc_cls, NULL, GNUNET_OK);
2006 }
2007 
2008 
2014 void *
2016 {
2017  struct WlanAddress wa;
2018  struct GNUNET_HELLO_Address *address;
2019  struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
2020  struct Plugin *plugin = api->cls;
2021  struct MacEndpoint *endpoint;
2022  struct MacEndpoint *endpoint_next;
2023 
2024  if (NULL == plugin)
2025  {
2026  GNUNET_free (api);
2027  return NULL;
2028  }
2029  if (GNUNET_YES == plugin->have_mac)
2030  {
2031  memset (&wa, 0, sizeof(wa));
2032  wa.options = htonl (plugin->options);
2033  wa.mac = plugin->mac_address;
2034  address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
2035  PLUGIN_NAME,
2036  &wa, sizeof (struct WlanAddress),
2038 
2039  plugin->env->notify_address (plugin->env->cls,
2040  GNUNET_NO,
2041  address);
2042  plugin->have_mac = GNUNET_NO;
2043  GNUNET_HELLO_address_free (address);
2044  }
2045 
2046  if (NULL != plugin->beacon_task)
2047  {
2049  plugin->beacon_task = NULL;
2050  }
2051  if (NULL != plugin->suid_helper)
2052  {
2054  GNUNET_NO);
2055  plugin->suid_helper = NULL;
2056  }
2057  endpoint_next = plugin->mac_head;
2058  while (NULL != (endpoint = endpoint_next))
2059  {
2060  endpoint_next = endpoint->next;
2061  free_macendpoint (endpoint);
2062  }
2063  if (NULL != plugin->fragment_data_tokenizer)
2064  {
2066  plugin->fragment_data_tokenizer = NULL;
2067  }
2068  if (NULL != plugin->wlan_header_payload_tokenizer)
2069  {
2071  plugin->wlan_header_payload_tokenizer = NULL;
2072  }
2073  if (NULL != plugin->helper_payload_tokenizer)
2074  {
2076  plugin->helper_payload_tokenizer = NULL;
2077  }
2079  GNUNET_free (plugin);
2080  GNUNET_free (api);
2081  return NULL;
2082 }
2083 
2084 
2097 static int
2099  const char *addr,
2100  uint16_t addrlen,
2101  void **buf,
2102  size_t *added)
2103 {
2104  struct WlanAddress *wa;
2105  unsigned int a[6];
2106  unsigned int i;
2107  char plugin[5];
2108  uint32_t options;
2109 
2110  if ((NULL == addr) || (0 == addrlen))
2111  {
2112  GNUNET_break (0);
2113  return GNUNET_SYSERR;
2114  }
2115  if ('\0' != addr[addrlen - 1])
2116  {
2117  GNUNET_break (0);
2118  return GNUNET_SYSERR;
2119  }
2120  if (strlen (addr) != addrlen - 1)
2121  {
2122  GNUNET_break (0);
2123  return GNUNET_SYSERR;
2124  }
2125 
2126  if (8 != SSCANF (addr,
2127  "%4s.%u.%X:%X:%X:%X:%X:%X",
2128  plugin, &options,
2129  &a[0], &a[1], &a[2],
2130  &a[3], &a[4], &a[5]))
2131  {
2132  GNUNET_break (0);
2133  return GNUNET_SYSERR;
2134  }
2135  wa = GNUNET_new (struct WlanAddress);
2136  for (i=0;i<6;i++)
2137  wa->mac.mac[i] = a[i];
2138  wa->options = htonl (0);
2139  *buf = wa;
2140  *added = sizeof (struct WlanAddress);
2141  return GNUNET_OK;
2142 }
2143 
2144 
2157 static void
2160  void *sic_cls)
2161 {
2162  struct Plugin *plugin = cls;
2163  struct MacEndpoint *mac;
2164  struct GNUNET_ATS_Session *session;
2165 
2166  plugin->sic = sic;
2167  plugin->sic_cls = sic_cls;
2168  if (NULL != sic)
2169  {
2170  for (mac = plugin->mac_head; NULL != mac; mac = mac->next)
2171  for (session = mac->sessions_head; NULL != session; session = session->next)
2172  {
2173  notify_session_monitor (plugin,
2174  session,
2176  notify_session_monitor (plugin,
2177  session,
2179  }
2180  sic (sic_cls, NULL, NULL);
2181  }
2182 }
2183 
2184 
2185 
2195 static void
2197  const struct GNUNET_PeerIdentity *peer,
2198  struct GNUNET_ATS_Session *session)
2199 {
2200  GNUNET_assert (NULL != session->timeout_task);
2202 }
2203 
2204 
2215 static void
2217  const struct GNUNET_PeerIdentity *peer,
2218  struct GNUNET_ATS_Session *session,
2219  struct GNUNET_TIME_Relative delay)
2220 {
2221  /* does nothing, as inbound delay is not supported by WLAN */
2222 }
2223 
2224 
2231 void *
2233 {
2236  struct Plugin *plugin;
2237  char *wlan_interface;
2238  unsigned long long testmode;
2239  char *binary;
2240 
2241  /* check for 'special' mode */
2242  if (NULL == env->receive)
2243  {
2244  /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
2245  initialze the plugin or the API */
2247  api->cls = NULL;
2251  return api;
2252  }
2253 
2254  testmode = 0;
2255  /* check configuration */
2256  if ( (GNUNET_YES ==
2258  CONFIG_NAME,
2259  "TESTMODE")) &&
2260  ( (GNUNET_SYSERR ==
2262  CONFIG_NAME,
2263  "TESTMODE",
2264  &testmode)) ||
2265  (testmode > 2) ) )
2266  {
2268  CONFIG_NAME,
2269  "TESTMODE");
2270  return NULL;
2271  }
2272  binary = GNUNET_OS_get_libexec_binary_path (HELPER_NAME);
2273  if ( (0 == testmode) &&
2274  (GNUNET_YES !=
2276  GNUNET_YES,
2277  NULL)) )
2278  {
2280  _("Helper binary `%s' not SUID, cannot run WLAN transport\n"),
2281  HELPER_NAME);
2282  GNUNET_free (binary);
2283  return NULL;
2284  }
2285  GNUNET_free (binary);
2286  if (GNUNET_YES !=
2288  CONFIG_NAME,
2289  "INTERFACE",
2290  &wlan_interface))
2291  {
2293  CONFIG_NAME,
2294  "INTERFACE");
2295  return NULL;
2296  }
2297 
2298  plugin = GNUNET_new (struct Plugin);
2299  plugin->wlan_interface = wlan_interface;
2300  plugin->env = env;
2301  GNUNET_STATISTICS_set (plugin->env->stats,
2302  _("# sessions allocated"),
2303  0, GNUNET_NO);
2304  GNUNET_STATISTICS_set (plugin->env->stats,
2305  _("# MAC endpoints allocated"),
2306  0, 0);
2307  GNUNET_BANDWIDTH_tracker_init (&plugin->tracker, NULL, NULL,
2308  GNUNET_BANDWIDTH_value_init (100 * 1024 *
2309  1024 / 8),
2310  100);
2312  plugin);
2314  plugin);
2316  plugin);
2317 
2318  plugin->options = 0;
2319 
2320  /* some compilers do not like switch on 'long long'... */
2321  switch ((unsigned int) testmode)
2322  {
2323  case 0: /* normal */
2324  plugin->helper_argv[0] = (char *) HELPER_NAME;
2325  plugin->helper_argv[1] = wlan_interface;
2326  plugin->helper_argv[2] = NULL;
2328  HELPER_NAME,
2329  plugin->helper_argv,
2331  NULL,
2332  plugin);
2333  break;
2334  case 1: /* testmode, peer 1 */
2335  plugin->helper_argv[0] = (char *) DUMMY_HELPER_NAME;
2336  plugin->helper_argv[1] = (char *) "1";
2337  plugin->helper_argv[2] = NULL;
2339  DUMMY_HELPER_NAME,
2340  plugin->helper_argv,
2342  NULL,
2343  plugin);
2344  break;
2345  case 2: /* testmode, peer 2 */
2346  plugin->helper_argv[0] = (char *) DUMMY_HELPER_NAME;
2347  plugin->helper_argv[1] = (char *) "2";
2348  plugin->helper_argv[2] = NULL;
2350  DUMMY_HELPER_NAME,
2351  plugin->helper_argv,
2353  NULL,
2354  plugin);
2355  break;
2356  default:
2357  GNUNET_assert (0);
2358  }
2359 
2361  api->cls = plugin;
2362  api->send = &wlan_plugin_send;
2376  return api;
2377 }
2378 
2379 
2380 /* 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:668
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:105
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:80
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:491
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...
#define LOG(kind,...)
Definition: arm_api.c:33
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:245
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 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:569
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
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:81
static int numeric
Option -n.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#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:208
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...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Information about a plugin&#39;s session.
Bluetooth LAN.
Definition: gnunet_nt_lib.h:65
Fragmentation context.
Definition: fragmentation.c:40
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:1246
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:701
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:114
void * cls
Closure for all of the callbacks.
#define GNUNET_memcpy(dst, src, n)
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.
Information about ongoing sessions of the transport client.
#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:1273
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:439
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.
#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:79
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:119
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.
#define SSCANF
Definition: plibc.h:691
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:660
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:649
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:80
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:965
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.