GNUnet  0.11.x
gnunet-service-transport.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2010-2016 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  */
25 #include "platform.h"
26 #include "gnunet_util_lib.h"
27 #include "gnunet_hello_lib.h"
31 #include "gnunet_ats_service.h"
39 #include "transport.h"
40 
44 #define TRANSPORT_BLACKLIST_HT_SIZE 64
45 
58 #define MAX_PENDING (128 * 1024)
59 
60 
65 {
70 
75 
80 
85 
90 };
91 
92 
97 {
101  CT_NONE = 0,
102 
106  CT_CORE = 1,
107 
112 
117 
122 };
123 
124 
128 struct GST_BlacklistCheck;
129 
133 struct TransportClient
134 {
138  struct TransportClient *next;
139 
143  struct TransportClient *prev;
144 
148  struct GNUNET_SERVICE_Client *client;
149 
153  struct GNUNET_MQ_Handle *mq;
154 
158  enum ClientType type;
159 
160  union
161  {
167  struct GNUNET_PeerIdentity monitor_peer;
168 
172  struct
173  {
179 
184 
189  } blacklist;
190  } details;
191 };
192 
193 
198 {
203 
208 
213 
218 
222  void *cont_cls;
223 
228 
233 
238 
243 };
244 
245 
250 {
255 
260 
265 };
266 
267 
272 {
277 
281  struct GNUNET_PeerIdentity target;
282 
286  struct GNUNET_TIME_Absolute send_time;
287 
291  unsigned long long uuid;
292 
298  int down;
299 };
300 
301 
306 
311 
319 
324 
329 
334 
339 
345 
351 
357 
363 
368 
373 
378 
383 
388 
393 
398 
403 
408 
413 
418 
426 static void
428  const struct GNUNET_MessageHeader *msg,
429  int may_drop)
430 {
431  struct GNUNET_MQ_Envelope *env;
432 
433  if ((GNUNET_MQ_get_length (tc->mq) >= MAX_PENDING) &&
434  (GNUNET_YES == may_drop))
435  {
436  GNUNET_log (
438  "Dropping message of type %u and size %u, have %u/%u messages pending\n",
439  ntohs (msg->type),
440  ntohs (msg->size),
441  GNUNET_MQ_get_length (tc->mq),
442  MAX_PENDING);
443  GNUNET_STATISTICS_update (GST_stats,
444  gettext_noop (
445  "# messages dropped due to slow client"),
446  1,
447  GNUNET_NO);
448  return;
449  }
450  env = GNUNET_MQ_msg_copy (msg);
451  GNUNET_MQ_send (tc->mq, env);
452 }
453 
454 
464 static void *
465 client_connect_cb (void *cls,
466  struct GNUNET_SERVICE_Client *client,
467  struct GNUNET_MQ_Handle *mq)
468 {
469  struct TransportClient *tc;
470 
471  tc = GNUNET_new (struct TransportClient);
472  tc->client = client;
473  tc->mq = mq;
474  GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc);
475  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", tc);
476  return tc;
477 }
478 
479 
485 static void
486 do_blacklist_check (void *cls);
487 
488 
498 static int
499 mark_match_down (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
500 {
501  struct TransportClient *tc = cls;
502  struct SendTransmitContinuationContext *stcc = value;
503 
504  if (tc == stcc->tc)
505  {
506  stcc->down = GNUNET_YES;
507  stcc->tc = NULL;
508  }
509  return GNUNET_OK;
510 }
511 
512 
521 static void
523  struct GNUNET_SERVICE_Client *client,
524  void *app_ctx)
525 {
526  struct TransportClient *tc = app_ctx;
527  struct GST_BlacklistCheck *bc;
528 
530  "Client %p disconnected, cleaning up.\n",
531  tc);
533  for (struct AddressToStringContext *cur = a2s_head; NULL != cur;
534  cur = cur->next)
535  {
536  if (cur->tc == tc)
537  cur->tc = NULL;
538  }
539  GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc);
540  switch (tc->type)
541  {
542  case CT_NONE:
543  break;
544 
545  case CT_CORE:
546  break;
547 
548  case CT_MONITOR:
549  break;
550 
551  case CT_BLACKLIST:
552  for (bc = bc_head; NULL != bc; bc = bc->next)
553  {
554  if (bc->bl_pos != tc)
555  continue;
556  bc->bl_pos = tc->next;
557  if (NULL == bc->task)
559  }
560  break;
561 
562  case CT_CORE_NO_HANDLERS:
563  break;
564  }
565  GNUNET_free (tc);
566 }
567 
568 
581 static void
583  const struct GNUNET_PeerIdentity *peer,
584  const struct GNUNET_HELLO_Address *address,
586  struct GNUNET_TIME_Absolute state_timeout,
587  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
588  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
589 {
590  struct TransportClient *tc = cls;
591  struct ConnectInfoMessage cim;
592 
594  return;
595  cim.header.size = htons (sizeof(struct ConnectInfoMessage));
597  cim.id = *peer;
598  cim.quota_out = bandwidth_out;
599  unicast (tc, &cim.header, GNUNET_NO);
600 }
601 
602 
611 static void
612 handle_client_start (void *cls, const struct StartMessage *start)
613 {
614  struct TransportClient *tc = cls;
615  const struct GNUNET_MessageHeader *hello;
616  uint32_t options;
617 
618  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p sent START\n", tc);
619  options = ntohl (start->options);
620  if ((0 != (1 & options)) &&
621  (0 != memcmp (&start->self,
623  sizeof(struct GNUNET_PeerIdentity))))
624  {
625  /* client thinks this is a different peer, reject */
626  GNUNET_break (0);
628  return;
629  }
630  if (CT_NONE != tc->type)
631  {
632  GNUNET_break (0);
634  return;
635  }
636  if (0 != (2 & options))
637  tc->type = CT_CORE;
638  else
640  hello = GST_hello_get ();
641  if (NULL != hello)
642  unicast (tc, hello, GNUNET_NO);
645 }
646 
647 
654 static int
655 check_client_hello (void *cls, const struct GNUNET_MessageHeader *message)
656 {
657  return GNUNET_OK; /* FIXME: check here? */
658 }
659 
660 
667 static void
668 handle_client_hello (void *cls, const struct GNUNET_MessageHeader *message)
669 {
670  struct TransportClient *tc = cls;
671 
672  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Received HELLO message\n");
673  GST_validation_handle_hello (message);
675 }
676 
677 
687 static void
689  int success,
690  size_t bytes_payload,
691  size_t bytes_on_wire)
692 {
693  struct SendTransmitContinuationContext *stcc = cls;
694  struct SendOkMessage send_ok_msg;
695  struct GNUNET_TIME_Relative delay;
696  const struct GNUNET_HELLO_Address *addr;
697 
700  if (delay.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
702  "It took us %s to send %u/%u bytes to %s (%d, %s)\n",
704  (unsigned int) bytes_payload,
705  (unsigned int) bytes_on_wire,
706  GNUNET_i2s (&stcc->target),
707  success,
708  (NULL != addr) ? addr->transport_name : "%");
709  else
711  "It took us %s to send %u/%u bytes to %s (%d, %s)\n",
713  (unsigned int) bytes_payload,
714  (unsigned int) bytes_on_wire,
715  GNUNET_i2s (&stcc->target),
716  success,
717  (NULL != addr) ? addr->transport_name : "%");
718 
719  if (GNUNET_NO == stcc->down)
720  {
721  /* Only send confirmation if we are still connected */
723  "Sending SEND_OK for transmission request %llu\n",
724  stcc->uuid);
725  send_ok_msg.header.size = htons (sizeof(send_ok_msg));
726  send_ok_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
727  send_ok_msg.bytes_msg = htonl (bytes_payload);
728  send_ok_msg.bytes_physical = htonl (bytes_on_wire);
729  send_ok_msg.success = htonl (success);
730  send_ok_msg.peer = stcc->target;
731  unicast (stcc->tc, &send_ok_msg.header, GNUNET_NO);
732  }
733  GNUNET_assert (
734  GNUNET_OK ==
735  GNUNET_CONTAINER_multipeermap_remove (active_stccs, &stcc->target, stcc));
736  GNUNET_free (stcc);
737 }
738 
739 
746 static int
747 check_client_send (void *cls, const struct OutboundMessage *obm)
748 {
749  uint16_t size;
750  const struct GNUNET_MessageHeader *obmm;
751 
752  size = ntohs (obm->header.size) - sizeof(struct OutboundMessage);
753  if (size < sizeof(struct GNUNET_MessageHeader))
754  {
755  GNUNET_break (0);
756  return GNUNET_SYSERR;
757  }
758  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
759  if (size != ntohs (obmm->size))
760  {
761  GNUNET_break (0);
762  return GNUNET_SYSERR;
763  }
764  return GNUNET_OK;
765 }
766 
767 
774 static void
775 handle_client_send (void *cls, const struct OutboundMessage *obm)
776 {
777  static unsigned long long uuid_gen;
778  struct TransportClient *tc = cls;
779  const struct GNUNET_MessageHeader *obmm;
780  struct SendTransmitContinuationContext *stcc;
781 
782  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
784  {
785  /* not connected, not allowed to send; can happen due to asynchronous operations */
787  "Could not send message to peer `%s': not connected\n",
788  GNUNET_i2s (&obm->peer));
790  GST_stats,
791  gettext_noop ("# bytes payload dropped (other peer was not connected)"),
792  ntohs (obmm->size),
793  GNUNET_NO);
795  return;
796  }
797  GNUNET_log (
799  "Received SEND request %llu for `%s' and first message of type %u and total size %u\n",
800  uuid_gen,
801  GNUNET_i2s (&obm->peer),
802  ntohs (obmm->type),
803  ntohs (obmm->size));
805 
807  stcc->target = obm->peer;
808  stcc->tc = tc;
810  stcc->uuid = uuid_gen++;
812  active_stccs,
813  &stcc->target,
814  stcc,
817  obmm,
818  ntohs (obmm->size),
821  stcc);
822 }
823 
824 
839 static void
840 transmit_address_to_client (void *cls, const char *buf, int res)
841 {
842  struct AddressToStringContext *actx = cls;
843  struct GNUNET_MQ_Envelope *env;
844  struct AddressToStringResultMessage *atsm;
845  size_t slen;
846 
847  GNUNET_assert ((GNUNET_OK == res) || (GNUNET_SYSERR == res));
848  if (NULL == actx->tc)
849  return;
850  if (NULL == buf)
851  {
852  env = GNUNET_MQ_msg (atsm,
854  if (GNUNET_OK == res)
855  {
856  /* this was the last call, transmit */
857  atsm->res = htonl (GNUNET_OK);
858  atsm->addr_len = htonl (0);
859  GNUNET_MQ_send (actx->tc->mq, env);
860  GNUNET_CONTAINER_DLL_remove (a2s_head, a2s_tail, actx);
861  GNUNET_free (actx);
862  return;
863  }
864  if (GNUNET_SYSERR == res)
865  {
866  /* address conversion failed, but there will be more callbacks */
867  atsm->res = htonl (GNUNET_SYSERR);
868  atsm->addr_len = htonl (0);
869  GNUNET_MQ_send (actx->tc->mq, env);
870  return;
871  }
872  }
873  GNUNET_assert (GNUNET_OK == res);
874  /* succesful conversion, append*/
875  slen = strlen (buf) + 1;
876  env =
877  GNUNET_MQ_msg_extra (atsm,
878  slen,
880  atsm->res = htonl (GNUNET_YES);
881  atsm->addr_len = htonl (slen);
882  GNUNET_memcpy (&atsm[1], buf, slen);
883  GNUNET_MQ_send (actx->tc->mq, env);
884 }
885 
886 
894 static int
896  const struct AddressLookupMessage *alum)
897 {
898  const char *plugin_name;
899  const char *address;
900  uint32_t address_len;
901  uint16_t size;
902 
903  size = ntohs (alum->header.size);
904  address_len = ntohs (alum->addrlen);
905  if (size <= sizeof(struct AddressLookupMessage) + address_len)
906  {
907  GNUNET_break (0);
908  return GNUNET_SYSERR;
909  }
910  address = (const char *) &alum[1];
911  plugin_name = (const char *) &address[address_len];
912  if ('\0' != plugin_name[size - sizeof(struct AddressLookupMessage)
913  - address_len - 1])
914  {
915  GNUNET_break (0);
916  return GNUNET_SYSERR;
917  }
918  return GNUNET_OK;
919 }
920 
921 
928 static void
930  const struct AddressLookupMessage *alum)
931 {
932  struct TransportClient *tc = cls;
934  const char *plugin_name;
935  const char *address;
936  uint32_t address_len;
937  struct AddressToStringContext *actx;
938  struct GNUNET_MQ_Envelope *env;
939  struct AddressToStringResultMessage *atsm;
940  struct GNUNET_TIME_Relative rtimeout;
941  int32_t numeric;
942 
943  address_len = ntohs (alum->addrlen);
944  address = (const char *) &alum[1];
945  plugin_name = (const char *) &address[address_len];
946  rtimeout = GNUNET_TIME_relative_ntoh (alum->timeout);
947  numeric = ntohs (alum->numeric_only);
948  papi = GST_plugins_printer_find (plugin_name);
949  if (NULL == papi)
950  {
952  "Failed to find plugin `%s'\n",
953  plugin_name);
954  env = GNUNET_MQ_msg (atsm,
956  atsm->res = htonl (GNUNET_SYSERR);
957  atsm->addr_len = htonl (0);
958  GNUNET_MQ_send (tc->mq, env);
959  env = GNUNET_MQ_msg (atsm,
961  atsm->res = htonl (GNUNET_OK);
962  atsm->addr_len = htonl (0);
963  GNUNET_MQ_send (tc->mq, env);
964  return;
965  }
966  actx = GNUNET_new (struct AddressToStringContext);
967  actx->tc = tc;
968  GNUNET_CONTAINER_DLL_insert (a2s_head, a2s_tail, actx);
971  "Pretty-printing address of %u bytes using plugin `%s'\n",
972  address_len,
973  plugin_name);
974  papi->address_pretty_printer (papi->cls,
975  plugin_name,
976  address,
977  address_len,
978  numeric,
979  rtimeout,
981  actx);
982 }
983 
984 
992 static struct PeerIterateResponseMessage *
994  const struct GNUNET_PeerIdentity *peer,
995  const struct GNUNET_HELLO_Address *address)
996 {
998  size_t size;
999  size_t tlen;
1000  size_t alen;
1001  char *addr;
1002 
1003  GNUNET_assert (NULL != peer);
1004  if (NULL != address)
1005  {
1006  tlen = strlen (address->transport_name) + 1;
1007  alen = address->address_length;
1008  }
1009  else
1010  {
1011  tlen = 0;
1012  alen = 0;
1013  }
1014  size = (sizeof(struct PeerIterateResponseMessage) + alen + tlen);
1015  msg = GNUNET_malloc (size);
1016  msg->header.size = htons (size);
1017  msg->header.type =
1019  msg->reserved = htonl (0);
1020  msg->peer = *peer;
1021  msg->addrlen = htonl (alen);
1022  msg->pluginlen = htonl (tlen);
1023 
1024  if (NULL != address)
1025  {
1026  msg->local_address_info = htonl ((uint32_t) address->local_info);
1027  addr = (char *) &msg[1];
1028  GNUNET_memcpy (addr, address->address, alen);
1029  GNUNET_memcpy (&addr[alen], address->transport_name, tlen);
1030  }
1031  return msg;
1032 }
1033 
1034 
1039 struct IterationContext
1040 {
1045 
1050 
1054  int all;
1055 };
1056 
1057 
1069 static void
1071  const struct GNUNET_PeerIdentity *peer,
1072  const struct GNUNET_HELLO_Address *address,
1074  struct GNUNET_TIME_Absolute state_timeout,
1075  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
1076  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
1077 {
1078  struct IterationContext *pc = cls;
1079  struct GNUNET_MQ_Envelope *env;
1081 
1082  if ((GNUNET_YES != pc->all) && (0 != memcmp (peer, &pc->id, sizeof(pc->id))))
1083  return;
1085  "Sending information about `%s' using address `%s' in state `%s'\n",
1086  GNUNET_i2s (peer),
1087  (NULL != address) ? GST_plugins_a2s (address) : "<none>",
1088  GNUNET_TRANSPORT_ps2s (state));
1089  msg = compose_address_iterate_response_message (peer, address);
1090  msg->state = htonl (state);
1091  msg->state_timeout = GNUNET_TIME_absolute_hton (state_timeout);
1092  env = GNUNET_MQ_msg_copy (&msg->header);
1093  GNUNET_free (msg);
1094  GNUNET_MQ_send (pc->tc->mq, env);
1095 }
1096 
1097 
1105 static void
1107 {
1108  struct TransportClient *tc = cls;
1109  struct IterationContext pc;
1110 
1111  if (CT_NONE != tc->type)
1112  {
1113  GNUNET_break (0);
1115  return;
1116  }
1119 
1120  /* Send initial list */
1121  pc.tc = tc;
1122  if (0 == memcmp (&msg->peer, &all_zeros, sizeof(struct GNUNET_PeerIdentity)))
1123  {
1124  /* iterate over all neighbours */
1125  pc.all = GNUNET_YES;
1126  pc.id = msg->peer;
1127  }
1128  else
1129  {
1130  /* just return one neighbour */
1131  pc.all = GNUNET_NO;
1132  pc.id = msg->peer;
1133  }
1135 
1136  if (GNUNET_YES != ntohl (msg->one_shot))
1137  {
1138  tc->details.monitor_peer = msg->peer;
1139  tc->type = CT_MONITOR;
1140  if (0 !=
1141  memcmp (&msg->peer, &all_zeros, sizeof(struct GNUNET_PeerIdentity)))
1143  "Client %p started monitoring of the peer `%s'\n",
1144  tc,
1145  GNUNET_i2s (&msg->peer));
1146  else
1148  "Client %p started monitoring all peers\n",
1149  tc);
1150  }
1151  else
1152  {
1153  struct GNUNET_MessageHeader *msg;
1154  struct GNUNET_MQ_Envelope *env;
1155 
1156  env =
1157  GNUNET_MQ_msg (msg,
1159  GNUNET_MQ_send (tc->mq, env);
1160  }
1161 }
1162 
1163 
1176 static void
1178  struct GNUNET_ATS_Session *session,
1179  const struct GNUNET_TRANSPORT_SessionInfo *info)
1180 {
1181  struct GNUNET_MQ_Envelope *env;
1183  struct GNUNET_MessageHeader *sync;
1184  size_t size;
1185  size_t slen;
1186  uint16_t alen;
1187  char *name;
1188  char *addr;
1189 
1190  if (0 == GNUNET_notification_context_get_size (plugin_nc))
1191  {
1192  GST_plugins_monitor_subscribe (NULL, NULL);
1193  return;
1194  }
1195  if ((NULL == info) && (NULL == session))
1196  {
1197  /* end of initial iteration */
1198  if (NULL != sync_client)
1199  {
1200  env =
1202  GNUNET_MQ_send (sync_client->mq, env);
1203  sync_client = NULL;
1204  }
1205  return;
1206  }
1207  GNUNET_assert (NULL != info);
1209  "Plugin event for peer %s on transport %s\n",
1210  GNUNET_i2s (&info->address->peer),
1211  info->address->transport_name);
1212  slen = strlen (info->address->transport_name) + 1;
1213  alen = info->address->address_length;
1214  size = sizeof(struct TransportPluginMonitorMessage) + slen + alen;
1215  if (size > UINT16_MAX)
1216  {
1217  GNUNET_break (0);
1218  return;
1219  }
1220  msg = GNUNET_malloc (size);
1221  msg->header.size = htons (size);
1223  msg->session_state = htons ((uint16_t) info->state);
1224  msg->is_inbound = htons ((int16_t) info->is_inbound);
1225  msg->msgs_pending = htonl (info->num_msg_pending);
1226  msg->bytes_pending = htonl (info->num_bytes_pending);
1229  msg->peer = info->address->peer;
1230  msg->session_id = (uint64_t) (intptr_t) session;
1231  msg->plugin_name_len = htons (slen);
1232  msg->plugin_address_len = htons (alen);
1233  name = (char *) &msg[1];
1234  GNUNET_memcpy (name, info->address->transport_name, slen);
1235  addr = &name[slen];
1236  GNUNET_memcpy (addr, info->address->address, alen);
1237  if (NULL != sync_client)
1238  {
1239  struct GNUNET_MQ_Envelope *env;
1240 
1241  env = GNUNET_MQ_msg_copy (&msg->header);
1242  GNUNET_MQ_send (sync_client->mq, env);
1243  }
1244  else
1245  {
1247  }
1248  GNUNET_free (msg);
1249 }
1250 
1251 
1258 static void
1260  const struct GNUNET_MessageHeader *message)
1261 {
1262  struct TransportClient *tc = cls;
1263 
1266  GNUNET_notification_context_add (plugin_nc, tc->mq);
1267  GNUNET_assert (NULL == sync_client);
1268  sync_client = tc;
1270 }
1271 
1272 
1279 void
1280 GST_clients_broadcast (const struct GNUNET_MessageHeader *msg, int may_drop)
1281 {
1282  int done;
1283 
1285  "Asked to broadcast message of type %u with %u bytes\n",
1286  (unsigned int) ntohs (msg->type),
1287  (unsigned int) ntohs (msg->size));
1288  done = GNUNET_NO;
1289  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
1290  {
1291  if (CT_NONE == tc->type)
1292  continue; /* client not yet ready */
1293  if ((GNUNET_YES == may_drop) && (CT_CORE != tc->type))
1294  continue; /* skip, this client does not care about payload */
1295  unicast (tc, msg, may_drop);
1296  done = GNUNET_YES;
1297  }
1298  if (GNUNET_NO == done)
1300  "Message of type %u not delivered, is CORE service up?\n",
1301  ntohs (msg->type));
1302 }
1303 
1304 
1313 void
1315  const struct GNUNET_PeerIdentity *peer,
1316  const struct GNUNET_HELLO_Address *address,
1318  struct GNUNET_TIME_Absolute state_timeout)
1319 {
1320  struct GNUNET_MQ_Envelope *env;
1322 
1323  msg = compose_address_iterate_response_message (peer, address);
1324  msg->state = htonl (state);
1325  msg->state_timeout = GNUNET_TIME_absolute_hton (state_timeout);
1326  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
1327  {
1328  if (CT_MONITOR != tc->type)
1329  continue;
1330  if ((0 == memcmp (&tc->details.monitor_peer,
1331  &all_zeros,
1332  sizeof(struct GNUNET_PeerIdentity))) ||
1333  (0 == memcmp (&tc->details.monitor_peer,
1334  peer,
1335  sizeof(struct GNUNET_PeerIdentity))))
1336  {
1337  env = GNUNET_MQ_msg_copy (&msg->header);
1338  GNUNET_MQ_send (tc->mq, env);
1339  }
1340  }
1341  GNUNET_free (msg);
1342 }
1343 
1344 
1354 static int
1355 mark_peer_down (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
1356 {
1357  struct SendTransmitContinuationContext *stcc = value;
1358 
1359  stcc->down = GNUNET_YES;
1360  return GNUNET_OK;
1361 }
1362 
1363 
1370 void
1372 {
1373  struct DisconnectInfoMessage disconnect_msg;
1374 
1376  peer,
1377  &mark_peer_down,
1378  NULL);
1379  disconnect_msg.header.size = htons (sizeof(struct DisconnectInfoMessage));
1380  disconnect_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
1381  disconnect_msg.reserved = htonl (0);
1382  disconnect_msg.peer = *peer;
1383  GST_clients_broadcast (&disconnect_msg.header, GNUNET_NO);
1384 }
1385 
1386 
1398 static void
1400  const struct GNUNET_PeerIdentity *peer,
1401  const struct GNUNET_HELLO_Address *address,
1403  struct GNUNET_TIME_Absolute state_timeout,
1404  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
1405  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
1406 {
1407  const struct GNUNET_MessageHeader *hello = cls;
1408 
1409  if (0 == memcmp (peer, &GST_my_identity, sizeof(struct GNUNET_PeerIdentity)))
1410  return; /* not to ourselves */
1412  return;
1413 
1414  GST_neighbours_send (peer,
1415  hello,
1416  ntohs (hello->size),
1418  NULL,
1419  NULL);
1420 }
1421 
1422 
1429 static void
1430 process_hello_update (void *cls, const struct GNUNET_MessageHeader *hello)
1431 {
1432  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Broadcasting HELLO to clients\n");
1434  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Broadcasting HELLO to neighbours\n");
1435  GST_neighbours_iterate (&transmit_our_hello, (void *) hello);
1436 }
1437 
1438 
1449 static struct GNUNET_TIME_Relative
1451  struct GNUNET_ATS_Session *session,
1452  const struct GNUNET_MessageHeader *message)
1453 {
1454  struct GNUNET_TIME_Relative ret;
1455  int do_forward;
1456  struct InboundMessage *im;
1457  size_t msg_size = ntohs (message->size);
1458  size_t size = sizeof(struct InboundMessage) + msg_size;
1459  char buf[size] GNUNET_ALIGN;
1460 
1461  do_forward = GNUNET_SYSERR;
1462  ret = GST_neighbours_calculate_receive_delay (&address->peer,
1463  msg_size,
1464  &do_forward);
1465  if (! GST_neighbours_test_connected (&address->peer))
1466  {
1468  "Discarded %u bytes type %u payload from peer `%s'\n",
1469  (unsigned int) msg_size,
1470  ntohs (message->type),
1471  GNUNET_i2s (&address->peer));
1473  GST_stats,
1474  gettext_noop ("# bytes payload discarded due to not connected peer"),
1475  msg_size,
1476  GNUNET_NO);
1477  return ret;
1478  }
1479 
1480  if (GNUNET_YES != do_forward)
1481  return ret;
1482  im = (struct InboundMessage *) buf;
1483  im->header.size = htons (size);
1485  im->peer = address->peer;
1486  GNUNET_memcpy (&im[1], message, ntohs (message->size));
1488  return ret;
1489 }
1490 
1491 
1497 static void
1499 {
1500  struct GNUNET_ATS_SessionKiller *sk = cls;
1501 
1502  sk->task = NULL;
1503  GNUNET_CONTAINER_DLL_remove (sk_head, sk_tail, sk);
1504  sk->plugin->disconnect_session (sk->plugin->cls, sk->session);
1505  GNUNET_free (sk);
1506 }
1507 
1508 
1516 static void
1517 kill_session (const char *plugin_name, struct GNUNET_ATS_Session *session)
1518 {
1520  struct GNUNET_ATS_SessionKiller *sk;
1521 
1522  for (sk = sk_head; NULL != sk; sk = sk->next)
1523  if (sk->session == session)
1524  return;
1525  plugin = GST_plugins_find (plugin_name);
1526  if (NULL == plugin)
1527  {
1528  GNUNET_break (0);
1529  return;
1530  }
1531  /* need to issue disconnect asynchronously */
1532  sk = GNUNET_new (struct GNUNET_ATS_SessionKiller);
1533  sk->session = session;
1534  sk->plugin = plugin;
1536  GNUNET_CONTAINER_DLL_insert (sk_head, sk_tail, sk);
1537 }
1538 
1539 
1550 static void
1552  const struct GNUNET_PeerIdentity *peer,
1553  const struct GNUNET_HELLO_Address *address,
1554  struct GNUNET_ATS_Session *session,
1555  int result)
1556 {
1557  struct GNUNET_MessageHeader *msg = cls;
1558 
1559  if (GNUNET_OK == result)
1560  {
1561  /* Blacklist allows to speak to this peer, forward SYN to neighbours */
1563  "Received SYN message from peer `%s' at `%s'\n",
1564  GNUNET_i2s (peer),
1565  GST_plugins_a2s (address));
1566  if (GNUNET_OK != GST_neighbours_handle_session_syn (msg, peer))
1567  {
1568  GST_blacklist_abort_matching (address, session);
1569  kill_session (address->transport_name, session);
1570  }
1571  GNUNET_free (msg);
1572  return;
1573  }
1574  GNUNET_free (msg);
1575  if (GNUNET_SYSERR == result)
1576  return; /* check was aborted, session destroyed */
1577  /* Blacklist denies to speak to this peer */
1579  "Discarding SYN message from `%s' due to denied blacklist check\n",
1580  GNUNET_i2s (peer));
1581  kill_session (address->transport_name, session);
1582 }
1583 
1584 
1598 struct GNUNET_TIME_Relative
1600  const struct GNUNET_HELLO_Address *address,
1601  struct GNUNET_ATS_Session *session,
1602  const struct GNUNET_MessageHeader *message)
1603 {
1604  const char *plugin_name = cls;
1605  struct GNUNET_TIME_Relative ret;
1606  uint16_t type;
1607 
1608  ret = GNUNET_TIME_UNIT_ZERO;
1609  if (NULL == message)
1610  goto end;
1611  type = ntohs (message->type);
1613  "Received message with type %u from peer `%s' at %s\n",
1614  type,
1615  GNUNET_i2s (&address->peer),
1616  GST_plugins_a2s (address));
1617 
1618  GNUNET_STATISTICS_update (GST_stats,
1619  gettext_noop ("# bytes total received"),
1620  ntohs (message->size),
1621  GNUNET_NO);
1622  GST_neighbours_notify_data_recv (address, message);
1623  switch (type)
1624  {
1626  /* Legacy HELLO message, discard */
1627  return ret;
1628 
1630  if (GNUNET_OK != GST_validation_handle_hello (message))
1631  {
1632  GNUNET_break_op (0);
1633  GST_blacklist_abort_matching (address, session);
1634  }
1635  return ret;
1636 
1639  "Processing PING from `%s'\n",
1640  GST_plugins_a2s (address));
1641  if (GNUNET_OK !=
1642  GST_validation_handle_ping (&address->peer, message, address, session))
1643  {
1644  GST_blacklist_abort_matching (address, session);
1645  kill_session (plugin_name, session);
1646  }
1647  break;
1648 
1651  "Processing PONG from `%s'\n",
1652  GST_plugins_a2s (address));
1653  if (GNUNET_OK != GST_validation_handle_pong (&address->peer, message))
1654  {
1655  GNUNET_break_op (0);
1656  GST_blacklist_abort_matching (address, session);
1657  kill_session (plugin_name, session);
1658  }
1659  break;
1660 
1662  /* Do blacklist check if communication with this peer is allowed */
1663  (void) GST_blacklist_test_allowed (&address->peer,
1664  NULL,
1666  GNUNET_copy_message (message),
1667  address,
1668  session);
1669  break;
1670 
1672  if (GNUNET_OK !=
1673  GST_neighbours_handle_session_syn_ack (message, address, session))
1674  {
1675  GST_blacklist_abort_matching (address, session);
1676  kill_session (plugin_name, session);
1677  }
1678  break;
1679 
1681  if (GNUNET_OK !=
1682  GST_neighbours_handle_session_ack (message, address, session))
1683  {
1684  GNUNET_break_op (0);
1685  GST_blacklist_abort_matching (address, session);
1686  kill_session (plugin_name, session);
1687  }
1688  break;
1689 
1691  GST_neighbours_handle_disconnect_message (&address->peer, message);
1692  break;
1693 
1695  GST_neighbours_handle_quota_message (&address->peer, message);
1696  break;
1697 
1699  GST_neighbours_keepalive (&address->peer, message);
1700  break;
1701 
1703  GST_neighbours_keepalive_response (&address->peer, message);
1704  break;
1705 
1706  default:
1707  /* should be payload */
1708  GNUNET_STATISTICS_update (GST_stats,
1709  gettext_noop ("# bytes payload received"),
1710  ntohs (message->size),
1711  GNUNET_NO);
1712  ret = process_payload (address, session, message);
1713  break;
1714  }
1715 end:
1717  "Allowing receive from peer %s to continue in %s\n",
1718  GNUNET_i2s (&address->peer),
1720  return ret;
1721 }
1722 
1723 
1733 static void
1735  void *cls,
1736  int add_remove,
1737  const struct GNUNET_HELLO_Address *address)
1738 {
1739  static int addresses = 0;
1740 
1741  if (GNUNET_YES == add_remove)
1742  {
1743  addresses++;
1744  GNUNET_STATISTICS_update (GST_stats, "# transport addresses", 1, GNUNET_NO);
1745  }
1746  else if (GNUNET_NO == add_remove)
1747  {
1748  if (0 == addresses)
1749  {
1750  GNUNET_break (0);
1751  }
1752  else
1753  {
1754  addresses--;
1755  GNUNET_STATISTICS_update (GST_stats,
1756  "# transport addresses",
1757  -1,
1758  GNUNET_NO);
1759  }
1760  }
1762  "Transport now has %u addresses to communicate\n",
1763  addresses);
1764  GST_hello_modify_addresses (add_remove, address);
1765 }
1766 
1767 
1781 static void
1783  const struct GNUNET_HELLO_Address *address,
1784  struct GNUNET_ATS_Session *session)
1785 {
1786  struct GNUNET_ATS_SessionKiller *sk;
1787 
1788  if (NULL == address)
1789  {
1790  GNUNET_break (0);
1791  return;
1792  }
1793  if (NULL == session)
1794  {
1795  GNUNET_break (0);
1796  return;
1797  }
1798  GNUNET_assert (strlen (address->transport_name) > 0);
1799 
1800  GNUNET_log (
1802  "Notification from plugin about terminated session %p from peer `%s' address `%s'\n",
1803  session,
1804  GNUNET_i2s (&address->peer),
1805  GST_plugins_a2s (address));
1806 
1807  GST_neighbours_session_terminated (&address->peer, session);
1808  GST_ats_del_session (address, session);
1809  GST_blacklist_abort_matching (address, session);
1810 
1811  for (sk = sk_head; NULL != sk; sk = sk->next)
1812  {
1813  if (sk->session == session)
1814  {
1815  GNUNET_CONTAINER_DLL_remove (sk_head, sk_tail, sk);
1817  GNUNET_free (sk);
1818  break;
1819  }
1820  }
1821 }
1822 
1823 
1835 static void
1837  void *cls,
1838  const struct GNUNET_PeerIdentity *peer,
1839  const struct GNUNET_HELLO_Address *address,
1840  struct GNUNET_ATS_Session *session,
1841  int result)
1842 {
1843  if (GNUNET_OK != result)
1844  {
1845  kill_session (address->transport_name, session);
1846  return;
1847  }
1848  if (GNUNET_YES !=
1851  {
1853  "Informing verifier about inbound session's address `%s'\n",
1854  GST_plugins_a2s (address));
1856  }
1857 }
1858 
1859 
1868 static void
1870  const struct GNUNET_HELLO_Address *address,
1871  struct GNUNET_ATS_Session *session,
1873 {
1874  struct GNUNET_ATS_Properties prop;
1875 
1876  if (NULL == address)
1877  {
1878  GNUNET_break (0);
1879  return;
1880  }
1881  if (NULL == session)
1882  {
1883  GNUNET_break (0);
1884  return;
1885  }
1886  GNUNET_log (
1888  "Notification from plugin `%s' about new session from peer `%s' address `%s'\n",
1889  address->transport_name,
1890  GNUNET_i2s (&address->peer),
1891  GST_plugins_a2s (address));
1892  if (GNUNET_YES ==
1895  {
1896  /* inbound is always new, but outbound MAY already be known, but
1897  for example for UNIX, we have symmetric connections and thus we
1898  may not know the address yet; add if necessary! */
1899  /* FIXME: maybe change API here so we just pass scope? */
1900  memset (&prop, 0, sizeof(prop));
1902  prop.scope = scope;
1903  GST_ats_add_inbound_address (address, session, &prop);
1904  }
1905  /* Do blacklist check if communication with this peer is allowed */
1906  (void) GST_blacklist_test_allowed (&address->peer,
1907  address->transport_name,
1909  NULL,
1910  address,
1911  session);
1912 }
1913 
1914 
1933 static void
1935  const struct GNUNET_PeerIdentity *peer,
1936  const struct GNUNET_HELLO_Address *address,
1937  struct GNUNET_ATS_Session *session,
1938  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
1939  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
1940 {
1941  uint32_t bw_in = ntohl (bandwidth_in.value__);
1942  uint32_t bw_out = ntohl (bandwidth_out.value__);
1943 
1944  if (NULL == peer)
1945  {
1946  /* ATS service died, all suggestions become invalid!
1947  (but we'll keep using the allocations for a little
1948  while, to keep going while ATS restarts) */
1949  /* FIXME: We should drop all
1950  connections now, as ATS won't explicitly tell
1951  us and be unaware of ongoing resource allocations! */
1952  return;
1953  }
1954  /* ATS tells me to disconnect from peer */
1955  if ((0 == bw_in) && (0 == bw_out))
1956  {
1958  "ATS tells me to disconnect from peer `%s'\n",
1959  GNUNET_i2s (peer));
1961  return;
1962  }
1963  GNUNET_assert (NULL != address);
1964  GNUNET_STATISTICS_update (GST_stats,
1965  "# ATS suggestions received",
1966  1,
1967  GNUNET_NO);
1969  session,
1970  bandwidth_in,
1971  bandwidth_out);
1972 }
1973 
1974 
1979 {
1983  int first;
1984 
1989 };
1990 
1991 
2003 static void
2005  const struct GNUNET_PeerIdentity *peer,
2006  const struct GNUNET_HELLO_Address *address,
2007  struct GNUNET_ATS_Session *session,
2008  int allowed)
2009 {
2010  if (GNUNET_OK == allowed)
2011  return; /* we're done */
2012  GNUNET_STATISTICS_update (GST_stats,
2013  gettext_noop ("# disconnects due to blacklist"),
2014  1,
2015  GNUNET_NO);
2017 }
2018 
2019 
2032 static void
2034  const struct GNUNET_PeerIdentity *peer,
2035  const struct GNUNET_HELLO_Address *address,
2037  struct GNUNET_TIME_Absolute state_timeout,
2038  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
2039  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
2040 {
2041  struct TestConnectionContext *tcc = cls;
2042  struct GST_BlacklistCheck *bc;
2043 
2044  bc = GNUNET_new (struct GST_BlacklistCheck);
2045  GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
2046  bc->peer = *peer;
2047  bc->address = GNUNET_HELLO_address_copy (address);
2049  bc->cont_cls = NULL;
2050  bc->bl_pos = tcc->tc;
2051  if (GNUNET_YES == tcc->first)
2052  {
2053  /* all would wait for the same client, no need to
2054  * create more than just the first task right now */
2056  tcc->first = GNUNET_NO;
2057  }
2058 }
2059 
2060 
2069 static void
2071  const struct GNUNET_MessageHeader *message)
2072 {
2073  struct TransportClient *tc = cls;
2074  struct TestConnectionContext tcc;
2075 
2076  if (CT_NONE != tc->type)
2077  {
2078  GNUNET_break (0);
2080  return;
2081  }
2083  tc->type = CT_BLACKLIST;
2084  tc->details.blacklist.call_receive_done = GNUNET_YES;
2085  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New blacklist client %p\n", tc);
2086  /* confirm that all existing connections are OK! */
2087  tcc.tc = tc;
2088  tcc.first = GNUNET_YES;
2090 }
2091 
2092 
2101 static int
2103  const struct GNUNET_PeerIdentity *key,
2104  void *value)
2105 {
2106  char *be = value;
2107 
2108  GNUNET_free_non_null (be);
2109  return GNUNET_OK;
2110 }
2111 
2112 
2119 static void
2120 handle_client_set_metric (void *cls, const struct TrafficMetricMessage *tm)
2121 {
2122  struct TransportClient *tc = cls;
2123 
2126 }
2127 
2128 
2135 static void
2136 shutdown_task (void *cls)
2137 {
2138  struct AddressToStringContext *cur;
2139 
2141  GST_plugins_unload ();
2143  GST_ats_done ();
2144  GNUNET_ATS_scheduling_done (GST_ats);
2145  GST_ats = NULL;
2146  GNUNET_ATS_connectivity_done (GST_ats_connect);
2147  GST_ats_connect = NULL;
2148  GNUNET_NT_scanner_done (GST_is);
2149  GST_is = NULL;
2150  while (NULL != (cur = a2s_head))
2151  {
2152  GNUNET_CONTAINER_DLL_remove (a2s_head, a2s_tail, cur);
2153  GNUNET_free (cur);
2154  }
2155  if (NULL != plugin_nc)
2156  {
2158  plugin_nc = NULL;
2159  }
2161  active_stccs = NULL;
2162  if (NULL != blacklist)
2163  {
2166  NULL);
2168  blacklist = NULL;
2169  }
2170  GST_hello_stop ();
2172 
2173  if (NULL != GST_peerinfo)
2174  {
2175  GNUNET_PEERINFO_disconnect (GST_peerinfo);
2176  GST_peerinfo = NULL;
2177  }
2178  if (NULL != GST_stats)
2179  {
2180  GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
2181  GST_stats = NULL;
2182  }
2183  if (NULL != GST_my_private_key)
2184  {
2185  GNUNET_free (GST_my_private_key);
2186  GST_my_private_key = NULL;
2187  }
2188 }
2189 
2190 
2196 static void
2198 {
2199  struct GST_BlacklistCheck *bc = cls;
2200  struct TransportClient *tc;
2201  struct GNUNET_MQ_Envelope *env;
2202  struct BlacklistMessage *bm;
2203 
2204  bc->task = NULL;
2205  while (NULL != (tc = bc->bl_pos))
2206  {
2207  if (CT_BLACKLIST == tc->type)
2208  break;
2209  bc->bl_pos = tc->next;
2210  }
2211  if (NULL == tc)
2212  {
2214  "No other blacklist clients active, will allow neighbour `%s'\n",
2215  GNUNET_i2s (&bc->peer));
2216 
2217  bc->cont (bc->cont_cls, &bc->peer, bc->address, bc->session, GNUNET_OK);
2219  return;
2220  }
2221  if ((NULL != tc->details.blacklist.bc) ||
2222  (GNUNET_NO != tc->details.blacklist.waiting_for_reply))
2223  return; /* someone else busy with this client */
2224  tc->details.blacklist.bc = bc;
2226  bm->is_allowed = htonl (0);
2227  bm->peer = bc->peer;
2228  GNUNET_MQ_send (tc->mq, env);
2229  if (GNUNET_YES == tc->details.blacklist.call_receive_done)
2230  {
2231  tc->details.blacklist.call_receive_done = GNUNET_NO;
2233  }
2234  tc->details.blacklist.waiting_for_reply = GNUNET_YES;
2235 }
2236 
2237 
2244 static void
2246 {
2247  struct TransportClient *tc = cls;
2248  struct GST_BlacklistCheck *bc;
2249 
2250  if (CT_BLACKLIST != tc->type)
2251  {
2252  GNUNET_break (0);
2254  return;
2255  }
2257  "Blacklist client %p sent reply for `%s'\n",
2258  tc,
2259  GNUNET_i2s (&msg->peer));
2260  bc = tc->details.blacklist.bc;
2261  tc->details.blacklist.bc = NULL;
2262  tc->details.blacklist.waiting_for_reply = GNUNET_NO;
2263  tc->details.blacklist.call_receive_done = GNUNET_YES;
2264  if (NULL != bc)
2265  {
2266  /* only run this if the blacklist check has not been
2267  * cancelled in the meantime... */
2268  GNUNET_assert (bc->bl_pos == tc);
2269  if (ntohl (msg->is_allowed) == GNUNET_SYSERR)
2270  {
2272  "Blacklist check failed, peer not allowed\n");
2273  /* For the duration of the continuation, make the ongoing
2274  check invisible (to avoid double-cancellation); then
2275  add it back again so we can re-use GST_blacklist_test_cancel() */
2276  GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
2277  bc->cont (bc->cont_cls, &bc->peer, bc->address, bc->session, GNUNET_NO);
2278  GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
2280  tc->details.blacklist.call_receive_done = GNUNET_NO;
2282  return;
2283  }
2284  else
2285  {
2287  "Blacklist check succeeded, continuing with checks\n");
2288  tc->details.blacklist.call_receive_done = GNUNET_NO;
2290  bc->bl_pos = tc->next;
2292  }
2293  }
2294  /* check if any other blacklist checks are waiting for this blacklister */
2295  for (bc = bc_head; bc != NULL; bc = bc->next)
2296  if ((bc->bl_pos == tc) && (NULL == bc->task))
2297  {
2299  break;
2300  }
2301 }
2302 
2303 
2310 void
2312  const char *transport_name)
2313 {
2314  char *transport = NULL;
2315 
2316  if (NULL != transport_name)
2317  {
2319  "Adding peer `%s' with plugin `%s' to blacklist\n",
2320  GNUNET_i2s (peer),
2321  transport_name);
2322  transport = GNUNET_strdup (transport_name);
2323  }
2324  else
2326  "Adding peer `%s' with all plugins to blacklist\n",
2327  GNUNET_i2s (peer));
2328  if (NULL == blacklist)
2329  blacklist =
2331  GNUNET_NO);
2332 
2334  peer,
2335  transport,
2337 }
2338 
2339 
2346 void
2348  struct GNUNET_ATS_Session *session)
2349 {
2350  struct GST_BlacklistCheck *bc;
2351  struct GST_BlacklistCheck *n;
2352 
2353  n = bc_head;
2354  while (NULL != (bc = n))
2355  {
2356  n = bc->next;
2357  if ((bc->session == session) &&
2358  (0 == GNUNET_HELLO_address_cmp (bc->address, address)))
2359  {
2360  bc->cont (bc->cont_cls,
2361  &bc->peer,
2362  bc->address,
2363  bc->session,
2364  GNUNET_SYSERR);
2366  }
2367  }
2368 }
2369 
2370 
2380 static int
2381 test_blacklisted (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
2382 {
2383  const char *transport_name = cls;
2384  char *be = value;
2385 
2386  /* Blacklist entry be:
2387  * (NULL == be): peer is blacklisted with all plugins
2388  * (NULL != be): peer is blacklisted for a specific plugin
2389  *
2390  * If (NULL != transport_name) we look for a transport specific entry:
2391  * if (transport_name == be) forbidden
2392  *
2394  "Comparing BL request for peer `%4s':`%s' with BL entry: `%s'\n",
2395  GNUNET_i2s (key),
2396  (NULL == transport_name) ? "unspecified" : transport_name,
2397  (NULL == be) ? "all plugins" : be);
2398  /* all plugins for this peer were blacklisted: disallow */
2399  if (NULL == value)
2400  return GNUNET_NO;
2401 
2402  /* blacklist check for specific transport */
2403  if ((NULL != transport_name) && (NULL != value))
2404  {
2405  if (0 == strcmp (transport_name, be))
2406  return GNUNET_NO; /* plugin is blacklisted! */
2407  }
2408  return GNUNET_OK;
2409 }
2410 
2411 
2424 struct GST_BlacklistCheck *
2426  const char *transport_name,
2428  void *cont_cls,
2429  const struct GNUNET_HELLO_Address *address,
2430  struct GNUNET_ATS_Session *session)
2431 {
2432  struct GST_BlacklistCheck *bc;
2433  struct TransportClient *tc;
2434 
2435  GNUNET_assert (NULL != peer);
2437  "Blacklist check for peer `%s':%s\n",
2438  GNUNET_i2s (peer),
2439  (NULL != transport_name) ? transport_name : "unspecified");
2440 
2441  /* Check local blacklist by iterating over hashmap
2442  * If iteration is aborted, we found a matching blacklist entry */
2443  if ((NULL != blacklist) &&
2444  (GNUNET_SYSERR ==
2446  peer,
2448  (void *) transport_name)))
2449  {
2450  /* Disallowed by config, disapprove instantly */
2451  GNUNET_STATISTICS_update (GST_stats,
2452  gettext_noop ("# disconnects due to blacklist"),
2453  1,
2454  GNUNET_NO);
2456  _ ("Disallowing connection to peer `%s' on transport %s\n"),
2457  GNUNET_i2s (peer),
2458  (NULL != transport_name) ? transport_name : "unspecified");
2459  if (NULL != cont)
2460  cont (cont_cls, peer, address, session, GNUNET_NO);
2461  return NULL;
2462  }
2463 
2464  for (tc = clients_head; NULL != tc; tc = tc->next)
2465  if (CT_BLACKLIST == tc->type)
2466  break;
2467  if (NULL == tc)
2468  {
2469  /* no blacklist clients, approve instantly */
2470  if (NULL != cont)
2471  cont (cont_cls, peer, address, session, GNUNET_OK);
2473  "Allowing connection to peer `%s' %s\n",
2474  GNUNET_i2s (peer),
2475  (NULL != transport_name) ? transport_name : "");
2476  return NULL;
2477  }
2478 
2479  /* need to query blacklist clients */
2480  bc = GNUNET_new (struct GST_BlacklistCheck);
2481  GNUNET_CONTAINER_DLL_insert (bc_head, bc_tail, bc);
2482  bc->peer = *peer;
2483  bc->address = GNUNET_HELLO_address_copy (address);
2484  bc->session = session;
2485  bc->cont = cont;
2486  bc->cont_cls = cont_cls;
2487  bc->bl_pos = tc;
2489  return bc;
2490 }
2491 
2492 
2498 void
2500 {
2501  GNUNET_CONTAINER_DLL_remove (bc_head, bc_tail, bc);
2502  if (NULL != bc->bl_pos)
2503  {
2504  if ((CT_BLACKLIST == bc->bl_pos->type) &&
2505  (bc->bl_pos->details.blacklist.bc == bc))
2506  {
2507  /* we're at the head of the queue, remove us! */
2508  bc->bl_pos->details.blacklist.bc = NULL;
2509  }
2510  }
2511  if (NULL != bc->task)
2512  {
2514  bc->task = NULL;
2515  }
2517  GNUNET_free (bc);
2518 }
2519 
2520 
2529 static void
2531  const char *section,
2532  const char *option,
2533  const char *value)
2534 {
2535  unsigned int *res = cls;
2536  struct GNUNET_PeerIdentity peer;
2537  char *plugs;
2538  char *pos;
2539 
2540  if (GNUNET_OK !=
2542  strlen (option),
2543  &peer.public_key))
2544  return;
2545 
2546  if ((NULL == value) || (0 == strcmp (value, "")))
2547  {
2548  /* Blacklist whole peer */
2549  GST_blacklist_add_peer (&peer, NULL);
2551  _ ("Adding blacklisting entry for peer `%s'\n"),
2552  GNUNET_i2s (&peer));
2553  }
2554  else
2555  {
2556  plugs = GNUNET_strdup (value);
2557  for (pos = strtok (plugs, " "); pos != NULL; pos = strtok (NULL, " "))
2558  {
2560  _ ("Adding blacklisting entry for peer `%s':`%s'\n"),
2561  GNUNET_i2s (&peer),
2562  pos);
2563  GST_blacklist_add_peer (&peer, pos);
2564  }
2565  GNUNET_free (plugs);
2566  }
2567  (*res)++;
2568 }
2569 
2570 
2577 static void
2579  const struct GNUNET_PeerIdentity *my_id)
2580 {
2581  char cfg_sect[512];
2582  unsigned int res = 0;
2583 
2584  GNUNET_snprintf (cfg_sect,
2585  sizeof(cfg_sect),
2586  "transport-blacklist-%s",
2587  GNUNET_i2s_full (my_id));
2589  cfg_sect,
2591  &res);
2593  "Loaded %u blacklisting entries from configuration\n",
2594  res);
2595 }
2596 
2597 
2605 static void
2606 run (void *cls,
2607  const struct GNUNET_CONFIGURATION_Handle *c,
2609 {
2610  char *keyfile;
2612  long long unsigned int max_fd_cfg;
2613  int max_fd_rlimit;
2614  int max_fd;
2615  int friend_only;
2616 
2617  /* setup globals */
2618  GST_cfg = c;
2620  "PEER",
2621  "PRIVATE_KEY",
2622  &keyfile))
2623  {
2624  GNUNET_log (
2626  _ (
2627  "Transport service is lacking key configuration settings. Exiting.\n"));
2629  return;
2630  }
2632  "transport",
2633  "HELLO_EXPIRATION",
2634  &hello_expiration))
2635  {
2637  }
2639  GNUNET_free (keyfile);
2640  GNUNET_assert (NULL != pk);
2641  GST_my_private_key = pk;
2642 
2643  GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
2644  GST_peerinfo = GNUNET_PEERINFO_connect (GST_cfg);
2645  GNUNET_CRYPTO_eddsa_key_get_public (GST_my_private_key,
2647  GNUNET_assert (NULL != GST_my_private_key);
2648 
2650  "My identity is `%s'\n",
2652 
2654  if (NULL == GST_peerinfo)
2655  {
2657  _ ("Could not access PEERINFO service. Exiting.\n"));
2659  return;
2660  }
2661 
2662  max_fd_rlimit = 0;
2663 #if HAVE_GETRLIMIT
2664  {
2665  struct rlimit r_file;
2666 
2667  if (0 == getrlimit (RLIMIT_NOFILE, &r_file))
2668  {
2669  max_fd_rlimit = r_file.rlim_cur;
2671  "Maximum number of open files was: %u/%u\n",
2672  (unsigned int) r_file.rlim_cur,
2673  (unsigned int) r_file.rlim_max);
2674  }
2675  max_fd_rlimit =
2676  (9 * max_fd_rlimit) / 10; /* Keep 10% for rest of transport */
2677  }
2678 #endif
2680  "transport",
2681  "MAX_FD",
2682  &max_fd_cfg))
2683  max_fd_cfg = max_fd_rlimit;
2684 
2685  if (max_fd_cfg > max_fd_rlimit)
2686  max_fd = max_fd_cfg;
2687  else
2688  max_fd = max_fd_rlimit;
2689  if (max_fd < DEFAULT_MAX_FDS)
2690  max_fd = DEFAULT_MAX_FDS;
2691 
2693  "Limiting number of sockets to %u: validation %u, neighbors: %u\n",
2694  max_fd,
2695  (max_fd / 3),
2696  (max_fd / 3) * 2);
2697 
2698  friend_only =
2699  GNUNET_CONFIGURATION_get_value_yesno (GST_cfg, "topology", "FRIENDS-ONLY");
2700  if (GNUNET_SYSERR == friend_only)
2701  friend_only = GNUNET_NO; /* According to topology defaults */
2702  /* start subsystems */
2703  /* Disable DSTJ peer */
2704  {
2705  struct GNUNET_PeerIdentity dstj;
2706  const char *ds = "DSTJBRRKZ8TBW3FGK6B0M5QXWT9WYNZ45H5MCV4HY7ST64Q8T9F0";
2707 
2708  GNUNET_assert (
2709  GNUNET_OK ==
2711  strlen (ds),
2712  &dstj.public_key));
2713  GST_blacklist_add_peer (&dstj, NULL);
2714  }
2716  GST_is = GNUNET_NT_scanner_init ();
2717  GST_ats_connect = GNUNET_ATS_connectivity_init (GST_cfg);
2718  GST_ats =
2720  GST_ats_init ();
2726  GST_hello_start (friend_only, &process_hello_update, NULL);
2727  GST_neighbours_start ((max_fd / 3) * 2);
2728  active_stccs = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
2729  plugin_nc = GNUNET_notification_context_create (0);
2730  GST_validation_start ((max_fd / 3));
2731 }
2732 
2733 
2738  "transport",
2740  &run,
2743  NULL,
2746  struct StartMessage,
2747  NULL),
2748  GNUNET_MQ_hd_var_size (client_hello,
2750  struct GNUNET_MessageHeader,
2751  NULL),
2754  struct OutboundMessage,
2755  NULL),
2756  GNUNET_MQ_hd_var_size (client_address_to_string,
2758  struct AddressLookupMessage,
2759  NULL),
2760  GNUNET_MQ_hd_fixed_size (client_monitor_peers,
2762  struct PeerMonitorMessage,
2763  NULL),
2764  GNUNET_MQ_hd_fixed_size (client_blacklist_init,
2766  struct GNUNET_MessageHeader,
2767  NULL),
2768  GNUNET_MQ_hd_fixed_size (client_blacklist_reply,
2770  struct BlacklistMessage,
2771  NULL),
2772  GNUNET_MQ_hd_fixed_size (client_set_metric,
2774  struct TrafficMetricMessage,
2775  NULL),
2776  GNUNET_MQ_hd_fixed_size (client_monitor_plugins,
2778  struct GNUNET_MessageHeader,
2779  NULL),
2781 
2782 
2783 /* end of file gnunet-service-transport.c */
struct GNUNET_CRYPTO_EddsaPrivateKey * GST_my_private_key
Our private key.
static void plugin_session_info_cb(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 ...
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK.
Definition: transport.h:221
struct GNUNET_HELLO_Address * address
Address for GST_blacklist_abort_matching(), can be NULL.
size_t address_length
Number of bytes in address.
Handle to the interface scanner.
Definition: nt.c:110
struct GNUNET_PeerIdentity id
Identity of the new neighbour.
Definition: transport.h:141
Closure for call_iterator().
enum GNUNET_HELLO_AddressInfo local_info
Extended information about address.
static void done()
Message used to notify the transport API about an address to string conversion.
Definition: transport.h:323
uint32_t num_bytes_pending
Number of bytes pending transmission for this session.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static struct GNUNET_CONTAINER_MultiPeerMap * active_stccs
Map of peer identities to active send transmit continuation contexts.
struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:653
void GST_neighbours_iterate(GST_NeighbourIterator cb, void *cb_cls)
Iterate over all connected neighbours.
Handle to the peerinfo service.
Definition: peerinfo_api.c:84
The notification context is the key datastructure for a convenience API used for transmission of noti...
Definition: nc.c:75
struct GNUNET_PeerIdentity monitor_peer
Peer identity to monitor the addresses of.
static struct GNUNET_CRYPTO_EddsaPrivateKey * pk
Private key of this peer.
int GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
It is a monitor, forward monitor data.
void GST_clients_broadcast(const struct GNUNET_MessageHeader *msg, int may_drop)
Broadcast the given message to all of our clients.
void(* GST_BlacklistTestContinuation)(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, int result)
Continuation called from a blacklist test.
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.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
struct TransportClient * tc
Handle to the blacklisting client we need to ask.
GNUNET_TRANSPORT_PeerState
Possible state of a neighbour.
uint64_t rel_value_us
The actual value.
Context we use when performing a blacklist check.
void GST_validation_start(unsigned int max_fds)
Start the validation subsystem.
static struct GNUNET_ATS_SessionKiller * sk_head
Head of DLL of asynchronous tasks to kill sessions.
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_SEND.
Definition: transport.h:289
struct GNUNET_TIME_Absolute send_time
At what time did we receive the message?
const void * address
Binary representation of the address (plugin-specific).
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT
Monitoring event about the connection state of plugins, generated in response to a subscription initi...
void GNUNET_CONFIGURATION_iterate_section_values(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, GNUNET_CONFIGURATION_Iterator iter, void *iter_cls)
Iterate over values of a section in the configuration.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_PING
Transport PING message.
void GST_plugins_monitor_subscribe(GNUNET_TRANSPORT_SessionInfoCallback cb, void *cb_cls)
Register callback with all plugins to monitor their status.
static void plugin_env_session_start(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, enum GNUNET_NetworkType scope)
Plugin tells transport service about a new inbound session.
common internal definitions for transport service
struct GNUNET_PeerIdentity peer
Which peer is being blacklisted or queried?
Definition: transport.h:602
static void send_peer_information(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
Output information of neighbours to the given client.
void GST_neighbours_keepalive_response(const struct GNUNET_PeerIdentity *neighbour, const struct GNUNET_MessageHeader *m)
We received a KEEP_ALIVE_RESPONSE message and use this to calculate latency to this peer...
uint32_t addr_len
Length of the following string, zero if is GNUNET_SYSERR.
Definition: transport.h:339
void GST_ats_done()
Shutdown ATS subsystem.
struct GNUNET_STATISTICS_Handle * GST_stats
Statistics handle.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
Handle to the ATS subsystem for bandwidth/transport scheduling information.
Handle to a service.
Definition: service.c:116
struct GNUNET_PEERINFO_Handle * GNUNET_PEERINFO_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the peerinfo service.
Definition: peerinfo_api.c:130
static void handle_client_blacklist_init(void *cls, const struct GNUNET_MessageHeader *message)
Initialize a blacklisting client.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
struct GNUNET_PeerIdentity GST_my_identity
Configuration handle.
uint32_t local_address_info
Local info about the address.
Definition: transport.h:562
int GST_neighbours_handle_session_syn(const struct GNUNET_MessageHeader *message, const struct GNUNET_PeerIdentity *peer)
We received a &#39;SYN&#39; message from the other peer.
void GST_plugins_load(GNUNET_TRANSPORT_PluginReceiveCallback recv_cb, GNUNET_TRANSPORT_AddressNotification address_cb, GNUNET_TRANSPORT_SessionStart session_start_cb, GNUNET_TRANSPORT_SessionEnd session_end_cb)
Load and initialize all plugins.
struct GNUNET_TRANSPORT_PluginFunctions * plugin
Plugin for the session.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
struct GST_BlacklistCheck * GST_blacklist_test_allowed(const struct GNUNET_PeerIdentity *peer, const char *transport_name, GST_BlacklistTestContinuation cont, void *cont_cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Test if a peer/transport combination is blacklisted.
int16_t 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; Value given in NBO.
Definition: transport.h:629
void GST_blacklist_abort_matching(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Abort blacklist if address and session match.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT.
Definition: transport.h:122
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
int client_send(struct GNUNET_ATS_Session *s, struct HTTP_Message *msg)
uint32_t is_allowed
0 for the query, GNUNET_OK (allowed) or GNUNET_SYSERR (disallowed) for the response.
Definition: transport.h:597
static void handle_client_set_metric(void *cls, const struct TrafficMetricMessage *tm)
Set traffic metric to manipulate.
void GST_manipulation_stop()
Stop traffic manipulation.
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;
int GST_neighbours_test_connected(const struct GNUNET_PeerIdentity *target)
Test if we&#39;re connected to the given peer.
struct GNUNET_PeerIdentity peer
Which peer should receive the message?
Definition: transport.h:308
struct GNUNET_PeerIdentity peer
Which peer is this connection for?
Definition: transport.h:654
enum GNUNET_TRANSPORT_SessionState state
New state of the session.
int GST_validation_handle_ping(const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *hdr, const struct GNUNET_HELLO_Address *sender_address, struct GNUNET_ATS_Session *session)
We&#39;ve received a PING.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_QUOTA
Message exchanged between transport services to indicate that the sender should limit its transmissio...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_BANDWIDTH_Value32NBO quota_out
Current outbound quota for this peer.
Definition: transport.h:135
void GST_hello_start(int friend_only, GST_HelloCallback cb, void *cb_cls)
Initialize the HELLO module.
GNUNET_SERVICE_MAIN("transport", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(client_start, GNUNET_MESSAGE_TYPE_TRANSPORT_START, struct StartMessage, NULL), GNUNET_MQ_hd_var_size(client_hello, GNUNET_MESSAGE_TYPE_HELLO, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_var_size(client_send, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, struct OutboundMessage, NULL), GNUNET_MQ_hd_var_size(client_address_to_string, GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING, struct AddressLookupMessage, NULL), GNUNET_MQ_hd_fixed_size(client_monitor_peers, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST, struct PeerMonitorMessage, NULL), GNUNET_MQ_hd_fixed_size(client_blacklist_init, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(client_blacklist_reply, GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY, struct BlacklistMessage, NULL), GNUNET_MQ_hd_fixed_size(client_set_metric, GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC, struct TrafficMetricMessage, NULL), GNUNET_MQ_hd_fixed_size(client_monitor_plugins, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_START, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static int free_blacklist_entry(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Free the given entry in the blacklist.
struct GNUNET_PeerIdentity target
Peer that was the target.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:418
GNUNET_TRANSPORT_DisconnectSessionFunction disconnect_session
Function that can be used to force the plugin to disconnect from the given peer and cancel all previo...
struct GNUNET_TIME_AbsoluteNBO state_timeout
Timeout for the state this peer is in.
Definition: transport.h:557
static void transmit_address_to_client(void *cls, const char *buf, int res)
Take the given address and append it to the set of results sent back to the client.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
int GST_neighbours_session_terminated(const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *session)
A session was terminated.
static void notify_client_about_neighbour(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
Function called for each of our connected neighbours.
static struct GNUNET_TRANSPORT_CoreHandle * transport
Transport service.
struct GNUNET_ATS_SchedulingHandle * GNUNET_ATS_scheduling_init(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressSuggestionCallback suggest_cb, void *suggest_cb_cls)
Initialize the ATS subsystem.
static struct GNUNET_TIME_Relative process_payload(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_MessageHeader *message)
We received some payload.
static void handle_send_transmit_continuation(void *cls, int success, size_t bytes_payload, size_t bytes_on_wire)
Function called after the transmission is done.
static int mark_match_down(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Mark the peer as down so we don&#39;t call the continuation context in the future.
void GNUNET_ATS_scheduling_done(struct GNUNET_ATS_SchedulingHandle *sh)
Client is done with ATS scheduling, release resources.
int client_start(struct Plugin *plugin)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
Message from the transport service to the library containing information about a peer.
Definition: transport.h:537
#define GNUNET_CONSTANTS_LATENCY_WARN
After what amount of latency for a message do we print a warning?
static void blacklist_cfg_iter(void *cls, const char *section, const char *option, const char *value)
Function to iterate over options in the blacklisting section for a peer.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
We do not know yet (client is fresh).
void GST_clients_broadcast_peer_notification(const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout)
Broadcast the new active address to all clients monitoring the peer.
static void confirm_or_drop_neighbour(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, int allowed)
Got the result about an existing connection from a new blacklister.
interfacing between transport and ATS service
static int check_client_hello(void *cls, const struct GNUNET_MessageHeader *message)
Client sent us a HELLO.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION
After how long do we expire an address in a HELLO that we just validated? This value is also used for...
#define GNUNET_NO
Definition: gnunet_common.h:78
static int numeric
Option -n.
static struct GNUNET_CONTAINER_MultiPeerMap * addresses
Hashmap to store addresses.
Definition: gnunet-ats.c:146
#define GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC
Message containing traffic metrics for transport service.
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_ATS_SessionKiller * next
Kept in a DLL.
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
int GST_validation_handle_hello(const struct GNUNET_MessageHeader *hello)
We&#39;ve received a HELLO, check which addresses are new and trigger validation.
static void kill_session_task(void *cls)
Task to asynchronously terminate a session.
static void handle_client_monitor_plugins(void *cls, const struct GNUNET_MessageHeader *message)
Client asked to obtain information about all plugin connections.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Closure for test_connection_ok().
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct TransportClient * clients_tail
Tail of linked list of all clients to this service.
struct GNUNET_PeerIdentity self
Identity we think we have.
Definition: transport.h:109
void GST_validation_stop()
Stop the validation subsystem.
struct GNUNET_PeerIdentity id
Which peers do we care about?
struct GNUNET_TRANSPORT_PluginFunctions * GST_plugins_printer_find(const char *name)
Obtain the plugin API based on a the stripped plugin name after the underscore.
static void do_blacklist_check(void *cls)
Perform next action in the blacklist check.
void GST_neighbours_keepalive(const struct GNUNET_PeerIdentity *neighbour, const struct GNUNET_MessageHeader *m)
Keep the connection to the given neighbour alive longer, we received a KEEPALIVE (or equivalent); sen...
struct GNUNET_SERVICE_Client * client
Handle to the client.
static struct TransportClient * clients_head
Head of linked list of all clients to this service.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct GNUNET_ATS_SchedulingHandle * GST_ats
ATS scheduling handle.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Called whenever a client connects.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
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.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
Handle for the service.
uint32_t addrlen
Address length.
Definition: transport.h:572
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void GNUNET_notification_context_add(struct GNUNET_NotificationContext *nc, struct GNUNET_MQ_Handle *mq)
Add a subscriber to the notification context.
Definition: nc.c:160
ATS performance characteristics for an address.
struct GST_BlacklistCheck * next
This is a linked list.
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 struct TransportClient * sync_client
Plugin monitoring client we are currently syncing, NULL if all monitoring clients are in sync...
enum ClientType type
What type of client is this?
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE_RESPONSE
Response to a GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE message to measure latency in a regular...
It is a blacklist, query about allowed connections.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
Request to TRANSPORT to transmit a message.
struct GNUNET_TIME_Absolute receive_delay
Until when does this plugin refuse to receive to manage staying within the inbound quota...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
Message from TRANSPORT notifying about a client that connected to us.
uint32_t value__
The actual value (bytes per second).
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static char * section
Name of the section.
Definition: gnunet-config.c:33
ClientType
What type of client is the struct TransportClient about?
#define MAX_PENDING
How many messages can we have pending for a given client process before we start to drop incoming mes...
static void plugin_env_session_end(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Function that will be called whenever the plugin internally cleans up a session pointer and hence the...
int GST_neighbours_handle_session_syn_ack(const struct GNUNET_MessageHeader *message, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
We received a &#39;SESSION_SYN_ACK&#39; message from the other peer.
Handle to a client that is connected to a service.
Definition: service.c:250
static void read_blacklist_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *my_id)
Read blacklist configuration.
struct GNUNET_ATS_Session * session
Session for GST_blacklist_abort_matching(), can be NULL.
void GST_neighbours_start(unsigned int max_fds)
Initialize the neighbours subsystem.
struct GNUNET_TIME_Relative GST_neighbours_calculate_receive_delay(const struct GNUNET_PeerIdentity *sender, ssize_t size, int *do_forward)
We have received a message from the given sender.
int GNUNET_HELLO_address_check_option(const struct GNUNET_HELLO_Address *address, enum GNUNET_HELLO_AddressInfo option)
Check if an address has a local option set.
Definition: address.c:39
static struct GST_BlacklistCheck * bc_head
Head of DLL of active blacklisting queries.
uint32_t state
State this peer is in as an enum GNUNET_TRANSPORT_PeerState
Definition: transport.h:567
#define GNUNET_MESSAGE_TYPE_HELLO_LEGACY
Previously used for HELLO messages used for communicating peer addresses.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END
Response to GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE_END terminating list of replies...
struct GNUNET_NT_InterfaceScanner * GST_is
Interface scanner determines our LAN address range(s).
Information about a plugin&#39;s session.
struct TransportClient * tc
Client that made the request.
Change in blacklisting (either request or notification, depending on which direction it is going)...
Definition: transport.h:585
uint16_t success
GNUNET_OK if the transmission succeeded, GNUNET_SYSERR if it failed (i.e.
Definition: transport.h:234
static void plugin_env_address_change_notification(void *cls, int add_remove, const struct GNUNET_HELLO_Address *address)
Function that will be called for each address the transport is aware that it might be reachable under...
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
struct AddressToStringContext * next
This is a doubly-linked list.
uint32_t res
GNUNET_OK if the conversion succeeded, GNUNET_SYSERR if it failed
Definition: transport.h:334
int GST_validation_handle_pong(const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *hdr)
We&#39;ve received a PONG.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
struct TransportClient * tc
Client that made the request.
void GST_manipulation_set_metric(const struct TrafficMetricMessage *tm)
Set traffic metric to manipulate.
void GST_neighbours_handle_disconnect_message(const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *msg)
We received a disconnect message from the given peer, validate and process.
int first
Is this the first neighbour we&#39;re checking?
struct GNUNET_TIME_Relative GST_manipulation_recv(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_MessageHeader *message)
Adapter function between transport plugins and transport receive function manipulation delays for nex...
enum State state
current state of profiling
uint32_t reserved
Reserved, always zero.
Definition: transport.h:159
void * cls
Closure for all of the callbacks.
void GST_neighbours_stop()
Cleanup the neighbours subsystem.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN_ACK
Transport SYN_ACK message exchanged between transport services to indicate that a SYN message was acc...
const struct GNUNET_HELLO_Address * GST_neighbour_get_current_address(const struct GNUNET_PeerIdentity *peer)
Obtain current address information for the given neighbour.
static char * value
Value of the record to add/remove.
int GST_neighbours_handle_session_ack(const struct GNUNET_MessageHeader *message, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
We received a &#39;ACK&#39; message from the other peer.
static int mark_peer_down(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Mark the peer as down so we don&#39;t call the continuation context in the future.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY
Reply from blacklisting client (answer to blacklist query).
void GST_manipulation_init()
Initialize traffic manipulation.
static void kill_session(const char *plugin_name, struct GNUNET_ATS_Session *session)
Force plugin to terminate session due to communication issue.
Session handle for connections.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
struct GNUNET_ATS_Session * session
Session to kill.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
This is an inbound address and cannot be used to initiate an outbound connection to another peer...
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:335
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE
Response to GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST request to iterate over all known addr...
static void handle_client_hello(void *cls, const struct GNUNET_MessageHeader *message)
Client sent us a HELLO.
struct GST_BlacklistCheck * bc
Blacklist check that we&#39;re currently performing (or NULL if we&#39;re performing one that has been cancel...
unsigned int GNUNET_notification_context_get_size(struct GNUNET_NotificationContext *nc)
Return active number of subscribers in this context.
Definition: nc.c:215
static void handle_client_blacklist_reply(void *cls, const struct BlacklistMessage *msg)
A blacklisting client has sent us reply.
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
neighbour manipulation API, allows manipulation of performance metrics (delay and towards ATS) ...
static enum GNUNET_NetworkType scope
Which network scope do we belong to?
Message from the library to the transport service asking for binary addresses known for a peer...
Definition: transport.h:470
struct GNUNET_PeerIdentity peer
The identity of the peer to look up.
Definition: transport.h:485
uint16_t plugin_name_len
Length of the plugin name in bytes, including 0-termination.
Definition: transport.h:664
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
static struct PeerIterateResponseMessage * compose_address_iterate_response_message(const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address)
Compose PeerIterateResponseMessage using the given peer and address.
uint32_t bytes_physical
Size of message sent over wire.
Definition: transport.h:245
uint32_t options
0: no options 1: The self field should be checked 2: this client is interested in payload traffic ...
Definition: transport.h:103
#define GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING_REPLY
Response to the address lookup request.
static char * option
Name of the option.
Definition: gnunet-config.c:38
static char buf[2048]
uint16_t plugin_address_len
Length of the plugin address in bytes.
Definition: transport.h:669
const char * transport_name
Name of the transport plugin enabling the communication using this address.
Message from the transport service to the library informing about neighbors.
Definition: transport.h:117
static int result
Global testing status.
static void plugin_env_session_start_bl_check_cont(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, int result)
Black list check result from blacklist check triggered when a plugin gave us a new session in plugin_...
uint32_t msgs_pending
Number of messages waiting transmission.
Definition: transport.h:634
struct GNUNET_TIME_RelativeNBO timeout
Allowed delay.
Definition: transport.h:302
struct GNUNET_TIME_Relative hello_expiration
Hello address expiration.
Message from the library to the transport service asking for binary addresses known for a peer...
Definition: transport.h:493
int down
Set to GNUNET_YES if the connection for target goes down and we thus must no longer send the GNUNET_M...
void GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c)
Set the &#39;monitor&#39; flag on this client.
Definition: service.c:2407
#define GNUNET_MESSAGE_TYPE_TRANSPORT_START
Message from the core saying that the transport server should start giving it messages.
void GST_neighbours_notify_data_recv(const struct GNUNET_HELLO_Address *address, const struct GNUNET_MessageHeader *message)
Track information about data we received from the given address (used to notify ATS about our utiliza...
void GST_ats_add_inbound_address(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_ATS_Properties *prop)
Notify ATS about a new inbound address.
void GST_clients_broadcast_disconnect(const struct GNUNET_PeerIdentity *peer)
Notify all clients about a disconnect, and cancel pending SEND_OK messages for this peer...
struct GNUNET_TIME_Absolute session_timeout
At what time will this session timeout (unless activity happens)?
const char * GST_plugins_a2s(const struct GNUNET_HELLO_Address *address)
Convert a given address to a human-readable format.
static void ats_request_address_change(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in)
Function called by ATS to notify the callee that the assigned bandwidth or address for a given peer w...
Internal representation of the hash map.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:641
int16_t numeric_only
Should the conversion use numeric IP addresses (otherwise a reverse DNS lookup is OK – if applicable...
Definition: transport.h:359
struct GNUNET_TRANSPORT_PluginFunctions * GST_plugins_find(const char *name)
Obtain the plugin API based on a plugin name.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST
Request to monitor addresses used by a peer or all peers.
int all
GNUNET_YES if id should be ignored because we want all peers.
static struct AddressToStringContext * a2s_tail
Tail of linked list of all pending address iterations.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_START
Request to start monitoring the connection state of plugins.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
Message from TRANSPORT notifying about a client that disconnected from us.
static int res
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
void GST_manipulation_send(const struct GNUNET_PeerIdentity *target, const void *msg, size_t msg_size, struct GNUNET_TIME_Relative timeout, GST_NeighbourSendContinuation cont, void *cont_cls)
Adapter function between transport&#39;s send function and transport plugins.
struct GNUNET_TIME_AbsoluteNBO timeout
When will this transport plugin session time out?
Definition: transport.h:644
void GNUNET_NT_scanner_done(struct GNUNET_NT_InterfaceScanner *is)
Terminate interface scanner.
Definition: nt.c:433
unsigned long long uuid
Unique ID, for logging.
const struct GNUNET_CONFIGURATION_Handle * GST_cfg
Configuration handle.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_SYNC
Monitoring event notifying client that the initial iteration is now completed and we are in sync with...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_KEEPALIVE
Message send by a peer to notify the other to keep the session alive and measure latency in a regular...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING
Request to look addresses of peers in server.
void GST_blacklist_add_peer(const struct GNUNET_PeerIdentity *peer, const char *transport_name)
Add the given peer to the blacklist (for the given transport).
Message used to notify the transport service about a message to be transmitted to another peer...
Definition: transport.h:284
static void handle_client_send(void *cls, const struct OutboundMessage *obm)
Client asked for transmission to a peer.
Message from the transport service to the library asking to check if both processes agree about this ...
Definition: transport.h:91
CORE client without any handlers.
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT.
Definition: transport.h:154
const char * GNUNET_TRANSPORT_ps2s(enum GNUNET_TRANSPORT_PeerState state)
Convert a transport state to a human readable string.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_PeerIdentity peer
Which peer sent the message?
Definition: transport.h:208
struct GNUNET_MQ_Handle * mq
Message queue to the client.
Transport-level connection status update.
Definition: transport.h:609
struct GNUNET_TIME_Relative GST_receive_callback(void *cls, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, const struct GNUNET_MessageHeader *message)
Function called by the transport for each received message.
int call_receive_done
GNUNET_YES if we have to call receive_done for this client
static struct GNUNET_ATS_SessionKiller * sk_tail
Tail of DLL of asynchronous tasks to kill sessions.
Message from the transport service to the library informing about disconnects.
Definition: transport.h:149
struct GNUNET_TIME_RelativeNBO timeout
timeout to give up (for DNS resolution timeout mostly)
Definition: transport.h:369
struct GNUNET_NT_InterfaceScanner * GNUNET_NT_scanner_init(void)
Initialize the address characterization client handle.
Definition: nt.c:412
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static void unicast(struct TransportClient *tc, const struct GNUNET_MessageHeader *msg, int may_drop)
Queue the given message for transmission to the given client.
void GST_blacklist_test_cancel(struct GST_BlacklistCheck *bc)
Cancel a blacklist check.
static void handle_client_start(void *cls, const struct StartMessage *start)
Initialize a normal client.
uint32_t bytes_pending
Number of bytes waiting for transmission.
Definition: transport.h:639
uint16_t bytes_msg
Size of message sent.
Definition: transport.h:239
GST_BlacklistTestContinuation cont
Continuation to call with the result.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
static void shutdown_task(void *cls)
Function called when the service shuts down.
32-bit bandwidth used for network exchange by GNUnet, in bytes per second.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
Confirmation from TRANSPORT that message for transmission has been queued (and that the next message ...
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
Called whenever a client is disconnected.
void GST_neighbours_switch_to_address(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
For the given peer, switch to this address.
struct TransportClient::@78::@79 blacklist
Additional details if type is CT_BLACKLIST.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_DISCONNECT
Transport DISCONNECT message exchanged between transport services to indicate that a connection shoul...
static struct GNUNET_CONTAINER_MultiPeerMap * blacklist
Hashmap of blacklisted peers.
static int check_client_address_to_string(void *cls, const struct AddressLookupMessage *alum)
Client asked to resolve an address.
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_ATS_ConnectivityHandle * GST_ats_connect
ATS connectivity handle.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:270
#define GNUNET_MESSAGE_TYPE_TRANSPORT_PONG
Transport PONG message.
struct GNUNET_NotificationContext * GNUNET_notification_context_create(unsigned int queue_length)
Create a new notification context.
Definition: nc.c:121
Message from the library to the transport service asking for converting a transport address to a huma...
Definition: transport.h:348
static int test_blacklisted(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Test if the given blacklist entry matches.
struct TransportClient * next
Kept in a DLL.
void GST_neighbours_force_disconnect(const struct GNUNET_PeerIdentity *target)
If we have an active connection to the given target, it must be shutdown.
enum GNUNET_NetworkType scope
Which network scope does the respective address belong to? This property does not change...
Allow multiple values with the same key.
struct AddressToStringContext * prev
This is a doubly-linked list.
Handle to a message queue.
Definition: mq.c:85
static struct GNUNET_PeerIdentity all_zeros
Peer identity that is all zeros, used as a way to indicate "all peers".
Information we need for an asynchronous session kill.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_SYN
Transport SYN message exchanged between transport services to indicate that a session should be marke...
uint32_t reserved
For alignment.
Definition: transport.h:547
struct GST_BlacklistCheck * prev
This is a linked list.
struct GNUNET_ATS_ConnectivityHandle * GNUNET_ATS_connectivity_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the ATS connectivity suggestion client handle.
Private ECC key encoded for transmission.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
int GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:499
static struct AddressToStringContext * a2s_head
Head of linked list of all pending address iterations.
uint64_t session_id
Unique identifier for the session.
Definition: transport.h:659
const struct GNUNET_MessageHeader * GST_hello_get()
Obtain this peers HELLO message.
void GNUNET_notification_context_broadcast(struct GNUNET_NotificationContext *nc, const struct GNUNET_MessageHeader *msg, int can_drop)
Send a message to all subscribers of this context.
Definition: nc.c:189
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
The identity of the host (wraps the signing key of the peer).
static void handle_client_monitor_peers(void *cls, const struct PeerMonitorMessage *msg)
Client asked to obtain information about a specific or all peers Process the request.
Message used to notify the transport API that it can send another message to the transport service...
Definition: transport.h:216
struct GNUNET_PeerIdentity peer
Which peer can send more now?
Definition: transport.h:251
struct TransportClient * bl_pos
Our current position in the blacklisters list.
struct GNUNET_SCHEDULER_Task * task
The kill task.
#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...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT
Register a client that wants to do blacklisting.
static void connect_bl_check_cont(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session, int result)
Black list check result for try_connect call If connection to the peer is allowed request adddress an...
uint16_t session_state
An enum GNUNET_TRANSPORT_SessionState in NBO.
Definition: transport.h:619
configuration data
Definition: configuration.c:85
struct GNUNET_TIME_AbsoluteNBO delay
Until how long is this plugin currently blocked from reading?
Definition: transport.h:649
struct GNUNET_PEERINFO_Handle * GST_peerinfo
Handle to peerinfo service.
void GST_plugins_unload()
Unload all plugins.
const char * name
#define GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
Message from TRANSPORT notifying about a message that was received.
uint32_t one_shot
One shot call or continous replies?
Definition: transport.h:480
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:375
struct GNUNET_SCHEDULER_Task * task
Current task performing the check.
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING.
Definition: transport.h:353
struct GNUNET_PeerIdentity peer
Who got disconnected?
Definition: transport.h:164
Closure for handle_send_transmit_continuation()
An address for communicating with a peer.
void GST_neighbours_handle_quota_message(const struct GNUNET_PeerIdentity *peer, const struct GNUNET_MessageHeader *msg)
We received a quota message from the given peer, validate and process.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
Automatic transport selection and outbound bandwidth determination.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
Client connected to the transport service.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
#define DEFAULT_MAX_FDS
What&#39;s the maximum number of sockets transport uses for validation and neighbors. ...
Definition: transport.h:52
static struct GNUNET_NotificationContext * plugin_nc
Notification context, to send updates on changes to active plugin connections.
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_file(const char *filename)
Create a new private key by reading it from a file.
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
void GNUNET_PEERINFO_disconnect(struct GNUNET_PEERINFO_Handle *h)
Disconnect from the peerinfo service.
Definition: peerinfo_api.c:156
struct GNUNET_PeerIdentity peer
Peer identity.
Definition: transport.h:552
void GST_ats_del_session(const struct GNUNET_HELLO_Address *address, struct GNUNET_ATS_Session *session)
Notify ATS that the session (but not the address) of a given address is no longer relevant...
void GST_neighbours_send(const struct GNUNET_PeerIdentity *target, const void *msg, size_t msg_size, struct GNUNET_TIME_Relative timeout, GST_NeighbourSendContinuation cont, void *cont_cls)
Transmit a message to the given target using the active connection.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE.
Definition: transport.h:542
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SESSION_ACK
Transport ACK message exchanged between transport services to indicate that a SYN_ACK message was acc...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_QUERY
Query to a blacklisting client (is this peer blacklisted)?
static void transmit_our_hello(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
Transmit our HELLO message to the given (connected) neighbour.
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.
#define TRANSPORT_BLACKLIST_HT_SIZE
Size of the blacklist hash map.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
static struct GNUNET_FS_DirScanner * ds
Handle to the directory scanner (for recursive insertions).
void GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
Destroy the context, force disconnect for all subscribers.
Definition: nc.c:137
uint16_t addrlen
Length of the (binary) address in bytes, in big-endian.
Definition: transport.h:364
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct TransportClient * tc
Context to use for the transmission.
union TransportClient::@72 details
int waiting_for_reply
Set to GNUNET_YES if we&#39;re currently waiting for a reply.
uint32_t pluginlen
Length of the plugin name.
Definition: transport.h:577
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initiate transport service.
struct GNUNET_PeerIdentity peer
Peer being checked.
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_RECV.
Definition: transport.h:203
#define GNUNET_MESSAGE_TYPE_HELLO
HELLO message with friend only flag used for communicating peer addresses.
static void handle_client_address_to_string(void *cls, const struct AddressLookupMessage *alum)
Client asked to resolve an address.
void GNUNET_SERVICE_client_disable_continue_warning(struct GNUNET_SERVICE_Client *c)
Disable the warning the server issues if a message is not acknowledged in a timely fashion...
Definition: service.c:2267
struct GNUNET_ATS_SessionKiller * prev
Kept in a DLL.
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
void GST_hello_modify_addresses(int addremove, const struct GNUNET_HELLO_Address *address)
Add or remove an address from this peer&#39;s HELLO message.
Handle to the ATS subsystem for connectivity management.
void GNUNET_ATS_connectivity_done(struct GNUNET_ATS_ConnectivityHandle *ch)
Client is done with ATS connectivity management, release resources.
void * cont_cls
Closure for cont.
Is the CORE service, we need to forward traffic to it.
Context for address to string operations.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
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).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
void GST_validation_handle_address(const struct GNUNET_HELLO_Address *address)
Validate an individual address.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static char * plugin_name
Name of our plugin.
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
void GST_hello_stop()
Shutdown the HELLO module.
static void test_connection_ok(void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Address *address, enum GNUNET_TRANSPORT_PeerState state, struct GNUNET_TIME_Absolute state_timeout, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out)
Test if an existing connection is still acceptable given a new blacklisting client.
#define GNUNET_malloc(size)
Wrapper around malloc.
static void process_hello_update(void *cls, const struct GNUNET_MessageHeader *hello)
My HELLO has changed.
static int check_client_send(void *cls, const struct OutboundMessage *obm)
Client asked for transmission to a peer.
Message used to notify the transport API about a message received from the network.
Definition: transport.h:198
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
#define gettext_noop(String)
Definition: gettext.h:69
Category of last resort.
Definition: gnunet_nt_lib.h:40
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PLUGIN_EVENT.
Definition: transport.h:614
void GST_ats_init()
Initialize ATS subsystem.
static struct GST_BlacklistCheck * bc_tail
Tail of DLL of active blacklisting queries.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966