GNUnet  0.17.6
gnunet-communicator-tcp.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2010-2014, 2018, 2019 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
30 #include "platform.h"
31 #include "gnunet_util_lib.h"
32 #include "gnunet_core_service.h"
34 #include "gnunet_protocols.h"
35 #include "gnunet_signatures.h"
36 #include "gnunet_constants.h"
37 #include "gnunet_nt_lib.h"
38 #include "gnunet_nat_service.h"
42 
47 #define ADDRESS_VALIDITY_PERIOD \
48  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
49 
58 #define DEFAULT_MAX_QUEUE_LENGTH 8
59 
64 #define BUF_SIZE (2 * 64 * 1024 + sizeof(struct TCPBox))
65 
69 #define DEFAULT_REKEY_INTERVAL GNUNET_TIME_UNIT_DAYS
70 
74 #define PROTO_QUEUE_TIMEOUT GNUNET_TIME_UNIT_MINUTES
75 
80 #define REKEY_MAX_BYTES (1024LLU * 1024 * 1024 * 4LLU)
81 
86 #define INITIAL_KX_SIZE \
87  (sizeof(struct GNUNET_CRYPTO_EcdhePublicKey) \
88  + sizeof(struct TCPConfirmation))
89 
93 #define INITIAL_CORE_KX_SIZE \
94  (sizeof(struct EphemeralKeyMessage) \
95  + sizeof(struct PingMessage) \
96  + sizeof(struct PongMessage))
97 
101 #define COMMUNICATOR_ADDRESS_PREFIX "tcp"
102 
106 #define COMMUNICATOR_CONFIG_SECTION "communicator-tcp"
107 
109 
110 
116 {
121 
126 
131 
136 
142 
147 };
148 
154 {
159 
164 
169 
175 
180 };
181 
186 {
191 
196 
202 
207 
208 };
209 
214 {
215 
216 
221 
226 
231 
237 
242 
243 };
244 
248 struct TCPBox
249 {
257 
266  struct GNUNET_ShortHashCode hmac;
267 
268  /* followed by as may bytes of payload as indicated in @e header,
269  excluding the TCPBox itself! */
270 };
271 
272 
277 struct TCPRekey
278 {
283 
292  struct GNUNET_ShortHashCode hmac;
293 
298 
303 
309 };
310 
316 {
321 
326 
331 
336 
342 };
343 
349 struct TCPFinish
350 {
355 
364  struct GNUNET_ShortHashCode hmac;
365 };
366 
367 
369 
374 {
379 
384 };
385 
389 struct Queue
390 {
395 
400 
405 
409  gcry_cipher_hd_t in_cipher;
410 
414  gcry_cipher_hd_t out_cipher;
415 
419  struct GNUNET_HashCode in_hmac;
420 
425  struct GNUNET_HashCode out_hmac;
426 
432 
437 
442 
446  struct sockaddr *address;
447 
453 
459 
463  socklen_t address_len;
464 
469 
474 
478  unsigned long long bytes_in_queue;
479 
484 
489 
493  char pread_buf[UINT16_MAX + 1 + sizeof(struct TCPBox)];
494 
498  char pwrite_buf[UINT16_MAX + 1 + sizeof(struct TCPBox)];
499 
504  size_t cread_off;
505 
510  size_t cwrite_off;
511 
516  size_t pread_off;
517 
522  size_t pwrite_off;
523 
528 
536  unsigned int backpressure;
537 
541  enum GNUNET_NetworkType nt;
542 
547 
552 
557 
565 
570  int rekeyed;
571 
576 
581 
586 
591 
596 
601 
606 
611 
616 
621 
626 };
627 
628 
634 {
638  struct ProtoQueue *next;
639 
643  struct ProtoQueue *prev;
644 
649 
654 
659 
663  struct sockaddr *address;
664 
668  socklen_t address_len;
669 
674 
680 
684  size_t ibuf_off;
685 };
686 
691 {
695  struct sockaddr *addr_ipv4;
696 
700  socklen_t addr_len_ipv4;
701 
705  struct sockaddr *addr_ipv6;
706 
710  socklen_t addr_len_ipv6;
711 
712 };
713 
717 struct Addresses
718 {
722  struct Addresses *next;
723 
727  struct Addresses *prev;
728 
732  struct sockaddr *addr;
733 
737  socklen_t addr_len;
738 
739 };
740 
741 
745 static unsigned long long max_queue_length;
746 
751 
756 
761 
766 
770 static struct GNUNET_PeerIdentity my_identity;
771 
776 
781 
785 static const struct GNUNET_CONFIGURATION_Handle *cfg;
786 
791 
795 static struct GNUNET_NAT_Handle *nat;
796 
800 static struct ProtoQueue *proto_head;
801 
805 static struct ProtoQueue *proto_tail;
806 
811 
816 
821 
826 
831 
836 
840 // TODO remove?
842 
847 
852 
856 unsigned int bind_port;
857 
865 static void
866 listen_cb (void *cls);
867 
875 static void
877 {
878  struct ListenTask *lt = NULL;
879  struct GNUNET_HashCode h_sock;
880  int sockfd;
881 
882  if (NULL != queue->listen_sock)
883  {
884  sockfd = GNUNET_NETWORK_get_fd (queue->listen_sock);
885  GNUNET_CRYPTO_hash (&sockfd,
886  sizeof(int),
887  &h_sock);
888 
890  }
891 
893  "Disconnecting queue for peer `%s'\n",
894  GNUNET_i2s (&queue->target));
895  if (NULL != queue->rekey_monotime_sc)
896  {
897  GNUNET_PEERSTORE_store_cancel (queue->rekey_monotime_sc);
898  queue->rekey_monotime_sc = NULL;
899  }
900  if (NULL != queue->handshake_monotime_sc)
901  {
902  GNUNET_PEERSTORE_store_cancel (queue->handshake_monotime_sc);
903  queue->handshake_monotime_sc = NULL;
904  }
905  if (NULL != queue->handshake_ack_monotime_sc)
906  {
907  GNUNET_PEERSTORE_store_cancel (queue->handshake_ack_monotime_sc);
908  queue->handshake_ack_monotime_sc = NULL;
909  }
910  if (NULL != queue->rekey_monotime_get)
911  {
912  GNUNET_PEERSTORE_iterate_cancel (queue->rekey_monotime_get);
913  queue->rekey_monotime_get = NULL;
914  }
915  if (NULL != queue->handshake_monotime_get)
916  {
917  GNUNET_PEERSTORE_iterate_cancel (queue->handshake_monotime_get);
918  queue->handshake_monotime_get = NULL;
919  }
920  if (NULL != queue->handshake_ack_monotime_get)
921  {
922  GNUNET_PEERSTORE_iterate_cancel (queue->handshake_ack_monotime_get);
923  queue->handshake_ack_monotime_get = NULL;
924  }
925  if (NULL != queue->qh)
926  {
928  queue->qh = NULL;
929  }
930  GNUNET_assert (
931  GNUNET_YES ==
934  "# queues active",
936  GNUNET_NO);
937  if (NULL != queue->read_task)
938  {
939  GNUNET_SCHEDULER_cancel (queue->read_task);
940  queue->read_task = NULL;
941  }
942  if (NULL != queue->write_task)
943  {
944  GNUNET_SCHEDULER_cancel (queue->write_task);
945  queue->write_task = NULL;
946  }
948  {
950  "closing socket failed\n");
951  }
952  gcry_cipher_close (queue->in_cipher);
953  gcry_cipher_close (queue->out_cipher);
954  GNUNET_free (queue->address);
955  if (0 != queue->backpressure)
956  queue->destroyed = GNUNET_YES;
957  else
958  GNUNET_free (queue);
959 
960  if (NULL == lt)
961  return;
962 
963  if ((! shutdown_running) && (NULL == lt->listen_task))
964  {
966  "add read net listen\n");
969  lt->listen_sock,
970  &listen_cb,
971  lt);
972  }
973  else
974  GNUNET_free (lt);
975 }
976 
977 
986 static void
987 calculate_hmac (struct GNUNET_HashCode *hmac_secret,
988  const void *buf,
989  size_t buf_size,
990  struct GNUNET_ShortHashCode *smac)
991 {
992  struct GNUNET_HashCode mac;
993 
994  GNUNET_CRYPTO_hmac_raw (hmac_secret,
995  sizeof(struct GNUNET_HashCode),
996  buf,
997  buf_size,
998  &mac);
999  /* truncate to `struct GNUNET_ShortHashCode` */
1000  memcpy (smac, &mac, sizeof(struct GNUNET_ShortHashCode));
1001  /* ratchet hmac key */
1002  GNUNET_CRYPTO_hash (hmac_secret,
1003  sizeof(struct GNUNET_HashCode),
1004  hmac_secret);
1005 }
1006 
1007 
1014 static void
1016 {
1017  struct TCPFinish fin;
1018 
1019  memset (&fin, 0, sizeof(fin));
1020  fin.header.size = htons (sizeof(fin));
1022  calculate_hmac (&queue->out_hmac, &fin, sizeof(fin), &fin.hmac);
1023  /* if there is any message left in pwrite_buf, we
1024  overwrite it (possibly dropping the last message
1025  from CORE hard here) */
1026  memcpy (queue->pwrite_buf, &fin, sizeof(fin));
1027  queue->pwrite_off = sizeof(fin);
1028  /* This flag will ensure that #queue_write() no longer
1029  notifies CORE about the possibility of sending
1030  more data, and that #queue_write() will call
1031  #queue_destroy() once the @c fin was fully written. */
1032  queue->finishing = GNUNET_YES;
1033 }
1034 
1035 
1043 static void
1045 {
1046  queue->timeout =
1048 }
1049 
1050 
1056 static void
1057 queue_read (void *cls);
1058 
1059 
1067 static void
1068 core_read_finished_cb (void *cls, int success)
1069 {
1070  struct Queue *queue = cls;
1071  if (GNUNET_OK != success)
1073  "# messages lost in communicator API towards CORE",
1074  1,
1075  GNUNET_NO);
1076  if (NULL == queue)
1077  return;
1078 
1080  "backpressure %u\n",
1081  queue->backpressure);
1082 
1083  queue->backpressure--;
1084  /* handle deferred queue destruction */
1085  if ((queue->destroyed) && (0 == queue->backpressure))
1086  {
1087  GNUNET_free (queue);
1088  return;
1089  }
1090  else if (GNUNET_YES != queue->destroyed)
1091  {
1093  /* possibly unchoke reading, now that CORE made progress */
1094  if (NULL == queue->read_task)
1095  queue->read_task =
1097  queue->timeout),
1098  queue->sock,
1099  &queue_read,
1100  queue);
1101  }
1102 }
1103 
1104 
1114 static void
1116  const void *plaintext,
1117  size_t plaintext_len)
1118 {
1119  const struct GNUNET_MessageHeader *hdr = plaintext;
1120  int ret;
1121 
1123  "pass message from %s to core\n",
1124  GNUNET_i2s (&queue->target));
1125 
1126  if (ntohs (hdr->size) != plaintext_len)
1127  {
1128  /* NOTE: If we ever allow multiple CORE messages in one
1129  BOX, this will have to change! */
1130  GNUNET_break (0);
1131  return;
1132  }
1134  &queue->target,
1135  hdr,
1138  queue);
1140  "passed to core\n");
1141  if (GNUNET_OK == ret)
1142  queue->backpressure++;
1143  GNUNET_break (GNUNET_NO != ret); /* backpressure not working!? */
1144  if (GNUNET_SYSERR == ret)
1146  "# bytes lost due to CORE not running",
1147  plaintext_len,
1148  GNUNET_NO);
1149 }
1150 
1151 
1161 static void
1162 setup_cipher (const struct GNUNET_HashCode *dh,
1163  const struct GNUNET_PeerIdentity *pid,
1164  gcry_cipher_hd_t *cipher,
1165  struct GNUNET_HashCode *hmac_key)
1166 {
1167  char key[256 / 8];
1168  char ctr[128 / 8];
1169 
1170  GNUNET_assert (0 == gcry_cipher_open (cipher,
1171  GCRY_CIPHER_AES256 /* low level: go for speed */,
1172  GCRY_CIPHER_MODE_CTR,
1173  0 /* flags */));
1175  sizeof(key),
1176  "TCP-key",
1177  strlen ("TCP-key"),
1178  dh,
1179  sizeof(*dh),
1180  pid,
1181  sizeof(*pid),
1182  NULL,
1183  0));
1184  GNUNET_assert (0 == gcry_cipher_setkey (*cipher, key, sizeof(key)));
1186  sizeof(ctr),
1187  "TCP-ctr",
1188  strlen ("TCP-ctr"),
1189  dh,
1190  sizeof(*dh),
1191  pid,
1192  sizeof(*pid),
1193  NULL,
1194  0));
1195  gcry_cipher_setctr (*cipher, ctr, sizeof(ctr));
1197  GNUNET_CRYPTO_kdf (hmac_key,
1198  sizeof(struct GNUNET_HashCode),
1199  "TCP-hmac",
1200  strlen ("TCP-hmac"),
1201  dh,
1202  sizeof(*dh),
1203  pid,
1204  sizeof(*pid),
1205  NULL,
1206  0));
1207 }
1208 
1209 
1215 static void
1216 rekey_monotime_store_cb (void *cls, int success)
1217 {
1218  struct Queue *queue = cls;
1219  if (GNUNET_OK != success)
1220  {
1222  "Failed to store rekey monotonic time in PEERSTORE!\n");
1223  }
1224  queue->rekey_monotime_sc = NULL;
1225 }
1226 
1227 
1235 static void
1237  const struct GNUNET_PEERSTORE_Record *record,
1238  const char *emsg)
1239 {
1240  struct Queue *queue = cls;
1241  struct GNUNET_TIME_AbsoluteNBO *mtbe;
1242  struct GNUNET_TIME_Absolute mt;
1243  const struct GNUNET_PeerIdentity *pid;
1244  struct GNUNET_TIME_AbsoluteNBO *rekey_monotonic_time;
1245 
1246  (void) emsg;
1247 
1248  rekey_monotonic_time = &queue->rekey_monotonic_time;
1249  pid = &queue->target;
1250  if (NULL == record)
1251  {
1252  queue->rekey_monotime_get = NULL;
1253  return;
1254  }
1255  if (sizeof(*mtbe) != record->value_size)
1256  {
1257  GNUNET_break (0);
1258  return;
1259  }
1260  mtbe = record->value;
1261  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
1263  queue->rekey_monotonic_time).abs_value_us)
1264  {
1266  "Queue from %s dropped, rekey monotime in the past\n",
1267  GNUNET_i2s (&queue->target));
1268  GNUNET_break (0);
1269  queue_finish (queue);
1270  return;
1271  }
1272  queue->rekey_monotime_sc = GNUNET_PEERSTORE_store (peerstore,
1273  "transport_tcp_communicator",
1274  pid,
1276  rekey_monotonic_time,
1277  sizeof(*
1278  rekey_monotonic_time),
1282  queue);
1283 }
1284 
1285 
1292 static void
1294  struct Queue *queue)
1295 {
1296  struct GNUNET_HashCode dh;
1297 
1298  GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &dh);
1299  setup_cipher (&dh, &my_identity, &queue->in_cipher, &queue->in_hmac);
1300 }
1301 
1302 
1311 static void
1312 do_rekey (struct Queue *queue, const struct TCPRekey *rekey)
1313 {
1314  struct TcpRekeySignature thp;
1315 
1317  thp.purpose.size = htonl (sizeof(thp));
1319  "do_rekey size %u\n",
1320  thp.purpose.size);
1321  thp.sender = queue->target;
1323  "sender %s\n",
1324  GNUNET_p2s (&thp.sender.public_key));
1326  "sender %s\n",
1327  GNUNET_p2s (&queue->target.public_key));
1328  thp.receiver = my_identity;
1330  "receiver %s\n",
1331  GNUNET_p2s (&thp.receiver.public_key));
1332  thp.ephemeral = rekey->ephemeral;
1334  "ephemeral %s\n",
1335  GNUNET_e2s (&thp.ephemeral));
1336  thp.monotonic_time = rekey->monotonic_time;
1338  "time %s\n",
1341  GNUNET_assert (ntohl ((&thp)->purpose.size) == sizeof (*(&thp)));
1342  if (GNUNET_OK !=
1345  &thp,
1346  &rekey->sender_sig,
1347  &queue->target.public_key))
1348  {
1349  GNUNET_break (0);
1350  queue_finish (queue);
1351  return;
1352  }
1353  queue->rekey_monotonic_time = rekey->monotonic_time;
1354  queue->rekey_monotime_get = GNUNET_PEERSTORE_iterate (peerstore,
1355  "transport_tcp_communicator",
1356  &queue->target,
1359  queue);
1360  gcry_cipher_close (queue->in_cipher);
1361  queue->rekeyed = GNUNET_YES;
1362  setup_in_cipher (&rekey->ephemeral, queue);
1363 }
1364 
1365 
1371 static void
1372 handshake_ack_monotime_store_cb (void *cls, int success)
1373 {
1374  struct Queue *queue = cls;
1375 
1376  if (GNUNET_OK != success)
1377  {
1379  "Failed to store handshake ack monotonic time in PEERSTORE!\n");
1380  }
1381  queue->handshake_ack_monotime_sc = NULL;
1382 }
1383 
1384 
1392 static void
1394  const struct GNUNET_PEERSTORE_Record *record,
1395  const char *emsg)
1396 {
1397  struct Queue *queue = cls;
1398  struct GNUNET_TIME_AbsoluteNBO *mtbe;
1399  struct GNUNET_TIME_Absolute mt;
1400  const struct GNUNET_PeerIdentity *pid;
1401  struct GNUNET_TIME_AbsoluteNBO *handshake_ack_monotonic_time;
1402 
1403  (void) emsg;
1404 
1405  handshake_ack_monotonic_time = &queue->handshake_ack_monotonic_time;
1406  pid = &queue->target;
1407  if (NULL == record)
1408  {
1409  queue->handshake_ack_monotime_get = NULL;
1410  return;
1411  }
1412  if (sizeof(*mtbe) != record->value_size)
1413  {
1414  GNUNET_break (0);
1415  return;
1416  }
1417  mtbe = record->value;
1418  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
1420  queue->handshake_ack_monotonic_time).abs_value_us)
1421  {
1423  "Queue from %s dropped, handshake ack monotime in the past\n",
1424  GNUNET_i2s (&queue->target));
1425  GNUNET_break (0);
1426  queue_finish (queue);
1427  return;
1428  }
1429  queue->handshake_ack_monotime_sc =
1431  "transport_tcp_communicator",
1432  pid,
1434  handshake_ack_monotonic_time,
1435  sizeof(*handshake_ack_monotonic_time),
1438  &
1440  queue);
1441 }
1442 
1443 
1450 static void
1452  Queue *queue)
1453 {
1454  struct TCPConfirmationAck tca;
1455  struct TcpHandshakeAckSignature thas;
1456 
1458  "transport",
1459  "sending challenge\n");
1460 
1461  tca.header.type = ntohs (
1463  tca.header.size = ntohs (sizeof(tca));
1464  tca.challenge = challenge;
1465  tca.sender = my_identity;
1466  tca.monotonic_time =
1468  thas.purpose.purpose = htonl (
1470  thas.purpose.size = htonl (sizeof(thas));
1471  thas.sender = my_identity;
1472  thas.receiver = queue->target;
1473  thas.monotonic_time = tca.monotonic_time;
1474  thas.challenge = tca.challenge;
1476  &thas,
1477  &tca.sender_sig);
1478  GNUNET_assert (0 ==
1479  gcry_cipher_encrypt (queue->out_cipher,
1480  &queue->cwrite_buf[queue->cwrite_off],
1481  sizeof(tca),
1482  &tca,
1483  sizeof(tca)));
1484  queue->cwrite_off += sizeof(tca);
1486  "transport",
1487  "sending challenge done\n");
1488 }
1489 
1490 
1497 static void
1499 {
1500  struct GNUNET_HashCode dh;
1501 
1502  GNUNET_CRYPTO_ecdh_eddsa (&queue->ephemeral, &queue->target.public_key, &dh);
1503  /* we don't need the private key anymore, drop it! */
1504  memset (&queue->ephemeral, 0, sizeof(queue->ephemeral));
1505  setup_cipher (&dh, &queue->target, &queue->out_cipher, &queue->out_hmac);
1507  queue->rekey_left_bytes =
1509 }
1510 
1511 
1518 static void
1520 {
1521  struct TCPRekey rekey;
1522  struct TcpRekeySignature thp;
1523 
1524  GNUNET_assert (0 == queue->pwrite_off);
1525  memset (&rekey, 0, sizeof(rekey));
1526  GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral);
1528  rekey.header.size = ntohs (sizeof(rekey));
1529  GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &rekey.ephemeral);
1530  rekey.monotonic_time =
1533  thp.purpose.size = htonl (sizeof(thp));
1535  "inject_rekey size %u\n",
1536  thp.purpose.size);
1537  thp.sender = my_identity;
1539  "sender %s\n",
1540  GNUNET_p2s (&thp.sender.public_key));
1541  thp.receiver = queue->target;
1543  "receiver %s\n",
1544  GNUNET_p2s (&thp.receiver.public_key));
1545  thp.ephemeral = rekey.ephemeral;
1547  "ephemeral %s\n",
1548  GNUNET_e2s (&thp.ephemeral));
1549  thp.monotonic_time = rekey.monotonic_time;
1551  "time %s\n",
1555  &thp,
1556  &rekey.sender_sig);
1557  calculate_hmac (&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac);
1558  /* Encrypt rekey message with 'old' cipher */
1559  GNUNET_assert (0 ==
1560  gcry_cipher_encrypt (queue->out_cipher,
1561  &queue->cwrite_buf[queue->cwrite_off],
1562  sizeof(rekey),
1563  &rekey,
1564  sizeof(rekey)));
1565  queue->cwrite_off += sizeof(rekey);
1566  /* Setup new cipher for successive messages */
1567  gcry_cipher_close (queue->out_cipher);
1569 }
1570 
1571 
1578 static void
1579 queue_write (void *cls)
1580 {
1581  struct Queue *queue = cls;
1582  ssize_t sent;
1583  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "In queue write\n");
1584  queue->write_task = NULL;
1585  if (0 != queue->cwrite_off)
1586  {
1587  sent = GNUNET_NETWORK_socket_send (queue->sock,
1588  queue->cwrite_buf,
1589  queue->cwrite_off);
1591  "Sent %lu bytes to TCP queue\n", sent);
1592  if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno))
1593  {
1595  queue_destroy (queue);
1596  return;
1597  }
1598  if (sent > 0)
1599  {
1600  size_t usent = (size_t) sent;
1601  queue->cwrite_off -= usent;
1602  memmove (queue->cwrite_buf,
1603  &queue->cwrite_buf[usent],
1604  queue->cwrite_off);
1606  }
1607  }
1608  /* can we encrypt more? (always encrypt full messages, needed
1609  such that #mq_cancel() can work!) */
1610  if ((0 < queue->rekey_left_bytes) &&
1611  (queue->pwrite_off > 0) &&
1612  (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE))
1613  {
1615  "Encrypting %lu bytes\n", queue->pwrite_off);
1616  GNUNET_assert (0 ==
1617  gcry_cipher_encrypt (queue->out_cipher,
1618  &queue->cwrite_buf[queue->cwrite_off],
1619  queue->pwrite_off,
1620  queue->pwrite_buf,
1621  queue->pwrite_off));
1622  if (queue->rekey_left_bytes > queue->pwrite_off)
1623  queue->rekey_left_bytes -= queue->pwrite_off;
1624  else
1625  queue->rekey_left_bytes = 0;
1626  queue->cwrite_off += queue->pwrite_off;
1627  queue->pwrite_off = 0;
1628  }
1629  // if ((-1 != unverified_size)&& ((0 == queue->pwrite_off) &&
1630  if (((0 == queue->pwrite_off) &&
1631  ((0 == queue->rekey_left_bytes) ||
1632  (0 ==
1634  queue->rekey_time).rel_value_us))))
1635  {
1636  inject_rekey (queue);
1637  }
1638  if ((0 == queue->pwrite_off) && (! queue->finishing) &&
1639  (GNUNET_YES == queue->mq_awaits_continue))
1640  {
1641  queue->mq_awaits_continue = GNUNET_NO;
1643  }
1644  /* did we just finish writing 'finish'? */
1645  if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing))
1646  {
1648  "Finishing queue\n");
1649  queue_destroy (queue);
1650  return;
1651  }
1652  /* do we care to write more? */
1653  if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off))
1654  queue->write_task =
1656  queue->sock,
1657  &queue_write,
1658  queue);
1659 }
1660 
1661 
1669 static size_t
1671 {
1672  const struct GNUNET_MessageHeader *hdr =
1673  (const struct GNUNET_MessageHeader *) queue->pread_buf;
1674  const struct TCPConfirmationAck *tca = (const struct
1675  TCPConfirmationAck *) queue->pread_buf;
1676  const struct TCPBox *box = (const struct TCPBox *) queue->pread_buf;
1677  const struct TCPRekey *rekey = (const struct TCPRekey *) queue->pread_buf;
1678  const struct TCPFinish *fin = (const struct TCPFinish *) queue->pread_buf;
1679  struct TCPRekey rekeyz;
1680  struct TCPFinish finz;
1681  struct GNUNET_ShortHashCode tmac;
1682  uint16_t type;
1683  size_t size = 0; /* make compiler happy */
1684  struct TcpHandshakeAckSignature thas;
1685  const struct GNUNET_CRYPTO_ChallengeNonceP challenge = queue->challenge;
1686 
1688  "try handle plaintext!\n");
1689 
1690  if ((sizeof(*hdr) > queue->pread_off))
1691  {
1693  "Handling plaintext, not even a header!\n");
1694  return 0; /* not even a header */
1695  }
1696 
1698  {
1700  "Already received data of size %lu bigger than KX size %lu!\n",
1703  GNUNET_break_op (0);
1704  queue_finish (queue);
1705  return 0;
1706  }
1707 
1708  type = ntohs (hdr->type);
1709  switch (type)
1710  {
1713  "start processing ack\n");
1714  if (sizeof(*tca) > queue->pread_off)
1715  {
1717  "Handling plaintext size of tca greater than pread offset.\n");
1718  return 0;
1719  }
1720  if (ntohs (hdr->size) != sizeof(*tca))
1721  {
1723  "Handling plaintext size does not match message type.\n");
1724  GNUNET_break_op (0);
1725  queue_finish (queue);
1726  return 0;
1727  }
1728 
1729  thas.purpose.purpose = htonl (
1731  thas.purpose.size = htonl (sizeof(thas));
1732  thas.sender = tca->sender;
1733  thas.receiver = my_identity;
1734  thas.monotonic_time = tca->monotonic_time;
1735  thas.challenge = tca->challenge;
1736 
1739  &thas,
1740  &tca->sender_sig,
1741  &tca->sender.public_key))
1742  {
1744  "Verification of signature failed!\n");
1745  GNUNET_break (0);
1746  queue_finish (queue);
1747  return 0;
1748  }
1749  if (0 != GNUNET_memcmp (&tca->challenge, &challenge))
1750  {
1752  "Challenge in TCPConfirmationAck not correct!\n");
1753  GNUNET_break (0);
1754  queue_finish (queue);
1755  return 0;
1756  }
1757 
1758  queue->handshake_ack_monotime_get = GNUNET_PEERSTORE_iterate (peerstore,
1759  "transport_tcp_communicator",
1760  &queue->target,
1762  &
1764  queue);
1765 
1767  "Handling plaintext, ack processed!\n");
1768 
1770  {
1771  send_challenge (queue->challenge_received, queue);
1772  queue->write_task =
1774  queue->sock,
1775  &queue_write,
1776  queue);
1777  }
1778 
1779  unverified_size = -1;
1780 
1781  char *foreign_addr;
1782 
1783  switch (queue->address->sa_family)
1784  {
1785  case AF_INET:
1786  GNUNET_asprintf (&foreign_addr,
1787  "%s-%s",
1789  GNUNET_a2s (queue->address, queue->address_len));
1790  break;
1791 
1792  case AF_INET6:
1793  GNUNET_asprintf (&foreign_addr,
1794  "%s-%s",
1796  GNUNET_a2s (queue->address, queue->address_len));
1797  break;
1798 
1799  default:
1800  GNUNET_assert (0);
1801  }
1802 
1804  &queue->target,
1805  foreign_addr,
1806  UINT16_MAX, /* no MTU */
1808  0, /* Priority */
1809  queue->nt,
1810  queue->cs,
1811  queue->mq);
1812 
1813  GNUNET_free (foreign_addr);
1814 
1815  size = ntohs (hdr->size);
1816  break;
1818  /* Special case: header size excludes box itself! */
1819  if (ntohs (hdr->size) + sizeof(struct TCPBox) > queue->pread_off)
1820  return 0;
1821  calculate_hmac (&queue->in_hmac, &box[1], ntohs (hdr->size), &tmac);
1822  if (0 != memcmp (&tmac, &box->hmac, sizeof(tmac)))
1823  {
1824  GNUNET_break_op (0);
1825  queue_finish (queue);
1826  return 0;
1827  }
1828  pass_plaintext_to_core (queue, (const void *) &box[1], ntohs (hdr->size));
1829  size = ntohs (hdr->size) + sizeof(*box);
1831  "Handling plaintext, box processed!\n");
1832  break;
1833 
1835  if (sizeof(*rekey) > queue->pread_off)
1836  return 0;
1837  if (ntohs (hdr->size) != sizeof(*rekey))
1838  {
1839  GNUNET_break_op (0);
1840  queue_finish (queue);
1841  return 0;
1842  }
1843  rekeyz = *rekey;
1844  memset (&rekeyz.hmac, 0, sizeof(rekeyz.hmac));
1845  calculate_hmac (&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac);
1846  if (0 != memcmp (&tmac, &rekey->hmac, sizeof(tmac)))
1847  {
1848  GNUNET_break_op (0);
1849  queue_finish (queue);
1850  return 0;
1851  }
1852  do_rekey (queue, rekey);
1853  size = ntohs (hdr->size);
1855  "Handling plaintext, rekey processed!\n");
1856  break;
1857 
1859  if (sizeof(*fin) > queue->pread_off)
1860  return 0;
1861  if (ntohs (hdr->size) != sizeof(*fin))
1862  {
1863  GNUNET_break_op (0);
1864  queue_finish (queue);
1865  return 0;
1866  }
1867  finz = *fin;
1868  memset (&finz.hmac, 0, sizeof(finz.hmac));
1869  calculate_hmac (&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac);
1870  if (0 != memcmp (&tmac, &fin->hmac, sizeof(tmac)))
1871  {
1872  GNUNET_break_op (0);
1873  queue_finish (queue);
1874  return 0;
1875  }
1876  /* handle FINISH by destroying queue */
1877  queue_destroy (queue);
1879  "Handling plaintext, finish processed!\n");
1880  break;
1881 
1882  default:
1884  "Handling plaintext, nothing processed!\n");
1885  GNUNET_break_op (0);
1886  queue_finish (queue);
1887  return 0;
1888  }
1889  GNUNET_assert (0 != size);
1890  if (-1 != unverified_size)
1891  unverified_size += size;
1892  return size;
1893 }
1894 
1895 
1901 static void
1902 queue_read (void *cls)
1903 {
1904  struct Queue *queue = cls;
1905  struct GNUNET_TIME_Relative left;
1906  ssize_t rcvd;
1907 
1908  queue->read_task = NULL;
1909  rcvd = GNUNET_NETWORK_socket_recv (queue->sock,
1910  &queue->cread_buf[queue->cread_off],
1911  BUF_SIZE - queue->cread_off);
1913  "Received %lu bytes from TCP queue\n", rcvd);
1915  "transport",
1916  "Received %lu bytes from TCP queue\n", rcvd);
1917  if (-1 == rcvd)
1918  {
1919  if ((EAGAIN != errno) && (EINTR != errno))
1920  {
1922  queue_finish (queue);
1923  return;
1924  }
1925  /* try again */
1926  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
1927  queue->read_task =
1929  return;
1930  }
1931  if (0 != rcvd)
1933  queue->cread_off += rcvd;
1934  while ((queue->pread_off < sizeof(queue->pread_buf)) &&
1935  (queue->cread_off > 0))
1936  {
1937  size_t max = GNUNET_MIN (sizeof(queue->pread_buf) - queue->pread_off,
1938  queue->cread_off);
1939  size_t done;
1940  size_t total;
1941  size_t old_pread_off = queue->pread_off;
1942 
1943  GNUNET_assert (0 ==
1944  gcry_cipher_decrypt (queue->in_cipher,
1945  &queue->pread_buf[queue->pread_off],
1946  max,
1947  queue->cread_buf,
1948  max));
1949  queue->pread_off += max;
1950  total = 0;
1951  while (0 != (done = try_handle_plaintext (queue)))
1952  {
1953  /* 'done' bytes of plaintext were used, shift buffer */
1954  GNUNET_assert (done <= queue->pread_off);
1955  /* NOTE: this memmove() could possibly sometimes be
1956  avoided if we pass 'total' into try_handle_plaintext()
1957  and use it at an offset into the buffer there! */
1958  memmove (queue->pread_buf,
1959  &queue->pread_buf[done],
1960  queue->pread_off - done);
1961  queue->pread_off -= done;
1962  total += done;
1963  /* The last plaintext was a rekey, abort for now */
1964  if (GNUNET_YES == queue->rekeyed)
1965  break;
1966  }
1967  /* when we encounter a rekey message, the decryption above uses the
1968  wrong key for everything after the rekey; in that case, we have
1969  to re-do the decryption at 'total' instead of at 'max'.
1970  However, we have to take into account that the plaintext buffer may have
1971  already contained data and not jumped too far ahead in the ciphertext.
1972  If there is no rekey and the last message is incomplete (max > total),
1973  it is safe to keep the decryption so we shift by 'max' */
1974  if (GNUNET_YES == queue->rekeyed)
1975  {
1976  max = total - old_pread_off;
1977  queue->rekeyed = GNUNET_NO;
1978  queue->pread_off = 0;
1979  }
1980  memmove (queue->cread_buf, &queue->cread_buf[max], queue->cread_off - max);
1981  queue->cread_off -= max;
1982  }
1983  if (BUF_SIZE == queue->cread_off)
1984  return; /* buffer full, suspend reading */
1985  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
1986  if (0 != left.rel_value_us)
1987  {
1988  if (max_queue_length > queue->backpressure)
1989  {
1990  /* continue reading */
1991  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
1992  queue->read_task =
1994  }
1995  return;
1996  }
1998  "Queue %p was idle for %s, disconnecting\n",
1999  queue,
2002  GNUNET_YES));
2003  queue_finish (queue);
2004 }
2005 
2006 
2014 static struct sockaddr *
2016  struct sockaddr_in6 v6,
2017  unsigned int port)
2018 {
2019  struct sockaddr *in;
2020 
2021  v6.sin6_family = AF_INET6;
2022  v6.sin6_port = htons ((uint16_t) port);
2023 #if HAVE_SOCKADDR_IN_SIN_LEN
2024  v6.sin6_len = sizeof(sizeof(struct sockaddr_in6));
2025 #endif
2026  v6.sin6_flowinfo = 0;
2027  v6.sin6_scope_id = 0;
2028  in = GNUNET_memdup (&v6, sizeof(v6));
2029  *sock_len = sizeof(struct sockaddr_in6);
2030 
2031  return in;
2032 }
2033 
2034 
2042 static struct sockaddr *
2044  struct sockaddr_in v4,
2045  unsigned int port)
2046 {
2047  struct sockaddr *in;
2048 
2049  v4.sin_family = AF_INET;
2050  v4.sin_port = htons ((uint16_t) port);
2051 #if HAVE_SOCKADDR_IN_SIN_LEN
2052  v4.sin_len = sizeof(struct sockaddr_in);
2053 #endif
2054  in = GNUNET_memdup (&v4, sizeof(v4));
2055  *sock_len = sizeof(struct sockaddr_in);
2056  return in;
2057 }
2058 
2059 
2066 static struct PortOnlyIpv4Ipv6 *
2067 tcp_address_to_sockaddr_port_only (const char *bindto, unsigned int *port)
2068 {
2069  struct PortOnlyIpv4Ipv6 *po;
2070  struct sockaddr_in *i4;
2071  struct sockaddr_in6 *i6;
2072  socklen_t sock_len_ipv4;
2073  socklen_t sock_len_ipv6;
2074 
2075  /* interpreting value as just a PORT number */
2076  if (*port > UINT16_MAX)
2077  {
2079  "BINDTO specification `%s' invalid: value too large for port\n",
2080  bindto);
2081  return NULL;
2082  }
2083 
2084  po = GNUNET_new (struct PortOnlyIpv4Ipv6);
2085 
2086  if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
2087  (GNUNET_YES ==
2090  "DISABLE_V6")))
2091  {
2092  i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
2093  po->addr_ipv4 = tcp_address_to_sockaddr_numeric_v4 (&sock_len_ipv4, *i4,
2094  *port);
2095  po->addr_len_ipv4 = sock_len_ipv4;
2096  }
2097  else
2098  {
2099 
2100  i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
2101  po->addr_ipv4 = tcp_address_to_sockaddr_numeric_v4 (&sock_len_ipv4, *i4,
2102  *port);
2103  po->addr_len_ipv4 = sock_len_ipv4;
2104 
2105  i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
2106  po->addr_ipv6 = tcp_address_to_sockaddr_numeric_v6 (&sock_len_ipv6, *i6,
2107  *port);
2108 
2109  po->addr_len_ipv6 = sock_len_ipv6;
2110 
2111  GNUNET_free (i6);
2112  }
2113 
2114  GNUNET_free (i4);
2115 
2116  return po;
2117 }
2118 
2119 
2126 static char *
2127 extract_address (const char *bindto)
2128 {
2129  char *addr;
2130  char *start;
2131  char *token;
2132  char *cp;
2133  char *rest = NULL;
2134  char *res;
2135 
2137  "extract address with bindto %s\n",
2138  bindto);
2139 
2140  if (NULL == bindto)
2142  "bindto is NULL\n");
2143 
2144  cp = GNUNET_strdup (bindto);
2145 
2147  "extract address 2\n");
2148 
2149  start = cp;
2150  if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
2151  {
2152  start++; /* skip over '['*/
2153  cp[strlen (cp) - 1] = '\0'; /* eat ']'*/
2154  addr = GNUNET_strdup (start);
2155  }
2156  else
2157  {
2158  token = strtok_r (cp, "]", &rest);
2159  if (strlen (bindto) == strlen (token))
2160  {
2161  token = strtok_r (cp, ":", &rest);
2162  addr = GNUNET_strdup (token);
2163  }
2164  else
2165  {
2166  token++;
2167  res = GNUNET_strdup (token);
2168  addr = GNUNET_strdup (res);
2169  }
2170  }
2171 
2173  "tcp address: %s\n",
2174  addr);
2175  GNUNET_free (cp);
2176  return addr;
2177 }
2178 
2179 
2186 static unsigned int
2187 extract_port (const char *addr_and_port)
2188 {
2189  unsigned int port;
2190  char dummy[2];
2191  char *token;
2192  char *addr;
2193  char *colon;
2194  char *cp;
2195  char *rest = NULL;
2196 
2197  if (NULL != addr_and_port)
2198  {
2199  cp = GNUNET_strdup (addr_and_port);
2200  token = strtok_r (cp, "]", &rest);
2201  if (strlen (addr_and_port) == strlen (token))
2202  {
2203  colon = strrchr (cp, ':');
2204  if (NULL == colon)
2205  {
2206  GNUNET_free (cp);
2207  return 0;
2208  }
2209  addr = colon;
2210  addr++;
2211  }
2212  else
2213  {
2214  token = strtok_r (NULL, "]", &rest);
2215  if (NULL == token)
2216  {
2217  GNUNET_free (cp);
2218  return 0;
2219  }
2220  else
2221  {
2222  addr = token;
2223  addr++;
2224  }
2225  }
2226 
2227 
2228  if (1 == sscanf (addr, "%u%1s", &port, dummy))
2229  {
2230  /* interpreting value as just a PORT number */
2231  if (port > UINT16_MAX)
2232  {
2234  "Port `%u' invalid: value too large for port\n",
2235  port);
2236  GNUNET_free (cp);
2237  return 0;
2238  }
2239  }
2240  else
2241  {
2243  "BINDTO specification invalid: last ':' not followed by number\n");
2244  GNUNET_free (cp);
2245  return 0;
2246  }
2247  GNUNET_free (cp);
2248  }
2249  else
2250  {
2252  "return 0\n");
2253  /* interpret missing port as 0, aka pick any free one */
2254  port = 0;
2255  }
2256 
2257  return port;
2258 }
2259 
2260 
2268 static struct sockaddr *
2269 tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
2270 {
2271  struct sockaddr *in;
2272  unsigned int port;
2273  struct sockaddr_in v4;
2274  struct sockaddr_in6 v6;
2275  char *start;
2276 
2277  start = extract_address (bindto);
2278  // FIXME: check NULL == start
2280  "start %s\n",
2281  start);
2282 
2284  "!bindto %s\n",
2285  bindto);
2286 
2287 
2288  if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
2289  {
2290  // colon = strrchr (cp, ':');
2291  port = extract_port (bindto);
2292 
2294  "port %u\n",
2295  port);
2296 
2297  in = tcp_address_to_sockaddr_numeric_v4 (sock_len, v4, port);
2298  }
2299  else if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
2300  {
2301  // colon = strrchr (cp, ':');
2302  port = extract_port (bindto);
2303  in = tcp_address_to_sockaddr_numeric_v6 (sock_len, v6, port);
2304  }
2305  else
2306  {
2307  GNUNET_assert (0);
2308  }
2309 
2310  GNUNET_free (start);
2311  return in;
2312 }
2313 
2314 
2323 static void
2325  const struct GNUNET_MessageHeader *msg,
2326  void *impl_state)
2327 {
2328  struct Queue *queue = impl_state;
2329  uint16_t msize = ntohs (msg->size);
2330  struct TCPBox box;
2332  "In MQ send. Queue finishing: %s; write task running: %s\n",
2333  (GNUNET_YES == queue->finishing) ? "yes" : "no",
2334  (NULL == queue->write_task) ? "yes" : "no");
2335  GNUNET_assert (mq == queue->mq);
2336  queue->mq_awaits_continue = GNUNET_YES;
2337  if (GNUNET_YES == queue->finishing)
2338  return; /* this queue is dying, drop msg */
2339  GNUNET_assert (0 == queue->pwrite_off);
2341  box.header.size = htons (msize);
2342  calculate_hmac (&queue->out_hmac, msg, msize, &box.hmac);
2343  memcpy (&queue->pwrite_buf[queue->pwrite_off], &box, sizeof(box));
2344  queue->pwrite_off += sizeof(box);
2345  memcpy (&queue->pwrite_buf[queue->pwrite_off], msg, msize);
2346  queue->pwrite_off += msize;
2348  "%lu bytes of plaintext to send\n", queue->pwrite_off);
2349  GNUNET_assert (NULL != queue->sock);
2350  if (NULL == queue->write_task)
2351  queue->write_task =
2353  queue->sock,
2354  &queue_write,
2355  queue);
2356 }
2357 
2358 
2367 static void
2368 mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
2369 {
2370  struct Queue *queue = impl_state;
2371 
2372  if (mq == queue->mq)
2373  {
2374  queue->mq = NULL;
2375  queue_finish (queue);
2376  }
2377 }
2378 
2379 
2386 static void
2387 mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
2388 {
2389  struct Queue *queue = impl_state;
2390 
2391  GNUNET_assert (0 != queue->pwrite_off);
2392  queue->pwrite_off = 0;
2393 }
2394 
2395 
2405 static void
2406 mq_error (void *cls, enum GNUNET_MQ_Error error)
2407 {
2408  struct Queue *queue = cls;
2409 
2411  "MQ error in queue to %s: %d\n",
2412  GNUNET_i2s (&queue->target),
2413  (int) error);
2414  queue_finish (queue);
2415 }
2416 
2417 
2425 static void
2427 {
2428  queue->nt =
2429  GNUNET_NT_scanner_get_type (is, queue->address, queue->address_len);
2431  queue_map,
2432  &queue->target,
2433  queue,
2436  "# queues active",
2438  GNUNET_NO);
2439  queue->timeout =
2442  &mq_destroy,
2443  &mq_cancel,
2444  queue,
2445  NULL,
2446  &mq_error,
2447  queue);
2448 }
2449 
2450 
2461 static void
2463  const struct GNUNET_CRYPTO_EcdhePublicKey *epub)
2464 {
2465  struct TcpHandshakeSignature ths;
2466  struct TCPConfirmation tc;
2467 
2468  memcpy (queue->cwrite_buf, epub, sizeof(*epub));
2469  queue->cwrite_off = sizeof(*epub);
2470  /* compute 'tc' and append in encrypted format to cwrite_buf */
2471  tc.sender = my_identity;
2472  tc.monotonic_time =
2475  &tc.challenge,
2476  sizeof(tc.challenge));
2477  ths.purpose.purpose = htonl (
2479  ths.purpose.size = htonl (sizeof(ths));
2480  ths.sender = my_identity;
2481  ths.receiver = queue->target;
2482  ths.ephemeral = *epub;
2483  ths.monotonic_time = tc.monotonic_time;
2484  ths.challenge = tc.challenge;
2486  &ths,
2487  &tc.sender_sig);
2488  GNUNET_assert (0 ==
2489  gcry_cipher_encrypt (queue->out_cipher,
2490  &queue->cwrite_buf[queue->cwrite_off],
2491  sizeof(tc),
2492  &tc,
2493  sizeof(tc)));
2494  queue->challenge = tc.challenge;
2495  queue->cwrite_off += sizeof(tc);
2496 
2498  "transport",
2499  "handshake written\n");
2500 }
2501 
2502 
2510 static void
2512 {
2513  struct GNUNET_CRYPTO_EcdhePublicKey epub;
2514 
2515  GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral);
2516  GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &epub);
2518  transmit_kx (queue, &epub);
2519 }
2520 
2521 
2527 static void
2528 handshake_monotime_store_cb (void *cls, int success)
2529 {
2530  struct Queue *queue = cls;
2531  if (GNUNET_OK != success)
2532  {
2534  "Failed to store handshake monotonic time in PEERSTORE!\n");
2535  }
2536  queue->handshake_monotime_sc = NULL;
2537 }
2538 
2539 
2547 static void
2549  const struct GNUNET_PEERSTORE_Record *record,
2550  const char *emsg)
2551 {
2552  struct Queue *queue = cls;
2553  struct GNUNET_TIME_AbsoluteNBO *mtbe;
2554  struct GNUNET_TIME_Absolute mt;
2555  const struct GNUNET_PeerIdentity *pid;
2556  struct GNUNET_TIME_AbsoluteNBO *handshake_monotonic_time;
2557 
2558  (void) emsg;
2559 
2560  handshake_monotonic_time = &queue->handshake_monotonic_time;
2561  pid = &queue->target;
2563  "tcp handshake with us %s\n",
2564  GNUNET_i2s (&my_identity));
2565  if (NULL == record)
2566  {
2567  queue->handshake_monotime_get = NULL;
2568  return;
2569  }
2571  "tcp handshake from peer %s\n",
2572  GNUNET_i2s (pid));
2573  if (sizeof(*mtbe) != record->value_size)
2574  {
2575  GNUNET_break (0);
2576  return;
2577  }
2578  mtbe = record->value;
2579  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
2581  queue->handshake_monotonic_time).abs_value_us)
2582  {
2584  "Queue from %s dropped, handshake monotime in the past\n",
2585  GNUNET_i2s (&queue->target));
2586  GNUNET_break (0);
2587  queue_finish (queue);
2588  return;
2589  }
2590  queue->handshake_monotime_sc = GNUNET_PEERSTORE_store (peerstore,
2591  "transport_tcp_communicator",
2592  pid,
2594  handshake_monotonic_time,
2595  sizeof(*
2596  handshake_monotonic_time),
2599  &
2601  queue);
2602 }
2603 
2604 
2616 static int
2618  struct TCPConfirmation *tc,
2619  char *ibuf)
2620 {
2621  struct TcpHandshakeSignature ths;
2623 
2624  GNUNET_assert (
2625  0 ==
2626  gcry_cipher_decrypt (queue->in_cipher,
2627  tc,
2628  sizeof(*tc),
2629  &ibuf[sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)],
2630  sizeof(*tc)));
2631  ths.purpose.purpose = htonl (
2633  ths.purpose.size = htonl (sizeof(ths));
2634  ths.sender = tc->sender;
2635  ths.receiver = my_identity;
2636  memcpy (&ths.ephemeral, ibuf, sizeof(struct GNUNET_CRYPTO_EcdhePublicKey));
2637  ths.monotonic_time = tc->monotonic_time;
2638  ths.challenge = tc->challenge;
2641  &ths,
2642  &tc->sender_sig,
2643  &tc->sender.public_key);
2644  if (GNUNET_YES == ret)
2645  queue->handshake_monotime_get =
2647  "transport_tcp_communicator",
2648  &queue->target,
2651  queue);
2652  return ret;
2653 }
2654 
2655 
2661 static void
2663 {
2664  if (NULL != pq->listen_sock)
2665  {
2667  pq->listen_sock = NULL;
2668  }
2670  GNUNET_free (pq->address);
2672  GNUNET_free (pq);
2673 }
2674 
2675 
2682 static void
2683 proto_read_kx (void *cls)
2684 {
2685  struct ProtoQueue *pq = cls;
2686  ssize_t rcvd;
2687  struct GNUNET_TIME_Relative left;
2688  struct Queue *queue;
2689  struct TCPConfirmation tc;
2690 
2691  pq->read_task = NULL;
2693  if (0 == left.rel_value_us)
2694  {
2695  free_proto_queue (pq);
2696  return;
2697  }
2698  rcvd = GNUNET_NETWORK_socket_recv (pq->sock,
2699  &pq->ibuf[pq->ibuf_off],
2700  sizeof(pq->ibuf) - pq->ibuf_off);
2702  "Received %lu bytes for KX\n", rcvd);
2704  "transport",
2705  "Received %lu bytes for KX\n", rcvd);
2706  if (-1 == rcvd)
2707  {
2708  if ((EAGAIN != errno) && (EINTR != errno))
2709  {
2711  free_proto_queue (pq);
2712  return;
2713  }
2714  /* try again */
2715  pq->read_task =
2717  return;
2718  }
2719  pq->ibuf_off += rcvd;
2720  if (pq->ibuf_off > sizeof(pq->ibuf))
2721  {
2722  /* read more */
2723  pq->read_task =
2725  return;
2726  }
2727  /* we got all the data, let's find out who we are talking to! */
2728  queue = GNUNET_new (struct Queue);
2729  setup_in_cipher ((const struct GNUNET_CRYPTO_EcdhePublicKey *) pq->ibuf,
2730  queue);
2731  if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, pq->ibuf))
2732  {
2734  "Invalid TCP KX received from %s\n",
2735  GNUNET_a2s (pq->address, pq->address_len));
2736  gcry_cipher_close (queue->in_cipher);
2737  GNUNET_free (queue);
2738  free_proto_queue (pq);
2739  return;
2740  }
2741  queue->address = pq->address; /* steals reference */
2742  queue->address_len = pq->address_len;
2743  queue->target = tc.sender;
2744  queue->listen_sock = pq->listen_sock;
2745  queue->sock = pq->sock;
2746 
2748  "created queue with target %s\n",
2749  GNUNET_i2s (&queue->target));
2750 
2752  "start kx proto\n");
2753 
2756  boot_queue (queue);
2757  queue->read_task =
2759  queue->sock,
2760  &queue_read,
2761  queue);
2762  queue->write_task =
2764  queue->sock,
2765  &queue_write,
2766  queue);
2767  // TODO To early! Move it somewhere else.
2768  // send_challenge (tc.challenge, queue);
2769  queue->challenge_received = tc.challenge;
2770 
2772  GNUNET_free (pq);
2773 }
2774 
2775 
2783 static void
2784 listen_cb (void *cls)
2785 {
2786  struct sockaddr_storage in;
2787  socklen_t addrlen;
2788  struct GNUNET_NETWORK_Handle *sock;
2789  struct ProtoQueue *pq;
2790  struct ListenTask *lt;
2791 
2793  "listen_cb\n");
2794 
2795  lt = cls;
2796 
2797  lt->listen_task = NULL;
2798  GNUNET_assert (NULL != lt->listen_sock);
2799  addrlen = sizeof(in);
2800  memset (&in, 0, sizeof(in));
2802  (struct sockaddr*) &in,
2803  &addrlen);
2804  if ((NULL == sock) && ((EMFILE == errno) || (ENFILE == errno)))
2805  return; /* system limit reached, wait until connection goes down */
2807  lt->listen_sock,
2808  &listen_cb,
2809  lt);
2810  if ((NULL == sock) && ((EAGAIN == errno) || (ENOBUFS == errno)))
2811  return;
2812  if (NULL == sock)
2813  {
2815  return;
2816  }
2817  pq = GNUNET_new (struct ProtoQueue);
2818  pq->address_len = addrlen;
2819  pq->address = GNUNET_memdup (&in, addrlen);
2821  pq->sock = sock;
2823  pq->sock,
2824  &proto_read_kx,
2825  pq);
2827 }
2828 
2829 
2837 static void
2838 queue_read_kx (void *cls)
2839 {
2840  struct Queue *queue = cls;
2841  ssize_t rcvd;
2842  struct GNUNET_TIME_Relative left;
2843  struct TCPConfirmation tc;
2844 
2845  queue->read_task = NULL;
2846  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
2847  if (0 == left.rel_value_us)
2848  {
2849  queue_destroy (queue);
2850  return;
2851  }
2852  rcvd = GNUNET_NETWORK_socket_recv (queue->sock,
2853  &queue->cread_buf[queue->cread_off],
2854  BUF_SIZE - queue->cread_off);
2856  "Received %lu bytes for KX\n",
2857  rcvd);
2859  "transport",
2860  "Received %lu bytes for KX\n",
2861  rcvd);
2862  if (-1 == rcvd)
2863  {
2864  if ((EAGAIN != errno) && (EINTR != errno))
2865  {
2867  queue_destroy (queue);
2868  return;
2869  }
2870  queue->read_task =
2872  return;
2873  }
2874  queue->cread_off += rcvd;
2875  if (queue->cread_off < INITIAL_KX_SIZE)
2876  {
2877  /* read more */
2878  queue->read_task =
2880  return;
2881  }
2882  /* we got all the data, let's find out who we are talking to! */
2884  queue->cread_buf,
2885  queue);
2886  if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, queue->cread_buf))
2887  {
2889  "Invalid TCP KX received from %s\n",
2890  GNUNET_a2s (queue->address, queue->address_len));
2891  queue_destroy (queue);
2892  return;
2893  }
2894  if (0 !=
2895  memcmp (&tc.sender, &queue->target, sizeof(struct GNUNET_PeerIdentity)))
2896  {
2898  "Invalid sender in TCP KX received from %s\n",
2899  GNUNET_a2s (queue->address, queue->address_len));
2900  queue_destroy (queue);
2901  return;
2902  }
2903  send_challenge (tc.challenge, queue);
2904  queue->write_task =
2906  queue->sock,
2907  &queue_write,
2908  queue);
2909 
2910  /* update queue timeout */
2912  /* prepare to continue with regular read task immediately */
2913  memmove (queue->cread_buf,
2914  &queue->cread_buf[INITIAL_KX_SIZE],
2915  queue->cread_off - (INITIAL_KX_SIZE));
2917  "cread_off is %lu bytes before adjusting\n",
2918  queue->cread_off);
2919  queue->cread_off -= INITIAL_KX_SIZE;
2921  "cread_off set to %lu bytes\n",
2922  queue->cread_off);
2924 }
2925 
2926 
2945 static int
2946 mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
2947 {
2948  struct Queue *queue;
2949  const char *path;
2950  struct sockaddr *in;
2951  socklen_t in_len = 0;
2952  struct GNUNET_NETWORK_Handle *sock;
2953 
2955  "Connecting to %s\n", address);
2957  "transport",
2958  "Connecting to %s\n", address);
2959  if (0 != strncmp (address,
2961  strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
2962  {
2963  GNUNET_break_op (0);
2964  return GNUNET_SYSERR;
2965  }
2966  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
2967  in = tcp_address_to_sockaddr (path, &in_len);
2968 
2969  if (NULL == in)
2970  {
2972  "Failed to setup TCP socket address\n");
2973  return GNUNET_SYSERR;
2974  }
2975 
2977  "in %s\n",
2978  GNUNET_a2s (in, in_len));
2979 
2980  sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP);
2981  if (NULL == sock)
2982  {
2984  "socket(%d) failed: %s",
2985  in->sa_family,
2986  strerror (errno));
2987  GNUNET_free (in);
2988  return GNUNET_SYSERR;
2989  }
2990  if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (sock, in, in_len)) &&
2991  (errno != EINPROGRESS))
2992  {
2994  "connect to `%s' failed: %s",
2995  address,
2996  strerror (errno));
2998  GNUNET_free (in);
2999  return GNUNET_SYSERR;
3000  }
3001 
3002  queue = GNUNET_new (struct Queue);
3003  queue->target = *peer;
3004  queue->address = in;
3005  queue->address_len = in_len;
3006  queue->sock = sock;
3008  boot_queue (queue);
3010  "booted queue with target %s\n",
3011  GNUNET_i2s (&queue->target));
3012  // queue->mq_awaits_continue = GNUNET_YES;
3013  queue->read_task =
3015  queue->sock,
3016  &queue_read_kx,
3017  queue);
3018 
3019 
3021  "start kx mq_init\n");
3022 
3024  queue->write_task =
3026  queue->sock,
3027  &queue_write,
3028  queue);
3029  return GNUNET_OK;
3030 }
3031 
3032 
3041 static int
3042 get_lt_delete_it (void *cls,
3043  const struct GNUNET_HashCode *key,
3044  void *value)
3045 {
3046  struct ListenTask *lt = value;
3047 
3048  (void) cls;
3049  (void) key;
3050  if (NULL != lt->listen_task)
3051  {
3053  lt->listen_task = NULL;
3054  }
3055  if (NULL != lt->listen_sock)
3056  {
3058  lt->listen_sock = NULL;
3059  }
3060  return GNUNET_OK;
3061 }
3062 
3063 
3072 static int
3074  const struct GNUNET_PeerIdentity *target,
3075  void *value)
3076 {
3077  struct Queue *queue = value;
3078 
3079  (void) cls;
3080  (void) target;
3081  queue_destroy (queue);
3082  return GNUNET_OK;
3083 }
3084 
3085 
3091 static void
3092 do_shutdown (void *cls)
3093 {
3095  "Shutdown %s!\n",
3096  shutdown_running ? "running" : "not running");
3097 
3099  return;
3100  else
3102 
3103  while (NULL != proto_head)
3105  if (NULL != nat)
3106  {
3108  nat = NULL;
3109  }
3113  if (NULL != ch)
3114  {
3117  ch = NULL;
3118  }
3119  if (NULL != stats)
3120  {
3122  stats = NULL;
3123  }
3124  if (NULL != my_private_key)
3125  {
3127  my_private_key = NULL;
3128  }
3129  if (NULL != is)
3130  {
3132  is = NULL;
3133  }
3134  if (NULL != peerstore)
3135  {
3137  peerstore = NULL;
3138  }
3139  if (NULL != resolve_request_handle)
3140  {
3142  resolve_request_handle = NULL;
3143  }
3145  "Shutdown done!\n");
3146 }
3147 
3148 
3160 static void
3161 enc_notify_cb (void *cls,
3162  const struct GNUNET_PeerIdentity *sender,
3163  const struct GNUNET_MessageHeader *msg)
3164 {
3165  (void) cls;
3166  (void) sender;
3167  (void) msg;
3168  GNUNET_break_op (0);
3169 }
3170 
3171 
3185 static void
3186 nat_address_cb (void *cls,
3187  void **app_ctx,
3188  int add_remove,
3190  const struct sockaddr *addr,
3191  socklen_t addrlen)
3192 {
3193  char *my_addr;
3195 
3197  "nat address cb %s %s\n",
3198  add_remove ? "add" : "remove",
3199  GNUNET_a2s (addr, addrlen));
3200 
3201  if (GNUNET_YES == add_remove)
3202  {
3203  enum GNUNET_NetworkType nt;
3204 
3205  GNUNET_asprintf (&my_addr,
3206  "%s-%s",
3208  GNUNET_a2s (addr, addrlen));
3209  nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
3210  ai =
3212  my_addr,
3213  nt,
3215  GNUNET_free (my_addr);
3216  *app_ctx = ai;
3217  }
3218  else
3219  {
3220  ai = *app_ctx;
3222  *app_ctx = NULL;
3223  }
3224 }
3225 
3226 
3230 static void
3231 add_addr (struct sockaddr *in, socklen_t in_len)
3232 {
3233 
3234  struct Addresses *saddrs;
3235 
3237  "add address %s\n",
3238  GNUNET_a2s (in, in_len));
3239 
3240  saddrs = GNUNET_new (struct Addresses);
3241  saddrs->addr = in;
3242  saddrs->addr_len = in_len;
3244 
3246  "after add address %s\n",
3247  GNUNET_a2s (in, in_len));
3248 
3250  "add address %s\n",
3251  GNUNET_a2s (saddrs->addr, saddrs->addr_len));
3252 
3253  addrs_lens++;
3254 }
3255 
3256 
3264 static int
3265 init_socket (struct sockaddr *addr,
3266  socklen_t in_len)
3267 {
3268  struct sockaddr_storage in_sto;
3269  socklen_t sto_len;
3270  struct GNUNET_NETWORK_Handle *listen_sock;
3271  struct ListenTask *lt;
3272  int sockfd;
3273  struct GNUNET_HashCode h_sock;
3274 
3275  if (NULL == addr)
3276  {
3278  "Address is NULL.\n");
3279  return GNUNET_SYSERR;
3280  }
3281 
3283  "address %s\n",
3284  GNUNET_a2s (addr, in_len));
3285 
3286  listen_sock =
3287  GNUNET_NETWORK_socket_create (addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
3288  if (NULL == listen_sock)
3289  {
3291  return GNUNET_SYSERR;
3292  }
3293 
3294  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (listen_sock, addr, in_len))
3295  {
3297  GNUNET_NETWORK_socket_close (listen_sock);
3298  listen_sock = NULL;
3299  return GNUNET_SYSERR;
3300  }
3301 
3302  if (GNUNET_OK !=
3303  GNUNET_NETWORK_socket_listen (listen_sock,
3304  5))
3305  {
3307  "listen");
3308  GNUNET_NETWORK_socket_close (listen_sock);
3309  listen_sock = NULL;
3310  return GNUNET_SYSERR;
3311  }
3312 
3313  /* We might have bound to port 0, allowing the OS to figure it out;
3314  thus, get the real IN-address from the socket */
3315  sto_len = sizeof(in_sto);
3316 
3317  if (0 != getsockname (GNUNET_NETWORK_get_fd (listen_sock),
3318  (struct sockaddr *) &in_sto,
3319  &sto_len))
3320  {
3321  memcpy (&in_sto, addr, in_len);
3322  sto_len = in_len;
3323  }
3324 
3325  // addr = (struct sockaddr *) &in_sto;
3326  in_len = sto_len;
3328  "Bound to `%s'\n",
3329  GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len));
3330  stats = GNUNET_STATISTICS_create ("C-TCP", cfg);
3331 
3332  if (NULL == is)
3334 
3335  if (NULL == my_private_key)
3337  if (NULL == my_private_key)
3338  {
3339  GNUNET_log (
3341  _ (
3342  "Transport service is lacking key configuration settings. Exiting.\n"));
3343  if (NULL != resolve_request_handle)
3346  return GNUNET_SYSERR;
3347  }
3349  /* start listening */
3350 
3351  lt = GNUNET_new (struct ListenTask);
3352  lt->listen_sock = listen_sock;
3353 
3355  listen_sock,
3356  &listen_cb,
3357  lt);
3358 
3360  "creating hash\n");
3361  sockfd = GNUNET_NETWORK_get_fd (lt->listen_sock);
3362  GNUNET_CRYPTO_hash (&sockfd,
3363  sizeof(int),
3364  &h_sock);
3365 
3367  "creating map\n");
3368  if (NULL == lt_map)
3370 
3372  "creating map entry\n");
3375  &h_sock,
3376  lt,
3378 
3380  "map entry created\n");
3381 
3382  if (NULL == queue_map)
3384 
3385  if (NULL == ch)
3390  &mq_init,
3391  NULL,
3392  &enc_notify_cb,
3393  NULL);
3394 
3395  if (NULL == ch)
3396  {
3397  GNUNET_break (0);
3398  if (NULL != resolve_request_handle)
3401  return GNUNET_SYSERR;
3402  }
3403 
3404  add_addr (addr, in_len);
3405  return GNUNET_OK;
3406 
3407 }
3408 
3409 
3413 static void
3415 {
3416  struct sockaddr **saddrs;
3417  socklen_t *saddr_lens;
3418  int i;
3419  size_t len;
3420 
3422  "starting nat register!\n");
3423  len = 0;
3424  i = 0;
3425  saddrs = GNUNET_malloc ((addrs_lens) * sizeof(struct sockaddr *));
3426  saddr_lens = GNUNET_malloc ((addrs_lens) * sizeof(socklen_t));
3427  for (struct Addresses *pos = addrs_head; NULL != pos; pos = pos->next)
3428  {
3430  "registering address %s\n",
3432 
3433  saddr_lens[i] = addrs_head->addr_len;
3434  len += saddr_lens[i];
3435  saddrs[i] = GNUNET_memdup (addrs_head->addr, saddr_lens[i]);
3436  i++;
3437  }
3438 
3440  "registering addresses %lu %lu %lu %lu\n",
3441  (addrs_lens) * sizeof(struct sockaddr *),
3442  (addrs_lens) * sizeof(socklen_t),
3443  len,
3444  sizeof(COMMUNICATOR_CONFIG_SECTION));
3447  IPPROTO_TCP,
3448  addrs_lens,
3449  (const struct sockaddr **) saddrs,
3450  saddr_lens,
3451  &nat_address_cb,
3452  NULL /* FIXME: support reversal: #5529 */,
3453  NULL /* closure */);
3454  for (i = addrs_lens - 1; i >= 0; i--)
3455  GNUNET_free (saddrs[i]);
3456  GNUNET_free (saddrs);
3457  GNUNET_free (saddr_lens);
3458 
3459  if (NULL == nat)
3460  {
3461  GNUNET_break (0);
3462  if (NULL != resolve_request_handle)
3465  }
3466 }
3467 
3468 
3476 static void
3478  const struct sockaddr *addr,
3479  socklen_t in_len)
3480 {
3481  struct sockaddr_in *v4;
3482  struct sockaddr_in6 *v6;
3483  struct sockaddr *in;
3484 
3485  (void) cls;
3486  if (NULL != addr)
3487  {
3488  if (AF_INET == addr->sa_family)
3489  {
3490  v4 = (struct sockaddr_in *) addr;
3491  in = tcp_address_to_sockaddr_numeric_v4 (&in_len, *v4, bind_port);// _global);
3492  }
3493  else if (AF_INET6 == addr->sa_family)
3494  {
3495  v6 = (struct sockaddr_in6 *) addr;
3496  in = tcp_address_to_sockaddr_numeric_v6 (&in_len, *v6, bind_port);// _global);
3497  }
3498  else
3499  {
3501  "Address family %u not suitable (not AF_INET %u nor AF_INET6 %u \n",
3502  addr->sa_family,
3503  AF_INET,
3504  AF_INET6);
3505  return;
3506  }
3507  init_socket (in, in_len);
3508  }
3509  else
3510  {
3512  "Address is NULL. This might be an error or the resolver finished resolving.\n");
3513  if (NULL == addrs_head)
3514  {
3516  "Resolver finished resolving, but we do not listen to an address!.\n");
3517  return;
3518  }
3519  nat_register ();
3520  }
3521 }
3522 
3523 
3532 static void
3533 run (void *cls,
3534  char *const *args,
3535  const char *cfgfile,
3536  const struct GNUNET_CONFIGURATION_Handle *c)
3537 {
3538  char *bindto;
3539  struct sockaddr *in;
3540  socklen_t in_len;
3541  struct sockaddr_in v4;
3542  struct sockaddr_in6 v6;
3543  char *start;
3544  unsigned int port;
3545  char dummy[2];
3546  char *rest = NULL;
3547  struct PortOnlyIpv4Ipv6 *po;
3548  socklen_t addr_len_ipv4;
3549  socklen_t addr_len_ipv6;
3550 
3551  (void) cls;
3552  cfg = c;
3553  if (GNUNET_OK !=
3556  "BINDTO",
3557  &bindto))
3558  {
3561  "BINDTO");
3562  return;
3563  }
3564  if (GNUNET_OK !=
3567  "MAX_QUEUE_LENGTH",
3568  &max_queue_length))
3570  if (GNUNET_OK !=
3573  "REKEY_INTERVAL",
3574  &rekey_interval))
3576 
3578  if (NULL == peerstore)
3579  {
3580  GNUNET_free (bindto);
3581  GNUNET_break (0);
3583  return;
3584  }
3585 
3587 
3588  if (1 == sscanf (bindto, "%u%1s", &bind_port, dummy))
3589  {
3593  "address po %s\n",
3595  if (NULL != po->addr_ipv4)
3596  {
3598  }
3599  if (NULL != po->addr_ipv6)
3600  {
3603  }
3604  GNUNET_free (po);
3605  nat_register ();
3606  GNUNET_free (bindto);
3607  return;
3608  }
3609 
3610  start = extract_address (bindto);
3611  // FIXME: check for NULL == start...
3612  if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
3613  {
3614  bind_port = extract_port (bindto);
3615 
3616  in = tcp_address_to_sockaddr_numeric_v4 (&in_len, v4, bind_port);
3617  init_socket (in, in_len);
3618  nat_register ();
3619  GNUNET_free (start);
3620  GNUNET_free (bindto);
3621  return;
3622  }
3623 
3624  if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
3625  {
3626  bind_port = extract_port (bindto);
3627  in = tcp_address_to_sockaddr_numeric_v6 (&in_len, v6, bind_port);
3628  init_socket (in, in_len);
3629  nat_register ();
3630  GNUNET_free (start);
3631  GNUNET_free (bindto);
3632  return;
3633  }
3634 
3635  bind_port = extract_port (bindto);
3636  resolve_request_handle = GNUNET_RESOLVER_ip_get (strtok_r (bindto,
3637  ":",
3638  &rest),
3639  AF_UNSPEC,
3642  &port);
3643  GNUNET_free (bindto);
3644  GNUNET_free (start);
3645 }
3646 
3647 
3655 int
3656 main (int argc, char *const *argv)
3657 {
3658  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
3660  };
3661  int ret;
3662 
3664  "transport",
3665  "Starting tcp communicator\n");
3666  if (GNUNET_OK !=
3667  GNUNET_STRINGS_get_utf8_args (argc, argv,
3668  &argc, &argv))
3669  return 2;
3670 
3671  ret = (GNUNET_OK ==
3672  GNUNET_PROGRAM_run (argc,
3673  argv,
3674  "gnunet-communicator-tcp",
3675  _ ("GNUnet TCP communicator"),
3676  options,
3677  &run,
3678  NULL))
3679  ? 0
3680  : 1;
3681  GNUNET_free_nz ((void *) argv);
3682  return ret;
3683 }
3684 
3685 
3686 /* end of gnunet-communicator-tcp.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static int res
static void done()
static uint16_t port
Port number.
Definition: gnunet-bcd.c:147
static void calculate_hmac(struct GNUNET_HashCode *hmac_secret, const void *buf, size_t buf_size, struct GNUNET_ShortHashCode *smac)
Compute mac over buf, and ratched the hmac_secret.
static void queue_finish(struct Queue *queue)
Append a 'finish' message to the outgoing transmission.
static struct GNUNET_CONTAINER_MultiPeerMap * queue_map
Queues (map from peer identity to struct Queue)
static void boot_queue(struct Queue *queue)
Add the given queue to our internal data structure.
unsigned int bind_port
The port the communicator should be assigned to.
struct ListenTask * lts_tail
Head of DLL with ListenTask.
static size_t try_handle_plaintext(struct Queue *queue)
Test if we have received a full message in plaintext.
static void pass_plaintext_to_core(struct Queue *queue, const void *plaintext, size_t plaintext_len)
We received plaintext_len bytes of plaintext on queue.
size_t unverified_size
Size of data received without KX challenge played back.
static struct GNUNET_PeerIdentity my_identity
Our public key.
static int get_queue_delete_it(void *cls, const struct GNUNET_PeerIdentity *target, void *value)
Iterator over all message queues to clean up.
#define COMMUNICATOR_ADDRESS_PREFIX
Address prefix used by the communicator.
static void mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state)
Signature of functions implementing the destruction of a message queue.
#define ADDRESS_VALIDITY_PERIOD
How long do we believe our addresses to remain up (before the other peer should revalidate).
#define INITIAL_CORE_KX_SIZE
Size of the initial core key exchange messages.
static void do_rekey(struct Queue *queue, const struct TCPRekey *rekey)
Handle rekey message on queue.
static int init_socket(struct sockaddr *addr, socklen_t in_len)
This method launch network interactions for each address we like to bind to.
static struct GNUNET_NT_InterfaceScanner * is
Network scanner to determine network types.
static void listen_cb(void *cls)
We have been notified that our listen socket has something to read.
static void rekey_monotime_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY where...
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
static void queue_destroy(struct Queue *queue)
Functions with this signature are called whenever we need to close a queue due to a disconnect or fai...
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void enc_notify_cb(void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
Function called when the transport service has received an acknowledgement for this communicator (!...
static void handshake_ack_monotime_store_cb(void *cls, int success)
Callback called when peerstore store operation for handshake ack monotime value is finished.
static struct GNUNET_PEERSTORE_Handle * peerstore
Database for peer's HELLOs.
static struct ProtoQueue * proto_tail
Protoqueues DLL tail.
static void queue_read_kx(void *cls)
Read from the socket of the queue until we have enough data to initialize the decryption logic and ca...
static int get_lt_delete_it(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over all ListenTasks to clean up.
static void inject_rekey(struct Queue *queue)
Inject a struct TCPRekey message into the queue's plaintext buffer.
static struct GNUNET_TIME_Relative rekey_interval
The rekey interval.
static struct PortOnlyIpv4Ipv6 * tcp_address_to_sockaddr_port_only(const char *bindto, unsigned int *port)
Convert TCP bind specification to a struct PortOnlyIpv4Ipv6 *
#define BUF_SIZE
Size of our IO buffers for ciphertext data.
static void reschedule_queue_timeout(struct Queue *queue)
Increment queue timeout due to activity.
static void do_shutdown(void *cls)
Shutdown the UNIX communicator.
#define COMMUNICATOR_CONFIG_SECTION
Configuration section used by the communicator.
static void proto_read_kx(void *cls)
Read from the socket of the proto queue until we have enough data to upgrade to full queue.
static char * extract_address(const char *bindto)
This Method extracts the address part of the BINDTO string.
static void nat_address_cb(void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of ...
static void init_socket_resolv(void *cls, const struct sockaddr *addr, socklen_t in_len)
This method is the callback called by the resolver API, and wraps method init_socket.
static struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Our environment.
static unsigned long long max_queue_length
Maximum queue length before we stop reading towards the transport service.
struct GNUNET_RESOLVER_RequestHandle * resolve_request_handle
Handle for DNS lookup of bindto address.
static void nat_register()
This method reads from the DLL addrs_head to register them at the NAT service.
int addrs_lens
Number of addresses in the DLL for register at NAT service.
static struct sockaddr * tcp_address_to_sockaddr(const char *bindto, socklen_t *sock_len)
Convert TCP bind specification to a struct sockaddr *
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
Setup communicator and launch network interactions.
struct ListenTask * lts_head
Head of DLL with ListenTasks.
static struct GNUNET_NAT_Handle * nat
Connection to NAT service.
#define PROTO_QUEUE_TIMEOUT
How long do we wait until we must have received the initial KX?
static void queue_read(void *cls)
Queue read task.
#define REKEY_MAX_BYTES
How often do we rekey based on number of bytes transmitted? (additionally randomized).
static void mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
#define INITIAL_KX_SIZE
Size of the initial key exchange message sent first in both directions.
static void handshake_ack_monotime_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_A...
static int mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
Function called by the transport service to initialize a message queue given address information abou...
static void setup_out_cipher(struct Queue *queue)
Setup cipher for outgoing data stream based on target and our ephemeral private key.
static void setup_cipher(const struct GNUNET_HashCode *dh, const struct GNUNET_PeerIdentity *pid, gcry_cipher_hd_t *cipher, struct GNUNET_HashCode *hmac_key)
Setup cipher based on shared secret dh and decrypting peer pid.
static struct sockaddr * tcp_address_to_sockaddr_numeric_v4(socklen_t *sock_len, struct sockaddr_in v4, unsigned int port)
Convert a struct sockaddr_in4 to astruct sockaddr *`.
static void handshake_monotime_store_cb(void *cls, int success)
Callback called when peerstore store operation for handshake monotime is finished.
static void send_challenge(struct GNUNET_CRYPTO_ChallengeNonceP challenge, struct Queue *queue)
Sending challenge with TcpConfirmationAck back to sender of ephemeral key.
static void rekey_monotime_store_cb(void *cls, int success)
Callback called when peerstore store operation for rekey monotime value is finished.
static struct ProtoQueue * proto_head
Protoqueues DLL head.
static void setup_in_cipher(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, struct Queue *queue)
Setup cipher of queue for decryption.
int shutdown_running
A flag indicating we are already doing a shutdown.
static void transmit_kx(struct Queue *queue, const struct GNUNET_CRYPTO_EcdhePublicKey *epub)
Generate and transmit our ephemeral key and the signature for the initial KX with the other peer.
static int decrypt_and_check_tc(struct Queue *queue, struct TCPConfirmation *tc, char *ibuf)
We have received the first bytes from the other side on a queue.
#define DEFAULT_REKEY_INTERVAL
How often do we rekey based on time (at least)
int main(int argc, char *const *argv)
The main function for the UNIX communicator.
static struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Our private key.
static void queue_write(void *cls)
We have been notified that our socket is ready to write.
static void add_addr(struct sockaddr *in, socklen_t in_len)
This method adds addresses to the DLL, that are later register at the NAT service.
static void handshake_monotime_cb(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE w...
struct Addresses * addrs_head
Head of DLL with addresses we like to register at NAT servcie.
struct Addresses * addrs_tail
Head of DLL with addresses we like to register at NAT servcie.
#define DEFAULT_MAX_QUEUE_LENGTH
How many messages do we keep at most in the queue to the transport service before we start to drop (d...
static void mq_error(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
static unsigned int extract_port(const char *addr_and_port)
This Method extracts the port part of the BINDTO string.
static void mq_send(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Signature of functions implementing the sending functionality of a message queue.
static void start_initial_kx_out(struct Queue *queue)
Initialize our key material for outgoing transmissions and inform the other peer about it.
static void free_proto_queue(struct ProtoQueue *pq)
Closes socket and frees memory associated with pq.
static struct GNUNET_CONTAINER_MultiHashMap * lt_map
ListenTasks (map from socket to struct ListenTask)
static void core_read_finished_cb(void *cls, int success)
Core tells us it is done processing a message that transport received on a queue with status success.
static struct sockaddr * tcp_address_to_sockaddr_numeric_v6(socklen_t *sock_len, struct sockaddr_in6 v6, unsigned int port)
Convert a struct sockaddr_in6 to astruct sockaddr *`.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static char * address
GNS address for this phone.
struct GNUNET_HashCode key
The key used in the DHT.
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static char * value
Value of the record to add/remove.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
static struct GNUNET_MQ_Envelope * ac
Handle to current GNUNET_PEERINFO_add_peer() operation.
static char buf[2048]
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
static void queue(const char *hostname)
Add hostname to the list of requests to be made.
Core service; the main API for encrypted P2P communications.
API to the peerstore service.
Constants for network protocols.
#define GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE_ACK
Signature by a peer sending back the nonce received at initial handshake.
#define GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY
Signature used by TCP communicator rekey.
#define GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE
Signature used by TCP communicator handshake.
API to create, modify and access statistics.
API of the transport service towards the communicator processes.
enum GNUNET_GenericReturnValue 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.
enum GNUNET_GenericReturnValue 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".
enum GNUNET_GenericReturnValue 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.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don't receive messages from the peer?
void GNUNET_CRYPTO_ecdhe_key_create(struct GNUNET_CRYPTO_EcdhePrivateKey *pk)
Create a new private key.
Definition: crypto_ecc.c:435
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Generate a random unsigned 64-bit value.
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer's key from the file specified in the configuration.
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
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:197
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_ecdh(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EcdhePublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a ECDH public key and a private EdDSA key.
Definition: crypto_ecc.c:739
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecdh_eddsa(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, const struct GNUNET_CRYPTO_EddsaPublicKey *pub, struct GNUNET_HashCode *key_material)
Derive key material from a EdDSA public key and a private ECDH key.
Definition: crypto_ecc.c:779
#define GNUNET_CRYPTO_eddsa_sign(priv, ps, sig)
EdDSA sign a given block.
#define GNUNET_CRYPTO_eddsa_verify(purp, ps, sig, pub)
Verify EdDSA signature.
void GNUNET_CRYPTO_ecdhe_key_get_public(const struct GNUNET_CRYPTO_EcdhePrivateKey *priv, struct GNUNET_CRYPTO_EcdhePublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:213
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_kdf(void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_kdf.c:69
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
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).
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
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.
enum GNUNET_GenericReturnValue 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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_NETWORK_STRUCT_BEGIN
Define as empty, GNUNET_PACKED should suffice, but this won't work on W32.
#define GNUNET_log(kind,...)
#define GNUNET_NETWORK_STRUCT_END
Define as empty, GNUNET_PACKED should suffice, but this won't work on W32;.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:96
#define GNUNET_MIN(a, b)
void GNUNET_CRYPTO_hmac_raw(const void *key, size_t key_len, const void *plaintext, size_t plaintext_len, struct GNUNET_HashCode *hmac)
Calculate HMAC of a message (RFC 2104) TODO: Shouldn't this be the standard hmac function and the abo...
Definition: crypto_hash.c:299
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
const char * GNUNET_e2s(const struct GNUNET_CRYPTO_EcdhePublicKey *p)
Convert a public key value to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
void GNUNET_log_from_nocheck(enum GNUNET_ErrorType kind, const char *comp, const char *message,...) __attribute__((format(printf
Log function that specifies an alternative component.
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages).
const char * GNUNET_p2s(const struct GNUNET_CRYPTO_EddsaPublicKey *p)
Convert a public key value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_free_nz(ptr)
Wrapper around free.
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
GNUNET_MQ_Error
Error codes for the queue.
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:467
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:423
void GNUNET_NAT_unregister(struct GNUNET_NAT_Handle *nh)
Stop port redirection and public IP address detection for the given handle.
Definition: nat_api.c:701
GNUNET_NAT_AddressClass
Some addresses contain sensitive information or are not suitable for global distribution.
struct GNUNET_NAT_Handle * GNUNET_NAT_register(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section, uint8_t proto, unsigned int num_addrs, const struct sockaddr **addrs, const socklen_t *addrlens, GNUNET_NAT_AddressCallback address_callback, GNUNET_NAT_ReversalCallback reversal_callback, void *callback_cls)
Attempt to enable port redirection and detect public IP address contacting UPnP or NAT-PMP routers on...
Definition: nat_api.c:386
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:508
int GNUNET_NETWORK_get_fd(const struct GNUNET_NETWORK_Handle *desc)
Return file descriptor for this network handle.
Definition: network.c:1023
ssize_t GNUNET_NETWORK_socket_recv(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length)
Read data from a connected socket (always non-blocking).
Definition: network.c:731
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_connect(const struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Connect a socket to some remote address.
Definition: network.c:606
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_accept(const struct GNUNET_NETWORK_Handle *desc, struct sockaddr *address, socklen_t *address_len)
Accept a new connection on a socket.
Definition: network.c:392
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:855
ssize_t GNUNET_NETWORK_socket_send(const struct GNUNET_NETWORK_Handle *desc, const void *buffer, size_t length)
Send data (always non-blocking).
Definition: network.c:760
enum GNUNET_GenericReturnValue GNUNET_NETWORK_test_pf(int pf)
Test if the given protocol family is supported by this system.
Definition: network.c:79
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_bind(struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Bind a socket to a particular address.
Definition: network.c:439
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_listen(const struct GNUNET_NETWORK_Handle *desc, int backlog)
Listen on a socket.
Definition: network.c:656
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:36
void GNUNET_NT_scanner_done(struct GNUNET_NT_InterfaceScanner *is)
Terminate interface scanner.
Definition: nt.c:433
struct GNUNET_NT_InterfaceScanner * GNUNET_NT_scanner_init(void)
Initialize the address characterization client handle.
Definition: nt.c:412
enum GNUNET_NetworkType GNUNET_NT_scanner_get_type(struct GNUNET_NT_InterfaceScanner *is, const struct sockaddr *addr, socklen_t addrlen)
Returns where the address is located: loopback, LAN or WAN.
Definition: nt.c:314
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
struct GNUNET_PEERSTORE_StoreContext * GNUNET_PEERSTORE_store(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
Store a new entry in the PEERSTORE.
void GNUNET_PEERSTORE_store_cancel(struct GNUNET_PEERSTORE_StoreContext *sc)
Cancel a store request.
void GNUNET_PEERSTORE_iterate_cancel(struct GNUNET_PEERSTORE_IterateContext *ic)
Cancel an iterate request Please do not call after the iterate request is done.
#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE
Key used to store sender's monotonic time from handshake message.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h, int sync_first)
Disconnect from the PEERSTORE service.
#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK
Key used to store sender's monotonic time from handshake ack message.
#define GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY
Key used to store sender's monotonic time from rekey message.
struct GNUNET_PEERSTORE_IterateContext * GNUNET_PEERSTORE_iterate(struct GNUNET_PEERSTORE_Handle *h, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Iterate over records matching supplied key information.
@ GNUNET_PEERSTORE_STOREOPTION_REPLACE
Delete any previous values for the given key before storing the given value.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:399
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK
TCP communicator confirmation ack.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH
TCP communicator end of stream.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX
TCP communicator payload box.
#define GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY
TCP communicator rekey message.
void GNUNET_RESOLVER_request_cancel(struct GNUNET_RESOLVER_RequestHandle *rh)
Cancel a request that is still pending with the resolver.
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_ip_get(const char *hostname, int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *callback_cls)
Convert a string to one or more IP addresses.
Definition: resolver_api.c:939
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:533
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:1281
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1573
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1502
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,...
Definition: scheduler.c:1316
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:957
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1223
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:404
#define GNUNET_TIME_UNIT_MINUTES
One minute.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:617
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:736
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:315
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_monotonic(const struct GNUNET_CONFIGURATION_Handle *cfg)
Obtain the current time and make sure it is monotonically increasing.
Definition: time.c:859
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:570
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:637
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
void GNUNET_TRANSPORT_communicator_address_remove(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Notify transport service about an address that this communicator no longer provides for this peer.
int GNUNET_TRANSPORT_communicator_receive(struct GNUNET_TRANSPORT_CommunicatorHandle *handle, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, struct GNUNET_TIME_Relative expected_addr_validity, GNUNET_TRANSPORT_MessageCompletedCallback cb, void *cb_cls)
Notify transport service that the communicator has received a message.
void GNUNET_TRANSPORT_communicator_mq_del(struct GNUNET_TRANSPORT_QueueHandle *qh)
Notify transport service that an MQ became unavailable due to a disconnect or timeout.
#define GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED
Queue length.
struct GNUNET_TRANSPORT_QueueHandle * GNUNET_TRANSPORT_communicator_mq_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *peer, const char *address, uint32_t mtu, uint64_t q_len, uint32_t priority, enum GNUNET_NetworkType nt, enum GNUNET_TRANSPORT_ConnectionStatus cs, struct GNUNET_MQ_Handle *mq)
Notify transport service that a MQ became available due to an "inbound" connection or because the com...
struct GNUNET_TRANSPORT_AddressIdentifier * GNUNET_TRANSPORT_communicator_address_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Relative expiration)
Notify transport service about an address that this communicator provides for this peer.
void GNUNET_TRANSPORT_communicator_disconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Disconnect from the transport service.
GNUNET_TRANSPORT_ConnectionStatus
Possible states of a connection.
void GNUNET_TRANSPORT_communicator_address_remove_all(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Notify transport service that this communicator no longer provides all its addresses for this peer.
struct GNUNET_TRANSPORT_CommunicatorHandle * GNUNET_TRANSPORT_communicator_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section_name, const char *addr_prefix, enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc, GNUNET_TRANSPORT_CommunicatorMqInit mq_init, void *mq_init_cls, GNUNET_TRANSPORT_CommunicatorNotify notify_cb, void *notify_cb_cls)
Connect to the transport service.
@ GNUNET_TRANSPORT_CC_RELIABLE
Transmission is reliabile (with ACKs), e.g.
@ GNUNET_TRANSPORT_CS_INBOUND
this is an inbound connection (communicator initiated)
@ GNUNET_TRANSPORT_CS_OUTBOUND
this is an outbound connection (transport initiated)
#define max(x, y)
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:423
DLL to store the addresses we like to register at NAT service.
struct Addresses * next
Kept in a DLL.
struct Addresses * prev
Kept in a DLL.
struct sockaddr * addr
Address we like to register at NAT service.
socklen_t addr_len
Length of address we like to register at NAT service.
Internal representation of the hash map.
Internal representation of the hash map.
Type of a nonce used for challenges.
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
Private ECC key encoded for transmission.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and encr...
Private ECC key encoded for transmission.
an ECC signature using EdDSA.
Definition of a command line option.
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:86
Header for all communications.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Handle for active NAT registrations.
Definition: nat_api.c:72
handle to a socket
Definition: network.c:53
Handle to the interface scanner.
Definition: nt.c:111
Handle to the PEERSTORE service.
Definition: peerstore_api.c:41
Context for a iterate request.
Single PEERSTORE record.
Context for a store request.
Definition: peerstore_api.c:97
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Handle to a request given to the resolver.
Definition: resolver_api.c:103
Entry in list of pending tasks.
Definition: scheduler.c:135
Handle for the service.
A 256-bit hashcode.
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
Internal representation of an address a communicator is currently providing for the transport service...
Opaque handle to the transport service for communicators.
Handle returned to identify the internal data structure the transport API has created to manage a mes...
Struct to use as closure.
struct GNUNET_NETWORK_Handle * listen_sock
Listen socket.
struct GNUNET_SCHEDULER_Task * listen_task
ID of listen task.
In case of port only configuration we like to bind to ipv4 and ipv6 addresses.
struct sockaddr * addr_ipv4
Ipv4 address we like to bind to.
struct sockaddr * addr_ipv6
Ipv6 address we like to bind to.
socklen_t addr_len_ipv6
Length of ipv6 address.
socklen_t addr_len_ipv4
Length of ipv4 address.
Handle for an incoming connection where we do not yet have enough information to setup a full queue.
socklen_t address_len
Length of the address.
struct GNUNET_NETWORK_Handle * listen_sock
Listen socket.
size_t ibuf_off
Current offset for reading into ibuf.
struct GNUNET_TIME_Absolute timeout
Timeout for this protoqueue.
struct GNUNET_NETWORK_Handle * sock
socket that we transmit all data with on this queue
struct sockaddr * address
Address of the other peer.
struct ProtoQueue * prev
Kept in a DLL.
char ibuf[(sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)+sizeof(struct TCPConfirmation))]
Buffer for reading all the information we need to upgrade from protoqueue to queue.
struct GNUNET_SCHEDULER_Task * read_task
ID of read task for this connection.
struct ProtoQueue * next
Kept in a DLL.
Handle for a queue.
unsigned int backpressure
How may messages did we pass from this queue to CORE for which we have yet to receive an acknoweldgem...
struct GNUNET_NETWORK_Handle * sock
socket that we transmit all data with on this queue
struct GNUNET_PEERSTORE_IterateContext * handshake_ack_monotime_get
Iteration Context for retrieving the monotonic time send with the handshake ack.
int rekeyed
GNUNET_YES if we just rekeyed and must thus possibly re-decrypt ciphertext.
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_TRANSPORT_QueueHandle * qh
handle for this queue with the ch.
struct GNUNET_HashCode out_hmac
Shared secret for HMAC generation on outgoing data, ratcheted after each operation.
int finishing
Did we enqueue a finish message and are closing down the queue?
socklen_t address_len
Length of the address.
struct GNUNET_MQ_Handle * mq
Message queue we are providing for the ch.
unsigned long long bytes_in_queue
Number of bytes we currently have in our write queue.
char pread_buf[UINT16_MAX+1+sizeof(struct TCPBox)]
Plaintext buffer for decrypted plaintext.
int destroyed
Did we technically destroy this queue, but kept the allocation around because of backpressure not bei...
struct GNUNET_CRYPTO_EcdhePrivateKey ephemeral
Our ephemeral key.
struct GNUNET_PEERSTORE_StoreContext * rekey_monotime_sc
Store Context for retrieving the monotonic time send with key for rekeying.
size_t cwrite_off
At which offset in the ciphertext write buffer should we append more ciphertext from reading next?
struct GNUNET_PEERSTORE_IterateContext * rekey_monotime_get
Iteration Context for retrieving the monotonic time send with key for rekeying.
char cread_buf[(2 *64 *1024+sizeof(struct TCPBox))]
Buffer for reading ciphertext from network into.
enum GNUNET_NetworkType nt
Which network type does this queue use?
struct GNUNET_CRYPTO_ChallengeNonceP challenge_received
Challenge value received.
struct GNUNET_SCHEDULER_Task * read_task
ID of read task for this connection.
uint64_t rekey_left_bytes
How many more bytes may we sent with the current out_cipher before we should rekey?
int mq_awaits_continue
Is MQ awaiting a GNUNET_MQ_impl_send_continue() call?
gcry_cipher_hd_t in_cipher
cipher for decryption of incoming data.
struct GNUNET_PEERSTORE_StoreContext * handshake_ack_monotime_sc
Store Context for retrieving the monotonic time send with the handshake ack.
size_t pwrite_off
At which offset in the plaintext output buffer should we append more plaintext for encryption next?
struct GNUNET_TIME_Absolute timeout
Timeout for this queue.
struct sockaddr * address
Address of the other peer.
size_t cread_off
At which offset in the ciphertext read buffer should we append more ciphertext for transmission next?
struct GNUNET_TIME_Absolute rekey_time
Until what time may we sent with the current out_cipher before we should rekey?
struct GNUNET_PeerIdentity target
To whom are we talking to.
char cwrite_buf[(2 *64 *1024+sizeof(struct TCPBox))]
buffer for writing ciphertext to network.
struct GNUNET_PEERSTORE_StoreContext * handshake_monotime_sc
Store Context for retrieving the monotonic time send with the handshake.
size_t pread_off
At which offset in the plaintext input buffer should we append more plaintext from decryption next?
enum GNUNET_TRANSPORT_ConnectionStatus cs
The connection status of this queue.
gcry_cipher_hd_t out_cipher
cipher for encryption of outgoing data.
char pwrite_buf[UINT16_MAX+1+sizeof(struct TCPBox)]
Plaintext buffer for messages to be encrypted.
struct GNUNET_HashCode in_hmac
Shared secret for HMAC verification on incoming data.
struct GNUNET_PEERSTORE_IterateContext * handshake_monotime_get
Iteration Context for retrieving the monotonic time send with the handshake.
struct GNUNET_NETWORK_Handle * listen_sock
Listen socket.
struct GNUNET_SCHEDULER_Task * write_task
ID of write task for this connection.
struct GNUNET_TIME_AbsoluteNBO handshake_ack_monotonic_time
Monotonic time value for handshake ack message.
struct GNUNET_TIME_AbsoluteNBO rekey_monotonic_time
Monotonic time value for rekey message.
struct GNUNET_TIME_AbsoluteNBO handshake_monotonic_time
Monotonic time value for handshake message.
TCP message box.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX.
struct GNUNET_ShortHashCode hmac
HMAC for the following encrypted message.
Ack for the encrypted continuation of TCP initial handshake.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Sender's signature of type GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE_ACK.
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK.
struct GNUNET_PeerIdentity sender
Sender's identity.
Encrypted continuation of TCP initial handshake.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Sender's signature of type GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE.
struct GNUNET_PeerIdentity sender
Sender's identity.
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH.
struct GNUNET_ShortHashCode hmac
HMAC for the following encrypted message.
TCP rekey message box.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral
New ephemeral key.
struct GNUNET_CRYPTO_EddsaSignature sender_sig
Sender's signature of type GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY.
struct GNUNET_ShortHashCode hmac
HMAC for the following encrypted message.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY.
Signature we use to verify that the ack from the receiver of the ephemeral key was really send by the...
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE_ACK.
struct GNUNET_PeerIdentity sender
Identity of the inititor of the TCP connection (TCP client).
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_PeerIdentity receiver
Presumed identity of the target of the TCP connection (TCP server)
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
Signature we use to verify that the ephemeral key was really chosen by the specified sender.
struct GNUNET_CRYPTO_ChallengeNonceP challenge
Challenge value used to protect against replay attack, if there is no stored monotonic time value.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE.
struct GNUNET_PeerIdentity sender
Identity of the inititor of the TCP connection (TCP client).
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral
Ephemeral key used by the sender.
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
struct GNUNET_PeerIdentity receiver
Presumed identity of the target of the TCP connection (TCP server)
Signature we use to verify that the ephemeral key was really chosen by the specified sender.
struct GNUNET_CRYPTO_EcdhePublicKey ephemeral
Ephemeral key used by the sender.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Purpose must be GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY.
struct GNUNET_PeerIdentity sender
Identity of the inititor of the TCP connection (TCP client).
struct GNUNET_PeerIdentity receiver
Presumed identity of the target of the TCP connection (TCP server)
struct GNUNET_TIME_AbsoluteNBO monotonic_time
Monotonic time of sender, to possibly help detect replay attacks (if receiver persists times by sende...
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.