diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/transport | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/transport')
85 files changed, 32597 insertions, 31804 deletions
diff --git a/src/transport/communicator.h b/src/transport/communicator.h index 04a9857e5..ab7a25de6 100644 --- a/src/transport/communicator.h +++ b/src/transport/communicator.h @@ -41,7 +41,8 @@ GNUNET_NETWORK_STRUCT_BEGIN * just the recommended "generic" style, communicators are always free * to implement original designs that better fit their requirements. */ -struct GNUNET_TRANSPORT_CommunicatorGenericKXConfirmation { +struct GNUNET_TRANSPORT_CommunicatorGenericKXConfirmation +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_KX_CONFIRMATION */ @@ -88,7 +89,8 @@ struct GNUNET_TRANSPORT_CommunicatorGenericKXConfirmation { * free to implement original designs that better fit their * requirements. */ -struct GNUNET_TRANSPORT_CommunicatorGenericFCLimits { +struct GNUNET_TRANSPORT_CommunicatorGenericFCLimits +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_FC_LIMITS */ diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c index a8d692940..f3ccbd262 100644 --- a/src/transport/gnunet-communicator-tcp.c +++ b/src/transport/gnunet-communicator-tcp.c @@ -47,7 +47,7 @@ * the other peer should revalidate). */ #define ADDRESS_VALIDITY_PERIOD \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 4) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) /** * How many messages do we keep at most in the queue to the @@ -86,8 +86,8 @@ * directions. */ #define INITIAL_KX_SIZE \ - (sizeof(struct GNUNET_CRYPTO_EcdhePublicKey) + \ - sizeof(struct TCPConfirmation)) + (sizeof(struct GNUNET_CRYPTO_EcdhePublicKey) \ + + sizeof(struct TCPConfirmation)) /** @@ -107,7 +107,8 @@ GNUNET_NETWORK_STRUCT_BEGIN * Signature we use to verify that the ephemeral key was really chosen by * the specified sender. */ -struct TcpHandshakeSignature { +struct TcpHandshakeSignature +{ /** * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE */ @@ -139,7 +140,8 @@ struct TcpHandshakeSignature { /** * Encrypted continuation of TCP initial handshake. */ -struct TCPConfirmation { +struct TCPConfirmation +{ /** * Sender's identity */ @@ -161,7 +163,8 @@ struct TCPConfirmation { /** * TCP message box. Always sent encrypted! */ -struct TCPBox { +struct TCPBox +{ /** * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX. Warning: the * header size EXCLUDES the size of the `struct TCPBox`. We usually @@ -189,7 +192,8 @@ struct TCPBox { * TCP rekey message box. Always sent encrypted! Data after * this message will use the new key. */ -struct TCPRekey { +struct TCPRekey +{ /** * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY. */ @@ -228,7 +232,8 @@ struct TCPRekey { * Needed/useful in case we drop RST/FIN packets on the GNUnet * port due to the possibility of malicious RST/FIN injection. */ -struct TCPFinish { +struct TCPFinish +{ /** * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH. */ @@ -252,7 +257,8 @@ GNUNET_NETWORK_STRUCT_END /** * Handle for a queue. */ -struct Queue { +struct Queue +{ /** * To whom are we talking to. */ @@ -430,7 +436,8 @@ struct Queue { * Handle for an incoming connection where we do not yet have enough * information to setup a full queue. */ -struct ProtoQueue { +struct ProtoQueue +{ /** * Kept in a DLL. */ @@ -553,7 +560,7 @@ static struct ProtoQueue *proto_tail; * @param cls NULL */ static void -listen_cb(void *cls); +listen_cb (void *cls); /** @@ -564,53 +571,53 @@ listen_cb(void *cls); * @param queue queue to close down */ static void -queue_destroy(struct Queue *queue) +queue_destroy (struct Queue *queue) { struct GNUNET_MQ_Handle *mq; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Disconnecting queue for peer `%s'\n", - GNUNET_i2s(&queue->target)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Disconnecting queue for peer `%s'\n", + GNUNET_i2s (&queue->target)); if (NULL != (mq = queue->mq)) - { - queue->mq = NULL; - GNUNET_MQ_destroy(mq); - } + { + queue->mq = NULL; + GNUNET_MQ_destroy (mq); + } if (NULL != queue->qh) - { - GNUNET_TRANSPORT_communicator_mq_del(queue->qh); - queue->qh = NULL; - } - GNUNET_assert( + { + GNUNET_TRANSPORT_communicator_mq_del (queue->qh); + queue->qh = NULL; + } + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(queue_map, &queue->target, queue)); - GNUNET_STATISTICS_set(stats, - "# queues active", - GNUNET_CONTAINER_multipeermap_size(queue_map), - GNUNET_NO); + GNUNET_CONTAINER_multipeermap_remove (queue_map, &queue->target, queue)); + GNUNET_STATISTICS_set (stats, + "# queues active", + GNUNET_CONTAINER_multipeermap_size (queue_map), + GNUNET_NO); if (NULL != queue->read_task) - { - GNUNET_SCHEDULER_cancel(queue->read_task); - queue->read_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (queue->read_task); + queue->read_task = NULL; + } if (NULL != queue->write_task) - { - GNUNET_SCHEDULER_cancel(queue->write_task); - queue->write_task = NULL; - } - GNUNET_NETWORK_socket_close(queue->sock); - gcry_cipher_close(queue->in_cipher); - gcry_cipher_close(queue->out_cipher); - GNUNET_free(queue->address); + { + GNUNET_SCHEDULER_cancel (queue->write_task); + queue->write_task = NULL; + } + GNUNET_NETWORK_socket_close (queue->sock); + gcry_cipher_close (queue->in_cipher); + gcry_cipher_close (queue->out_cipher); + GNUNET_free (queue->address); if (0 != queue->backpressure) queue->destroyed = GNUNET_YES; else - GNUNET_free(queue); + GNUNET_free (queue); if (NULL == listen_task) - listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - listen_sock, - &listen_cb, - NULL); + listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + listen_sock, + &listen_cb, + NULL); } @@ -623,24 +630,24 @@ queue_destroy(struct Queue *queue) * @param smac[out] where to write the HMAC */ static void -calculate_hmac(struct GNUNET_HashCode *hmac_secret, - const void *buf, - size_t buf_size, - struct GNUNET_ShortHashCode *smac) +calculate_hmac (struct GNUNET_HashCode *hmac_secret, + const void *buf, + size_t buf_size, + struct GNUNET_ShortHashCode *smac) { struct GNUNET_HashCode mac; - GNUNET_CRYPTO_hmac_raw(hmac_secret, - sizeof(struct GNUNET_HashCode), - buf, - buf_size, - &mac); + GNUNET_CRYPTO_hmac_raw (hmac_secret, + sizeof(struct GNUNET_HashCode), + buf, + buf_size, + &mac); /* truncate to `struct GNUNET_ShortHashCode` */ - memcpy(smac, &mac, sizeof(struct GNUNET_ShortHashCode)); + memcpy (smac, &mac, sizeof(struct GNUNET_ShortHashCode)); /* ratchet hmac key */ - GNUNET_CRYPTO_hash(hmac_secret, - sizeof(struct GNUNET_HashCode), - hmac_secret); + GNUNET_CRYPTO_hash (hmac_secret, + sizeof(struct GNUNET_HashCode), + hmac_secret); } @@ -651,18 +658,18 @@ calculate_hmac(struct GNUNET_HashCode *hmac_secret, * @param queue queue to shut down nicely */ static void -queue_finish(struct Queue *queue) +queue_finish (struct Queue *queue) { struct TCPFinish fin; - memset(&fin, 0, sizeof(fin)); - fin.header.size = htons(sizeof(fin)); - fin.header.type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH); - calculate_hmac(&queue->out_hmac, &fin, sizeof(fin), &fin.hmac); + memset (&fin, 0, sizeof(fin)); + fin.header.size = htons (sizeof(fin)); + fin.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH); + calculate_hmac (&queue->out_hmac, &fin, sizeof(fin), &fin.hmac); /* if there is any message left in pwrite_buf, we overwrite it (possibly dropping the last message from CORE hard here) */ - memcpy(queue->pwrite_buf, &fin, sizeof(fin)); + memcpy (queue->pwrite_buf, &fin, sizeof(fin)); queue->pwrite_off = sizeof(fin); /* This flag will ensure that #queue_write() no longer notifies CORE about the possibility of sending @@ -680,10 +687,10 @@ queue_finish(struct Queue *queue) * @param queue queue for which the timeout should be rescheduled */ static void -reschedule_queue_timeout(struct Queue *queue) +reschedule_queue_timeout (struct Queue *queue) { queue->timeout = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); } @@ -693,7 +700,7 @@ reschedule_queue_timeout(struct Queue *queue) * @param cls the `struct Queue *` to disconnect */ static void -queue_read(void *cls); +queue_read (void *cls); /** @@ -704,31 +711,31 @@ queue_read(void *cls); * @param success #GNUNET_OK on success */ static void -core_read_finished_cb(void *cls, int success) +core_read_finished_cb (void *cls, int success) { struct Queue *queue = cls; if (GNUNET_OK != success) - GNUNET_STATISTICS_update(stats, - "# messages lost in communicator API towards CORE", - 1, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, + "# messages lost in communicator API towards CORE", + 1, + GNUNET_NO); queue->backpressure--; /* handle deferred queue destruction */ if ((queue->destroyed) && (0 == queue->backpressure)) - { - GNUNET_free(queue); - return; - } - reschedule_queue_timeout(queue); + { + GNUNET_free (queue); + return; + } + reschedule_queue_timeout (queue); /* possibly unchoke reading, now that CORE made progress */ if (NULL == queue->read_task) queue->read_task = - GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_absolute_get_remaining( - queue->timeout), - queue->sock, - &queue_read, - queue); + GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining ( + queue->timeout), + queue->sock, + &queue_read, + queue); } @@ -742,34 +749,34 @@ core_read_finished_cb(void *cls, int success) * @param plaintext_len number of bytes of plaintext received */ static void -pass_plaintext_to_core(struct Queue *queue, - const void *plaintext, - size_t plaintext_len) +pass_plaintext_to_core (struct Queue *queue, + const void *plaintext, + size_t plaintext_len) { const struct GNUNET_MessageHeader *hdr = plaintext; int ret; - if (ntohs(hdr->size) != plaintext_len) - { - /* NOTE: If we ever allow multiple CORE messages in one - BOX, this will have to change! */ - GNUNET_break(0); - return; - } - ret = GNUNET_TRANSPORT_communicator_receive(ch, - &queue->target, - hdr, - ADDRESS_VALIDITY_PERIOD, - &core_read_finished_cb, - queue); + if (ntohs (hdr->size) != plaintext_len) + { + /* NOTE: If we ever allow multiple CORE messages in one + BOX, this will have to change! */ + GNUNET_break (0); + return; + } + ret = GNUNET_TRANSPORT_communicator_receive (ch, + &queue->target, + hdr, + ADDRESS_VALIDITY_PERIOD, + &core_read_finished_cb, + queue); if (GNUNET_OK == ret) queue->backpressure++; - GNUNET_break(GNUNET_NO != ret); /* backpressure not working!? */ + GNUNET_break (GNUNET_NO != ret); /* backpressure not working!? */ if (GNUNET_SYSERR == ret) - GNUNET_STATISTICS_update(stats, - "# bytes lost due to CORE not running", - plaintext_len, - GNUNET_NO); + GNUNET_STATISTICS_update (stats, + "# bytes lost due to CORE not running", + plaintext_len, + GNUNET_NO); } @@ -783,51 +790,51 @@ pass_plaintext_to_core(struct Queue *queue, * @param hmac_key[out] HMAC key to initialize */ 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 (const struct GNUNET_HashCode *dh, + const struct GNUNET_PeerIdentity *pid, + gcry_cipher_hd_t *cipher, + struct GNUNET_HashCode *hmac_key) { char key[256 / 8]; char ctr[128 / 8]; - gcry_cipher_open(cipher, - GCRY_CIPHER_AES256 /* low level: go for speed */, - GCRY_CIPHER_MODE_CTR, - 0 /* flags */); - GNUNET_assert(GNUNET_YES == GNUNET_CRYPTO_kdf(key, - sizeof(key), - "TCP-key", - strlen("TCP-key"), - dh, - sizeof(*dh), - pid, - sizeof(*pid), - NULL, - 0)); - gcry_cipher_setkey(*cipher, key, sizeof(key)); - GNUNET_assert(GNUNET_YES == GNUNET_CRYPTO_kdf(ctr, - sizeof(ctr), - "TCP-ctr", - strlen("TCP-ctr"), - dh, - sizeof(*dh), - pid, - sizeof(*pid), - NULL, - 0)); - gcry_cipher_setctr(*cipher, ctr, sizeof(ctr)); - GNUNET_assert(GNUNET_YES == - GNUNET_CRYPTO_kdf(hmac_key, - sizeof(struct GNUNET_HashCode), - "TCP-hmac", - strlen("TCP-hmac"), - dh, - sizeof(*dh), - pid, - sizeof(*pid), - NULL, - 0)); + gcry_cipher_open (cipher, + GCRY_CIPHER_AES256 /* low level: go for speed */, + GCRY_CIPHER_MODE_CTR, + 0 /* flags */); + GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_kdf (key, + sizeof(key), + "TCP-key", + strlen ("TCP-key"), + dh, + sizeof(*dh), + pid, + sizeof(*pid), + NULL, + 0)); + gcry_cipher_setkey (*cipher, key, sizeof(key)); + GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_kdf (ctr, + sizeof(ctr), + "TCP-ctr", + strlen ("TCP-ctr"), + dh, + sizeof(*dh), + pid, + sizeof(*pid), + NULL, + 0)); + gcry_cipher_setctr (*cipher, ctr, sizeof(ctr)); + GNUNET_assert (GNUNET_YES == + GNUNET_CRYPTO_kdf (hmac_key, + sizeof(struct GNUNET_HashCode), + "TCP-hmac", + strlen ("TCP-hmac"), + dh, + sizeof(*dh), + pid, + sizeof(*pid), + NULL, + 0)); } @@ -838,13 +845,13 @@ setup_cipher(const struct GNUNET_HashCode *dh, * @param queue[in,out] queue to initialize decryption cipher for */ static void -setup_in_cipher(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, - struct Queue *queue) +setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, + struct Queue *queue) { struct GNUNET_HashCode dh; - GNUNET_CRYPTO_eddsa_ecdh(my_private_key, ephemeral, &dh); - setup_cipher(&dh, &my_identity, &queue->in_cipher, &queue->in_hmac); + GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &dh); + setup_cipher (&dh, &my_identity, &queue->in_cipher, &queue->in_hmac); } @@ -857,30 +864,30 @@ setup_in_cipher(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, * @param rekey the rekey message */ static void -do_rekey(struct Queue *queue, const struct TCPRekey *rekey) +do_rekey (struct Queue *queue, const struct TCPRekey *rekey) { struct TcpHandshakeSignature thp; - thp.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); - thp.purpose.size = htonl(sizeof(thp)); + thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); + thp.purpose.size = htonl (sizeof(thp)); thp.sender = queue->target; thp.receiver = my_identity; thp.ephemeral = rekey->ephemeral; thp.monotonic_time = rekey->monotonic_time; /* FIXME: check monotonic time is monotonic... */ if (GNUNET_OK != - GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY, - &thp.purpose, - &rekey->sender_sig, - &queue->target.public_key)) - { - GNUNET_break(0); - queue_finish(queue); - return; - } - gcry_cipher_close(queue->in_cipher); + GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY, + &thp.purpose, + &rekey->sender_sig, + &queue->target.public_key)) + { + GNUNET_break (0); + queue_finish (queue); + return; + } + gcry_cipher_close (queue->in_cipher); queue->rekeyed = GNUNET_YES; - setup_in_cipher(&rekey->ephemeral, queue); + setup_in_cipher (&rekey->ephemeral, queue); } @@ -892,13 +899,13 @@ do_rekey(struct Queue *queue, const struct TCPRekey *rekey) * @return number of bytes of plaintext handled, 0 for none */ static size_t -try_handle_plaintext(struct Queue *queue) +try_handle_plaintext (struct Queue *queue) { const struct GNUNET_MessageHeader *hdr = - (const struct GNUNET_MessageHeader *)queue->pread_buf; - const struct TCPBox *box = (const struct TCPBox *)queue->pread_buf; - const struct TCPRekey *rekey = (const struct TCPRekey *)queue->pread_buf; - const struct TCPFinish *fin = (const struct TCPFinish *)queue->pread_buf; + (const struct GNUNET_MessageHeader *) queue->pread_buf; + const struct TCPBox *box = (const struct TCPBox *) queue->pread_buf; + const struct TCPRekey *rekey = (const struct TCPRekey *) queue->pread_buf; + const struct TCPFinish *fin = (const struct TCPFinish *) queue->pread_buf; struct TCPRekey rekeyz; struct TCPFinish finz; struct GNUNET_ShortHashCode tmac; @@ -907,74 +914,74 @@ try_handle_plaintext(struct Queue *queue) if (sizeof(*hdr) > queue->pread_off) return 0; /* not even a header */ - type = ntohs(hdr->type); + type = ntohs (hdr->type); switch (type) + { + case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX: + /* Special case: header size excludes box itself! */ + if (ntohs (hdr->size) + sizeof(struct TCPBox) > queue->pread_off) + return 0; + calculate_hmac (&queue->in_hmac, &box[1], ntohs (hdr->size), &tmac); + if (0 != memcmp (&tmac, &box->hmac, sizeof(tmac))) { - case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX: - /* Special case: header size excludes box itself! */ - if (ntohs(hdr->size) + sizeof(struct TCPBox) > queue->pread_off) - return 0; - calculate_hmac(&queue->in_hmac, &box[1], ntohs(hdr->size), &tmac); - if (0 != memcmp(&tmac, &box->hmac, sizeof(tmac))) - { - GNUNET_break_op(0); - queue_finish(queue); - return 0; - } - pass_plaintext_to_core(queue, (const void *)&box[1], ntohs(hdr->size)); - size = ntohs(hdr->size) + sizeof(*box); - break; - - case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY: - if (sizeof(*rekey) > queue->pread_off) - return 0; - if (ntohs(hdr->size) != sizeof(*rekey)) - { - GNUNET_break_op(0); - queue_finish(queue); - return 0; - } - rekeyz = *rekey; - memset(&rekeyz.hmac, 0, sizeof(rekeyz.hmac)); - calculate_hmac(&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac); - if (0 != memcmp(&tmac, &box->hmac, sizeof(tmac))) - { - GNUNET_break_op(0); - queue_finish(queue); - return 0; - } - do_rekey(queue, rekey); - size = ntohs(hdr->size); - break; + GNUNET_break_op (0); + queue_finish (queue); + return 0; + } + pass_plaintext_to_core (queue, (const void *) &box[1], ntohs (hdr->size)); + size = ntohs (hdr->size) + sizeof(*box); + break; - case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH: - if (sizeof(*fin) > queue->pread_off) - return 0; - if (ntohs(hdr->size) != sizeof(*fin)) - { - GNUNET_break_op(0); - queue_finish(queue); - return 0; - } - finz = *fin; - memset(&finz.hmac, 0, sizeof(finz.hmac)); - calculate_hmac(&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac); - if (0 != memcmp(&tmac, &fin->hmac, sizeof(tmac))) - { - GNUNET_break_op(0); - queue_finish(queue); - return 0; - } - /* handle FINISH by destroying queue */ - queue_destroy(queue); - break; + case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY: + if (sizeof(*rekey) > queue->pread_off) + return 0; + if (ntohs (hdr->size) != sizeof(*rekey)) + { + GNUNET_break_op (0); + queue_finish (queue); + return 0; + } + rekeyz = *rekey; + memset (&rekeyz.hmac, 0, sizeof(rekeyz.hmac)); + calculate_hmac (&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac); + if (0 != memcmp (&tmac, &box->hmac, sizeof(tmac))) + { + GNUNET_break_op (0); + queue_finish (queue); + return 0; + } + do_rekey (queue, rekey); + size = ntohs (hdr->size); + break; - default: - GNUNET_break_op(0); - queue_finish(queue); + case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH: + if (sizeof(*fin) > queue->pread_off) + return 0; + if (ntohs (hdr->size) != sizeof(*fin)) + { + GNUNET_break_op (0); + queue_finish (queue); + return 0; + } + finz = *fin; + memset (&finz.hmac, 0, sizeof(finz.hmac)); + calculate_hmac (&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac); + if (0 != memcmp (&tmac, &fin->hmac, sizeof(tmac))) + { + GNUNET_break_op (0); + queue_finish (queue); return 0; } - GNUNET_assert(0 != size); + /* handle FINISH by destroying queue */ + queue_destroy (queue); + break; + + default: + GNUNET_break_op (0); + queue_finish (queue); + return 0; + } + GNUNET_assert (0 != size); return size; } @@ -985,96 +992,96 @@ try_handle_plaintext(struct Queue *queue) * @param cls the `struct Queue *` to disconnect */ static void -queue_read(void *cls) +queue_read (void *cls) { struct Queue *queue = cls; struct GNUNET_TIME_Relative left; ssize_t rcvd; queue->read_task = NULL; - rcvd = GNUNET_NETWORK_socket_recv(queue->sock, - &queue->cread_buf[queue->cread_off], - BUF_SIZE - queue->cread_off); + rcvd = GNUNET_NETWORK_socket_recv (queue->sock, + &queue->cread_buf[queue->cread_off], + BUF_SIZE - queue->cread_off); if (-1 == rcvd) + { + if ((EAGAIN != errno) && (EINTR != errno)) { - if ((EAGAIN != errno) && (EINTR != errno)) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv"); - queue_finish(queue); - return; - } - /* try again */ - queue->read_task = - GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read, queue); + GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv"); + queue_finish (queue); return; } + /* try again */ + queue->read_task = + GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read, queue); + return; + } if (0 != rcvd) - reschedule_queue_timeout(queue); + reschedule_queue_timeout (queue); queue->cread_off += rcvd; while ((queue->pread_off < sizeof(queue->pread_buf)) && (queue->cread_off > 0)) - { - size_t max = GNUNET_MIN(sizeof(queue->pread_buf) - queue->pread_off, - queue->cread_off); - size_t done; - size_t total; + { + size_t max = GNUNET_MIN (sizeof(queue->pread_buf) - queue->pread_off, + queue->cread_off); + size_t done; + size_t total; - GNUNET_assert(0 == - gcry_cipher_decrypt(queue->in_cipher, + GNUNET_assert (0 == + gcry_cipher_decrypt (queue->in_cipher, &queue->pread_buf[queue->pread_off], max, queue->cread_buf, max)); - queue->pread_off += max; - total = 0; - while ((GNUNET_NO == queue->rekeyed) && - (0 != (done = try_handle_plaintext(queue)))) - { - /* 'done' bytes of plaintext were used, shift buffer */ - GNUNET_assert(done <= queue->pread_off); - /* NOTE: this memmove() could possibly sometimes be - avoided if we pass 'total' into try_handle_plaintext() - and use it at an offset into the buffer there! */ - memmove(queue->pread_buf, - &queue->pread_buf[done], - queue->pread_off - done); - queue->pread_off -= done; - total += done; - } - /* when we encounter a rekey message, the decryption above uses the - wrong key for everything after the rekey; in that case, we have - to re-do the decryption at 'total' instead of at 'max'. If there - is no rekey and the last message is incomplete (max > total), - it is safe to keep the decryption so we shift by 'max' */ - if (GNUNET_YES == queue->rekeyed) - { - max = total; - queue->rekeyed = GNUNET_NO; - } - memmove(queue->cread_buf, &queue->cread_buf[max], queue->cread_off - max); - queue->cread_off -= max; + queue->pread_off += max; + total = 0; + while ((GNUNET_NO == queue->rekeyed) && + (0 != (done = try_handle_plaintext (queue)))) + { + /* 'done' bytes of plaintext were used, shift buffer */ + GNUNET_assert (done <= queue->pread_off); + /* NOTE: this memmove() could possibly sometimes be + avoided if we pass 'total' into try_handle_plaintext() + and use it at an offset into the buffer there! */ + memmove (queue->pread_buf, + &queue->pread_buf[done], + queue->pread_off - done); + queue->pread_off -= done; + total += done; + } + /* when we encounter a rekey message, the decryption above uses the + wrong key for everything after the rekey; in that case, we have + to re-do the decryption at 'total' instead of at 'max'. If there + is no rekey and the last message is incomplete (max > total), + it is safe to keep the decryption so we shift by 'max' */ + if (GNUNET_YES == queue->rekeyed) + { + max = total; + queue->rekeyed = GNUNET_NO; } + memmove (queue->cread_buf, &queue->cread_buf[max], queue->cread_off - max); + queue->cread_off -= max; + } if (BUF_SIZE == queue->cread_off) return; /* buffer full, suspend reading */ - left = GNUNET_TIME_absolute_get_remaining(queue->timeout); + left = GNUNET_TIME_absolute_get_remaining (queue->timeout); if (0 != left.rel_value_us) + { + if (max_queue_length < queue->backpressure) { - if (max_queue_length < queue->backpressure) - { - /* continue reading */ - queue->read_task = - GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read, queue); - } - return; + /* continue reading */ + queue->read_task = + GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read, queue); } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Queue %p was idle for %s, disconnecting\n", - queue, - GNUNET_STRINGS_relative_time_to_string( - GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - GNUNET_YES)); - queue_finish(queue); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Queue %p was idle for %s, disconnecting\n", + queue, + GNUNET_STRINGS_relative_time_to_string ( + GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, + GNUNET_YES)); + queue_finish (queue); } @@ -1086,7 +1093,7 @@ queue_read(void *cls) * @return converted bindto specification */ static struct sockaddr * -tcp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) +tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len) { struct sockaddr *in; unsigned int port; @@ -1094,88 +1101,88 @@ tcp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) char *colon; char *cp; - if (1 == sscanf(bindto, "%u%1s", &port, dummy)) + if (1 == sscanf (bindto, "%u%1s", &port, dummy)) + { + /* interpreting value as just a PORT number */ + if (port > UINT16_MAX) { - /* interpreting value as just a PORT number */ - if (port > UINT16_MAX) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "BINDTO specification `%s' invalid: value too large for port\n", - bindto); - return NULL; - } - if ((GNUNET_NO == GNUNET_NETWORK_test_pf(PF_INET6)) || - (GNUNET_YES == - GNUNET_CONFIGURATION_get_value_yesno(cfg, - COMMUNICATOR_CONFIG_SECTION, - "DISABLE_V6"))) - { - struct sockaddr_in *i4; - - i4 = GNUNET_malloc(sizeof(struct sockaddr_in)); - i4->sin_family = AF_INET; - i4->sin_port = htons((uint16_t)port); - *sock_len = sizeof(struct sockaddr_in); - in = (struct sockaddr *)i4; - } - else - { - struct sockaddr_in6 *i6; - - i6 = GNUNET_malloc(sizeof(struct sockaddr_in6)); - i6->sin6_family = AF_INET6; - i6->sin6_port = htons((uint16_t)port); - *sock_len = sizeof(struct sockaddr_in6); - in = (struct sockaddr *)i6; - } - return in; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "BINDTO specification `%s' invalid: value too large for port\n", + bindto); + return NULL; + } + if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) || + (GNUNET_YES == + GNUNET_CONFIGURATION_get_value_yesno (cfg, + COMMUNICATOR_CONFIG_SECTION, + "DISABLE_V6"))) + { + struct sockaddr_in *i4; + + i4 = GNUNET_malloc (sizeof(struct sockaddr_in)); + i4->sin_family = AF_INET; + i4->sin_port = htons ((uint16_t) port); + *sock_len = sizeof(struct sockaddr_in); + in = (struct sockaddr *) i4; + } + else + { + struct sockaddr_in6 *i6; + + i6 = GNUNET_malloc (sizeof(struct sockaddr_in6)); + i6->sin6_family = AF_INET6; + i6->sin6_port = htons ((uint16_t) port); + *sock_len = sizeof(struct sockaddr_in6); + in = (struct sockaddr *) i6; } - cp = GNUNET_strdup(bindto); - colon = strrchr(cp, ':'); + return in; + } + cp = GNUNET_strdup (bindto); + colon = strrchr (cp, ':'); if (NULL != colon) + { + /* interpet value after colon as port */ + *colon = '\0'; + colon++; + if (1 == sscanf (colon, "%u%1s", &port, dummy)) { - /* interpet value after colon as port */ - *colon = '\0'; - colon++; - if (1 == sscanf(colon, "%u%1s", &port, dummy)) - { - /* interpreting value as just a PORT number */ - if (port > UINT16_MAX) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "BINDTO specification `%s' invalid: value too large for port\n", - bindto); - GNUNET_free(cp); - return NULL; - } - } - else - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - "BINDTO specification `%s' invalid: last ':' not followed by number\n", - bindto); - GNUNET_free(cp); - return NULL; - } + /* interpreting value as just a PORT number */ + if (port > UINT16_MAX) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "BINDTO specification `%s' invalid: value too large for port\n", + bindto); + GNUNET_free (cp); + return NULL; + } } - else + else { - /* interpret missing port as 0, aka pick any free one */ - port = 0; + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + "BINDTO specification `%s' invalid: last ':' not followed by number\n", + bindto); + GNUNET_free (cp); + return NULL; } + } + else + { + /* interpret missing port as 0, aka pick any free one */ + port = 0; + } { /* try IPv4 */ struct sockaddr_in v4; - if (1 == inet_pton(AF_INET, cp, &v4)) - { - v4.sin_port = htons((uint16_t)port); - in = GNUNET_memdup(&v4, sizeof(v4)); - *sock_len = sizeof(v4); - GNUNET_free(cp); - return in; - } + if (1 == inet_pton (AF_INET, cp, &v4)) + { + v4.sin_port = htons ((uint16_t) port); + in = GNUNET_memdup (&v4, sizeof(v4)); + *sock_len = sizeof(v4); + GNUNET_free (cp); + return in; + } } { /* try IPv6 */ @@ -1183,22 +1190,22 @@ tcp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) const char *start; start = cp; - if (('[' == *cp) && (']' == cp[strlen(cp) - 1])) - { - start++; /* skip over '[' */ - cp[strlen(cp) - 1] = '\0'; /* eat ']' */ - } - if (1 == inet_pton(AF_INET6, start, &v6)) - { - v6.sin6_port = htons((uint16_t)port); - in = GNUNET_memdup(&v6, sizeof(v6)); - *sock_len = sizeof(v6); - GNUNET_free(cp); - return in; - } + if (('[' == *cp) && (']' == cp[strlen (cp) - 1])) + { + start++; /* skip over '[' */ + cp[strlen (cp) - 1] = '\0'; /* eat ']' */ + } + if (1 == inet_pton (AF_INET6, start, &v6)) + { + v6.sin6_port = htons ((uint16_t) port); + in = GNUNET_memdup (&v6, sizeof(v6)); + *sock_len = sizeof(v6); + GNUNET_free (cp); + return in; + } } /* #5528 FIXME (feature!): maybe also try getnameinfo()? */ - GNUNET_free(cp); + GNUNET_free (cp); return NULL; } @@ -1210,17 +1217,17 @@ tcp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) * @param queue queue to setup outgoing (encryption) cipher for */ static void -setup_out_cipher(struct Queue *queue) +setup_out_cipher (struct Queue *queue) { struct GNUNET_HashCode dh; - GNUNET_CRYPTO_ecdh_eddsa(&queue->ephemeral, &queue->target.public_key, &dh); + GNUNET_CRYPTO_ecdh_eddsa (&queue->ephemeral, &queue->target.public_key, &dh); /* we don't need the private key anymore, drop it! */ - memset(&queue->ephemeral, 0, sizeof(queue->ephemeral)); - setup_cipher(&dh, &queue->target, &queue->out_cipher, &queue->out_hmac); - queue->rekey_time = GNUNET_TIME_relative_to_absolute(REKEY_TIME_INTERVAL); + memset (&queue->ephemeral, 0, sizeof(queue->ephemeral)); + setup_cipher (&dh, &queue->target, &queue->out_cipher, &queue->out_hmac); + queue->rekey_time = GNUNET_TIME_relative_to_absolute (REKEY_TIME_INTERVAL); queue->rekey_left_bytes = - GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, REKEY_MAX_BYTES); + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, REKEY_MAX_BYTES); } @@ -1231,31 +1238,31 @@ setup_out_cipher(struct Queue *queue) * @param queue queue to perform rekeying on */ static void -inject_rekey(struct Queue *queue) +inject_rekey (struct Queue *queue) { struct TCPRekey rekey; struct TcpHandshakeSignature thp; - GNUNET_assert(0 == queue->pwrite_off); - memset(&rekey, 0, sizeof(rekey)); - GNUNET_assert(GNUNET_OK == - GNUNET_CRYPTO_ecdhe_key_create2(&queue->ephemeral)); - rekey.header.type = ntohs(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY); - rekey.header.size = ntohs(sizeof(rekey)); - GNUNET_CRYPTO_ecdhe_key_get_public(&queue->ephemeral, &rekey.ephemeral); + GNUNET_assert (0 == queue->pwrite_off); + memset (&rekey, 0, sizeof(rekey)); + GNUNET_assert (GNUNET_OK == + GNUNET_CRYPTO_ecdhe_key_create2 (&queue->ephemeral)); + rekey.header.type = ntohs (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY); + rekey.header.size = ntohs (sizeof(rekey)); + GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &rekey.ephemeral); rekey.monotonic_time = - GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_monotonic(cfg)); - thp.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); - thp.purpose.size = htonl(sizeof(thp)); + GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); + thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); + thp.purpose.size = htonl (sizeof(thp)); thp.sender = my_identity; thp.receiver = queue->target; thp.ephemeral = rekey.ephemeral; thp.monotonic_time = rekey.monotonic_time; - GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key, - &thp.purpose, - &rekey.sender_sig)); - calculate_hmac(&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac); - memcpy(queue->pwrite_buf, &rekey, sizeof(rekey)); + GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key, + &thp.purpose, + &rekey.sender_sig)); + calculate_hmac (&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac); + memcpy (queue->pwrite_buf, &rekey, sizeof(rekey)); queue->pwrite_off = sizeof(rekey); } @@ -1267,79 +1274,79 @@ inject_rekey(struct Queue *queue) * @param cls a `struct Queue` */ static void -queue_write(void *cls) +queue_write (void *cls) { struct Queue *queue = cls; ssize_t sent; queue->write_task = NULL; if (0 != queue->cwrite_off) + { + sent = GNUNET_NETWORK_socket_send (queue->sock, + queue->cwrite_buf, + queue->cwrite_off); + if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno)) + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); + queue_destroy (queue); + return; + } + if (sent > 0) { - sent = GNUNET_NETWORK_socket_send(queue->sock, - queue->cwrite_buf, - queue->cwrite_off); - if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno)) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send"); - queue_destroy(queue); - return; - } - if (sent > 0) - { - size_t usent = (size_t)sent; - - memmove(queue->cwrite_buf, - &queue->cwrite_buf[usent], - queue->cwrite_off - usent); - reschedule_queue_timeout(queue); - } + size_t usent = (size_t) sent; + + memmove (queue->cwrite_buf, + &queue->cwrite_buf[usent], + queue->cwrite_off - usent); + reschedule_queue_timeout (queue); } + } /* can we encrypt more? (always encrypt full messages, needed such that #mq_cancel() can work!) */ if ((0 < queue->rekey_left_bytes) && (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE)) - { - GNUNET_assert(0 == - gcry_cipher_encrypt(queue->out_cipher, + { + GNUNET_assert (0 == + gcry_cipher_encrypt (queue->out_cipher, &queue->cwrite_buf[queue->cwrite_off], queue->pwrite_off, queue->pwrite_buf, queue->pwrite_off)); - if (queue->rekey_left_bytes > queue->pwrite_off) - queue->rekey_left_bytes -= queue->pwrite_off; - else - queue->rekey_left_bytes = 0; - queue->cwrite_off += queue->pwrite_off; - queue->pwrite_off = 0; - } + if (queue->rekey_left_bytes > queue->pwrite_off) + queue->rekey_left_bytes -= queue->pwrite_off; + else + queue->rekey_left_bytes = 0; + queue->cwrite_off += queue->pwrite_off; + queue->pwrite_off = 0; + } if ((0 == queue->pwrite_off) && ((0 == queue->rekey_left_bytes) || (0 == - GNUNET_TIME_absolute_get_remaining(queue->rekey_time).rel_value_us))) - { - gcry_cipher_close(queue->out_cipher); - setup_out_cipher(queue); - inject_rekey(queue); - } - if ((0 == queue->pwrite_off) && (!queue->finishing) && + GNUNET_TIME_absolute_get_remaining (queue->rekey_time).rel_value_us))) + { + gcry_cipher_close (queue->out_cipher); + setup_out_cipher (queue); + inject_rekey (queue); + } + if ((0 == queue->pwrite_off) && (! queue->finishing) && (queue->mq_awaits_continue)) - { - queue->mq_awaits_continue = GNUNET_NO; - GNUNET_MQ_impl_send_continue(queue->mq); - } + { + queue->mq_awaits_continue = GNUNET_NO; + GNUNET_MQ_impl_send_continue (queue->mq); + } /* did we just finish writing 'finish'? */ if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing)) - { - queue_destroy(queue); - return; - } + { + queue_destroy (queue); + return; + } /* do we care to write more? */ if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off)) queue->write_task = - GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, - queue->sock, - &queue_write, - queue); + GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + queue->sock, + &queue_write, + queue); } @@ -1352,32 +1359,32 @@ queue_write(void *cls) * @param impl_state our `struct Queue` */ static void -mq_send(struct GNUNET_MQ_Handle *mq, - const struct GNUNET_MessageHeader *msg, - void *impl_state) +mq_send (struct GNUNET_MQ_Handle *mq, + const struct GNUNET_MessageHeader *msg, + void *impl_state) { struct Queue *queue = impl_state; - uint16_t msize = ntohs(msg->size); + uint16_t msize = ntohs (msg->size); struct TCPBox box; - GNUNET_assert(mq == queue->mq); + GNUNET_assert (mq == queue->mq); if (GNUNET_YES == queue->finishing) return; /* this queue is dying, drop msg */ - GNUNET_assert(0 == queue->pread_off); - box.header.type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX); - box.header.size = htons(msize); - calculate_hmac(&queue->out_hmac, msg, msize, &box.hmac); - memcpy(&queue->pread_buf[queue->pread_off], &box, sizeof(box)); + GNUNET_assert (0 == queue->pread_off); + box.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX); + box.header.size = htons (msize); + calculate_hmac (&queue->out_hmac, msg, msize, &box.hmac); + memcpy (&queue->pread_buf[queue->pread_off], &box, sizeof(box)); queue->pread_off += sizeof(box); - memcpy(&queue->pread_buf[queue->pread_off], msg, msize); + memcpy (&queue->pread_buf[queue->pread_off], msg, msize); queue->pread_off += msize; - GNUNET_assert(NULL != queue->sock); + GNUNET_assert (NULL != queue->sock); if (NULL == queue->write_task) queue->write_task = - GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, - queue->sock, - &queue_write, - queue); + GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + queue->sock, + &queue_write, + queue); } @@ -1390,15 +1397,15 @@ mq_send(struct GNUNET_MQ_Handle *mq, * @param impl_state our `struct Queue` */ static void -mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state) +mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state) { struct Queue *queue = impl_state; if (mq == queue->mq) - { - queue->mq = NULL; - queue_finish(queue); - } + { + queue->mq = NULL; + queue_finish (queue); + } } @@ -1409,11 +1416,11 @@ mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state) * @param impl_state our `struct Queue` */ static void -mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) +mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state) { struct Queue *queue = impl_state; - GNUNET_assert(0 != queue->pwrite_off); + GNUNET_assert (0 != queue->pwrite_off); queue->pwrite_off = 0; } @@ -1428,15 +1435,15 @@ mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) * @param error error code */ static void -mq_error(void *cls, enum GNUNET_MQ_Error error) +mq_error (void *cls, enum GNUNET_MQ_Error error) { struct Queue *queue = cls; - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "MQ error in queue to %s: %d\n", - GNUNET_i2s(&queue->target), - (int)error); - queue_finish(queue); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "MQ error in queue to %s: %d\n", + GNUNET_i2s (&queue->target), + (int) error); + queue_finish (queue); } @@ -1448,58 +1455,58 @@ mq_error(void *cls, enum GNUNET_MQ_Error error) * @param queue queue to boot */ static void -boot_queue(struct Queue *queue, enum GNUNET_TRANSPORT_ConnectionStatus cs) +boot_queue (struct Queue *queue, enum GNUNET_TRANSPORT_ConnectionStatus cs) { queue->nt = - GNUNET_NT_scanner_get_type(is, queue->address, queue->address_len); - (void)GNUNET_CONTAINER_multipeermap_put( + GNUNET_NT_scanner_get_type (is, queue->address, queue->address_len); + (void) GNUNET_CONTAINER_multipeermap_put ( queue_map, &queue->target, queue, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - GNUNET_STATISTICS_set(stats, - "# queues active", - GNUNET_CONTAINER_multipeermap_size(queue_map), - GNUNET_NO); + GNUNET_STATISTICS_set (stats, + "# queues active", + GNUNET_CONTAINER_multipeermap_size (queue_map), + GNUNET_NO); queue->timeout = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); - queue->mq = GNUNET_MQ_queue_for_callbacks(&mq_send, - &mq_destroy, - &mq_cancel, - queue, - NULL, - &mq_error, - queue); + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + queue->mq = GNUNET_MQ_queue_for_callbacks (&mq_send, + &mq_destroy, + &mq_cancel, + queue, + NULL, + &mq_error, + queue); { char *foreign_addr; switch (queue->address->sa_family) - { - case AF_INET: - GNUNET_asprintf(&foreign_addr, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_a2s(queue->address, queue->address_len)); - break; - - case AF_INET6: - GNUNET_asprintf(&foreign_addr, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_a2s(queue->address, queue->address_len)); - break; - - default: - GNUNET_assert(0); - } - queue->qh = GNUNET_TRANSPORT_communicator_mq_add(ch, - &queue->target, - foreign_addr, - 0 /* no MTU */, - queue->nt, - cs, - queue->mq); - GNUNET_free(foreign_addr); + { + case AF_INET: + GNUNET_asprintf (&foreign_addr, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_a2s (queue->address, queue->address_len)); + break; + + case AF_INET6: + GNUNET_asprintf (&foreign_addr, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_a2s (queue->address, queue->address_len)); + break; + + default: + GNUNET_assert (0); + } + queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, + &queue->target, + foreign_addr, + 0 /* no MTU */, + queue->nt, + cs, + queue->mq); + GNUNET_free (foreign_addr); } } @@ -1515,33 +1522,33 @@ boot_queue(struct Queue *queue, enum GNUNET_TRANSPORT_ConnectionStatus cs) * @param epub our public key for the KX */ static void -transmit_kx(struct Queue *queue, - const struct GNUNET_CRYPTO_EcdhePublicKey *epub) +transmit_kx (struct Queue *queue, + const struct GNUNET_CRYPTO_EcdhePublicKey *epub) { struct TcpHandshakeSignature ths; struct TCPConfirmation tc; - memcpy(queue->cwrite_buf, epub, sizeof(*epub)); + memcpy (queue->cwrite_buf, epub, sizeof(*epub)); queue->cwrite_off = sizeof(epub); /* compute 'tc' and append in encrypted format to cwrite_buf */ tc.sender = my_identity; tc.monotonic_time = - GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_monotonic(cfg)); - ths.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE); - ths.purpose.size = htonl(sizeof(ths)); + GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); + ths.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE); + ths.purpose.size = htonl (sizeof(ths)); ths.sender = my_identity; ths.receiver = queue->target; ths.ephemeral = *epub; ths.monotonic_time = tc.monotonic_time; - GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key, - &ths.purpose, - &tc.sender_sig)); - GNUNET_assert(0 == - gcry_cipher_encrypt(queue->out_cipher, - &queue->cwrite_buf[queue->cwrite_off], - sizeof(tc), - &tc, - sizeof(tc))); + GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key, + &ths.purpose, + &tc.sender_sig)); + GNUNET_assert (0 == + gcry_cipher_encrypt (queue->out_cipher, + &queue->cwrite_buf[queue->cwrite_off], + sizeof(tc), + &tc, + sizeof(tc))); queue->cwrite_off += sizeof(tc); } @@ -1554,15 +1561,15 @@ transmit_kx(struct Queue *queue, * @param queue the queue to setup */ static void -start_initial_kx_out(struct Queue *queue) +start_initial_kx_out (struct Queue *queue) { struct GNUNET_CRYPTO_EcdhePublicKey epub; - GNUNET_assert(GNUNET_OK == - GNUNET_CRYPTO_ecdhe_key_create2(&queue->ephemeral)); - GNUNET_CRYPTO_ecdhe_key_get_public(&queue->ephemeral, &epub); - setup_out_cipher(queue); - transmit_kx(queue, &epub); + GNUNET_assert (GNUNET_OK == + GNUNET_CRYPTO_ecdhe_key_create2 (&queue->ephemeral)); + GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &epub); + setup_out_cipher (queue); + transmit_kx (queue, &epub); } @@ -1578,31 +1585,32 @@ start_initial_kx_out(struct Queue *queue) * @return #GNUNET_OK if the signature was OK, #GNUNET_SYSERR if not */ static int -decrypt_and_check_tc(struct Queue *queue, - struct TCPConfirmation *tc, - char *ibuf) +decrypt_and_check_tc (struct Queue *queue, + struct TCPConfirmation *tc, + char *ibuf) { struct TcpHandshakeSignature ths; - GNUNET_assert( + GNUNET_assert ( 0 == - gcry_cipher_decrypt(queue->in_cipher, - tc, - sizeof(*tc), - &ibuf[sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)], - sizeof(tc))); - ths.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE); - ths.purpose.size = htonl(sizeof(ths)); + gcry_cipher_decrypt (queue->in_cipher, + tc, + sizeof(*tc), + &ibuf[sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)], + sizeof(tc))); + ths.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE); + ths.purpose.size = htonl (sizeof(ths)); ths.sender = tc->sender; ths.receiver = my_identity; - memcpy(&ths.ephemeral, ibuf, sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)); + memcpy (&ths.ephemeral, ibuf, sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)); ths.monotonic_time = tc->monotonic_time; /* FIXME: check monotonic time against previous mono times from this sender! */ - return GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE, - &ths.purpose, - &tc->sender_sig, - &tc->sender.public_key); + return GNUNET_CRYPTO_eddsa_verify ( + GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE, + &ths.purpose, + &tc->sender_sig, + &tc->sender.public_key); } @@ -1612,12 +1620,12 @@ decrypt_and_check_tc(struct Queue *queue, * @param pq proto queue to free */ static void -free_proto_queue(struct ProtoQueue *pq) +free_proto_queue (struct ProtoQueue *pq) { - GNUNET_NETWORK_socket_close(pq->sock); - GNUNET_free(pq->address); - GNUNET_CONTAINER_DLL_remove(proto_head, proto_tail, pq); - GNUNET_free(pq); + GNUNET_NETWORK_socket_close (pq->sock); + GNUNET_free (pq->address); + GNUNET_CONTAINER_DLL_remove (proto_head, proto_tail, pq); + GNUNET_free (pq); } @@ -1628,7 +1636,7 @@ free_proto_queue(struct ProtoQueue *pq) * @param cls a `struct ProtoQueue` */ static void -proto_read_kx(void *cls) +proto_read_kx (void *cls) { struct ProtoQueue *pq = cls; ssize_t rcvd; @@ -1637,67 +1645,67 @@ proto_read_kx(void *cls) struct TCPConfirmation tc; pq->read_task = NULL; - left = GNUNET_TIME_absolute_get_remaining(pq->timeout); + left = GNUNET_TIME_absolute_get_remaining (pq->timeout); if (0 == left.rel_value_us) - { - free_proto_queue(pq); - return; - } - rcvd = GNUNET_NETWORK_socket_recv(pq->sock, - &pq->ibuf[pq->ibuf_off], - sizeof(pq->ibuf) - pq->ibuf_off); + { + free_proto_queue (pq); + return; + } + rcvd = GNUNET_NETWORK_socket_recv (pq->sock, + &pq->ibuf[pq->ibuf_off], + sizeof(pq->ibuf) - pq->ibuf_off); if (-1 == rcvd) + { + if ((EAGAIN != errno) && (EINTR != errno)) { - if ((EAGAIN != errno) && (EINTR != errno)) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv"); - free_proto_queue(pq); - return; - } - /* try again */ - pq->read_task = - GNUNET_SCHEDULER_add_read_net(left, pq->sock, &proto_read_kx, pq); + GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv"); + free_proto_queue (pq); return; } + /* try again */ + pq->read_task = + GNUNET_SCHEDULER_add_read_net (left, pq->sock, &proto_read_kx, pq); + return; + } pq->ibuf_off += rcvd; if (pq->ibuf_off > sizeof(pq->ibuf)) - { - /* read more */ - pq->read_task = - GNUNET_SCHEDULER_add_read_net(left, pq->sock, &proto_read_kx, pq); - return; - } + { + /* read more */ + pq->read_task = + GNUNET_SCHEDULER_add_read_net (left, pq->sock, &proto_read_kx, pq); + return; + } /* we got all the data, let's find out who we are talking to! */ - queue = GNUNET_new(struct Queue); - setup_in_cipher((const struct GNUNET_CRYPTO_EcdhePublicKey *)pq->ibuf, - queue); - if (GNUNET_OK != decrypt_and_check_tc(queue, &tc, pq->ibuf)) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Invalid TCP KX received from %s\n", - GNUNET_a2s(queue->address, queue->address_len)); - gcry_cipher_close(queue->in_cipher); - GNUNET_free(queue); - free_proto_queue(pq); - return; - } + queue = GNUNET_new (struct Queue); + setup_in_cipher ((const struct GNUNET_CRYPTO_EcdhePublicKey *) pq->ibuf, + queue); + if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, pq->ibuf)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Invalid TCP KX received from %s\n", + GNUNET_a2s (queue->address, queue->address_len)); + gcry_cipher_close (queue->in_cipher); + GNUNET_free (queue); + free_proto_queue (pq); + return; + } queue->address = pq->address; /* steals reference */ queue->address_len = pq->address_len; queue->target = tc.sender; - start_initial_kx_out(queue); - boot_queue(queue, GNUNET_TRANSPORT_CS_INBOUND); + start_initial_kx_out (queue); + boot_queue (queue, GNUNET_TRANSPORT_CS_INBOUND); queue->read_task = - GNUNET_SCHEDULER_add_read_net(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - queue->sock, - &queue_read, - queue); - queue->write_task = - GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_SCHEDULER_add_read_net (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, queue->sock, - &queue_write, + &queue_read, queue); - GNUNET_CONTAINER_DLL_remove(proto_head, proto_tail, pq); - GNUNET_free(pq); + queue->write_task = + GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + queue->sock, + &queue_write, + queue); + GNUNET_CONTAINER_DLL_remove (proto_head, proto_tail, pq); + GNUNET_free (pq); } @@ -1709,7 +1717,7 @@ proto_read_kx(void *cls) * @param cls NULL */ static void -listen_cb(void *cls) +listen_cb (void *cls) { struct sockaddr_storage in; socklen_t addrlen; @@ -1717,35 +1725,35 @@ listen_cb(void *cls) struct ProtoQueue *pq; listen_task = NULL; - GNUNET_assert(NULL != listen_sock); + GNUNET_assert (NULL != listen_sock); addrlen = sizeof(in); - memset(&in, 0, sizeof(in)); - sock = GNUNET_NETWORK_socket_accept(listen_sock, - (struct sockaddr *)&in, - &addrlen); + memset (&in, 0, sizeof(in)); + sock = GNUNET_NETWORK_socket_accept (listen_sock, + (struct sockaddr *) &in, + &addrlen); if ((NULL == sock) && ((EMFILE == errno) || (ENFILE == errno))) return; /* system limit reached, wait until connection goes down */ - listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - listen_sock, - &listen_cb, - NULL); + listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + listen_sock, + &listen_cb, + NULL); if ((NULL == sock) && ((EAGAIN == errno) || (ENOBUFS == errno))) return; if (NULL == sock) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "accept"); - return; - } - pq = GNUNET_new(struct ProtoQueue); + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept"); + return; + } + pq = GNUNET_new (struct ProtoQueue); pq->address_len = addrlen; - pq->address = GNUNET_memdup(&in, addrlen); - pq->timeout = GNUNET_TIME_relative_to_absolute(PROTO_QUEUE_TIMEOUT); + pq->address = GNUNET_memdup (&in, addrlen); + pq->timeout = GNUNET_TIME_relative_to_absolute (PROTO_QUEUE_TIMEOUT); pq->sock = sock; - pq->read_task = GNUNET_SCHEDULER_add_read_net(PROTO_QUEUE_TIMEOUT, - pq->sock, - &proto_read_kx, - pq); - GNUNET_CONTAINER_DLL_insert(proto_head, proto_tail, pq); + pq->read_task = GNUNET_SCHEDULER_add_read_net (PROTO_QUEUE_TIMEOUT, + pq->sock, + &proto_read_kx, + pq); + GNUNET_CONTAINER_DLL_insert (proto_head, proto_tail, pq); } @@ -1757,7 +1765,7 @@ listen_cb(void *cls) * @param cls a `struct Queue` */ static void -queue_read_kx(void *cls) +queue_read_kx (void *cls) { struct Queue *queue = cls; ssize_t rcvd; @@ -1765,65 +1773,65 @@ queue_read_kx(void *cls) struct TCPConfirmation tc; queue->read_task = NULL; - left = GNUNET_TIME_absolute_get_remaining(queue->timeout); + left = GNUNET_TIME_absolute_get_remaining (queue->timeout); if (0 == left.rel_value_us) - { - queue_destroy(queue); - return; - } - rcvd = GNUNET_NETWORK_socket_recv(queue->sock, - &queue->cread_buf[queue->cread_off], - BUF_SIZE - queue->cread_off); + { + queue_destroy (queue); + return; + } + rcvd = GNUNET_NETWORK_socket_recv (queue->sock, + &queue->cread_buf[queue->cread_off], + BUF_SIZE - queue->cread_off); if (-1 == rcvd) + { + if ((EAGAIN != errno) && (EINTR != errno)) { - if ((EAGAIN != errno) && (EINTR != errno)) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv"); - queue_destroy(queue); - return; - } - queue->read_task = - GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read_kx, queue); + GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv"); + queue_destroy (queue); return; } + queue->read_task = + GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read_kx, queue); + return; + } queue->cread_off += rcvd; if (queue->cread_off < INITIAL_KX_SIZE) - { - /* read more */ - queue->read_task = - GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read_kx, queue); - return; - } + { + /* read more */ + queue->read_task = + GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read_kx, queue); + return; + } /* we got all the data, let's find out who we are talking to! */ - setup_in_cipher((const struct GNUNET_CRYPTO_EcdhePublicKey *) - queue->cread_buf, - queue); - if (GNUNET_OK != decrypt_and_check_tc(queue, &tc, queue->cread_buf)) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Invalid TCP KX received from %s\n", - GNUNET_a2s(queue->address, queue->address_len)); - queue_destroy(queue); - return; - } + setup_in_cipher ((const struct GNUNET_CRYPTO_EcdhePublicKey *) + queue->cread_buf, + queue); + if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, queue->cread_buf)) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Invalid TCP KX received from %s\n", + GNUNET_a2s (queue->address, queue->address_len)); + queue_destroy (queue); + return; + } if (0 != - memcmp(&tc.sender, &queue->target, sizeof(struct GNUNET_PeerIdentity))) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Invalid sender in TCP KX received from %s\n", - GNUNET_a2s(queue->address, queue->address_len)); - queue_destroy(queue); - return; - } + memcmp (&tc.sender, &queue->target, sizeof(struct GNUNET_PeerIdentity))) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Invalid sender in TCP KX received from %s\n", + GNUNET_a2s (queue->address, queue->address_len)); + queue_destroy (queue); + return; + } /* update queue timeout */ - reschedule_queue_timeout(queue); + reschedule_queue_timeout (queue); /* prepare to continue with regular read task immediately */ - memmove(queue->cread_buf, - &queue->cread_buf[INITIAL_KX_SIZE], - queue->cread_off - (INITIAL_KX_SIZE)); + memmove (queue->cread_buf, + &queue->cread_buf[INITIAL_KX_SIZE], + queue->cread_off - (INITIAL_KX_SIZE)); queue->cread_off -= INITIAL_KX_SIZE; - queue->read_task = GNUNET_SCHEDULER_add_now(&queue_read, queue); + queue->read_task = GNUNET_SCHEDULER_add_now (&queue_read, queue); } @@ -1846,7 +1854,7 @@ queue_read_kx(void *cls) * invalid */ static int -mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) +mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) { struct Queue *queue; const char *path; @@ -1854,54 +1862,54 @@ mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) socklen_t in_len; struct GNUNET_NETWORK_Handle *sock; - if (0 != strncmp(address, - COMMUNICATOR_ADDRESS_PREFIX "-", - strlen(COMMUNICATOR_ADDRESS_PREFIX "-"))) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } - path = &address[strlen(COMMUNICATOR_ADDRESS_PREFIX "-")]; - in = tcp_address_to_sockaddr(path, &in_len); + if (0 != strncmp (address, + COMMUNICATOR_ADDRESS_PREFIX "-", + strlen (COMMUNICATOR_ADDRESS_PREFIX "-"))) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")]; + in = tcp_address_to_sockaddr (path, &in_len); - sock = GNUNET_NETWORK_socket_create(in->sa_family, SOCK_STREAM, IPPROTO_TCP); + sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP); if (NULL == sock) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "socket(%d) failed: %s", - in->sa_family, - strerror(errno)); - GNUNET_free(in); - return GNUNET_SYSERR; - } - if (GNUNET_OK != GNUNET_NETWORK_socket_connect(sock, in, in_len)) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "connect to `%s' failed: %s", - address, - strerror(errno)); - GNUNET_NETWORK_socket_close(sock); - GNUNET_free(in); - return GNUNET_SYSERR; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "socket(%d) failed: %s", + in->sa_family, + strerror (errno)); + GNUNET_free (in); + return GNUNET_SYSERR; + } + if (GNUNET_OK != GNUNET_NETWORK_socket_connect (sock, in, in_len)) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "connect to `%s' failed: %s", + address, + strerror (errno)); + GNUNET_NETWORK_socket_close (sock); + GNUNET_free (in); + return GNUNET_SYSERR; + } - queue = GNUNET_new(struct Queue); + queue = GNUNET_new (struct Queue); queue->target = *peer; queue->address = in; queue->address_len = in_len; queue->sock = sock; - boot_queue(queue, GNUNET_TRANSPORT_CS_OUTBOUND); + boot_queue (queue, GNUNET_TRANSPORT_CS_OUTBOUND); queue->read_task = - GNUNET_SCHEDULER_add_read_net(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - queue->sock, - &queue_read_kx, - queue); - start_initial_kx_out(queue); - queue->write_task = - GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_SCHEDULER_add_read_net (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, queue->sock, - &queue_write, + &queue_read_kx, queue); + start_initial_kx_out (queue); + queue->write_task = + GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + queue->sock, + &queue_write, + queue); return GNUNET_OK; } @@ -1915,15 +1923,15 @@ mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) * @return #GNUNET_OK to continue to iterate */ static int -get_queue_delete_it(void *cls, - const struct GNUNET_PeerIdentity *target, - void *value) +get_queue_delete_it (void *cls, + const struct GNUNET_PeerIdentity *target, + void *value) { struct Queue *queue = value; - (void)cls; - (void)target; - queue_destroy(queue); + (void) cls; + (void) target; + queue_destroy (queue); return GNUNET_OK; } @@ -1934,47 +1942,47 @@ get_queue_delete_it(void *cls, * @param cls NULL (always) */ static void -do_shutdown(void *cls) +do_shutdown (void *cls) { while (NULL != proto_head) - free_proto_queue(proto_head); + free_proto_queue (proto_head); if (NULL != nat) - { - GNUNET_NAT_unregister(nat); - nat = NULL; - } + { + GNUNET_NAT_unregister (nat); + nat = NULL; + } if (NULL != listen_task) - { - GNUNET_SCHEDULER_cancel(listen_task); - listen_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (listen_task); + listen_task = NULL; + } if (NULL != listen_sock) - { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(listen_sock)); - listen_sock = NULL; - } - GNUNET_CONTAINER_multipeermap_iterate(queue_map, &get_queue_delete_it, NULL); - GNUNET_CONTAINER_multipeermap_destroy(queue_map); + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (listen_sock)); + listen_sock = NULL; + } + GNUNET_CONTAINER_multipeermap_iterate (queue_map, &get_queue_delete_it, NULL); + GNUNET_CONTAINER_multipeermap_destroy (queue_map); if (NULL != ch) - { - GNUNET_TRANSPORT_communicator_disconnect(ch); - ch = NULL; - } + { + GNUNET_TRANSPORT_communicator_disconnect (ch); + ch = NULL; + } if (NULL != stats) - { - GNUNET_STATISTICS_destroy(stats, GNUNET_NO); - stats = NULL; - } + { + GNUNET_STATISTICS_destroy (stats, GNUNET_NO); + stats = NULL; + } if (NULL != my_private_key) - { - GNUNET_free(my_private_key); - my_private_key = NULL; - } + { + GNUNET_free (my_private_key); + my_private_key = NULL; + } if (NULL != is) - { - GNUNET_NT_scanner_done(is); - is = NULL; - } + { + GNUNET_NT_scanner_done (is); + is = NULL; + } } @@ -1990,14 +1998,14 @@ do_shutdown(void *cls) * @param msg payload */ static void -enc_notify_cb(void *cls, - const struct GNUNET_PeerIdentity *sender, - const struct GNUNET_MessageHeader *msg) +enc_notify_cb (void *cls, + const struct GNUNET_PeerIdentity *sender, + const struct GNUNET_MessageHeader *msg) { - (void)cls; - (void)sender; - (void)msg; - GNUNET_break_op(0); + (void) cls; + (void) sender; + (void) msg; + GNUNET_break_op (0); } @@ -2015,39 +2023,39 @@ enc_notify_cb(void *cls, * @param addrlen actual length of the @a addr */ 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) +nat_address_cb (void *cls, + void **app_ctx, + int add_remove, + enum GNUNET_NAT_AddressClass ac, + const struct sockaddr *addr, + socklen_t addrlen) { char *my_addr; struct GNUNET_TRANSPORT_AddressIdentifier *ai; if (GNUNET_YES == add_remove) - { - enum GNUNET_NetworkType nt; - - GNUNET_asprintf(&my_addr, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_a2s(addr, addrlen)); - nt = GNUNET_NT_scanner_get_type(is, addr, addrlen); - ai = - GNUNET_TRANSPORT_communicator_address_add(ch, - my_addr, - nt, - GNUNET_TIME_UNIT_FOREVER_REL); - GNUNET_free(my_addr); - *app_ctx = ai; - } + { + enum GNUNET_NetworkType nt; + + GNUNET_asprintf (&my_addr, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_a2s (addr, addrlen)); + nt = GNUNET_NT_scanner_get_type (is, addr, addrlen); + ai = + GNUNET_TRANSPORT_communicator_address_add (ch, + my_addr, + nt, + GNUNET_TIME_UNIT_FOREVER_REL); + GNUNET_free (my_addr); + *app_ctx = ai; + } else - { - ai = *app_ctx; - GNUNET_TRANSPORT_communicator_address_remove(ai); - *app_ctx = NULL; - } + { + ai = *app_ctx; + GNUNET_TRANSPORT_communicator_address_remove (ai); + *app_ctx = NULL; + } } @@ -2060,10 +2068,10 @@ nat_address_cb(void *cls, * @param c configuration */ static void -run(void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *c) +run (void *cls, + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *c) { char *bindto; struct sockaddr *in; @@ -2071,113 +2079,113 @@ run(void *cls, struct sockaddr_storage in_sto; socklen_t sto_len; - (void)cls; + (void) cls; cfg = c; if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_filename(cfg, - COMMUNICATOR_CONFIG_SECTION, - "BINDTO", - &bindto)) - { - GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, - COMMUNICATOR_CONFIG_SECTION, - "BINDTO"); - return; - } + GNUNET_CONFIGURATION_get_value_filename (cfg, + COMMUNICATOR_CONFIG_SECTION, + "BINDTO", + &bindto)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, + COMMUNICATOR_CONFIG_SECTION, + "BINDTO"); + return; + } if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_number(cfg, - COMMUNICATOR_CONFIG_SECTION, - "MAX_QUEUE_LENGTH", - &max_queue_length)) + GNUNET_CONFIGURATION_get_value_number (cfg, + COMMUNICATOR_CONFIG_SECTION, + "MAX_QUEUE_LENGTH", + &max_queue_length)) max_queue_length = DEFAULT_MAX_QUEUE_LENGTH; - in = tcp_address_to_sockaddr(bindto, &in_len); + in = tcp_address_to_sockaddr (bindto, &in_len); if (NULL == in) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Failed to setup TCP socket address with path `%s'\n", - bindto); - GNUNET_free(bindto); - return; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to setup TCP socket address with path `%s'\n", + bindto); + GNUNET_free (bindto); + return; + } listen_sock = - GNUNET_NETWORK_socket_create(in->sa_family, SOCK_STREAM, IPPROTO_TCP); + GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP); if (NULL == listen_sock) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "socket"); - GNUNET_free(in); - GNUNET_free(bindto); - return; - } - if (GNUNET_OK != GNUNET_NETWORK_socket_bind(listen_sock, in, in_len)) - { - GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "bind", bindto); - GNUNET_NETWORK_socket_close(listen_sock); - listen_sock = NULL; - GNUNET_free(in); - GNUNET_free(bindto); - return; - } + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket"); + GNUNET_free (in); + GNUNET_free (bindto); + return; + } + if (GNUNET_OK != GNUNET_NETWORK_socket_bind (listen_sock, in, in_len)) + { + GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", bindto); + GNUNET_NETWORK_socket_close (listen_sock); + listen_sock = NULL; + GNUNET_free (in); + GNUNET_free (bindto); + return; + } /* We might have bound to port 0, allowing the OS to figure it out; thus, get the real IN-address from the socket */ sto_len = sizeof(in_sto); - if (0 != getsockname(GNUNET_NETWORK_get_fd(listen_sock), - (struct sockaddr *)&in_sto, - &sto_len)) - { - memcpy(&in_sto, in, in_len); - sto_len = in_len; - } - GNUNET_free(in); - GNUNET_free(bindto); - in = (struct sockaddr *)&in_sto; + if (0 != getsockname (GNUNET_NETWORK_get_fd (listen_sock), + (struct sockaddr *) &in_sto, + &sto_len)) + { + memcpy (&in_sto, in, in_len); + sto_len = in_len; + } + GNUNET_free (in); + GNUNET_free (bindto); + in = (struct sockaddr *) &in_sto; in_len = sto_len; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Bound to `%s'\n", - GNUNET_a2s((const struct sockaddr *)&in_sto, sto_len)); - stats = GNUNET_STATISTICS_create("C-TCP", cfg); - GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); - is = GNUNET_NT_scanner_init(); - my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Bound to `%s'\n", + GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len)); + stats = GNUNET_STATISTICS_create ("C-TCP", cfg); + GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); + is = GNUNET_NT_scanner_init (); + my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg); if (NULL == my_private_key) - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - _( - "Transport service is lacking key configuration settings. Exiting.\n")); - GNUNET_SCHEDULER_shutdown(); - return; - } - GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key); + { + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + _ ( + "Transport service is lacking key configuration settings. Exiting.\n")); + GNUNET_SCHEDULER_shutdown (); + return; + } + GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key); /* start listening */ - listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - listen_sock, - &listen_cb, + listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + listen_sock, + &listen_cb, + NULL); + queue_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); + ch = GNUNET_TRANSPORT_communicator_connect (cfg, + COMMUNICATOR_CONFIG_SECTION, + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_TRANSPORT_CC_RELIABLE, + &mq_init, + NULL, + &enc_notify_cb, NULL); - queue_map = GNUNET_CONTAINER_multipeermap_create(10, GNUNET_NO); - ch = GNUNET_TRANSPORT_communicator_connect(cfg, - COMMUNICATOR_CONFIG_SECTION, - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_TRANSPORT_CC_RELIABLE, - &mq_init, - NULL, - &enc_notify_cb, - NULL); if (NULL == ch) - { - GNUNET_break(0); - GNUNET_SCHEDULER_shutdown(); - return; - } - nat = GNUNET_NAT_register(cfg, - COMMUNICATOR_CONFIG_SECTION, - IPPROTO_TCP, - 1 /* one address */, - (const struct sockaddr **)&in, - &in_len, - &nat_address_cb, - NULL /* FIXME: support reversal: #5529 */, - NULL /* closure */); + { + GNUNET_break (0); + GNUNET_SCHEDULER_shutdown (); + return; + } + nat = GNUNET_NAT_register (cfg, + COMMUNICATOR_CONFIG_SECTION, + IPPROTO_TCP, + 1 /* one address */, + (const struct sockaddr **) &in, + &in_len, + &nat_address_cb, + NULL /* FIXME: support reversal: #5529 */, + NULL /* closure */); } @@ -2189,26 +2197,26 @@ run(void *cls, * @return 0 ok, 1 on error */ int -main(int argc, char *const *argv) +main (int argc, char *const *argv) { static const struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_OPTION_END }; int ret; - if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) + if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) return 2; - ret = (GNUNET_OK == GNUNET_PROGRAM_run(argc, - argv, - "gnunet-communicator-tcp", - _("GNUnet TCP communicator"), - options, - &run, - NULL)) + ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc, + argv, + "gnunet-communicator-tcp", + _ ("GNUnet TCP communicator"), + options, + &run, + NULL)) ? 0 : 1; - GNUNET_free((void *)argv); + GNUNET_free ((void *) argv); return ret; } diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c index 228540b81..2d9fabfec 100644 --- a/src/transport/gnunet-communicator-udp.c +++ b/src/transport/gnunet-communicator-udp.c @@ -67,7 +67,7 @@ * How often do we scan for changes to our network interfaces? */ #define INTERFACE_SCAN_FREQUENCY \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) /** * How long do we believe our addresses to remain up (before @@ -156,7 +156,8 @@ GNUNET_NETWORK_STRUCT_BEGIN * the specified sender. If possible, the receiver should respond with * a `struct UDPAck` (possibly via backchannel). */ -struct UdpHandshakeSignature { +struct UdpHandshakeSignature +{ /** * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE */ @@ -189,7 +190,8 @@ struct UdpHandshakeSignature { * "Plaintext" header at beginning of KX message. Followed * by encrypted `struct UDPConfirmation`. */ -struct InitialKX { +struct InitialKX +{ /** * Ephemeral key for KX. */ @@ -207,7 +209,8 @@ struct InitialKX { * Encrypted continuation of UDP initial handshake, followed * by message header with payload. */ -struct UDPConfirmation { +struct UDPConfirmation +{ /** * Sender's identity */ @@ -234,7 +237,8 @@ struct UDPConfirmation { * UDP key acknowledgement. May be sent via backchannel. Allows the * sender to use `struct UDPBox` with the acknowledge key henceforth. */ -struct UDPAck { +struct UDPAck +{ /** * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK. */ @@ -261,7 +265,8 @@ struct UDPAck { * be just any global peer -- an attacker must have at least * shared a LAN with the peer they're pretending to be here. */ -struct UdpBroadcastSignature { +struct UdpBroadcastSignature +{ /** * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST */ @@ -285,7 +290,8 @@ struct UdpBroadcastSignature { * recognized in LAN as GNUnet peers if this feature is enabled * anyway. Also, the entire message is in cleartext. */ -struct UDPBroadcast { +struct UDPBroadcast +{ /** * Sender's peer identity. */ @@ -303,7 +309,8 @@ struct UDPBroadcast { * UDP message box. Always sent encrypted, only allowed after * the receiver sent a `struct UDPAck` for the base key! */ -struct UDPBox { +struct UDPBox +{ /** * Key and IV identification code. KDF applied to an acknowledged * base key and a sequence number. Sequence numbers must be used @@ -336,7 +343,8 @@ struct SharedSecret; * Pre-generated "kid" code (key and IV identification code) to * quickly derive master key for a `struct UDPBox`. */ -struct KeyCacheEntry { +struct KeyCacheEntry +{ /** * Kept in a DLL. */ @@ -383,7 +391,8 @@ struct ReceiverAddress; /** * Shared secret we generated for a particular sender or receiver. */ -struct SharedSecret { +struct SharedSecret +{ /** * Kept in a DLL. */ @@ -448,7 +457,8 @@ struct SharedSecret { * Information we track per sender address we have recently been * in contact with (we decrypt messages from the sender). */ -struct SenderAddress { +struct SenderAddress +{ /** * To whom are we talking to. */ @@ -500,7 +510,8 @@ struct SenderAddress { * Information we track per receiving address we have recently been * in contact with (encryption to receiver). */ -struct ReceiverAddress { +struct ReceiverAddress +{ /** * To whom are we talking to. */ @@ -578,7 +589,8 @@ struct ReceiverAddress { /** * Interface we broadcast our presence on. */ -struct BroadcastInterface { +struct BroadcastInterface +{ /** * Kept in a DLL. */ @@ -739,25 +751,25 @@ static uint16_t my_port; * @param bi entity to close down */ static void -bi_destroy(struct BroadcastInterface *bi) +bi_destroy (struct BroadcastInterface *bi) { if (AF_INET6 == bi->sa->sa_family) + { + /* Leave the multicast group */ + if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock, + IPPROTO_IPV6, + IPV6_LEAVE_GROUP, + &bi->mcreq, + sizeof(bi->mcreq))) { - /* Leave the multicast group */ - if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(udp_sock, - IPPROTO_IPV6, - IPV6_LEAVE_GROUP, - &bi->mcreq, - sizeof(bi->mcreq))) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "setsockopt"); - } + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); } - GNUNET_CONTAINER_DLL_remove(bi_head, bi_tail, bi); - GNUNET_SCHEDULER_cancel(bi->broadcast_task); - GNUNET_free(bi->sa); - GNUNET_free_non_null(bi->ba); - GNUNET_free(bi); + } + GNUNET_CONTAINER_DLL_remove (bi_head, bi_tail, bi); + GNUNET_SCHEDULER_cancel (bi->broadcast_task); + GNUNET_free (bi->sa); + GNUNET_free_non_null (bi->ba); + GNUNET_free (bi); } @@ -767,35 +779,35 @@ bi_destroy(struct BroadcastInterface *bi) * @param receiver entity to close down */ static void -receiver_destroy(struct ReceiverAddress *receiver) +receiver_destroy (struct ReceiverAddress *receiver) { struct GNUNET_MQ_Handle *mq; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Disconnecting receiver for peer `%s'\n", - GNUNET_i2s(&receiver->target)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Disconnecting receiver for peer `%s'\n", + GNUNET_i2s (&receiver->target)); if (NULL != (mq = receiver->mq)) - { - receiver->mq = NULL; - GNUNET_MQ_destroy(mq); - } + { + receiver->mq = NULL; + GNUNET_MQ_destroy (mq); + } if (NULL != receiver->qh) - { - GNUNET_TRANSPORT_communicator_mq_del(receiver->qh); - receiver->qh = NULL; - } - GNUNET_assert(GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(receivers, - &receiver->target, - receiver)); - GNUNET_assert(receiver == GNUNET_CONTAINER_heap_remove_node(receiver->hn)); - GNUNET_STATISTICS_set(stats, - "# receivers active", - GNUNET_CONTAINER_multipeermap_size(receivers), - GNUNET_NO); - GNUNET_free(receiver->address); - GNUNET_free(receiver->foreign_addr); - GNUNET_free(receiver); + { + GNUNET_TRANSPORT_communicator_mq_del (receiver->qh); + receiver->qh = NULL; + } + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multipeermap_remove (receivers, + &receiver->target, + receiver)); + GNUNET_assert (receiver == GNUNET_CONTAINER_heap_remove_node (receiver->hn)); + GNUNET_STATISTICS_set (stats, + "# receivers active", + GNUNET_CONTAINER_multipeermap_size (receivers), + GNUNET_NO); + GNUNET_free (receiver->address); + GNUNET_free (receiver->foreign_addr); + GNUNET_free (receiver); } @@ -805,16 +817,16 @@ receiver_destroy(struct ReceiverAddress *receiver) * @param kce the key cache entry */ static void -kce_destroy(struct KeyCacheEntry *kce) +kce_destroy (struct KeyCacheEntry *kce) { struct SharedSecret *ss = kce->ss; ss->active_kce_count--; - GNUNET_CONTAINER_DLL_remove(ss->kce_head, ss->kce_tail, kce); - GNUNET_assert(GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove(key_cache, - &kce->kid, - kce)); - GNUNET_free(kce); + GNUNET_CONTAINER_DLL_remove (ss->kce_head, ss->kce_tail, kce); + GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (key_cache, + &kce->kid, + kce)); + GNUNET_free (kce); } @@ -826,24 +838,24 @@ kce_destroy(struct KeyCacheEntry *kce) * @param kid[out] where to write the key ID */ static void -get_kid(const struct GNUNET_HashCode *msec, - uint32_t serial, - struct GNUNET_ShortHashCode *kid) +get_kid (const struct GNUNET_HashCode *msec, + uint32_t serial, + struct GNUNET_ShortHashCode *kid) { - uint32_t sid = htonl(serial); - - GNUNET_CRYPTO_hkdf(kid, - sizeof(*kid), - GCRY_MD_SHA512, - GCRY_MD_SHA256, - &sid, - sizeof(sid), - msec, - sizeof(*msec), - "UDP-KID", - strlen("UDP-KID"), - NULL, - 0); + uint32_t sid = htonl (serial); + + GNUNET_CRYPTO_hkdf (kid, + sizeof(*kid), + GCRY_MD_SHA512, + GCRY_MD_SHA256, + &sid, + sizeof(sid), + msec, + sizeof(*msec), + "UDP-KID", + strlen ("UDP-KID"), + NULL, + 0); } @@ -854,26 +866,26 @@ get_kid(const struct GNUNET_HashCode *msec, * @param seq sequence number for the key cache entry */ static void -kce_generate(struct SharedSecret *ss, uint32_t seq) +kce_generate (struct SharedSecret *ss, uint32_t seq) { struct KeyCacheEntry *kce; - GNUNET_assert(0 < seq); - kce = GNUNET_new(struct KeyCacheEntry); + GNUNET_assert (0 < seq); + kce = GNUNET_new (struct KeyCacheEntry); kce->ss = ss; kce->sequence_number = seq; - get_kid(&ss->master, seq, &kce->kid); - GNUNET_CONTAINER_DLL_insert(ss->kce_head, ss->kce_tail, kce); + get_kid (&ss->master, seq, &kce->kid); + GNUNET_CONTAINER_DLL_insert (ss->kce_head, ss->kce_tail, kce); ss->active_kce_count++; - (void)GNUNET_CONTAINER_multishortmap_put( + (void) GNUNET_CONTAINER_multishortmap_put ( key_cache, &kce->kid, kce, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - GNUNET_STATISTICS_set(stats, - "# KIDs active", - GNUNET_CONTAINER_multishortmap_size(key_cache), - GNUNET_NO); + GNUNET_STATISTICS_set (stats, + "# KIDs active", + GNUNET_CONTAINER_multishortmap_size (key_cache), + GNUNET_NO); } @@ -883,31 +895,31 @@ kce_generate(struct SharedSecret *ss, uint32_t seq) * @param ss shared secret to destroy */ static void -secret_destroy(struct SharedSecret *ss) +secret_destroy (struct SharedSecret *ss) { struct SenderAddress *sender; struct ReceiverAddress *receiver; struct KeyCacheEntry *kce; if (NULL != (sender = ss->sender)) - { - GNUNET_CONTAINER_DLL_remove(sender->ss_head, sender->ss_tail, ss); - sender->num_secrets--; - } + { + GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss); + sender->num_secrets--; + } if (NULL != (receiver = ss->receiver)) - { - GNUNET_CONTAINER_DLL_remove(receiver->ss_head, receiver->ss_tail, ss); - receiver->num_secrets--; - receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used); - } + { + GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss); + receiver->num_secrets--; + receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used); + } while (NULL != (kce = ss->kce_head)) - kce_destroy(kce); - GNUNET_STATISTICS_update(stats, "# Secrets active", -1, GNUNET_NO); - GNUNET_STATISTICS_set(stats, - "# KIDs active", - GNUNET_CONTAINER_multishortmap_size(key_cache), - GNUNET_NO); - GNUNET_free(ss); + kce_destroy (kce); + GNUNET_STATISTICS_update (stats, "# Secrets active", -1, GNUNET_NO); + GNUNET_STATISTICS_set (stats, + "# KIDs active", + GNUNET_CONTAINER_multishortmap_size (key_cache), + GNUNET_NO); + GNUNET_free (ss); } @@ -918,18 +930,18 @@ secret_destroy(struct SharedSecret *ss) * @param sender entity to close down */ static void -sender_destroy(struct SenderAddress *sender) +sender_destroy (struct SenderAddress *sender) { - GNUNET_assert( + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(senders, &sender->target, sender)); - GNUNET_assert(sender == GNUNET_CONTAINER_heap_remove_node(sender->hn)); - GNUNET_STATISTICS_set(stats, - "# senders active", - GNUNET_CONTAINER_multipeermap_size(senders), - GNUNET_NO); - GNUNET_free(sender->address); - GNUNET_free(sender); + GNUNET_CONTAINER_multipeermap_remove (senders, &sender->target, sender)); + GNUNET_assert (sender == GNUNET_CONTAINER_heap_remove_node (sender->hn)); + GNUNET_STATISTICS_set (stats, + "# senders active", + GNUNET_CONTAINER_multipeermap_size (senders), + GNUNET_NO); + GNUNET_free (sender->address); + GNUNET_free (sender); } @@ -942,28 +954,28 @@ sender_destroy(struct SenderAddress *sender) * @param iv[out] where to write the IV */ static void -get_iv_key(const struct GNUNET_HashCode *msec, - uint32_t serial, - char key[AES_KEY_SIZE], - char iv[AES_IV_SIZE]) +get_iv_key (const struct GNUNET_HashCode *msec, + uint32_t serial, + char key[AES_KEY_SIZE], + char iv[AES_IV_SIZE]) { - uint32_t sid = htonl(serial); + uint32_t sid = htonl (serial); char res[AES_KEY_SIZE + AES_IV_SIZE]; - GNUNET_CRYPTO_hkdf(res, - sizeof(res), - GCRY_MD_SHA512, - GCRY_MD_SHA256, - &sid, - sizeof(sid), - msec, - sizeof(*msec), - "UDP-IV-KEY", - strlen("UDP-IV-KEY"), - NULL, - 0); - memcpy(key, res, AES_KEY_SIZE); - memcpy(iv, &res[AES_KEY_SIZE], AES_IV_SIZE); + GNUNET_CRYPTO_hkdf (res, + sizeof(res), + GCRY_MD_SHA512, + GCRY_MD_SHA256, + &sid, + sizeof(sid), + msec, + sizeof(*msec), + "UDP-IV-KEY", + strlen ("UDP-IV-KEY"), + NULL, + 0); + memcpy (key, res, AES_KEY_SIZE); + memcpy (iv, &res[AES_KEY_SIZE], AES_IV_SIZE); } @@ -973,11 +985,11 @@ get_iv_key(const struct GNUNET_HashCode *msec, * @param sender address for which the timeout should be rescheduled */ static void -reschedule_sender_timeout(struct SenderAddress *sender) +reschedule_sender_timeout (struct SenderAddress *sender) { sender->timeout = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); - GNUNET_CONTAINER_heap_update_cost(sender->hn, sender->timeout.abs_value_us); + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + GNUNET_CONTAINER_heap_update_cost (sender->hn, sender->timeout.abs_value_us); } @@ -987,12 +999,12 @@ reschedule_sender_timeout(struct SenderAddress *sender) * @param receiver address for which the timeout should be rescheduled */ static void -reschedule_receiver_timeout(struct ReceiverAddress *receiver) +reschedule_receiver_timeout (struct ReceiverAddress *receiver) { receiver->timeout = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); - GNUNET_CONTAINER_heap_update_cost(receiver->hn, - receiver->timeout.abs_value_us); + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + GNUNET_CONTAINER_heap_update_cost (receiver->hn, + receiver->timeout.abs_value_us); } @@ -1002,7 +1014,7 @@ reschedule_receiver_timeout(struct ReceiverAddress *receiver) * @param cls unused, NULL */ static void -check_timeouts(void *cls) +check_timeouts (void *cls) { struct GNUNET_TIME_Relative st; struct GNUNET_TIME_Relative rt; @@ -1010,27 +1022,27 @@ check_timeouts(void *cls) struct ReceiverAddress *receiver; struct SenderAddress *sender; - (void)cls; + (void) cls; timeout_task = NULL; rt = GNUNET_TIME_UNIT_FOREVER_REL; - while (NULL != (receiver = GNUNET_CONTAINER_heap_peek(receivers_heap))) - { - rt = GNUNET_TIME_absolute_get_remaining(receiver->timeout); - if (0 != rt.rel_value_us) - break; - receiver_destroy(receiver); - } + while (NULL != (receiver = GNUNET_CONTAINER_heap_peek (receivers_heap))) + { + rt = GNUNET_TIME_absolute_get_remaining (receiver->timeout); + if (0 != rt.rel_value_us) + break; + receiver_destroy (receiver); + } st = GNUNET_TIME_UNIT_FOREVER_REL; - while (NULL != (sender = GNUNET_CONTAINER_heap_peek(senders_heap))) - { - st = GNUNET_TIME_absolute_get_remaining(sender->timeout); - if (0 != st.rel_value_us) - break; - sender_destroy(sender); - } - delay = GNUNET_TIME_relative_min(rt, st); + while (NULL != (sender = GNUNET_CONTAINER_heap_peek (senders_heap))) + { + st = GNUNET_TIME_absolute_get_remaining (sender->timeout); + if (0 != st.rel_value_us) + break; + sender_destroy (sender); + } + delay = GNUNET_TIME_relative_min (rt, st); if (delay.rel_value_us < GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) - timeout_task = GNUNET_SCHEDULER_add_delayed(delay, &check_timeouts, NULL); + timeout_task = GNUNET_SCHEDULER_add_delayed (delay, &check_timeouts, NULL); } @@ -1040,20 +1052,20 @@ check_timeouts(void *cls) * @param ss[in,out] data structure to complete */ static void -calculate_cmac(struct SharedSecret *ss) +calculate_cmac (struct SharedSecret *ss) { - GNUNET_CRYPTO_hkdf(&ss->cmac, - sizeof(ss->cmac), - GCRY_MD_SHA512, - GCRY_MD_SHA256, - "CMAC", - strlen("CMAC"), - &ss->master, - sizeof(ss->master), - "UDP-CMAC", - strlen("UDP-CMAC"), - NULL, - 0); + GNUNET_CRYPTO_hkdf (&ss->cmac, + sizeof(ss->cmac), + GCRY_MD_SHA512, + GCRY_MD_SHA256, + "CMAC", + strlen ("CMAC"), + &ss->master, + sizeof(ss->master), + "UDP-CMAC", + strlen ("UDP-CMAC"), + NULL, + 0); } @@ -1066,36 +1078,36 @@ calculate_cmac(struct SharedSecret *ss) * @param plaintext_len number of bytes of plaintext received */ static void -pass_plaintext_to_core(struct SenderAddress *sender, - const void *plaintext, - size_t plaintext_len) +pass_plaintext_to_core (struct SenderAddress *sender, + const void *plaintext, + size_t plaintext_len) { const struct GNUNET_MessageHeader *hdr = plaintext; - while (ntohs(hdr->size) < plaintext_len) - { - GNUNET_STATISTICS_update(stats, - "# bytes given to core", - ntohs(hdr->size), - GNUNET_NO); - (void) - GNUNET_TRANSPORT_communicator_receive(ch, - &sender->target, - hdr, - ADDRESS_VALIDITY_PERIOD, - NULL /* no flow control possible */ - , - NULL); - /* move on to next message, if any */ - plaintext_len -= ntohs(hdr->size); - if (plaintext_len < sizeof(*hdr)) - break; - hdr = plaintext + ntohs(hdr->size); - } - GNUNET_STATISTICS_update(stats, - "# bytes padding discarded", - plaintext_len, - GNUNET_NO); + while (ntohs (hdr->size) < plaintext_len) + { + GNUNET_STATISTICS_update (stats, + "# bytes given to core", + ntohs (hdr->size), + GNUNET_NO); + (void) + GNUNET_TRANSPORT_communicator_receive (ch, + &sender->target, + hdr, + ADDRESS_VALIDITY_PERIOD, + NULL /* no flow control possible */ + , + NULL); + /* move on to next message, if any */ + plaintext_len -= ntohs (hdr->size); + if (plaintext_len < sizeof(*hdr)) + break; + hdr = plaintext + ntohs (hdr->size); + } + GNUNET_STATISTICS_update (stats, + "# bytes padding discarded", + plaintext_len, + GNUNET_NO); } @@ -1108,20 +1120,20 @@ pass_plaintext_to_core(struct SenderAddress *sender, * @param cipher[out] cipher to initialize */ static void -setup_cipher(const struct GNUNET_HashCode *msec, - uint32_t serial, - gcry_cipher_hd_t *cipher) +setup_cipher (const struct GNUNET_HashCode *msec, + uint32_t serial, + gcry_cipher_hd_t *cipher) { char key[AES_KEY_SIZE]; char iv[AES_IV_SIZE]; - gcry_cipher_open(cipher, - GCRY_CIPHER_AES256 /* low level: go for speed */, - GCRY_CIPHER_MODE_GCM, - 0 /* flags */); - get_iv_key(msec, serial, key, iv); - gcry_cipher_setkey(*cipher, key, sizeof(key)); - gcry_cipher_setiv(*cipher, iv, sizeof(iv)); + gcry_cipher_open (cipher, + GCRY_CIPHER_AES256 /* low level: go for speed */, + GCRY_CIPHER_MODE_GCM, + 0 /* flags */); + get_iv_key (msec, serial, key, iv); + gcry_cipher_setkey (*cipher, key, sizeof(key)); + gcry_cipher_setiv (*cipher, iv, sizeof(iv)); } @@ -1138,29 +1150,29 @@ setup_cipher(const struct GNUNET_HashCode *msec, * @return #GNUNET_OK on success */ static int -try_decrypt(const struct SharedSecret *ss, - const char tag[GCM_TAG_SIZE], - uint32_t serial, - const char *in_buf, - size_t in_buf_size, - char *out_buf) +try_decrypt (const struct SharedSecret *ss, + const char tag[GCM_TAG_SIZE], + uint32_t serial, + const char *in_buf, + size_t in_buf_size, + char *out_buf) { gcry_cipher_hd_t cipher; - setup_cipher(&ss->master, serial, &cipher); - GNUNET_assert( + setup_cipher (&ss->master, serial, &cipher); + GNUNET_assert ( 0 == - gcry_cipher_decrypt(cipher, out_buf, in_buf_size, in_buf, in_buf_size)); - if (0 != gcry_cipher_checktag(cipher, tag, GCM_TAG_SIZE)) - { - gcry_cipher_close(cipher); - GNUNET_STATISTICS_update(stats, - "# AEAD authentication failures", - 1, - GNUNET_NO); - return GNUNET_SYSERR; - } - gcry_cipher_close(cipher); + gcry_cipher_decrypt (cipher, out_buf, in_buf_size, in_buf, in_buf_size)); + if (0 != gcry_cipher_checktag (cipher, tag, GCM_TAG_SIZE)) + { + gcry_cipher_close (cipher); + GNUNET_STATISTICS_update (stats, + "# AEAD authentication failures", + 1, + GNUNET_NO); + return GNUNET_SYSERR; + } + gcry_cipher_close (cipher); return GNUNET_OK; } @@ -1172,12 +1184,12 @@ try_decrypt(const struct SharedSecret *ss, * @return new shared secret */ static struct SharedSecret * -setup_shared_secret_dec(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral) +setup_shared_secret_dec (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral) { struct SharedSecret *ss; - ss = GNUNET_new(struct SharedSecret); - GNUNET_CRYPTO_eddsa_ecdh(my_private_key, ephemeral, &ss->master); + ss = GNUNET_new (struct SharedSecret); + GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &ss->master); return ss; } @@ -1190,20 +1202,20 @@ setup_shared_secret_dec(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral) * @return new shared secret */ static struct SharedSecret * -setup_shared_secret_enc(const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral, - struct ReceiverAddress *receiver) +setup_shared_secret_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral, + struct ReceiverAddress *receiver) { struct SharedSecret *ss; - ss = GNUNET_new(struct SharedSecret); - GNUNET_CRYPTO_ecdh_eddsa(ephemeral, - &receiver->target.public_key, - &ss->master); - calculate_cmac(ss); + ss = GNUNET_new (struct SharedSecret); + GNUNET_CRYPTO_ecdh_eddsa (ephemeral, + &receiver->target.public_key, + &ss->master); + calculate_cmac (ss); ss->receiver = receiver; - GNUNET_CONTAINER_DLL_insert(receiver->ss_head, receiver->ss_tail, ss); + GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss); receiver->num_secrets++; - GNUNET_STATISTICS_update(stats, "# Secrets active", 1, GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO); return ss; } @@ -1216,7 +1228,7 @@ setup_shared_secret_enc(const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral, * @param receiver receiver to setup MQ for */ static void -setup_receiver_mq(struct ReceiverAddress *receiver); +setup_receiver_mq (struct ReceiverAddress *receiver); /** @@ -1230,36 +1242,36 @@ setup_receiver_mq(struct ReceiverAddress *receiver); * @return #GNUNET_YES to continue to iterate */ static int -handle_ack(void *cls, const struct GNUNET_PeerIdentity *pid, void *value) +handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value) { const struct UDPAck *ack = cls; struct ReceiverAddress *receiver = value; - (void)pid; + (void) pid; for (struct SharedSecret *ss = receiver->ss_head; NULL != ss; ss = ss->next) + { + if (0 == memcmp (&ack->cmac, &ss->cmac, sizeof(struct GNUNET_HashCode))) { - if (0 == memcmp(&ack->cmac, &ss->cmac, sizeof(struct GNUNET_HashCode))) + uint32_t allowed; + + allowed = ntohl (ack->sequence_max); + + if (allowed > ss->sequence_allowed) + { + receiver->acks_available += (allowed - ss->sequence_allowed); + if ((allowed - ss->sequence_allowed) == receiver->acks_available) { - uint32_t allowed; - - allowed = ntohl(ack->sequence_max); - - if (allowed > ss->sequence_allowed) - { - receiver->acks_available += (allowed - ss->sequence_allowed); - if ((allowed - ss->sequence_allowed) == receiver->acks_available) - { - /* we just incremented from zero => MTU change! */ - setup_receiver_mq(receiver); - } - ss->sequence_allowed = allowed; - /* move ss to head to avoid discarding it anytime soon! */ - GNUNET_CONTAINER_DLL_remove(receiver->ss_head, receiver->ss_tail, ss); - GNUNET_CONTAINER_DLL_insert(receiver->ss_head, receiver->ss_tail, ss); - } - return GNUNET_NO; + /* we just incremented from zero => MTU change! */ + setup_receiver_mq (receiver); } + ss->sequence_allowed = allowed; + /* move ss to head to avoid discarding it anytime soon! */ + GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss); + GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss); + } + return GNUNET_NO; } + } return GNUNET_YES; } @@ -1273,41 +1285,41 @@ handle_ack(void *cls, const struct GNUNET_PeerIdentity *pid, void *value) * @param buf_size number of bytes in @a buf */ static void -try_handle_plaintext(struct SenderAddress *sender, - const void *buf, - size_t buf_size) +try_handle_plaintext (struct SenderAddress *sender, + const void *buf, + size_t buf_size) { const struct GNUNET_MessageHeader *hdr = - (const struct GNUNET_MessageHeader *)buf; - const struct UDPAck *ack = (const struct UDPAck *)buf; + (const struct GNUNET_MessageHeader *) buf; + const struct UDPAck *ack = (const struct UDPAck *) buf; uint16_t type; if (sizeof(*hdr) > buf_size) return; /* not even a header */ - if (ntohs(hdr->size) > buf_size) + if (ntohs (hdr->size) > buf_size) return; /* not even a header */ - type = ntohs(hdr->type); + type = ntohs (hdr->type); switch (type) - { - case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK: - /* lookup master secret by 'cmac', then update sequence_max */ - GNUNET_CONTAINER_multipeermap_get_multiple(receivers, - &sender->target, - &handle_ack, - (void *)ack); - /* There could be more messages after the ACK, handle those as well */ - buf += ntohs(hdr->size); - buf_size -= ntohs(hdr->size); - pass_plaintext_to_core(sender, buf, buf_size); - break; - - case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD: - /* skip padding */ - break; - - default: - pass_plaintext_to_core(sender, buf, buf_size); - } + { + case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK: + /* lookup master secret by 'cmac', then update sequence_max */ + GNUNET_CONTAINER_multipeermap_get_multiple (receivers, + &sender->target, + &handle_ack, + (void *) ack); + /* There could be more messages after the ACK, handle those as well */ + buf += ntohs (hdr->size); + buf_size -= ntohs (hdr->size); + pass_plaintext_to_core (sender, buf, buf_size); + break; + + case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD: + /* skip padding */ + break; + + default: + pass_plaintext_to_core (sender, buf, buf_size); + } } @@ -1320,29 +1332,29 @@ try_handle_plaintext(struct SenderAddress *sender, * @param ss shared secret to generate ACKs for */ static void -consider_ss_ack(struct SharedSecret *ss) +consider_ss_ack (struct SharedSecret *ss) { - GNUNET_assert(NULL != ss->sender); + GNUNET_assert (NULL != ss->sender); /* drop ancient KeyCacheEntries */ while ((NULL != ss->kce_head) && (MAX_SQN_DELTA < ss->kce_head->sequence_number - ss->kce_tail->sequence_number)) - kce_destroy(ss->kce_tail); + kce_destroy (ss->kce_tail); if (ss->active_kce_count < KCN_THRESHOLD) - { - struct UDPAck ack; - - while (ss->active_kce_count < KCN_TARGET) - kce_generate(ss, ++ss->sequence_allowed); - ack.header.type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK); - ack.header.size = htons(sizeof(ack)); - ack.sequence_max = htonl(ss->sequence_allowed); - ack.cmac = ss->cmac; - GNUNET_TRANSPORT_communicator_notify(ch, - &ss->sender->target, - COMMUNICATOR_ADDRESS_PREFIX, - &ack.header); - } + { + struct UDPAck ack; + + while (ss->active_kce_count < KCN_TARGET) + kce_generate (ss, ++ss->sequence_allowed); + ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK); + ack.header.size = htons (sizeof(ack)); + ack.sequence_max = htonl (ss->sequence_allowed); + ack.cmac = ss->cmac; + GNUNET_TRANSPORT_communicator_notify (ch, + &ss->sender->target, + COMMUNICATOR_ADDRESS_PREFIX, + &ack.header); + } } @@ -1354,42 +1366,43 @@ consider_ss_ack(struct SharedSecret *ss) * @param kce key index to decrypt @a box */ static void -decrypt_box(const struct UDPBox *box, - size_t box_len, - struct KeyCacheEntry *kce) +decrypt_box (const struct UDPBox *box, + size_t box_len, + struct KeyCacheEntry *kce) { struct SharedSecret *ss = kce->ss; char out_buf[box_len - sizeof(*box)]; - GNUNET_assert(NULL != ss->sender); - if (GNUNET_OK != try_decrypt(ss, - box->gcm_tag, - kce->sequence_number, - (const char *)&box[1], - sizeof(out_buf), - out_buf)) - { - GNUNET_STATISTICS_update(stats, - "# Decryption failures with valid KCE", - 1, - GNUNET_NO); - kce_destroy(kce); - return; - } - kce_destroy(kce); - GNUNET_STATISTICS_update(stats, - "# bytes decrypted with BOX", - sizeof(out_buf), - GNUNET_NO); - try_handle_plaintext(ss->sender, out_buf, sizeof(out_buf)); - consider_ss_ack(ss); + GNUNET_assert (NULL != ss->sender); + if (GNUNET_OK != try_decrypt (ss, + box->gcm_tag, + kce->sequence_number, + (const char *) &box[1], + sizeof(out_buf), + out_buf)) + { + GNUNET_STATISTICS_update (stats, + "# Decryption failures with valid KCE", + 1, + GNUNET_NO); + kce_destroy (kce); + return; + } + kce_destroy (kce); + GNUNET_STATISTICS_update (stats, + "# bytes decrypted with BOX", + sizeof(out_buf), + GNUNET_NO); + try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf)); + consider_ss_ack (ss); } /** * Closure for #find_sender_by_address() */ -struct SearchContext { +struct SearchContext +{ /** * Address we are looking for. */ @@ -1416,19 +1429,19 @@ struct SearchContext { * @return #GNUNET_YES if not found (continue to search), #GNUNET_NO if found */ static int -find_sender_by_address(void *cls, - const struct GNUNET_PeerIdentity *key, - void *value) +find_sender_by_address (void *cls, + const struct GNUNET_PeerIdentity *key, + void *value) { struct SearchContext *sc = cls; struct SenderAddress *sender = value; if ((sender->address_len == sc->address_len) && - (0 == memcmp(sender->address, sc->address, sender->address_len))) - { - sc->sender = sender; - return GNUNET_NO; /* stop iterating! */ - } + (0 == memcmp (sender->address, sc->address, sender->address_len))) + { + sc->sender = sender; + return GNUNET_NO; /* stop iterating! */ + } return GNUNET_YES; } @@ -1445,45 +1458,45 @@ find_sender_by_address(void *cls, * decrypting data from @a target */ static struct SenderAddress * -setup_sender(const struct GNUNET_PeerIdentity *target, - const struct sockaddr *address, - socklen_t address_len) +setup_sender (const struct GNUNET_PeerIdentity *target, + const struct sockaddr *address, + socklen_t address_len) { struct SenderAddress *sender; struct SearchContext sc = { .address = address, .address_len = address_len, .sender = NULL }; - GNUNET_CONTAINER_multipeermap_get_multiple(senders, - target, - &find_sender_by_address, - &sc); + GNUNET_CONTAINER_multipeermap_get_multiple (senders, + target, + &find_sender_by_address, + &sc); if (NULL != sc.sender) - { - reschedule_sender_timeout(sc.sender); - return sc.sender; - } - sender = GNUNET_new(struct SenderAddress); + { + reschedule_sender_timeout (sc.sender); + return sc.sender; + } + sender = GNUNET_new (struct SenderAddress); sender->target = *target; - sender->address = GNUNET_memdup(address, address_len); + sender->address = GNUNET_memdup (address, address_len); sender->address_len = address_len; - (void)GNUNET_CONTAINER_multipeermap_put( + (void) GNUNET_CONTAINER_multipeermap_put ( senders, &sender->target, sender, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - GNUNET_STATISTICS_set(stats, - "# senders active", - GNUNET_CONTAINER_multipeermap_size(receivers), - GNUNET_NO); + GNUNET_STATISTICS_set (stats, + "# senders active", + GNUNET_CONTAINER_multipeermap_size (receivers), + GNUNET_NO); sender->timeout = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); - sender->hn = GNUNET_CONTAINER_heap_insert(senders_heap, - sender, - sender->timeout.abs_value_us); - sender->nt = GNUNET_NT_scanner_get_type(is, address, address_len); + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + sender->hn = GNUNET_CONTAINER_heap_insert (senders_heap, + sender, + sender->timeout.abs_value_us); + sender->nt = GNUNET_NT_scanner_get_type (is, address, address_len); if (NULL == timeout_task) - timeout_task = GNUNET_SCHEDULER_add_now(&check_timeouts, NULL); + timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL); return sender; } @@ -1496,21 +1509,22 @@ setup_sender(const struct GNUNET_PeerIdentity *target, * @return #GNUNET_OK if signature is valid */ static int -verify_confirmation(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, - const struct UDPConfirmation *uc) +verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, + const struct UDPConfirmation *uc) { struct UdpHandshakeSignature uhs; - uhs.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE); - uhs.purpose.size = htonl(sizeof(uhs)); + uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE); + uhs.purpose.size = htonl (sizeof(uhs)); uhs.sender = uc->sender; uhs.receiver = my_identity; uhs.ephemeral = *ephemeral; uhs.monotonic_time = uc->monotonic_time; - return GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE, - &uhs.purpose, - &uc->sender_sig, - &uc->sender.public_key); + return GNUNET_CRYPTO_eddsa_verify ( + GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE, + &uhs.purpose, + &uc->sender_sig, + &uc->sender.public_key); } @@ -1523,30 +1537,30 @@ verify_confirmation(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, * @return string representation of @a address */ static char * -sockaddr_to_udpaddr_string(const struct sockaddr *address, - socklen_t address_len) +sockaddr_to_udpaddr_string (const struct sockaddr *address, + socklen_t address_len) { char *ret; switch (address->sa_family) - { - case AF_INET: - GNUNET_asprintf(&ret, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_a2s(address, address_len)); - break; - - case AF_INET6: - GNUNET_asprintf(&ret, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_a2s(address, address_len)); - break; - - default: - GNUNET_assert(0); - } + { + case AF_INET: + GNUNET_asprintf (&ret, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_a2s (address, address_len)); + break; + + case AF_INET6: + GNUNET_asprintf (&ret, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_a2s (address, address_len)); + break; + + default: + GNUNET_assert (0); + } return ret; } @@ -1557,87 +1571,87 @@ sockaddr_to_udpaddr_string(const struct sockaddr *address, * @param cls NULL */ static void -sock_read(void *cls) +sock_read (void *cls) { struct sockaddr_storage sa; socklen_t salen = sizeof(sa); char buf[UINT16_MAX]; ssize_t rcvd; - (void)cls; - read_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - udp_sock, - &sock_read, - NULL); - rcvd = GNUNET_NETWORK_socket_recvfrom(udp_sock, - buf, - sizeof(buf), - (struct sockaddr *)&sa, - &salen); + (void) cls; + read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + udp_sock, + &sock_read, + NULL); + rcvd = GNUNET_NETWORK_socket_recvfrom (udp_sock, + buf, + sizeof(buf), + (struct sockaddr *) &sa, + &salen); if (-1 == rcvd) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv"); - return; - } + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv"); + return; + } /* first, see if it is a UDPBox */ if (rcvd > sizeof(struct UDPBox)) - { - const struct UDPBox *box; - struct KeyCacheEntry *kce; + { + const struct UDPBox *box; + struct KeyCacheEntry *kce; - box = (const struct UDPBox *)buf; - kce = GNUNET_CONTAINER_multishortmap_get(key_cache, &box->kid); - if (NULL != kce) - { - decrypt_box(box, (size_t)rcvd, kce); - return; - } + box = (const struct UDPBox *) buf; + kce = GNUNET_CONTAINER_multishortmap_get (key_cache, &box->kid); + if (NULL != kce) + { + decrypt_box (box, (size_t) rcvd, kce); + return; } + } /* next, check if it is a broadcast */ if (sizeof(struct UDPBroadcast) == rcvd) + { + const struct UDPBroadcast *ub; + struct UdpBroadcastSignature uhs; + + ub = (const struct UDPBroadcast *) buf; + uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST); + uhs.purpose.size = htonl (sizeof(uhs)); + uhs.sender = ub->sender; + GNUNET_CRYPTO_hash (&sa, salen, &uhs.h_address); + if (GNUNET_OK == + GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST, + &uhs.purpose, + &ub->sender_sig, + &ub->sender.public_key)) { - const struct UDPBroadcast *ub; - struct UdpBroadcastSignature uhs; - - ub = (const struct UDPBroadcast *)buf; - uhs.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST); - uhs.purpose.size = htonl(sizeof(uhs)); - uhs.sender = ub->sender; - GNUNET_CRYPTO_hash(&sa, salen, &uhs.h_address); - if (GNUNET_OK == - GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST, - &uhs.purpose, - &ub->sender_sig, - &ub->sender.public_key)) - { - char *addr_s; - enum GNUNET_NetworkType nt; - - addr_s = - sockaddr_to_udpaddr_string((const struct sockaddr *)&sa, salen); - GNUNET_STATISTICS_update(stats, "# broadcasts received", 1, GNUNET_NO); - /* use our own mechanism to determine network type */ - nt = - GNUNET_NT_scanner_get_type(is, (const struct sockaddr *)&sa, salen); - GNUNET_TRANSPORT_application_validate(ah, &ub->sender, nt, addr_s); - GNUNET_free(addr_s); - return; - } - /* continue with KX, mostly for statistics... */ + char *addr_s; + enum GNUNET_NetworkType nt; + + addr_s = + sockaddr_to_udpaddr_string ((const struct sockaddr *) &sa, salen); + GNUNET_STATISTICS_update (stats, "# broadcasts received", 1, GNUNET_NO); + /* use our own mechanism to determine network type */ + nt = + GNUNET_NT_scanner_get_type (is, (const struct sockaddr *) &sa, salen); + GNUNET_TRANSPORT_application_validate (ah, &ub->sender, nt, addr_s); + GNUNET_free (addr_s); + return; } + /* continue with KX, mostly for statistics... */ + } /* finally, test if it is a KX */ if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX)) - { - GNUNET_STATISTICS_update(stats, - "# messages dropped (no kid, too small for KX)", - 1, - GNUNET_NO); - return; - } + { + GNUNET_STATISTICS_update (stats, + "# messages dropped (no kid, too small for KX)", + 1, + GNUNET_NO); + return; + } { const struct InitialKX *kx; @@ -1646,48 +1660,48 @@ sock_read(void *cls) const struct UDPConfirmation *uc; struct SenderAddress *sender; - kx = (const struct InitialKX *)buf; - ss = setup_shared_secret_dec(&kx->ephemeral); - if (GNUNET_OK != try_decrypt(ss, - kx->gcm_tag, - 0, - &buf[sizeof(*kx)], - sizeof(pbuf), - pbuf)) - { - GNUNET_free(ss); - GNUNET_STATISTICS_update( - stats, - "# messages dropped (no kid, AEAD decryption failed)", - 1, - GNUNET_NO); - return; - } - uc = (const struct UDPConfirmation *)pbuf; - if (GNUNET_OK != verify_confirmation(&kx->ephemeral, uc)) - { - GNUNET_break_op(0); - GNUNET_free(ss); - GNUNET_STATISTICS_update(stats, - "# messages dropped (sender signature invalid)", - 1, - GNUNET_NO); - return; - } - calculate_cmac(ss); - sender = setup_sender(&uc->sender, (const struct sockaddr *)&sa, salen); + kx = (const struct InitialKX *) buf; + ss = setup_shared_secret_dec (&kx->ephemeral); + if (GNUNET_OK != try_decrypt (ss, + kx->gcm_tag, + 0, + &buf[sizeof(*kx)], + sizeof(pbuf), + pbuf)) + { + GNUNET_free (ss); + GNUNET_STATISTICS_update ( + stats, + "# messages dropped (no kid, AEAD decryption failed)", + 1, + GNUNET_NO); + return; + } + uc = (const struct UDPConfirmation *) pbuf; + if (GNUNET_OK != verify_confirmation (&kx->ephemeral, uc)) + { + GNUNET_break_op (0); + GNUNET_free (ss); + GNUNET_STATISTICS_update (stats, + "# messages dropped (sender signature invalid)", + 1, + GNUNET_NO); + return; + } + calculate_cmac (ss); + sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen); ss->sender = sender; - GNUNET_CONTAINER_DLL_insert(sender->ss_head, sender->ss_tail, ss); + GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss); sender->num_secrets++; - GNUNET_STATISTICS_update(stats, "# Secrets active", 1, GNUNET_NO); - GNUNET_STATISTICS_update(stats, - "# messages decrypted without BOX", - 1, - GNUNET_NO); - try_handle_plaintext(sender, &uc[1], sizeof(pbuf) - sizeof(*uc)); - consider_ss_ack(ss); + GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO); + GNUNET_STATISTICS_update (stats, + "# messages decrypted without BOX", + 1, + GNUNET_NO); + try_handle_plaintext (sender, &uc[1], sizeof(pbuf) - sizeof(*uc)); + consider_ss_ack (ss); if (sender->num_secrets > MAX_SECRETS) - secret_destroy(sender->ss_tail); + secret_destroy (sender->ss_tail); } } @@ -1700,7 +1714,7 @@ sock_read(void *cls) * @return converted bindto specification */ static struct sockaddr * -udp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) +udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len) { struct sockaddr *in; unsigned int port; @@ -1708,88 +1722,88 @@ udp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) char *colon; char *cp; - if (1 == sscanf(bindto, "%u%1s", &port, dummy)) + if (1 == sscanf (bindto, "%u%1s", &port, dummy)) + { + /* interpreting value as just a PORT number */ + if (port > UINT16_MAX) { - /* interpreting value as just a PORT number */ - if (port > UINT16_MAX) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "BINDTO specification `%s' invalid: value too large for port\n", - bindto); - return NULL; - } - if ((GNUNET_NO == GNUNET_NETWORK_test_pf(PF_INET6)) || - (GNUNET_YES == - GNUNET_CONFIGURATION_get_value_yesno(cfg, - COMMUNICATOR_CONFIG_SECTION, - "DISABLE_V6"))) - { - struct sockaddr_in *i4; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "BINDTO specification `%s' invalid: value too large for port\n", + bindto); + return NULL; + } + if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) || + (GNUNET_YES == + GNUNET_CONFIGURATION_get_value_yesno (cfg, + COMMUNICATOR_CONFIG_SECTION, + "DISABLE_V6"))) + { + struct sockaddr_in *i4; - i4 = GNUNET_malloc(sizeof(struct sockaddr_in)); - i4->sin_family = AF_INET; - i4->sin_port = htons((uint16_t)port); - *sock_len = sizeof(struct sockaddr_in); - in = (struct sockaddr *)i4; - } - else - { - struct sockaddr_in6 *i6; + i4 = GNUNET_malloc (sizeof(struct sockaddr_in)); + i4->sin_family = AF_INET; + i4->sin_port = htons ((uint16_t) port); + *sock_len = sizeof(struct sockaddr_in); + in = (struct sockaddr *) i4; + } + else + { + struct sockaddr_in6 *i6; - i6 = GNUNET_malloc(sizeof(struct sockaddr_in6)); - i6->sin6_family = AF_INET6; - i6->sin6_port = htons((uint16_t)port); - *sock_len = sizeof(struct sockaddr_in6); - in = (struct sockaddr *)i6; - } - return in; + i6 = GNUNET_malloc (sizeof(struct sockaddr_in6)); + i6->sin6_family = AF_INET6; + i6->sin6_port = htons ((uint16_t) port); + *sock_len = sizeof(struct sockaddr_in6); + in = (struct sockaddr *) i6; } - cp = GNUNET_strdup(bindto); - colon = strrchr(cp, ':'); + return in; + } + cp = GNUNET_strdup (bindto); + colon = strrchr (cp, ':'); if (NULL != colon) + { + /* interpet value after colon as port */ + *colon = '\0'; + colon++; + if (1 == sscanf (colon, "%u%1s", &port, dummy)) { - /* interpet value after colon as port */ - *colon = '\0'; - colon++; - if (1 == sscanf(colon, "%u%1s", &port, dummy)) - { - /* interpreting value as just a PORT number */ - if (port > UINT16_MAX) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "BINDTO specification `%s' invalid: value too large for port\n", - bindto); - GNUNET_free(cp); - return NULL; - } - } - else - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - "BINDTO specification `%s' invalid: last ':' not followed by number\n", - bindto); - GNUNET_free(cp); - return NULL; - } + /* interpreting value as just a PORT number */ + if (port > UINT16_MAX) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "BINDTO specification `%s' invalid: value too large for port\n", + bindto); + GNUNET_free (cp); + return NULL; + } } - else + else { - /* interpret missing port as 0, aka pick any free one */ - port = 0; + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + "BINDTO specification `%s' invalid: last ':' not followed by number\n", + bindto); + GNUNET_free (cp); + return NULL; } + } + else + { + /* interpret missing port as 0, aka pick any free one */ + port = 0; + } { /* try IPv4 */ struct sockaddr_in v4; - if (1 == inet_pton(AF_INET, cp, &v4)) - { - v4.sin_port = htons((uint16_t)port); - in = GNUNET_memdup(&v4, sizeof(v4)); - *sock_len = sizeof(v4); - GNUNET_free(cp); - return in; - } + if (1 == inet_pton (AF_INET, cp, &v4)) + { + v4.sin_port = htons ((uint16_t) port); + in = GNUNET_memdup (&v4, sizeof(v4)); + *sock_len = sizeof(v4); + GNUNET_free (cp); + return in; + } } { /* try IPv6 */ @@ -1797,22 +1811,22 @@ udp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) const char *start; start = cp; - if (('[' == *cp) && (']' == cp[strlen(cp) - 1])) - { - start++; /* skip over '[' */ - cp[strlen(cp) - 1] = '\0'; /* eat ']' */ - } - if (1 == inet_pton(AF_INET6, start, &v6)) - { - v6.sin6_port = htons((uint16_t)port); - in = GNUNET_memdup(&v6, sizeof(v6)); - *sock_len = sizeof(v6); - GNUNET_free(cp); - return in; - } + if (('[' == *cp) && (']' == cp[strlen (cp) - 1])) + { + start++; /* skip over '[' */ + cp[strlen (cp) - 1] = '\0'; /* eat ']' */ + } + if (1 == inet_pton (AF_INET6, start, &v6)) + { + v6.sin6_port = htons ((uint16_t) port); + in = GNUNET_memdup (&v6, sizeof(v6)); + *sock_len = sizeof(v6); + GNUNET_free (cp); + return in; + } } /* #5528 FIXME (feature!): maybe also try getnameinfo()? */ - GNUNET_free(cp); + GNUNET_free (cp); return NULL; } @@ -1825,22 +1839,22 @@ udp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) * @param pad_size number of bytes of padding to append */ static void -do_pad(gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size) +do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size) { char pad[pad_size]; - GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, pad, sizeof(pad)); + GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, pad, sizeof(pad)); if (sizeof(pad) > sizeof(struct GNUNET_MessageHeader)) - { - struct GNUNET_MessageHeader hdr = - { .size = htons(sizeof(pad)), - .type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD) }; + { + struct GNUNET_MessageHeader hdr = + { .size = htons (sizeof(pad)), + .type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD) }; - memcpy(pad, &hdr, sizeof(hdr)); - } - GNUNET_assert( + memcpy (pad, &hdr, sizeof(hdr)); + } + GNUNET_assert ( 0 == - gcry_cipher_encrypt(out_cipher, dgram, sizeof(pad), pad, sizeof(pad))); + gcry_cipher_encrypt (out_cipher, dgram, sizeof(pad), pad, sizeof(pad))); } @@ -1853,123 +1867,123 @@ do_pad(gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size) * @param impl_state our `struct ReceiverAddress` */ static void -mq_send(struct GNUNET_MQ_Handle *mq, - const struct GNUNET_MessageHeader *msg, - void *impl_state) +mq_send (struct GNUNET_MQ_Handle *mq, + const struct GNUNET_MessageHeader *msg, + void *impl_state) { struct ReceiverAddress *receiver = impl_state; - uint16_t msize = ntohs(msg->size); + uint16_t msize = ntohs (msg->size); - GNUNET_assert(mq == receiver->mq); + GNUNET_assert (mq == receiver->mq); if (msize > receiver->mtu) - { - GNUNET_break(0); - receiver_destroy(receiver); - return; - } - reschedule_receiver_timeout(receiver); + { + GNUNET_break (0); + receiver_destroy (receiver); + return; + } + reschedule_receiver_timeout (receiver); if (0 == receiver->acks_available) - { - /* use KX encryption method */ - struct UdpHandshakeSignature uhs; - struct UDPConfirmation uc; - struct InitialKX kx; - struct GNUNET_CRYPTO_EcdhePrivateKey epriv; - char dgram[receiver->mtu + sizeof(uc) + sizeof(kx)]; - size_t dpos; - gcry_cipher_hd_t out_cipher; - struct SharedSecret *ss; - - /* setup key material */ - GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_ecdhe_key_create2(&epriv)); - - ss = setup_shared_secret_enc(&epriv, receiver); - setup_cipher(&ss->master, 0, &out_cipher); - /* compute 'uc' */ - uc.sender = my_identity; - uc.monotonic_time = - GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_monotonic(cfg)); - uhs.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE); - uhs.purpose.size = htonl(sizeof(uhs)); - uhs.sender = my_identity; - uhs.receiver = receiver->target; - GNUNET_CRYPTO_ecdhe_key_get_public(&epriv, &uhs.ephemeral); - uhs.monotonic_time = uc.monotonic_time; - GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key, + { + /* use KX encryption method */ + struct UdpHandshakeSignature uhs; + struct UDPConfirmation uc; + struct InitialKX kx; + struct GNUNET_CRYPTO_EcdhePrivateKey epriv; + char dgram[receiver->mtu + sizeof(uc) + sizeof(kx)]; + size_t dpos; + gcry_cipher_hd_t out_cipher; + struct SharedSecret *ss; + + /* setup key material */ + GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdhe_key_create2 (&epriv)); + + ss = setup_shared_secret_enc (&epriv, receiver); + setup_cipher (&ss->master, 0, &out_cipher); + /* compute 'uc' */ + uc.sender = my_identity; + uc.monotonic_time = + GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); + uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE); + uhs.purpose.size = htonl (sizeof(uhs)); + uhs.sender = my_identity; + uhs.receiver = receiver->target; + GNUNET_CRYPTO_ecdhe_key_get_public (&epriv, &uhs.ephemeral); + uhs.monotonic_time = uc.monotonic_time; + GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key, &uhs.purpose, &uc.sender_sig)); - /* Leave space for kx */ - dpos = sizeof(struct GNUNET_CRYPTO_EcdhePublicKey); - /* Append encrypted uc to dgram */ - GNUNET_assert(0 == gcry_cipher_encrypt(out_cipher, + /* Leave space for kx */ + dpos = sizeof(struct GNUNET_CRYPTO_EcdhePublicKey); + /* Append encrypted uc to dgram */ + GNUNET_assert (0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], sizeof(uc), &uc, sizeof(uc))); - dpos += sizeof(uc); - /* Append encrypted payload to dgram */ - GNUNET_assert( - 0 == gcry_cipher_encrypt(out_cipher, &dgram[dpos], msize, msg, msize)); - dpos += msize; - do_pad(out_cipher, &dgram[dpos], sizeof(dgram) - dpos); - /* Datagram starts with kx */ - kx.ephemeral = uhs.ephemeral; - GNUNET_assert( - 0 == gcry_cipher_gettag(out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag))); - gcry_cipher_close(out_cipher); - memcpy(dgram, &kx, sizeof(kx)); - if (-1 == GNUNET_NETWORK_socket_sendto(udp_sock, - dgram, - sizeof(dgram), - receiver->address, - receiver->address_len)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send"); - GNUNET_MQ_impl_send_continue(mq); - return; - } /* End of KX encryption method */ + dpos += sizeof(uc); + /* Append encrypted payload to dgram */ + GNUNET_assert ( + 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize)); + dpos += msize; + do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos); + /* Datagram starts with kx */ + kx.ephemeral = uhs.ephemeral; + GNUNET_assert ( + 0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag))); + gcry_cipher_close (out_cipher); + memcpy (dgram, &kx, sizeof(kx)); + if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock, + dgram, + sizeof(dgram), + receiver->address, + receiver->address_len)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); + GNUNET_MQ_impl_send_continue (mq); + return; + } /* End of KX encryption method */ /* begin "BOX" encryption method, scan for ACKs from tail! */ for (struct SharedSecret *ss = receiver->ss_tail; NULL != ss; ss = ss->prev) + { + if (ss->sequence_used < ss->sequence_allowed) { - if (ss->sequence_used < ss->sequence_allowed) - { - char dgram[sizeof(struct UDPBox) + receiver->mtu]; - struct UDPBox *box; - gcry_cipher_hd_t out_cipher; - size_t dpos; - - box = (struct UDPBox *)dgram; - ss->sequence_used++; - get_kid(&ss->master, ss->sequence_used, &box->kid); - setup_cipher(&ss->master, ss->sequence_used, &out_cipher); - /* Append encrypted payload to dgram */ - dpos = sizeof(struct UDPBox); - GNUNET_assert( - 0 == gcry_cipher_encrypt(out_cipher, &dgram[dpos], msize, msg, msize)); - dpos += msize; - do_pad(out_cipher, &dgram[dpos], sizeof(dgram) - dpos); - GNUNET_assert(0 == gcry_cipher_gettag(out_cipher, - box->gcm_tag, - sizeof(box->gcm_tag))); - gcry_cipher_close(out_cipher); - if (-1 == GNUNET_NETWORK_socket_sendto(udp_sock, - dgram, - sizeof(dgram), - receiver->address, - receiver->address_len)) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send"); - GNUNET_MQ_impl_send_continue(mq); - receiver->acks_available--; - if (0 == receiver->acks_available) - { - /* We have no more ACKs => MTU change! */ - setup_receiver_mq(receiver); - } - return; - } + char dgram[sizeof(struct UDPBox) + receiver->mtu]; + struct UDPBox *box; + gcry_cipher_hd_t out_cipher; + size_t dpos; + + box = (struct UDPBox *) dgram; + ss->sequence_used++; + get_kid (&ss->master, ss->sequence_used, &box->kid); + setup_cipher (&ss->master, ss->sequence_used, &out_cipher); + /* Append encrypted payload to dgram */ + dpos = sizeof(struct UDPBox); + GNUNET_assert ( + 0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize)); + dpos += msize; + do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos); + GNUNET_assert (0 == gcry_cipher_gettag (out_cipher, + box->gcm_tag, + sizeof(box->gcm_tag))); + gcry_cipher_close (out_cipher); + if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock, + dgram, + sizeof(dgram), + receiver->address, + receiver->address_len)) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); + GNUNET_MQ_impl_send_continue (mq); + receiver->acks_available--; + if (0 == receiver->acks_available) + { + /* We have no more ACKs => MTU change! */ + setup_receiver_mq (receiver); + } + return; } - GNUNET_assert(0); + } + GNUNET_assert (0); } @@ -1982,15 +1996,15 @@ mq_send(struct GNUNET_MQ_Handle *mq, * @param impl_state our `struct ReceiverAddress` */ static void -mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state) +mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state) { struct ReceiverAddress *receiver = impl_state; if (mq == receiver->mq) - { - receiver->mq = NULL; - receiver_destroy(receiver); - } + { + receiver->mq = NULL; + receiver_destroy (receiver); + } } @@ -2001,10 +2015,10 @@ mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state) * @param impl_state our `struct RecvierAddress` */ static void -mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) +mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state) { /* Cancellation is impossible with UDP; bail */ - GNUNET_assert(0); + GNUNET_assert (0); } @@ -2018,15 +2032,15 @@ mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) * @param error error code */ static void -mq_error(void *cls, enum GNUNET_MQ_Error error) +mq_error (void *cls, enum GNUNET_MQ_Error error) { struct ReceiverAddress *receiver = cls; - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "MQ error in queue to %s: %d\n", - GNUNET_i2s(&receiver->target), - (int)error); - receiver_destroy(receiver); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "MQ error in queue to %s: %d\n", + GNUNET_i2s (&receiver->target), + (int) error); + receiver_destroy (receiver); } @@ -2038,63 +2052,63 @@ mq_error(void *cls, enum GNUNET_MQ_Error error) * @param receiver receiver to setup MQ for */ static void -setup_receiver_mq(struct ReceiverAddress *receiver) +setup_receiver_mq (struct ReceiverAddress *receiver) { size_t base_mtu; if (NULL != receiver->qh) - { - GNUNET_TRANSPORT_communicator_mq_del(receiver->qh); - receiver->qh = NULL; - } - GNUNET_assert(NULL == receiver->mq); + { + GNUNET_TRANSPORT_communicator_mq_del (receiver->qh); + receiver->qh = NULL; + } + GNUNET_assert (NULL == receiver->mq); switch (receiver->address->sa_family) - { - case AF_INET: - base_mtu = 1480 /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */ - - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */ - - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */; - break; - - case AF_INET6: - base_mtu = 1280 /* Minimum MTU required by IPv6 */ - - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */ - - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */; - break; - - default: - GNUNET_assert(0); - break; - } + { + case AF_INET: + base_mtu = 1480 /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */ + - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */ + - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */; + break; + + case AF_INET6: + base_mtu = 1280 /* Minimum MTU required by IPv6 */ + - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */ + - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */; + break; + + default: + GNUNET_assert (0); + break; + } if (0 == receiver->acks_available) - { - /* MTU based on full KX messages */ - receiver->mtu = base_mtu - sizeof(struct InitialKX) /* 48 */ - - sizeof(struct UDPConfirmation); /* 104 */ - } + { + /* MTU based on full KX messages */ + receiver->mtu = base_mtu - sizeof(struct InitialKX) /* 48 */ + - sizeof(struct UDPConfirmation); /* 104 */ + } else - { - /* MTU based on BOXed messages */ - receiver->mtu = base_mtu - sizeof(struct UDPBox); - } + { + /* MTU based on BOXed messages */ + receiver->mtu = base_mtu - sizeof(struct UDPBox); + } /* => Effective MTU for CORE will range from 1080 (IPv6 + KX) to 1404 (IPv4 + Box) bytes, depending on circumstances... */ if (NULL == receiver->mq) - receiver->mq = GNUNET_MQ_queue_for_callbacks(&mq_send, - &mq_destroy, - &mq_cancel, - receiver, - NULL, - &mq_error, - receiver); + receiver->mq = GNUNET_MQ_queue_for_callbacks (&mq_send, + &mq_destroy, + &mq_cancel, + receiver, + NULL, + &mq_error, + receiver); receiver->qh = - GNUNET_TRANSPORT_communicator_mq_add(ch, - &receiver->target, - receiver->foreign_addr, - receiver->mtu, - receiver->nt, - GNUNET_TRANSPORT_CS_OUTBOUND, - receiver->mq); + GNUNET_TRANSPORT_communicator_mq_add (ch, + &receiver->target, + receiver->foreign_addr, + receiver->mtu, + receiver->nt, + GNUNET_TRANSPORT_CS_OUTBOUND, + receiver->mq); } @@ -2117,47 +2131,47 @@ setup_receiver_mq(struct ReceiverAddress *receiver) * invalid */ static int -mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) +mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) { struct ReceiverAddress *receiver; const char *path; struct sockaddr *in; socklen_t in_len; - if (0 != strncmp(address, - COMMUNICATOR_ADDRESS_PREFIX "-", - strlen(COMMUNICATOR_ADDRESS_PREFIX "-"))) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } - path = &address[strlen(COMMUNICATOR_ADDRESS_PREFIX "-")]; - in = udp_address_to_sockaddr(path, &in_len); + if (0 != strncmp (address, + COMMUNICATOR_ADDRESS_PREFIX "-", + strlen (COMMUNICATOR_ADDRESS_PREFIX "-"))) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")]; + in = udp_address_to_sockaddr (path, &in_len); - receiver = GNUNET_new(struct ReceiverAddress); + receiver = GNUNET_new (struct ReceiverAddress); receiver->address = in; receiver->address_len = in_len; receiver->target = *peer; - receiver->nt = GNUNET_NT_scanner_get_type(is, in, in_len); - (void)GNUNET_CONTAINER_multipeermap_put( + receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len); + (void) GNUNET_CONTAINER_multipeermap_put ( receivers, &receiver->target, receiver, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); receiver->timeout = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); - receiver->hn = GNUNET_CONTAINER_heap_insert(receivers_heap, - receiver, - receiver->timeout.abs_value_us); - GNUNET_STATISTICS_set(stats, - "# receivers active", - GNUNET_CONTAINER_multipeermap_size(receivers), - GNUNET_NO); + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + receiver->hn = GNUNET_CONTAINER_heap_insert (receivers_heap, + receiver, + receiver->timeout.abs_value_us); + GNUNET_STATISTICS_set (stats, + "# receivers active", + GNUNET_CONTAINER_multipeermap_size (receivers), + GNUNET_NO); receiver->foreign_addr = - sockaddr_to_udpaddr_string(receiver->address, receiver->address_len); - setup_receiver_mq(receiver); + sockaddr_to_udpaddr_string (receiver->address, receiver->address_len); + setup_receiver_mq (receiver); if (NULL == timeout_task) - timeout_task = GNUNET_SCHEDULER_add_now(&check_timeouts, NULL); + timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL); return GNUNET_OK; } @@ -2171,15 +2185,15 @@ mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) * @return #GNUNET_OK to continue to iterate */ static int -get_receiver_delete_it(void *cls, - const struct GNUNET_PeerIdentity *target, - void *value) +get_receiver_delete_it (void *cls, + const struct GNUNET_PeerIdentity *target, + void *value) { struct ReceiverAddress *receiver = value; - (void)cls; - (void)target; - receiver_destroy(receiver); + (void) cls; + (void) target; + receiver_destroy (receiver); return GNUNET_OK; } @@ -2193,15 +2207,15 @@ get_receiver_delete_it(void *cls, * @return #GNUNET_OK to continue to iterate */ static int -get_sender_delete_it(void *cls, - const struct GNUNET_PeerIdentity *target, - void *value) +get_sender_delete_it (void *cls, + const struct GNUNET_PeerIdentity *target, + void *value) { struct SenderAddress *sender = value; - (void)cls; - (void)target; - sender_destroy(sender); + (void) cls; + (void) target; + sender_destroy (sender); return GNUNET_OK; } @@ -2212,64 +2226,64 @@ get_sender_delete_it(void *cls, * @param cls NULL (always) */ static void -do_shutdown(void *cls) +do_shutdown (void *cls) { if (NULL != nat) - { - GNUNET_NAT_unregister(nat); - nat = NULL; - } + { + GNUNET_NAT_unregister (nat); + nat = NULL; + } while (NULL != bi_head) - bi_destroy(bi_head); + bi_destroy (bi_head); if (NULL != broadcast_task) - { - GNUNET_SCHEDULER_cancel(broadcast_task); - broadcast_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (broadcast_task); + broadcast_task = NULL; + } if (NULL != read_task) - { - GNUNET_SCHEDULER_cancel(read_task); - read_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (read_task); + read_task = NULL; + } if (NULL != udp_sock) - { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(udp_sock)); - udp_sock = NULL; - } - GNUNET_CONTAINER_multipeermap_iterate(receivers, - &get_receiver_delete_it, - NULL); - GNUNET_CONTAINER_multipeermap_destroy(receivers); - GNUNET_CONTAINER_multipeermap_iterate(senders, &get_sender_delete_it, NULL); - GNUNET_CONTAINER_multipeermap_destroy(senders); - GNUNET_CONTAINER_multishortmap_destroy(key_cache); - GNUNET_CONTAINER_heap_destroy(senders_heap); - GNUNET_CONTAINER_heap_destroy(receivers_heap); + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (udp_sock)); + udp_sock = NULL; + } + GNUNET_CONTAINER_multipeermap_iterate (receivers, + &get_receiver_delete_it, + NULL); + GNUNET_CONTAINER_multipeermap_destroy (receivers); + GNUNET_CONTAINER_multipeermap_iterate (senders, &get_sender_delete_it, NULL); + GNUNET_CONTAINER_multipeermap_destroy (senders); + GNUNET_CONTAINER_multishortmap_destroy (key_cache); + GNUNET_CONTAINER_heap_destroy (senders_heap); + GNUNET_CONTAINER_heap_destroy (receivers_heap); if (NULL != ch) - { - GNUNET_TRANSPORT_communicator_disconnect(ch); - ch = NULL; - } + { + GNUNET_TRANSPORT_communicator_disconnect (ch); + ch = NULL; + } if (NULL != ah) - { - GNUNET_TRANSPORT_application_done(ah); - ah = NULL; - } + { + GNUNET_TRANSPORT_application_done (ah); + ah = NULL; + } if (NULL != stats) - { - GNUNET_STATISTICS_destroy(stats, GNUNET_NO); - stats = NULL; - } + { + GNUNET_STATISTICS_destroy (stats, GNUNET_NO); + stats = NULL; + } if (NULL != my_private_key) - { - GNUNET_free(my_private_key); - my_private_key = NULL; - } + { + GNUNET_free (my_private_key); + my_private_key = NULL; + } if (NULL != is) - { - GNUNET_NT_scanner_done(is); - is = NULL; - } + { + GNUNET_NT_scanner_done (is); + is = NULL; + } } @@ -2283,24 +2297,24 @@ do_shutdown(void *cls) * @param msg payload */ static void -enc_notify_cb(void *cls, - const struct GNUNET_PeerIdentity *sender, - const struct GNUNET_MessageHeader *msg) +enc_notify_cb (void *cls, + const struct GNUNET_PeerIdentity *sender, + const struct GNUNET_MessageHeader *msg) { const struct UDPAck *ack; - (void)cls; - if ((ntohs(msg->type) != GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK) || - (ntohs(msg->size) != sizeof(struct UDPAck))) - { - GNUNET_break_op(0); - return; - } - ack = (const struct UDPAck *)msg; - GNUNET_CONTAINER_multipeermap_get_multiple(receivers, - sender, - &handle_ack, - (void *)ack); + (void) cls; + if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK) || + (ntohs (msg->size) != sizeof(struct UDPAck))) + { + GNUNET_break_op (0); + return; + } + ack = (const struct UDPAck *) msg; + GNUNET_CONTAINER_multipeermap_get_multiple (receivers, + sender, + &handle_ack, + (void *) ack); } @@ -2318,39 +2332,39 @@ enc_notify_cb(void *cls, * @param addrlen actual length of the @a addr */ 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) +nat_address_cb (void *cls, + void **app_ctx, + int add_remove, + enum GNUNET_NAT_AddressClass ac, + const struct sockaddr *addr, + socklen_t addrlen) { char *my_addr; struct GNUNET_TRANSPORT_AddressIdentifier *ai; if (GNUNET_YES == add_remove) - { - enum GNUNET_NetworkType nt; - - GNUNET_asprintf(&my_addr, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_a2s(addr, addrlen)); - nt = GNUNET_NT_scanner_get_type(is, addr, addrlen); - ai = - GNUNET_TRANSPORT_communicator_address_add(ch, - my_addr, - nt, - GNUNET_TIME_UNIT_FOREVER_REL); - GNUNET_free(my_addr); - *app_ctx = ai; - } + { + enum GNUNET_NetworkType nt; + + GNUNET_asprintf (&my_addr, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_a2s (addr, addrlen)); + nt = GNUNET_NT_scanner_get_type (is, addr, addrlen); + ai = + GNUNET_TRANSPORT_communicator_address_add (ch, + my_addr, + nt, + GNUNET_TIME_UNIT_FOREVER_REL); + GNUNET_free (my_addr); + *app_ctx = ai; + } else - { - ai = *app_ctx; - GNUNET_TRANSPORT_communicator_address_remove(ai); - *app_ctx = NULL; - } + { + ai = *app_ctx; + GNUNET_TRANSPORT_communicator_address_remove (ai); + *app_ctx = NULL; + } } @@ -2360,69 +2374,69 @@ nat_address_cb(void *cls, * @param cls a `struct BroadcastInterface` */ static void -ifc_broadcast(void *cls) +ifc_broadcast (void *cls) { struct BroadcastInterface *bi = cls; struct GNUNET_TIME_Relative delay; delay = BROADCAST_FREQUENCY; delay.rel_value_us = - GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, delay.rel_value_us); + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, delay.rel_value_us); bi->broadcast_task = - GNUNET_SCHEDULER_add_delayed(INTERFACE_SCAN_FREQUENCY, &ifc_broadcast, bi); + GNUNET_SCHEDULER_add_delayed (INTERFACE_SCAN_FREQUENCY, &ifc_broadcast, bi); switch (bi->sa->sa_family) - { - case AF_INET: { + { + case AF_INET: { static int yes = 1; static int no = 0; ssize_t sent; - if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(udp_sock, - SOL_SOCKET, - SO_BROADCAST, - &yes, - sizeof(int))) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "setsockopt"); - sent = GNUNET_NETWORK_socket_sendto(udp_sock, - &bi->bcm, - sizeof(bi->bcm), - bi->ba, - bi->salen); + if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock, + SOL_SOCKET, + SO_BROADCAST, + &yes, + sizeof(int))) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); + sent = GNUNET_NETWORK_socket_sendto (udp_sock, + &bi->bcm, + sizeof(bi->bcm), + bi->ba, + bi->salen); if (-1 == sent) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "sendto"); - if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(udp_sock, - SOL_SOCKET, - SO_BROADCAST, - &no, - sizeof(int))) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "setsockopt"); + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto"); + if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock, + SOL_SOCKET, + SO_BROADCAST, + &no, + sizeof(int))) + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); break; } - case AF_INET6: { + case AF_INET6: { ssize_t sent; struct sockaddr_in6 dst; dst.sin6_family = AF_INET6; - dst.sin6_port = htons(my_port); + dst.sin6_port = htons (my_port); dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr; - dst.sin6_scope_id = ((struct sockaddr_in6 *)bi->ba)->sin6_scope_id; + dst.sin6_scope_id = ((struct sockaddr_in6 *) bi->ba)->sin6_scope_id; - sent = GNUNET_NETWORK_socket_sendto(udp_sock, - &bi->bcm, - sizeof(bi->bcm), - (const struct sockaddr *)&dst, - sizeof(dst)); + sent = GNUNET_NETWORK_socket_sendto (udp_sock, + &bi->bcm, + sizeof(bi->bcm), + (const struct sockaddr *) &dst, + sizeof(dst)); if (-1 == sent) - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "sendto"); + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto"); break; } - default: - GNUNET_break(0); - break; - } + default: + GNUNET_break (0); + break; + } } @@ -2441,90 +2455,90 @@ ifc_broadcast(void *cls) * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort */ static int -iface_proc(void *cls, - const char *name, - int isDefault, - const struct sockaddr *addr, - const struct sockaddr *broadcast_addr, - const struct sockaddr *netmask, - socklen_t addrlen) +iface_proc (void *cls, + const char *name, + int isDefault, + const struct sockaddr *addr, + const struct sockaddr *broadcast_addr, + const struct sockaddr *netmask, + socklen_t addrlen) { struct BroadcastInterface *bi; enum GNUNET_NetworkType network; struct UdpBroadcastSignature ubs; - (void)cls; - (void)netmask; + (void) cls; + (void) netmask; if (NULL == addr) return GNUNET_YES; /* need to know our address! */ - network = GNUNET_NT_scanner_get_type(is, addr, addrlen); + network = GNUNET_NT_scanner_get_type (is, addr, addrlen); if (GNUNET_NT_LOOPBACK == network) - { - /* Broadcasting on loopback does not make sense */ - return GNUNET_YES; - } + { + /* Broadcasting on loopback does not make sense */ + return GNUNET_YES; + } for (bi = bi_head; NULL != bi; bi = bi->next) + { + if ((bi->salen == addrlen) && (0 == memcmp (addr, bi->sa, addrlen))) { - if ((bi->salen == addrlen) && (0 == memcmp(addr, bi->sa, addrlen))) - { - bi->found = GNUNET_YES; - return GNUNET_OK; - } + bi->found = GNUNET_YES; + return GNUNET_OK; } + } if ((AF_INET6 == addr->sa_family) && (NULL == broadcast_addr)) return GNUNET_OK; /* broadcast_addr is required for IPv6! */ if ((AF_INET6 == addr->sa_family) && (GNUNET_YES != have_v6_socket)) return GNUNET_OK; /* not using IPv6 */ - bi = GNUNET_new(struct BroadcastInterface); - bi->sa = GNUNET_memdup(addr, addrlen); + bi = GNUNET_new (struct BroadcastInterface); + bi->sa = GNUNET_memdup (addr, addrlen); if (NULL != broadcast_addr) - bi->ba = GNUNET_memdup(broadcast_addr, addrlen); + bi->ba = GNUNET_memdup (broadcast_addr, addrlen); bi->salen = addrlen; bi->found = GNUNET_YES; bi->bcm.sender = my_identity; - ubs.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST); - ubs.purpose.size = htonl(sizeof(ubs)); + ubs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST); + ubs.purpose.size = htonl (sizeof(ubs)); ubs.sender = my_identity; - GNUNET_CRYPTO_hash(addr, addrlen, &ubs.h_address); - GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key, - &ubs.purpose, - &bi->bcm.sender_sig)); - bi->broadcast_task = GNUNET_SCHEDULER_add_now(&ifc_broadcast, bi); - GNUNET_CONTAINER_DLL_insert(bi_head, bi_tail, bi); + GNUNET_CRYPTO_hash (addr, addrlen, &ubs.h_address); + GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key, + &ubs.purpose, + &bi->bcm.sender_sig)); + bi->broadcast_task = GNUNET_SCHEDULER_add_now (&ifc_broadcast, bi); + GNUNET_CONTAINER_DLL_insert (bi_head, bi_tail, bi); if ((AF_INET6 == addr->sa_family) && (NULL != broadcast_addr)) + { + /* Create IPv6 multicast request */ + const struct sockaddr_in6 *s6 = + (const struct sockaddr_in6 *) broadcast_addr; + + GNUNET_assert ( + 1 == inet_pton (AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr)); + + /* http://tools.ietf.org/html/rfc2553#section-5.2: + * + * IPV6_JOIN_GROUP + * + * Join a multicast group on a specified local interface. If the + * interface index is specified as 0, the kernel chooses the local + * interface. For example, some kernels look up the multicast + * group in the normal IPv6 routing table and using the resulting + * interface; we do this for each interface, so no need to use + * zero (anymore...). + */ + bi->mcreq.ipv6mr_interface = s6->sin6_scope_id; + + /* Join the multicast group */ + if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock, + IPPROTO_IPV6, + IPV6_JOIN_GROUP, + &bi->mcreq, + sizeof(bi->mcreq))) { - /* Create IPv6 multicast request */ - const struct sockaddr_in6 *s6 = - (const struct sockaddr_in6 *)broadcast_addr; - - GNUNET_assert( - 1 == inet_pton(AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr)); - - /* http://tools.ietf.org/html/rfc2553#section-5.2: - * - * IPV6_JOIN_GROUP - * - * Join a multicast group on a specified local interface. If the - * interface index is specified as 0, the kernel chooses the local - * interface. For example, some kernels look up the multicast - * group in the normal IPv6 routing table and using the resulting - * interface; we do this for each interface, so no need to use - * zero (anymore...). - */ - bi->mcreq.ipv6mr_interface = s6->sin6_scope_id; - - /* Join the multicast group */ - if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(udp_sock, - IPPROTO_IPV6, - IPV6_JOIN_GROUP, - &bi->mcreq, - sizeof(bi->mcreq))) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "setsockopt"); - } + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt"); } + } return GNUNET_OK; } @@ -2535,23 +2549,23 @@ iface_proc(void *cls, * @param cls NULL, unused */ static void -do_broadcast(void *cls) +do_broadcast (void *cls) { struct BroadcastInterface *bin; - (void)cls; + (void) cls; for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bi->next) bi->found = GNUNET_NO; - GNUNET_OS_network_interfaces_list(&iface_proc, NULL); + GNUNET_OS_network_interfaces_list (&iface_proc, NULL); for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bin) - { - bin = bi->next; - if (GNUNET_NO == bi->found) - bi_destroy(bi); - } - broadcast_task = GNUNET_SCHEDULER_add_delayed(INTERFACE_SCAN_FREQUENCY, - &do_broadcast, - NULL); + { + bin = bi->next; + if (GNUNET_NO == bi->found) + bi_destroy (bi); + } + broadcast_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_SCAN_FREQUENCY, + &do_broadcast, + NULL); } @@ -2564,10 +2578,10 @@ do_broadcast(void *cls) * @param c configuration */ static void -run(void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *c) +run (void *cls, + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *c) { char *bindto; struct sockaddr *in; @@ -2575,143 +2589,143 @@ run(void *cls, struct sockaddr_storage in_sto; socklen_t sto_len; - (void)cls; + (void) cls; cfg = c; if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_filename(cfg, - COMMUNICATOR_CONFIG_SECTION, - "BINDTO", - &bindto)) - { - GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, - COMMUNICATOR_CONFIG_SECTION, - "BINDTO"); - return; - } + GNUNET_CONFIGURATION_get_value_filename (cfg, + COMMUNICATOR_CONFIG_SECTION, + "BINDTO", + &bindto)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, + COMMUNICATOR_CONFIG_SECTION, + "BINDTO"); + return; + } - in = udp_address_to_sockaddr(bindto, &in_len); + in = udp_address_to_sockaddr (bindto, &in_len); if (NULL == in) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Failed to setup UDP socket address with path `%s'\n", - bindto); - GNUNET_free(bindto); - return; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to setup UDP socket address with path `%s'\n", + bindto); + GNUNET_free (bindto); + return; + } udp_sock = - GNUNET_NETWORK_socket_create(in->sa_family, SOCK_DGRAM, IPPROTO_UDP); + GNUNET_NETWORK_socket_create (in->sa_family, SOCK_DGRAM, IPPROTO_UDP); if (NULL == udp_sock) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "socket"); - GNUNET_free(in); - GNUNET_free(bindto); - return; - } + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket"); + GNUNET_free (in); + GNUNET_free (bindto); + return; + } if (AF_INET6 == in->sa_family) have_v6_socket = GNUNET_YES; - if (GNUNET_OK != GNUNET_NETWORK_socket_bind(udp_sock, in, in_len)) - { - GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "bind", bindto); - GNUNET_NETWORK_socket_close(udp_sock); - udp_sock = NULL; - GNUNET_free(in); - GNUNET_free(bindto); - return; - } + if (GNUNET_OK != GNUNET_NETWORK_socket_bind (udp_sock, in, in_len)) + { + GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", bindto); + GNUNET_NETWORK_socket_close (udp_sock); + udp_sock = NULL; + GNUNET_free (in); + GNUNET_free (bindto); + return; + } /* We might have bound to port 0, allowing the OS to figure it out; thus, get the real IN-address from the socket */ sto_len = sizeof(in_sto); - if (0 != getsockname(GNUNET_NETWORK_get_fd(udp_sock), - (struct sockaddr *)&in_sto, - &sto_len)) - { - memcpy(&in_sto, in, in_len); - sto_len = in_len; - } - GNUNET_free(in); - GNUNET_free(bindto); - in = (struct sockaddr *)&in_sto; + if (0 != getsockname (GNUNET_NETWORK_get_fd (udp_sock), + (struct sockaddr *) &in_sto, + &sto_len)) + { + memcpy (&in_sto, in, in_len); + sto_len = in_len; + } + GNUNET_free (in); + GNUNET_free (bindto); + in = (struct sockaddr *) &in_sto; in_len = sto_len; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Bound to `%s'\n", - GNUNET_a2s((const struct sockaddr *)&in_sto, sto_len)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Bound to `%s'\n", + GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len)); switch (in->sa_family) - { - case AF_INET: - my_port = ntohs(((struct sockaddr_in *)in)->sin_port); - break; + { + case AF_INET: + my_port = ntohs (((struct sockaddr_in *) in)->sin_port); + break; - case AF_INET6: - my_port = ntohs(((struct sockaddr_in6 *)in)->sin6_port); - break; + case AF_INET6: + my_port = ntohs (((struct sockaddr_in6 *) in)->sin6_port); + break; - default: - GNUNET_break(0); - my_port = 0; - } - stats = GNUNET_STATISTICS_create("C-UDP", cfg); - senders = GNUNET_CONTAINER_multipeermap_create(32, GNUNET_YES); - receivers = GNUNET_CONTAINER_multipeermap_create(32, GNUNET_YES); - senders_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); + default: + GNUNET_break (0); + my_port = 0; + } + stats = GNUNET_STATISTICS_create ("C-UDP", cfg); + senders = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES); + receivers = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES); + senders_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); receivers_heap = - GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); - key_cache = GNUNET_CONTAINER_multishortmap_create(1024, GNUNET_YES); - GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); - is = GNUNET_NT_scanner_init(); - my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg); + GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); + key_cache = GNUNET_CONTAINER_multishortmap_create (1024, GNUNET_YES); + GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); + is = GNUNET_NT_scanner_init (); + my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg); if (NULL == my_private_key) - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - _( - "Transport service is lacking key configuration settings. Exiting.\n")); - GNUNET_SCHEDULER_shutdown(); - return; - } - GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key); + { + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + _ ( + "Transport service is lacking key configuration settings. Exiting.\n")); + GNUNET_SCHEDULER_shutdown (); + return; + } + GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key); /* start reading */ - read_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - udp_sock, - &sock_read, - NULL); - ch = GNUNET_TRANSPORT_communicator_connect(cfg, - COMMUNICATOR_CONFIG_SECTION, - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_TRANSPORT_CC_UNRELIABLE, - &mq_init, - NULL, - &enc_notify_cb, + read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + udp_sock, + &sock_read, NULL); + ch = GNUNET_TRANSPORT_communicator_connect (cfg, + COMMUNICATOR_CONFIG_SECTION, + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_TRANSPORT_CC_UNRELIABLE, + &mq_init, + NULL, + &enc_notify_cb, + NULL); if (NULL == ch) - { - GNUNET_break(0); - GNUNET_SCHEDULER_shutdown(); - return; - } - ah = GNUNET_TRANSPORT_application_init(cfg); + { + GNUNET_break (0); + GNUNET_SCHEDULER_shutdown (); + return; + } + ah = GNUNET_TRANSPORT_application_init (cfg); if (NULL == ah) - { - GNUNET_break(0); - GNUNET_SCHEDULER_shutdown(); - return; - } + { + GNUNET_break (0); + GNUNET_SCHEDULER_shutdown (); + return; + } /* start broadcasting */ if (GNUNET_YES != - GNUNET_CONFIGURATION_get_value_yesno(cfg, - COMMUNICATOR_CONFIG_SECTION, - "DISABLE_BROADCAST")) - { - broadcast_task = GNUNET_SCHEDULER_add_now(&do_broadcast, NULL); - } - nat = GNUNET_NAT_register(cfg, - COMMUNICATOR_CONFIG_SECTION, - IPPROTO_UDP, - 1 /* one address */, - (const struct sockaddr **)&in, - &in_len, - &nat_address_cb, - NULL /* FIXME: support reversal: #5529 */, - NULL /* closure */); + GNUNET_CONFIGURATION_get_value_yesno (cfg, + COMMUNICATOR_CONFIG_SECTION, + "DISABLE_BROADCAST")) + { + broadcast_task = GNUNET_SCHEDULER_add_now (&do_broadcast, NULL); + } + nat = GNUNET_NAT_register (cfg, + COMMUNICATOR_CONFIG_SECTION, + IPPROTO_UDP, + 1 /* one address */, + (const struct sockaddr **) &in, + &in_len, + &nat_address_cb, + NULL /* FIXME: support reversal: #5529 */, + NULL /* closure */); } @@ -2723,26 +2737,26 @@ run(void *cls, * @return 0 ok, 1 on error */ int -main(int argc, char *const *argv) +main (int argc, char *const *argv) { static const struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_OPTION_END }; int ret; - if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) + if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) return 2; - ret = (GNUNET_OK == GNUNET_PROGRAM_run(argc, - argv, - "gnunet-communicator-udp", - _("GNUnet UDP communicator"), - options, - &run, - NULL)) + ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc, + argv, + "gnunet-communicator-udp", + _ ("GNUnet UDP communicator"), + options, + &run, + NULL)) ? 0 : 1; - GNUNET_free((void *)argv); + GNUNET_free ((void *) argv); return ret; } diff --git a/src/transport/gnunet-communicator-unix.c b/src/transport/gnunet-communicator-unix.c index da610daa1..d8205addb 100644 --- a/src/transport/gnunet-communicator-unix.c +++ b/src/transport/gnunet-communicator-unix.c @@ -64,7 +64,8 @@ GNUNET_NETWORK_STRUCT_BEGIN /** * UNIX Message-Packet header. */ -struct UNIXMessage { +struct UNIXMessage +{ /** * Message header. */ @@ -82,7 +83,8 @@ GNUNET_NETWORK_STRUCT_END /** * Handle for a queue. */ -struct Queue { +struct Queue +{ /** * Queues with pending messages (!) are kept in a DLL. */ @@ -205,37 +207,37 @@ static struct GNUNET_TRANSPORT_AddressIdentifier *ai; * @param queue queue to close down */ static void -queue_destroy(struct Queue *queue) +queue_destroy (struct Queue *queue) { struct GNUNET_MQ_Handle *mq; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Disconnecting queue for peer `%s'\n", - GNUNET_i2s(&queue->target)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Disconnecting queue for peer `%s'\n", + GNUNET_i2s (&queue->target)); if (0 != queue->bytes_in_queue) - { - GNUNET_CONTAINER_DLL_remove(queue_head, queue_tail, queue); - queue->bytes_in_queue = 0; - } + { + GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue); + queue->bytes_in_queue = 0; + } if (NULL != (mq = queue->mq)) - { - queue->mq = NULL; - GNUNET_MQ_destroy(mq); - } - GNUNET_assert( + { + queue->mq = NULL; + GNUNET_MQ_destroy (mq); + } + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(queue_map, &queue->target, queue)); - GNUNET_STATISTICS_set(stats, - "# queues active", - GNUNET_CONTAINER_multipeermap_size(queue_map), - GNUNET_NO); + GNUNET_CONTAINER_multipeermap_remove (queue_map, &queue->target, queue)); + GNUNET_STATISTICS_set (stats, + "# queues active", + GNUNET_CONTAINER_multipeermap_size (queue_map), + GNUNET_NO); if (NULL != queue->timeout_task) - { - GNUNET_SCHEDULER_cancel(queue->timeout_task); - queue->timeout_task = NULL; - } - GNUNET_free(queue->address); - GNUNET_free(queue); + { + GNUNET_SCHEDULER_cancel (queue->timeout_task); + queue->timeout_task = NULL; + } + GNUNET_free (queue->address); + GNUNET_free (queue); } @@ -245,28 +247,28 @@ queue_destroy(struct Queue *queue) * @param cls the `struct Queue *` to disconnect */ static void -queue_timeout(void *cls) +queue_timeout (void *cls) { struct Queue *queue = cls; struct GNUNET_TIME_Relative left; queue->timeout_task = NULL; - left = GNUNET_TIME_absolute_get_remaining(queue->timeout); + left = GNUNET_TIME_absolute_get_remaining (queue->timeout); if (0 != left.rel_value_us) - { - /* not actually our turn yet, but let's at least update - the monitor, it may think we're about to die ... */ - queue->timeout_task = - GNUNET_SCHEDULER_add_delayed(left, &queue_timeout, queue); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Queue %p was idle for %s, disconnecting\n", - queue, - GNUNET_STRINGS_relative_time_to_string( - GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - GNUNET_YES)); - queue_destroy(queue); + { + /* not actually our turn yet, but let's at least update + the monitor, it may think we're about to die ... */ + queue->timeout_task = + GNUNET_SCHEDULER_add_delayed (left, &queue_timeout, queue); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Queue %p was idle for %s, disconnecting\n", + queue, + GNUNET_STRINGS_relative_time_to_string ( + GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, + GNUNET_YES)); + queue_destroy (queue); } @@ -278,11 +280,11 @@ queue_timeout(void *cls) * @param queue queue for which the timeout should be rescheduled */ static void -reschedule_queue_timeout(struct Queue *queue) +reschedule_queue_timeout (struct Queue *queue) { - GNUNET_assert(NULL != queue->timeout_task); + GNUNET_assert (NULL != queue->timeout_task); queue->timeout = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); } @@ -295,22 +297,22 @@ reschedule_queue_timeout(struct Queue *queue) * @return converted unix path */ static struct sockaddr_un * -unix_address_to_sockaddr(const char *unixpath, socklen_t *sock_len) +unix_address_to_sockaddr (const char *unixpath, socklen_t *sock_len) { struct sockaddr_un *un; size_t slen; - GNUNET_assert(0 < strlen(unixpath)); /* sanity check */ - un = GNUNET_new(struct sockaddr_un); + GNUNET_assert (0 < strlen (unixpath)); /* sanity check */ + un = GNUNET_new (struct sockaddr_un); un->sun_family = AF_UNIX; - slen = strlen(unixpath); + slen = strlen (unixpath); if (slen >= sizeof(un->sun_path)) slen = sizeof(un->sun_path) - 1; - GNUNET_memcpy(un->sun_path, unixpath, slen); + GNUNET_memcpy (un->sun_path, unixpath, slen); un->sun_path[slen] = '\0'; slen = sizeof(struct sockaddr_un); #if HAVE_SOCKADDR_UN_SUN_LEN - un->sun_len = (u_char)slen; + un->sun_len = (u_char) slen; #endif (*sock_len) = slen; if ('@' == un->sun_path[0]) @@ -322,7 +324,8 @@ unix_address_to_sockaddr(const char *unixpath, socklen_t *sock_len) /** * Closure to #lookup_queue_it(). */ -struct LookupCtx { +struct LookupCtx +{ /** * Location to store the queue, if found. */ @@ -349,17 +352,17 @@ struct LookupCtx { * @return #GNUNET_YES if not found (continue looking), #GNUNET_NO on success */ static int -lookup_queue_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value) +lookup_queue_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value) { struct LookupCtx *lctx = cls; struct Queue *queue = value; if ((queue->address_len = lctx->un_len) && - (0 == memcmp(lctx->un, queue->address, queue->address_len))) - { - lctx->res = queue; - return GNUNET_NO; - } + (0 == memcmp (lctx->un, queue->address, queue->address_len))) + { + lctx->res = queue; + return GNUNET_NO; + } return GNUNET_YES; } @@ -372,18 +375,18 @@ lookup_queue_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value) * @return NULL if queue was not found */ static struct Queue * -lookup_queue(const struct GNUNET_PeerIdentity *peer, - const struct sockaddr_un *un, - socklen_t un_len) +lookup_queue (const struct GNUNET_PeerIdentity *peer, + const struct sockaddr_un *un, + socklen_t un_len) { struct LookupCtx lctx; lctx.un = un; lctx.un_len = un_len; - GNUNET_CONTAINER_multipeermap_get_multiple(queue_map, - peer, - &lookup_queue_it, - &lctx); + GNUNET_CONTAINER_multipeermap_get_multiple (queue_map, + peer, + &lookup_queue_it, + &lctx); return lctx.res; } @@ -395,105 +398,105 @@ lookup_queue(const struct GNUNET_PeerIdentity *peer, * @param cls NULL */ static void -select_write_cb(void *cls) +select_write_cb (void *cls) { struct Queue *queue = queue_tail; const struct GNUNET_MessageHeader *msg = queue->msg; - size_t msg_size = ntohs(msg->size); + size_t msg_size = ntohs (msg->size); ssize_t sent; /* take queue of the ready list */ write_task = NULL; - GNUNET_CONTAINER_DLL_remove(queue_head, queue_tail, queue); + GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue); if (NULL != queue_head) - write_task = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, - unix_sock, - &select_write_cb, - NULL); + write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + unix_sock, + &select_write_cb, + NULL); /* send 'msg' */ queue->msg = NULL; - GNUNET_MQ_impl_send_continue(queue->mq); + GNUNET_MQ_impl_send_continue (queue->mq); resend: /* Send the data */ - sent = GNUNET_NETWORK_socket_sendto(unix_sock, - msg, - msg_size, - (const struct sockaddr *)queue->address, - queue->address_len); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "UNIX transmitted message to %s (%d/%u: %s)\n", - GNUNET_i2s(&queue->target), - (int)sent, - (unsigned int)msg_size, - (sent < 0) ? strerror(errno) : "ok"); + sent = GNUNET_NETWORK_socket_sendto (unix_sock, + msg, + msg_size, + (const struct sockaddr *) queue->address, + queue->address_len); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "UNIX transmitted message to %s (%d/%u: %s)\n", + GNUNET_i2s (&queue->target), + (int) sent, + (unsigned int) msg_size, + (sent < 0) ? strerror (errno) : "ok"); if (-1 != sent) - { - GNUNET_STATISTICS_update(stats, - "# bytes sent", - (long long)sent, - GNUNET_NO); - reschedule_queue_timeout(queue); - return; /* all good */ - } - GNUNET_STATISTICS_update(stats, - "# network transmission failures", - 1, - GNUNET_NO); + { + GNUNET_STATISTICS_update (stats, + "# bytes sent", + (long long) sent, + GNUNET_NO); + reschedule_queue_timeout (queue); + return; /* all good */ + } + GNUNET_STATISTICS_update (stats, + "# network transmission failures", + 1, + GNUNET_NO); switch (errno) - { - case EAGAIN: - case ENOBUFS: - /* We should retry later... */ - GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "send"); - return; + { + case EAGAIN: + case ENOBUFS: + /* We should retry later... */ + GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send"); + return; - case EMSGSIZE: { + case EMSGSIZE: { socklen_t size = 0; socklen_t len = sizeof(size); - GNUNET_NETWORK_socket_getsockopt(unix_sock, - SOL_SOCKET, - SO_SNDBUF, - &size, - &len); - if (size > ntohs(msg->size)) - { - /* Buffer is bigger than message: error, no retry - * This should never happen!*/ - GNUNET_break(0); - return; - } - GNUNET_log( + GNUNET_NETWORK_socket_getsockopt (unix_sock, + SOL_SOCKET, + SO_SNDBUF, + &size, + &len); + if (size > ntohs (msg->size)) + { + /* Buffer is bigger than message: error, no retry + * This should never happen!*/ + GNUNET_break (0); + return; + } + GNUNET_log ( GNUNET_ERROR_TYPE_DEBUG, "Trying to increase socket buffer size from %u to %u for message size %u\n", - (unsigned int)size, - (unsigned int)((msg_size / 1000) + 2) * 1000, - (unsigned int)msg_size); + (unsigned int) size, + (unsigned int) ((msg_size / 1000) + 2) * 1000, + (unsigned int) msg_size); size = ((msg_size / 1000) + 2) * 1000; - if (GNUNET_OK == GNUNET_NETWORK_socket_setsockopt(unix_sock, - SOL_SOCKET, - SO_SNDBUF, - &size, - sizeof(size))) + if (GNUNET_OK == GNUNET_NETWORK_socket_setsockopt (unix_sock, + SOL_SOCKET, + SO_SNDBUF, + &size, + sizeof(size))) goto resend; /* Increased buffer size, retry sending */ /* Ok, then just try very modest increase */ size = msg_size; - if (GNUNET_OK == GNUNET_NETWORK_socket_setsockopt(unix_sock, - SOL_SOCKET, - SO_SNDBUF, - &size, - sizeof(size))) + if (GNUNET_OK == GNUNET_NETWORK_socket_setsockopt (unix_sock, + SOL_SOCKET, + SO_SNDBUF, + &size, + sizeof(size))) goto resend; /* Increased buffer size, retry sending */ /* Could not increase buffer size: error, no retry */ - GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "setsockopt"); + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt"); return; } - default: - GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "send"); - return; - } + default: + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "send"); + return; + } } @@ -506,22 +509,22 @@ resend: * @param impl_state our `struct Queue` */ static void -mq_send(struct GNUNET_MQ_Handle *mq, - const struct GNUNET_MessageHeader *msg, - void *impl_state) +mq_send (struct GNUNET_MQ_Handle *mq, + const struct GNUNET_MessageHeader *msg, + void *impl_state) { struct Queue *queue = impl_state; - GNUNET_assert(mq == queue->mq); - GNUNET_assert(NULL == queue->msg); + GNUNET_assert (mq == queue->mq); + GNUNET_assert (NULL == queue->msg); queue->msg = msg; - GNUNET_CONTAINER_DLL_insert(queue_head, queue_tail, queue); - GNUNET_assert(NULL != unix_sock); + GNUNET_CONTAINER_DLL_insert (queue_head, queue_tail, queue); + GNUNET_assert (NULL != unix_sock); if (NULL == write_task) - write_task = GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, - unix_sock, - &select_write_cb, - NULL); + write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, + unix_sock, + &select_write_cb, + NULL); } @@ -534,15 +537,15 @@ mq_send(struct GNUNET_MQ_Handle *mq, * @param impl_state our `struct Queue` */ static void -mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state) +mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state) { struct Queue *queue = impl_state; if (mq == queue->mq) - { - queue->mq = NULL; - queue_destroy(queue); - } + { + queue->mq = NULL; + queue_destroy (queue); + } } @@ -553,19 +556,19 @@ mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state) * @param impl_state our `struct Queue` */ static void -mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) +mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state) { struct Queue *queue = impl_state; - GNUNET_assert(NULL != queue->msg); + GNUNET_assert (NULL != queue->msg); queue->msg = NULL; - GNUNET_CONTAINER_DLL_remove(queue_head, queue_tail, queue); - GNUNET_assert(NULL != write_task); + GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue); + GNUNET_assert (NULL != write_task); if (NULL == queue_head) - { - GNUNET_SCHEDULER_cancel(write_task); - write_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (write_task); + write_task = NULL; + } } @@ -579,15 +582,15 @@ mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) * @param error error code */ static void -mq_error(void *cls, enum GNUNET_MQ_Error error) +mq_error (void *cls, enum GNUNET_MQ_Error error) { struct Queue *queue = cls; - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "UNIX MQ error in queue to %s: %d\n", - GNUNET_i2s(&queue->target), - (int)error); - queue_destroy(queue); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "UNIX MQ error in queue to %s: %d\n", + GNUNET_i2s (&queue->target), + (int) error); + queue_destroy (queue); } @@ -602,60 +605,60 @@ mq_error(void *cls, enum GNUNET_MQ_Error error) * @return the queue or NULL of max connections exceeded */ static struct Queue * -setup_queue(const struct GNUNET_PeerIdentity *target, - enum GNUNET_TRANSPORT_ConnectionStatus cs, - const struct sockaddr_un *un, - socklen_t un_len) +setup_queue (const struct GNUNET_PeerIdentity *target, + enum GNUNET_TRANSPORT_ConnectionStatus cs, + const struct sockaddr_un *un, + socklen_t un_len) { struct Queue *queue; - queue = GNUNET_new(struct Queue); + queue = GNUNET_new (struct Queue); queue->target = *target; - queue->address = GNUNET_memdup(un, un_len); + queue->address = GNUNET_memdup (un, un_len); queue->address_len = un_len; - (void)GNUNET_CONTAINER_multipeermap_put( + (void) GNUNET_CONTAINER_multipeermap_put ( queue_map, &queue->target, queue, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); - GNUNET_STATISTICS_set(stats, - "# queues active", - GNUNET_CONTAINER_multipeermap_size(queue_map), - GNUNET_NO); + GNUNET_STATISTICS_set (stats, + "# queues active", + GNUNET_CONTAINER_multipeermap_size (queue_map), + GNUNET_NO); queue->timeout = - GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); + GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); queue->timeout_task = - GNUNET_SCHEDULER_add_delayed(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, - &queue_timeout, - queue); - queue->mq = GNUNET_MQ_queue_for_callbacks(&mq_send, - &mq_destroy, - &mq_cancel, - queue, - NULL, - &mq_error, - queue); + GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, + &queue_timeout, + queue); + queue->mq = GNUNET_MQ_queue_for_callbacks (&mq_send, + &mq_destroy, + &mq_cancel, + queue, + NULL, + &mq_error, + queue); { char *foreign_addr; if ('\0' == un->sun_path[0]) - GNUNET_asprintf(&foreign_addr, - "%s-@%s", - COMMUNICATOR_ADDRESS_PREFIX, - &un->sun_path[1]); + GNUNET_asprintf (&foreign_addr, + "%s-@%s", + COMMUNICATOR_ADDRESS_PREFIX, + &un->sun_path[1]); else - GNUNET_asprintf(&foreign_addr, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - un->sun_path); - queue->qh = GNUNET_TRANSPORT_communicator_mq_add(ch, - &queue->target, - foreign_addr, - UNIX_MTU, - GNUNET_NT_LOOPBACK, - cs, - queue->mq); - GNUNET_free(foreign_addr); + GNUNET_asprintf (&foreign_addr, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + un->sun_path); + queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, + &queue->target, + foreign_addr, + UNIX_MTU, + GNUNET_NT_LOOPBACK, + cs, + queue->mq); + GNUNET_free (foreign_addr); } return queue; } @@ -669,7 +672,7 @@ setup_queue(const struct GNUNET_PeerIdentity *target, * @param cls NULL */ static void -select_read_cb(void *cls); +select_read_cb (void *cls); /** @@ -680,21 +683,21 @@ select_read_cb(void *cls); * @param success #GNUNET_OK on success */ static void -receive_complete_cb(void *cls, int success) +receive_complete_cb (void *cls, int success) { - (void)cls; + (void) cls; delivering_messages--; if (GNUNET_OK != success) - GNUNET_STATISTICS_update(stats, - "# transport transmission failures", - 1, - GNUNET_NO); - GNUNET_assert(NULL != unix_sock); + GNUNET_STATISTICS_update (stats, + "# transport transmission failures", + 1, + GNUNET_NO); + GNUNET_assert (NULL != unix_sock); if ((NULL == read_task) && (delivering_messages < max_queue_length)) - read_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - unix_sock, - &select_read_cb, - NULL); + read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + unix_sock, + &select_read_cb, + NULL); } @@ -706,7 +709,7 @@ receive_complete_cb(void *cls, int success) * @param cls NULL */ static void -select_read_cb(void *cls) +select_read_cb (void *cls) { char buf[65536] GNUNET_ALIGN; struct Queue *queue; @@ -716,93 +719,93 @@ select_read_cb(void *cls) ssize_t ret; uint16_t msize; - GNUNET_assert(NULL != unix_sock); - read_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - unix_sock, - &select_read_cb, - NULL); + GNUNET_assert (NULL != unix_sock); + read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + unix_sock, + &select_read_cb, + NULL); addrlen = sizeof(un); - memset(&un, 0, sizeof(un)); - ret = GNUNET_NETWORK_socket_recvfrom(unix_sock, - buf, - sizeof(buf), - (struct sockaddr *)&un, - &addrlen); + memset (&un, 0, sizeof(un)); + ret = GNUNET_NETWORK_socket_recvfrom (unix_sock, + buf, + sizeof(buf), + (struct sockaddr *) &un, + &addrlen); if ((-1 == ret) && ((EAGAIN == errno) || (ENOBUFS == errno))) return; if (-1 == ret) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "recvfrom"); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Read %d bytes from socket %s\n", - (int)ret, - un.sun_path); - GNUNET_assert(AF_UNIX == (un.sun_family)); - msg = (struct UNIXMessage *)buf; - msize = ntohs(msg->header.size); + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom"); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Read %d bytes from socket %s\n", + (int) ret, + un.sun_path); + GNUNET_assert (AF_UNIX == (un.sun_family)); + msg = (struct UNIXMessage *) buf; + msize = ntohs (msg->header.size); if ((msize < sizeof(struct UNIXMessage)) || (msize > ret)) - { - GNUNET_break_op(0); - return; - } - queue = lookup_queue(&msg->sender, &un, addrlen); + { + GNUNET_break_op (0); + return; + } + queue = lookup_queue (&msg->sender, &un, addrlen); if (NULL == queue) queue = - setup_queue(&msg->sender, GNUNET_TRANSPORT_CS_INBOUND, &un, addrlen); + setup_queue (&msg->sender, GNUNET_TRANSPORT_CS_INBOUND, &un, addrlen); else - reschedule_queue_timeout(queue); + reschedule_queue_timeout (queue); if (NULL == queue) - { - GNUNET_log( - GNUNET_ERROR_TYPE_ERROR, - _( - "Maximum number of UNIX connections exceeded, dropping incoming message\n")); - return; - } + { + GNUNET_log ( + GNUNET_ERROR_TYPE_ERROR, + _ ( + "Maximum number of UNIX connections exceeded, dropping incoming message\n")); + return; + } { uint16_t offset = 0; uint16_t tsize = msize - sizeof(struct UNIXMessage); - const char *msgbuf = (const char *)&msg[1]; + const char *msgbuf = (const char *) &msg[1]; while (offset + sizeof(struct GNUNET_MessageHeader) <= tsize) + { + const struct GNUNET_MessageHeader *currhdr; + struct GNUNET_MessageHeader al_hdr; + uint16_t csize; + + currhdr = (const struct GNUNET_MessageHeader *) &msgbuf[offset]; + /* ensure aligned access */ + memcpy (&al_hdr, currhdr, sizeof(al_hdr)); + csize = ntohs (al_hdr.size); + if ((csize < sizeof(struct GNUNET_MessageHeader)) || + (csize > tsize - offset)) { - const struct GNUNET_MessageHeader *currhdr; - struct GNUNET_MessageHeader al_hdr; - uint16_t csize; - - currhdr = (const struct GNUNET_MessageHeader *)&msgbuf[offset]; - /* ensure aligned access */ - memcpy(&al_hdr, currhdr, sizeof(al_hdr)); - csize = ntohs(al_hdr.size); - if ((csize < sizeof(struct GNUNET_MessageHeader)) || - (csize > tsize - offset)) - { - GNUNET_break_op(0); - break; - } - ret = GNUNET_TRANSPORT_communicator_receive(ch, - &msg->sender, - currhdr, - GNUNET_TIME_UNIT_FOREVER_REL, - &receive_complete_cb, - NULL); - if (GNUNET_SYSERR == ret) - return; /* transport not up */ - if (GNUNET_NO == ret) - break; - delivering_messages++; - offset += csize; + GNUNET_break_op (0); + break; } + ret = GNUNET_TRANSPORT_communicator_receive (ch, + &msg->sender, + currhdr, + GNUNET_TIME_UNIT_FOREVER_REL, + &receive_complete_cb, + NULL); + if (GNUNET_SYSERR == ret) + return; /* transport not up */ + if (GNUNET_NO == ret) + break; + delivering_messages++; + offset += csize; + } } if (delivering_messages >= max_queue_length) - { - /* we should try to apply 'back pressure' */ - GNUNET_SCHEDULER_cancel(read_task); - read_task = NULL; - } + { + /* we should try to apply 'back pressure' */ + GNUNET_SCHEDULER_cancel (read_task); + read_task = NULL; + } } @@ -824,43 +827,43 @@ select_read_cb(void *cls) * @return #GNUNET_OK on success, #GNUNET_SYSERR if the provided address is invalid */ static int -mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) +mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) { struct Queue *queue; const char *path; struct sockaddr_un *un; socklen_t un_len; - (void)cls; - if (0 != strncmp(address, - COMMUNICATOR_ADDRESS_PREFIX "-", - strlen(COMMUNICATOR_ADDRESS_PREFIX "-"))) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } - path = &address[strlen(COMMUNICATOR_ADDRESS_PREFIX "-")]; - un = unix_address_to_sockaddr(path, &un_len); - queue = lookup_queue(peer, un, un_len); + (void) cls; + if (0 != strncmp (address, + COMMUNICATOR_ADDRESS_PREFIX "-", + strlen (COMMUNICATOR_ADDRESS_PREFIX "-"))) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")]; + un = unix_address_to_sockaddr (path, &un_len); + queue = lookup_queue (peer, un, un_len); if (NULL != queue) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Address `%s' for %s ignored, queue exists\n", - path, - GNUNET_i2s(peer)); - GNUNET_free(un); - return GNUNET_OK; - } - queue = setup_queue(peer, GNUNET_TRANSPORT_CS_OUTBOUND, un, un_len); - GNUNET_free(un); + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Address `%s' for %s ignored, queue exists\n", + path, + GNUNET_i2s (peer)); + GNUNET_free (un); + return GNUNET_OK; + } + queue = setup_queue (peer, GNUNET_TRANSPORT_CS_OUTBOUND, un, un_len); + GNUNET_free (un); if (NULL == queue) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Failed to setup queue to %s at `%s'\n", - GNUNET_i2s(peer), - path); - return GNUNET_NO; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Failed to setup queue to %s at `%s'\n", + GNUNET_i2s (peer), + path); + return GNUNET_NO; + } return GNUNET_OK; } @@ -874,15 +877,15 @@ mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) * @return #GNUNET_OK to continue to iterate */ static int -get_queue_delete_it(void *cls, - const struct GNUNET_PeerIdentity *target, - void *value) +get_queue_delete_it (void *cls, + const struct GNUNET_PeerIdentity *target, + void *value) { struct Queue *queue = value; - (void)cls; - (void)target; - queue_destroy(queue); + (void) cls; + (void) target; + queue_destroy (queue); return GNUNET_OK; } @@ -893,40 +896,40 @@ get_queue_delete_it(void *cls, * @param cls NULL (always) */ static void -do_shutdown(void *cls) +do_shutdown (void *cls) { if (NULL != read_task) - { - GNUNET_SCHEDULER_cancel(read_task); - read_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (read_task); + read_task = NULL; + } if (NULL != write_task) - { - GNUNET_SCHEDULER_cancel(write_task); - write_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (write_task); + write_task = NULL; + } if (NULL != unix_sock) - { - GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(unix_sock)); - unix_sock = NULL; - } - GNUNET_CONTAINER_multipeermap_iterate(queue_map, &get_queue_delete_it, NULL); - GNUNET_CONTAINER_multipeermap_destroy(queue_map); + { + GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (unix_sock)); + unix_sock = NULL; + } + GNUNET_CONTAINER_multipeermap_iterate (queue_map, &get_queue_delete_it, NULL); + GNUNET_CONTAINER_multipeermap_destroy (queue_map); if (NULL != ai) - { - GNUNET_TRANSPORT_communicator_address_remove(ai); - ai = NULL; - } + { + GNUNET_TRANSPORT_communicator_address_remove (ai); + ai = NULL; + } if (NULL != ch) - { - GNUNET_TRANSPORT_communicator_disconnect(ch); - ch = NULL; - } + { + GNUNET_TRANSPORT_communicator_disconnect (ch); + ch = NULL; + } if (NULL != stats) - { - GNUNET_STATISTICS_destroy(stats, GNUNET_NO); - stats = NULL; - } + { + GNUNET_STATISTICS_destroy (stats, GNUNET_NO); + stats = NULL; + } } @@ -942,14 +945,14 @@ do_shutdown(void *cls) * @param msg payload */ static void -enc_notify_cb(void *cls, - const struct GNUNET_PeerIdentity *sender, - const struct GNUNET_MessageHeader *msg) +enc_notify_cb (void *cls, + const struct GNUNET_PeerIdentity *sender, + const struct GNUNET_MessageHeader *msg) { - (void)cls; - (void)sender; - (void)msg; - GNUNET_break_op(0); + (void) cls; + (void) sender; + (void) msg; + GNUNET_break_op (0); } @@ -962,110 +965,110 @@ enc_notify_cb(void *cls, * @param cfg configuration */ static void -run(void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) +run (void *cls, + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *cfg) { char *unix_socket_path; struct sockaddr_un *un; socklen_t un_len; char *my_addr; - (void)cls; + (void) cls; if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_filename(cfg, - COMMUNICATOR_CONFIG_SECTION, - "UNIXPATH", - &unix_socket_path)) - { - GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, - COMMUNICATOR_CONFIG_SECTION, - "UNIXPATH"); - return; - } + GNUNET_CONFIGURATION_get_value_filename (cfg, + COMMUNICATOR_CONFIG_SECTION, + "UNIXPATH", + &unix_socket_path)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, + COMMUNICATOR_CONFIG_SECTION, + "UNIXPATH"); + return; + } if (GNUNET_OK != - GNUNET_CONFIGURATION_get_value_number(cfg, - COMMUNICATOR_CONFIG_SECTION, - "MAX_QUEUE_LENGTH", - &max_queue_length)) + GNUNET_CONFIGURATION_get_value_number (cfg, + COMMUNICATOR_CONFIG_SECTION, + "MAX_QUEUE_LENGTH", + &max_queue_length)) max_queue_length = DEFAULT_MAX_QUEUE_LENGTH; - un = unix_address_to_sockaddr(unix_socket_path, &un_len); + un = unix_address_to_sockaddr (unix_socket_path, &un_len); if (NULL == un) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Failed to setup UNIX domain socket address with path `%s'\n", - unix_socket_path); - GNUNET_free(unix_socket_path); - return; - } - unix_sock = GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_DGRAM, 0); + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to setup UNIX domain socket address with path `%s'\n", + unix_socket_path); + GNUNET_free (unix_socket_path); + return; + } + unix_sock = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0); if (NULL == unix_sock) - { - GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "socket"); - GNUNET_free(un); - GNUNET_free(unix_socket_path); - return; - } + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket"); + GNUNET_free (un); + GNUNET_free (unix_socket_path); + return; + } if (('\0' != un->sun_path[0]) && - (GNUNET_OK != GNUNET_DISK_directory_create_for_file(un->sun_path))) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - _("Cannot create path to `%s'\n"), - un->sun_path); - GNUNET_NETWORK_socket_close(unix_sock); - unix_sock = NULL; - GNUNET_free(un); - GNUNET_free(unix_socket_path); - return; - } - if (GNUNET_OK != GNUNET_NETWORK_socket_bind(unix_sock, - (const struct sockaddr *)un, - un_len)) - { - GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "bind", un->sun_path); - GNUNET_NETWORK_socket_close(unix_sock); - unix_sock = NULL; - GNUNET_free(un); - GNUNET_free(unix_socket_path); - return; - } - GNUNET_free(un); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", unix_socket_path); - stats = GNUNET_STATISTICS_create("C-UNIX", cfg); - GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); - read_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, - unix_sock, - &select_read_cb, - NULL); - queue_map = GNUNET_CONTAINER_multipeermap_create(10, GNUNET_NO); - ch = GNUNET_TRANSPORT_communicator_connect(cfg, - COMMUNICATOR_CONFIG_SECTION, - COMMUNICATOR_ADDRESS_PREFIX, - GNUNET_TRANSPORT_CC_RELIABLE, - &mq_init, - NULL, - &enc_notify_cb, + (GNUNET_OK != GNUNET_DISK_directory_create_for_file (un->sun_path))) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + _ ("Cannot create path to `%s'\n"), + un->sun_path); + GNUNET_NETWORK_socket_close (unix_sock); + unix_sock = NULL; + GNUNET_free (un); + GNUNET_free (unix_socket_path); + return; + } + if (GNUNET_OK != GNUNET_NETWORK_socket_bind (unix_sock, + (const struct sockaddr *) un, + un_len)) + { + GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", un->sun_path); + GNUNET_NETWORK_socket_close (unix_sock); + unix_sock = NULL; + GNUNET_free (un); + GNUNET_free (unix_socket_path); + return; + } + GNUNET_free (un); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", unix_socket_path); + stats = GNUNET_STATISTICS_create ("C-UNIX", cfg); + GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); + read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, + unix_sock, + &select_read_cb, NULL); + queue_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); + ch = GNUNET_TRANSPORT_communicator_connect (cfg, + COMMUNICATOR_CONFIG_SECTION, + COMMUNICATOR_ADDRESS_PREFIX, + GNUNET_TRANSPORT_CC_RELIABLE, + &mq_init, + NULL, + &enc_notify_cb, + NULL); if (NULL == ch) - { - GNUNET_break(0); - GNUNET_SCHEDULER_shutdown(); - GNUNET_free(unix_socket_path); - return; - } - GNUNET_asprintf(&my_addr, - "%s-%s", - COMMUNICATOR_ADDRESS_PREFIX, - unix_socket_path); - GNUNET_free(unix_socket_path); - ai = GNUNET_TRANSPORT_communicator_address_add(ch, - my_addr, - GNUNET_NT_LOOPBACK, - GNUNET_TIME_UNIT_FOREVER_REL); - GNUNET_free(my_addr); + { + GNUNET_break (0); + GNUNET_SCHEDULER_shutdown (); + GNUNET_free (unix_socket_path); + return; + } + GNUNET_asprintf (&my_addr, + "%s-%s", + COMMUNICATOR_ADDRESS_PREFIX, + unix_socket_path); + GNUNET_free (unix_socket_path); + ai = GNUNET_TRANSPORT_communicator_address_add (ch, + my_addr, + GNUNET_NT_LOOPBACK, + GNUNET_TIME_UNIT_FOREVER_REL); + GNUNET_free (my_addr); } @@ -1077,27 +1080,27 @@ run(void *cls, * @return 0 ok, 1 on error */ int -main(int argc, char *const *argv) +main (int argc, char *const *argv) { static const struct GNUNET_GETOPT_CommandLineOption options[] = { GNUNET_GETOPT_OPTION_END }; int ret; - if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) + if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) return 2; ret = (GNUNET_OK == - GNUNET_PROGRAM_run(argc, - argv, - "gnunet-communicator-unix", - _("GNUnet UNIX domain socket communicator"), - options, - &run, - NULL)) + GNUNET_PROGRAM_run (argc, + argv, + "gnunet-communicator-unix", + _ ("GNUnet UNIX domain socket communicator"), + options, + &run, + NULL)) ? 0 : 1; - GNUNET_free((void *)argv); + GNUNET_free ((void *) argv); return ret; } @@ -1108,11 +1111,11 @@ main(int argc, char *const *argv) /** * MINIMIZE heap size (way below 128k) since this process doesn't need much. */ -void __attribute__ ((constructor)) GNUNET_ARM_memory_init() +void __attribute__ ((constructor)) GNUNET_ARM_memory_init () { - mallopt(M_TRIM_THRESHOLD, 4 * 1024); - mallopt(M_TOP_PAD, 1 * 1024); - malloc_trim(0); + mallopt (M_TRIM_THRESHOLD, 4 * 1024); + mallopt (M_TOP_PAD, 1 * 1024); + malloc_trim (0); } #endif diff --git a/src/transport/gnunet-helper-transport-bluetooth.c b/src/transport/gnunet-helper-transport-bluetooth.c index 4696f48f8..c0e0d9673 100644 --- a/src/transport/gnunet-helper-transport-bluetooth.c +++ b/src/transport/gnunet-helper-transport-bluetooth.c @@ -69,7 +69,8 @@ * struct for storing the information of the hardware. There is only * one of these. */ -struct HardwareInfos { +struct HardwareInfos +{ /** * Name of the interface, not necessarily 0-terminated (!). */ @@ -94,7 +95,8 @@ struct HardwareInfos { /** * IO buffer used for buffering data in transit (to wireless or to stdout). */ -struct SendBuffer { +struct SendBuffer +{ /** * How many bytes of data are stored in 'buf' for transmission right now? * Data always starts at offset 0 and extends to 'size'. @@ -119,7 +121,8 @@ struct SendBuffer { * Devices buffer used to keep a list with all the discoverable devices in * order to send them HELLO messages one by one when it receive a broadcast message. */ -struct BroadcastMessages { +struct BroadcastMessages +{ /* List with the discoverable devices' addresses */ bdaddr_t devices[MAX_PORTS]; @@ -140,7 +143,10 @@ struct BroadcastMessages { /** * Address used to identify the broadcast messages. */ -static struct GNUNET_TRANSPORT_WLAN_MacAddress broadcast_address = { { 255, 255, 255, 255, 255, 255 } }; +static struct GNUNET_TRANSPORT_WLAN_MacAddress broadcast_address = { { 255, 255, + 255, 255, + 255, + 255 } }; /** * Buffer with the discoverable devices. @@ -190,7 +196,8 @@ typedef void (*MessageTokenizerCallback) (void *cls, /** * Handle to a message stream tokenizer. */ -struct MessageStreamTokenizer { +struct MessageStreamTokenizer +{ /** * Function to call on completed messages. */ @@ -231,23 +238,23 @@ struct MessageStreamTokenizer { * @return handle to tokenizer */ static struct MessageStreamTokenizer * -mst_create(MessageTokenizerCallback cb, - void *cb_cls) +mst_create (MessageTokenizerCallback cb, + void *cb_cls) { struct MessageStreamTokenizer *ret; - ret = malloc(sizeof(struct MessageStreamTokenizer)); + ret = malloc (sizeof(struct MessageStreamTokenizer)); if (NULL == ret) - { - fprintf(stderr, "Failed to allocate buffer for tokenizer\n"); - exit(1); - } - ret->hdr = malloc(MIN_BUFFER_SIZE); + { + fprintf (stderr, "Failed to allocate buffer for tokenizer\n"); + exit (1); + } + ret->hdr = malloc (MIN_BUFFER_SIZE); if (NULL == ret->hdr) - { - fprintf(stderr, "Failed to allocate buffer for alignment\n"); - exit(1); - } + { + fprintf (stderr, "Failed to allocate buffer for alignment\n"); + exit (1); + } ret->curr_buf = MIN_BUFFER_SIZE; ret->cb = cb; ret->cb_cls = cb_cls; @@ -268,8 +275,8 @@ mst_create(MessageTokenizerCallback cb, * GNUNET_SYSERR if the data stream is corrupt */ static int -mst_receive(struct MessageStreamTokenizer *mst, - const char *buf, size_t size) +mst_receive (struct MessageStreamTokenizer *mst, + const char *buf, size_t size) { const struct GNUNET_MessageHeader *hdr; size_t delta; @@ -280,161 +287,162 @@ mst_receive(struct MessageStreamTokenizer *mst, int ret; ret = GNUNET_OK; - ibuf = (char *)mst->hdr; + ibuf = (char *) mst->hdr; while (mst->pos > 0) - { + { do_align: - if (mst->pos < mst->off) - { - //fprintf (stderr, "We processed too many bytes!\n"); - return GNUNET_SYSERR; - } - if ((mst->curr_buf - mst->off < sizeof(struct GNUNET_MessageHeader)) || - (0 != (mst->off % ALIGN_FACTOR))) - { - /* need to align or need more space */ - mst->pos -= mst->off; - memmove(ibuf, &ibuf[mst->off], mst->pos); - mst->off = 0; - } - if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader)) - { - delta = - GNUNET_MIN(sizeof(struct GNUNET_MessageHeader) - - (mst->pos - mst->off), size); - GNUNET_memcpy(&ibuf[mst->pos], buf, delta); - mst->pos += delta; - buf += delta; - size -= delta; - } - if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader)) - { - //FIXME should I reset ?? - // mst->off = 0; - // mst->pos = 0; - return GNUNET_OK; - } - hdr = (const struct GNUNET_MessageHeader *)&ibuf[mst->off]; - want = ntohs(hdr->size); - if (want < sizeof(struct GNUNET_MessageHeader)) - { - fprintf(stderr, - "Received invalid message from stdin\n"); - return GNUNET_SYSERR; - } - if ((mst->curr_buf - mst->off < want) && - (mst->off > 0)) - { - /* need more space */ - mst->pos -= mst->off; - memmove(ibuf, &ibuf[mst->off], mst->pos); - mst->off = 0; - } - if (want > mst->curr_buf) - { - if (mst->off != 0) - { - fprintf(stderr, "Error! We should proceeded 0 bytes\n"); - return GNUNET_SYSERR; - } - mst->hdr = realloc(mst->hdr, want); - if (NULL == mst->hdr) - { - fprintf(stderr, "Failed to allocate buffer for alignment\n"); - exit(1); - } - ibuf = (char *)mst->hdr; - mst->curr_buf = want; - } - hdr = (const struct GNUNET_MessageHeader *)&ibuf[mst->off]; - if (mst->pos - mst->off < want) - { - delta = GNUNET_MIN(want - (mst->pos - mst->off), size); - if (mst->pos + delta > mst->curr_buf) - { - fprintf(stderr, "The size of the buffer will be exceeded!\n"); - return GNUNET_SYSERR; - } - GNUNET_memcpy(&ibuf[mst->pos], buf, delta); - mst->pos += delta; - buf += delta; - size -= delta; - } - if (mst->pos - mst->off < want) - { - //FIXME should I use this? - // mst->off = 0; - // mst->pos = 0; - return GNUNET_OK; - } - mst->cb(mst->cb_cls, hdr); - mst->off += want; - if (mst->off == mst->pos) - { - /* reset to beginning of buffer, it's free right now! */ - mst->off = 0; - mst->pos = 0; - } + if (mst->pos < mst->off) + { + // fprintf (stderr, "We processed too many bytes!\n"); + return GNUNET_SYSERR; } - if (0 != mst->pos) + if ((mst->curr_buf - mst->off < sizeof(struct GNUNET_MessageHeader)) || + (0 != (mst->off % ALIGN_FACTOR))) + { + /* need to align or need more space */ + mst->pos -= mst->off; + memmove (ibuf, &ibuf[mst->off], mst->pos); + mst->off = 0; + } + if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader)) + { + delta = + GNUNET_MIN (sizeof(struct GNUNET_MessageHeader) + - (mst->pos - mst->off), size); + GNUNET_memcpy (&ibuf[mst->pos], buf, delta); + mst->pos += delta; + buf += delta; + size -= delta; + } + if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader)) + { + // FIXME should I reset ?? + // mst->off = 0; + // mst->pos = 0; + return GNUNET_OK; + } + hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off]; + want = ntohs (hdr->size); + if (want < sizeof(struct GNUNET_MessageHeader)) { - fprintf(stderr, "There should some valid bytes in the buffer on this stage\n"); + fprintf (stderr, + "Received invalid message from stdin\n"); return GNUNET_SYSERR; } + if ((mst->curr_buf - mst->off < want) && + (mst->off > 0)) + { + /* need more space */ + mst->pos -= mst->off; + memmove (ibuf, &ibuf[mst->off], mst->pos); + mst->off = 0; + } + if (want > mst->curr_buf) + { + if (mst->off != 0) + { + fprintf (stderr, "Error! We should proceeded 0 bytes\n"); + return GNUNET_SYSERR; + } + mst->hdr = realloc (mst->hdr, want); + if (NULL == mst->hdr) + { + fprintf (stderr, "Failed to allocate buffer for alignment\n"); + exit (1); + } + ibuf = (char *) mst->hdr; + mst->curr_buf = want; + } + hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off]; + if (mst->pos - mst->off < want) + { + delta = GNUNET_MIN (want - (mst->pos - mst->off), size); + if (mst->pos + delta > mst->curr_buf) + { + fprintf (stderr, "The size of the buffer will be exceeded!\n"); + return GNUNET_SYSERR; + } + GNUNET_memcpy (&ibuf[mst->pos], buf, delta); + mst->pos += delta; + buf += delta; + size -= delta; + } + if (mst->pos - mst->off < want) + { + // FIXME should I use this? + // mst->off = 0; + // mst->pos = 0; + return GNUNET_OK; + } + mst->cb (mst->cb_cls, hdr); + mst->off += want; + if (mst->off == mst->pos) + { + /* reset to beginning of buffer, it's free right now! */ + mst->off = 0; + mst->pos = 0; + } + } + if (0 != mst->pos) + { + fprintf (stderr, + "There should some valid bytes in the buffer on this stage\n"); + return GNUNET_SYSERR; + } while (size > 0) + { + if (size < sizeof(struct GNUNET_MessageHeader)) + break; + offset = (unsigned long) buf; + need_align = (0 != offset % ALIGN_FACTOR) ? GNUNET_YES : GNUNET_NO; + if (GNUNET_NO == need_align) { - if (size < sizeof(struct GNUNET_MessageHeader)) - break; - offset = (unsigned long)buf; - need_align = (0 != offset % ALIGN_FACTOR) ? GNUNET_YES : GNUNET_NO; - if (GNUNET_NO == need_align) - { - /* can try to do zero-copy and process directly from original buffer */ - hdr = (const struct GNUNET_MessageHeader *)buf; - want = ntohs(hdr->size); - if (want < sizeof(struct GNUNET_MessageHeader)) - { - fprintf(stderr, - "Received invalid message from stdin\n"); - //exit (1); - mst->off = 0; - return GNUNET_SYSERR; - } - if (size < want) - break; /* or not, buffer incomplete, so copy to private buffer... */ - mst->cb(mst->cb_cls, hdr); - buf += want; - size -= want; - } - else - { - /* need to copy to private buffer to align; - * yes, we go a bit more spagetti than usual here */ - goto do_align; - } + /* can try to do zero-copy and process directly from original buffer */ + hdr = (const struct GNUNET_MessageHeader *) buf; + want = ntohs (hdr->size); + if (want < sizeof(struct GNUNET_MessageHeader)) + { + fprintf (stderr, + "Received invalid message from stdin\n"); + // exit (1); + mst->off = 0; + return GNUNET_SYSERR; + } + if (size < want) + break; /* or not, buffer incomplete, so copy to private buffer... */ + mst->cb (mst->cb_cls, hdr); + buf += want; + size -= want; } + else + { + /* need to copy to private buffer to align; + * yes, we go a bit more spagetti than usual here */ + goto do_align; + } + } if (size > 0) + { + if (size + mst->pos > mst->curr_buf) { - if (size + mst->pos > mst->curr_buf) - { - mst->hdr = realloc(mst->hdr, size + mst->pos); - if (NULL == mst->hdr) - { - fprintf(stderr, "Failed to allocate buffer for alignment\n"); - exit(1); - } - ibuf = (char *)mst->hdr; - mst->curr_buf = size + mst->pos; - } - if (mst->pos + size > mst->curr_buf) - { - fprintf(stderr, - "Assertion failed\n"); - exit(1); - } - GNUNET_memcpy(&ibuf[mst->pos], buf, size); - mst->pos += size; + mst->hdr = realloc (mst->hdr, size + mst->pos); + if (NULL == mst->hdr) + { + fprintf (stderr, "Failed to allocate buffer for alignment\n"); + exit (1); + } + ibuf = (char *) mst->hdr; + mst->curr_buf = size + mst->pos; + } + if (mst->pos + size > mst->curr_buf) + { + fprintf (stderr, + "Assertion failed\n"); + exit (1); } + GNUNET_memcpy (&ibuf[mst->pos], buf, size); + mst->pos += size; + } return ret; } @@ -444,10 +452,10 @@ do_align: * @param mst tokenizer to destroy */ static void -mst_destroy(struct MessageStreamTokenizer *mst) +mst_destroy (struct MessageStreamTokenizer *mst) { - free(mst->hdr); - free(mst); + free (mst->hdr); + free (mst); } /** @@ -458,7 +466,7 @@ mst_destroy(struct MessageStreamTokenizer *mst) * @return crc sum */ static unsigned long -calc_crc_osdep(const unsigned char *buf, size_t len) +calc_crc_osdep (const unsigned char *buf, size_t len) { static const unsigned long int crc_tbl_osdep[256] = { 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, @@ -544,14 +552,14 @@ calc_crc_osdep(const unsigned char *buf, size_t len) * @return 0 on success (checksum matches), 1 on error */ static int -check_crc_buf_osdep(const unsigned char *buf, size_t len) +check_crc_buf_osdep (const unsigned char *buf, size_t len) { unsigned long crc; - crc = calc_crc_osdep(buf, len); + crc = calc_crc_osdep (buf, len); buf += len; - if (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] && - ((crc >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3]) + if ((((crc) & 0xFF) == buf[0])&&(((crc >> 8) & 0xFF) == buf[1])&& + ( ((crc >> 16) & 0xFF) == buf[2]) &&( ((crc >> 24) & 0xFF) == buf[3]) ) return 0; return 1; } @@ -568,19 +576,20 @@ check_crc_buf_osdep(const unsigned char *buf, size_t len) * @return 0 on success */ static int -bind_socket(int socket, struct sockaddr_rc *addr) +bind_socket (int socket, struct sockaddr_rc *addr) { int port, status; /* Bind every possible port (from 0 to 30) and stop when binding doesn't fail */ - //FIXME : it should start from port 1, but on my computer it doesn't work :) + // FIXME : it should start from port 1, but on my computer it doesn't work :) for (port = 3; port <= 30; port++) - { - addr->rc_channel = port; - status = bind(socket, (struct sockaddr *)addr, sizeof(struct sockaddr_rc)); - if (status == 0) - return 0; - } + { + addr->rc_channel = port; + status = bind (socket, (struct sockaddr *) addr, sizeof(struct + sockaddr_rc)); + if (status == 0) + return 0; + } return -1; } @@ -594,7 +603,7 @@ bind_socket(int socket, struct sockaddr_rc *addr) * @return 0 on success */ static int -register_service(struct HardwareInfos *dev, int rc_channel) +register_service (struct HardwareInfos *dev, int rc_channel) { /** * 1. initializations @@ -606,8 +615,10 @@ register_service(struct HardwareInfos *dev, int rc_channel) * 7. cleanup */ uint8_t svc_uuid_int[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - dev->pl_mac.mac[5], dev->pl_mac.mac[4], dev->pl_mac.mac[3], - dev->pl_mac.mac[2], dev->pl_mac.mac[1], dev->pl_mac.mac[0] }; + dev->pl_mac.mac[5], dev->pl_mac.mac[4], + dev->pl_mac.mac[3], + dev->pl_mac.mac[2], dev->pl_mac.mac[1], + dev->pl_mac.mac[0] }; const char *service_dsc = "Bluetooth plugin services"; const char *service_prov = "GNUnet provider"; uuid_t root_uuid, rfcomm_uuid, svc_uuid; @@ -616,61 +627,63 @@ register_service(struct HardwareInfos *dev, int rc_channel) sdp_record_t *record = 0; sdp_data_t *channel = 0; - record = sdp_record_alloc(); + record = sdp_record_alloc (); /* Set the general service ID */ - sdp_uuid128_create(&svc_uuid, &svc_uuid_int); - svc_list = sdp_list_append(0, &svc_uuid); - sdp_set_service_classes(record, svc_list); - sdp_set_service_id(record, svc_uuid); + sdp_uuid128_create (&svc_uuid, &svc_uuid_int); + svc_list = sdp_list_append (0, &svc_uuid); + sdp_set_service_classes (record, svc_list); + sdp_set_service_id (record, svc_uuid); /* Make the service record publicly browsable */ - sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); - root_list = sdp_list_append(0, &root_uuid); - sdp_set_browse_groups(record, root_list); + sdp_uuid16_create (&root_uuid, PUBLIC_BROWSE_GROUP); + root_list = sdp_list_append (0, &root_uuid); + sdp_set_browse_groups (record, root_list); /* Register the RFCOMM channel */ - sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); - channel = sdp_data_alloc(SDP_UINT8, &rc_channel); - rfcomm_list = sdp_list_append(0, &rfcomm_uuid); - sdp_list_append(rfcomm_list, channel); - proto_list = sdp_list_append(0, rfcomm_list); + sdp_uuid16_create (&rfcomm_uuid, RFCOMM_UUID); + channel = sdp_data_alloc (SDP_UINT8, &rc_channel); + rfcomm_list = sdp_list_append (0, &rfcomm_uuid); + sdp_list_append (rfcomm_list, channel); + proto_list = sdp_list_append (0, rfcomm_list); /* Set protocol information */ - access_proto_list = sdp_list_append(0, proto_list); - sdp_set_access_protos(record, access_proto_list); + access_proto_list = sdp_list_append (0, proto_list); + sdp_set_access_protos (record, access_proto_list); /* Set the name, provider, and description */ - sdp_set_info_attr(record, dev->iface, service_prov, service_dsc); + sdp_set_info_attr (record, dev->iface, service_prov, service_dsc); /* Connect to the local SDP server */ - dev->session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY); + dev->session = sdp_connect (BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY); - if (!dev->session) - { - fprintf(stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n", - IFNAMSIZ, dev->iface, strerror(errno)); - //FIXME exit? - return 1; - } + if (! dev->session) + { + fprintf (stderr, + "Failed to connect to the SDP server on interface `%.*s': %s\n", + IFNAMSIZ, dev->iface, strerror (errno)); + // FIXME exit? + return 1; + } /* Register the service record */ - if (sdp_record_register(dev->session, record, 0) < 0) - { - fprintf(stderr, "Failed to register a service record on interface `%.*s': %s\n", - IFNAMSIZ, dev->iface, strerror(errno)); - //FIXME exit? - return 1; - } + if (sdp_record_register (dev->session, record, 0) < 0) + { + fprintf (stderr, + "Failed to register a service record on interface `%.*s': %s\n", + IFNAMSIZ, dev->iface, strerror (errno)); + // FIXME exit? + return 1; + } /* Cleanup */ - sdp_data_free(channel); - sdp_list_free(root_list, 0); - sdp_list_free(rfcomm_list, 0); - sdp_list_free(proto_list, 0); - sdp_list_free(access_proto_list, 0); - sdp_list_free(svc_list, 0); - sdp_record_free(record); + sdp_data_free (channel); + sdp_list_free (root_list, 0); + sdp_list_free (rfcomm_list, 0); + sdp_list_free (proto_list, 0); + sdp_list_free (access_proto_list, 0); + sdp_list_free (svc_list, 0); + sdp_record_free (record); return 0; } @@ -684,7 +697,7 @@ register_service(struct HardwareInfos *dev, int rc_channel) * @return channel */ static int -get_channel(struct HardwareInfos *dev, bdaddr_t dest) +get_channel (struct HardwareInfos *dev, bdaddr_t dest) { /** * 1. detect all nearby devices @@ -704,46 +717,48 @@ get_channel(struct HardwareInfos *dev, bdaddr_t dest) int channel = -1; /* Connect to the local SDP server */ - session = sdp_connect(BDADDR_ANY, &dest, 0); - if (!session) - { - fprintf(stderr, "Failed to connect to the SDP server on interface `%.*s': %s\n", - IFNAMSIZ, dev->iface, strerror(errno)); - return -1; - } + session = sdp_connect (BDADDR_ANY, &dest, 0); + if (! session) + { + fprintf (stderr, + "Failed to connect to the SDP server on interface `%.*s': %s\n", + IFNAMSIZ, dev->iface, strerror (errno)); + return -1; + } - sdp_uuid128_create(&svc_uuid, &svc_uuid_int); - search_list = sdp_list_append(0, &svc_uuid); - attrid_list = sdp_list_append(0, &range); + sdp_uuid128_create (&svc_uuid, &svc_uuid_int); + search_list = sdp_list_append (0, &svc_uuid); + attrid_list = sdp_list_append (0, &range); - if (sdp_service_search_attr_req(session, search_list, - SDP_ATTR_REQ_RANGE, attrid_list, &response_list) == 0) + if (sdp_service_search_attr_req (session, search_list, + SDP_ATTR_REQ_RANGE, attrid_list, + &response_list) == 0) + { + for (it = response_list; it; it = it->next) { - for (it = response_list; it; it = it->next) - { - sdp_record_t *record = (sdp_record_t*)it->data; - sdp_list_t *proto_list = 0; - if (sdp_get_access_protos(record, &proto_list) == 0) - { - channel = sdp_get_proto_port(proto_list, RFCOMM_UUID); - sdp_list_free(proto_list, 0); - } - sdp_record_free(record); - } + sdp_record_t *record = (sdp_record_t*) it->data; + sdp_list_t *proto_list = 0; + if (sdp_get_access_protos (record, &proto_list) == 0) + { + channel = sdp_get_proto_port (proto_list, RFCOMM_UUID); + sdp_list_free (proto_list, 0); + } + sdp_record_free (record); } + } - sdp_list_free(search_list, 0); - sdp_list_free(attrid_list, 0); - sdp_list_free(response_list, 0); + sdp_list_free (search_list, 0); + sdp_list_free (attrid_list, 0); + sdp_list_free (response_list, 0); - sdp_close(session); + sdp_close (session); if (-1 == channel) - fprintf(stderr, - "Failed to find the listening channel for interface `%.*s': %s\n", - IFNAMSIZ, - dev->iface, - strerror(errno)); + fprintf (stderr, + "Failed to find the listening channel for interface `%.*s': %s\n", + IFNAMSIZ, + dev->iface, + strerror (errno)); return channel; } @@ -759,48 +774,50 @@ get_channel(struct HardwareInfos *dev, bdaddr_t dest) * @return number of bytes written to 'buf' */ static ssize_t -read_from_the_socket(void *sock, - unsigned char *buf, size_t buf_size, - struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri) +read_from_the_socket (void *sock, + unsigned char *buf, size_t buf_size, + struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri) { unsigned char tmpbuf[buf_size]; ssize_t count; - count = read(*((int *)sock), tmpbuf, buf_size); + count = read (*((int *) sock), tmpbuf, buf_size); if (0 > count) - { - if (EAGAIN == errno) - return 0; + { + if (EAGAIN == errno) + return 0; - fprintf(stderr, "Failed to read from the HCI socket: %s\n", strerror(errno)); + fprintf (stderr, "Failed to read from the HCI socket: %s\n", strerror ( + errno)); - return -1; - } + return -1; + } #ifdef LINUX /* Get the channel used */ int len; struct sockaddr_rc rc_addr = { 0 }; - memset(&rc_addr, 0, sizeof(rc_addr)); + memset (&rc_addr, 0, sizeof(rc_addr)); len = sizeof(rc_addr); - if (0 > getsockname(*((int *)sock), (struct sockaddr *)&rc_addr, (socklen_t *)&len)) - { - fprintf(stderr, "getsockname() call failed : %s\n", strerror(errno)); - return -1; - } + if (0 > getsockname (*((int *) sock), (struct sockaddr *) &rc_addr, + (socklen_t *) &len)) + { + fprintf (stderr, "getsockname() call failed : %s\n", strerror (errno)); + return -1; + } - memset(ri, 0, sizeof(*ri)); + memset (ri, 0, sizeof(*ri)); ri->ri_channel = rc_addr.rc_channel; #endif /* Detect CRC32 at the end */ - if (0 == check_crc_buf_osdep(tmpbuf, count - sizeof(uint32_t))) - { - count -= sizeof(uint32_t); - } + if (0 == check_crc_buf_osdep (tmpbuf, count - sizeof(uint32_t))) + { + count -= sizeof(uint32_t); + } - GNUNET_memcpy(buf, tmpbuf, count); + GNUNET_memcpy (buf, tmpbuf, count); return count; } @@ -813,14 +830,15 @@ read_from_the_socket(void *sock, * @return 0 on success, non-zero on error */ static int -open_device(struct HardwareInfos *dev) +open_device (struct HardwareInfos *dev) { int i, dev_id = -1, fd_hci; - struct { + struct + { struct hci_dev_list_req list; struct hci_dev_req dev[HCI_MAX_DEV]; - } request; //used for detecting the local devices - struct sockaddr_rc rc_addr = { 0 }; //used for binding + } request; // used for detecting the local devices + struct sockaddr_rc rc_addr = { 0 }; // used for binding /* Initialize the neighbour structure */ neighbours.dev_id = -1; @@ -828,147 +846,148 @@ open_device(struct HardwareInfos *dev) neighbours.fds[i] = -1; /* Open a HCI socket */ - fd_hci = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); + fd_hci = socket (AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); if (fd_hci < 0) - { - fprintf(stderr, - "Failed to create HCI socket: %s\n", - strerror(errno)); - return -1; - } + { + fprintf (stderr, + "Failed to create HCI socket: %s\n", + strerror (errno)); + return -1; + } - memset(&request, 0, sizeof(request)); + memset (&request, 0, sizeof(request)); request.list.dev_num = HCI_MAX_DEV; - if (ioctl(fd_hci, HCIGETDEVLIST, (void *)&request) < 0) - { - fprintf(stderr, - "ioctl(HCIGETDEVLIST) on interface `%.*s' failed: %s\n", - IFNAMSIZ, - dev->iface, - strerror(errno)); - (void)close(fd_hci); - return 1; - } + if (ioctl (fd_hci, HCIGETDEVLIST, (void *) &request) < 0) + { + fprintf (stderr, + "ioctl(HCIGETDEVLIST) on interface `%.*s' failed: %s\n", + IFNAMSIZ, + dev->iface, + strerror (errno)); + (void) close (fd_hci); + return 1; + } /* Search for a device with dev->iface name */ for (i = 0; i < request.list.dev_num; i++) - { - struct hci_dev_info dev_info; + { + struct hci_dev_info dev_info; - memset(&dev_info, 0, sizeof(struct hci_dev_info)); - dev_info.dev_id = request.dev[i].dev_id; - strncpy(dev_info.name, dev->iface, BLUEZ_DEVNAME_SIZE); + memset (&dev_info, 0, sizeof(struct hci_dev_info)); + dev_info.dev_id = request.dev[i].dev_id; + strncpy (dev_info.name, dev->iface, BLUEZ_DEVNAME_SIZE); - if (ioctl(fd_hci, HCIGETDEVINFO, (void *)&dev_info)) + if (ioctl (fd_hci, HCIGETDEVINFO, (void *) &dev_info)) + { + fprintf (stderr, + "ioctl(HCIGETDEVINFO) on interface `%.*s' failed: %s\n", + IFNAMSIZ, + dev->iface, + strerror (errno)); + (void) close (fd_hci); + return 1; + } + + if (strncmp (dev_info.name, dev->iface, BLUEZ_DEVNAME_SIZE) == 0) + { + dev_id = dev_info.dev_id; // the device was found + /** + * Copy the MAC address to the device structure + */ + GNUNET_memcpy (&dev->pl_mac, &dev_info.bdaddr, sizeof(bdaddr_t)); + + /* Check if the interface is up */ + if (hci_test_bit (HCI_UP, (void *) &dev_info.flags) == 0) + { + /* Bring the interface up */ + if (ioctl (fd_hci, HCIDEVUP, dev_info.dev_id)) { - fprintf(stderr, - "ioctl(HCIGETDEVINFO) on interface `%.*s' failed: %s\n", - IFNAMSIZ, - dev->iface, - strerror(errno)); - (void)close(fd_hci); + fprintf (stderr, + "ioctl(HCIDEVUP) on interface `%.*s' failed: %s\n", + IFNAMSIZ, + dev->iface, + strerror (errno)); + (void) close (fd_hci); return 1; } + } - if (strncmp(dev_info.name, dev->iface, BLUEZ_DEVNAME_SIZE) == 0) - { - dev_id = dev_info.dev_id; //the device was found - /** - * Copy the MAC address to the device structure - */ - GNUNET_memcpy(&dev->pl_mac, &dev_info.bdaddr, sizeof(bdaddr_t)); - - /* Check if the interface is up */ - if (hci_test_bit(HCI_UP, (void *)&dev_info.flags) == 0) - { - /* Bring the interface up */ - if (ioctl(fd_hci, HCIDEVUP, dev_info.dev_id)) - { - fprintf(stderr, - "ioctl(HCIDEVUP) on interface `%.*s' failed: %s\n", - IFNAMSIZ, - dev->iface, - strerror(errno)); - (void)close(fd_hci); - return 1; - } - } - - /* Check if the device is discoverable */ - if (hci_test_bit(HCI_PSCAN, (void *)&dev_info.flags) == 0 || - hci_test_bit(HCI_ISCAN, (void *)&dev_info.flags) == 0) - { - /* Set interface Page Scan and Inqury Scan ON */ - struct hci_dev_req dev_req; + /* Check if the device is discoverable */ + if ((hci_test_bit (HCI_PSCAN, (void *) &dev_info.flags) == 0) || + (hci_test_bit (HCI_ISCAN, (void *) &dev_info.flags) == 0) ) + { + /* Set interface Page Scan and Inqury Scan ON */ + struct hci_dev_req dev_req; - memset(&dev_req, 0, sizeof(dev_req)); - dev_req.dev_id = dev_info.dev_id; - dev_req.dev_opt = SCAN_PAGE | SCAN_INQUIRY; + memset (&dev_req, 0, sizeof(dev_req)); + dev_req.dev_id = dev_info.dev_id; + dev_req.dev_opt = SCAN_PAGE | SCAN_INQUIRY; - if (ioctl(fd_hci, HCISETSCAN, (unsigned long)&dev_req)) - { - fprintf(stderr, - "ioctl(HCISETSCAN) on interface `%.*s' failed: %s\n", - IFNAMSIZ, - dev->iface, - strerror(errno)); - (void)close(fd_hci); - return 1; - } - } - break; + if (ioctl (fd_hci, HCISETSCAN, (unsigned long) &dev_req)) + { + fprintf (stderr, + "ioctl(HCISETSCAN) on interface `%.*s' failed: %s\n", + IFNAMSIZ, + dev->iface, + strerror (errno)); + (void) close (fd_hci); + return 1; } + } + break; } + } /* Check if the interface was not found */ if (-1 == dev_id) - { - fprintf(stderr, - "The interface %s was not found\n", - dev->iface); - (void)close(fd_hci); - return 1; - } + { + fprintf (stderr, + "The interface %s was not found\n", + dev->iface); + (void) close (fd_hci); + return 1; + } /* Close the hci socket */ - (void)close(fd_hci); + (void) close (fd_hci); /* Bind the rfcomm socket to the interface */ - memset(&rc_addr, 0, sizeof(rc_addr)); + memset (&rc_addr, 0, sizeof(rc_addr)); rc_addr.rc_family = AF_BLUETOOTH; rc_addr.rc_bdaddr = *BDADDR_ANY; - if (bind_socket(dev->fd_rfcomm, &rc_addr) != 0) - { - fprintf(stderr, - "Failed to bind interface `%.*s': %s\n", - IFNAMSIZ, - dev->iface, - strerror(errno)); - return 1; - } + if (bind_socket (dev->fd_rfcomm, &rc_addr) != 0) + { + fprintf (stderr, + "Failed to bind interface `%.*s': %s\n", + IFNAMSIZ, + dev->iface, + strerror (errno)); + return 1; + } /* Register a SDP service */ - if (register_service(dev, rc_addr.rc_channel) != 0) - { - fprintf(stderr, - "Failed to register a service on interface `%.*s': %s\n", - IFNAMSIZ, - dev->iface, strerror(errno)); - return 1; - } + if (register_service (dev, rc_addr.rc_channel) != 0) + { + fprintf (stderr, + "Failed to register a service on interface `%.*s': %s\n", + IFNAMSIZ, + dev->iface, strerror (errno)); + return 1; + } /* Switch socket in listening mode */ - if (listen(dev->fd_rfcomm, 5) == -1) //FIXME: probably we need a bigger number - { - fprintf(stderr, "Failed to listen on socket for interface `%.*s': %s\n", IFNAMSIZ, - dev->iface, strerror(errno)); - return 1; - } + if (listen (dev->fd_rfcomm, 5) == -1) // FIXME: probably we need a bigger number + { + fprintf (stderr, "Failed to listen on socket for interface `%.*s': %s\n", + IFNAMSIZ, + dev->iface, strerror (errno)); + return 1; + } return 0; } @@ -983,10 +1002,10 @@ open_device(struct HardwareInfos *dev) **** copy from gnunet-helper-transport-wlan.c **** */ static void -mac_set(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, - const struct HardwareInfos *dev) +mac_set (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, + const struct HardwareInfos *dev) { - taIeeeHeader->frame_control = htons(IEEE80211_FC0_TYPE_DATA); + taIeeeHeader->frame_control = htons (IEEE80211_FC0_TYPE_DATA); taIeeeHeader->addr3 = mac_bssid_gnunet; taIeeeHeader->addr2 = dev->pl_mac; } @@ -1001,22 +1020,22 @@ mac_set(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, **** similar with the one from gnunet-helper-transport-wlan.c **** */ static int -test_bluetooth_interface(const char *iface) +test_bluetooth_interface (const char *iface) { char strbuf[512]; struct stat sbuf; int ret; - ret = snprintf(strbuf, sizeof(strbuf), - "/sys/class/bluetooth/%s/subsystem", - iface); - if ((ret < 0) || (ret >= sizeof(strbuf)) || (0 != stat(strbuf, &sbuf))) - { - fprintf(stderr, - "Did not find 802.15.1 interface `%s'. Exiting.\n", - iface); - exit(1); - } + ret = snprintf (strbuf, sizeof(strbuf), + "/sys/class/bluetooth/%s/subsystem", + iface); + if ((ret < 0) || (ret >= sizeof(strbuf)) || (0 != stat (strbuf, &sbuf))) + { + fprintf (stderr, + "Did not find 802.15.1 interface `%s'. Exiting.\n", + iface); + exit (1); + } return 0; } #endif @@ -1031,19 +1050,19 @@ test_bluetooth_interface(const char *iface) **** same as the one from gnunet-helper-transport-wlan.c **** */ static int -mac_test(const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, - const struct HardwareInfos *dev) +mac_test (const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, + const struct HardwareInfos *dev) { static struct GNUNET_TRANSPORT_WLAN_MacAddress all_zeros; - if ((0 == memcmp(&taIeeeHeader->addr3, &all_zeros, MAC_ADDR_SIZE)) || - (0 == memcmp(&taIeeeHeader->addr1, &all_zeros, MAC_ADDR_SIZE))) + if ((0 == memcmp (&taIeeeHeader->addr3, &all_zeros, MAC_ADDR_SIZE)) || + (0 == memcmp (&taIeeeHeader->addr1, &all_zeros, MAC_ADDR_SIZE))) return 0; /* some drivers set no Macs, then assume it is all for us! */ - if (0 != memcmp(&taIeeeHeader->addr3, &mac_bssid_gnunet, MAC_ADDR_SIZE)) + if (0 != memcmp (&taIeeeHeader->addr3, &mac_bssid_gnunet, MAC_ADDR_SIZE)) return 1; /* not a GNUnet ad-hoc package */ - if ((0 == memcmp(&taIeeeHeader->addr1, &dev->pl_mac, MAC_ADDR_SIZE)) || - (0 == memcmp(&taIeeeHeader->addr1, &bc_all_mac, MAC_ADDR_SIZE))) + if ((0 == memcmp (&taIeeeHeader->addr1, &dev->pl_mac, MAC_ADDR_SIZE)) || + (0 == memcmp (&taIeeeHeader->addr1, &bc_all_mac, MAC_ADDR_SIZE))) return 0; /* for us, or broadcast */ return 1; /* not for us */ } @@ -1059,37 +1078,37 @@ mac_test(const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, **** same as the one from gnunet-helper-transport-wlan.c **** */ static void -stdin_send_hw(void *cls, const struct GNUNET_MessageHeader *hdr) +stdin_send_hw (void *cls, const struct GNUNET_MessageHeader *hdr) { struct HardwareInfos *dev = cls; const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header; struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *blueheader; size_t sendsize; - sendsize = ntohs(hdr->size); + sendsize = ntohs (hdr->size); if ((sendsize < sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)) || - (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs(hdr->type))) - { - fprintf(stderr, "Received malformed message\n"); - exit(1); - } - sendsize -= (sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) - - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)); + (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type))) + { + fprintf (stderr, "Received malformed message\n"); + exit (1); + } + sendsize -= (sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)); if (MAXLINE < sendsize) - { - fprintf(stderr, "Packet too big for buffer\n"); - exit(1); - } - header = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *)hdr; - GNUNET_memcpy(&write_pout.buf, &header->frame, sendsize); - blueheader = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *)&write_pout.buf; + { + fprintf (stderr, "Packet too big for buffer\n"); + exit (1); + } + header = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr; + GNUNET_memcpy (&write_pout.buf, &header->frame, sendsize); + blueheader = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) &write_pout.buf; /* payload contains MAC address, but we don't trust it, so we'll * overwrite it with OUR MAC address to prevent mischief */ - mac_set(blueheader, dev); - GNUNET_memcpy(&blueheader->addr1, &header->frame.addr1, - sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)); + mac_set (blueheader, dev); + GNUNET_memcpy (&blueheader->addr1, &header->frame.addr1, + sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)); write_pout.size = sendsize; } @@ -1102,105 +1121,120 @@ stdin_send_hw(void *cls, const struct GNUNET_MessageHeader *hdr) * @return 0 on success */ static int -send_broadcast(struct HardwareInfos *dev, int *sendsocket) +send_broadcast (struct HardwareInfos *dev, int *sendsocket) { int new_device = 0; int loops = 0; search_for_devices: - if ((neighbours.size == neighbours.pos && new_device == 1) || neighbours.size == 0) + if (((neighbours.size == neighbours.pos)&&(new_device == 1)) || + (neighbours.size == 0) ) + { +inquiry_devices: // skip the conditions and force a inquiry for new devices { -inquiry_devices: //skip the conditions and force a inquiry for new devices + /** + * It means that I sent HELLO messages to all the devices from the list and I should search + * for new ones or that this is the first time when I do a search. + */ + inquiry_info *devices = NULL; + int i, responses, max_responses = MAX_PORTS; + + /* sanity checks */ + if (neighbours.size >= MAX_PORTS) { - /** - * It means that I sent HELLO messages to all the devices from the list and I should search - * for new ones or that this is the first time when I do a search. - */ - inquiry_info *devices = NULL; - int i, responses, max_responses = MAX_PORTS; - - /* sanity checks */ - if (neighbours.size >= MAX_PORTS) - { - fprintf(stderr, "%.*s reached the top limit for the discovarable devices\n", IFNAMSIZ, dev->iface); - return 2; - } - - /* Get the device id */ - if (neighbours.dev_id == -1) - { - char addr[19] = { 0 }; //the device MAC address - - ba2str((bdaddr_t *)&dev->pl_mac, addr); - neighbours.dev_id = hci_devid(addr); - if (neighbours.dev_id < 0) - { - fprintf(stderr, "Failed to get the device id for interface %.*s : %s\n", IFNAMSIZ, - dev->iface, strerror(errno)); - return 1; - } - } + fprintf (stderr, + "%.*s reached the top limit for the discovarable devices\n", + IFNAMSIZ, + dev->iface); + return 2; + } - devices = malloc(max_responses * sizeof(inquiry_info)); - if (devices == NULL) - { - fprintf(stderr, "Failed to allocate memory for inquiry info list on interface %.*s\n", IFNAMSIZ, - dev->iface); - return 1; - } + /* Get the device id */ + if (neighbours.dev_id == -1) + { + char addr[19] = { 0 }; // the device MAC address - responses = hci_inquiry(neighbours.dev_id, 8, max_responses, NULL, &devices, IREQ_CACHE_FLUSH); - if (responses < 0) - { - fprintf(stderr, "Failed to inquiry on interface %.*s\n", IFNAMSIZ, dev->iface); - return 1; - } + ba2str ((bdaddr_t *) &dev->pl_mac, addr); + neighbours.dev_id = hci_devid (addr); + if (neighbours.dev_id < 0) + { + fprintf (stderr, + "Failed to get the device id for interface %.*s : %s\n", + IFNAMSIZ, + dev->iface, strerror (errno)); + return 1; + } + } - fprintf(stderr, "LOG : Found %d devices\n", responses); //FIXME delete it after debugging stage + devices = malloc (max_responses * sizeof(inquiry_info)); + if (devices == NULL) + { + fprintf (stderr, + "Failed to allocate memory for inquiry info list on interface %.*s\n", + IFNAMSIZ, + dev->iface); + return 1; + } - if (responses == 0) - { - fprintf(stderr, "LOG : No devices discoverable\n"); - return 1; - } + responses = hci_inquiry (neighbours.dev_id, 8, max_responses, NULL, + &devices, IREQ_CACHE_FLUSH); + if (responses < 0) + { + fprintf (stderr, "Failed to inquiry on interface %.*s\n", IFNAMSIZ, + dev->iface); + return 1; + } - for (i = 0; i < responses; i++) - { - int j; - int found = 0; + fprintf (stderr, "LOG : Found %d devices\n", responses); // FIXME delete it after debugging stage - /* sanity check */ - if (i >= MAX_PORTS) - { - fprintf(stderr, "%.*s reached the top limit for the discoverable devices (after inquiry)\n", IFNAMSIZ, - dev->iface); - return 2; - } + if (responses == 0) + { + fprintf (stderr, "LOG : No devices discoverable\n"); + return 1; + } - /* Search if the address already exists on the list */ - for (j = 0; j < neighbours.size; j++) - { - if (memcmp(&(devices + i)->bdaddr, &(neighbours.devices[j]), sizeof(bdaddr_t)) == 0) - { - found = 1; - fprintf(stderr, "LOG : the device already exists on the list\n"); //FIXME debugging message - break; - } - } + for (i = 0; i < responses; i++) + { + int j; + int found = 0; - if (found == 0) - { - char addr[19] = { 0 }; + /* sanity check */ + if (i >= MAX_PORTS) + { + fprintf (stderr, + "%.*s reached the top limit for the discoverable devices (after inquiry)\n", + IFNAMSIZ, + dev->iface); + return 2; + } - ba2str(&(devices + i)->bdaddr, addr); - fprintf(stderr, "LOG : %s was added to the list\n", addr); //FIXME debugging message - GNUNET_memcpy(&(neighbours.devices[neighbours.size++]), &(devices + i)->bdaddr, sizeof(bdaddr_t)); - } + /* Search if the address already exists on the list */ + for (j = 0; j < neighbours.size; j++) + { + if (memcmp (&(devices + i)->bdaddr, &(neighbours.devices[j]), + sizeof(bdaddr_t)) == 0) + { + found = 1; + fprintf (stderr, "LOG : the device already exists on the list\n"); // FIXME debugging message + break; } + } + + if (found == 0) + { + char addr[19] = { 0 }; - free(devices); + ba2str (&(devices + i)->bdaddr, addr); + fprintf (stderr, "LOG : %s was added to the list\n", addr); // FIXME debugging message + GNUNET_memcpy (&(neighbours.devices[neighbours.size++]), &(devices + + i)-> + bdaddr, sizeof(bdaddr_t)); + } } + + free (devices); } + } int connection_successful = 0; struct sockaddr_rc addr_rc = { 0 }; @@ -1209,115 +1243,120 @@ inquiry_devices: //skip the conditions and force a inquiry for new devices /* Try to connect to a new device from the list */ while (neighbours.pos < neighbours.size) + { + /* Check if we are already connected to this device */ + if (neighbours.fds[neighbours.pos] == -1) { - /* Check if we are already connected to this device */ - if (neighbours.fds[neighbours.pos] == -1) - { - memset(&addr_rc.rc_bdaddr, 0, sizeof(addr_rc.rc_bdaddr)); - GNUNET_memcpy(&addr_rc.rc_bdaddr, &(neighbours.devices[neighbours.pos]), sizeof(addr_rc.rc_bdaddr)); + memset (&addr_rc.rc_bdaddr, 0, sizeof(addr_rc.rc_bdaddr)); + GNUNET_memcpy (&addr_rc.rc_bdaddr, &(neighbours.devices[neighbours.pos]), + sizeof(addr_rc.rc_bdaddr)); - addr_rc.rc_channel = get_channel(dev, addr_rc.rc_bdaddr); + addr_rc.rc_channel = get_channel (dev, addr_rc.rc_bdaddr); - *sendsocket = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); - if ((-1 < *sendsocket) && - (0 == connect(*sendsocket, - (struct sockaddr *)&addr_rc, - sizeof(addr_rc)))) - { - neighbours.fds[neighbours.pos++] = *sendsocket; - connection_successful = 1; - char addr[19] = { 0 }; - ba2str(&(neighbours.devices[neighbours.pos - 1]), addr); - fprintf(stderr, "LOG : Connected to %s\n", addr); - break; - } - else - { - char addr[19] = { 0 }; - errno_copy = errno; //Save a copy for later + *sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); + if ((-1 < *sendsocket) && + (0 == connect (*sendsocket, + (struct sockaddr *) &addr_rc, + sizeof(addr_rc)))) + { + neighbours.fds[neighbours.pos++] = *sendsocket; + connection_successful = 1; + char addr[19] = { 0 }; + ba2str (&(neighbours.devices[neighbours.pos - 1]), addr); + fprintf (stderr, "LOG : Connected to %s\n", addr); + break; + } + else + { + char addr[19] = { 0 }; + errno_copy = errno; // Save a copy for later - if (-1 != *sendsocket) - { - (void)close(*sendsocket); - *sendsocket = -1; - } - ba2str(&(neighbours.devices[neighbours.pos]), addr); - fprintf(stderr, - "LOG : Couldn't connect on device %s, error : %s\n", - addr, - strerror(errno)); - if (errno != ECONNREFUSED) //FIXME be sure that this works - { - fprintf(stderr, "LOG : Removes %d device from the list\n", neighbours.pos); - /* Remove the device from the list */ - GNUNET_memcpy(&neighbours.devices[neighbours.pos], &neighbours.devices[neighbours.size - 1], sizeof(bdaddr_t)); - memset(&neighbours.devices[neighbours.size - 1], 0, sizeof(bdaddr_t)); - neighbours.fds[neighbours.pos] = neighbours.fds[neighbours.size - 1]; - neighbours.fds[neighbours.size - 1] = -1; - neighbours.size -= 1; - } + if (-1 != *sendsocket) + { + (void) close (*sendsocket); + *sendsocket = -1; + } + ba2str (&(neighbours.devices[neighbours.pos]), addr); + fprintf (stderr, + "LOG : Couldn't connect on device %s, error : %s\n", + addr, + strerror (errno)); + if (errno != ECONNREFUSED) // FIXME be sure that this works + { + fprintf (stderr, "LOG : Removes %d device from the list\n", + neighbours.pos); + /* Remove the device from the list */ + GNUNET_memcpy (&neighbours.devices[neighbours.pos], + &neighbours.devices[neighbours.size - 1], + sizeof(bdaddr_t)); + memset (&neighbours.devices[neighbours.size - 1], 0, + sizeof(bdaddr_t)); + neighbours.fds[neighbours.pos] = neighbours.fds[neighbours.size - 1]; + neighbours.fds[neighbours.size - 1] = -1; + neighbours.size -= 1; + } - neighbours.pos += 1; + neighbours.pos += 1; - if (neighbours.pos >= neighbours.size) - neighbours.pos = 0; + if (neighbours.pos >= neighbours.size) + neighbours.pos = 0; - loops += 1; + loops += 1; - if (loops == MAX_LOOPS) //don't get stuck trying to connect to one device - return 1; - } - } - else - { - fprintf(stderr, "LOG : Search for a new device\n"); //FIXME debugging message - neighbours.pos += 1; - } + if (loops == MAX_LOOPS) // don't get stuck trying to connect to one device + return 1; + } + } + else + { + fprintf (stderr, "LOG : Search for a new device\n"); // FIXME debugging message + neighbours.pos += 1; } + } /* Cycle on the list */ if (neighbours.pos == neighbours.size) - { - neighbours.pos = 0; - searching_devices_count += 1; + { + neighbours.pos = 0; + searching_devices_count += 1; - if (searching_devices_count == MAX_LOOPS) - { - fprintf(stderr, "LOG : Force to inquiry for new devices\n"); - searching_devices_count = 0; - goto inquiry_devices; - } + if (searching_devices_count == MAX_LOOPS) + { + fprintf (stderr, "LOG : Force to inquiry for new devices\n"); + searching_devices_count = 0; + goto inquiry_devices; } + } /* If a new device wasn't found, search an old one */ if (connection_successful == 0) + { + int loop_check = neighbours.pos; + while (neighbours.fds[neighbours.pos] == -1) { - int loop_check = neighbours.pos; - while (neighbours.fds[neighbours.pos] == -1) - { - if (neighbours.pos == neighbours.size) - neighbours.pos = 0; - - if (neighbours.pos == loop_check) - { - if (errno_copy == ECONNREFUSED) - { - fprintf(stderr, "LOG : No device found. Go back and search again\n"); //FIXME debugging message - new_device = 1; - loops += 1; - goto search_for_devices; - } - else - { - return 1; // Skip the broadcast message - } - } + if (neighbours.pos == neighbours.size) + neighbours.pos = 0; - neighbours.pos += 1; + if (neighbours.pos == loop_check) + { + if (errno_copy == ECONNREFUSED) + { + fprintf (stderr, "LOG : No device found. Go back and search again\n"); // FIXME debugging message + new_device = 1; + loops += 1; + goto search_for_devices; } + else + { + return 1; // Skip the broadcast message + } + } - *sendsocket = neighbours.fds[neighbours.pos++]; + neighbours.pos += 1; } + *sendsocket = neighbours.fds[neighbours.pos++]; + } + return 0; } #endif @@ -1334,7 +1373,7 @@ inquiry_devices: //skip the conditions and force a inquiry for new devices **** similar to gnunet-helper-transport-wlan.c **** */ int -main(int argc, char *argv[]) +main (int argc, char *argv[]) { #ifdef LINUX struct HardwareInfos dev; @@ -1351,83 +1390,85 @@ main(int argc, char *argv[]) /* Assert privs so we can modify the firewall rules! */ { #ifdef HAVE_SETRESUID - uid_t uid = getuid(); + uid_t uid = getuid (); - if (0 != setresuid(uid, 0, 0)) - { - fprintf(stderr, - "Failed to setresuid to root: %s\n", - strerror(errno)); - return 254; - } + if (0 != setresuid (uid, 0, 0)) + { + fprintf (stderr, + "Failed to setresuid to root: %s\n", + strerror (errno)); + return 254; + } #else - if (0 != seteuid(0)) - { - fprintf(stderr, - "Failed to seteuid back to root: %s\n", strerror(errno)); - return 254; - } + if (0 != seteuid (0)) + { + fprintf (stderr, + "Failed to seteuid back to root: %s\n", strerror (errno)); + return 254; + } #endif } /* Make use of SGID capabilities on POSIX */ - memset(&dev, 0, sizeof(dev)); - dev.fd_rfcomm = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); + memset (&dev, 0, sizeof(dev)); + dev.fd_rfcomm = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); raw_eno = errno; /* remember for later */ /* Now that we've dropped root rights, we can do error checking */ if (2 != argc) - { - fprintf(stderr, "You must specify the name of the interface as the first \ + { + fprintf (stderr, + "You must specify the name of the interface as the first \ and only argument to this program.\n"); - if (-1 != dev.fd_rfcomm) - (void)close(dev.fd_rfcomm); - return 1; - } + if (-1 != dev.fd_rfcomm) + (void) close (dev.fd_rfcomm); + return 1; + } if (-1 == dev.fd_rfcomm) - { - fprintf(stderr, "Failed to create a RFCOMM socket: %s\n", strerror(raw_eno)); - return 1; - } + { + fprintf (stderr, "Failed to create a RFCOMM socket: %s\n", strerror ( + raw_eno)); + return 1; + } if (dev.fd_rfcomm >= FD_SETSIZE) + { + fprintf (stderr, "File descriptor too large for select (%d > %d)\n", + dev.fd_rfcomm, FD_SETSIZE); + (void) close (dev.fd_rfcomm); + return 1; + } + if (0 != test_bluetooth_interface (argv[1])) + { + (void) close (dev.fd_rfcomm); + return 1; + } + strncpy (dev.iface, argv[1], IFNAMSIZ); + if (0 != open_device (&dev)) + { + (void) close (dev.fd_rfcomm); + return 1; + } + + /* Drop privs */ + { + uid_t uid = getuid (); + #ifdef HAVE_SETRESUID + if (0 != setresuid (uid, uid, uid)) { - fprintf(stderr, "File descriptor too large for select (%d > %d)\n", - dev.fd_rfcomm, FD_SETSIZE); - (void)close(dev.fd_rfcomm); - return 1; - } - if (0 != test_bluetooth_interface(argv[1])) - { - (void)close(dev.fd_rfcomm); + fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno)); + if (-1 != dev.fd_rfcomm) + (void) close (dev.fd_rfcomm); return 1; } - strncpy(dev.iface, argv[1], IFNAMSIZ); - if (0 != open_device(&dev)) + #else + if (0 != (setuid (uid) | seteuid (uid))) { - (void)close(dev.fd_rfcomm); + fprintf (stderr, "Failed to setuid: %s\n", strerror (errno)); + if (-1 != dev.fd_rfcomm) + (void) close (dev.fd_rfcomm); return 1; } - - /* Drop privs */ - { - uid_t uid = getuid(); - #ifdef HAVE_SETRESUID - if (0 != setresuid(uid, uid, uid)) - { - fprintf(stderr, "Failed to setresuid: %s\n", strerror(errno)); - if (-1 != dev.fd_rfcomm) - (void)close(dev.fd_rfcomm); - return 1; - } - #else - if (0 != (setuid(uid) | seteuid(uid))) - { - fprintf(stderr, "Failed to setuid: %s\n", strerror(errno)); - if (-1 != dev.fd_rfcomm) - (void)close(dev.fd_rfcomm); - return 1; - } #endif } @@ -1435,15 +1476,16 @@ main(int argc, char *argv[]) { struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg; - macmsg.hdr.size = htons(sizeof(macmsg)); - macmsg.hdr.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); - GNUNET_memcpy(&macmsg.mac, &dev.pl_mac, sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)); - GNUNET_memcpy(write_std.buf, &macmsg, sizeof(macmsg)); + macmsg.hdr.size = htons (sizeof(macmsg)); + macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); + GNUNET_memcpy (&macmsg.mac, &dev.pl_mac, sizeof(struct + GNUNET_TRANSPORT_WLAN_MacAddress)); + GNUNET_memcpy (write_std.buf, &macmsg, sizeof(macmsg)); write_std.size = sizeof(macmsg); } - stdin_mst = mst_create(&stdin_send_hw, &dev); + stdin_mst = mst_create (&stdin_send_hw, &dev); stdin_open = 1; /** @@ -1451,348 +1493,381 @@ main(int argc, char *argv[]) * from get_wlan_header (plugin_transport_bluetooth.c) is correct. */ while (1) + { + maxfd = -1; + broadcast = 0; + sendsocket = -1; + + FD_ZERO (&rfds); + if ((0 == write_pout.size) && (1 == stdin_open)) + { + FD_SET (STDIN_FILENO, &rfds); + maxfd = MAX (maxfd, STDIN_FILENO); + } + if (0 == write_std.size) { - maxfd = -1; - broadcast = 0; - sendsocket = -1; + FD_SET (dev.fd_rfcomm, &rfds); + maxfd = MAX (maxfd, dev.fd_rfcomm); + } - FD_ZERO(&rfds); - if ((0 == write_pout.size) && (1 == stdin_open)) - { - FD_SET(STDIN_FILENO, &rfds); - maxfd = MAX(maxfd, STDIN_FILENO); - } - if (0 == write_std.size) + for (i = 0; i < crt_rfds; i++) // it can receive messages from multiple devices + { + FD_SET (rfds_list[i], &rfds); + maxfd = MAX (maxfd, rfds_list[i]); + } + FD_ZERO (&wfds); + if (0 < write_std.size) + { + FD_SET (STDOUT_FILENO, &wfds); + maxfd = MAX (maxfd, STDOUT_FILENO); + } + if (0 < write_pout.size) // it can send messages only to one device per loop + { + struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *frame; + /* Get the destination address */ + frame = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) write_pout.buf; + + if (memcmp (&frame->addr1, &dev.pl_mac, + sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) + { + broadcast = 1; + memset (&write_pout, 0, sizeof(write_pout)); // clear the buffer + } + else if (memcmp (&frame->addr1, &broadcast_address, + sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) + { + fprintf (stderr, "LOG : %s has a broadcast message (pos %d, size %d)\n", + dev.iface, neighbours.pos, neighbours.size); // FIXME: debugging message + + if (send_broadcast (&dev, &sendsocket) != 0) // if the searching wasn't successful don't get stuck on the select stage { - FD_SET(dev.fd_rfcomm, &rfds); - maxfd = MAX(maxfd, dev.fd_rfcomm); + broadcast = 1; + memset (&write_pout, 0, sizeof(write_pout)); // remove the message + fprintf (stderr, + "LOG : Skipping the broadcast message (pos %d, size %d)\n", + neighbours.pos, neighbours.size); } - - for (i = 0; i < crt_rfds; i++) // it can receive messages from multiple devices + else { - FD_SET(rfds_list[i], &rfds); - maxfd = MAX(maxfd, rfds_list[i]); + FD_SET (sendsocket, &wfds); + maxfd = MAX (maxfd, sendsocket); } - FD_ZERO(&wfds); - if (0 < write_std.size) + } + else + { + int found = 0; + int pos = 0; + /* Search if the address already exists on the list */ + for (i = 0; i < neighbours.size; i++) { - FD_SET(STDOUT_FILENO, &wfds); - maxfd = MAX(maxfd, STDOUT_FILENO); + if (memcmp (&frame->addr1, &(neighbours.devices[i]), + sizeof(bdaddr_t)) == 0) + { + pos = i; + if (neighbours.fds[i] != -1) + { + found = 1; // save the position where it was found + FD_SET (neighbours.fds[i], &wfds); + maxfd = MAX (maxfd, neighbours.fds[i]); + sendsocket = neighbours.fds[i]; + fprintf (stderr, "LOG: the address was found in the list\n"); + break; + } + } } - if (0 < write_pout.size) //it can send messages only to one device per loop + if (found == 0) { - struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *frame; - /* Get the destination address */ - frame = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *)write_pout.buf; + int status; + struct sockaddr_rc addr = { 0 }; - if (memcmp(&frame->addr1, &dev.pl_mac, - sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) + fprintf (stderr, + "LOG : %s has a new message for %.2X:%.2X:%.2X:%.2X:%.2X:%.2X which isn't on the broadcast list\n", + dev.iface, + frame->addr1.mac[5], frame->addr1.mac[4], + frame->addr1.mac[3], + frame->addr1.mac[2], frame->addr1.mac[1], + frame->addr1.mac[0]); // FIXME: debugging message + + sendsocket = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); + + if (sendsocket < 0) + { + fprintf (stderr, + "Failed to create a RFCOMM socket (sending stage): %s\n", + strerror (errno)); + return -1; + } + + GNUNET_memcpy (&addr.rc_bdaddr, &frame->addr1, sizeof(bdaddr_t)); + addr.rc_family = AF_BLUETOOTH; + addr.rc_channel = get_channel (&dev, addr.rc_bdaddr); + + int tries = 0; +connect_retry: + status = connect (sendsocket, (struct sockaddr *) &addr, + sizeof(addr)); + if ((0 != status) &&(errno != EAGAIN) ) + { + if ((errno == ECONNREFUSED) &&(tries < 2) ) + { + fprintf (stderr, "LOG : %.*s failed to connect. Trying again!\n", + IFNAMSIZ, dev.iface); + tries++; + goto connect_retry; + } + else if (errno == EBADF) { + fprintf (stderr, "LOG : %s failed to connect : %s. Skip it!\n", + dev.iface, strerror (errno)); + memset (&write_pout, 0, sizeof(write_pout)); broadcast = 1; - memset(&write_pout, 0, sizeof(write_pout)); //clear the buffer } - else if (memcmp(&frame->addr1, &broadcast_address, - sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)) == 0) + else { - fprintf(stderr, "LOG : %s has a broadcast message (pos %d, size %d)\n", dev.iface, neighbours.pos, neighbours.size); //FIXME: debugging message - - if (send_broadcast(&dev, &sendsocket) != 0) //if the searching wasn't successful don't get stuck on the select stage - { - broadcast = 1; - memset(&write_pout, 0, sizeof(write_pout)); //remove the message - fprintf(stderr, "LOG : Skipping the broadcast message (pos %d, size %d)\n", neighbours.pos, neighbours.size); - } - else - { - FD_SET(sendsocket, &wfds); - maxfd = MAX(maxfd, sendsocket); - } + fprintf (stderr, + "LOG : %s failed to connect : %s. Try again later!\n", + dev.iface, + strerror (errno)); + memset (&write_pout, 0, sizeof(write_pout)); + broadcast = 1; } + } else + { + FD_SET (sendsocket, &wfds); + maxfd = MAX (maxfd, sendsocket); + fprintf (stderr, "LOG : Connection successful\n"); + if (pos != 0) // save the socket { - int found = 0; - int pos = 0; - /* Search if the address already exists on the list */ - for (i = 0; i < neighbours.size; i++) - { - if (memcmp(&frame->addr1, &(neighbours.devices[i]), sizeof(bdaddr_t)) == 0) - { - pos = i; - if (neighbours.fds[i] != -1) - { - found = 1; //save the position where it was found - FD_SET(neighbours.fds[i], &wfds); - maxfd = MAX(maxfd, neighbours.fds[i]); - sendsocket = neighbours.fds[i]; - fprintf(stderr, "LOG: the address was found in the list\n"); - break; - } - } - } - if (found == 0) - { - int status; - struct sockaddr_rc addr = { 0 }; - - fprintf(stderr, "LOG : %s has a new message for %.2X:%.2X:%.2X:%.2X:%.2X:%.2X which isn't on the broadcast list\n", dev.iface, - frame->addr1.mac[5], frame->addr1.mac[4], frame->addr1.mac[3], - frame->addr1.mac[2], frame->addr1.mac[1], frame->addr1.mac[0]); //FIXME: debugging message - - sendsocket = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); - - if (sendsocket < 0) - { - fprintf(stderr, "Failed to create a RFCOMM socket (sending stage): %s\n", - strerror(errno)); - return -1; - } - - GNUNET_memcpy(&addr.rc_bdaddr, &frame->addr1, sizeof(bdaddr_t)); - addr.rc_family = AF_BLUETOOTH; - addr.rc_channel = get_channel(&dev, addr.rc_bdaddr); - - int tries = 0; -connect_retry: - status = connect(sendsocket, (struct sockaddr *)&addr, sizeof(addr)); - if (0 != status && errno != EAGAIN) - { - if (errno == ECONNREFUSED && tries < 2) - { - fprintf(stderr, "LOG : %.*s failed to connect. Trying again!\n", IFNAMSIZ, dev.iface); - tries++; - goto connect_retry; - } - else if (errno == EBADF) - { - fprintf(stderr, "LOG : %s failed to connect : %s. Skip it!\n", dev.iface, strerror(errno)); - memset(&write_pout, 0, sizeof(write_pout)); - broadcast = 1; - } - else - { - fprintf(stderr, "LOG : %s failed to connect : %s. Try again later!\n", dev.iface, strerror(errno)); - memset(&write_pout, 0, sizeof(write_pout)); - broadcast = 1; - } - } - else - { - FD_SET(sendsocket, &wfds); - maxfd = MAX(maxfd, sendsocket); - fprintf(stderr, "LOG : Connection successful\n"); - if (pos != 0) // save the socket - { - neighbours.fds[pos] = sendsocket; - } - else - { - /* Add the new device to the discovered devices list */ - if (neighbours.size < MAX_PORTS) - { - neighbours.fds[neighbours.size] = sendsocket; - GNUNET_memcpy(&(neighbours.devices[neighbours.size++]), &addr.rc_bdaddr, sizeof(bdaddr_t)); - } - else - { - fprintf(stderr, "The top limit for the discovarable devices' list was reached\n"); - } - } - } - } + neighbours.fds[pos] = sendsocket; } + else + { + /* Add the new device to the discovered devices list */ + if (neighbours.size < MAX_PORTS) + { + neighbours.fds[neighbours.size] = sendsocket; + GNUNET_memcpy (&(neighbours.devices[neighbours.size++]), + &addr.rc_bdaddr, sizeof(bdaddr_t)); + } + else + { + fprintf (stderr, + "The top limit for the discovarable devices' list was reached\n"); + } + } + } } + } + } - if (broadcast == 0) + if (broadcast == 0) + { + /* Select a fd which is ready for action :) */ + { + int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL); + if ((-1 == retval) && (EINTR == errno)) + continue; + if ((0 > retval) &&(errno != EBADF) ) // we handle BADF errors later + { + fprintf (stderr, "select failed: %s\n", strerror (errno)); + break; + } + } + if (FD_ISSET (STDOUT_FILENO, &wfds)) + { + ssize_t ret = + write (STDOUT_FILENO, write_std.buf + write_std.pos, + write_std.size - write_std.pos); + if (0 > ret) + { + fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno)); + break; + } + write_std.pos += ret; + if (write_std.pos == write_std.size) { - /* Select a fd which is ready for action :) */ + write_std.pos = 0; + write_std.size = 0; + } + fprintf (stderr, "LOG : %s sends a message to STDOUT\n", dev.iface); // FIXME: debugging message + } + if (-1 != sendsocket) + { + if (FD_ISSET (sendsocket, &wfds)) + { + ssize_t ret = write (sendsocket, + write_pout.buf + write_std.pos, + write_pout.size - write_pout.pos); + if (0 > ret) // FIXME should I first check the error type? { - int retval = select(maxfd + 1, &rfds, &wfds, NULL, NULL); - if ((-1 == retval) && (EINTR == errno)) - continue; - if (0 > retval && errno != EBADF) // we handle BADF errors later + fprintf (stderr, + "Failed to write to bluetooth device: %s. Closing the socket!\n", + strerror (errno)); + for (i = 0; i < neighbours.size; i++) + { + if (neighbours.fds[i] == sendsocket) { - fprintf(stderr, "select failed: %s\n", strerror(errno)); + (void) close (sendsocket); + neighbours.fds[i] = -1; break; } + } + /* Remove the message */ + memset (&write_pout.buf + write_std.pos, 0, (write_pout.size + - write_pout.pos)); + write_pout.pos = 0; + write_pout.size = 0; } - if (FD_ISSET(STDOUT_FILENO, &wfds)) + else + { + write_pout.pos += ret; + if ((write_pout.pos != write_pout.size) && (0 != ret)) { - ssize_t ret = - write(STDOUT_FILENO, write_std.buf + write_std.pos, - write_std.size - write_std.pos); - if (0 > ret) - { - fprintf(stderr, "Failed to write to STDOUT: %s\n", strerror(errno)); - break; - } - write_std.pos += ret; - if (write_std.pos == write_std.size) - { - write_std.pos = 0; - write_std.size = 0; - } - fprintf(stderr, "LOG : %s sends a message to STDOUT\n", dev.iface); //FIXME: debugging message + /* We should not get partial sends with packet-oriented devices... */ + fprintf (stderr, "Write error, partial send: %u/%u\n", + (unsigned int) write_pout.pos, + (unsigned int) write_pout.size); + break; } - if (-1 != sendsocket) + + if (write_pout.pos == write_pout.size) { - if (FD_ISSET(sendsocket, &wfds)) - { - ssize_t ret = write(sendsocket, - write_pout.buf + write_std.pos, - write_pout.size - write_pout.pos); - if (0 > ret) //FIXME should I first check the error type? - { - fprintf(stderr, "Failed to write to bluetooth device: %s. Closing the socket!\n", - strerror(errno)); - for (i = 0; i < neighbours.size; i++) - { - if (neighbours.fds[i] == sendsocket) - { - (void)close(sendsocket); - neighbours.fds[i] = -1; - break; - } - } - /* Remove the message */ - memset(&write_pout.buf + write_std.pos, 0, (write_pout.size - write_pout.pos)); - write_pout.pos = 0; - write_pout.size = 0; - } - else - { - write_pout.pos += ret; - if ((write_pout.pos != write_pout.size) && (0 != ret)) - { - /* We should not get partial sends with packet-oriented devices... */ - fprintf(stderr, "Write error, partial send: %u/%u\n", - (unsigned int)write_pout.pos, - (unsigned int)write_pout.size); - break; - } - - if (write_pout.pos == write_pout.size) - { - write_pout.pos = 0; - write_pout.size = 0; - } - fprintf(stderr, "LOG : %s sends a message to a DEVICE\n", dev.iface); //FIXME: debugging message - } - } + write_pout.pos = 0; + write_pout.size = 0; + } + fprintf (stderr, "LOG : %s sends a message to a DEVICE\n", + dev.iface); // FIXME: debugging message + } + } + } + for (i = 0; i <= maxfd; i++) + { + if (FD_ISSET (i, &rfds)) + { + if (i == STDIN_FILENO) + { + ssize_t ret = + read (i, readbuf, sizeof(readbuf)); + if (0 > ret) + { + fprintf (stderr, + "Read error from STDIN: %s\n", + strerror (errno)); + break; } - for (i = 0; i <= maxfd; i++) + if (0 == ret) { - if (FD_ISSET(i, &rfds)) - { - if (i == STDIN_FILENO) - { - ssize_t ret = - read(i, readbuf, sizeof(readbuf)); - if (0 > ret) - { - fprintf(stderr, - "Read error from STDIN: %s\n", - strerror(errno)); - break; - } - if (0 == ret) - { - /* stop reading... */ - stdin_open = 0; - } - else - { - mst_receive(stdin_mst, readbuf, ret); - fprintf(stderr, "LOG : %s receives a message from STDIN\n", dev.iface); //FIXME: debugging message - } - } - else if (i == dev.fd_rfcomm) - { - int readsocket; - struct sockaddr_rc addr = { 0 }; - unsigned int opt = sizeof(addr); - - readsocket = accept(dev.fd_rfcomm, (struct sockaddr *)&addr, &opt); - fprintf(stderr, "LOG : %s accepts a message\n", dev.iface); //FIXME: debugging message - if (readsocket == -1) - { - fprintf(stderr, "Failed to accept a connection on interface: %.*s\n", IFNAMSIZ, - strerror(errno)); - break; - } - else - { - FD_SET(readsocket, &rfds); - maxfd = MAX(maxfd, readsocket); - - if (crt_rfds < MAX_PORTS) - rfds_list[crt_rfds++] = readsocket; - else - { - fprintf(stderr, "The limit for the read file descriptors list was \ + /* stop reading... */ + stdin_open = 0; + } + else + { + mst_receive (stdin_mst, readbuf, ret); + fprintf (stderr, "LOG : %s receives a message from STDIN\n", + dev.iface); // FIXME: debugging message + } + } + else if (i == dev.fd_rfcomm) + { + int readsocket; + struct sockaddr_rc addr = { 0 }; + unsigned int opt = sizeof(addr); + + readsocket = accept (dev.fd_rfcomm, (struct sockaddr *) &addr, + &opt); + fprintf (stderr, "LOG : %s accepts a message\n", dev.iface); // FIXME: debugging message + if (readsocket == -1) + { + fprintf (stderr, + "Failed to accept a connection on interface: %.*s\n", + IFNAMSIZ, + strerror (errno)); + break; + } + else + { + FD_SET (readsocket, &rfds); + maxfd = MAX (maxfd, readsocket); + + if (crt_rfds < MAX_PORTS) + rfds_list[crt_rfds++] = readsocket; + else + { + fprintf (stderr, + "The limit for the read file descriptors list was \ reached\n"); - break; - } - } - } - else - { - struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm; - ssize_t ret; - fprintf(stderr, "LOG : %s reads something from the socket\n", dev.iface);//FIXME : debugging message - rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *)write_std.buf; - ret = - read_from_the_socket((void *)&i, (unsigned char *)&rrm->frame, - sizeof(write_std.buf) - - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) - + sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame), - rrm); - if (0 >= ret) - { - int j; - FD_CLR(i, &rfds); - close(i); - /* Remove the socket from the list */ - for (j = 0; j < crt_rfds; j++) - { - if (rfds_list[j] == i) - { - rfds_list[j] ^= rfds_list[crt_rfds - 1]; - rfds_list[crt_rfds - 1] ^= rfds_list[j]; - rfds_list[j] ^= rfds_list[crt_rfds - 1]; - crt_rfds -= 1; - break; - } - } - - fprintf(stderr, "Read error from raw socket: %s\n", strerror(errno)); - break; - } - if ((0 < ret) && (0 == mac_test(&rrm->frame, &dev))) - { - write_std.size = ret - + sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) - - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame); - rrm->header.size = htons(write_std.size); - rrm->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); - } - } + break; + } + } + } + else + { + struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm; + ssize_t ret; + fprintf (stderr, "LOG : %s reads something from the socket\n", + dev.iface); // FIXME : debugging message + rrm = (struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf; + ret = + read_from_the_socket ((void *) &i, (unsigned char *) &rrm->frame, + sizeof(write_std.buf) + - sizeof(struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + + sizeof(struct + GNUNET_TRANSPORT_WLAN_Ieee80211Frame), + rrm); + if (0 >= ret) + { + int j; + FD_CLR (i, &rfds); + close (i); + /* Remove the socket from the list */ + for (j = 0; j < crt_rfds; j++) + { + if (rfds_list[j] == i) + { + rfds_list[j] ^= rfds_list[crt_rfds - 1]; + rfds_list[crt_rfds - 1] ^= rfds_list[j]; + rfds_list[j] ^= rfds_list[crt_rfds - 1]; + crt_rfds -= 1; + break; } + } + + fprintf (stderr, "Read error from raw socket: %s\n", strerror ( + errno)); + break; + } + if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev))) + { + write_std.size = ret + + sizeof(struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + - sizeof(struct + GNUNET_TRANSPORT_WLAN_Ieee80211Frame); + rrm->header.size = htons (write_std.size); + rrm->header.type = htons ( + GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); } + } } + } } + } /* Error handling, try to clean up a bit at least */ - mst_destroy(stdin_mst); + mst_destroy (stdin_mst); stdin_mst = NULL; - sdp_close(dev.session); - (void)close(dev.fd_rfcomm); + sdp_close (dev.session); + (void) close (dev.fd_rfcomm); if (-1 != sendsocket) - (void)close(sendsocket); + (void) close (sendsocket); for (i = 0; i < crt_rfds; i++) - (void)close(rfds_list[i]); + (void) close (rfds_list[i]); for (i = 0; i < neighbours.size; i++) - (void)close(neighbours.fds[i]); + (void) close (neighbours.fds[i]); #else struct HardwareInfos dev; struct GNUNET_NETWORK_Handle *sendsocket; @@ -1803,25 +1878,25 @@ connect_retry: SOCKADDR_BTH acc_addr = { 0 }; int addr_len = sizeof(SOCKADDR_BTH); int broadcast, i, stdin_open, crt_rfds = 0; - HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE); - HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); + HANDLE stdin_handle = GetStdHandle (STD_INPUT_HANDLE); + HANDLE stdout_handle = GetStdHandle (STD_OUTPUT_HANDLE); struct MessageStreamTokenizer *stdin_mst; /* check the handles */ if (stdin_handle == INVALID_HANDLE_VALUE) - { - fprintf(stderr, "Failed to get the stdin handle\n"); - ExitProcess(2); - } + { + fprintf (stderr, "Failed to get the stdin handle\n"); + ExitProcess (2); + } if (stdout_handle == INVALID_HANDLE_VALUE) - { - fprintf(stderr, "Failed to get the stdout handle\n"); - ExitProcess(2); - } + { + fprintf (stderr, "Failed to get the stdout handle\n"); + ExitProcess (2); + } /* initialize windows sockets */ - initialize_windows_sockets(); + initialize_windows_sockets (); // /* test bluetooth socket family support */ --> it return false because the GNUNET_NETWORK_test_pf should also receive the type of socket (BTHPROTO_RFCOMM) // if (GNUNET_NETWORK_test_pf (AF_BTH) != GNUNET_OK) @@ -1831,347 +1906,373 @@ connect_retry: // } /* create the socket */ - dev.handle = GNUNET_NETWORK_socket_create(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM); + dev.handle = GNUNET_NETWORK_socket_create (AF_BTH, SOCK_STREAM, + BTHPROTO_RFCOMM); if (dev.handle == NULL) - { - fprintf(stderr, "Failed to create RFCOMM socket: "); - print_last_error(); - ExitProcess(2); - } + { + fprintf (stderr, "Failed to create RFCOMM socket: "); + print_last_error (); + ExitProcess (2); + } - if (open_device(&dev) == -1) + if (open_device (&dev) == -1) + { + fprintf (stderr, "Failed to open the device\n"); + print_last_error (); + if (GNUNET_NETWORK_socket_close (dev.handle) != GNUNET_OK) { - fprintf(stderr, "Failed to open the device\n"); - print_last_error(); - if (GNUNET_NETWORK_socket_close(dev.handle) != GNUNET_OK) - { - fprintf(stderr, "Failed to close the socket!\n"); - print_last_error(); - } - ExitProcess(2); + fprintf (stderr, "Failed to close the socket!\n"); + print_last_error (); } + ExitProcess (2); + } - if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking(dev.handle, 1)) - { - fprintf(stderr, "Failed to change the socket mode\n"); - ExitProcess(2); - } + if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (dev.handle, 1)) + { + fprintf (stderr, "Failed to change the socket mode\n"); + ExitProcess (2); + } - memset(&write_std, 0, sizeof(write_std)); - memset(&write_pout, 0, sizeof(write_pout)); + memset (&write_std, 0, sizeof(write_std)); + memset (&write_pout, 0, sizeof(write_pout)); stdin_open = 1; - rfds = GNUNET_NETWORK_fdset_create(); - wfds = GNUNET_NETWORK_fdset_create(); + rfds = GNUNET_NETWORK_fdset_create (); + wfds = GNUNET_NETWORK_fdset_create (); /* Send MAC address of the bluetooth interface to STDOUT first */ { struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg; - macmsg.hdr.size = htons(sizeof(macmsg)); - macmsg.hdr.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); - GNUNET_memcpy(&macmsg.mac, &dev.pl_mac, sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress_Copy)); - GNUNET_memcpy(write_std.buf, &macmsg, sizeof(macmsg)); + macmsg.hdr.size = htons (sizeof(macmsg)); + macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); + GNUNET_memcpy (&macmsg.mac, &dev.pl_mac, sizeof(struct + GNUNET_TRANSPORT_WLAN_MacAddress_Copy)); + GNUNET_memcpy (write_std.buf, &macmsg, sizeof(macmsg)); write_std.size = sizeof(macmsg); } - stdin_mst = mst_create(&stdin_send_hw, &dev); + stdin_mst = mst_create (&stdin_send_hw, &dev); stdin_open = 1; int pos = 0; int stdin_pos = -1; int stdout_pos = -1; while (1) + { + broadcast = 0; + pos = 0; + stdin_pos = -1; + stdout_pos = -1; + sendsocket = NULL; // FIXME ???memleaks + + GNUNET_NETWORK_fdset_zero (rfds); + if ((0 == write_pout.size) && (1 == stdin_open)) { - broadcast = 0; - pos = 0; - stdin_pos = -1; - stdout_pos = -1; - sendsocket = NULL; //FIXME ???memleaks - - GNUNET_NETWORK_fdset_zero(rfds); - if ((0 == write_pout.size) && (1 == stdin_open)) + stdin_pos = pos; + pos += 1; + GNUNET_NETWORK_fdset_handle_set (rfds, (struct + GNUNET_DISK_FileHandle*) & + stdin_handle); + } + + if (0 == write_std.size) + { + pos += 1; + GNUNET_NETWORK_fdset_set (rfds, dev.handle); + } + + for (i = 0; i < crt_rfds; i++) + { + pos += 1; + GNUNET_NETWORK_fdset_set (rfds, rfds_list[i]); + } + + GNUNET_NETWORK_fdset_zero (wfds); + if (0 < write_std.size) + { + stdout_pos = pos; + GNUNET_NETWORK_fdset_handle_set (wfds, (struct + GNUNET_DISK_FileHandle*) & + stdout_handle); + // printf ("%s\n", write_std.buf); + // memset (write_std.buf, 0, write_std.size); + // write_std.size = 0; + } + + if (0 < write_pout.size) + { + if (strcmp (argv[1], "ff:ff:ff:ff:ff:ff") == 0) + { + fprintf (stderr, "LOG: BROADCAST! Skipping the message\n"); + // skip the message + broadcast = 1; + memset (write_pout.buf, 0, write_pout.size); + write_pout.size = 0; + } + else + { + SOCKADDR_BTH addr; + fprintf (stderr, "LOG : has a new message for %s\n", argv[1]); + sendsocket = GNUNET_NETWORK_socket_create (AF_BTH, SOCK_STREAM, + BTHPROTO_RFCOMM); + + if (sendsocket == NULL) { - stdin_pos = pos; - pos += 1; - GNUNET_NETWORK_fdset_handle_set(rfds, (struct GNUNET_DISK_FileHandle*)&stdin_handle); + fprintf (stderr, "Failed to create RFCOMM socket: \n"); + print_last_error (); + ExitProcess (2); } - if (0 == write_std.size) + memset (&addr, 0, sizeof(addr)); + // addr.addressFamily = AF_BTH; + if (SOCKET_ERROR == + WSAStringToAddress (argv[1], AF_BTH, NULL, (LPSOCKADDR) &addr, + &addr_len)) + { + fprintf (stderr, "Failed to translate the address: "); + print_last_error (); + ExitProcess (2); + } + addr.port = get_channel (argv[1]); + if (addr.port == -1) + { + fprintf (stderr, + "Couldn't find the sdp service for the address: %s\n", + argv[1]); + memset (write_pout.buf, 0, write_pout.size); + write_pout.size = 0; + broadcast = 1; // skipping the select part + } + else { - pos += 1; - GNUNET_NETWORK_fdset_set(rfds, dev.handle); + if (GNUNET_OK != GNUNET_NETWORK_socket_connect (sendsocket, + (LPSOCKADDR) &addr, + addr_len)) + { + fprintf (stderr, "Failed to connect: "); + print_last_error (); + ExitProcess (2); + } + + if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (sendsocket, 1)) + { + fprintf (stderr, "Failed to change the socket mode\n"); + ExitProcess (2); + } + + GNUNET_NETWORK_fdset_set (wfds, sendsocket); } + } + } - for (i = 0; i < crt_rfds; i++) + if (broadcast == 0) + { + int retval = GNUNET_NETWORK_socket_select (rfds, wfds, NULL, + GNUNET_TIME_relative_get_forever_ ()); + if (retval < 0) + { + fprintf (stderr, "Select error\n"); + ExitProcess (2); + } + // if (GNUNET_NETWORK_fdset_isset (wfds, (struct GNUNET_NETWORK_Handle*)&stdout_handle)) + if (retval == stdout_pos) + { + fprintf (stderr, "LOG : sends a message to STDOUT\n"); // FIXME: debugging message + // ssize_t ret; + // ret = GNUNET_NETWORK_socket_send ((struct GNUNET_NETWORK_Handle *)&stdout_handle, write_std.buf + write_std.pos, write_std.size - write_std.pos); + // ret = write (STDOUT_FILENO, write_std.buf + write_std.pos, write_std.size - write_std.pos); + DWORD ret; + if (FALSE == WriteFile (stdout_handle, write_std.buf + write_std.pos, + write_std.size - write_std.pos, &ret, NULL)) { - pos += 1; - GNUNET_NETWORK_fdset_set(rfds, rfds_list[i]); + fprintf (stderr, "Failed to write to STDOUT: "); + print_last_error (); + break; } - GNUNET_NETWORK_fdset_zero(wfds); - if (0 < write_std.size) + if (ret <= 0) { - stdout_pos = pos; - GNUNET_NETWORK_fdset_handle_set(wfds, (struct GNUNET_DISK_FileHandle*)&stdout_handle); - // printf ("%s\n", write_std.buf); - // memset (write_std.buf, 0, write_std.size); - // write_std.size = 0; + fprintf (stderr, "Failed to write to STDOUT\n"); + ExitProcess (2); } - if (0 < write_pout.size) + write_std.pos += ret; + if (write_std.pos == write_std.size) + { + write_std.pos = 0; + write_std.size = 0; + } + } + if (sendsocket != NULL) + { + if (GNUNET_NETWORK_fdset_isset (wfds, sendsocket)) { - if (strcmp(argv[1], "ff:ff:ff:ff:ff:ff") == 0) + ssize_t ret; + ret = GNUNET_NETWORK_socket_send (sendsocket, write_pout.buf + + write_pout.pos, + write_pout.size - write_pout.pos); + + if (GNUNET_SYSERR == ret) + { + fprintf (stderr, + "Failed to send to the socket. Closing the socket. Error: \n"); + print_last_error (); + if (GNUNET_NETWORK_socket_close (sendsocket) != GNUNET_OK) { - fprintf(stderr, "LOG: BROADCAST! Skipping the message\n"); - // skip the message - broadcast = 1; - memset(write_pout.buf, 0, write_pout.size); - write_pout.size = 0; + fprintf (stderr, "Failed to close the sendsocket!\n"); + print_last_error (); } + ExitProcess (2); + } else + { + write_pout.pos += ret; + if ((write_pout.pos != write_pout.size) && (0 != ret)) { - SOCKADDR_BTH addr; - fprintf(stderr, "LOG : has a new message for %s\n", argv[1]); - sendsocket = GNUNET_NETWORK_socket_create(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM); - - if (sendsocket == NULL) - { - fprintf(stderr, "Failed to create RFCOMM socket: \n"); - print_last_error(); - ExitProcess(2); - } - - memset(&addr, 0, sizeof(addr)); - //addr.addressFamily = AF_BTH; - if (SOCKET_ERROR == - WSAStringToAddress(argv[1], AF_BTH, NULL, (LPSOCKADDR)&addr, &addr_len)) - { - fprintf(stderr, "Failed to translate the address: "); - print_last_error(); - ExitProcess(2); - } - addr.port = get_channel(argv[1]); - if (addr.port == -1) - { - fprintf(stderr, "Couldn't find the sdp service for the address: %s\n", argv[1]); - memset(write_pout.buf, 0, write_pout.size); - write_pout.size = 0; - broadcast = 1; //skipping the select part - } - else - { - if (GNUNET_OK != GNUNET_NETWORK_socket_connect(sendsocket, (LPSOCKADDR)&addr, addr_len)) - { - fprintf(stderr, "Failed to connect: "); - print_last_error(); - ExitProcess(2); - } - - if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking(sendsocket, 1)) - { - fprintf(stderr, "Failed to change the socket mode\n"); - ExitProcess(2); - } - - GNUNET_NETWORK_fdset_set(wfds, sendsocket); - } + /* we should not get partial sends with packet-oriented devices... */ + fprintf (stderr, "Write error, partial send: %u/%u\n", + (unsigned int) write_pout.pos, + (unsigned int) write_pout.size); + break; } - } - if (broadcast == 0) - { - int retval = GNUNET_NETWORK_socket_select(rfds, wfds, NULL, GNUNET_TIME_relative_get_forever_()); - if (retval < 0) + if (write_pout.pos == write_pout.size) { - fprintf(stderr, "Select error\n"); - ExitProcess(2); + write_pout.pos = 0; + write_pout.size = 0; } - //if (GNUNET_NETWORK_fdset_isset (wfds, (struct GNUNET_NETWORK_Handle*)&stdout_handle)) - if (retval == stdout_pos) - { - fprintf(stderr, "LOG : sends a message to STDOUT\n"); //FIXME: debugging message - //ssize_t ret; - //ret = GNUNET_NETWORK_socket_send ((struct GNUNET_NETWORK_Handle *)&stdout_handle, write_std.buf + write_std.pos, write_std.size - write_std.pos); - //ret = write (STDOUT_FILENO, write_std.buf + write_std.pos, write_std.size - write_std.pos); - DWORD ret; - if (FALSE == WriteFile(stdout_handle, write_std.buf + write_std.pos, write_std.size - write_std.pos, &ret, NULL)) - { - fprintf(stderr, "Failed to write to STDOUT: "); - print_last_error(); - break; - } + fprintf (stderr, "LOG : sends a message to a DEVICE\n"); // FIXME: debugging message + } + } + } - if (ret <= 0) - { - fprintf(stderr, "Failed to write to STDOUT\n"); - ExitProcess(2); - } + // if (GNUNET_NETWORK_fdset_isset (rfds, (struct GNUNET_NETWORK_Handle*)&stdin_handle)) + if (retval == stdin_pos) + { + // ssize_t ret; + // ret = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)&stdin_handle, readbuf, sizeof (write_pout.buf)); + // ret = read (STDIN_FILENO, readbuf, sizeof (readbuf)); + DWORD ret; + if (FALSE == ReadFile (stdin_handle, readbuf, sizeof(readbuf), &ret, + NULL)) /* do nothing asynchronous */ + { + fprintf (stderr, "Read error from STDIN: "); + print_last_error (); + break; + } + if (0 == ret) + { + /* stop reading... */ + stdin_open = 0; + } + else + { + mst_receive (stdin_mst, readbuf, ret); + fprintf (stderr, "LOG : receives a message from STDIN\n"); // FIXME: debugging message + } + } + else if (GNUNET_NETWORK_fdset_isset (rfds, dev.handle)) + { + fprintf (stderr, "LOG: accepting connection\n"); + struct GNUNET_NETWORK_Handle *readsocket; + readsocket = GNUNET_NETWORK_socket_accept (dev.handle, + (LPSOCKADDR) &acc_addr, + &addr_len); + if (readsocket == NULL) + { + fprintf (stderr, "Accept error %d: ", GetLastError ()); + print_last_error (); + ExitProcess (2); + } + else + { + if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (readsocket, 1)) + { + fprintf (stderr, "Failed to change the socket mode\n"); + ExitProcess (2); + } + GNUNET_NETWORK_fdset_set (rfds, readsocket); - write_std.pos += ret; - if (write_std.pos == write_std.size) - { - write_std.pos = 0; - write_std.size = 0; - } - } - if (sendsocket != NULL) + if (crt_rfds < MAX_PORTS) + rfds_list[crt_rfds++] = readsocket; + else + { + fprintf (stderr, + "The limit for the read file descriptors list was reached\n"); + break; + } + } + } + else + for (i = 0; i < crt_rfds; i++) + { + if (GNUNET_NETWORK_fdset_isset (rfds, rfds_list[i])) + { + struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm; + ssize_t ret; + fprintf (stderr, "LOG: reading something from the socket\n"); // FIXME : debugging message + rrm = (struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf; + ret = read_from_the_socket (rfds_list[i], (unsigned + char *) &rrm->frame, + sizeof(write_std.buf) + - sizeof(struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + + sizeof(struct + GNUNET_TRANSPORT_WLAN_Ieee80211Frame), + rrm); + if (0 >= ret) { - if (GNUNET_NETWORK_fdset_isset(wfds, sendsocket)) - { - ssize_t ret; - ret = GNUNET_NETWORK_socket_send(sendsocket, write_pout.buf + write_pout.pos, - write_pout.size - write_pout.pos); - - if (GNUNET_SYSERR == ret) - { - fprintf(stderr, "Failed to send to the socket. Closing the socket. Error: \n"); - print_last_error(); - if (GNUNET_NETWORK_socket_close(sendsocket) != GNUNET_OK) - { - fprintf(stderr, "Failed to close the sendsocket!\n"); - print_last_error(); - } - ExitProcess(2); - } - else - { - write_pout.pos += ret; - if ((write_pout.pos != write_pout.size) && (0 != ret)) - { - /* we should not get partial sends with packet-oriented devices... */ - fprintf(stderr, "Write error, partial send: %u/%u\n", - (unsigned int)write_pout.pos, - (unsigned int)write_pout.size); - break; - } - - if (write_pout.pos == write_pout.size) - { - write_pout.pos = 0; - write_pout.size = 0; - } - fprintf(stderr, "LOG : sends a message to a DEVICE\n"); //FIXME: debugging message - } - } - } + // TODO remove the socket from the list + if (GNUNET_NETWORK_socket_close (rfds_list[i]) != GNUNET_OK) + { + fprintf (stderr, "Failed to close the sendsocket!\n"); + print_last_error (); + } - //if (GNUNET_NETWORK_fdset_isset (rfds, (struct GNUNET_NETWORK_Handle*)&stdin_handle)) - if (retval == stdin_pos) - { - //ssize_t ret; - //ret = GNUNET_NETWORK_socket_recv ((struct GNUNET_NETWORK_Handle *)&stdin_handle, readbuf, sizeof (write_pout.buf)); - //ret = read (STDIN_FILENO, readbuf, sizeof (readbuf)); - DWORD ret; - if (FALSE == ReadFile(stdin_handle, readbuf, sizeof(readbuf), &ret, NULL)) /* do nothing asynchronous */ - { - fprintf(stderr, "Read error from STDIN: "); - print_last_error(); - break; - } - if (0 == ret) - { - /* stop reading... */ - stdin_open = 0; - } - else - { - mst_receive(stdin_mst, readbuf, ret); - fprintf(stderr, "LOG : receives a message from STDIN\n"); //FIXME: debugging message - } + fprintf (stderr, "Read error from raw socket: "); + print_last_error (); + break; } - else - if (GNUNET_NETWORK_fdset_isset(rfds, dev.handle)) + if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev))) { - fprintf(stderr, "LOG: accepting connection\n"); - struct GNUNET_NETWORK_Handle *readsocket; - readsocket = GNUNET_NETWORK_socket_accept(dev.handle, (LPSOCKADDR)&acc_addr, &addr_len); - if (readsocket == NULL) - { - fprintf(stderr, "Accept error %d: ", GetLastError()); - print_last_error(); - ExitProcess(2); - } - else - { - if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking(readsocket, 1)) - { - fprintf(stderr, "Failed to change the socket mode\n"); - ExitProcess(2); - } - GNUNET_NETWORK_fdset_set(rfds, readsocket); - - if (crt_rfds < MAX_PORTS) - rfds_list[crt_rfds++] = readsocket; - else - { - fprintf(stderr, "The limit for the read file descriptors list was reached\n"); - break; - } - } + write_std.size = ret + + sizeof(struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + - sizeof(struct + GNUNET_TRANSPORT_WLAN_Ieee80211Frame); + rrm->header.size = htons (write_std.size); + rrm->header.type = htons ( + GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); } - else - for (i = 0; i < crt_rfds; i++) - { - if (GNUNET_NETWORK_fdset_isset(rfds, rfds_list[i])) - { - struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm; - ssize_t ret; - fprintf(stderr, "LOG: reading something from the socket\n");//FIXME : debugging message - rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *)write_std.buf; - ret = read_from_the_socket(rfds_list[i], (unsigned char *)&rrm->frame, - sizeof(write_std.buf) - - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) - + sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame), - rrm); - if (0 >= ret) - { - //TODO remove the socket from the list - if (GNUNET_NETWORK_socket_close(rfds_list[i]) != GNUNET_OK) - { - fprintf(stderr, "Failed to close the sendsocket!\n"); - print_last_error(); - } - - fprintf(stderr, "Read error from raw socket: "); - print_last_error(); - break; - } - if ((0 < ret) && (0 == mac_test(&rrm->frame, &dev))) - { - write_std.size = ret - + sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) - - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame); - rrm->header.size = htons(write_std.size); - rrm->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); - } - break; - } - } + break; + } } } + } - mst_destroy(stdin_mst); + mst_destroy (stdin_mst); stdin_mst = NULL; - if (GNUNET_NETWORK_socket_close(dev.handle) != GNUNET_OK) - { - fprintf(stderr, "Failed to close the socket!\n"); - print_last_error(); - } + if (GNUNET_NETWORK_socket_close (dev.handle) != GNUNET_OK) + { + fprintf (stderr, "Failed to close the socket!\n"); + print_last_error (); + } for (i = 0; i < crt_rfds; i++) + { + if (GNUNET_NETWORK_socket_close (rfds_list[i]) != GNUNET_OK) { - if (GNUNET_NETWORK_socket_close(rfds_list[i]) != GNUNET_OK) - { - fprintf(stderr, "Failed to close the socket!\n"); - print_last_error(); - } + fprintf (stderr, "Failed to close the socket!\n"); + print_last_error (); } + } - WSACleanup(); + WSACleanup (); #endif return 1; /* we never exit 'normally' */ } diff --git a/src/transport/gnunet-helper-transport-wlan-dummy.c b/src/transport/gnunet-helper-transport-wlan-dummy.c index 44a54b7f6..ab77f5c68 100644 --- a/src/transport/gnunet-helper-transport-wlan-dummy.c +++ b/src/transport/gnunet-helper-transport-wlan-dummy.c @@ -47,7 +47,8 @@ /** * IO buffer used for buffering data in transit. */ -struct SendBuffer { +struct SendBuffer +{ /** * How many bytes that were stored in 'buf' did we already write to the * destination? Always smaller than 'size'. @@ -80,11 +81,11 @@ static int closeprog; * @param sig killing signal */ static void -sigfunc(int sig) +sigfunc (int sig) { closeprog = 1; - (void)unlink(FIFO_FILE1); - (void)unlink(FIFO_FILE2); + (void) unlink (FIFO_FILE1); + (void) unlink (FIFO_FILE2); } @@ -96,19 +97,19 @@ sigfunc(int sig) * @return number of bytes written */ static int -send_mac_to_plugin(char *buffer, struct GNUNET_TRANSPORT_WLAN_MacAddress *mac) +send_mac_to_plugin (char *buffer, struct GNUNET_TRANSPORT_WLAN_MacAddress *mac) { struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg; - GNUNET_memcpy(&macmsg.mac, - (char *)mac, - sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)); + GNUNET_memcpy (&macmsg.mac, + (char *) mac, + sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)); macmsg.hdr.size = - htons(sizeof(struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)); - macmsg.hdr.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); - GNUNET_memcpy(buffer, - &macmsg, - sizeof(struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)); + htons (sizeof(struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)); + macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); + GNUNET_memcpy (buffer, + &macmsg, + sizeof(struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)); return sizeof(struct GNUNET_TRANSPORT_WLAN_HelperControlMessage); } @@ -124,7 +125,7 @@ send_mac_to_plugin(char *buffer, struct GNUNET_TRANSPORT_WLAN_MacAddress *mac) * #GNUNET_SYSERR to stop further processing with error */ static int -stdin_send(void *cls, const struct GNUNET_MessageHeader *hdr) +stdin_send (void *cls, const struct GNUNET_MessageHeader *hdr) { struct SendBuffer *write_pout = cls; const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *in; @@ -132,32 +133,32 @@ stdin_send(void *cls, const struct GNUNET_MessageHeader *hdr) struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage newheader; uint16_t sendsize; - sendsize = ntohs(hdr->size); - in = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *)hdr; - if ((GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs(hdr->type)) || + sendsize = ntohs (hdr->size); + in = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr; + if ((GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)) || (sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) > sendsize)) - { - fprintf(stderr, "%s", "Received malformed message\n"); - exit(1); - } + { + fprintf (stderr, "%s", "Received malformed message\n"); + exit (1); + } payload_size = sendsize - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage); - if ((payload_size + - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + - write_pout->size) > MAXLINE * 2) - { - fprintf(stderr, "%s", "Packet too big for buffer\n"); - exit(1); - } - memset(&newheader, 0, sizeof(newheader)); - newheader.header.size = htons(payload_size + sizeof(newheader)); - newheader.header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); + if ((payload_size + + sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + + write_pout->size) > MAXLINE * 2) + { + fprintf (stderr, "%s", "Packet too big for buffer\n"); + exit (1); + } + memset (&newheader, 0, sizeof(newheader)); + newheader.header.size = htons (payload_size + sizeof(newheader)); + newheader.header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); newheader.frame = in->frame; - GNUNET_memcpy(write_pout->buf + write_pout->size, - &newheader, - sizeof(newheader)); + GNUNET_memcpy (write_pout->buf + write_pout->size, + &newheader, + sizeof(newheader)); write_pout->size += sizeof(newheader); - GNUNET_memcpy(write_pout->buf + write_pout->size, &in[1], payload_size); + GNUNET_memcpy (write_pout->buf + write_pout->size, &in[1], payload_size); write_pout->size += payload_size; return GNUNET_OK; } @@ -173,18 +174,18 @@ stdin_send(void *cls, const struct GNUNET_MessageHeader *hdr) * #GNUNET_SYSERR to stop further processing with error */ static int -file_in_send(void *cls, const struct GNUNET_MessageHeader *hdr) +file_in_send (void *cls, const struct GNUNET_MessageHeader *hdr) { struct SendBuffer *write_std = cls; uint16_t sendsize; - sendsize = ntohs(hdr->size); + sendsize = ntohs (hdr->size); if ((sendsize + write_std->size) > MAXLINE * 2) - { - fprintf(stderr, "%s", "Packet too big for buffer\n"); - exit(1); - } - GNUNET_memcpy(write_std->buf + write_std->size, hdr, sendsize); + { + fprintf (stderr, "%s", "Packet too big for buffer\n"); + exit (1); + } + GNUNET_memcpy (write_std->buf + write_std->size, hdr, sendsize); write_std->size += sendsize; return GNUNET_OK; } @@ -198,7 +199,7 @@ file_in_send(void *cls, const struct GNUNET_MessageHeader *hdr) * @return 1 on error, 0 if terminated normally via signal */ int -main(int argc, char *argv[]) +main (int argc, char *argv[]) { struct stat st; int erg; @@ -222,298 +223,298 @@ main(int argc, char *argv[]) int first; if ((2 != argc) || - ((0 != strcmp(argv[1], "1")) && (0 != strcmp(argv[1], "2")))) - { - fprintf( - stderr, - "%s", - "This program must be started with the operating mode (1 or 2) as the only argument.\n"); - return 1; - } + ((0 != strcmp (argv[1], "1")) && (0 != strcmp (argv[1], "2")))) + { + fprintf ( + stderr, + "%s", + "This program must be started with the operating mode (1 or 2) as the only argument.\n"); + return 1; + } /* make the fifos if needed */ - umask(0); - if ((GNUNET_OK != GNUNET_DISK_directory_create_for_file(FIFO_FILE1)) || - (GNUNET_OK != GNUNET_DISK_directory_create_for_file(FIFO_FILE2))) + umask (0); + if ((GNUNET_OK != GNUNET_DISK_directory_create_for_file (FIFO_FILE1)) || + (GNUNET_OK != GNUNET_DISK_directory_create_for_file (FIFO_FILE2))) + { + fprintf (stderr, "Failed to create directory for file `%s'\n", FIFO_FILE1); + return 1; + } + if (0 == strcmp (argv[1], "1")) + { + if (0 != stat (FIFO_FILE1, &st)) { - fprintf(stderr, "Failed to create directory for file `%s'\n", FIFO_FILE1); - return 1; - } - if (0 == strcmp(argv[1], "1")) - { - if (0 != stat(FIFO_FILE1, &st)) - { - erg = mkfifo(FIFO_FILE1, 0666); - if ((0 != erg) && (EEXIST != errno)) - fprintf(stderr, - "Error in mkfifo(%s): %s\n", - FIFO_FILE1, - strerror(errno)); - } + erg = mkfifo (FIFO_FILE1, 0666); + if ((0 != erg) && (EEXIST != errno)) + fprintf (stderr, + "Error in mkfifo(%s): %s\n", + FIFO_FILE1, + strerror (errno)); } + } else + { + if (0 != stat (FIFO_FILE2, &st)) { - if (0 != stat(FIFO_FILE2, &st)) - { - GNUNET_break(0 == (erg = mkfifo(FIFO_FILE2, 0666))); - if ((0 != erg) && (EEXIST != errno)) - fprintf(stderr, - "Error in mkfifo(%s): %s\n", - FIFO_FILE2, - strerror(errno)); - } + GNUNET_break (0 == (erg = mkfifo (FIFO_FILE2, 0666))); + if ((0 != erg) && (EEXIST != errno)) + fprintf (stderr, + "Error in mkfifo(%s): %s\n", + FIFO_FILE2, + strerror (errno)); } + } - if (0 == strcmp(argv[1], "1")) + if (0 == strcmp (argv[1], "1")) + { + first = 1; + fpin = fopen (FIFO_FILE1, "r"); + if (NULL == fpin) { - first = 1; - fpin = fopen(FIFO_FILE1, "r"); - if (NULL == fpin) - { - fprintf(stderr, - "fopen of read FIFO_FILE1 failed: %s\n", - strerror(errno)); - goto end; - } - if (NULL == (fpout = fopen(FIFO_FILE2, "w"))) - { - GNUNET_break(0 == mkfifo(FIFO_FILE2, 0666)); - fpout = fopen(FIFO_FILE2, "w"); - } - if (NULL == fpout) - { - fprintf(stderr, - "fopen of write FIFO_FILE2 failed: %s\n", - strerror(errno)); - goto end; - } + fprintf (stderr, + "fopen of read FIFO_FILE1 failed: %s\n", + strerror (errno)); + goto end; + } + if (NULL == (fpout = fopen (FIFO_FILE2, "w"))) + { + GNUNET_break (0 == mkfifo (FIFO_FILE2, 0666)); + fpout = fopen (FIFO_FILE2, "w"); } + if (NULL == fpout) + { + fprintf (stderr, + "fopen of write FIFO_FILE2 failed: %s\n", + strerror (errno)); + goto end; + } + } else + { + first = 0; + if (NULL == (fpout = fopen (FIFO_FILE1, "w"))) { - first = 0; - if (NULL == (fpout = fopen(FIFO_FILE1, "w"))) - { - GNUNET_break(0 == mkfifo(FIFO_FILE1, 0666)); - fpout = fopen(FIFO_FILE1, "w"); - } - if (NULL == fpout) - { - fprintf(stderr, - "fopen of write FIFO_FILE1 failed: %s\n", - strerror(errno)); - goto end; - } - fpin = fopen(FIFO_FILE2, "r"); - if (NULL == fpin) - { - fprintf(stderr, - "fopen of read FIFO_FILE2 failed: %s\n", - strerror(errno)); - goto end; - } + GNUNET_break (0 == mkfifo (FIFO_FILE1, 0666)); + fpout = fopen (FIFO_FILE1, "w"); } - - fdpin = fileno(fpin); - GNUNET_assert(fpin >= 0); - if (fdpin >= FD_SETSIZE) + if (NULL == fpout) { - fprintf(stderr, - "File fdpin number too large (%d > %u)\n", - fdpin, - (unsigned int)FD_SETSIZE); + fprintf (stderr, + "fopen of write FIFO_FILE1 failed: %s\n", + strerror (errno)); goto end; } - - fdpout = fileno(fpout); - GNUNET_assert(fdpout >= 0); - - if (fdpout >= FD_SETSIZE) + fpin = fopen (FIFO_FILE2, "r"); + if (NULL == fpin) { - fprintf(stderr, - "File fdpout number too large (%d > %u)\n", - fdpout, - (unsigned int)FD_SETSIZE); + fprintf (stderr, + "fopen of read FIFO_FILE2 failed: %s\n", + strerror (errno)); goto end; } + } + + fdpin = fileno (fpin); + GNUNET_assert (fpin >= 0); + if (fdpin >= FD_SETSIZE) + { + fprintf (stderr, + "File fdpin number too large (%d > %u)\n", + fdpin, + (unsigned int) FD_SETSIZE); + goto end; + } - signal(SIGINT, &sigfunc); - signal(SIGTERM, &sigfunc); - signal(GNUNET_TERM_SIG, &sigfunc); + fdpout = fileno (fpout); + GNUNET_assert (fdpout >= 0); + + if (fdpout >= FD_SETSIZE) + { + fprintf (stderr, + "File fdpout number too large (%d > %u)\n", + fdpout, + (unsigned int) FD_SETSIZE); + goto end; + } + + signal (SIGINT, &sigfunc); + signal (SIGTERM, &sigfunc); + signal (GNUNET_TERM_SIG, &sigfunc); write_std.size = 0; write_std.pos = 0; write_pout.size = 0; write_pout.pos = 0; - stdin_mst = GNUNET_MST_create(&stdin_send, &write_pout); - file_in_mst = GNUNET_MST_create(&file_in_send, &write_std); + stdin_mst = GNUNET_MST_create (&stdin_send, &write_pout); + file_in_mst = GNUNET_MST_create (&file_in_send, &write_std); /* Send 'random' mac address */ macaddr.mac[0] = 0x13; macaddr.mac[1] = 0x22; macaddr.mac[2] = 0x33; macaddr.mac[3] = 0x44; - macaddr.mac[4] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 256); - macaddr.mac[5] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, 256); - write_std.size = send_mac_to_plugin(write_std.buf, &macaddr); + macaddr.mac[4] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 256); + macaddr.mac[5] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, 256); + write_std.size = send_mac_to_plugin (write_std.buf, &macaddr); while (0 == closeprog) + { + maxfd = -1; + tv.tv_sec = 5; + tv.tv_usec = 0; + + FD_ZERO (&rfds); + FD_ZERO (&wfds); + /* if output queue is empty, read */ + if (0 == write_pout.size) { - maxfd = -1; - tv.tv_sec = 5; - tv.tv_usec = 0; - - FD_ZERO(&rfds); - FD_ZERO(&wfds); - /* if output queue is empty, read */ - if (0 == write_pout.size) - { - FD_SET(STDIN_FILENO, &rfds); - maxfd = MAX(STDIN_FILENO, maxfd); - } - if (0 == write_std.size) - { - FD_SET(fdpin, &rfds); - maxfd = MAX(fdpin, maxfd); - } + FD_SET (STDIN_FILENO, &rfds); + maxfd = MAX (STDIN_FILENO, maxfd); + } + if (0 == write_std.size) + { + FD_SET (fdpin, &rfds); + maxfd = MAX (fdpin, maxfd); + } - /* if there is something to write, try to write */ - if (0 < write_std.size) - { - FD_SET(STDOUT_FILENO, &wfds); - maxfd = MAX(maxfd, STDOUT_FILENO); - } - if (0 < write_pout.size) - { - FD_SET(fdpout, &wfds); - maxfd = MAX(maxfd, fdpout); - } + /* if there is something to write, try to write */ + if (0 < write_std.size) + { + FD_SET (STDOUT_FILENO, &wfds); + maxfd = MAX (maxfd, STDOUT_FILENO); + } + if (0 < write_pout.size) + { + FD_SET (fdpout, &wfds); + maxfd = MAX (maxfd, fdpout); + } - retval = select(maxfd + 1, &rfds, &wfds, NULL, &tv); - if ((-1 == retval) && (EINTR == errno)) - continue; - if (0 > retval) - { - fprintf(stderr, "select failed: %s\n", strerror(errno)); - closeprog = 1; - break; - } + retval = select (maxfd + 1, &rfds, &wfds, NULL, &tv); + if ((-1 == retval) && (EINTR == errno)) + continue; + if (0 > retval) + { + fprintf (stderr, "select failed: %s\n", strerror (errno)); + closeprog = 1; + break; + } - if (FD_ISSET(STDOUT_FILENO, &wfds)) + if (FD_ISSET (STDOUT_FILENO, &wfds)) + { + ret = write (STDOUT_FILENO, + write_std.buf + write_std.pos, + write_std.size - write_std.pos); + if (0 > ret) + { + closeprog = 1; + fprintf (stderr, + "Write ERROR to STDOUT_FILENO: %s\n", + strerror (errno)); + break; + } + else + { + write_std.pos += ret; + /* check if finished writing */ + if (write_std.pos == write_std.size) { - ret = write(STDOUT_FILENO, - write_std.buf + write_std.pos, - write_std.size - write_std.pos); - if (0 > ret) - { - closeprog = 1; - fprintf(stderr, - "Write ERROR to STDOUT_FILENO: %s\n", - strerror(errno)); - break; - } - else - { - write_std.pos += ret; - /* check if finished writing */ - if (write_std.pos == write_std.size) - { - write_std.pos = 0; - write_std.size = 0; - } - } + write_std.pos = 0; + write_std.size = 0; } + } + } - if (FD_ISSET(fdpout, &wfds)) + if (FD_ISSET (fdpout, &wfds)) + { + ret = write (fdpout, + write_pout.buf + write_pout.pos, + write_pout.size - write_pout.pos); + + if (0 > ret) + { + closeprog = 1; + fprintf (stderr, + "Write ERROR to fdpout failed: %s\n", + strerror (errno)); + } + else + { + write_pout.pos += ret; + /* check if finished writing */ + if (write_pout.pos == write_pout.size) { - ret = write(fdpout, - write_pout.buf + write_pout.pos, - write_pout.size - write_pout.pos); - - if (0 > ret) - { - closeprog = 1; - fprintf(stderr, - "Write ERROR to fdpout failed: %s\n", - strerror(errno)); - } - else - { - write_pout.pos += ret; - /* check if finished writing */ - if (write_pout.pos == write_pout.size) - { - write_pout.pos = 0; - write_pout.size = 0; - } - } + write_pout.pos = 0; + write_pout.size = 0; } + } + } - if (FD_ISSET(STDIN_FILENO, &rfds)) - { - readsize = read(STDIN_FILENO, readbuf, sizeof(readbuf)); - - if (0 > readsize) - { - closeprog = 1; - fprintf(stderr, - "Error reading from STDIN_FILENO: %s\n", - strerror(errno)); - } - else if (0 < readsize) - { - GNUNET_MST_from_buffer(stdin_mst, - readbuf, - readsize, - GNUNET_NO, - GNUNET_NO); - } - else - { - /* eof */ - closeprog = 1; - } - } + if (FD_ISSET (STDIN_FILENO, &rfds)) + { + readsize = read (STDIN_FILENO, readbuf, sizeof(readbuf)); + + if (0 > readsize) + { + closeprog = 1; + fprintf (stderr, + "Error reading from STDIN_FILENO: %s\n", + strerror (errno)); + } + else if (0 < readsize) + { + GNUNET_MST_from_buffer (stdin_mst, + readbuf, + readsize, + GNUNET_NO, + GNUNET_NO); + } + else + { + /* eof */ + closeprog = 1; + } + } - if (FD_ISSET(fdpin, &rfds)) - { - readsize = read(fdpin, readbuf, sizeof(readbuf)); - if (0 > readsize) - { - closeprog = 1; - fprintf(stderr, "Error reading from fdpin: %s\n", strerror(errno)); - break; - } - else if (0 < readsize) - { - GNUNET_MST_from_buffer(file_in_mst, - readbuf, - readsize, - GNUNET_NO, - GNUNET_NO); - } - else - { - /* eof */ - closeprog = 1; - } - } + if (FD_ISSET (fdpin, &rfds)) + { + readsize = read (fdpin, readbuf, sizeof(readbuf)); + if (0 > readsize) + { + closeprog = 1; + fprintf (stderr, "Error reading from fdpin: %s\n", strerror (errno)); + break; + } + else if (0 < readsize) + { + GNUNET_MST_from_buffer (file_in_mst, + readbuf, + readsize, + GNUNET_NO, + GNUNET_NO); + } + else + { + /* eof */ + closeprog = 1; + } } + } end: /* clean up */ if (NULL != stdin_mst) - GNUNET_MST_destroy(stdin_mst); + GNUNET_MST_destroy (stdin_mst); if (NULL != file_in_mst) - GNUNET_MST_destroy(file_in_mst); + GNUNET_MST_destroy (file_in_mst); if (NULL != fpout) - fclose(fpout); + fclose (fpout); if (NULL != fpin) - fclose(fpin); + fclose (fpin); if (1 == first) - { - (void)unlink(FIFO_FILE1); - (void)unlink(FIFO_FILE2); - } + { + (void) unlink (FIFO_FILE1); + (void) unlink (FIFO_FILE2); + } return 0; } diff --git a/src/transport/gnunet-helper-transport-wlan.c b/src/transport/gnunet-helper-transport-wlan.c index 885edb1b0..7ad6c5175 100644 --- a/src/transport/gnunet-helper-transport-wlan.c +++ b/src/transport/gnunet-helper-transport-wlan.c @@ -234,7 +234,8 @@ /** * Values in the 'struct PrismHeader'. All in host byte order (!). */ -struct PrismValue { +struct PrismValue +{ /** * This has a different ID for each parameter, see * PRISM_DID_* constants. @@ -263,7 +264,8 @@ struct PrismValue { /** * Prism header format ('struct p80211msg' in Linux). All in host byte order (!). */ -struct PrismHeader { +struct PrismHeader +{ /** * We expect this to be a PRISM_MSGCODE_*. */ @@ -301,7 +303,8 @@ struct PrismHeader { * reliable indicator of alignment requirement. See also * 'man 9 ieee80211_radiotap'. */ -enum RadiotapType { +enum RadiotapType +{ /** * IEEE80211_RADIOTAP_TSFT __le64 microseconds * @@ -576,7 +579,8 @@ enum RadiotapType { * The radio capture header precedes the 802.11 header. * All data in the header is little endian on all platforms. */ -struct Ieee80211RadiotapHeader { +struct Ieee80211RadiotapHeader +{ /** * Version 0. Only increases for drastic changes, introduction of * compatible new fields does not count. @@ -607,7 +611,8 @@ struct Ieee80211RadiotapHeader { * Format of the header we need to prepend to messages to be sent to the * Kernel. */ -struct RadiotapTransmissionHeader { +struct RadiotapTransmissionHeader +{ /** * First we begin with the 'generic' header we also get when receiving * messages. @@ -638,7 +643,12 @@ struct RadiotapTransmissionHeader { * following value for 'header.it_present' based on the presence of * the 'rate' and 'txflags' in the overall struct. */ -#define IEEE80211_RADIOTAP_OUR_TRANSMISSION_HEADER_MASK ((1 << IEEE80211_RADIOTAP_RATE) | (1 << IEEE80211_RADIOTAP_TX_FLAGS)) +#define IEEE80211_RADIOTAP_OUR_TRANSMISSION_HEADER_MASK ((1 \ + << \ + IEEE80211_RADIOTAP_RATE) \ + | (1 \ + << \ + IEEE80211_RADIOTAP_TX_FLAGS)) @@ -646,7 +656,8 @@ struct RadiotapTransmissionHeader { * struct Ieee80211RadiotapHeaderIterator - tracks walk through present radiotap arguments * in the radiotap header. Used when we parse radiotap packets received from the kernel. */ -struct Ieee80211RadiotapHeaderIterator { +struct Ieee80211RadiotapHeaderIterator +{ /** * pointer to the radiotap header we are walking through */ @@ -698,7 +709,8 @@ struct Ieee80211RadiotapHeaderIterator { * struct for storing the information of the hardware. There is only * one of these. */ -struct HardwareInfos { +struct HardwareInfos +{ /** * file descriptor for the raw socket */ @@ -725,7 +737,8 @@ struct HardwareInfos { /** * IO buffer used for buffering data in transit (to wireless or to stdout). */ -struct SendBuffer { +struct SendBuffer +{ /** * How many bytes of data are stored in 'buf' for transmission right now? * Data always starts at offset 0 and extends to 'size'. @@ -787,7 +800,8 @@ typedef void (*MessageTokenizerCallback) (void *cls, /** * Handle to a message stream tokenizer. */ -struct MessageStreamTokenizer { +struct MessageStreamTokenizer +{ /** * Function to call on completed messages. */ @@ -828,23 +842,23 @@ struct MessageStreamTokenizer { * @return handle to tokenizer */ static struct MessageStreamTokenizer * -mst_create(MessageTokenizerCallback cb, - void *cb_cls) +mst_create (MessageTokenizerCallback cb, + void *cb_cls) { struct MessageStreamTokenizer *ret; - ret = malloc(sizeof(struct MessageStreamTokenizer)); + ret = malloc (sizeof(struct MessageStreamTokenizer)); if (NULL == ret) - { - fprintf(stderr, "Failed to allocate buffer for tokenizer\n"); - exit(1); - } - ret->hdr = malloc(MIN_BUFFER_SIZE); + { + fprintf (stderr, "Failed to allocate buffer for tokenizer\n"); + exit (1); + } + ret->hdr = malloc (MIN_BUFFER_SIZE); if (NULL == ret->hdr) - { - fprintf(stderr, "Failed to allocate buffer for alignment\n"); - exit(1); - } + { + fprintf (stderr, "Failed to allocate buffer for alignment\n"); + exit (1); + } ret->curr_buf = MIN_BUFFER_SIZE; ret->cb = cb; ret->cb_cls = cb_cls; @@ -863,8 +877,8 @@ mst_create(MessageTokenizerCallback cb, * GNUNET_SYSERR if the data stream is corrupt */ static int -mst_receive(struct MessageStreamTokenizer *mst, - const char *buf, size_t size) +mst_receive (struct MessageStreamTokenizer *mst, + const char *buf, size_t size) { const struct GNUNET_MessageHeader *hdr; size_t delta; @@ -875,132 +889,132 @@ mst_receive(struct MessageStreamTokenizer *mst, int ret; ret = GNUNET_OK; - ibuf = (char *)mst->hdr; + ibuf = (char *) mst->hdr; while (mst->pos > 0) - { + { do_align: - if ((mst->curr_buf - mst->off < sizeof(struct GNUNET_MessageHeader)) || - (0 != (mst->off % ALIGN_FACTOR))) - { - /* need to align or need more space */ - mst->pos -= mst->off; - memmove(ibuf, &ibuf[mst->off], mst->pos); - mst->off = 0; - } - if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader)) - { - delta = - GNUNET_MIN(sizeof(struct GNUNET_MessageHeader) - - (mst->pos - mst->off), size); - GNUNET_memcpy(&ibuf[mst->pos], buf, delta); - mst->pos += delta; - buf += delta; - size -= delta; - } - if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader)) - { - return GNUNET_OK; - } - hdr = (const struct GNUNET_MessageHeader *)&ibuf[mst->off]; - want = ntohs(hdr->size); - if (want < sizeof(struct GNUNET_MessageHeader)) - { - fprintf(stderr, - "Received invalid message from stdin\n"); - exit(1); - } - if (mst->curr_buf - mst->off < want) - { - /* need more space */ - mst->pos -= mst->off; - memmove(ibuf, &ibuf[mst->off], mst->pos); - mst->off = 0; - } - if (want > mst->curr_buf) - { - mst->hdr = realloc(mst->hdr, want); - if (NULL == mst->hdr) - { - fprintf(stderr, "Failed to allocate buffer for alignment\n"); - exit(1); - } - ibuf = (char *)mst->hdr; - mst->curr_buf = want; - } - hdr = (const struct GNUNET_MessageHeader *)&ibuf[mst->off]; - if (mst->pos - mst->off < want) - { - delta = GNUNET_MIN(want - (mst->pos - mst->off), size); - GNUNET_memcpy(&ibuf[mst->pos], buf, delta); - mst->pos += delta; - buf += delta; - size -= delta; - } - if (mst->pos - mst->off < want) - { - return GNUNET_OK; - } - mst->cb(mst->cb_cls, hdr); - mst->off += want; - if (mst->off == mst->pos) - { - /* reset to beginning of buffer, it's free right now! */ - mst->off = 0; - mst->pos = 0; - } + if ((mst->curr_buf - mst->off < sizeof(struct GNUNET_MessageHeader)) || + (0 != (mst->off % ALIGN_FACTOR))) + { + /* need to align or need more space */ + mst->pos -= mst->off; + memmove (ibuf, &ibuf[mst->off], mst->pos); + mst->off = 0; + } + if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader)) + { + delta = + GNUNET_MIN (sizeof(struct GNUNET_MessageHeader) + - (mst->pos - mst->off), size); + GNUNET_memcpy (&ibuf[mst->pos], buf, delta); + mst->pos += delta; + buf += delta; + size -= delta; + } + if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader)) + { + return GNUNET_OK; + } + hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off]; + want = ntohs (hdr->size); + if (want < sizeof(struct GNUNET_MessageHeader)) + { + fprintf (stderr, + "Received invalid message from stdin\n"); + exit (1); + } + if (mst->curr_buf - mst->off < want) + { + /* need more space */ + mst->pos -= mst->off; + memmove (ibuf, &ibuf[mst->off], mst->pos); + mst->off = 0; + } + if (want > mst->curr_buf) + { + mst->hdr = realloc (mst->hdr, want); + if (NULL == mst->hdr) + { + fprintf (stderr, "Failed to allocate buffer for alignment\n"); + exit (1); + } + ibuf = (char *) mst->hdr; + mst->curr_buf = want; + } + hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off]; + if (mst->pos - mst->off < want) + { + delta = GNUNET_MIN (want - (mst->pos - mst->off), size); + GNUNET_memcpy (&ibuf[mst->pos], buf, delta); + mst->pos += delta; + buf += delta; + size -= delta; + } + if (mst->pos - mst->off < want) + { + return GNUNET_OK; } + mst->cb (mst->cb_cls, hdr); + mst->off += want; + if (mst->off == mst->pos) + { + /* reset to beginning of buffer, it's free right now! */ + mst->off = 0; + mst->pos = 0; + } + } while (size > 0) + { + if (size < sizeof(struct GNUNET_MessageHeader)) + break; + offset = (unsigned long) buf; + need_align = (0 != offset % ALIGN_FACTOR) ? GNUNET_YES : GNUNET_NO; + if (GNUNET_NO == need_align) { - if (size < sizeof(struct GNUNET_MessageHeader)) - break; - offset = (unsigned long)buf; - need_align = (0 != offset % ALIGN_FACTOR) ? GNUNET_YES : GNUNET_NO; - if (GNUNET_NO == need_align) - { - /* can try to do zero-copy and process directly from original buffer */ - hdr = (const struct GNUNET_MessageHeader *)buf; - want = ntohs(hdr->size); - if (want < sizeof(struct GNUNET_MessageHeader)) - { - fprintf(stderr, - "Received invalid message from stdin\n"); - exit(1); - } - if (size < want) - break; /* or not, buffer incomplete, so copy to private buffer... */ - mst->cb(mst->cb_cls, hdr); - buf += want; - size -= want; - } - else - { - /* need to copy to private buffer to align; - * yes, we go a bit more spagetti than usual here */ - goto do_align; - } + /* can try to do zero-copy and process directly from original buffer */ + hdr = (const struct GNUNET_MessageHeader *) buf; + want = ntohs (hdr->size); + if (want < sizeof(struct GNUNET_MessageHeader)) + { + fprintf (stderr, + "Received invalid message from stdin\n"); + exit (1); + } + if (size < want) + break; /* or not, buffer incomplete, so copy to private buffer... */ + mst->cb (mst->cb_cls, hdr); + buf += want; + size -= want; + } + else + { + /* need to copy to private buffer to align; + * yes, we go a bit more spagetti than usual here */ + goto do_align; } + } if (size > 0) + { + if (size + mst->pos > mst->curr_buf) { - if (size + mst->pos > mst->curr_buf) - { - mst->hdr = realloc(mst->hdr, size + mst->pos); - if (NULL == mst->hdr) - { - fprintf(stderr, "Failed to allocate buffer for alignment\n"); - exit(1); - } - ibuf = (char *)mst->hdr; - mst->curr_buf = size + mst->pos; - } - if (mst->pos + size > mst->curr_buf) - { - fprintf(stderr, - "Assertion failed\n"); - exit(1); - } - GNUNET_memcpy(&ibuf[mst->pos], buf, size); - mst->pos += size; + mst->hdr = realloc (mst->hdr, size + mst->pos); + if (NULL == mst->hdr) + { + fprintf (stderr, "Failed to allocate buffer for alignment\n"); + exit (1); + } + ibuf = (char *) mst->hdr; + mst->curr_buf = size + mst->pos; + } + if (mst->pos + size > mst->curr_buf) + { + fprintf (stderr, + "Assertion failed\n"); + exit (1); } + GNUNET_memcpy (&ibuf[mst->pos], buf, size); + mst->pos += size; + } return ret; } @@ -1011,10 +1025,10 @@ do_align: * @param mst tokenizer to destroy */ static void -mst_destroy(struct MessageStreamTokenizer *mst) +mst_destroy (struct MessageStreamTokenizer *mst) { - free(mst->hdr); - free(mst); + free (mst->hdr); + free (mst); } /* ***************** end of server_mst.c clone ***************** **/ @@ -1040,9 +1054,11 @@ mst_destroy(struct MessageStreamTokenizer *mst) * @return 0 on success, -1 on error */ static int -ieee80211_radiotap_iterator_init(struct Ieee80211RadiotapHeaderIterator *iterator, - const struct Ieee80211RadiotapHeader *radiotap_header, - size_t max_length) +ieee80211_radiotap_iterator_init (struct + Ieee80211RadiotapHeaderIterator *iterator, + const struct + Ieee80211RadiotapHeader *radiotap_header, + size_t max_length) { if ((iterator == NULL) || (radiotap_header == NULL)) @@ -1054,36 +1070,39 @@ ieee80211_radiotap_iterator_init(struct Ieee80211RadiotapHeaderIterator *iterato /* sanity check for allowed length and radiotap length field */ if ((max_length < sizeof(struct Ieee80211RadiotapHeader)) || - (max_length < (GNUNET_le16toh(radiotap_header->it_len)))) + (max_length < (GNUNET_le16toh (radiotap_header->it_len)))) return -1; - memset(iterator, 0, sizeof(struct Ieee80211RadiotapHeaderIterator)); + memset (iterator, 0, sizeof(struct Ieee80211RadiotapHeaderIterator)); iterator->rtheader = radiotap_header; - iterator->max_length = GNUNET_le16toh(radiotap_header->it_len); - iterator->bitmap_shifter = GNUNET_le32toh(radiotap_header->it_present); - iterator->arg = ((uint8_t *)radiotap_header) + sizeof(struct Ieee80211RadiotapHeader); + iterator->max_length = GNUNET_le16toh (radiotap_header->it_len); + iterator->bitmap_shifter = GNUNET_le32toh (radiotap_header->it_present); + iterator->arg = ((uint8_t *) radiotap_header) + sizeof(struct + Ieee80211RadiotapHeader); /* find payload start allowing for extended bitmap(s) */ if (0 != (iterator->bitmap_shifter & IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK)) + { + while (GNUNET_le32toh (*((uint32_t *) iterator->arg)) + & IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK) { - while (GNUNET_le32toh(*((uint32_t *)iterator->arg)) & IEEE80211_RADIOTAP_PRESENT_EXTEND_MASK) - { - iterator->arg += sizeof(uint32_t); - /* - * check for insanity where the present bitmaps - * keep claiming to extend up to or even beyond the - * stated radiotap header length - */ - if (iterator->arg - ((uint8_t*)iterator->rtheader) > iterator->max_length) - return -1; - } iterator->arg += sizeof(uint32_t); /* - * no need to check again for blowing past stated radiotap - * header length, becuase ieee80211_radiotap_iterator_next - * checks it before it is dereferenced + * check for insanity where the present bitmaps + * keep claiming to extend up to or even beyond the + * stated radiotap header length */ + if (iterator->arg - ((uint8_t*) iterator->rtheader) > + iterator->max_length) + return -1; } + iterator->arg += sizeof(uint32_t); + /* + * no need to check again for blowing past stated radiotap + * header length, becuase ieee80211_radiotap_iterator_next + * checks it before it is dereferenced + */ + } /* we are all initialized happily */ return 0; } @@ -1102,7 +1121,8 @@ ieee80211_radiotap_iterator_init(struct Ieee80211RadiotapHeaderIterator *iterato * @return next present arg index on success or -1 if no more or error */ static int -ieee80211_radiotap_iterator_next(struct Ieee80211RadiotapHeaderIterator *iterator) +ieee80211_radiotap_iterator_next (struct + Ieee80211RadiotapHeaderIterator *iterator) { /* * small length lookup table for all radiotap types we heard of @@ -1149,94 +1169,96 @@ ieee80211_radiotap_iterator_next(struct Ieee80211RadiotapHeaderIterator *iterato * least skip (by knowing the length)... */ while (iterator->arg_index < sizeof(rt_sizes)) + { + int hit = (0 != (iterator->bitmap_shifter & 1)); + + if (hit) { - int hit = (0 != (iterator->bitmap_shifter & 1)); + unsigned int wanted_alignment; + unsigned int unalignment; + /* + * arg is present, account for alignment padding + * 8-bit args can be at any alignment + * 16-bit args must start on 16-bit boundary + * 32-bit args must start on 32-bit boundary + * 64-bit args must start on 64-bit boundary + * + * note that total arg size can differ from alignment of + * elements inside arg, so we use upper nybble of length table + * to base alignment on. First, 'wanted_alignment' is set to be + * 1 for 8-bit, 2 for 16-bit, 4 for 32-bit and 8 for 64-bit + * arguments. Then, we calculate the 'unalignment' (how many + * bytes we are over by taking the difference of 'arg' and the + * overall starting point modulo the desired alignment. As + * desired alignments are powers of two, we can do modulo with + * binary "&" (and also avoid the possibility of a division by + * zero if the 'rt_sizes' table contains bogus entries). + * + * also note: these alignments are relative to the start of the + * radiotap header. There is no guarantee that the radiotap + * header itself is aligned on any kind of boundary, thus we + * need to really look at the delta here. + */ + wanted_alignment = rt_sizes[iterator->arg_index] >> 4; + unalignment = (((void *) iterator->arg) - ((void *) iterator->rtheader)) + & (wanted_alignment - 1); + if (0 != unalignment) + { + /* need padding (by 'wanted_alignment - unalignment') */ + iterator->arg_index += wanted_alignment - unalignment; + } - if (hit) - { - unsigned int wanted_alignment; - unsigned int unalignment; - /* - * arg is present, account for alignment padding - * 8-bit args can be at any alignment - * 16-bit args must start on 16-bit boundary - * 32-bit args must start on 32-bit boundary - * 64-bit args must start on 64-bit boundary - * - * note that total arg size can differ from alignment of - * elements inside arg, so we use upper nybble of length table - * to base alignment on. First, 'wanted_alignment' is set to be - * 1 for 8-bit, 2 for 16-bit, 4 for 32-bit and 8 for 64-bit - * arguments. Then, we calculate the 'unalignment' (how many - * bytes we are over by taking the difference of 'arg' and the - * overall starting point modulo the desired alignment. As - * desired alignments are powers of two, we can do modulo with - * binary "&" (and also avoid the possibility of a division by - * zero if the 'rt_sizes' table contains bogus entries). - * - * also note: these alignments are relative to the start of the - * radiotap header. There is no guarantee that the radiotap - * header itself is aligned on any kind of boundary, thus we - * need to really look at the delta here. - */ - wanted_alignment = rt_sizes[iterator->arg_index] >> 4; - unalignment = (((void *)iterator->arg) - ((void *)iterator->rtheader)) & (wanted_alignment - 1); - if (0 != unalignment) - { - /* need padding (by 'wanted_alignment - unalignment') */ - iterator->arg_index += wanted_alignment - unalignment; - } + /* + * this is what we will return to user, but we need to + * move on first so next call has something fresh to test + */ + iterator->this_arg_index = iterator->arg_index; + iterator->this_arg = iterator->arg; - /* - * this is what we will return to user, but we need to - * move on first so next call has something fresh to test - */ - iterator->this_arg_index = iterator->arg_index; - iterator->this_arg = iterator->arg; - - /* internally move on the size of this arg (using lower nybble from - the table) */ - iterator->arg += rt_sizes[iterator->arg_index] & 0x0f; - - /* - * check for insanity where we are given a bitmap that - * claims to have more arg content than the length of the - * radiotap section. We will normally end up equalling this - * max_length on the last arg, never exceeding it. - */ - if ((((void *)iterator->arg) - ((void *)iterator->rtheader)) > iterator->max_length) - return -1; - } + /* internally move on the size of this arg (using lower nybble from + the table) */ + iterator->arg += rt_sizes[iterator->arg_index] & 0x0f; - /* Now, move on to next bit / next entry */ - iterator->arg_index++; + /* + * check for insanity where we are given a bitmap that + * claims to have more arg content than the length of the + * radiotap section. We will normally end up equalling this + * max_length on the last arg, never exceeding it. + */ + if ((((void *) iterator->arg) - ((void *) iterator->rtheader)) > + iterator->max_length) + return -1; + } - if (0 == (iterator->arg_index % 32)) - { - /* completed current uint32_t bitmap */ - if (0 != (iterator->bitmap_shifter & 1)) - { - /* bit 31 was set, there is more; move to next uint32_t bitmap */ - iterator->bitmap_shifter = GNUNET_le32toh(*iterator->next_bitmap); - iterator->next_bitmap++; - } - else - { - /* no more bitmaps: end (by setting arg_index to high, unsupported value) */ - iterator->arg_index = sizeof(rt_sizes); - } - } - else - { - /* just try the next bit (while loop will move on) */ - iterator->bitmap_shifter >>= 1; - } + /* Now, move on to next bit / next entry */ + iterator->arg_index++; - /* if we found a valid arg earlier, return it now */ - if (hit) - return iterator->this_arg_index; + if (0 == (iterator->arg_index % 32)) + { + /* completed current uint32_t bitmap */ + if (0 != (iterator->bitmap_shifter & 1)) + { + /* bit 31 was set, there is more; move to next uint32_t bitmap */ + iterator->bitmap_shifter = GNUNET_le32toh (*iterator->next_bitmap); + iterator->next_bitmap++; + } + else + { + /* no more bitmaps: end (by setting arg_index to high, unsupported value) */ + iterator->arg_index = sizeof(rt_sizes); + } + } + else + { + /* just try the next bit (while loop will move on) */ + iterator->bitmap_shifter >>= 1; } + /* if we found a valid arg earlier, return it now */ + if (hit) + return iterator->this_arg_index; + } + /* we don't know how to handle any more args (or there are no more), so we're done (this is not an error) */ return -1; @@ -1251,7 +1273,7 @@ ieee80211_radiotap_iterator_next(struct Ieee80211RadiotapHeaderIterator *iterato * @return crc sum */ static unsigned long -calc_crc_osdep(const unsigned char *buf, size_t len) +calc_crc_osdep (const unsigned char *buf, size_t len) { static const unsigned long int crc_tbl_osdep[256] = { 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, @@ -1337,14 +1359,14 @@ calc_crc_osdep(const unsigned char *buf, size_t len) * @return 0 on success (checksum matches), 1 on error */ static int -check_crc_buf_osdep(const unsigned char *buf, size_t len) +check_crc_buf_osdep (const unsigned char *buf, size_t len) { unsigned long crc; - crc = calc_crc_osdep(buf, len); + crc = calc_crc_osdep (buf, len); buf += len; - if (((crc) & 0xFF) == buf[0] && ((crc >> 8) & 0xFF) == buf[1] && - ((crc >> 16) & 0xFF) == buf[2] && ((crc >> 24) & 0xFF) == buf[3]) + if ((((crc) & 0xFF) == buf[0])&&(((crc >> 8) & 0xFF) == buf[1])&& + ( ((crc >> 16) & 0xFF) == buf[2]) &&( ((crc >> 24) & 0xFF) == buf[3]) ) return 0; return 1; } @@ -1362,13 +1384,13 @@ check_crc_buf_osdep(const unsigned char *buf, size_t len) * @return number of the channel */ static int -get_channel_from_frequency(int32_t frequency) +get_channel_from_frequency (int32_t frequency) { - if (frequency >= 2412 && frequency <= 2472) + if ((frequency >= 2412)&&(frequency <= 2472)) return (frequency - 2407) / 5; if (frequency == 2484) return 14; - if (frequency >= 5000 && frequency <= 6100) + if ((frequency >= 5000)&&(frequency <= 6100)) return (frequency - 5000) / 5; return -1; } @@ -1381,14 +1403,14 @@ get_channel_from_frequency(int32_t frequency) * @return channel number, -1 on error */ static int -linux_get_channel(const struct HardwareInfos *dev) +linux_get_channel (const struct HardwareInfos *dev) { struct iwreq wrq; int32_t frequency; - memset(&wrq, 0, sizeof(struct iwreq)); - strncpy(wrq.ifr_name, dev->iface, IFNAMSIZ); - if (0 > ioctl(dev->fd_raw, SIOCGIWFREQ, &wrq)) + memset (&wrq, 0, sizeof(struct iwreq)); + strncpy (wrq.ifr_name, dev->iface, IFNAMSIZ); + if (0 > ioctl (dev->fd_raw, SIOCGIWFREQ, &wrq)) return -1; frequency = wrq.u.freq.m; /* 'iw_freq' defines 'm' as '__s32', so we keep it signed */ if (100000000 < frequency) @@ -1396,7 +1418,7 @@ linux_get_channel(const struct HardwareInfos *dev) else if (1000000 < frequency) frequency /= 1000; if (1000 < frequency) - return get_channel_from_frequency(frequency); + return get_channel_from_frequency (frequency); return frequency; } @@ -1413,9 +1435,9 @@ linux_get_channel(const struct HardwareInfos *dev) * @return number of bytes written to 'buf' */ static ssize_t -linux_read(struct HardwareInfos *dev, - unsigned char *buf, size_t buf_size, - struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri) +linux_read (struct HardwareInfos *dev, + unsigned char *buf, size_t buf_size, + struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *ri) { unsigned char tmpbuf[buf_size]; ssize_t caplen; @@ -1425,207 +1447,210 @@ linux_read(struct HardwareInfos *dev, int got_channel = 0; int fcs_removed = 0; - caplen = read(dev->fd_raw, tmpbuf, buf_size); + caplen = read (dev->fd_raw, tmpbuf, buf_size); if (0 > caplen) - { - if (EAGAIN == errno) - return 0; - fprintf(stderr, "Failed to read from RAW socket: %s\n", strerror(errno)); - return -1; - } + { + if (EAGAIN == errno) + return 0; + fprintf (stderr, "Failed to read from RAW socket: %s\n", strerror (errno)); + return -1; + } - memset(ri, 0, sizeof(*ri)); + memset (ri, 0, sizeof(*ri)); switch (dev->arptype_in) - { - case ARPHRD_IEEE80211_PRISM: + { + case ARPHRD_IEEE80211_PRISM: { const struct PrismHeader *ph; - ph = (const struct PrismHeader*)tmpbuf; + ph = (const struct PrismHeader*) tmpbuf; n = ph->msglen; if ((n < 8) || (n >= caplen)) return 0; /* invalid format */ if ((PRISM_MSGCODE_MONITOR == ph->msgcode) && (n >= sizeof(struct PrismHeader))) + { + const char *pos; + size_t left; + struct PrismValue pv; + + left = n - sizeof(struct PrismHeader); + pos = (const char *) &ph[1]; + while (left > sizeof(struct PrismValue)) { - const char *pos; - size_t left; - struct PrismValue pv; + left -= sizeof(struct PrismValue); + GNUNET_memcpy (&pv, pos, sizeof(struct PrismValue)); + pos += sizeof(struct PrismValue); + + switch (pv.did) + { + case PRISM_DID_NOISE: + if (PRISM_STATUS_OK == pv.status) + { + ri->ri_noise = pv.data; + /* got_noise = 1; */ + } + break; + + case PRISM_DID_RATE: + if (PRISM_STATUS_OK == pv.status) + ri->ri_rate = pv.data * 500000; + break; + + case PRISM_DID_CHANNEL: + if (PRISM_STATUS_OK == pv.status) + { + ri->ri_channel = pv.data; + got_channel = 1; + } + break; + + case PRISM_DID_MACTIME: + if (PRISM_STATUS_OK == pv.status) + ri->ri_mactime = pv.data; + break; - left = n - sizeof(struct PrismHeader); - pos = (const char *)&ph[1]; - while (left > sizeof(struct PrismValue)) + case PRISM_DID_SIGNAL: + if (PRISM_STATUS_OK == pv.status) { - left -= sizeof(struct PrismValue); - GNUNET_memcpy(&pv, pos, sizeof(struct PrismValue)); - pos += sizeof(struct PrismValue); - - switch (pv.did) - { - case PRISM_DID_NOISE: - if (PRISM_STATUS_OK == pv.status) - { - ri->ri_noise = pv.data; - /* got_noise = 1; */ - } - break; - - case PRISM_DID_RATE: - if (PRISM_STATUS_OK == pv.status) - ri->ri_rate = pv.data * 500000; - break; - - case PRISM_DID_CHANNEL: - if (PRISM_STATUS_OK == pv.status) - { - ri->ri_channel = pv.data; - got_channel = 1; - } - break; - - case PRISM_DID_MACTIME: - if (PRISM_STATUS_OK == pv.status) - ri->ri_mactime = pv.data; - break; - - case PRISM_DID_SIGNAL: - if (PRISM_STATUS_OK == pv.status) - { - ri->ri_power = pv.data; - /* got_signal = 1; */ - } - break; - } + ri->ri_power = pv.data; + /* got_signal = 1; */ } + break; + } } + } if ((n < 8) || (n >= caplen)) return 0; /* invalid format */ } break; - case ARPHRD_IEEE80211_FULL: + case ARPHRD_IEEE80211_FULL: { struct Ieee80211RadiotapHeaderIterator iterator; struct Ieee80211RadiotapHeader *rthdr; - memset(&iterator, 0, sizeof(iterator)); - rthdr = (struct Ieee80211RadiotapHeader *)tmpbuf; - n = GNUNET_le16toh(rthdr->it_len); + memset (&iterator, 0, sizeof(iterator)); + rthdr = (struct Ieee80211RadiotapHeader *) tmpbuf; + n = GNUNET_le16toh (rthdr->it_len); if ((n < sizeof(struct Ieee80211RadiotapHeader)) || (n >= caplen)) return 0; /* invalid 'it_len' */ - if (0 != ieee80211_radiotap_iterator_init(&iterator, rthdr, caplen)) + if (0 != ieee80211_radiotap_iterator_init (&iterator, rthdr, caplen)) return 0; /* go through the radiotap arguments we have been given by the driver */ - while (0 <= ieee80211_radiotap_iterator_next(&iterator)) + while (0 <= ieee80211_radiotap_iterator_next (&iterator)) + { + switch (iterator.this_arg_index) { - switch (iterator.this_arg_index) - { - case IEEE80211_RADIOTAP_TSFT: - ri->ri_mactime = GNUNET_le64toh(*((uint64_t *)iterator.this_arg)); - break; - - case IEEE80211_RADIOTAP_DBM_ANTSIGNAL: - if (!got_signal) - { - ri->ri_power = *((int8_t*)iterator.this_arg); - got_signal = 1; - } - break; - - case IEEE80211_RADIOTAP_DB_ANTSIGNAL: - if (!got_signal) - { - ri->ri_power = *((int8_t*)iterator.this_arg); - got_signal = 1; - } - break; - - case IEEE80211_RADIOTAP_DBM_ANTNOISE: - if (!got_noise) - { - ri->ri_noise = *((int8_t*)iterator.this_arg); - got_noise = 1; - } - break; - - case IEEE80211_RADIOTAP_DB_ANTNOISE: - if (!got_noise) - { - ri->ri_noise = *((int8_t*)iterator.this_arg); - got_noise = 1; - } - break; - - case IEEE80211_RADIOTAP_ANTENNA: - ri->ri_antenna = *iterator.this_arg; - break; - - case IEEE80211_RADIOTAP_CHANNEL: - ri->ri_channel = *iterator.this_arg; - got_channel = 1; - break; + case IEEE80211_RADIOTAP_TSFT: + ri->ri_mactime = GNUNET_le64toh (*((uint64_t *) iterator.this_arg)); + break; - case IEEE80211_RADIOTAP_RATE: - ri->ri_rate = (*iterator.this_arg) * 500000; - break; + case IEEE80211_RADIOTAP_DBM_ANTSIGNAL: + if (! got_signal) + { + ri->ri_power = *((int8_t*) iterator.this_arg); + got_signal = 1; + } + break; - case IEEE80211_RADIOTAP_FLAGS: - { - uint8_t flags = *iterator.this_arg; - /* is the CRC visible at the end? if so, remove */ - if (0 != (flags & IEEE80211_RADIOTAP_F_FCS)) - { - fcs_removed = 1; - caplen -= sizeof(uint32_t); - } - break; - } + case IEEE80211_RADIOTAP_DB_ANTSIGNAL: + if (! got_signal) + { + ri->ri_power = *((int8_t*) iterator.this_arg); + got_signal = 1; + } + break; + + case IEEE80211_RADIOTAP_DBM_ANTNOISE: + if (! got_noise) + { + ri->ri_noise = *((int8_t*) iterator.this_arg); + got_noise = 1; + } + break; + + case IEEE80211_RADIOTAP_DB_ANTNOISE: + if (! got_noise) + { + ri->ri_noise = *((int8_t*) iterator.this_arg); + got_noise = 1; + } + break; - case IEEE80211_RADIOTAP_RX_FLAGS: + case IEEE80211_RADIOTAP_ANTENNA: + ri->ri_antenna = *iterator.this_arg; + break; + + case IEEE80211_RADIOTAP_CHANNEL: + ri->ri_channel = *iterator.this_arg; + got_channel = 1; + break; + + case IEEE80211_RADIOTAP_RATE: + ri->ri_rate = (*iterator.this_arg) * 500000; + break; + + case IEEE80211_RADIOTAP_FLAGS: + { + uint8_t flags = *iterator.this_arg; + /* is the CRC visible at the end? if so, remove */ + if (0 != (flags & IEEE80211_RADIOTAP_F_FCS)) { - uint16_t flags = ntohs(*((uint16_t *)iterator.this_arg)); - if (0 != (flags & IEEE80211_RADIOTAP_F_RX_BADFCS)) - return 0; + fcs_removed = 1; + caplen -= sizeof(uint32_t); } break; - } /* end of 'switch' */ - } /* end of the 'while' loop */ + } + + case IEEE80211_RADIOTAP_RX_FLAGS: + { + uint16_t flags = ntohs (*((uint16_t *) iterator.this_arg)); + if (0 != (flags & IEEE80211_RADIOTAP_F_RX_BADFCS)) + return 0; + } + break; + } /* end of 'switch' */ + } /* end of the 'while' loop */ } break; - case ARPHRD_IEEE80211: - n = 0; /* no header */ - break; + case ARPHRD_IEEE80211: + n = 0; /* no header */ + break; - case ARPHRD_ETHER: + case ARPHRD_ETHER: { if (sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee8023Frame) > caplen) return 0; /* invalid */ - GNUNET_memcpy(&buf[sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)], - tmpbuf + sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee8023Frame), - caplen - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee8023Frame) - 4 /* 4 byte FCS */); + GNUNET_memcpy (&buf[sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)], + tmpbuf + sizeof(struct + GNUNET_TRANSPORT_WLAN_Ieee8023Frame), + caplen - sizeof(struct + GNUNET_TRANSPORT_WLAN_Ieee8023Frame) + - 4 /* 4 byte FCS */); return caplen - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee8023Frame) - 4; } - default: - errno = ENOTSUP; /* unsupported format */ - return -1; - } + default: + errno = ENOTSUP; /* unsupported format */ + return -1; + } caplen -= n; - if (!got_channel) - ri->ri_channel = linux_get_channel(dev); + if (! got_channel) + ri->ri_channel = linux_get_channel (dev); /* detect CRC32 at the end, even if the flag wasn't set and remove it */ if ((0 == fcs_removed) && - (0 == check_crc_buf_osdep(tmpbuf + n, caplen - sizeof(uint32_t)))) - { - /* NOTE: this heuristic can of course fail if there happens to - be a matching checksum at the end. Would be good to have - some data to see how often this heuristic actually works. */ - caplen -= sizeof(uint32_t); - } + (0 == check_crc_buf_osdep (tmpbuf + n, caplen - sizeof(uint32_t)))) + { + /* NOTE: this heuristic can of course fail if there happens to + be a matching checksum at the end. Would be good to have + some data to see how often this heuristic actually works. */ + caplen -= sizeof(uint32_t); + } /* copy payload to target buffer */ - GNUNET_memcpy(buf, tmpbuf + n, caplen); + GNUNET_memcpy (buf, tmpbuf + n, caplen); return caplen; } @@ -1642,7 +1667,7 @@ linux_read(struct HardwareInfos *dev, * @return 0 on success */ static int -open_device_raw(struct HardwareInfos *dev) +open_device_raw (struct HardwareInfos *dev) { struct ifreq ifr; struct iwreq wrq; @@ -1650,112 +1675,114 @@ open_device_raw(struct HardwareInfos *dev) struct sockaddr_ll sll; /* find the interface index */ - memset(&ifr, 0, sizeof(ifr)); - strncpy(ifr.ifr_name, dev->iface, IFNAMSIZ); - if (-1 == ioctl(dev->fd_raw, SIOCGIFINDEX, &ifr)) - { - fprintf(stderr, "ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n", - IFNAMSIZ, dev->iface, strerror(errno)); - return 1; - } + memset (&ifr, 0, sizeof(ifr)); + strncpy (ifr.ifr_name, dev->iface, IFNAMSIZ); + if (-1 == ioctl (dev->fd_raw, SIOCGIFINDEX, &ifr)) + { + fprintf (stderr, "ioctl(SIOCGIFINDEX) on interface `%.*s' failed: %s\n", + IFNAMSIZ, dev->iface, strerror (errno)); + return 1; + } /* lookup the hardware type */ - memset(&sll, 0, sizeof(sll)); + memset (&sll, 0, sizeof(sll)); sll.sll_family = AF_PACKET; sll.sll_ifindex = ifr.ifr_ifindex; - sll.sll_protocol = htons(ETH_P_ALL); - if (-1 == ioctl(dev->fd_raw, SIOCGIFHWADDR, &ifr)) - { - fprintf(stderr, "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n", - IFNAMSIZ, dev->iface, strerror(errno)); - return 1; - } + sll.sll_protocol = htons (ETH_P_ALL); + if (-1 == ioctl (dev->fd_raw, SIOCGIFHWADDR, &ifr)) + { + fprintf (stderr, "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n", + IFNAMSIZ, dev->iface, strerror (errno)); + return 1; + } if (((ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) && (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) && (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) && (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL))) - { - fprintf(stderr, "Error: interface `%.*s' is not using a supported hardware address family (got %d)\n", - IFNAMSIZ, dev->iface, - ifr.ifr_hwaddr.sa_family); - return 1; - } + { + fprintf (stderr, + "Error: interface `%.*s' is not using a supported hardware address family (got %d)\n", + IFNAMSIZ, dev->iface, + ifr.ifr_hwaddr.sa_family); + return 1; + } /* lookup iw mode */ - memset(&wrq, 0, sizeof(struct iwreq)); - strncpy(wrq.ifr_name, dev->iface, IFNAMSIZ); - if (-1 == ioctl(dev->fd_raw, SIOCGIWMODE, &wrq)) - { - /* most probably not supported (ie for rtap ipw interface) * - * so just assume its correctly set... */ - wrq.u.mode = IW_MODE_MONITOR; - } + memset (&wrq, 0, sizeof(struct iwreq)); + strncpy (wrq.ifr_name, dev->iface, IFNAMSIZ); + if (-1 == ioctl (dev->fd_raw, SIOCGIWMODE, &wrq)) + { + /* most probably not supported (ie for rtap ipw interface) * + * so just assume its correctly set... */ + wrq.u.mode = IW_MODE_MONITOR; + } if ((wrq.u.mode != IW_MODE_MONITOR) && (wrq.u.mode != IW_MODE_ADHOC)) - { - fprintf(stderr, "Error: interface `%.*s' is not in monitor or ad-hoc mode (got %d)\n", - IFNAMSIZ, dev->iface, - wrq.u.mode); - return 1; - } + { + fprintf (stderr, + "Error: interface `%.*s' is not in monitor or ad-hoc mode (got %d)\n", + IFNAMSIZ, dev->iface, + wrq.u.mode); + return 1; + } /* Is interface st to up, broadcast & running ? */ if ((ifr.ifr_flags | IFF_UP | IFF_BROADCAST | IFF_RUNNING) != ifr.ifr_flags) - { - /* Bring interface up */ - ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING; - - if (-1 == ioctl(dev->fd_raw, SIOCSIFFLAGS, &ifr)) - { - fprintf(stderr, "ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n", - IFNAMSIZ, dev->iface, strerror(errno)); - return 1; - } - } + { + /* Bring interface up */ + ifr.ifr_flags |= IFF_UP | IFF_BROADCAST | IFF_RUNNING; - /* bind the raw socket to the interface */ - if (-1 == bind(dev->fd_raw, (struct sockaddr *)&sll, sizeof(sll))) + if (-1 == ioctl (dev->fd_raw, SIOCSIFFLAGS, &ifr)) { - fprintf(stderr, "Failed to bind interface `%.*s': %s\n", IFNAMSIZ, - dev->iface, strerror(errno)); + fprintf (stderr, "ioctl(SIOCSIFFLAGS) on interface `%.*s' failed: %s\n", + IFNAMSIZ, dev->iface, strerror (errno)); return 1; } + } + + /* bind the raw socket to the interface */ + if (-1 == bind (dev->fd_raw, (struct sockaddr *) &sll, sizeof(sll))) + { + fprintf (stderr, "Failed to bind interface `%.*s': %s\n", IFNAMSIZ, + dev->iface, strerror (errno)); + return 1; + } /* lookup the hardware type */ - if (-1 == ioctl(dev->fd_raw, SIOCGIFHWADDR, &ifr)) - { - fprintf(stderr, "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n", - IFNAMSIZ, dev->iface, strerror(errno)); - return 1; - } + if (-1 == ioctl (dev->fd_raw, SIOCGIFHWADDR, &ifr)) + { + fprintf (stderr, "ioctl(SIOCGIFHWADDR) on interface `%.*s' failed: %s\n", + IFNAMSIZ, dev->iface, strerror (errno)); + return 1; + } - GNUNET_memcpy(&dev->pl_mac, ifr.ifr_hwaddr.sa_data, MAC_ADDR_SIZE); + GNUNET_memcpy (&dev->pl_mac, ifr.ifr_hwaddr.sa_data, MAC_ADDR_SIZE); dev->arptype_in = ifr.ifr_hwaddr.sa_family; if ((ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) && (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211) && (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM) && (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL)) - { - fprintf(stderr, "Unsupported hardware link type %d on interface `%.*s'\n", - ifr.ifr_hwaddr.sa_family, IFNAMSIZ, dev->iface); - return 1; - } + { + fprintf (stderr, "Unsupported hardware link type %d on interface `%.*s'\n", + ifr.ifr_hwaddr.sa_family, IFNAMSIZ, dev->iface); + return 1; + } /* enable promiscuous mode */ - memset(&mr, 0, sizeof(mr)); + memset (&mr, 0, sizeof(mr)); mr.mr_ifindex = sll.sll_ifindex; mr.mr_type = PACKET_MR_PROMISC; if (0 != - setsockopt(dev->fd_raw, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mr, - sizeof(mr))) - { - fprintf(stderr, - "Failed to enable promiscuous mode on interface `%.*s'\n", - IFNAMSIZ, - dev->iface); - return 1; - } + setsockopt (dev->fd_raw, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mr, + sizeof(mr))) + { + fprintf (stderr, + "Failed to enable promiscuous mode on interface `%.*s'\n", + IFNAMSIZ, + dev->iface); + return 1; + } return 0; } @@ -1768,22 +1795,22 @@ open_device_raw(struct HardwareInfos *dev) * @return 0 on success, 1 on error */ static int -test_wlan_interface(const char *iface) +test_wlan_interface (const char *iface) { char strbuf[512]; struct stat sbuf; int ret; - ret = snprintf(strbuf, sizeof(strbuf), - "/sys/class/net/%s/phy80211/subsystem", - iface); - if ((ret < 0) || (ret >= sizeof(strbuf)) || (0 != stat(strbuf, &sbuf))) - { - fprintf(stderr, - "Did not find 802.11 interface `%s'. Exiting.\n", - iface); - exit(1); - } + ret = snprintf (strbuf, sizeof(strbuf), + "/sys/class/net/%s/phy80211/subsystem", + iface); + if ((ret < 0) || (ret >= sizeof(strbuf)) || (0 != stat (strbuf, &sbuf))) + { + fprintf (stderr, + "Did not find 802.11 interface `%s'. Exiting.\n", + iface); + exit (1); + } return 0; } @@ -1796,19 +1823,19 @@ test_wlan_interface(const char *iface) * @return 0 if mac belongs to us, 1 if mac is for another target */ static int -mac_test(const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, - const struct HardwareInfos *dev) +mac_test (const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, + const struct HardwareInfos *dev) { static struct GNUNET_TRANSPORT_WLAN_MacAddress all_zeros; - if ((0 == memcmp(&taIeeeHeader->addr3, &all_zeros, MAC_ADDR_SIZE)) || - (0 == memcmp(&taIeeeHeader->addr1, &all_zeros, MAC_ADDR_SIZE))) + if ((0 == memcmp (&taIeeeHeader->addr3, &all_zeros, MAC_ADDR_SIZE)) || + (0 == memcmp (&taIeeeHeader->addr1, &all_zeros, MAC_ADDR_SIZE))) return 0; /* some drivers set no Macs, then assume it is all for us! */ - if (0 != memcmp(&taIeeeHeader->addr3, &mac_bssid_gnunet, MAC_ADDR_SIZE)) + if (0 != memcmp (&taIeeeHeader->addr3, &mac_bssid_gnunet, MAC_ADDR_SIZE)) return 1; /* not a GNUnet ad-hoc package */ - if ((0 == memcmp(&taIeeeHeader->addr1, &dev->pl_mac, MAC_ADDR_SIZE)) || - (0 == memcmp(&taIeeeHeader->addr1, &bc_all_mac, MAC_ADDR_SIZE))) + if ((0 == memcmp (&taIeeeHeader->addr1, &dev->pl_mac, MAC_ADDR_SIZE)) || + (0 == memcmp (&taIeeeHeader->addr1, &bc_all_mac, MAC_ADDR_SIZE))) return 0; /* for us, or broadcast */ return 1; /* not for us */ } @@ -1821,10 +1848,10 @@ mac_test(const struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, * @param dev pointer to the Hardware_Infos struct */ static void -mac_set(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, - const struct HardwareInfos *dev) +mac_set (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, + const struct HardwareInfos *dev) { - taIeeeHeader->frame_control = htons(IEEE80211_FC0_TYPE_DATA); + taIeeeHeader->frame_control = htons (IEEE80211_FC0_TYPE_DATA); taIeeeHeader->addr2 = dev->pl_mac; taIeeeHeader->addr3 = mac_bssid_gnunet; } @@ -1839,7 +1866,7 @@ mac_set(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *taIeeeHeader, * @param hdr pointer to the start of the packet */ static void -stdin_send_hw(void *cls, const struct GNUNET_MessageHeader *hdr) +stdin_send_hw (void *cls, const struct GNUNET_MessageHeader *hdr) { struct HardwareInfos *dev = cls; const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header; @@ -1848,58 +1875,67 @@ stdin_send_hw(void *cls, const struct GNUNET_MessageHeader *hdr) struct RadiotapTransmissionHeader rtheader; struct GNUNET_TRANSPORT_WLAN_Ieee8023Frame etheader; - sendsize = ntohs(hdr->size); + sendsize = ntohs (hdr->size); if ((sendsize < sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage)) || - (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs(hdr->type))) - { - fprintf(stderr, "Received malformed message\n"); - exit(1); - } - sendsize -= (sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)); + (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type))) + { + fprintf (stderr, "Received malformed message\n"); + exit (1); + } + sendsize -= (sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) + - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)); if (MAXLINE < sendsize) - { - fprintf(stderr, "Packet too big for buffer\n"); - exit(1); - } - header = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *)hdr; + { + fprintf (stderr, "Packet too big for buffer\n"); + exit (1); + } + header = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr; switch (dev->arptype_in) - { - case ARPHRD_IEEE80211_PRISM: - case ARPHRD_IEEE80211_FULL: - case ARPHRD_IEEE80211: - rtheader.header.it_version = 0; - rtheader.header.it_pad = 0; - rtheader.header.it_len = GNUNET_htole16(sizeof(rtheader)); - rtheader.header.it_present = GNUNET_htole16(IEEE80211_RADIOTAP_OUR_TRANSMISSION_HEADER_MASK); - rtheader.rate = header->rate; - rtheader.pad1 = 0; - rtheader.txflags = GNUNET_htole16(IEEE80211_RADIOTAP_F_TX_NOACK | IEEE80211_RADIOTAP_F_TX_NOSEQ); - GNUNET_memcpy(write_pout.buf, &rtheader, sizeof(rtheader)); - GNUNET_memcpy(&write_pout.buf[sizeof(rtheader)], &header->frame, sendsize); - wlanheader = (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *)&write_pout.buf[sizeof(rtheader)]; - - /* payload contains MAC address, but we don't trust it, so we'll - * overwrite it with OUR MAC address to prevent mischief */ - mac_set(wlanheader, dev); - write_pout.size = sendsize + sizeof(rtheader); - break; + { + case ARPHRD_IEEE80211_PRISM: + case ARPHRD_IEEE80211_FULL: + case ARPHRD_IEEE80211: + rtheader.header.it_version = 0; + rtheader.header.it_pad = 0; + rtheader.header.it_len = GNUNET_htole16 (sizeof(rtheader)); + rtheader.header.it_present = GNUNET_htole16 ( + IEEE80211_RADIOTAP_OUR_TRANSMISSION_HEADER_MASK); + rtheader.rate = header->rate; + rtheader.pad1 = 0; + rtheader.txflags = GNUNET_htole16 (IEEE80211_RADIOTAP_F_TX_NOACK + | IEEE80211_RADIOTAP_F_TX_NOSEQ); + GNUNET_memcpy (write_pout.buf, &rtheader, sizeof(rtheader)); + GNUNET_memcpy (&write_pout.buf[sizeof(rtheader)], &header->frame, sendsize); + wlanheader = (struct + GNUNET_TRANSPORT_WLAN_Ieee80211Frame *) &write_pout.buf[sizeof( + rtheader) + ]; + + /* payload contains MAC address, but we don't trust it, so we'll + * overwrite it with OUR MAC address to prevent mischief */ + mac_set (wlanheader, dev); + write_pout.size = sendsize + sizeof(rtheader); + break; - case ARPHRD_ETHER: - etheader.dst = header->frame.addr1; - /* etheader.src = header->frame.addr2; --- untrusted input */ - etheader.src = dev->pl_mac; - etheader.type = htons(ETH_P_IP); - GNUNET_memcpy(write_pout.buf, ðeader, sizeof(etheader)); - GNUNET_memcpy(&write_pout.buf[sizeof(etheader)], &header[1], sendsize - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)); - write_pout.size = sendsize - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame) + sizeof(etheader); - break; + case ARPHRD_ETHER: + etheader.dst = header->frame.addr1; + /* etheader.src = header->frame.addr2; --- untrusted input */ + etheader.src = dev->pl_mac; + etheader.type = htons (ETH_P_IP); + GNUNET_memcpy (write_pout.buf, ðeader, sizeof(etheader)); + GNUNET_memcpy (&write_pout.buf[sizeof(etheader)], &header[1], sendsize + - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame)); + write_pout.size = sendsize - sizeof(struct + GNUNET_TRANSPORT_WLAN_Ieee80211Frame) + + sizeof(etheader); + break; - default: - fprintf(stderr, - "Unsupported ARPTYPE!\n"); - break; - } + default: + fprintf (stderr, + "Unsupported ARPTYPE!\n"); + break; + } } @@ -1914,7 +1950,7 @@ stdin_send_hw(void *cls, const struct GNUNET_MessageHeader *hdr) * @return 0 on success (never happens, as we don't return unless aborted), 1 on error */ int -main(int argc, char *argv[]) +main (int argc, char *argv[]) { struct HardwareInfos dev; char readbuf[MAXLINE]; @@ -1928,83 +1964,83 @@ main(int argc, char *argv[]) /* assert privs so we can modify the firewall rules! */ { #ifdef HAVE_SETRESUID - uid_t uid = getuid(); + uid_t uid = getuid (); - if (0 != setresuid(uid, 0, 0)) - { - fprintf(stderr, - "Failed to setresuid to root: %s\n", - strerror(errno)); - return 254; - } + if (0 != setresuid (uid, 0, 0)) + { + fprintf (stderr, + "Failed to setresuid to root: %s\n", + strerror (errno)); + return 254; + } #else - if (0 != seteuid(0)) - { - fprintf(stderr, - "Failed to seteuid back to root: %s\n", strerror(errno)); - return 254; - } + if (0 != seteuid (0)) + { + fprintf (stderr, + "Failed to seteuid back to root: %s\n", strerror (errno)); + return 254; + } #endif } /* make use of SGID capabilities on POSIX */ - memset(&dev, 0, sizeof(dev)); - dev.fd_raw = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); + memset (&dev, 0, sizeof(dev)); + dev.fd_raw = socket (PF_PACKET, SOCK_RAW, htons (ETH_P_ALL)); raw_eno = errno; /* remember for later */ /* now that we've dropped root rights, we can do error checking */ if (2 != argc) - { - fprintf(stderr, - "You must specify the name of the interface as the first and only argument to this program.\n"); - if (-1 != dev.fd_raw) - (void)close(dev.fd_raw); - return 1; - } + { + fprintf (stderr, + "You must specify the name of the interface as the first and only argument to this program.\n"); + if (-1 != dev.fd_raw) + (void) close (dev.fd_raw); + return 1; + } if (-1 == dev.fd_raw) - { - fprintf(stderr, "Failed to create raw socket: %s\n", strerror(raw_eno)); - return 1; - } + { + fprintf (stderr, "Failed to create raw socket: %s\n", strerror (raw_eno)); + return 1; + } if (dev.fd_raw >= FD_SETSIZE) + { + fprintf (stderr, "File descriptor too large for select (%d > %d)\n", + dev.fd_raw, FD_SETSIZE); + (void) close (dev.fd_raw); + return 1; + } + if (0 != test_wlan_interface (argv[1])) + { + (void) close (dev.fd_raw); + return 1; + } + strncpy (dev.iface, argv[1], IFNAMSIZ); + if (0 != open_device_raw (&dev)) + { + (void) close (dev.fd_raw); + return 1; + } + + /* drop privs */ + { + uid_t uid = getuid (); +#ifdef HAVE_SETRESUID + if (0 != setresuid (uid, uid, uid)) { - fprintf(stderr, "File descriptor too large for select (%d > %d)\n", - dev.fd_raw, FD_SETSIZE); - (void)close(dev.fd_raw); - return 1; - } - if (0 != test_wlan_interface(argv[1])) - { - (void)close(dev.fd_raw); + fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno)); + if (-1 != dev.fd_raw) + (void) close (dev.fd_raw); return 1; } - strncpy(dev.iface, argv[1], IFNAMSIZ); - if (0 != open_device_raw(&dev)) +#else + if (0 != (setuid (uid) | seteuid (uid))) { - (void)close(dev.fd_raw); + fprintf (stderr, "Failed to setuid: %s\n", strerror (errno)); + if (-1 != dev.fd_raw) + (void) close (dev.fd_raw); return 1; } - - /* drop privs */ - { - uid_t uid = getuid(); -#ifdef HAVE_SETRESUID - if (0 != setresuid(uid, uid, uid)) - { - fprintf(stderr, "Failed to setresuid: %s\n", strerror(errno)); - if (-1 != dev.fd_raw) - (void)close(dev.fd_raw); - return 1; - } -#else - if (0 != (setuid(uid) | seteuid(uid))) - { - fprintf(stderr, "Failed to setuid: %s\n", strerror(errno)); - if (-1 != dev.fd_raw) - (void)close(dev.fd_raw); - return 1; - } #endif } @@ -2013,141 +2049,145 @@ main(int argc, char *argv[]) { struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg; - macmsg.hdr.size = htons(sizeof(macmsg)); - macmsg.hdr.type = htons(GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); - GNUNET_memcpy(&macmsg.mac, &dev.pl_mac, sizeof(struct GNUNET_TRANSPORT_WLAN_MacAddress)); - GNUNET_memcpy(write_std.buf, &macmsg, sizeof(macmsg)); + macmsg.hdr.size = htons (sizeof(macmsg)); + macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); + GNUNET_memcpy (&macmsg.mac, &dev.pl_mac, sizeof(struct + GNUNET_TRANSPORT_WLAN_MacAddress)); + GNUNET_memcpy (write_std.buf, &macmsg, sizeof(macmsg)); write_std.size = sizeof(macmsg); } - stdin_mst = mst_create(&stdin_send_hw, &dev); + stdin_mst = mst_create (&stdin_send_hw, &dev); stdin_open = 1; while (1) + { + maxfd = -1; + FD_ZERO (&rfds); + if ((0 == write_pout.size) && (1 == stdin_open)) { - maxfd = -1; - FD_ZERO(&rfds); - if ((0 == write_pout.size) && (1 == stdin_open)) - { - FD_SET(STDIN_FILENO, &rfds); - maxfd = MAX(maxfd, STDIN_FILENO); - } - if (0 == write_std.size) - { - FD_SET(dev.fd_raw, &rfds); - maxfd = MAX(maxfd, dev.fd_raw); - } - FD_ZERO(&wfds); - if (0 < write_std.size) - { - FD_SET(STDOUT_FILENO, &wfds); - maxfd = MAX(maxfd, STDOUT_FILENO); - } - if (0 < write_pout.size) - { - FD_SET(dev.fd_raw, &wfds); - maxfd = MAX(maxfd, dev.fd_raw); - } + FD_SET (STDIN_FILENO, &rfds); + maxfd = MAX (maxfd, STDIN_FILENO); + } + if (0 == write_std.size) + { + FD_SET (dev.fd_raw, &rfds); + maxfd = MAX (maxfd, dev.fd_raw); + } + FD_ZERO (&wfds); + if (0 < write_std.size) + { + FD_SET (STDOUT_FILENO, &wfds); + maxfd = MAX (maxfd, STDOUT_FILENO); + } + if (0 < write_pout.size) + { + FD_SET (dev.fd_raw, &wfds); + maxfd = MAX (maxfd, dev.fd_raw); + } + { + int retval = select (maxfd + 1, &rfds, &wfds, NULL, NULL); + if ((-1 == retval) && (EINTR == errno)) + continue; + if (0 > retval) { - int retval = select(maxfd + 1, &rfds, &wfds, NULL, NULL); - if ((-1 == retval) && (EINTR == errno)) - continue; - if (0 > retval) - { - fprintf(stderr, "select failed: %s\n", strerror(errno)); - break; - } + fprintf (stderr, "select failed: %s\n", strerror (errno)); + break; } - if (FD_ISSET(STDOUT_FILENO, &wfds)) - { - ssize_t ret = - write(STDOUT_FILENO, write_std.buf + write_std.pos, - write_std.size - write_std.pos); - if (0 > ret) - { - fprintf(stderr, "Failed to write to STDOUT: %s\n", strerror(errno)); - break; - } - write_std.pos += ret; - if (write_std.pos == write_std.size) - { - write_std.pos = 0; - write_std.size = 0; - } - } - if (FD_ISSET(dev.fd_raw, &wfds)) - { - ssize_t ret = - write(dev.fd_raw, write_pout.buf + write_pout.pos, - write_pout.size - write_pout.pos); - if (0 > ret) - { - fprintf(stderr, "Failed to write to WLAN device: %s\n", - strerror(errno)); - break; - } - write_pout.pos += ret; - if ((write_pout.pos != write_pout.size) && (0 != ret)) - { - /* we should not get partial sends with packet-oriented devices... */ - fprintf(stderr, "Write error, partial send: %u/%u\n", - (unsigned int)write_pout.pos, - (unsigned int)write_pout.size); - break; - } - if (write_pout.pos == write_pout.size) - { - write_pout.pos = 0; - write_pout.size = 0; - } - } + } + if (FD_ISSET (STDOUT_FILENO, &wfds)) + { + ssize_t ret = + write (STDOUT_FILENO, write_std.buf + write_std.pos, + write_std.size - write_std.pos); + if (0 > ret) + { + fprintf (stderr, "Failed to write to STDOUT: %s\n", strerror (errno)); + break; + } + write_std.pos += ret; + if (write_std.pos == write_std.size) + { + write_std.pos = 0; + write_std.size = 0; + } + } + if (FD_ISSET (dev.fd_raw, &wfds)) + { + ssize_t ret = + write (dev.fd_raw, write_pout.buf + write_pout.pos, + write_pout.size - write_pout.pos); + if (0 > ret) + { + fprintf (stderr, "Failed to write to WLAN device: %s\n", + strerror (errno)); + break; + } + write_pout.pos += ret; + if ((write_pout.pos != write_pout.size) && (0 != ret)) + { + /* we should not get partial sends with packet-oriented devices... */ + fprintf (stderr, "Write error, partial send: %u/%u\n", + (unsigned int) write_pout.pos, + (unsigned int) write_pout.size); + break; + } + if (write_pout.pos == write_pout.size) + { + write_pout.pos = 0; + write_pout.size = 0; + } + } - if (FD_ISSET(STDIN_FILENO, &rfds)) - { - ssize_t ret = - read(STDIN_FILENO, readbuf, sizeof(readbuf)); - if (0 > ret) - { - fprintf(stderr, "Read error from STDIN: %s\n", strerror(errno)); - break; - } - if (0 == ret) - { - /* stop reading... */ - stdin_open = 0; - } - mst_receive(stdin_mst, readbuf, ret); - } + if (FD_ISSET (STDIN_FILENO, &rfds)) + { + ssize_t ret = + read (STDIN_FILENO, readbuf, sizeof(readbuf)); + if (0 > ret) + { + fprintf (stderr, "Read error from STDIN: %s\n", strerror (errno)); + break; + } + if (0 == ret) + { + /* stop reading... */ + stdin_open = 0; + } + mst_receive (stdin_mst, readbuf, ret); + } - if (FD_ISSET(dev.fd_raw, &rfds)) - { - struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm; - ssize_t ret; - - rrm = (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *)write_std.buf; - ret = - linux_read(&dev, (unsigned char *)&rrm->frame, - sizeof(write_std.buf) - - sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) - + sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame), - rrm); - if (0 > ret) - { - fprintf(stderr, "Read error from raw socket: %s\n", strerror(errno)); - break; - } - if ((0 < ret) && (0 == mac_test(&rrm->frame, &dev))) - { - write_std.size = ret - + sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) - - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame); - rrm->header.size = htons(write_std.size); - rrm->header.type = htons(GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); - } - } + if (FD_ISSET (dev.fd_raw, &rfds)) + { + struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *rrm; + ssize_t ret; + + rrm = (struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) write_std.buf; + ret = + linux_read (&dev, (unsigned char *) &rrm->frame, + sizeof(write_std.buf) + - sizeof(struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + + sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame), + rrm); + if (0 > ret) + { + fprintf (stderr, "Read error from raw socket: %s\n", strerror (errno)); + break; + } + if ((0 < ret) && (0 == mac_test (&rrm->frame, &dev))) + { + write_std.size = ret + + sizeof(struct + GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + - sizeof(struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame); + rrm->header.size = htons (write_std.size); + rrm->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); + } } + } /* Error handling, try to clean up a bit at least */ - mst_destroy(stdin_mst); - (void)close(dev.fd_raw); + mst_destroy (stdin_mst); + (void) close (dev.fd_raw); return 1; /* we never exit 'normally' */ } diff --git a/src/transport/gnunet-service-tng.c b/src/transport/gnunet-service-tng.c index 09e15655f..66a836b84 100644 --- a/src/transport/gnunet-service-tng.c +++ b/src/transport/gnunet-service-tng.c @@ -176,14 +176,14 @@ * the value chosen here might be too aggressively low! */ #define DELAY_WARN_THRESHOLD \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) /** * If a DVBox could not be forwarded after this number of * seconds we drop it. */ #define DV_FORWARD_TIMEOUT \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60) /** * We only consider queues as "quality" connections when @@ -191,53 +191,53 @@ * the latency of the queue is below this threshold. */ #define DV_QUALITY_RTT_THRESHOLD \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) /** * How long do we consider a DV path valid if we see no * further updates on it? Note: the value chosen here might be too low! */ #define DV_PATH_VALIDITY_TIMEOUT \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) /** * How long do we cache backchannel (struct Backtalker) information * after a backchannel goes inactive? */ #define BACKCHANNEL_INACTIVITY_TIMEOUT \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) /** * How long before paths expire would we like to (re)discover DV paths? Should * be below #DV_PATH_VALIDITY_TIMEOUT. */ #define DV_PATH_DISCOVERY_FREQUENCY \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 4) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4) /** * How long are ephemeral keys valid? */ #define EPHEMERAL_VALIDITY \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 4) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) /** * How long do we keep partially reassembled messages around before giving up? */ #define REASSEMBLY_EXPIRATION \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 4) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4) /** * What is the fastest rate at which we send challenges *if* we keep learning * an address (gossip, DHT, etc.)? */ #define FAST_VALIDATION_CHALLENGE_FREQ \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 1) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1) /** * What is the slowest rate at which we send challenges? */ #define MAX_VALIDATION_CHALLENGE_FREQ \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_DAYS, 1) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_DAYS, 1) /** * How long until we forget about historic accumulators and thus @@ -245,7 +245,7 @@ * active connection experiences without an ACK. */ #define ACK_CUMMULATOR_TIMEOUT \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 4) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) /** * What is the non-randomized base frequency at which we @@ -263,13 +263,13 @@ * When do we forget an invalid address for sure? */ #define MAX_ADDRESS_VALID_UNTIL \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MONTHS, 1) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MONTHS, 1) /** * How long do we consider an address valid if we just checked? */ #define ADDRESS_VALIDATION_LIFETIME \ - GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 4) + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) /** * What is the maximum frequency at which we do address validation? @@ -308,7 +308,8 @@ GNUNET_NETWORK_STRUCT_BEGIN /** * Unique identifier we attach to a message. */ -struct MessageUUIDP { +struct MessageUUIDP +{ /** * Unique value, generated by incrementing the * `message_uuid_ctr` of `struct Neighbour`. @@ -320,7 +321,8 @@ struct MessageUUIDP { /** * Unique identifier to map an acknowledgement to a transmission. */ -struct AcknowledgementUUIDP { +struct AcknowledgementUUIDP +{ /** * The UUID value. */ @@ -331,7 +333,8 @@ struct AcknowledgementUUIDP { /** * Type of a nonce used for challenges. */ -struct ChallengeNonceP { +struct ChallengeNonceP +{ /** * The value of the nonce. Note that this is NOT a hash. */ @@ -342,7 +345,8 @@ struct ChallengeNonceP { /** * Outer layer of an encapsulated backchannel message. */ -struct TransportBackchannelEncapsulationMessage { +struct TransportBackchannelEncapsulationMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION. */ @@ -358,7 +362,8 @@ struct TransportBackchannelEncapsulationMessage { /** * Body by which a peer confirms that it is using an ephemeral key. */ -struct EphemeralConfirmationPS { +struct EphemeralConfirmationPS +{ /** * Purpose is #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL */ @@ -397,7 +402,8 @@ struct EphemeralConfirmationPS { * Plaintext of the variable-size payload that is encrypted * within a `struct TransportBackchannelEncapsulationMessage` */ -struct TransportDVBoxPayloadP { +struct TransportDVBoxPayloadP +{ /** * Sender's peer identity. */ @@ -430,7 +436,8 @@ struct TransportDVBoxPayloadP { * Outer layer of an encapsulated unfragmented application message sent * over an unreliable channel. */ -struct TransportReliabilityBoxMessage { +struct TransportReliabilityBoxMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX */ @@ -456,7 +463,8 @@ struct TransportReliabilityBoxMessage { /** * Acknowledgement payload. */ -struct TransportCummulativeAckPayloadP { +struct TransportCummulativeAckPayloadP +{ /** * How long was the ACK delayed for generating cummulative ACKs? * Used to calculate the correct network RTT by taking the receipt @@ -479,7 +487,8 @@ struct TransportCummulativeAckPayloadP { * so ACKs are identified by a combination of PID of sender and * message UUID, without the queue playing any role! */ -struct TransportReliabilityAckMessage { +struct TransportReliabilityAckMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK */ @@ -499,7 +508,8 @@ struct TransportReliabilityAckMessage { /** * Outer layer of an encapsulated fragmented application message. */ -struct TransportFragmentBoxMessage { +struct TransportFragmentBoxMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT */ @@ -549,7 +559,8 @@ struct TransportFragmentBoxMessage { * potential amplificator will check the @e monotonic_time and only respond * (at most) once per message. */ -struct DvInitPS { +struct DvInitPS +{ /** * Purpose is #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR */ @@ -592,7 +603,8 @@ struct DvInitPS { * replay old messages. Thus, passively learned paths should always be * immediately marked as "potentially stale". */ -struct DvHopPS { +struct DvHopPS +{ /** * Purpose is #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP */ @@ -619,7 +631,8 @@ struct DvHopPS { * An entry describing a peer on a path in a * `struct TransportDVLearnMessage` message. */ -struct DVPathEntryP { +struct DVPathEntryP +{ /** * Identity of a peer on the path. */ @@ -646,7 +659,8 @@ struct DVPathEntryP { * zero, peers that can forward to the initator should always try to * forward to the initiator. */ -struct TransportDVLearnMessage { +struct TransportDVLearnMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN */ @@ -733,7 +747,8 @@ struct TransportDVLearnMessage { * the predecessor must be the origin (so this is not really useful * for anonymization). */ -struct TransportDVBoxMessage { +struct TransportDVBoxMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX */ @@ -791,7 +806,8 @@ struct TransportDVBoxMessage { * Message send to another peer to validate that it can indeed * receive messages at a particular address. */ -struct TransportValidationChallengeMessage { +struct TransportValidationChallengeMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE */ @@ -819,7 +835,8 @@ struct TransportValidationChallengeMessage { * Message signed by a peer to confirm that it can indeed * receive messages at a particular address. */ -struct TransportValidationPS { +struct TransportValidationPS +{ /** * Purpose is #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE */ @@ -842,7 +859,8 @@ struct TransportValidationPS { * Message send to a peer to respond to a * #GNUNET_MESSAGE_TYPE_ADDRESS_VALIDATION_CHALLENGE */ -struct TransportValidationResponseMessage { +struct TransportValidationResponseMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE */ @@ -886,7 +904,8 @@ struct TransportValidationResponseMessage { * send to us, and how much data we already received from the other * peer. */ -struct TransportFlowControlMessage { +struct TransportFlowControlMessage +{ /** * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL */ @@ -942,7 +961,8 @@ GNUNET_NETWORK_STRUCT_END /** * What type of client is the `struct TransportClient` about? */ -enum ClientType { +enum ClientType +{ /** * We do not know yet (client is fresh). */ @@ -974,7 +994,8 @@ enum ClientType { * Which transmission options are allowable for transmission? * Interpreted bit-wise! */ -enum RouteMessageOptions { +enum RouteMessageOptions +{ /** * Only confirmed, non-DV direct neighbours. */ @@ -1007,7 +1028,8 @@ enum RouteMessageOptions { /** * When did we launch this DV learning activity? */ -struct LearnLaunchEntry { +struct LearnLaunchEntry +{ /** * Kept (also) in a DLL sorted by launch time. */ @@ -1035,7 +1057,8 @@ struct LearnLaunchEntry { * Information we keep per #GOODPUT_AGING_SLOTS about historic * (or current) transmission performance. */ -struct TransmissionHistoryEntry { +struct TransmissionHistoryEntry +{ /** * Number of bytes actually sent in the interval. */ @@ -1052,7 +1075,8 @@ struct TransmissionHistoryEntry { /** * Performance data for a transmission possibility. */ -struct PerformanceData { +struct PerformanceData +{ /** * Weighted average for the RTT. */ @@ -1119,7 +1143,8 @@ struct VirtualLink; * Context from #handle_incoming_msg(). Closure for many * message handlers below. */ -struct CommunicatorMessageContext { +struct CommunicatorMessageContext +{ /** * Kept in a DLL of `struct VirtualLink` if waiting for CORE * flow control to unchoke. @@ -1153,7 +1178,8 @@ struct CommunicatorMessageContext { /** * Closure for #core_env_sent_cb. */ -struct CoreSentContext { +struct CoreSentContext +{ /** * Kept in a DLL to clear @e vl in case @e vl is lost. */ @@ -1192,7 +1218,8 @@ struct CoreSentContext { * data that is per neighbour that is not specific to how the * connectivity is established. */ -struct VirtualLink { +struct VirtualLink +{ /** * Identity of the peer at the other end of the link. */ @@ -1390,7 +1417,8 @@ struct VirtualLink { /** * Data structure kept when we are waiting for an acknowledgement. */ -struct PendingAcknowledgement { +struct PendingAcknowledgement +{ /** * If @e pm is non-NULL, this is the DLL in which this acknowledgement * is kept in relation to its pending message. @@ -1483,7 +1511,8 @@ struct PendingAcknowledgement { /** * One possible hop towards a DV target. */ -struct DistanceVectorHop { +struct DistanceVectorHop +{ /** * Kept in a MDLL, sorted by @e timeout. */ @@ -1564,7 +1593,8 @@ struct DistanceVectorHop { * Entry in our #dv_routes table, representing a (set of) distance * vector routes to a particular peer. */ -struct DistanceVector { +struct DistanceVector +{ /** * To which peer is this a route? */ @@ -1628,7 +1658,8 @@ struct DistanceVector { * what the communicator can actually provide towards a particular * peer/target). */ -struct QueueEntry { +struct QueueEntry +{ /** * Kept as a DLL. */ @@ -1660,7 +1691,8 @@ struct QueueEntry { * A queue is a message queue provided by a communicator * via which we can reach a particular neighbour. */ -struct Queue { +struct Queue +{ /** * Kept in a MDLL. */ @@ -1788,7 +1820,8 @@ struct Queue { /** * Information we keep for a message that we are reassembling. */ -struct ReassemblyContext { +struct ReassemblyContext +{ /** * Original message ID for of the message that all the fragments * belong to. @@ -1846,7 +1879,8 @@ struct ReassemblyContext { /** * A neighbour that at least one communicator is connected to. */ -struct Neighbour { +struct Neighbour +{ /** * Which peer is this about? */ @@ -1929,7 +1963,8 @@ struct Neighbour { * Another peer attempted to talk to us, we should try to establish * a connection in the other direction. */ -struct IncomingRequest { +struct IncomingRequest +{ /** * Kept in a DLL. */ @@ -1955,7 +1990,8 @@ struct IncomingRequest { /** * A peer that an application (client) would like us to talk to directly. */ -struct PeerRequest { +struct PeerRequest +{ /** * Which peer is this about? */ @@ -1988,7 +2024,8 @@ struct PeerRequest { /** * Types of different pending messages. */ -enum PendingMessageType { +enum PendingMessageType +{ /** * Ordinary message received from the CORE service. */ @@ -2037,7 +2074,8 @@ enum PendingMessageType { * is never again transmitted (even if it fits below the MTU), and * only (remaining) fragments are sent. */ -struct PendingMessage { +struct PendingMessage +{ /** * Kept in a MDLL of messages for this @a vl. */ @@ -2176,7 +2214,8 @@ struct PendingMessage { /** * Acknowledgement payload. */ -struct TransportCummulativeAckPayload { +struct TransportCummulativeAckPayload +{ /** * When did we receive the message we are ACKing? Used to calculate * the delay we introduced by cummulating ACKs. @@ -2194,7 +2233,8 @@ struct TransportCummulativeAckPayload { * Data structure in which we track acknowledgements still to * be sent to the */ -struct AcknowledgementCummulator { +struct AcknowledgementCummulator +{ /** * Target peer for which we are accumulating ACKs here. */ @@ -2234,7 +2274,8 @@ struct AcknowledgementCummulator { /** * One of the addresses of this peer. */ -struct AddressListEntry { +struct AddressListEntry +{ /** * Kept in a DLL. */ @@ -2286,7 +2327,8 @@ struct AddressListEntry { /** * Client connected to the transport service. */ -struct TransportClient { +struct TransportClient +{ /** * Kept in a DLL. */ @@ -2312,11 +2354,13 @@ struct TransportClient { */ enum ClientType type; - union { + union + { /** * Information for @e type #CT_CORE. */ - struct { + struct + { /** * Head of list of messages pending for this client, sorted by * transmission time ("next_attempt" + possibly internal prioritization). @@ -2332,7 +2376,8 @@ struct TransportClient { /** * Information for @e type #CT_MONITOR. */ - struct { + struct + { /** * Peer identity to monitor the addresses of. * Zero to monitor all neighbours. Valid if @@ -2350,7 +2395,8 @@ struct TransportClient { /** * Information for @e type #CT_COMMUNICATOR. */ - struct { + struct + { /** * If @e type is #CT_COMMUNICATOR, this communicator * supports communicating using these addresses. @@ -2395,7 +2441,8 @@ struct TransportClient { /** * Information for @e type #CT_APPLICATION */ - struct { + struct + { /** * Map of requests for peers the given client application would like to * see connections for. Maps from PIDs to `struct PeerRequest`. @@ -2410,7 +2457,8 @@ struct TransportClient { * State we keep for validation activities. Each of these * is both in the #validation_heap and the #validation_map. */ -struct ValidationState { +struct ValidationState +{ /** * For which peer is @a address to be validated (or possibly valid)? * Serves as key in the #validation_map. @@ -2520,7 +2568,8 @@ struct ValidationState { * material (to avoid repeatedly checking signatures), and to synchronize * monotonic time with the PEERSTORE. */ -struct Backtalker { +struct Backtalker +{ /** * Peer this is about. */ @@ -2743,11 +2792,11 @@ static struct GNUNET_TIME_Absolute hello_mono_time; * @return current age of the world */ static unsigned int -get_age() +get_age () { struct GNUNET_TIME_Absolute now; - now = GNUNET_TIME_absolute_get(); + now = GNUNET_TIME_absolute_get (); return now.abs_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us / 15; } @@ -2758,13 +2807,13 @@ get_age() * @param ir data structure to release */ static void -free_incoming_request(struct IncomingRequest *ir) +free_incoming_request (struct IncomingRequest *ir) { - GNUNET_CONTAINER_DLL_remove(ir_head, ir_tail, ir); - GNUNET_assert(ir_total > 0); + GNUNET_CONTAINER_DLL_remove (ir_head, ir_tail, ir); + GNUNET_assert (ir_total > 0); ir_total--; - GNUNET_PEERSTORE_watch_cancel(ir->wc); - GNUNET_free(ir); + GNUNET_PEERSTORE_watch_cancel (ir->wc); + GNUNET_free (ir); } @@ -2774,34 +2823,34 @@ free_incoming_request(struct IncomingRequest *ir) * @param pa data structure to release */ static void -free_pending_acknowledgement(struct PendingAcknowledgement *pa) +free_pending_acknowledgement (struct PendingAcknowledgement *pa) { struct Queue *q = pa->queue; struct PendingMessage *pm = pa->pm; struct DistanceVectorHop *dvh = pa->dvh; - GNUNET_CONTAINER_MDLL_remove(pa, pa_head, pa_tail, pa); + GNUNET_CONTAINER_MDLL_remove (pa, pa_head, pa_tail, pa); pa_count--; if (NULL != q) - { - GNUNET_CONTAINER_MDLL_remove(queue, q->pa_head, q->pa_tail, pa); - pa->queue = NULL; - } + { + GNUNET_CONTAINER_MDLL_remove (queue, q->pa_head, q->pa_tail, pa); + pa->queue = NULL; + } if (NULL != pm) - { - GNUNET_CONTAINER_MDLL_remove(pm, pm->pa_head, pm->pa_tail, pa); - pa->pm = NULL; - } + { + GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa); + pa->pm = NULL; + } if (NULL != dvh) - { - GNUNET_CONTAINER_MDLL_remove(dvh, dvh->pa_head, dvh->pa_tail, pa); - pa->queue = NULL; - } - GNUNET_assert(GNUNET_YES == - GNUNET_CONTAINER_multiuuidmap_remove(pending_acks, - &pa->ack_uuid.value, - pa)); - GNUNET_free(pa); + { + GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa); + pa->queue = NULL; + } + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multiuuidmap_remove (pending_acks, + &pa->ack_uuid.value, + pa)); + GNUNET_free (pa); } @@ -2814,23 +2863,23 @@ free_pending_acknowledgement(struct PendingAcknowledgement *pa) * @param root root of the tree to free */ static void -free_fragment_tree(struct PendingMessage *root) +free_fragment_tree (struct PendingMessage *root) { struct PendingMessage *frag; while (NULL != (frag = root->head_frag)) - { - struct PendingAcknowledgement *pa; + { + struct PendingAcknowledgement *pa; - free_fragment_tree(frag); - while (NULL != (pa = frag->pa_head)) - { - GNUNET_CONTAINER_MDLL_remove(pm, frag->pa_head, frag->pa_tail, pa); - pa->pm = NULL; - } - GNUNET_CONTAINER_MDLL_remove(frag, root->head_frag, root->tail_frag, frag); - GNUNET_free(frag); + free_fragment_tree (frag); + while (NULL != (pa = frag->pa_head)) + { + GNUNET_CONTAINER_MDLL_remove (pm, frag->pa_head, frag->pa_tail, pa); + pa->pm = NULL; } + GNUNET_CONTAINER_MDLL_remove (frag, root->head_frag, root->tail_frag, frag); + GNUNET_free (frag); + } } @@ -2842,44 +2891,44 @@ free_fragment_tree(struct PendingMessage *root) * @param pm the pending message to free */ static void -free_pending_message(struct PendingMessage *pm) +free_pending_message (struct PendingMessage *pm) { struct TransportClient *tc = pm->client; struct VirtualLink *vl = pm->vl; struct PendingAcknowledgement *pa; if (NULL != tc) - { - GNUNET_CONTAINER_MDLL_remove(client, - tc->details.core.pending_msg_head, - tc->details.core.pending_msg_tail, - pm); - } + { + GNUNET_CONTAINER_MDLL_remove (client, + tc->details.core.pending_msg_head, + tc->details.core.pending_msg_tail, + pm); + } if (NULL != vl) - { - GNUNET_CONTAINER_MDLL_remove(vl, - vl->pending_msg_head, - vl->pending_msg_tail, - pm); - } + { + GNUNET_CONTAINER_MDLL_remove (vl, + vl->pending_msg_head, + vl->pending_msg_tail, + pm); + } while (NULL != (pa = pm->pa_head)) - { - GNUNET_CONTAINER_MDLL_remove(pm, pm->pa_head, pm->pa_tail, pa); - pa->pm = NULL; - } + { + GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa); + pa->pm = NULL; + } - free_fragment_tree(pm); + free_fragment_tree (pm); if (NULL != pm->qe) - { - GNUNET_assert(pm == pm->qe->pm); - pm->qe->pm = NULL; - } + { + GNUNET_assert (pm == pm->qe->pm); + pm->qe->pm = NULL; + } if (NULL != pm->bpm) - { - free_fragment_tree(pm->bpm); - GNUNET_free(pm->bpm); - } - GNUNET_free(pm); + { + free_fragment_tree (pm->bpm); + GNUNET_free (pm->bpm); + } + GNUNET_free (pm); } @@ -2889,34 +2938,34 @@ free_pending_message(struct PendingMessage *pm) * @param vl link data to free */ static void -free_virtual_link(struct VirtualLink *vl) +free_virtual_link (struct VirtualLink *vl) { struct PendingMessage *pm; struct CoreSentContext *csc; while (NULL != (pm = vl->pending_msg_head)) - free_pending_message(pm); - GNUNET_assert(GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(links, &vl->target, vl)); + free_pending_message (pm); + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multipeermap_remove (links, &vl->target, vl)); if (NULL != vl->visibility_task) - { - GNUNET_SCHEDULER_cancel(vl->visibility_task); - vl->visibility_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (vl->visibility_task); + vl->visibility_task = NULL; + } if (NULL != vl->fc_retransmit_task) - { - GNUNET_SCHEDULER_cancel(vl->fc_retransmit_task); - vl->fc_retransmit_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task); + vl->fc_retransmit_task = NULL; + } while (NULL != (csc = vl->csc_head)) - { - GNUNET_CONTAINER_DLL_remove(vl->csc_head, vl->csc_tail, csc); - GNUNET_assert(vl == csc->vl); - csc->vl = NULL; - } - GNUNET_break(NULL == vl->n); - GNUNET_break(NULL == vl->dv); - GNUNET_free(vl); + { + GNUNET_CONTAINER_DLL_remove (vl->csc_head, vl->csc_tail, csc); + GNUNET_assert (vl == csc->vl); + csc->vl = NULL; + } + GNUNET_break (NULL == vl->n); + GNUNET_break (NULL == vl->dv); + GNUNET_free (vl); } @@ -2926,20 +2975,20 @@ free_virtual_link(struct VirtualLink *vl) * @param vs validation state to free */ static void -free_validation_state(struct ValidationState *vs) +free_validation_state (struct ValidationState *vs) { - GNUNET_assert( + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(validation_map, &vs->pid, vs)); - GNUNET_CONTAINER_heap_remove_node(vs->hn); + GNUNET_CONTAINER_multipeermap_remove (validation_map, &vs->pid, vs)); + GNUNET_CONTAINER_heap_remove_node (vs->hn); vs->hn = NULL; if (NULL != vs->sc) - { - GNUNET_PEERSTORE_store_cancel(vs->sc); - vs->sc = NULL; - } - GNUNET_free(vs->address); - GNUNET_free(vs); + { + GNUNET_PEERSTORE_store_cancel (vs->sc); + vs->sc = NULL; + } + GNUNET_free (vs->address); + GNUNET_free (vs); } @@ -2950,9 +2999,9 @@ free_validation_state(struct ValidationState *vs) * @return NULL if we do not have this peer as a neighbour */ static struct Neighbour * -lookup_neighbour(const struct GNUNET_PeerIdentity *pid) +lookup_neighbour (const struct GNUNET_PeerIdentity *pid) { - return GNUNET_CONTAINER_multipeermap_get(neighbours, pid); + return GNUNET_CONTAINER_multipeermap_get (neighbours, pid); } @@ -2963,16 +3012,17 @@ lookup_neighbour(const struct GNUNET_PeerIdentity *pid) * @return NULL if we do not have this peer as a virtual link */ static struct VirtualLink * -lookup_virtual_link(const struct GNUNET_PeerIdentity *pid) +lookup_virtual_link (const struct GNUNET_PeerIdentity *pid) { - return GNUNET_CONTAINER_multipeermap_get(links, pid); + return GNUNET_CONTAINER_multipeermap_get (links, pid); } /** * Details about what to notify monitors about. */ -struct MonitorEvent { +struct MonitorEvent +{ /** * @deprecated To be discussed if we keep these... */ @@ -3011,20 +3061,20 @@ struct MonitorEvent { * @param dvh hop to free */ static void -free_distance_vector_hop(struct DistanceVectorHop *dvh) +free_distance_vector_hop (struct DistanceVectorHop *dvh) { struct Neighbour *n = dvh->next_hop; struct DistanceVector *dv = dvh->dv; struct PendingAcknowledgement *pa; while (NULL != (pa = dvh->pa_head)) - { - GNUNET_CONTAINER_MDLL_remove(dvh, dvh->pa_head, dvh->pa_tail, pa); - pa->dvh = NULL; - } - GNUNET_CONTAINER_MDLL_remove(neighbour, n->dv_head, n->dv_tail, dvh); - GNUNET_CONTAINER_MDLL_remove(dv, dv->dv_head, dv->dv_tail, dvh); - GNUNET_free(dvh); + { + GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa); + pa->dvh = NULL; + } + GNUNET_CONTAINER_MDLL_remove (neighbour, n->dv_head, n->dv_tail, dvh); + GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, dvh); + GNUNET_free (dvh); } @@ -3035,7 +3085,7 @@ free_distance_vector_hop(struct DistanceVectorHop *dvh) * @param cls a `struct VirtualLink` */ static void -check_link_down(void *cls); +check_link_down (void *cls); /** @@ -3044,22 +3094,22 @@ check_link_down(void *cls); * @param pid peer the connection was for */ static void -cores_send_disconnect_info(const struct GNUNET_PeerIdentity *pid) +cores_send_disconnect_info (const struct GNUNET_PeerIdentity *pid) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Informing CORE clients about disconnect from %s\n", - GNUNET_i2s(pid)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Informing CORE clients about disconnect from %s\n", + GNUNET_i2s (pid)); for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next) - { - struct GNUNET_MQ_Envelope *env; - struct DisconnectInfoMessage *dim; - - if (CT_CORE != tc->type) - continue; - env = GNUNET_MQ_msg(dim, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT); - dim->peer = *pid; - GNUNET_MQ_send(tc->mq, env); - } + { + struct GNUNET_MQ_Envelope *env; + struct DisconnectInfoMessage *dim; + + if (CT_CORE != tc->type) + continue; + env = GNUNET_MQ_msg (dim, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT); + dim->peer = *pid; + GNUNET_MQ_send (tc->mq, env); + } } @@ -3070,43 +3120,43 @@ cores_send_disconnect_info(const struct GNUNET_PeerIdentity *pid) * @param dv route to free */ static void -free_dv_route(struct DistanceVector *dv) +free_dv_route (struct DistanceVector *dv) { struct DistanceVectorHop *dvh; while (NULL != (dvh = dv->dv_head)) - free_distance_vector_hop(dvh); + free_distance_vector_hop (dvh); if (NULL == dv->dv_head) - { - struct VirtualLink *vl; + { + struct VirtualLink *vl; - GNUNET_assert( - GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(dv_routes, &dv->target, dv)); - if (NULL != (vl = dv->vl)) - { - GNUNET_assert(dv == vl->dv); - vl->dv = NULL; - if (NULL == vl->n) - { - cores_send_disconnect_info(&dv->target); - free_virtual_link(vl); - } - else - { - GNUNET_SCHEDULER_cancel(vl->visibility_task); - vl->visibility_task = GNUNET_SCHEDULER_add_now(&check_link_down, vl); - } - dv->vl = NULL; - } + GNUNET_assert ( + GNUNET_YES == + GNUNET_CONTAINER_multipeermap_remove (dv_routes, &dv->target, dv)); + if (NULL != (vl = dv->vl)) + { + GNUNET_assert (dv == vl->dv); + vl->dv = NULL; + if (NULL == vl->n) + { + cores_send_disconnect_info (&dv->target); + free_virtual_link (vl); + } + else + { + GNUNET_SCHEDULER_cancel (vl->visibility_task); + vl->visibility_task = GNUNET_SCHEDULER_add_now (&check_link_down, vl); + } + dv->vl = NULL; + } - if (NULL != dv->timeout_task) - { - GNUNET_SCHEDULER_cancel(dv->timeout_task); - dv->timeout_task = NULL; - } - GNUNET_free(dv); + if (NULL != dv->timeout_task) + { + GNUNET_SCHEDULER_cancel (dv->timeout_task); + dv->timeout_task = NULL; } + GNUNET_free (dv); + } } @@ -3124,30 +3174,30 @@ free_dv_route(struct DistanceVector *dv) * @param me detailed information to transmit */ static void -notify_monitor(struct TransportClient *tc, - const struct GNUNET_PeerIdentity *peer, - const char *address, - enum GNUNET_NetworkType nt, - const struct MonitorEvent *me) +notify_monitor (struct TransportClient *tc, + const struct GNUNET_PeerIdentity *peer, + const char *address, + enum GNUNET_NetworkType nt, + const struct MonitorEvent *me) { struct GNUNET_MQ_Envelope *env; struct GNUNET_TRANSPORT_MonitorData *md; - size_t addr_len = strlen(address) + 1; + size_t addr_len = strlen (address) + 1; - env = GNUNET_MQ_msg_extra(md, - addr_len, - GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA); - md->nt = htonl((uint32_t)nt); + env = GNUNET_MQ_msg_extra (md, + addr_len, + GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA); + md->nt = htonl ((uint32_t) nt); md->peer = *peer; - md->last_validation = GNUNET_TIME_absolute_hton(me->last_validation); - md->valid_until = GNUNET_TIME_absolute_hton(me->valid_until); - md->next_validation = GNUNET_TIME_absolute_hton(me->next_validation); - md->rtt = GNUNET_TIME_relative_hton(me->rtt); - md->cs = htonl((uint32_t)me->cs); - md->num_msg_pending = htonl(me->num_msg_pending); - md->num_bytes_pending = htonl(me->num_bytes_pending); - memcpy(&md[1], address, addr_len); - GNUNET_MQ_send(tc->mq, env); + md->last_validation = GNUNET_TIME_absolute_hton (me->last_validation); + md->valid_until = GNUNET_TIME_absolute_hton (me->valid_until); + md->next_validation = GNUNET_TIME_absolute_hton (me->next_validation); + md->rtt = GNUNET_TIME_relative_hton (me->rtt); + md->cs = htonl ((uint32_t) me->cs); + md->num_msg_pending = htonl (me->num_msg_pending); + md->num_bytes_pending = htonl (me->num_bytes_pending); + memcpy (&md[1], address, addr_len); + GNUNET_MQ_send (tc->mq, env); } @@ -3161,22 +3211,22 @@ notify_monitor(struct TransportClient *tc, * @param me detailed information to transmit */ static void -notify_monitors(const struct GNUNET_PeerIdentity *peer, - const char *address, - enum GNUNET_NetworkType nt, - const struct MonitorEvent *me) +notify_monitors (const struct GNUNET_PeerIdentity *peer, + const char *address, + enum GNUNET_NetworkType nt, + const struct MonitorEvent *me) { for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next) - { - if (CT_MONITOR != tc->type) - continue; - if (tc->details.monitor.one_shot) - continue; - if ((0 != GNUNET_is_zero(&tc->details.monitor.peer)) && - (0 != GNUNET_memcmp(&tc->details.monitor.peer, peer))) - continue; - notify_monitor(tc, peer, address, nt, me); - } + { + if (CT_MONITOR != tc->type) + continue; + if (tc->details.monitor.one_shot) + continue; + if ((0 != GNUNET_is_zero (&tc->details.monitor.peer)) && + (0 != GNUNET_memcmp (&tc->details.monitor.peer, peer))) + continue; + notify_monitor (tc, peer, address, nt, me); + } } @@ -3190,18 +3240,18 @@ notify_monitors(const struct GNUNET_PeerIdentity *peer, * @return our `struct TransportClient` */ static void * -client_connect_cb(void *cls, - struct GNUNET_SERVICE_Client *client, - struct GNUNET_MQ_Handle *mq) +client_connect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + struct GNUNET_MQ_Handle *mq) { struct TransportClient *tc; - (void)cls; - tc = GNUNET_new(struct TransportClient); + (void) cls; + tc = GNUNET_new (struct TransportClient); tc->client = client; tc->mq = mq; - GNUNET_CONTAINER_DLL_insert(clients_head, clients_tail, tc); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", tc); + GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", tc); return tc; } @@ -3212,16 +3262,16 @@ client_connect_cb(void *cls, * @param rc data structure to free */ static void -free_reassembly_context(struct ReassemblyContext *rc) +free_reassembly_context (struct ReassemblyContext *rc) { struct Neighbour *n = rc->neighbour; - GNUNET_assert(rc == GNUNET_CONTAINER_heap_remove_node(rc->hn)); - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap32_remove(n->reassembly_map, - rc->msg_uuid.uuid, - rc)); - GNUNET_free(rc); + GNUNET_assert (rc == GNUNET_CONTAINER_heap_remove_node (rc->hn)); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap32_remove (n->reassembly_map, + rc->msg_uuid.uuid, + rc)); + GNUNET_free (rc); } @@ -3231,27 +3281,27 @@ free_reassembly_context(struct ReassemblyContext *rc) * @param cls a `struct Neighbour` */ static void -reassembly_cleanup_task(void *cls) +reassembly_cleanup_task (void *cls) { struct Neighbour *n = cls; struct ReassemblyContext *rc; n->reassembly_timeout_task = NULL; - while (NULL != (rc = GNUNET_CONTAINER_heap_peek(n->reassembly_heap))) + while (NULL != (rc = GNUNET_CONTAINER_heap_peek (n->reassembly_heap))) + { + if (0 == GNUNET_TIME_absolute_get_remaining (rc->reassembly_timeout) + .rel_value_us) { - if (0 == GNUNET_TIME_absolute_get_remaining(rc->reassembly_timeout) - .rel_value_us) - { - free_reassembly_context(rc); - continue; - } - GNUNET_assert(NULL == n->reassembly_timeout_task); - n->reassembly_timeout_task = - GNUNET_SCHEDULER_add_at(rc->reassembly_timeout, - &reassembly_cleanup_task, - n); - return; + free_reassembly_context (rc); + continue; } + GNUNET_assert (NULL == n->reassembly_timeout_task); + n->reassembly_timeout_task = + GNUNET_SCHEDULER_add_at (rc->reassembly_timeout, + &reassembly_cleanup_task, + n); + return; + } } @@ -3264,13 +3314,13 @@ reassembly_cleanup_task(void *cls) * @return #GNUNET_OK (continue iteration) */ static int -free_reassembly_cb(void *cls, uint32_t key, void *value) +free_reassembly_cb (void *cls, uint32_t key, void *value) { struct ReassemblyContext *rc = value; - (void)cls; - (void)key; - free_reassembly_context(rc); + (void) cls; + (void) key; + free_reassembly_context (rc); return GNUNET_OK; } @@ -3281,66 +3331,66 @@ free_reassembly_cb(void *cls, uint32_t key, void *value) * @param neighbour neighbour entry to free */ static void -free_neighbour(struct Neighbour *neighbour) +free_neighbour (struct Neighbour *neighbour) { struct DistanceVectorHop *dvh; struct VirtualLink *vl; - GNUNET_assert(NULL == neighbour->queue_head); - GNUNET_assert(GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(neighbours, - &neighbour->pid, - neighbour)); + GNUNET_assert (NULL == neighbour->queue_head); + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multipeermap_remove (neighbours, + &neighbour->pid, + neighbour)); if (NULL != neighbour->reassembly_map) - { - GNUNET_CONTAINER_multihashmap32_iterate(neighbour->reassembly_map, - &free_reassembly_cb, - NULL); - GNUNET_CONTAINER_multihashmap32_destroy(neighbour->reassembly_map); - neighbour->reassembly_map = NULL; - GNUNET_CONTAINER_heap_destroy(neighbour->reassembly_heap); - neighbour->reassembly_heap = NULL; - } + { + GNUNET_CONTAINER_multihashmap32_iterate (neighbour->reassembly_map, + &free_reassembly_cb, + NULL); + GNUNET_CONTAINER_multihashmap32_destroy (neighbour->reassembly_map); + neighbour->reassembly_map = NULL; + GNUNET_CONTAINER_heap_destroy (neighbour->reassembly_heap); + neighbour->reassembly_heap = NULL; + } while (NULL != (dvh = neighbour->dv_head)) - { - struct DistanceVector *dv = dvh->dv; + { + struct DistanceVector *dv = dvh->dv; - free_distance_vector_hop(dvh); - if (NULL == dv->dv_head) - free_dv_route(dv); - } + free_distance_vector_hop (dvh); + if (NULL == dv->dv_head) + free_dv_route (dv); + } if (NULL != neighbour->reassembly_timeout_task) - { - GNUNET_SCHEDULER_cancel(neighbour->reassembly_timeout_task); - neighbour->reassembly_timeout_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (neighbour->reassembly_timeout_task); + neighbour->reassembly_timeout_task = NULL; + } if (NULL != neighbour->get) - { - GNUNET_PEERSTORE_iterate_cancel(neighbour->get); - neighbour->get = NULL; - } + { + GNUNET_PEERSTORE_iterate_cancel (neighbour->get); + neighbour->get = NULL; + } if (NULL != neighbour->sc) + { + GNUNET_PEERSTORE_store_cancel (neighbour->sc); + neighbour->sc = NULL; + } + if (NULL != (vl = neighbour->vl)) + { + GNUNET_assert (neighbour == vl->n); + vl->n = NULL; + if (NULL == vl->dv) { - GNUNET_PEERSTORE_store_cancel(neighbour->sc); - neighbour->sc = NULL; + cores_send_disconnect_info (&vl->target); + free_virtual_link (vl); } - if (NULL != (vl = neighbour->vl)) + else { - GNUNET_assert(neighbour == vl->n); - vl->n = NULL; - if (NULL == vl->dv) - { - cores_send_disconnect_info(&vl->target); - free_virtual_link(vl); - } - else - { - GNUNET_SCHEDULER_cancel(vl->visibility_task); - vl->visibility_task = GNUNET_SCHEDULER_add_now(&check_link_down, vl); - } - neighbour->vl = NULL; + GNUNET_SCHEDULER_cancel (vl->visibility_task); + vl->visibility_task = GNUNET_SCHEDULER_add_now (&check_link_down, vl); } - GNUNET_free(neighbour); + neighbour->vl = NULL; + } + GNUNET_free (neighbour); } @@ -3351,16 +3401,16 @@ free_neighbour(struct Neighbour *neighbour) * @param pid peer the connection is for */ static void -core_send_connect_info(struct TransportClient *tc, - const struct GNUNET_PeerIdentity *pid) +core_send_connect_info (struct TransportClient *tc, + const struct GNUNET_PeerIdentity *pid) { struct GNUNET_MQ_Envelope *env; struct ConnectInfoMessage *cim; - GNUNET_assert(CT_CORE == tc->type); - env = GNUNET_MQ_msg(cim, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT); + GNUNET_assert (CT_CORE == tc->type); + env = GNUNET_MQ_msg (cim, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT); cim->id = *pid; - GNUNET_MQ_send(tc->mq, env); + GNUNET_MQ_send (tc->mq, env); } @@ -3370,17 +3420,17 @@ core_send_connect_info(struct TransportClient *tc, * @param pid peer the queue was for */ static void -cores_send_connect_info(const struct GNUNET_PeerIdentity *pid) +cores_send_connect_info (const struct GNUNET_PeerIdentity *pid) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Informing CORE clients about connection to %s\n", - GNUNET_i2s(pid)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Informing CORE clients about connection to %s\n", + GNUNET_i2s (pid)); for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next) - { - if (CT_CORE != tc->type) - continue; - core_send_connect_info(tc, pid); - } + { + if (CT_CORE != tc->type) + continue; + core_send_connect_info (tc, pid); + } } @@ -3392,7 +3442,7 @@ cores_send_connect_info(const struct GNUNET_PeerIdentity *pid) * @param cls the `struct Queue` to process transmissions for */ static void -transmit_on_queue(void *cls); +transmit_on_queue (void *cls); /** @@ -3403,38 +3453,38 @@ transmit_on_queue(void *cls); * @param p task priority to use, if @a queue is scheduled */ static void -schedule_transmit_on_queue(struct Queue *queue, - enum GNUNET_SCHEDULER_Priority p) +schedule_transmit_on_queue (struct Queue *queue, + enum GNUNET_SCHEDULER_Priority p) { if (queue->tc->details.communicator.total_queue_length >= COMMUNICATOR_TOTAL_QUEUE_LIMIT) - { - GNUNET_STATISTICS_update( - GST_stats, - "# Transmission throttled due to communicator queue limit", - 1, - GNUNET_NO); - queue->idle = GNUNET_NO; - return; - } + { + GNUNET_STATISTICS_update ( + GST_stats, + "# Transmission throttled due to communicator queue limit", + 1, + GNUNET_NO); + queue->idle = GNUNET_NO; + return; + } if (queue->queue_length >= QUEUE_LENGTH_LIMIT) - { - GNUNET_STATISTICS_update(GST_stats, - "# Transmission throttled due to queue queue limit", - 1, - GNUNET_NO); - queue->idle = GNUNET_NO; - return; - } + { + GNUNET_STATISTICS_update (GST_stats, + "# Transmission throttled due to queue queue limit", + 1, + GNUNET_NO); + queue->idle = GNUNET_NO; + return; + } /* queue might indeed be ready, schedule it */ if (NULL != queue->transmit_task) - GNUNET_SCHEDULER_cancel(queue->transmit_task); + GNUNET_SCHEDULER_cancel (queue->transmit_task); queue->transmit_task = - GNUNET_SCHEDULER_add_with_priority(p, &transmit_on_queue, queue); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Considering transmission on queue `%s' to %s\n", - queue->address, - GNUNET_i2s(&queue->neighbour->pid)); + GNUNET_SCHEDULER_add_with_priority (p, &transmit_on_queue, queue); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Considering transmission on queue `%s' to %s\n", + queue->address, + GNUNET_i2s (&queue->neighbour->pid)); } @@ -3445,7 +3495,7 @@ schedule_transmit_on_queue(struct Queue *queue, * @param cls a `struct VirtualLink` */ static void -check_link_down(void *cls) +check_link_down (void *cls) { struct VirtualLink *vl = cls; struct DistanceVector *dv = vl->dv; @@ -3457,30 +3507,30 @@ check_link_down(void *cls) dvh_timeout = GNUNET_TIME_UNIT_ZERO_ABS; for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; pos = pos->next_dv) - dvh_timeout = GNUNET_TIME_absolute_max(dvh_timeout, pos->path_valid_until); - if (0 == GNUNET_TIME_absolute_get_remaining(dvh_timeout).rel_value_us) - { - vl->dv->vl = NULL; - vl->dv = NULL; - } + dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout, pos->path_valid_until); + if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us) + { + vl->dv->vl = NULL; + vl->dv = NULL; + } q_timeout = GNUNET_TIME_UNIT_ZERO_ABS; for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour) - q_timeout = GNUNET_TIME_absolute_max(q_timeout, q->validated_until); - if (0 == GNUNET_TIME_absolute_get_remaining(q_timeout).rel_value_us) - { - vl->n->vl = NULL; - vl->n = NULL; - } + q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until); + if (0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us) + { + vl->n->vl = NULL; + vl->n = NULL; + } if ((NULL == vl->n) && (NULL == vl->dv)) - { - cores_send_disconnect_info(&vl->target); - free_virtual_link(vl); - return; - } + { + cores_send_disconnect_info (&vl->target); + free_virtual_link (vl); + return; + } vl->visibility_task = - GNUNET_SCHEDULER_add_at(GNUNET_TIME_absolute_max(q_timeout, dvh_timeout), - &check_link_down, - vl); + GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_max (q_timeout, dvh_timeout), + &check_link_down, + vl); } @@ -3490,7 +3540,7 @@ check_link_down(void *cls) * @param queue the queue to free */ static void -free_queue(struct Queue *queue) +free_queue (struct Queue *queue) { struct Neighbour *neighbour = queue->neighbour; struct TransportClient *tc = queue->tc; @@ -3502,65 +3552,65 @@ free_queue(struct Queue *queue) struct VirtualLink *vl; if (NULL != queue->transmit_task) - { - GNUNET_SCHEDULER_cancel(queue->transmit_task); - queue->transmit_task = NULL; - } + { + GNUNET_SCHEDULER_cancel (queue->transmit_task); + queue->transmit_task = NULL; + } while (NULL != (pa = queue->pa_head)) - { - GNUNET_CONTAINER_MDLL_remove(queue, queue->pa_head, queue->pa_tail, pa); - pa->queue = NULL; - } + { + GNUNET_CONTAINER_MDLL_remove (queue, queue->pa_head, queue->pa_tail, pa); + pa->queue = NULL; + } - GNUNET_CONTAINER_MDLL_remove(neighbour, - neighbour->queue_head, - neighbour->queue_tail, - queue); - GNUNET_CONTAINER_MDLL_remove(client, - tc->details.communicator.queue_head, - tc->details.communicator.queue_tail, - queue); + GNUNET_CONTAINER_MDLL_remove (neighbour, + neighbour->queue_head, + neighbour->queue_tail, + queue); + GNUNET_CONTAINER_MDLL_remove (client, + tc->details.communicator.queue_head, + tc->details.communicator.queue_tail, + queue); maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT >= tc->details.communicator.total_queue_length); while (NULL != (qe = queue->queue_head)) + { + GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe); + queue->queue_length--; + tc->details.communicator.total_queue_length--; + if (NULL != qe->pm) { - GNUNET_CONTAINER_DLL_remove(queue->queue_head, queue->queue_tail, qe); - queue->queue_length--; - tc->details.communicator.total_queue_length--; - if (NULL != qe->pm) - { - GNUNET_assert(qe == qe->pm->qe); - qe->pm->qe = NULL; - } - GNUNET_free(qe); + GNUNET_assert (qe == qe->pm->qe); + qe->pm->qe = NULL; } - GNUNET_assert(0 == queue->queue_length); + GNUNET_free (qe); + } + GNUNET_assert (0 == queue->queue_length); if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT < tc->details.communicator.total_queue_length)) - { - /* Communicator dropped below threshold, resume all _other_ queues */ - GNUNET_STATISTICS_update( - GST_stats, - "# Transmission throttled due to communicator queue limit", - -1, - GNUNET_NO); - for (struct Queue *s = tc->details.communicator.queue_head; NULL != s; - s = s->next_client) - schedule_transmit_on_queue(s, GNUNET_SCHEDULER_PRIORITY_DEFAULT); - } - notify_monitors(&neighbour->pid, queue->address, queue->nt, &me); - GNUNET_free(queue); + { + /* Communicator dropped below threshold, resume all _other_ queues */ + GNUNET_STATISTICS_update ( + GST_stats, + "# Transmission throttled due to communicator queue limit", + -1, + GNUNET_NO); + for (struct Queue *s = tc->details.communicator.queue_head; NULL != s; + s = s->next_client) + schedule_transmit_on_queue (s, GNUNET_SCHEDULER_PRIORITY_DEFAULT); + } + notify_monitors (&neighbour->pid, queue->address, queue->nt, &me); + GNUNET_free (queue); - vl = lookup_virtual_link(&neighbour->pid); + vl = lookup_virtual_link (&neighbour->pid); if ((NULL != vl) && (neighbour == vl->n)) - { - GNUNET_SCHEDULER_cancel(vl->visibility_task); - check_link_down(vl); - } + { + GNUNET_SCHEDULER_cancel (vl->visibility_task); + check_link_down (vl); + } if (NULL == neighbour->queue_head) - { - free_neighbour(neighbour); - } + { + free_neighbour (neighbour); + } } @@ -3570,24 +3620,24 @@ free_queue(struct Queue *queue) * @param ale address list entry to free */ static void -free_address_list_entry(struct AddressListEntry *ale) +free_address_list_entry (struct AddressListEntry *ale) { struct TransportClient *tc = ale->tc; - GNUNET_CONTAINER_DLL_remove(tc->details.communicator.addr_head, - tc->details.communicator.addr_tail, - ale); + GNUNET_CONTAINER_DLL_remove (tc->details.communicator.addr_head, + tc->details.communicator.addr_tail, + ale); if (NULL != ale->sc) - { - GNUNET_PEERSTORE_store_cancel(ale->sc); - ale->sc = NULL; - } + { + GNUNET_PEERSTORE_store_cancel (ale->sc); + ale->sc = NULL; + } if (NULL != ale->st) - { - GNUNET_SCHEDULER_cancel(ale->st); - ale->st = NULL; - } - GNUNET_free(ale); + { + GNUNET_SCHEDULER_cancel (ale->st); + ale->st = NULL; + } + GNUNET_free (ale); } @@ -3600,20 +3650,20 @@ free_address_list_entry(struct AddressListEntry *ale) * @return #GNUNET_YES (always) */ static int -stop_peer_request(void *cls, - const struct GNUNET_PeerIdentity *pid, - void *value) +stop_peer_request (void *cls, + const struct GNUNET_PeerIdentity *pid, + void *value) { struct TransportClient *tc = cls; struct PeerRequest *pr = value; - GNUNET_PEERSTORE_watch_cancel(pr->wc); - GNUNET_assert( + GNUNET_PEERSTORE_watch_cancel (pr->wc); + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(tc->details.application.requests, - pid, - pr)); - GNUNET_free(pr); + GNUNET_CONTAINER_multipeermap_remove (tc->details.application.requests, + pid, + pr)); + GNUNET_free (pr); return GNUNET_OK; } @@ -3628,60 +3678,60 @@ stop_peer_request(void *cls, * @param app_ctx our `struct TransportClient` */ static void -client_disconnect_cb(void *cls, - struct GNUNET_SERVICE_Client *client, - void *app_ctx) +client_disconnect_cb (void *cls, + struct GNUNET_SERVICE_Client *client, + void *app_ctx) { struct TransportClient *tc = app_ctx; - (void)cls; - (void)client; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Client %p disconnected, cleaning up.\n", - tc); - GNUNET_CONTAINER_DLL_remove(clients_head, clients_tail, tc); + (void) cls; + (void) client; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Client %p disconnected, cleaning up.\n", + tc); + GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc); switch (tc->type) - { - case CT_NONE: - break; + { + case CT_NONE: + break; - case CT_CORE: { + case CT_CORE: { struct PendingMessage *pm; while (NULL != (pm = tc->details.core.pending_msg_head)) - { - GNUNET_CONTAINER_MDLL_remove(client, - tc->details.core.pending_msg_head, - tc->details.core.pending_msg_tail, - pm); - pm->client = NULL; - } + { + GNUNET_CONTAINER_MDLL_remove (client, + tc->details.core.pending_msg_head, + tc->details.core.pending_msg_tail, + pm); + pm->client = NULL; + } } break; - case CT_MONITOR: - break; + case CT_MONITOR: + break; - case CT_COMMUNICATOR: { + case CT_COMMUNICATOR: { struct Queue *q; struct AddressListEntry *ale; while (NULL != (q = tc->details.communicator.queue_head)) - free_queue(q); + free_queue (q); while (NULL != (ale = tc->details.communicator.addr_head)) - free_address_list_entry(ale); - GNUNET_free(tc->details.communicator.address_prefix); + free_address_list_entry (ale); + GNUNET_free (tc->details.communicator.address_prefix); } break; - case CT_APPLICATION: - GNUNET_CONTAINER_multipeermap_iterate(tc->details.application.requests, - &stop_peer_request, - tc); - GNUNET_CONTAINER_multipeermap_destroy(tc->details.application.requests); - break; - } - GNUNET_free(tc); + case CT_APPLICATION: + GNUNET_CONTAINER_multipeermap_iterate (tc->details.application.requests, + &stop_peer_request, + tc); + GNUNET_CONTAINER_multipeermap_destroy (tc->details.application.requests); + break; + } + GNUNET_free (tc); } @@ -3695,17 +3745,17 @@ client_disconnect_cb(void *cls, * @return #GNUNET_OK (continue to iterate) */ static int -notify_client_connect_info(void *cls, - const struct GNUNET_PeerIdentity *pid, - void *value) +notify_client_connect_info (void *cls, + const struct GNUNET_PeerIdentity *pid, + void *value) { struct TransportClient *tc = cls; - (void)value; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Telling new CORE client about existing connection to %s\n", - GNUNET_i2s(pid)); - core_send_connect_info(tc, pid); + (void) value; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Telling new CORE client about existing connection to %s\n", + GNUNET_i2s (pid)); + core_send_connect_info (tc, pid); return GNUNET_OK; } @@ -3719,34 +3769,34 @@ notify_client_connect_info(void *cls, * @param start the start message that was sent */ static void -handle_client_start(void *cls, const struct StartMessage *start) +handle_client_start (void *cls, const struct StartMessage *start) { struct TransportClient *tc = cls; uint32_t options; - options = ntohl(start->options); + options = ntohl (start->options); if ((0 != (1 & options)) && - (0 != GNUNET_memcmp(&start->self, &GST_my_identity))) - { - /* client thinks this is a different peer, reject */ - GNUNET_break(0); - GNUNET_SERVICE_client_drop(tc->client); - return; - } + (0 != GNUNET_memcmp (&start->self, &GST_my_identity))) + { + /* client thinks this is a different peer, reject */ + GNUNET_break (0); + GNUNET_SERVICE_client_drop (tc->client); + return; + } if (CT_NONE != tc->type) - { - GNUNET_break(0); - GNUNET_SERVICE_client_drop(tc->client); - return; - } + { + GNUNET_break (0); + GNUNET_SERVICE_client_drop (tc->client); + return; + } tc->type = CT_CORE; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "New CORE client with PID %s registered\n", - GNUNET_i2s(&start->self)); - GNUNET_CONTAINER_multipeermap_iterate(neighbours, - ¬ify_client_connect_info, - tc); - GNUNET_SERVICE_client_continue(tc->client); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "New CORE client with PID %s registered\n", + GNUNET_i2s (&start->self)); + GNUNET_CONTAINER_multipeermap_iterate (neighbours, + ¬ify_client_connect_info, + tc); + GNUNET_SERVICE_client_continue (tc->client); } @@ -3757,29 +3807,29 @@ handle_client_start(void *cls, const struct StartMessage *start) * @param obm the send message that was sent */ static int -check_client_send(void *cls, const struct OutboundMessage *obm) +check_client_send (void *cls, const struct OutboundMessage *obm) { struct TransportClient *tc = cls; uint16_t size; const struct GNUNET_MessageHeader *obmm; if (CT_CORE != tc->type) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } - size = ntohs(obm->header.size) - sizeof(struct OutboundMessage); + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + size = ntohs (obm->header.size) - sizeof(struct OutboundMessage); if (size < sizeof(struct GNUNET_MessageHeader)) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } - obmm = (const struct GNUNET_MessageHeader *)&obm[1]; - if (size != ntohs(obmm->size)) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + obmm = (const struct GNUNET_MessageHeader *) &obm[1]; + if (size != ntohs (obmm->size)) + { + GNUNET_break (0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -3792,25 +3842,25 @@ check_client_send(void *cls, const struct OutboundMessage *obm) * @param pm handle to the original pending message */ static void -client_send_response(struct PendingMessage *pm) +client_send_response (struct PendingMessage *pm) { struct TransportClient *tc = pm->client; struct VirtualLink *vl = pm->vl; if (NULL != tc) - { - struct GNUNET_MQ_Envelope *env; - struct SendOkMessage *som; - - env = GNUNET_MQ_msg(som, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK); - som->peer = vl->target; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Confirming transmission of <%llu> to %s\n", - pm->logging_uuid, - GNUNET_i2s(&vl->target)); - GNUNET_MQ_send(tc->mq, env); - } - free_pending_message(pm); + { + struct GNUNET_MQ_Envelope *env; + struct SendOkMessage *som; + + env = GNUNET_MQ_msg (som, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK); + som->peer = vl->target; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Confirming transmission of <%llu> to %s\n", + pm->logging_uuid, + GNUNET_i2s (&vl->target)); + GNUNET_MQ_send (tc->mq, env); + } + free_pending_message (pm); } @@ -3824,10 +3874,10 @@ client_send_response(struct PendingMessage *pm) * @return number of entries set in @a hops_array */ static unsigned int -pick_random_dv_hops(const struct DistanceVector *dv, - enum RouteMessageOptions options, - struct DistanceVectorHop **hops_array, - unsigned int hops_array_length) +pick_random_dv_hops (const struct DistanceVector *dv, + enum RouteMessageOptions options, + struct DistanceVectorHop **hops_array, + unsigned int hops_array_length) { uint64_t choices[hops_array_length]; uint64_t num_dv; @@ -3839,56 +3889,56 @@ pick_random_dv_hops(const struct DistanceVector *dv, dv_count = 0; for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; pos = pos->next_dv) - { - if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) && - (GNUNET_TIME_absolute_get_remaining(pos->path_valid_until) - .rel_value_us == 0)) - continue; /* pos unconfirmed and confirmed required */ - num_dv += MAX_DV_HOPS_ALLOWED - pos->distance; - dv_count++; - } + { + if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) && + (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until) + .rel_value_us == 0)) + continue; /* pos unconfirmed and confirmed required */ + num_dv += MAX_DV_HOPS_ALLOWED - pos->distance; + dv_count++; + } if (0 == dv_count) return 0; if (dv_count <= hops_array_length) - { - dv_count = 0; - for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; - pos = pos->next_dv) - hops_array[dv_count++] = pos; - return dv_count; - } + { + dv_count = 0; + for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; + pos = pos->next_dv) + hops_array[dv_count++] = pos; + return dv_count; + } for (unsigned int i = 0; i < hops_array_length; i++) - { - int ok = GNUNET_NO; - while (GNUNET_NO == ok) + { + int ok = GNUNET_NO; + while (GNUNET_NO == ok) + { + choices[i] = + GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, num_dv); + ok = GNUNET_YES; + for (unsigned int j = 0; j < i; j++) + if (choices[i] == choices[j]) { - choices[i] = - GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, num_dv); - ok = GNUNET_YES; - for (unsigned int j = 0; j < i; j++) - if (choices[i] == choices[j]) - { - ok = GNUNET_NO; - break; - } + ok = GNUNET_NO; + break; } } + } dv_count = 0; num_dv = 0; for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; pos = pos->next_dv) - { - uint32_t delta = MAX_DV_HOPS_ALLOWED - pos->distance; - - if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) && - (GNUNET_TIME_absolute_get_remaining(pos->path_valid_until) - .rel_value_us == 0)) - continue; /* pos unconfirmed and confirmed required */ - for (unsigned int i = 0; i < hops_array_length; i++) - if ((num_dv <= choices[i]) && (num_dv + delta > choices[i])) - hops_array[dv_count++] = pos; - num_dv += delta; - } + { + uint32_t delta = MAX_DV_HOPS_ALLOWED - pos->distance; + + if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) && + (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until) + .rel_value_us == 0)) + continue; /* pos unconfirmed and confirmed required */ + for (unsigned int i = 0; i < hops_array_length; i++) + if ((num_dv <= choices[i]) && (num_dv + delta > choices[i])) + hops_array[dv_count++] = pos; + num_dv += delta; + } return dv_count; } @@ -3900,7 +3950,7 @@ pick_random_dv_hops(const struct DistanceVector *dv, * @param cam the send message that was sent */ static int -check_communicator_available( +check_communicator_available ( void *cls, const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam) { @@ -3908,15 +3958,15 @@ check_communicator_available( uint16_t size; if (CT_NONE != tc->type) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + { + GNUNET_break (0); + return GNUNET_SYSERR; + } tc->type = CT_COMMUNICATOR; - size = ntohs(cam->header.size) - sizeof(*cam); + size = ntohs (cam->header.size) - sizeof(*cam); if (0 == size) return GNUNET_OK; /* receive-only communicator */ - GNUNET_MQ_check_zero_termination(cam); + GNUNET_MQ_check_zero_termination (cam); return GNUNET_OK; } @@ -3927,22 +3977,22 @@ check_communicator_available( * @param cmc context for which we are done handling the message */ static void -finish_cmc_handling(struct CommunicatorMessageContext *cmc) +finish_cmc_handling (struct CommunicatorMessageContext *cmc) { - if (0 != ntohl(cmc->im.fc_on)) - { - /* send ACK when done to communicator for flow control! */ - struct GNUNET_MQ_Envelope *env; - struct GNUNET_TRANSPORT_IncomingMessageAck *ack; - - env = GNUNET_MQ_msg(ack, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK); - ack->reserved = htonl(0); - ack->fc_id = cmc->im.fc_id; - ack->sender = cmc->im.sender; - GNUNET_MQ_send(cmc->tc->mq, env); - } - GNUNET_SERVICE_client_continue(cmc->tc->client); - GNUNET_free(cmc); + if (0 != ntohl (cmc->im.fc_on)) + { + /* send ACK when done to communicator for flow control! */ + struct GNUNET_MQ_Envelope *env; + struct GNUNET_TRANSPORT_IncomingMessageAck *ack; + + env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK); + ack->reserved = htonl (0); + ack->fc_id = cmc->im.fc_id; + ack->sender = cmc->im.sender; + GNUNET_MQ_send (cmc->tc->mq, env); + } + GNUNET_SERVICE_client_continue (cmc->tc->client); + GNUNET_free (cmc); } @@ -3956,7 +4006,7 @@ finish_cmc_handling(struct CommunicatorMessageContext *cmc) * @param rom the message that was sent */ static void -handle_client_recv_ok(void *cls, const struct RecvOkMessage *rom) +handle_client_recv_ok (void *cls, const struct RecvOkMessage *rom) { struct TransportClient *tc = cls; struct VirtualLink *vl; @@ -3964,31 +4014,31 @@ handle_client_recv_ok(void *cls, const struct RecvOkMessage *rom) struct CommunicatorMessageContext *cmc; if (CT_CORE != tc->type) - { - GNUNET_break(0); - GNUNET_SERVICE_client_drop(tc->client); - return; - } - vl = lookup_virtual_link(&rom->peer); + { + GNUNET_break (0); + GNUNET_SERVICE_client_drop (tc->client); + return; + } + vl = lookup_virtual_link (&rom->peer); if (NULL == vl) - { - GNUNET_STATISTICS_update(GST_stats, - "# RECV_OK dropped: virtual link unknown", - 1, - GNUNET_NO); - GNUNET_SERVICE_client_continue(tc->client); - return; - } - delta = ntohl(rom->increase_window_delta); + { + GNUNET_STATISTICS_update (GST_stats, + "# RECV_OK dropped: virtual link unknown", + 1, + GNUNET_NO); + GNUNET_SERVICE_client_continue (tc->client); + return; + } + delta = ntohl (rom->increase_window_delta); vl->core_recv_window += delta; if (vl->core_recv_window <= 0) return; /* resume communicators */ while (NULL != (cmc = vl->cmc_tail)) - { - GNUNET_CONTAINER_DLL_remove(vl->cmc_head, vl->cmc_tail, cmc); - finish_cmc_handling(cmc); - } + { + GNUNET_CONTAINER_DLL_remove (vl->cmc_head, vl->cmc_tail, cmc); + finish_cmc_handling (cmc); + } } @@ -3999,28 +4049,28 @@ handle_client_recv_ok(void *cls, const struct RecvOkMessage *rom) * @param cam the send message that was sent */ static void -handle_communicator_available( +handle_communicator_available ( void *cls, const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam) { struct TransportClient *tc = cls; uint16_t size; - size = ntohs(cam->header.size) - sizeof(*cam); + size = ntohs (cam->header.size) - sizeof(*cam); if (0 == size) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Receive-only communicator connected\n"); - return; /* receive-only communicator */ - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Receive-only communicator connected\n"); + return; /* receive-only communicator */ + } tc->details.communicator.address_prefix = - GNUNET_strdup((const char *)&cam[1]); + GNUNET_strdup ((const char *) &cam[1]); tc->details.communicator.cc = - (enum GNUNET_TRANSPORT_CommunicatorCharacteristics)ntohl(cam->cc); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Communicator with prefix `%s' connected\n", - tc->details.communicator.address_prefix); - GNUNET_SERVICE_client_continue(tc->client); + (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (cam->cc); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Communicator with prefix `%s' connected\n", + tc->details.communicator.address_prefix); + GNUNET_SERVICE_client_continue (tc->client); } @@ -4032,7 +4082,7 @@ handle_communicator_available( * @return #GNUNET_OK if message is well-formed */ static int -check_communicator_backchannel( +check_communicator_backchannel ( void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb) { @@ -4041,24 +4091,24 @@ check_communicator_backchannel( uint16_t msize; uint16_t isize; - (void)cls; - msize = ntohs(cb->header.size) - sizeof(*cb); - inbox = (const struct GNUNET_MessageHeader *)&cb[1]; - isize = ntohs(inbox->size); + (void) cls; + msize = ntohs (cb->header.size) - sizeof(*cb); + inbox = (const struct GNUNET_MessageHeader *) &cb[1]; + isize = ntohs (inbox->size); if (isize >= msize) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } - is = (const char *)inbox; + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + is = (const char *) inbox; is += isize; msize -= isize; - GNUNET_assert(0 < msize); + GNUNET_assert (0 < msize); if ('\0' != is[msize - 1]) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + { + GNUNET_break (0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -4070,26 +4120,26 @@ check_communicator_backchannel( * @param dv[in,out] virtual link to update ephemeral for */ static void -update_ephemeral(struct DistanceVector *dv) +update_ephemeral (struct DistanceVector *dv) { struct EphemeralConfirmationPS ec; if (0 != - GNUNET_TIME_absolute_get_remaining(dv->ephemeral_validity).rel_value_us) + GNUNET_TIME_absolute_get_remaining (dv->ephemeral_validity).rel_value_us) return; - dv->monotime = GNUNET_TIME_absolute_get_monotonic(GST_cfg); + dv->monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg); dv->ephemeral_validity = - GNUNET_TIME_absolute_add(dv->monotime, EPHEMERAL_VALIDITY); - GNUNET_assert(GNUNET_OK == - GNUNET_CRYPTO_ecdhe_key_create2(&dv->private_key)); - GNUNET_CRYPTO_ecdhe_key_get_public(&dv->private_key, &dv->ephemeral_key); - ec.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL); - ec.purpose.size = htonl(sizeof(ec)); + GNUNET_TIME_absolute_add (dv->monotime, EPHEMERAL_VALIDITY); + GNUNET_assert (GNUNET_OK == + GNUNET_CRYPTO_ecdhe_key_create2 (&dv->private_key)); + GNUNET_CRYPTO_ecdhe_key_get_public (&dv->private_key, &dv->ephemeral_key); + ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL); + ec.purpose.size = htonl (sizeof(ec)); ec.target = dv->target; ec.ephemeral_key = dv->ephemeral_key; - GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(GST_my_private_key, - &ec.purpose, - &dv->sender_sig)); + GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (GST_my_private_key, + &ec.purpose, + &dv->sender_sig)); } @@ -4103,45 +4153,45 @@ update_ephemeral(struct DistanceVector *dv) * @param payload_size number of bytes in @a payload */ static void -queue_send_msg(struct Queue *queue, - struct PendingMessage *pm, - const void *payload, - size_t payload_size) +queue_send_msg (struct Queue *queue, + struct PendingMessage *pm, + const void *payload, + size_t payload_size) { struct Neighbour *n = queue->neighbour; struct GNUNET_TRANSPORT_SendMessageTo *smt; struct GNUNET_MQ_Envelope *env; queue->idle = GNUNET_NO; - GNUNET_log( + GNUNET_log ( GNUNET_ERROR_TYPE_DEBUG, "Queueing %u bytes of payload for transmission <%llu> on queue %llu to %s\n", - (unsigned int)payload_size, + (unsigned int) payload_size, (NULL == pm) ? 0 : pm->logging_uuid, - (unsigned long long)queue->qid, - GNUNET_i2s(&queue->neighbour->pid)); - env = GNUNET_MQ_msg_extra(smt, - payload_size, - GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG); + (unsigned long long) queue->qid, + GNUNET_i2s (&queue->neighbour->pid)); + env = GNUNET_MQ_msg_extra (smt, + payload_size, + GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG); smt->qid = queue->qid; smt->mid = queue->mid_gen; smt->receiver = n->pid; - memcpy(&smt[1], payload, payload_size); + memcpy (&smt[1], payload, payload_size); { /* Pass the env to the communicator of queue for transmission. */ struct QueueEntry *qe; - qe = GNUNET_new(struct QueueEntry); + qe = GNUNET_new (struct QueueEntry); qe->mid = queue->mid_gen++; qe->queue = queue; if (NULL != pm) - { - qe->pm = pm; - GNUNET_assert(NULL == pm->qe); - pm->qe = qe; - } - GNUNET_CONTAINER_DLL_insert(queue->queue_head, queue->queue_tail, qe); - GNUNET_assert(CT_COMMUNICATOR == queue->tc->type); + { + qe->pm = pm; + GNUNET_assert (NULL == pm->qe); + pm->qe = qe; + } + GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe); + GNUNET_assert (CT_COMMUNICATOR == queue->tc->type); queue->queue_length++; queue->tc->details.communicator.total_queue_length++; if (COMMUNICATOR_TOTAL_QUEUE_LIMIT == @@ -4149,7 +4199,7 @@ queue_send_msg(struct Queue *queue, queue->idle = GNUNET_NO; if (QUEUE_LENGTH_LIMIT == queue->queue_length) queue->idle = GNUNET_NO; - GNUNET_MQ_send(queue->tc->mq, env); + GNUNET_MQ_send (queue->tc->mq, env); } } @@ -4165,9 +4215,9 @@ queue_send_msg(struct Queue *queue, * @return expected RTT for transmission, #GNUNET_TIME_UNIT_FOREVER_REL if sending failed */ static struct GNUNET_TIME_Relative -route_via_neighbour(const struct Neighbour *n, - const struct GNUNET_MessageHeader *hdr, - enum RouteMessageOptions options) +route_via_neighbour (const struct Neighbour *n, + const struct GNUNET_MessageHeader *hdr, + enum RouteMessageOptions options) { struct GNUNET_TIME_Absolute now; unsigned int candidates; @@ -4176,7 +4226,7 @@ route_via_neighbour(const struct Neighbour *n, struct GNUNET_TIME_Relative rtt; /* Pick one or two 'random' queues from n (under constraints of options) */ - now = GNUNET_TIME_absolute_get(); + now = GNUNET_TIME_absolute_get (); /* FIXME-OPTIMIZE: give queues 'weights' and pick proportional to weight in the future; weight could be assigned by observed bandwidth (note: not sure if we should do this for this type @@ -4184,53 +4234,53 @@ route_via_neighbour(const struct Neighbour *n, candidates = 0; for (struct Queue *pos = n->queue_head; NULL != pos; pos = pos->next_neighbour) - { - if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) || - (pos->validated_until.abs_value_us > now.abs_value_us)) - candidates++; - } + { + if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) || + (pos->validated_until.abs_value_us > now.abs_value_us)) + candidates++; + } if (0 == candidates) - { - /* This can happen rarely if the last confirmed queue timed - out just as we were beginning to process this message. */ - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Could not route message of type %u to %s: no valid queue\n", - ntohs(hdr->type), - GNUNET_i2s(&n->pid)); - GNUNET_STATISTICS_update(GST_stats, - "# route selection failed (all no valid queue)", - 1, - GNUNET_NO); - return GNUNET_TIME_UNIT_FOREVER_REL; - } + { + /* This can happen rarely if the last confirmed queue timed + out just as we were beginning to process this message. */ + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Could not route message of type %u to %s: no valid queue\n", + ntohs (hdr->type), + GNUNET_i2s (&n->pid)); + GNUNET_STATISTICS_update (GST_stats, + "# route selection failed (all no valid queue)", + 1, + GNUNET_NO); + return GNUNET_TIME_UNIT_FOREVER_REL; + } rtt = GNUNET_TIME_UNIT_FOREVER_REL; - sel1 = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, candidates); + sel1 = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, candidates); if (0 == (options & RMO_REDUNDANT)) sel2 = candidates; /* picks none! */ else - sel2 = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, candidates); + sel2 = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, candidates); candidates = 0; for (struct Queue *pos = n->queue_head; NULL != pos; pos = pos->next_neighbour) + { + if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) || + (pos->validated_until.abs_value_us > now.abs_value_us)) { - if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) || - (pos->validated_until.abs_value_us > now.abs_value_us)) - { - if ((sel1 == candidates) || (sel2 == candidates)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Routing message of type %u to %s using %s (#%u)\n", - ntohs(hdr->type), - GNUNET_i2s(&n->pid), - pos->address, - (sel1 == candidates) ? 1 : 2); - rtt = GNUNET_TIME_relative_min(rtt, pos->pd.aged_rtt); - queue_send_msg(pos, NULL, hdr, ntohs(hdr->size)); - } - candidates++; - } + if ((sel1 == candidates) || (sel2 == candidates)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Routing message of type %u to %s using %s (#%u)\n", + ntohs (hdr->type), + GNUNET_i2s (&n->pid), + pos->address, + (sel1 == candidates) ? 1 : 2); + rtt = GNUNET_TIME_relative_min (rtt, pos->pd.aged_rtt); + queue_send_msg (pos, NULL, hdr, ntohs (hdr->size)); + } + candidates++; } + } return rtt; } @@ -4238,7 +4288,8 @@ route_via_neighbour(const struct Neighbour *n, /** * Structure of the key material used to encrypt backchannel messages. */ -struct DVKeyState { +struct DVKeyState +{ /** * State of our block cipher. */ @@ -4247,7 +4298,8 @@ struct DVKeyState { /** * Actual key material. */ - struct { + struct + { /** * Key used for HMAC calculations (via #GNUNET_CRYPTO_hmac()). */ @@ -4275,34 +4327,34 @@ struct DVKeyState { * @param key[out] symmetric cipher and HMAC state to generate */ static void -dv_setup_key_state_from_km(const struct GNUNET_HashCode *km, - const struct GNUNET_ShortHashCode *iv, - struct DVKeyState *key) +dv_setup_key_state_from_km (const struct GNUNET_HashCode *km, + const struct GNUNET_ShortHashCode *iv, + struct DVKeyState *key) { /* must match #dh_key_derive_eph_pub */ - GNUNET_assert(GNUNET_YES == - GNUNET_CRYPTO_kdf(&key->material, - sizeof(key->material), - "transport-backchannel-key", - strlen("transport-backchannel-key"), - &km, - sizeof(km), - iv, - sizeof(*iv))); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Deriving backchannel key based on KM %s and IV %s\n", - GNUNET_h2s(km), - GNUNET_sh2s(iv)); - gcry_cipher_open(&key->cipher, - GCRY_CIPHER_AES256 /* low level: go for speed */, - GCRY_CIPHER_MODE_CTR, - 0 /* flags */); - gcry_cipher_setkey(key->cipher, - &key->material.aes_key, - sizeof(key->material.aes_key)); - gcry_cipher_setctr(key->cipher, - &key->material.aes_ctr, - sizeof(key->material.aes_ctr)); + GNUNET_assert (GNUNET_YES == + GNUNET_CRYPTO_kdf (&key->material, + sizeof(key->material), + "transport-backchannel-key", + strlen ("transport-backchannel-key"), + &km, + sizeof(km), + iv, + sizeof(*iv))); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Deriving backchannel key based on KM %s and IV %s\n", + GNUNET_h2s (km), + GNUNET_sh2s (iv)); + gcry_cipher_open (&key->cipher, + GCRY_CIPHER_AES256 /* low level: go for speed */, + GCRY_CIPHER_MODE_CTR, + 0 /* flags */); + gcry_cipher_setkey (key->cipher, + &key->material.aes_key, + sizeof(key->material.aes_key)); + gcry_cipher_setctr (key->cipher, + &key->material.aes_ctr, + sizeof(key->material.aes_ctr)); } @@ -4316,7 +4368,7 @@ dv_setup_key_state_from_km(const struct GNUNET_HashCode *km, * @param key[out] set to the key material */ static void -dh_key_derive_eph_pid( +dh_key_derive_eph_pid ( const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ephemeral, const struct GNUNET_PeerIdentity *target, const struct GNUNET_ShortHashCode *iv, @@ -4324,10 +4376,10 @@ dh_key_derive_eph_pid( { struct GNUNET_HashCode km; - GNUNET_assert(GNUNET_YES == GNUNET_CRYPTO_ecdh_eddsa(priv_ephemeral, - &target->public_key, - &km)); - dv_setup_key_state_from_km(&km, iv, key); + GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_ecdh_eddsa (priv_ephemeral, + &target->public_key, + &km)); + dv_setup_key_state_from_km (&km, iv, key); } @@ -4341,16 +4393,16 @@ dh_key_derive_eph_pid( * @param key[out] set to the key material */ static void -dh_key_derive_eph_pub(const struct GNUNET_CRYPTO_EcdhePublicKey *pub_ephemeral, - const struct GNUNET_ShortHashCode *iv, - struct DVKeyState *key) +dh_key_derive_eph_pub (const struct GNUNET_CRYPTO_EcdhePublicKey *pub_ephemeral, + const struct GNUNET_ShortHashCode *iv, + struct DVKeyState *key) { struct GNUNET_HashCode km; - GNUNET_assert(GNUNET_YES == GNUNET_CRYPTO_eddsa_ecdh(GST_my_private_key, - pub_ephemeral, - &km)); - dv_setup_key_state_from_km(&km, iv, key); + GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_eddsa_ecdh (GST_my_private_key, + pub_ephemeral, + &km)); + dv_setup_key_state_from_km (&km, iv, key); } @@ -4364,12 +4416,12 @@ dh_key_derive_eph_pub(const struct GNUNET_CRYPTO_EcdhePublicKey *pub_ephemeral, * @param data_size number of bytes in @a data */ static void -dv_hmac(const struct DVKeyState *key, - struct GNUNET_HashCode *hmac, - const void *data, - size_t data_size) +dv_hmac (const struct DVKeyState *key, + struct GNUNET_HashCode *hmac, + const void *data, + size_t data_size) { - GNUNET_CRYPTO_hmac(&key->material.hmac_key, data, data_size, hmac); + GNUNET_CRYPTO_hmac (&key->material.hmac_key, data, data_size, hmac); } @@ -4383,10 +4435,10 @@ dv_hmac(const struct DVKeyState *key, * @param in_size number of bytes of input in @a in and available at @a dst */ static void -dv_encrypt(struct DVKeyState *key, const void *in, void *dst, size_t in_size) +dv_encrypt (struct DVKeyState *key, const void *in, void *dst, size_t in_size) { - GNUNET_assert(0 == - gcry_cipher_encrypt(key->cipher, dst, in_size, in, in_size)); + GNUNET_assert (0 == + gcry_cipher_encrypt (key->cipher, dst, in_size, in, in_size)); } @@ -4400,13 +4452,13 @@ dv_encrypt(struct DVKeyState *key, const void *in, void *dst, size_t in_size) * @param out_size number of bytes of input in @a ciph and available in @a out */ static void -dv_decrypt(struct DVKeyState *key, - void *out, - const void *ciph, - size_t out_size) +dv_decrypt (struct DVKeyState *key, + void *out, + const void *ciph, + size_t out_size) { - GNUNET_assert( - 0 == gcry_cipher_decrypt(key->cipher, out, out_size, ciph, out_size)); + GNUNET_assert ( + 0 == gcry_cipher_decrypt (key->cipher, out, out_size, ciph, out_size)); } @@ -4416,10 +4468,10 @@ dv_decrypt(struct DVKeyState *key, * @param key key material to clean up (memory must not be free'd!) */ static void -dv_key_clean(struct DVKeyState *key) +dv_key_clean (struct DVKeyState *key) { - gcry_cipher_close(key->cipher); - GNUNET_CRYPTO_zero_keys(&key->material, sizeof(key->material)); + gcry_cipher_close (key->cipher); + GNUNET_CRYPTO_zero_keys (&key->material, sizeof(key->material)); } @@ -4452,92 +4504,92 @@ typedef void (*DVMessageHandler) (void *cls, * @return expected RTT for transmission, #GNUNET_TIME_UNIT_FOREVER_REL if sending failed */ static struct GNUNET_TIME_Relative -encapsulate_for_dv(struct DistanceVector *dv, - unsigned int num_dvhs, - struct DistanceVectorHop **dvhs, - const struct GNUNET_MessageHeader *hdr, - DVMessageHandler use, - void *use_cls, - enum RouteMessageOptions options) +encapsulate_for_dv (struct DistanceVector *dv, + unsigned int num_dvhs, + struct DistanceVectorHop **dvhs, + const struct GNUNET_MessageHeader *hdr, + DVMessageHandler use, + void *use_cls, + enum RouteMessageOptions options) { struct TransportDVBoxMessage box_hdr; struct TransportDVBoxPayloadP payload_hdr; - uint16_t enc_body_size = ntohs(hdr->size); + uint16_t enc_body_size = ntohs (hdr->size); char enc[sizeof(struct TransportDVBoxPayloadP) + enc_body_size] GNUNET_ALIGN; struct TransportDVBoxPayloadP *enc_payload_hdr = - (struct TransportDVBoxPayloadP *)enc; + (struct TransportDVBoxPayloadP *) enc; struct DVKeyState key; struct GNUNET_TIME_Relative rtt; /* Encrypt payload */ - box_hdr.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX); - box_hdr.total_hops = htons(0); - update_ephemeral(dv); + box_hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX); + box_hdr.total_hops = htons (0); + update_ephemeral (dv); box_hdr.ephemeral_key = dv->ephemeral_key; payload_hdr.sender_sig = dv->sender_sig; - GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_NONCE, - &box_hdr.iv, - sizeof(box_hdr.iv)); - dh_key_derive_eph_pid(&dv->private_key, &dv->target, &box_hdr.iv, &key); + GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE, + &box_hdr.iv, + sizeof(box_hdr.iv)); + dh_key_derive_eph_pid (&dv->private_key, &dv->target, &box_hdr.iv, &key); payload_hdr.sender = GST_my_identity; - payload_hdr.monotonic_time = GNUNET_TIME_absolute_hton(dv->monotime); - dv_encrypt(&key, &payload_hdr, enc_payload_hdr, sizeof(payload_hdr)); - dv_encrypt(&key, - hdr, - &enc[sizeof(struct TransportDVBoxPayloadP)], - enc_body_size); - dv_hmac(&key, &box_hdr.hmac, enc, sizeof(enc)); - dv_key_clean(&key); + payload_hdr.monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime); + dv_encrypt (&key, &payload_hdr, enc_payload_hdr, sizeof(payload_hdr)); + dv_encrypt (&key, + hdr, + &enc[sizeof(struct TransportDVBoxPayloadP)], + enc_body_size); + dv_hmac (&key, &box_hdr.hmac, enc, sizeof(enc)); + dv_key_clean (&key); rtt = GNUNET_TIME_UNIT_FOREVER_REL; /* For each selected path, take the pre-computed header and body and add the path in the middle of the message; then send it. */ for (unsigned int i = 0; i < num_dvhs; i++) + { + struct DistanceVectorHop *dvh = dvhs[i]; + unsigned int num_hops = dvh->distance + 1; + char buf[sizeof(struct TransportDVBoxMessage) + + sizeof(struct GNUNET_PeerIdentity) * num_hops + + sizeof(struct TransportDVBoxPayloadP) + + enc_body_size] GNUNET_ALIGN; + struct GNUNET_PeerIdentity *dhops; + + box_hdr.header.size = htons (sizeof(buf)); + box_hdr.num_hops = htons (num_hops); + memcpy (buf, &box_hdr, sizeof(box_hdr)); + dhops = (struct GNUNET_PeerIdentity *) &buf[sizeof(box_hdr)]; + memcpy (dhops, + dvh->path, + dvh->distance * sizeof(struct GNUNET_PeerIdentity)); + dhops[dvh->distance] = dv->target; + if (GNUNET_EXTRA_LOGGING > 0) { - struct DistanceVectorHop *dvh = dvhs[i]; - unsigned int num_hops = dvh->distance + 1; - char buf[sizeof(struct TransportDVBoxMessage) + - sizeof(struct GNUNET_PeerIdentity) * num_hops + - sizeof(struct TransportDVBoxPayloadP) + - enc_body_size] GNUNET_ALIGN; - struct GNUNET_PeerIdentity *dhops; - - box_hdr.header.size = htons(sizeof(buf)); - box_hdr.num_hops = htons(num_hops); - memcpy(buf, &box_hdr, sizeof(box_hdr)); - dhops = (struct GNUNET_PeerIdentity *)&buf[sizeof(box_hdr)]; - memcpy(dhops, - dvh->path, - dvh->distance * sizeof(struct GNUNET_PeerIdentity)); - dhops[dvh->distance] = dv->target; - if (GNUNET_EXTRA_LOGGING > 0) - { - char *path; - - path = GNUNET_strdup(GNUNET_i2s(&GST_my_identity)); - for (unsigned int j = 0; j <= num_hops; j++) - { - char *tmp; - - GNUNET_asprintf(&tmp, "%s-%s", path, GNUNET_i2s(&dhops[j])); - GNUNET_free(path); - path = tmp; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Routing message of type %u to %s using DV (#%u/%u) via %s\n", - ntohs(hdr->type), - GNUNET_i2s(&dv->target), - i + 1, - num_dvhs + 1, - path); - GNUNET_free(path); - } - rtt = GNUNET_TIME_relative_min(rtt, dvh->pd.aged_rtt); - memcpy(&dhops[num_hops], enc, sizeof(enc)); - use(use_cls, - dvh->next_hop, - (const struct GNUNET_MessageHeader *)buf, - options); - } + char *path; + + path = GNUNET_strdup (GNUNET_i2s (&GST_my_identity)); + for (unsigned int j = 0; j <= num_hops; j++) + { + char *tmp; + + GNUNET_asprintf (&tmp, "%s-%s", path, GNUNET_i2s (&dhops[j])); + GNUNET_free (path); + path = tmp; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Routing message of type %u to %s using DV (#%u/%u) via %s\n", + ntohs (hdr->type), + GNUNET_i2s (&dv->target), + i + 1, + num_dvhs + 1, + path); + GNUNET_free (path); + } + rtt = GNUNET_TIME_relative_min (rtt, dvh->pd.aged_rtt); + memcpy (&dhops[num_hops], enc, sizeof(enc)); + use (use_cls, + dvh->next_hop, + (const struct GNUNET_MessageHeader *) buf, + options); + } return rtt; } @@ -4552,13 +4604,13 @@ encapsulate_for_dv(struct DistanceVector *dv, * @param options message options for queue selection */ static void -send_dv_to_neighbour(void *cls, - struct Neighbour *next_hop, - const struct GNUNET_MessageHeader *hdr, - enum RouteMessageOptions options) +send_dv_to_neighbour (void *cls, + struct Neighbour *next_hop, + const struct GNUNET_MessageHeader *hdr, + enum RouteMessageOptions options) { - (void)cls; - (void)route_via_neighbour(next_hop, hdr, options); + (void) cls; + (void) route_via_neighbour (next_hop, hdr, options); } @@ -4574,9 +4626,9 @@ send_dv_to_neighbour(void *cls, * @return expected RTT for transmission, #GNUNET_TIME_UNIT_FOREVER_REL if sending failed */ static struct GNUNET_TIME_Relative -route_control_message_without_fc(const struct GNUNET_PeerIdentity *target, - const struct GNUNET_MessageHeader *hdr, - enum RouteMessageOptions options) +route_control_message_without_fc (const struct GNUNET_PeerIdentity *target, + const struct GNUNET_MessageHeader *hdr, + enum RouteMessageOptions options) { struct VirtualLink *vl; struct Neighbour *n; @@ -4584,78 +4636,78 @@ route_control_message_without_fc(const struct GNUNET_PeerIdentity *target, struct GNUNET_TIME_Relative rtt1; struct GNUNET_TIME_Relative rtt2; - vl = lookup_virtual_link(target); - GNUNET_assert(NULL != vl); + vl = lookup_virtual_link (target); + GNUNET_assert (NULL != vl); n = vl->n; dv = (0 != (options & RMO_DV_ALLOWED)) ? vl->dv : NULL; if (0 == (options & RMO_UNCONFIRMED_ALLOWED)) - { - /* if confirmed is required, and we do not have anything - confirmed, drop respective options */ - if (NULL == n) - n = lookup_neighbour(target); - if ((NULL == dv) && (0 != (options & RMO_DV_ALLOWED))) - dv = GNUNET_CONTAINER_multipeermap_get(dv_routes, target); - } + { + /* if confirmed is required, and we do not have anything + confirmed, drop respective options */ + if (NULL == n) + n = lookup_neighbour (target); + if ((NULL == dv) && (0 != (options & RMO_DV_ALLOWED))) + dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, target); + } if ((NULL == n) && (NULL == dv)) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Cannot route message of type %u to %s: no route\n", - ntohs(hdr->type), - GNUNET_i2s(target)); - GNUNET_STATISTICS_update(GST_stats, - "# Messages dropped in routing: no acceptable method", - 1, - GNUNET_NO); - return GNUNET_TIME_UNIT_FOREVER_REL; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Routing message of type %u to %s with options %X\n", - ntohs(hdr->type), - GNUNET_i2s(target), - (unsigned int)options); + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Cannot route message of type %u to %s: no route\n", + ntohs (hdr->type), + GNUNET_i2s (target)); + GNUNET_STATISTICS_update (GST_stats, + "# Messages dropped in routing: no acceptable method", + 1, + GNUNET_NO); + return GNUNET_TIME_UNIT_FOREVER_REL; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Routing message of type %u to %s with options %X\n", + ntohs (hdr->type), + GNUNET_i2s (target), + (unsigned int) options); /* If both dv and n are possible and we must choose: flip a coin for the choice between the two; for now 50/50 */ if ((NULL != n) && (NULL != dv) && (0 == (options & RMO_REDUNDANT))) - { - if (0 == GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 2)) - n = NULL; - else - dv = NULL; - } + { + if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2)) + n = NULL; + else + dv = NULL; + } if ((NULL != n) && (NULL != dv)) options &= ~RMO_REDUNDANT; /* We will do one DV and one direct, that's enough for redunancy, so clear the flag. */ rtt1 = GNUNET_TIME_UNIT_FOREVER_REL; rtt2 = GNUNET_TIME_UNIT_FOREVER_REL; if (NULL != n) - { - rtt1 = route_via_neighbour(n, hdr, options); - } + { + rtt1 = route_via_neighbour (n, hdr, options); + } if (NULL != dv) - { - struct DistanceVectorHop *hops[2]; - unsigned int res; - - res = pick_random_dv_hops(dv, - options, - hops, - (0 == (options & RMO_REDUNDANT)) ? 1 : 2); - if (0 == res) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Failed to route message, could not determine DV path\n"); - return rtt1; - } - rtt2 = encapsulate_for_dv(dv, - res, - hops, - hdr, - &send_dv_to_neighbour, - NULL, - options & (~RMO_REDUNDANT)); - } - return GNUNET_TIME_relative_min(rtt1, rtt2); + { + struct DistanceVectorHop *hops[2]; + unsigned int res; + + res = pick_random_dv_hops (dv, + options, + hops, + (0 == (options & RMO_REDUNDANT)) ? 1 : 2); + if (0 == res) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Failed to route message, could not determine DV path\n"); + return rtt1; + } + rtt2 = encapsulate_for_dv (dv, + res, + hops, + hdr, + &send_dv_to_neighbour, + NULL, + options & (~RMO_REDUNDANT)); + } + return GNUNET_TIME_relative_min (rtt1, rtt2); } @@ -4666,7 +4718,7 @@ route_control_message_without_fc(const struct GNUNET_PeerIdentity *target, * @param cls a `struct VirtualLink` to work with */ static void -consider_sending_fc(void *cls) +consider_sending_fc (void *cls) { struct VirtualLink *vl = cls; struct GNUNET_TIME_Absolute monotime; @@ -4674,7 +4726,7 @@ consider_sending_fc(void *cls) struct GNUNET_TIME_Relative duration; struct GNUNET_TIME_Relative rtt; - duration = GNUNET_TIME_absolute_get_duration(vl->last_fc_transmission); + duration = GNUNET_TIME_absolute_get_duration (vl->last_fc_transmission); /* OPTIMIZE-FC-BDP: decide sane criteria on when to do this, instead of doing it always! */ /* For example, we should probably ONLY do this if a bit more than @@ -4683,41 +4735,41 @@ consider_sending_fc(void *cls) need an estimate for the bandwidth-delay-product for the entire VL, as that determines "significantly". We have the delay, but the bandwidth statistics need to be added for the VL!*/ - (void)duration; - - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending FC seq %u to %s with new window %llu\n", - (unsigned int)vl->fc_seq_gen, - GNUNET_i2s(&vl->target), - (unsigned long long)vl->incoming_fc_window_size); - monotime = GNUNET_TIME_absolute_get_monotonic(GST_cfg); + (void) duration; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending FC seq %u to %s with new window %llu\n", + (unsigned int) vl->fc_seq_gen, + GNUNET_i2s (&vl->target), + (unsigned long long) vl->incoming_fc_window_size); + monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg); vl->last_fc_transmission = monotime; - fc.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL); - fc.header.size = htons(sizeof(fc)); - fc.seq = htonl(vl->fc_seq_gen++); - fc.inbound_window_size = GNUNET_htonll(vl->incoming_fc_window_size); - fc.outbound_sent = GNUNET_htonll(vl->outbound_fc_window_size_used); - fc.outbound_window_size = GNUNET_htonll(vl->outbound_fc_window_size); - fc.sender_time = GNUNET_TIME_absolute_hton(monotime); - rtt = route_control_message_without_fc(&vl->target, &fc.header, RMO_NONE); + fc.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL); + fc.header.size = htons (sizeof(fc)); + fc.seq = htonl (vl->fc_seq_gen++); + fc.inbound_window_size = GNUNET_htonll (vl->incoming_fc_window_size); + fc.outbound_sent = GNUNET_htonll (vl->outbound_fc_window_size_used); + fc.outbound_window_size = GNUNET_htonll (vl->outbound_fc_window_size); + fc.sender_time = GNUNET_TIME_absolute_hton (monotime); + rtt = route_control_message_without_fc (&vl->target, &fc.header, RMO_NONE); if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == rtt.rel_value_us) - { - rtt = GNUNET_TIME_UNIT_SECONDS; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "FC retransmission to %s failed, will retry in %s\n", - GNUNET_i2s(&vl->target), - GNUNET_STRINGS_relative_time_to_string(rtt, GNUNET_YES)); - vl->last_fc_rtt = GNUNET_TIME_UNIT_ZERO; - } + { + rtt = GNUNET_TIME_UNIT_SECONDS; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "FC retransmission to %s failed, will retry in %s\n", + GNUNET_i2s (&vl->target), + GNUNET_STRINGS_relative_time_to_string (rtt, GNUNET_YES)); + vl->last_fc_rtt = GNUNET_TIME_UNIT_ZERO; + } else - { - /* OPTIMIZE-FC-BDP: rtt is not ideal, we can do better! */ - vl->last_fc_rtt = rtt; - } + { + /* OPTIMIZE-FC-BDP: rtt is not ideal, we can do better! */ + vl->last_fc_rtt = rtt; + } if (NULL != vl->fc_retransmit_task) - GNUNET_SCHEDULER_cancel(vl->fc_retransmit_task); + GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task); vl->fc_retransmit_task = - GNUNET_SCHEDULER_add_delayed(rtt, &consider_sending_fc, vl); + GNUNET_SCHEDULER_add_delayed (rtt, &consider_sending_fc, vl); } @@ -4738,7 +4790,7 @@ consider_sending_fc(void *cls) * @param vl virtual link where we should check for transmission */ static void -check_vl_transmission(struct VirtualLink *vl) +check_vl_transmission (struct VirtualLink *vl) { struct Neighbour *n = vl->n; struct DistanceVector *dv = vl->dv; @@ -4750,57 +4802,57 @@ check_vl_transmission(struct VirtualLink *vl) elig = GNUNET_NO; for (struct PendingMessage *pm = vl->pending_msg_head; NULL != pm; pm = pm->next_vl) - { - if (NULL != pm->qe) - continue; /* not eligible, is in a queue! */ - if (pm->bytes_msg + vl->outbound_fc_window_size_used > - vl->outbound_fc_window_size) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Stalled transmision on VL %s due to flow control: %llu < %llu\n", - GNUNET_i2s(&vl->target), - (unsigned long long)vl->outbound_fc_window_size, - (unsigned long long)(pm->bytes_msg + - vl->outbound_fc_window_size_used)); - consider_sending_fc(vl); - return; /* We have a message, but flow control says "nope" */ - } - elig = GNUNET_YES; - break; - } + { + if (NULL != pm->qe) + continue; /* not eligible, is in a queue! */ + if (pm->bytes_msg + vl->outbound_fc_window_size_used > + vl->outbound_fc_window_size) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Stalled transmision on VL %s due to flow control: %llu < %llu\n", + GNUNET_i2s (&vl->target), + (unsigned long long) vl->outbound_fc_window_size, + (unsigned long long) (pm->bytes_msg + + vl->outbound_fc_window_size_used)); + consider_sending_fc (vl); + return; /* We have a message, but flow control says "nope" */ + } + elig = GNUNET_YES; + break; + } if (GNUNET_NO == elig) return; /* Notify queues at direct neighbours that we are interested */ - now = GNUNET_TIME_absolute_get(); + now = GNUNET_TIME_absolute_get (); if (NULL != n) + { + for (struct Queue *queue = n->queue_head; NULL != queue; + queue = queue->next_neighbour) + if ((GNUNET_YES == queue->idle) && + (queue->validated_until.abs_value_us > now.abs_value_us)) + schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); + } + /* Notify queues via DV that we are interested */ + if (NULL != dv) + { + /* Do DV with lower scheduler priority, which effectively means that + IF a neighbour exists and is available, we prefer it. */ + for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; + pos = pos->next_dv) { - for (struct Queue *queue = n->queue_head; NULL != queue; + struct Neighbour *nh = pos->next_hop; + + if (pos->path_valid_until.abs_value_us <= now.abs_value_us) + continue; /* skip this one: path not validated */ + for (struct Queue *queue = nh->queue_head; NULL != queue; queue = queue->next_neighbour) if ((GNUNET_YES == queue->idle) && (queue->validated_until.abs_value_us > now.abs_value_us)) - schedule_transmit_on_queue(queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); - } - /* Notify queues via DV that we are interested */ - if (NULL != dv) - { - /* Do DV with lower scheduler priority, which effectively means that - IF a neighbour exists and is available, we prefer it. */ - for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos; - pos = pos->next_dv) - { - struct Neighbour *nh = pos->next_hop; - - if (pos->path_valid_until.abs_value_us <= now.abs_value_us) - continue; /* skip this one: path not validated */ - for (struct Queue *queue = nh->queue_head; NULL != queue; - queue = queue->next_neighbour) - if ((GNUNET_YES == queue->idle) && - (queue->validated_until.abs_value_us > now.abs_value_us)) - schedule_transmit_on_queue(queue, - GNUNET_SCHEDULER_PRIORITY_BACKGROUND); - } + schedule_transmit_on_queue (queue, + GNUNET_SCHEDULER_PRIORITY_BACKGROUND); } + } } @@ -4811,7 +4863,7 @@ check_vl_transmission(struct VirtualLink *vl) * @param obm the send message that was sent */ static void -handle_client_send(void *cls, const struct OutboundMessage *obm) +handle_client_send (void *cls, const struct OutboundMessage *obm) { struct TransportClient *tc = cls; struct PendingMessage *pm; @@ -4820,46 +4872,46 @@ handle_client_send(void *cls, const struct OutboundMessage *obm) struct VirtualLink *vl; enum GNUNET_MQ_PriorityPreferences pp; - GNUNET_assert(CT_CORE == tc->type); - obmm = (const struct GNUNET_MessageHeader *)&obm[1]; - bytes_msg = ntohs(obmm->size); - pp = (enum GNUNET_MQ_PriorityPreferences)ntohl(obm->priority); - vl = lookup_virtual_link(&obm->peer); + GNUNET_assert (CT_CORE == tc->type); + obmm = (const struct GNUNET_MessageHeader *) &obm[1]; + bytes_msg = ntohs (obmm->size); + pp = (enum GNUNET_MQ_PriorityPreferences) ntohl (obm->priority); + vl = lookup_virtual_link (&obm->peer); if (NULL == vl) - { - /* Failure: don't have this peer as a neighbour (anymore). - Might have gone down asynchronously, so this is NOT - a protocol violation by CORE. Still count the event, - as this should be rare. */ - GNUNET_SERVICE_client_continue(tc->client); - GNUNET_STATISTICS_update(GST_stats, - "# messages dropped (neighbour unknown)", - 1, - GNUNET_NO); - return; - } + { + /* Failure: don't have this peer as a neighbour (anymore). + Might have gone down asynchronously, so this is NOT + a protocol violation by CORE. Still count the event, + as this should be rare. */ + GNUNET_SERVICE_client_continue (tc->client); + GNUNET_STATISTICS_update (GST_stats, + "# messages dropped (neighbour unknown)", + 1, + GNUNET_NO); + return; + } - pm = GNUNET_malloc(sizeof(struct PendingMessage) + bytes_msg); + pm = GNUNET_malloc (sizeof(struct PendingMessage) + bytes_msg); pm->logging_uuid = logging_uuid_gen++; pm->prefs = pp; pm->client = tc; pm->vl = vl; pm->bytes_msg = bytes_msg; - memcpy(&pm[1], obmm, bytes_msg); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending %u bytes as <%llu> to %s\n", - bytes_msg, - pm->logging_uuid, - GNUNET_i2s(&obm->peer)); - GNUNET_CONTAINER_MDLL_insert(client, - tc->details.core.pending_msg_head, - tc->details.core.pending_msg_tail, - pm); - GNUNET_CONTAINER_MDLL_insert(vl, - vl->pending_msg_head, - vl->pending_msg_tail, - pm); - check_vl_transmission(vl); + memcpy (&pm[1], obmm, bytes_msg); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending %u bytes as <%llu> to %s\n", + bytes_msg, + pm->logging_uuid, + GNUNET_i2s (&obm->peer)); + GNUNET_CONTAINER_MDLL_insert (client, + tc->details.core.pending_msg_head, + tc->details.core.pending_msg_tail, + pm); + GNUNET_CONTAINER_MDLL_insert (vl, + vl->pending_msg_head, + vl->pending_msg_tail, + pm); + check_vl_transmission (vl); } @@ -4873,39 +4925,40 @@ handle_client_send(void *cls, const struct OutboundMessage *obm) * @param cb the send message that was sent */ static void -handle_communicator_backchannel( +handle_communicator_backchannel ( void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb) { struct TransportClient *tc = cls; const struct GNUNET_MessageHeader *inbox = - (const struct GNUNET_MessageHeader *)&cb[1]; - uint16_t isize = ntohs(inbox->size); - const char *is = ((const char *)&cb[1]) + isize; + (const struct GNUNET_MessageHeader *) &cb[1]; + uint16_t isize = ntohs (inbox->size); + const char *is = ((const char *) &cb[1]) + isize; char - mbuf[isize + - sizeof(struct TransportBackchannelEncapsulationMessage)] GNUNET_ALIGN; + mbuf[isize + + sizeof(struct + TransportBackchannelEncapsulationMessage)] GNUNET_ALIGN; struct TransportBackchannelEncapsulationMessage *be = - (struct TransportBackchannelEncapsulationMessage *)mbuf; + (struct TransportBackchannelEncapsulationMessage *) mbuf; /* 0-termination of 'is' was checked already in #check_communicator_backchannel() */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Preparing backchannel transmission to %s:%s of type %u\n", - GNUNET_i2s(&cb->pid), - is, - ntohs(inbox->size)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Preparing backchannel transmission to %s:%s of type %u\n", + GNUNET_i2s (&cb->pid), + is, + ntohs (inbox->size)); /* encapsulate and encrypt message */ be->header.type = - htons(GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION); - be->header.size = htons(sizeof(mbuf)); - memcpy(&be[1], inbox, isize); - memcpy(&mbuf[sizeof(struct TransportBackchannelEncapsulationMessage) + - isize], - is, - strlen(is) + 1); - route_control_message_without_fc(&cb->pid, &be->header, RMO_DV_ALLOWED); - GNUNET_SERVICE_client_continue(tc->client); + htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION); + be->header.size = htons (sizeof(mbuf)); + memcpy (&be[1], inbox, isize); + memcpy (&mbuf[sizeof(struct TransportBackchannelEncapsulationMessage) + + isize], + is, + strlen (is) + 1); + route_control_message_without_fc (&cb->pid, &be->header, RMO_DV_ALLOWED); + GNUNET_SERVICE_client_continue (tc->client); } @@ -4917,17 +4970,17 @@ handle_communicator_backchannel( * @return #GNUNET_OK if message is well-formed */ static int -check_add_address(void *cls, - const struct GNUNET_TRANSPORT_AddAddressMessage *aam) +check_add_address (void *cls, + const struct GNUNET_TRANSPORT_AddAddressMessage *aam) { struct TransportClient *tc = cls; if (CT_COMMUNICATOR != tc->type) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } - GNUNET_MQ_check_zero_termination(aam); + { + GNUNET_break (0); + return GNUNET_SYSERR; + } + GNUNET_MQ_check_zero_termination (aam); return GNUNET_OK; } @@ -4938,7 +4991,7 @@ check_add_address(void *cls, * @param cls an `struct AddressListEntry *` */ static void -store_pi(void *cls); +store_pi (void *cls); /** @@ -4948,26 +5001,26 @@ store_pi(void *cls); * @param success #GNUNET_YES if peerstore was successful */ static void -peerstore_store_own_cb(void *cls, int success) +peerstore_store_own_cb (void *cls, int success) { struct AddressListEntry *ale = cls; ale->sc = NULL; if (GNUNET_YES != success) - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Failed to store our own address `%s' in peerstore!\n", - ale->address); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to store our own address `%s' in peerstore!\n", + ale->address); else - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Successfully stored our own address `%s' in peerstore!\n", - ale->address); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Successfully stored our own address `%s' in peerstore!\n", + ale->address); /* refresh period is 1/4 of expiration time, that should be plenty without being excessive. */ ale->st = - GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_divide(ale->expiration, - 4ULL), - &store_pi, - ale); + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (ale->expiration, + 4ULL), + &store_pi, + ale); } @@ -4977,7 +5030,7 @@ peerstore_store_own_cb(void *cls, int success) * @param cls an `struct AddressListEntry *` */ static void -store_pi(void *cls) +store_pi (void *cls) { struct AddressListEntry *ale = cls; void *addr; @@ -4985,36 +5038,36 @@ store_pi(void *cls) struct GNUNET_TIME_Absolute expiration; ale->st = NULL; - expiration = GNUNET_TIME_relative_to_absolute(ale->expiration); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Storing our address `%s' in peerstore until %s!\n", - ale->address, - GNUNET_STRINGS_absolute_time_to_string(expiration)); - GNUNET_HELLO_sign_address(ale->address, - ale->nt, - hello_mono_time, - GST_my_private_key, - &addr, - &addr_len); - ale->sc = GNUNET_PEERSTORE_store(peerstore, - "transport", - &GST_my_identity, - GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY, - addr, - addr_len, - expiration, - GNUNET_PEERSTORE_STOREOPTION_MULTIPLE, - &peerstore_store_own_cb, - ale); - GNUNET_free(addr); + expiration = GNUNET_TIME_relative_to_absolute (ale->expiration); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Storing our address `%s' in peerstore until %s!\n", + ale->address, + GNUNET_STRINGS_absolute_time_to_string (expiration)); + GNUNET_HELLO_sign_address (ale->address, + ale->nt, + hello_mono_time, + GST_my_private_key, + &addr, + &addr_len); + ale->sc = GNUNET_PEERSTORE_store (peerstore, + "transport", + &GST_my_identity, + GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY, + addr, + addr_len, + expiration, + GNUNET_PEERSTORE_STOREOPTION_MULTIPLE, + &peerstore_store_own_cb, + ale); + GNUNET_free (addr); if (NULL == ale->sc) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Failed to store our address `%s' with peerstore\n", - ale->address); - ale->st = - GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &store_pi, ale); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Failed to store our address `%s' with peerstore\n", + ale->address); + ale->st = + GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &store_pi, ale); + } } @@ -5025,30 +5078,30 @@ store_pi(void *cls) * @param aam the send message that was sent */ static void -handle_add_address(void *cls, - const struct GNUNET_TRANSPORT_AddAddressMessage *aam) +handle_add_address (void *cls, + const struct GNUNET_TRANSPORT_AddAddressMessage *aam) { struct TransportClient *tc = cls; struct AddressListEntry *ale; size_t slen; /* 0-termination of &aam[1] was checked in #check_add_address */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Communicator added address `%s'!\n", - (const char *)&aam[1]); - slen = ntohs(aam->header.size) - sizeof(*aam); - ale = GNUNET_malloc(sizeof(struct AddressListEntry) + slen); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Communicator added address `%s'!\n", + (const char *) &aam[1]); + slen = ntohs (aam->header.size) - sizeof(*aam); + ale = GNUNET_malloc (sizeof(struct AddressListEntry) + slen); ale->tc = tc; - ale->address = (const char *)&ale[1]; - ale->expiration = GNUNET_TIME_relative_ntoh(aam->expiration); + ale->address = (const char *) &ale[1]; + ale->expiration = GNUNET_TIME_relative_ntoh (aam->expiration); ale->aid = aam->aid; - ale->nt = (enum GNUNET_NetworkType)ntohl(aam->nt); - memcpy(&ale[1], &aam[1], slen); - GNUNET_CONTAINER_DLL_insert(tc->details.communicator.addr_head, - tc->details.communicator.addr_tail, - ale); - ale->st = GNUNET_SCHEDULER_add_now(&store_pi, ale); - GNUNET_SERVICE_client_continue(tc->client); + ale->nt = (enum GNUNET_NetworkType) ntohl (aam->nt); + memcpy (&ale[1], &aam[1], slen); + GNUNET_CONTAINER_DLL_insert (tc->details.communicator.addr_head, + tc->details.communicator.addr_tail, + ale); + ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale); + GNUNET_SERVICE_client_continue (tc->client); } @@ -5059,34 +5112,34 @@ handle_add_address(void *cls, * @param dam the send message that was sent */ static void -handle_del_address(void *cls, - const struct GNUNET_TRANSPORT_DelAddressMessage *dam) +handle_del_address (void *cls, + const struct GNUNET_TRANSPORT_DelAddressMessage *dam) { struct TransportClient *tc = cls; struct AddressListEntry *alen; if (CT_COMMUNICATOR != tc->type) - { - GNUNET_break(0); - GNUNET_SERVICE_client_drop(tc->client); - return; - } + { + GNUNET_break (0); + GNUNET_SERVICE_client_drop (tc->client); + return; + } for (struct AddressListEntry *ale = tc->details.communicator.addr_head; NULL != ale; ale = alen) - { - alen = ale->next; - if (dam->aid != ale->aid) - continue; - GNUNET_assert(ale->tc == tc); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Communicator deleted address `%s'!\n", - ale->address); - free_address_list_entry(ale); - GNUNET_SERVICE_client_continue(tc->client); - } - GNUNET_break(0); - GNUNET_SERVICE_client_drop(tc->client); + { + alen = ale->next; + if (dam->aid != ale->aid) + continue; + GNUNET_assert (ale->tc == tc); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Communicator deleted address `%s'!\n", + ale->address); + free_address_list_entry (ale); + GNUNET_SERVICE_client_continue (tc->client); + } + GNUNET_break (0); + GNUNET_SERVICE_client_drop (tc->client); } @@ -5098,8 +5151,8 @@ handle_del_address(void *cls, * @param msg message to demultiplex */ static void -demultiplex_with_cmc(struct CommunicatorMessageContext *cmc, - const struct GNUNET_MessageHeader *msg); +demultiplex_with_cmc (struct CommunicatorMessageContext *cmc, + const struct GNUNET_MessageHeader *msg); /** @@ -5110,23 +5163,23 @@ demultiplex_with_cmc(struct CommunicatorMessageContext *cmc, * @param cls a `struct CoreSentContext` */ static void -core_env_sent_cb(void *cls) +core_env_sent_cb (void *cls) { struct CoreSentContext *ctx = cls; struct VirtualLink *vl = ctx->vl; if (NULL == vl) - { - /* lost the link in the meantime, ignore */ - GNUNET_free(ctx); - return; - } - GNUNET_CONTAINER_DLL_remove(vl->csc_head, vl->csc_tail, ctx); - GNUNET_assert(vl->incoming_fc_window_size_ram >= ctx->size); + { + /* lost the link in the meantime, ignore */ + GNUNET_free (ctx); + return; + } + GNUNET_CONTAINER_DLL_remove (vl->csc_head, vl->csc_tail, ctx); + GNUNET_assert (vl->incoming_fc_window_size_ram >= ctx->size); vl->incoming_fc_window_size_ram -= ctx->size; vl->incoming_fc_window_size_used += ctx->isize; - consider_sending_fc(vl); - GNUNET_free(ctx); + consider_sending_fc (vl); + GNUNET_free (ctx); } @@ -5139,109 +5192,109 @@ core_env_sent_cb(void *cls) * @param mh the message that was received */ static void -handle_raw_message(void *cls, const struct GNUNET_MessageHeader *mh) +handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh) { struct CommunicatorMessageContext *cmc = cls; struct VirtualLink *vl; - uint16_t size = ntohs(mh->size); + uint16_t size = ntohs (mh->size); int have_core; if ((size > UINT16_MAX - sizeof(struct InboundMessage)) || (size < sizeof(struct GNUNET_MessageHeader))) - { - struct GNUNET_SERVICE_Client *client = cmc->tc->client; + { + struct GNUNET_SERVICE_Client *client = cmc->tc->client; - GNUNET_break(0); - finish_cmc_handling(cmc); - GNUNET_SERVICE_client_drop(client); - return; - } - vl = lookup_virtual_link(&cmc->im.sender); + GNUNET_break (0); + finish_cmc_handling (cmc); + GNUNET_SERVICE_client_drop (client); + return; + } + vl = lookup_virtual_link (&cmc->im.sender); if (NULL == vl) - { - /* FIXME: sender is giving us messages for CORE but we don't have - the link up yet! I *suspect* this can happen right now (i.e. - sender has verified us, but we didn't verify sender), but if - we pass this on, CORE would be confused (link down, messages - arrive). We should investigate more if this happens often, - or in a persistent manner, and possibly do "something" about - it. Thus logging as error for now. */ - GNUNET_break_op(0); - GNUNET_STATISTICS_update(GST_stats, - "# CORE messages droped (virtual link still down)", - 1, - GNUNET_NO); - - finish_cmc_handling(cmc); - return; - } + { + /* FIXME: sender is giving us messages for CORE but we don't have + the link up yet! I *suspect* this can happen right now (i.e. + sender has verified us, but we didn't verify sender), but if + we pass this on, CORE would be confused (link down, messages + arrive). We should investigate more if this happens often, + or in a persistent manner, and possibly do "something" about + it. Thus logging as error for now. */ + GNUNET_break_op (0); + GNUNET_STATISTICS_update (GST_stats, + "# CORE messages droped (virtual link still down)", + 1, + GNUNET_NO); + + finish_cmc_handling (cmc); + return; + } if (vl->incoming_fc_window_size_ram > UINT_MAX - size) - { - GNUNET_STATISTICS_update(GST_stats, - "# CORE messages droped (FC arithmetic overflow)", - 1, - GNUNET_NO); + { + GNUNET_STATISTICS_update (GST_stats, + "# CORE messages droped (FC arithmetic overflow)", + 1, + GNUNET_NO); - finish_cmc_handling(cmc); - return; - } + finish_cmc_handling (cmc); + return; + } if (vl->incoming_fc_window_size_ram + size > vl->available_fc_window_size) - { - GNUNET_STATISTICS_update(GST_stats, - "# CORE messages droped (FC window overflow)", - 1, - GNUNET_NO); - finish_cmc_handling(cmc); - return; - } + { + GNUNET_STATISTICS_update (GST_stats, + "# CORE messages droped (FC window overflow)", + 1, + GNUNET_NO); + finish_cmc_handling (cmc); + return; + } /* Forward to all CORE clients */ have_core = GNUNET_NO; for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next) - { - struct GNUNET_MQ_Envelope *env; - struct InboundMessage *im; - struct CoreSentContext *ctx; - - if (CT_CORE != tc->type) - continue; - vl->incoming_fc_window_size_ram += size; - env = GNUNET_MQ_msg_extra(im, size, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV); - ctx = GNUNET_new(struct CoreSentContext); - ctx->vl = vl; - ctx->size = size; - ctx->isize = (GNUNET_NO == have_core) ? size : 0; - have_core = GNUNET_YES; - GNUNET_CONTAINER_DLL_insert(vl->csc_head, vl->csc_tail, ctx); - GNUNET_MQ_notify_sent(env, &core_env_sent_cb, ctx); - im->peer = cmc->im.sender; - memcpy(&im[1], mh, size); - GNUNET_MQ_send(tc->mq, env); - vl->core_recv_window--; - } + { + struct GNUNET_MQ_Envelope *env; + struct InboundMessage *im; + struct CoreSentContext *ctx; + + if (CT_CORE != tc->type) + continue; + vl->incoming_fc_window_size_ram += size; + env = GNUNET_MQ_msg_extra (im, size, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV); + ctx = GNUNET_new (struct CoreSentContext); + ctx->vl = vl; + ctx->size = size; + ctx->isize = (GNUNET_NO == have_core) ? size : 0; + have_core = GNUNET_YES; + GNUNET_CONTAINER_DLL_insert (vl->csc_head, vl->csc_tail, ctx); + GNUNET_MQ_notify_sent (env, &core_env_sent_cb, ctx); + im->peer = cmc->im.sender; + memcpy (&im[1], mh, size); + GNUNET_MQ_send (tc->mq, env); + vl->core_recv_window--; + } if (GNUNET_NO == have_core) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Dropped message to CORE: no CORE client connected!\n"); - /* Nevertheless, count window as used, as it is from the - perspective of the other peer! */ - vl->incoming_fc_window_size_used += size; - /* TODO-M1 */ - finish_cmc_handling(cmc); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Delivered message from %s of type %u to CORE\n", - GNUNET_i2s(&cmc->im.sender), - ntohs(mh->type)); + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Dropped message to CORE: no CORE client connected!\n"); + /* Nevertheless, count window as used, as it is from the + perspective of the other peer! */ + vl->incoming_fc_window_size_used += size; + /* TODO-M1 */ + finish_cmc_handling (cmc); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Delivered message from %s of type %u to CORE\n", + GNUNET_i2s (&cmc->im.sender), + ntohs (mh->type)); if (vl->core_recv_window > 0) - { - finish_cmc_handling(cmc); - return; - } + { + finish_cmc_handling (cmc); + return; + } /* Wait with calling #finish_cmc_handling(cmc) until the message was processed by CORE MQs (for CORE flow control)! */ - GNUNET_CONTAINER_DLL_insert(vl->cmc_head, vl->cmc_tail, cmc); + GNUNET_CONTAINER_DLL_insert (vl->cmc_head, vl->cmc_tail, cmc); } @@ -5253,27 +5306,27 @@ handle_raw_message(void *cls, const struct GNUNET_MessageHeader *mh) * @return #GNUNET_YES if message is well-formed */ static int -check_fragment_box(void *cls, const struct TransportFragmentBoxMessage *fb) +check_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb) { - uint16_t size = ntohs(fb->header.size); + uint16_t size = ntohs (fb->header.size); uint16_t bsize = size - sizeof(*fb); - (void)cls; + (void) cls; if (0 == bsize) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } - if (bsize + ntohs(fb->frag_off) > ntohs(fb->msg_size)) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } - if (ntohs(fb->frag_off) >= ntohs(fb->msg_size)) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + if (bsize + ntohs (fb->frag_off) > ntohs (fb->msg_size)) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + if (ntohs (fb->frag_off) >= ntohs (fb->msg_size)) + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } return GNUNET_YES; } @@ -5284,16 +5337,16 @@ check_fragment_box(void *cls, const struct TransportFragmentBoxMessage *fb) * @param cls a `struct AcknowledgementCummulator *` */ static void -destroy_ack_cummulator(void *cls) +destroy_ack_cummulator (void *cls) { struct AcknowledgementCummulator *ac = cls; ac->task = NULL; - GNUNET_assert(0 == ac->num_acks); - GNUNET_assert( + GNUNET_assert (0 == ac->num_acks); + GNUNET_assert ( GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove(ack_cummulators, &ac->target, ac)); - GNUNET_free(ac); + GNUNET_CONTAINER_multipeermap_remove (ack_cummulators, &ac->target, ac)); + GNUNET_free (ac); } @@ -5303,39 +5356,39 @@ destroy_ack_cummulator(void *cls) * @param cls a `struct AcknowledgementCummulator *` */ static void -transmit_cummulative_ack_cb(void *cls) +transmit_cummulative_ack_cb (void *cls) { struct AcknowledgementCummulator *ac = cls; - char buf[sizeof(struct TransportReliabilityAckMessage) + - ac->ack_counter * - sizeof(struct TransportCummulativeAckPayloadP)] GNUNET_ALIGN; + char buf[sizeof(struct TransportReliabilityAckMessage) + + ac->ack_counter + * sizeof(struct TransportCummulativeAckPayloadP)] GNUNET_ALIGN; struct TransportReliabilityAckMessage *ack = - (struct TransportReliabilityAckMessage *)buf; + (struct TransportReliabilityAckMessage *) buf; struct TransportCummulativeAckPayloadP *ap; ac->task = NULL; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending ACK with %u components to %s\n", - ac->ack_counter, - GNUNET_i2s(&ac->target)); - GNUNET_assert(0 < ac->ack_counter); - ack->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending ACK with %u components to %s\n", + ac->ack_counter, + GNUNET_i2s (&ac->target)); + GNUNET_assert (0 < ac->ack_counter); + ack->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK); ack->header.size = - htons(sizeof(*ack) + - ac->ack_counter * sizeof(struct TransportCummulativeAckPayloadP)); - ack->ack_counter = htonl(ac->ack_counter++); - ap = (struct TransportCummulativeAckPayloadP *)&ack[1]; + htons (sizeof(*ack) + + ac->ack_counter * sizeof(struct TransportCummulativeAckPayloadP)); + ack->ack_counter = htonl (ac->ack_counter++); + ap = (struct TransportCummulativeAckPayloadP *) &ack[1]; for (unsigned int i = 0; i < ac->ack_counter; i++) - { - ap[i].ack_uuid = ac->ack_uuids[i].ack_uuid; - ap[i].ack_delay = GNUNET_TIME_relative_hton( - GNUNET_TIME_absolute_get_duration(ac->ack_uuids[i].receive_time)); - } - route_control_message_without_fc(&ac->target, &ack->header, RMO_DV_ALLOWED); + { + ap[i].ack_uuid = ac->ack_uuids[i].ack_uuid; + ap[i].ack_delay = GNUNET_TIME_relative_hton ( + GNUNET_TIME_absolute_get_duration (ac->ack_uuids[i].receive_time)); + } + route_control_message_without_fc (&ac->target, &ack->header, RMO_DV_ALLOWED); ac->num_acks = 0; - ac->task = GNUNET_SCHEDULER_add_delayed(ACK_CUMMULATOR_TIMEOUT, - &destroy_ack_cummulator, - ac); + ac->task = GNUNET_SCHEDULER_add_delayed (ACK_CUMMULATOR_TIMEOUT, + &destroy_ack_cummulator, + ac); } @@ -5348,55 +5401,56 @@ transmit_cummulative_ack_cb(void *cls) * @param max_delay how long can the ACK wait */ static void -cummulative_ack(const struct GNUNET_PeerIdentity *pid, - const struct AcknowledgementUUIDP *ack_uuid, - struct GNUNET_TIME_Absolute max_delay) +cummulative_ack (const struct GNUNET_PeerIdentity *pid, + const struct AcknowledgementUUIDP *ack_uuid, + struct GNUNET_TIME_Absolute max_delay) { struct AcknowledgementCummulator *ac; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Scheduling ACK %s for transmission to %s\n", - GNUNET_uuid2s(&ack_uuid->value), - GNUNET_i2s(pid)); - ac = GNUNET_CONTAINER_multipeermap_get(ack_cummulators, pid); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Scheduling ACK %s for transmission to %s\n", + GNUNET_uuid2s (&ack_uuid->value), + GNUNET_i2s (pid)); + ac = GNUNET_CONTAINER_multipeermap_get (ack_cummulators, pid); if (NULL == ac) - { - ac = GNUNET_new(struct AcknowledgementCummulator); - ac->target = *pid; - ac->min_transmission_time = max_delay; - GNUNET_assert(GNUNET_YES == - GNUNET_CONTAINER_multipeermap_put( - ack_cummulators, - &ac->target, - ac, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); - } + { + ac = GNUNET_new (struct AcknowledgementCummulator); + ac->target = *pid; + ac->min_transmission_time = max_delay; + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multipeermap_put ( + ack_cummulators, + &ac->target, + ac, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + } else + { + if (MAX_CUMMULATIVE_ACKS == ac->num_acks) { - if (MAX_CUMMULATIVE_ACKS == ac->num_acks) - { - /* must run immediately, ack buffer full! */ - GNUNET_SCHEDULER_cancel(ac->task); - transmit_cummulative_ack_cb(ac); - } - GNUNET_SCHEDULER_cancel(ac->task); - ac->min_transmission_time = - GNUNET_TIME_absolute_min(ac->min_transmission_time, max_delay); + /* must run immediately, ack buffer full! */ + GNUNET_SCHEDULER_cancel (ac->task); + transmit_cummulative_ack_cb (ac); } - GNUNET_assert(ac->num_acks < MAX_CUMMULATIVE_ACKS); - ac->ack_uuids[ac->num_acks].receive_time = GNUNET_TIME_absolute_get(); + GNUNET_SCHEDULER_cancel (ac->task); + ac->min_transmission_time = + GNUNET_TIME_absolute_min (ac->min_transmission_time, max_delay); + } + GNUNET_assert (ac->num_acks < MAX_CUMMULATIVE_ACKS); + ac->ack_uuids[ac->num_acks].receive_time = GNUNET_TIME_absolute_get (); ac->ack_uuids[ac->num_acks].ack_uuid = *ack_uuid; ac->num_acks++; - ac->task = GNUNET_SCHEDULER_add_at(ac->min_transmission_time, - &transmit_cummulative_ack_cb, - ac); + ac->task = GNUNET_SCHEDULER_add_at (ac->min_transmission_time, + &transmit_cummulative_ack_cb, + ac); } /** * Closure for #find_by_message_uuid. */ -struct FindByMessageUuidContext { +struct FindByMessageUuidContext +{ /** * UUID to look for. */ @@ -5419,17 +5473,17 @@ struct FindByMessageUuidContext { * @return #GNUNET_YES if not found, #GNUNET_NO if found */ static int -find_by_message_uuid(void *cls, uint32_t key, void *value) +find_by_message_uuid (void *cls, uint32_t key, void *value) { struct FindByMessageUuidContext *fc = cls; struct ReassemblyContext *rc = value; - (void)key; - if (0 == GNUNET_memcmp(&fc->message_uuid, &rc->msg_uuid)) - { - fc->rc = rc; - return GNUNET_NO; - } + (void) key; + if (0 == GNUNET_memcmp (&fc->message_uuid, &rc->msg_uuid)) + { + fc->rc = rc; + return GNUNET_NO; + } return GNUNET_YES; } @@ -5442,7 +5496,7 @@ find_by_message_uuid(void *cls, uint32_t key, void *value) * @param fb the message that was received */ static void -handle_fragment_box(void *cls, const struct TransportFragmentBoxMessage *fb) +handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb) { struct CommunicatorMessageContext *cmc = cls; struct Neighbour *n; @@ -5455,142 +5509,142 @@ handle_fragment_box(void *cls, const struct TransportFragmentBoxMessage *fb) struct GNUNET_TIME_Relative cdelay; struct FindByMessageUuidContext fc; - n = lookup_neighbour(&cmc->im.sender); + n = lookup_neighbour (&cmc->im.sender); if (NULL == n) - { - struct GNUNET_SERVICE_Client *client = cmc->tc->client; + { + struct GNUNET_SERVICE_Client *client = cmc->tc->client; - GNUNET_break(0); - finish_cmc_handling(cmc); - GNUNET_SERVICE_client_drop(client); - return; - } + GNUNET_break (0); + finish_cmc_handling (cmc); + GNUNET_SERVICE_client_drop (client); + return; + } if (NULL == n->reassembly_map) - { - n->reassembly_map = GNUNET_CONTAINER_multihashmap32_create(8); - n->reassembly_heap = - GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); - n->reassembly_timeout_task = - GNUNET_SCHEDULER_add_delayed(REASSEMBLY_EXPIRATION, - &reassembly_cleanup_task, - n); - } - msize = ntohs(fb->msg_size); + { + n->reassembly_map = GNUNET_CONTAINER_multihashmap32_create (8); + n->reassembly_heap = + GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); + n->reassembly_timeout_task = + GNUNET_SCHEDULER_add_delayed (REASSEMBLY_EXPIRATION, + &reassembly_cleanup_task, + n); + } + msize = ntohs (fb->msg_size); fc.message_uuid = fb->msg_uuid; fc.rc = NULL; - (void)GNUNET_CONTAINER_multihashmap32_get_multiple(n->reassembly_map, - fb->msg_uuid.uuid, - &find_by_message_uuid, - &fc); + (void) GNUNET_CONTAINER_multihashmap32_get_multiple (n->reassembly_map, + fb->msg_uuid.uuid, + &find_by_message_uuid, + &fc); if (NULL == (rc = fc.rc)) - { - rc = GNUNET_malloc(sizeof(*rc) + msize + /* reassembly payload buffer */ - (msize + 7) / 8 * sizeof(uint8_t) /* bitfield */); - rc->msg_uuid = fb->msg_uuid; - rc->neighbour = n; - rc->msg_size = msize; - rc->reassembly_timeout = - GNUNET_TIME_relative_to_absolute(REASSEMBLY_EXPIRATION); - rc->last_frag = GNUNET_TIME_absolute_get(); - rc->hn = GNUNET_CONTAINER_heap_insert(n->reassembly_heap, - rc, - rc->reassembly_timeout.abs_value_us); - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap32_put( - n->reassembly_map, - rc->msg_uuid.uuid, - rc, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); - target = (char *)&rc[1]; - rc->bitfield = (uint8_t *)(target + rc->msg_size); - rc->msg_missing = rc->msg_size; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received fragment at offset %u/%u from %s for NEW message %u\n", - ntohs(fb->frag_off), - msize, - GNUNET_i2s(&cmc->im.sender), - (unsigned int)fb->msg_uuid.uuid); - } + { + rc = GNUNET_malloc (sizeof(*rc) + msize /* reassembly payload buffer */ + + (msize + 7) / 8 * sizeof(uint8_t) /* bitfield */); + rc->msg_uuid = fb->msg_uuid; + rc->neighbour = n; + rc->msg_size = msize; + rc->reassembly_timeout = + GNUNET_TIME_relative_to_absolute (REASSEMBLY_EXPIRATION); + rc->last_frag = GNUNET_TIME_absolute_get (); + rc->hn = GNUNET_CONTAINER_heap_insert (n->reassembly_heap, + rc, + rc->reassembly_timeout.abs_value_us); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap32_put ( + n->reassembly_map, + rc->msg_uuid.uuid, + rc, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); + target = (char *) &rc[1]; + rc->bitfield = (uint8_t *) (target + rc->msg_size); + rc->msg_missing = rc->msg_size; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received fragment at offset %u/%u from %s for NEW message %u\n", + ntohs (fb->frag_off), + msize, + GNUNET_i2s (&cmc->im.sender), + (unsigned int) fb->msg_uuid.uuid); + } else - { - target = (char *)&rc[1]; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received fragment at offset %u/%u from %s for message %u\n", - ntohs(fb->frag_off), - msize, - GNUNET_i2s(&cmc->im.sender), - (unsigned int)fb->msg_uuid.uuid); - } + { + target = (char *) &rc[1]; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received fragment at offset %u/%u from %s for message %u\n", + ntohs (fb->frag_off), + msize, + GNUNET_i2s (&cmc->im.sender), + (unsigned int) fb->msg_uuid.uuid); + } if (msize != rc->msg_size) - { - GNUNET_break(0); - finish_cmc_handling(cmc); - return; - } + { + GNUNET_break (0); + finish_cmc_handling (cmc); + return; + } /* reassemble */ - fsize = ntohs(fb->header.size) - sizeof(*fb); + fsize = ntohs (fb->header.size) - sizeof(*fb); if (0 == fsize) - { - GNUNET_break(0); - finish_cmc_handling(cmc); - return; - } - frag_off = ntohs(fb->frag_off); + { + GNUNET_break (0); + finish_cmc_handling (cmc); + return; + } + frag_off = ntohs (fb->frag_off); if (frag_off + fsize > msize) - { - /* Fragment (plus fragment size) exceeds message size! */ - GNUNET_break_op(0); - finish_cmc_handling(cmc); - return; - } - memcpy(&target[frag_off], &fb[1], fsize); + { + /* Fragment (plus fragment size) exceeds message size! */ + GNUNET_break_op (0); + finish_cmc_handling (cmc); + return; + } + memcpy (&target[frag_off], &fb[1], fsize); /* update bitfield and msg_missing */ for (unsigned int i = frag_off; i < frag_off + fsize; i++) + { + if (0 == (rc->bitfield[i / 8] & (1 << (i % 8)))) { - if (0 == (rc->bitfield[i / 8] & (1 << (i % 8)))) - { - rc->bitfield[i / 8] |= (1 << (i % 8)); - rc->msg_missing--; - } + rc->bitfield[i / 8] |= (1 << (i % 8)); + rc->msg_missing--; } + } /* Compute cummulative ACK */ - cdelay = GNUNET_TIME_absolute_get_duration(rc->last_frag); - cdelay = GNUNET_TIME_relative_multiply(cdelay, rc->msg_missing / fsize); + cdelay = GNUNET_TIME_absolute_get_duration (rc->last_frag); + cdelay = GNUNET_TIME_relative_multiply (cdelay, rc->msg_missing / fsize); if (0 == rc->msg_missing) cdelay = GNUNET_TIME_UNIT_ZERO; - cummulative_ack(&cmc->im.sender, - &fb->ack_uuid, - GNUNET_TIME_relative_to_absolute(cdelay)); - rc->last_frag = GNUNET_TIME_absolute_get(); + cummulative_ack (&cmc->im.sender, + &fb->ack_uuid, + GNUNET_TIME_relative_to_absolute (cdelay)); + rc->last_frag = GNUNET_TIME_absolute_get (); /* is reassembly complete? */ if (0 != rc->msg_missing) - { - finish_cmc_handling(cmc); - return; - } + { + finish_cmc_handling (cmc); + return; + } /* reassembly is complete, verify result */ - msg = (const struct GNUNET_MessageHeader *)&rc[1]; - if (ntohs(msg->size) != rc->msg_size) - { - GNUNET_break(0); - free_reassembly_context(rc); - finish_cmc_handling(cmc); - return; - } + msg = (const struct GNUNET_MessageHeader *) &rc[1]; + if (ntohs (msg->size) != rc->msg_size) + { + GNUNET_break (0); + free_reassembly_context (rc); + finish_cmc_handling (cmc); + return; + } /* successful reassembly */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Fragment reassembly complete for message %u\n", - (unsigned int)fb->msg_uuid.uuid); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Fragment reassembly complete for message %u\n", + (unsigned int) fb->msg_uuid.uuid); /* FIXME: check that the resulting msg is NOT a DV Box or Reliability Box, as that is NOT allowed! */ - demultiplex_with_cmc(cmc, msg); + demultiplex_with_cmc (cmc, msg); /* FIXME-OPTIMIZE: really free here? Might be bad if fragments are still en-route and we forget that we finished this reassembly immediately! -> keep around until timeout? -> shorten timeout based on ACK? */ - free_reassembly_context(rc); + free_reassembly_context (rc); } @@ -5602,11 +5656,11 @@ handle_fragment_box(void *cls, const struct TransportFragmentBoxMessage *fb) * @return #GNUNET_YES if message is well-formed */ static int -check_reliability_box(void *cls, - const struct TransportReliabilityBoxMessage *rb) +check_reliability_box (void *cls, + const struct TransportReliabilityBoxMessage *rb) { - (void)cls; - GNUNET_MQ_check_boxed_message(rb); + (void) cls; + GNUNET_MQ_check_boxed_message (rb); return GNUNET_YES; } @@ -5619,34 +5673,34 @@ check_reliability_box(void *cls, * @param rb the message that was received */ static void -handle_reliability_box(void *cls, - const struct TransportReliabilityBoxMessage *rb) +handle_reliability_box (void *cls, + const struct TransportReliabilityBoxMessage *rb) { struct CommunicatorMessageContext *cmc = cls; const struct GNUNET_MessageHeader *inbox = - (const struct GNUNET_MessageHeader *)&rb[1]; + (const struct GNUNET_MessageHeader *) &rb[1]; struct GNUNET_TIME_Relative rtt; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received reliability box from %s with UUID %s of type %u\n", - GNUNET_i2s(&cmc->im.sender), - GNUNET_uuid2s(&rb->ack_uuid.value), - (unsigned int)ntohs(inbox->type)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received reliability box from %s with UUID %s of type %u\n", + GNUNET_i2s (&cmc->im.sender), + GNUNET_uuid2s (&rb->ack_uuid.value), + (unsigned int) ntohs (inbox->type)); rtt = GNUNET_TIME_UNIT_SECONDS; /* FIXME: should base this on "RTT", but we do not really have an RTT for the * incoming* queue (should we have the sender add it to the rb message?) */ - cummulative_ack( + cummulative_ack ( &cmc->im.sender, &rb->ack_uuid, - (0 == ntohl(rb->ack_countdown)) + (0 == ntohl (rb->ack_countdown)) ? GNUNET_TIME_UNIT_ZERO_ABS - : GNUNET_TIME_relative_to_absolute( - GNUNET_TIME_relative_divide(rtt, 8 /* FIXME: magic constant */))); + : GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_relative_divide (rtt, 8 /* FIXME: magic constant */))); /* continue with inner message */ /* FIXME: check that inbox is NOT a DV Box, fragment or another reliability box (not allowed!) */ - demultiplex_with_cmc(cmc, inbox); + demultiplex_with_cmc (cmc, inbox); } @@ -5659,20 +5713,20 @@ handle_reliability_box(void *cls, * @param age current age */ static void -update_pd_age(struct PerformanceData *pd, unsigned int age) +update_pd_age (struct PerformanceData *pd, unsigned int age) { unsigned int sage; if (age == pd->last_age) return; /* nothing to do */ - sage = GNUNET_MAX(pd->last_age, age - 2 * GOODPUT_AGING_SLOTS); + sage = GNUNET_MAX (pd->last_age, age - 2 * GOODPUT_AGING_SLOTS); for (unsigned int i = sage; i <= age - GOODPUT_AGING_SLOTS; i++) - { - struct TransmissionHistoryEntry *the = &pd->the[i % GOODPUT_AGING_SLOTS]; + { + struct TransmissionHistoryEntry *the = &pd->the[i % GOODPUT_AGING_SLOTS]; - the->bytes_sent = 0; - the->bytes_received = 0; - } + the->bytes_sent = 0; + the->bytes_received = 0; + } pd->last_age = age; } @@ -5686,20 +5740,20 @@ update_pd_age(struct PerformanceData *pd, unsigned int age) * @param bytes_transmitted_ok number of bytes receiver confirmed as received */ static void -update_performance_data(struct PerformanceData *pd, - struct GNUNET_TIME_Relative rtt, - uint16_t bytes_transmitted_ok) +update_performance_data (struct PerformanceData *pd, + struct GNUNET_TIME_Relative rtt, + uint16_t bytes_transmitted_ok) { uint64_t nval = rtt.rel_value_us; uint64_t oval = pd->aged_rtt.rel_value_us; - unsigned int age = get_age(); + unsigned int age = get_age (); struct TransmissionHistoryEntry *the = &pd->the[age % GOODPUT_AGING_SLOTS]; if (oval == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) pd->aged_rtt = rtt; else pd->aged_rtt.rel_value_us = (nval + 7 * oval) / 8; - update_pd_age(pd, age); + update_pd_age (pd, age); the->bytes_received += bytes_transmitted_ok; } @@ -5712,11 +5766,11 @@ update_performance_data(struct PerformanceData *pd, * @param bytes_transmitted_ok number of bytes successfully transmitted */ static void -update_queue_performance(struct Queue *q, - struct GNUNET_TIME_Relative rtt, - uint16_t bytes_transmitted_ok) +update_queue_performance (struct Queue *q, + struct GNUNET_TIME_Relative rtt, + uint16_t bytes_transmitted_ok) { - update_performance_data(&q->pd, rtt, bytes_transmitted_ok); + update_performance_data (&q->pd, rtt, bytes_transmitted_ok); } @@ -5728,11 +5782,11 @@ update_queue_performance(struct Queue *q, * @param bytes_transmitted_ok number of bytes successfully transmitted */ static void -update_dvh_performance(struct DistanceVectorHop *dvh, - struct GNUNET_TIME_Relative rtt, - uint16_t bytes_transmitted_ok) +update_dvh_performance (struct DistanceVectorHop *dvh, + struct GNUNET_TIME_Relative rtt, + uint16_t bytes_transmitted_ok) { - update_performance_data(&dvh->pd, rtt, bytes_transmitted_ok); + update_performance_data (&dvh->pd, rtt, bytes_transmitted_ok); } @@ -5744,47 +5798,47 @@ update_dvh_performance(struct DistanceVectorHop *dvh, * @param pm pending message that was transmitted */ static void -completed_pending_message(struct PendingMessage *pm) +completed_pending_message (struct PendingMessage *pm) { struct PendingMessage *pos; switch (pm->pmt) - { - case PMT_CORE: - case PMT_RELIABILITY_BOX: - /* Full message sent, we are done */ - client_send_response(pm); - return; + { + case PMT_CORE: + case PMT_RELIABILITY_BOX: + /* Full message sent, we are done */ + client_send_response (pm); + return; - case PMT_FRAGMENT_BOX: - /* Fragment sent over reliabile channel */ - free_fragment_tree(pm); + case PMT_FRAGMENT_BOX: + /* Fragment sent over reliabile channel */ + free_fragment_tree (pm); + pos = pm->frag_parent; + GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm); + GNUNET_free (pm); + /* check if subtree is done */ + while ((NULL == pos->head_frag) && (pos->frag_off == pos->bytes_msg) && + (pos != pm)) + { + pm = pos; pos = pm->frag_parent; - GNUNET_CONTAINER_MDLL_remove(frag, pos->head_frag, pos->tail_frag, pm); - GNUNET_free(pm); - /* check if subtree is done */ - while ((NULL == pos->head_frag) && (pos->frag_off == pos->bytes_msg) && - (pos != pm)) - { - pm = pos; - pos = pm->frag_parent; - GNUNET_CONTAINER_MDLL_remove(frag, pos->head_frag, pos->tail_frag, pm); - GNUNET_free(pm); - } + GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm); + GNUNET_free (pm); + } - /* Was this the last applicable fragmment? */ - if ((NULL == pos->head_frag) && (NULL == pos->frag_parent) && - (pos->frag_off == pos->bytes_msg)) - client_send_response(pos); - return; + /* Was this the last applicable fragmment? */ + if ((NULL == pos->head_frag) && (NULL == pos->frag_parent) && + (pos->frag_off == pos->bytes_msg)) + client_send_response (pos); + return; - case PMT_DV_BOX: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Completed transmission of message %llu (DV Box)\n", - pm->logging_uuid); - free_pending_message(pm); - return; - } + case PMT_DV_BOX: + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Completed transmission of message %llu (DV Box)\n", + pm->logging_uuid); + free_pending_message (pm); + return; + } } @@ -5796,23 +5850,23 @@ completed_pending_message(struct PendingMessage *pm) * other peer */ static void -handle_acknowledged(struct PendingAcknowledgement *pa, - struct GNUNET_TIME_Relative ack_delay) +handle_acknowledged (struct PendingAcknowledgement *pa, + struct GNUNET_TIME_Relative ack_delay) { struct GNUNET_TIME_Relative delay; - delay = GNUNET_TIME_absolute_get_duration(pa->transmission_time); + delay = GNUNET_TIME_absolute_get_duration (pa->transmission_time); if (delay.rel_value_us > ack_delay.rel_value_us) delay = GNUNET_TIME_UNIT_ZERO; else - delay = GNUNET_TIME_relative_subtract(delay, ack_delay); + delay = GNUNET_TIME_relative_subtract (delay, ack_delay); if (NULL != pa->queue) - update_queue_performance(pa->queue, delay, pa->message_size); + update_queue_performance (pa->queue, delay, pa->message_size); if (NULL != pa->dvh) - update_dvh_performance(pa->dvh, delay, pa->message_size); + update_dvh_performance (pa->dvh, delay, pa->message_size); if (NULL != pa->pm) - completed_pending_message(pa->pm); - free_pending_acknowledgement(pa); + completed_pending_message (pa->pm); + free_pending_acknowledgement (pa); } @@ -5824,25 +5878,25 @@ handle_acknowledged(struct PendingAcknowledgement *pa, * @return #GNUNET_Ok if @a ra is well-formed */ static int -check_reliability_ack(void *cls, - const struct TransportReliabilityAckMessage *ra) +check_reliability_ack (void *cls, + const struct TransportReliabilityAckMessage *ra) { unsigned int n_acks; - (void)cls; - n_acks = (ntohs(ra->header.size) - sizeof(*ra)) / - sizeof(struct TransportCummulativeAckPayloadP); + (void) cls; + n_acks = (ntohs (ra->header.size) - sizeof(*ra)) + / sizeof(struct TransportCummulativeAckPayloadP); if (0 == n_acks) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } - if ((ntohs(ra->header.size) - sizeof(*ra)) != + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } + if ((ntohs (ra->header.size) - sizeof(*ra)) != n_acks * sizeof(struct TransportCummulativeAckPayloadP)) - { - GNUNET_break_op(0); - return GNUNET_SYSERR; - } + { + GNUNET_break_op (0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -5855,46 +5909,46 @@ check_reliability_ack(void *cls, * @param ra the message that was received */ static void -handle_reliability_ack(void *cls, - const struct TransportReliabilityAckMessage *ra) +handle_reliability_ack (void *cls, + const struct TransportReliabilityAckMessage *ra) { struct CommunicatorMessageContext *cmc = cls; const struct TransportCummulativeAckPayloadP *ack; unsigned int n_acks; uint32_t ack_counter; - n_acks = (ntohs(ra->header.size) - sizeof(*ra)) / - sizeof(struct TransportCummulativeAckPayloadP); - ack = (const struct TransportCummulativeAckPayloadP *)&ra[1]; + n_acks = (ntohs (ra->header.size) - sizeof(*ra)) + / sizeof(struct TransportCummulativeAckPayloadP); + ack = (const struct TransportCummulativeAckPayloadP *) &ra[1]; for (unsigned int i = 0; i < n_acks; i++) - { - struct PendingAcknowledgement *pa = - GNUNET_CONTAINER_multiuuidmap_get(pending_acks, &ack[i].ack_uuid.value); - if (NULL == pa) - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "Received ACK from %s with UUID %s which is unknown to us!\n", - GNUNET_i2s(&cmc->im.sender), - GNUNET_uuid2s(&ack[i].ack_uuid.value)); - GNUNET_STATISTICS_update( - GST_stats, - "# FRAGMENT_ACKS dropped, no matching pending message", - 1, - GNUNET_NO); - continue; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Received ACK from %s with UUID %s\n", - GNUNET_i2s(&cmc->im.sender), - GNUNET_uuid2s(&ack[i].ack_uuid.value)); - handle_acknowledged(pa, GNUNET_TIME_relative_ntoh(ack[i].ack_delay)); + { + struct PendingAcknowledgement *pa = + GNUNET_CONTAINER_multiuuidmap_get (pending_acks, &ack[i].ack_uuid.value); + if (NULL == pa) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Received ACK from %s with UUID %s which is unknown to us!\n", + GNUNET_i2s (&cmc->im.sender), + GNUNET_uuid2s (&ack[i].ack_uuid.value)); + GNUNET_STATISTICS_update ( + GST_stats, + "# FRAGMENT_ACKS dropped, no matching pending message", + 1, + GNUNET_NO); + continue; } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received ACK from %s with UUID %s\n", + GNUNET_i2s (&cmc->im.sender), + GNUNET_uuid2s (&ack[i].ack_uuid.value)); + handle_acknowledged (pa, GNUNET_TIME_relative_ntoh (ack[i].ack_delay)); + } - ack_counter = htonl(ra->ack_counter); - (void)ack_counter; /* silence compiler warning for now */ + ack_counter = htonl (ra->ack_counter); + (void) ack_counter; /* silence compiler warning for now */ // FIXME-OPTIMIZE: track ACK losses based on ack_counter somewhere! // (DV and/o |