naming

diff --git a/src/core/core_api.c b/src/core/core_api.c
index 6a1b881476632497055f88fa97f589a7c8ffa1c6..619a0420f00de94688530a3ae8313a82957664a7 100644 (file)
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -836,7 +836,7 @@ void
 GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
 {
   if (handle->th != NULL)
-    GNUNET_NETWORK_connection_notify_transmit_ready_cancel (handle->th);
+    GNUNET_CONNECTION_notify_transmit_ready_cancel (handle->th);
   if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (handle->sched, handle->reconnect_task);
   GNUNET_CLIENT_disconnect (handle->client);

diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c
index 8a750fd69bfbf5f2084e1c528f44c07e1d92ac9c..eab031f1c39f5f46c51c8b79167ebeca9a35b196 100644 (file)
--- a/src/core/gnunet-service-core.c
+++ b/src/core/gnunet-service-core.c
@@ -1021,7 +1021,7 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
           else
             prev->next = pos->next;
           if (pos->th != NULL)
-            GNUNET_NETWORK_connection_notify_transmit_ready_cancel (pos->th);
+            GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
          while (NULL != (e = pos->event_head))
            {
              pos->event_head = e->next;

diff --git a/src/include/gnunet_client_lib.h b/src/include/gnunet_client_lib.h
index eb75e8d1ec6e91a7ca96b4678d49c9e541e16644..4ac993deac5404c1f5b2db662f764e8f53b4786e 100644 (file)
--- a/src/include/gnunet_client_lib.h
+++ b/src/include/gnunet_client_lib.h
@@ -109,7 +109,7 @@ void GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
  * @param notify_cls closure for notify
  * @return NULL if someone else is already waiting to be notified
  *         non-NULL if the notify callback was queued (can be used to cancel
- *         using GNUNET_NETWORK_connection_notify_transmit_ready_cancel)
+ *         using GNUNET_CONNECTION_notify_transmit_ready_cancel)
  */
 struct GNUNET_NETWORK_TransmitHandle
   *GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,

diff --git a/src/include/gnunet_connection_lib.h b/src/include/gnunet_connection_lib.h
index 69bd7d4a610339db82fe7aeed91c8d751b11b574..34f6bd8a2e7530bcf75b0ab23f5126100929868a 100644 (file)
--- a/src/include/gnunet_connection_lib.h
+++ b/src/include/gnunet_connection_lib.h
@@ -95,7 +95,7 @@ typedef void (*GNUNET_NETWORK_Receiver) (void *cls,
  * @return the boxed socket handle\r
  */\r
 struct GNUNET_NETWORK_ConnectionHandle\r
-  *GNUNET_NETWORK_connection_create_from_existing (struct\r
+  *GNUNET_CONNECTION_create_from_existing (struct\r
                                                    GNUNET_SCHEDULER_Handle\r
                                                    *sched,\r
                                                    struct\r
@@ -116,7 +116,7 @@ struct GNUNET_NETWORK_ConnectionHandle
  * @return the socket handle, NULL on error (for example, access refused)\r
  */\r
 struct GNUNET_NETWORK_ConnectionHandle\r
-  *GNUNET_NETWORK_connection_create_from_accept (struct\r
+  *GNUNET_CONNECTION_create_from_accept (struct\r
                                                  GNUNET_SCHEDULER_Handle\r
                                                  *sched,\r
                                                  GNUNET_NETWORK_AccessCheck\r
@@ -139,7 +139,7 @@ struct GNUNET_NETWORK_ConnectionHandle
  * @return the socket handle\r
  */\r
 struct GNUNET_NETWORK_ConnectionHandle\r
-  *GNUNET_NETWORK_connection_create_from_connect (struct\r
+  *GNUNET_CONNECTION_create_from_connect (struct\r
                                                   GNUNET_SCHEDULER_Handle\r
                                                   *sched,\r
                                                   const char *hostname,\r
@@ -162,7 +162,7 @@ struct GNUNET_NETWORK_ConnectionHandle
  * @return the socket handle\r
  */\r
 struct GNUNET_NETWORK_ConnectionHandle\r
-  *GNUNET_NETWORK_connection_create_from_sockaddr (struct\r
+  *GNUNET_CONNECTION_create_from_sockaddr (struct\r
                                                    GNUNET_SCHEDULER_Handle\r
                                                    *sched, int af_family,\r
                                                    const struct sockaddr\r
@@ -178,7 +178,7 @@ struct GNUNET_NETWORK_ConnectionHandle
  * @param sock socket to check\r
  * @return GNUNET_YES if valid, GNUNET_NO otherwise\r
  */\r
-int GNUNET_NETWORK_connection_check (struct GNUNET_NETWORK_ConnectionHandle\r
+int GNUNET_CONNECTION_check (struct GNUNET_NETWORK_ConnectionHandle\r
                                      *sock);\r
 \r
 \r
@@ -190,7 +190,7 @@ int GNUNET_NETWORK_connection_check (struct GNUNET_NETWORK_ConnectionHandle
  * @param addrlen where to store the length of the address\r
  * @return GNUNET_OK on success\r
  */\r
-int GNUNET_NETWORK_connection_get_address (struct\r
+int GNUNET_CONNECTION_get_address (struct\r
                                            GNUNET_NETWORK_ConnectionHandle\r
                                            *sock, void **addr,\r
                                            size_t * addrlen);\r
@@ -202,7 +202,7 @@ int GNUNET_NETWORK_connection_get_address (struct
  *\r
  * @param sock socket to destroy\r
  */\r
-void GNUNET_NETWORK_connection_destroy (struct GNUNET_NETWORK_ConnectionHandle\r
+void GNUNET_CONNECTION_destroy (struct GNUNET_NETWORK_ConnectionHandle\r
                                         *sock);\r
 \r
 \r
@@ -221,7 +221,7 @@ void GNUNET_NETWORK_connection_destroy (struct GNUNET_NETWORK_ConnectionHandle
  * @return scheduler task ID used for receiving, GNUNET_SCHEDULER_NO_TASK on error\r
  */\r
 GNUNET_SCHEDULER_TaskIdentifier\r
-GNUNET_NETWORK_connection_receive (struct GNUNET_NETWORK_ConnectionHandle\r
+GNUNET_CONNECTION_receive (struct GNUNET_NETWORK_ConnectionHandle\r
                                    *sock, size_t max,\r
                                    struct GNUNET_TIME_Relative timeout,\r
                                    GNUNET_NETWORK_Receiver receiver,\r
@@ -237,7 +237,7 @@ GNUNET_NETWORK_connection_receive (struct GNUNET_NETWORK_ConnectionHandle
  * @param task task identifier returned from the receive call\r
  * @return closure of the original receiver callback\r
  */\r
-void *GNUNET_NETWORK_connection_receive_cancel (struct\r
+void *GNUNET_CONNECTION_receive_cancel (struct\r
                                                 GNUNET_NETWORK_ConnectionHandle\r
                                                 *sock,\r
                                                 GNUNET_SCHEDULER_TaskIdentifier\r
@@ -295,7 +295,7 @@ struct GNUNET_NETWORK_TransmitHandle;
  *         NULL if we are already going to notify someone else (busy)\r
  */\r
 struct GNUNET_NETWORK_TransmitHandle\r
-  *GNUNET_NETWORK_connection_notify_transmit_ready (struct\r
+  *GNUNET_CONNECTION_notify_transmit_ready (struct\r
                                                     GNUNET_NETWORK_ConnectionHandle\r
                                                     *sock, size_t size,\r
                                                     struct\r
@@ -312,7 +312,7 @@ struct GNUNET_NETWORK_TransmitHandle
  * @param h handle for notification to cancel\r
  */\r
 void\r
-GNUNET_NETWORK_connection_notify_transmit_ready_cancel (struct\r
+GNUNET_CONNECTION_notify_transmit_ready_cancel (struct\r
                                                         GNUNET_NETWORK_TransmitHandle\r
                                                         *h);\r
 \r

diff --git a/src/include/gnunet_server_lib.h b/src/include/gnunet_server_lib.h
index 092bab40be9650a29f8778a3d718ead5566f2ef7..f62a409ce2b63c35afe2f66c00b940b04079de6c 100644 (file)
--- a/src/include/gnunet_server_lib.h
+++ b/src/include/gnunet_server_lib.h
@@ -175,7 +175,7 @@ GNUNET_SERVER_add_handlers (struct GNUNET_SERVER_Handle *server,
  * @param callback_cls closure for callback
  * @return non-NULL if the notify callback was queued; can be used
  *           to cancel the request using
- *           GNUNET_NETWORK_connection_notify_transmit_ready_cancel.
+ *           GNUNET_CONNECTION_notify_transmit_ready_cancel.
  *         NULL if we are already going to notify someone else (busy)
  */
 struct GNUNET_NETWORK_TransmitHandle

diff --git a/src/transport/plugin_transport_tcp.c b/src/transport/plugin_transport_tcp.c
index 2e174f80acf9259f2110eb07c5275382c3ed4053..feab67195f9d816fb2870c4ef098a6750959695f 100644 (file)
--- a/src/transport/plugin_transport_tcp.c
+++ b/src/transport/plugin_transport_tcp.c
@@ -665,7 +665,7 @@ connect_and_create_validation_session (struct Plugin *plugin,
       GNUNET_break_op (0);
       return NULL;              /* invalid address */
     }
-  conn = GNUNET_NETWORK_connection_create_from_sockaddr (plugin->env->sched,
+  conn = GNUNET_CONNECTION_create_from_sockaddr (plugin->env->sched,
                                                      af,
                                                      addr,
                                                      addrlen,
@@ -796,7 +796,7 @@ disconnect_session (struct Session *session)
   /* clean up state */
   if (session->transmit_handle != NULL)
     {
-      GNUNET_NETWORK_connection_notify_transmit_ready_cancel (session->transmit_handle);
+      GNUNET_CONNECTION_notify_transmit_ready_cancel (session->transmit_handle);
       session->transmit_handle = NULL;
     }
   while (NULL != (pm = session->pending_messages))
@@ -923,7 +923,7 @@ try_connect_to_address (void *cls,
     {
       cc->welcome = create_welcome (addrlen, addr, cc->plugin);
       cc->sa =
-        GNUNET_NETWORK_connection_create_from_sockaddr (cc->plugin->env->sched,
+        GNUNET_CONNECTION_create_from_sockaddr (cc->plugin->env->sched,
                                                     af, addr, addrlen,
                                                     GNUNET_SERVER_MAX_MESSAGE_SIZE);
 #if DEBUG_TCP

diff --git a/src/transport/transport_api.c b/src/transport/transport_api.c
index 93efcb4ba623bab9a6e42c87ec2bb2405defd866..451b66c1285c224763eed7808ee00d69f15dc522 100644 (file)
--- a/src/transport/transport_api.c
+++ b/src/transport/transport_api.c
@@ -1573,7 +1573,7 @@ demultiplexer (void *cls, const struct GNUNET_MessageHeader *msg)
 #endif
           if (h->network_handle != NULL)
             {
-              GNUNET_NETWORK_connection_notify_transmit_ready_cancel (h->network_handle);
+              GNUNET_CONNECTION_notify_transmit_ready_cancel (h->network_handle);
               h->network_handle = NULL;
               h->transmission_scheduled = GNUNET_NO;
              th = h->connect_ready_head;
@@ -1964,7 +1964,7 @@ GNUNET_TRANSPORT_notify_transmit_ready_cancel (struct
   h = th->handle;
   if ((h->connect_ready_head == NULL) && (h->network_handle != NULL))
     {
-      GNUNET_NETWORK_connection_notify_transmit_ready_cancel (h->network_handle);
+      GNUNET_CONNECTION_notify_transmit_ready_cancel (h->network_handle);
       h->network_handle = NULL;
       h->transmission_scheduled = GNUNET_NO;
     }

diff --git a/src/util/client.c b/src/util/client.c
index 4e6e09066fe2ae5072ec0c0de14c152a021df94d..9836b3e7908296314b0e5813df315bd862786b39 100644 (file)
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -147,7 +147,7 @@ GNUNET_CLIENT_connect (struct GNUNET_SCHEDULER_Handle *sched,
                   service_name);
       return NULL;
     }
-  sock = GNUNET_NETWORK_connection_create_from_connect (sched,
+  sock = GNUNET_CONNECTION_create_from_connect (sched,
                                                     hostname,
                                                     port,
                                                     GNUNET_SERVER_MAX_MESSAGE_SIZE);
@@ -184,7 +184,7 @@ void
 GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock)
 {
   GNUNET_assert (sock->sock != NULL);
-  GNUNET_NETWORK_connection_destroy (sock->sock);
+  GNUNET_CONNECTION_destroy (sock->sock);
   sock->sock = NULL;
   sock->receiver_handler = NULL;
   GNUNET_SCHEDULER_add_after (sock->sched,
@@ -331,7 +331,7 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
                                                       GNUNET_SCHEDULER_NO_TASK,
                                                       &receive_task, sock);
   else
-    sock->receiver_task = GNUNET_NETWORK_connection_receive (sock->sock,
+    sock->receiver_task = GNUNET_CONNECTION_receive (sock->sock,
                                                   GNUNET_SERVER_MAX_MESSAGE_SIZE,
                                                   timeout,
                                                   &receive_helper, sock);
@@ -362,7 +362,7 @@ write_shutdown (void *cls, size_t size, void *buf)
 void
 GNUNET_CLIENT_service_shutdown (struct GNUNET_CLIENT_Connection *sock)
 {
-  GNUNET_NETWORK_connection_notify_transmit_ready (sock->sock,
+  GNUNET_CONNECTION_notify_transmit_ready (sock->sock,
                                         sizeof (struct GNUNET_MessageHeader),
                                         GNUNET_TIME_UNIT_FOREVER_REL,
                                         &write_shutdown, NULL);
@@ -478,7 +478,7 @@ GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
   conn->test_cb = task;
   conn->test_cb_cls = task_cls;
   if (NULL ==
-      GNUNET_NETWORK_connection_notify_transmit_ready (conn->sock,
+      GNUNET_CONNECTION_notify_transmit_ready (conn->sock,
                                             sizeof (struct
                                                     GNUNET_MessageHeader),
                                             timeout, &write_test, NULL))
@@ -515,7 +515,7 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
                                      GNUNET_NETWORK_TransmitReadyNotify
                                      notify, void *notify_cls)
 {
-  return GNUNET_NETWORK_connection_notify_transmit_ready (sock->sock,
+  return GNUNET_CONNECTION_notify_transmit_ready (sock->sock,
                                                size,
                                                timeout, notify, notify_cls);
 }

diff --git a/src/util/network.c b/src/util/network.c
index 6d8b9f9382cb34731a01d0b919669b31dd4475dc..02d9e5dfdffef8706b8ff6d6162d065efd2361bb 100644 (file)
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -167,7 +167,7 @@ struct GNUNET_NETWORK_ConnectionHandle
   GNUNET_SCHEDULER_TaskIdentifier write_task;
 
   /**
-   * The handle we return for GNUNET_NETWORK_connection_notify_transmit_ready.
+   * The handle we return for GNUNET_CONNECTION_notify_transmit_ready.
    */
   struct GNUNET_NETWORK_TransmitHandle nth;
 
@@ -218,7 +218,7 @@ struct GNUNET_NETWORK_ConnectionHandle
  * @return the boxed socket handle
  */
 struct GNUNET_NETWORK_ConnectionHandle *
-GNUNET_NETWORK_connection_create_from_existing (struct GNUNET_SCHEDULER_Handle
+GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
                                             *sched, struct GNUNET_NETWORK_Descriptor *osSocket,
                                             size_t maxbuf)
 {
@@ -245,7 +245,7 @@ GNUNET_NETWORK_connection_create_from_existing (struct GNUNET_SCHEDULER_Handle
  * @return the socket handle, NULL on error
  */
 struct GNUNET_NETWORK_ConnectionHandle *
-GNUNET_NETWORK_connection_create_from_accept (struct GNUNET_SCHEDULER_Handle
+GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
                                           *sched,
                                           GNUNET_NETWORK_AccessCheck access,
                                           void *access_cls, struct GNUNET_NETWORK_Descriptor *lsock,
@@ -338,7 +338,7 @@ GNUNET_NETWORK_connection_create_from_accept (struct GNUNET_SCHEDULER_Handle
  * @return GNUNET_OK on success
  */
 int
-GNUNET_NETWORK_connection_get_address (struct GNUNET_NETWORK_ConnectionHandle *sock,
+GNUNET_CONNECTION_get_address (struct GNUNET_NETWORK_ConnectionHandle *sock,
                                    void **addr, size_t * addrlen)
 {
   if ((sock->addr == NULL) || (sock->addrlen == 0))
@@ -546,7 +546,7 @@ connect_continuation (void *cls,
  * @return the socket handle
  */
 struct GNUNET_NETWORK_ConnectionHandle *
-GNUNET_NETWORK_connection_create_from_connect (struct GNUNET_SCHEDULER_Handle
+GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle
                                            *sched, const char *hostname,
                                            uint16_t port, size_t maxbuf)
 {
@@ -593,7 +593,7 @@ GNUNET_NETWORK_connection_create_from_connect (struct GNUNET_SCHEDULER_Handle
  * @return the socket handle
  */
 struct GNUNET_NETWORK_ConnectionHandle *
-GNUNET_NETWORK_connection_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
+GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
                                             *sched, int af_family,
                                             const struct sockaddr *serv_addr,
                                             socklen_t addrlen, size_t maxbuf)
@@ -634,7 +634,7 @@ GNUNET_NETWORK_connection_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
       GNUNET_break (0 == GNUNET_NETWORK_socket_close (s));
       return NULL;
     }
-  ret = GNUNET_NETWORK_connection_create_from_existing (sched, s, maxbuf);
+  ret = GNUNET_CONNECTION_create_from_existing (sched, s, maxbuf);
   ret->addr = GNUNET_malloc (addrlen);
   memcpy (ret->addr, serv_addr, addrlen);
   ret->addrlen = addrlen;
@@ -651,7 +651,7 @@ GNUNET_NETWORK_connection_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
  * @return GNUNET_YES if valid, GNUNET_NO otherwise
  */
 int
-GNUNET_NETWORK_connection_check (struct GNUNET_NETWORK_ConnectionHandle *sock)
+GNUNET_CONNECTION_check (struct GNUNET_NETWORK_ConnectionHandle *sock)
 {
   if (sock->ai != NULL)
     return GNUNET_YES;          /* still trying to connect */
@@ -723,7 +723,7 @@ destroy_continuation (void *cls,
  * @param sock socket to destroy
  */
 void
-GNUNET_NETWORK_connection_destroy (struct GNUNET_NETWORK_ConnectionHandle *sock)
+GNUNET_CONNECTION_destroy (struct GNUNET_NETWORK_ConnectionHandle *sock)
 {
   if (sock->write_buffer_off == 0)
     sock->ai_pos = NULL;        /* if we're still trying to connect and have
@@ -911,7 +911,7 @@ receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return scheduler task ID used for receiving, GNUNET_SCHEDULER_NO_TASK on error
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_NETWORK_connection_receive (struct GNUNET_NETWORK_ConnectionHandle *sock,
+GNUNET_CONNECTION_receive (struct GNUNET_NETWORK_ConnectionHandle *sock,
                         size_t max,
                         struct GNUNET_TIME_Relative timeout,
                         GNUNET_NETWORK_Receiver receiver, void *receiver_cls)
@@ -942,7 +942,7 @@ GNUNET_NETWORK_connection_receive (struct GNUNET_NETWORK_ConnectionHandle *sock,
  * @return closure of the original receiver callback
  */
 void *
-GNUNET_NETWORK_connection_receive_cancel (struct GNUNET_NETWORK_ConnectionHandle *sock,
+GNUNET_CONNECTION_receive_cancel (struct GNUNET_NETWORK_ConnectionHandle *sock,
                                GNUNET_SCHEDULER_TaskIdentifier task)
 {
   GNUNET_assert (sock->read_task == task);
@@ -1164,7 +1164,7 @@ SCHEDULE_WRITE:
  *         NULL if we are already going to notify someone else (busy)
  */
 struct GNUNET_NETWORK_TransmitHandle *
-GNUNET_NETWORK_connection_notify_transmit_ready (struct GNUNET_NETWORK_ConnectionHandle
+GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_NETWORK_ConnectionHandle
                                       *sock, size_t size,
                                       struct GNUNET_TIME_Relative timeout,
                                       GNUNET_NETWORK_TransmitReadyNotify
@@ -1228,7 +1228,7 @@ GNUNET_NETWORK_connection_notify_transmit_ready (struct GNUNET_NETWORK_Connectio
  * notification.
  */
 void
-GNUNET_NETWORK_connection_notify_transmit_ready_cancel (struct
+GNUNET_CONNECTION_notify_transmit_ready_cancel (struct
                                              GNUNET_NETWORK_TransmitHandle *h)
 {
   GNUNET_assert (h->notify_ready != NULL);

diff --git a/src/util/server.c b/src/util/server.c
index ff9ea993de2e6b3309313590ff7aba95581d7bf3..e8683dce8a1654e9b429a84e41527a8e3f92e2aa 100644 (file)
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -331,7 +331,7 @@ process_listen_socket (void *cls,
   shutpipe = GNUNET_DISK_pipe_handle (server->shutpipe, 0);
   GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready, server->listen_socket));
   GNUNET_assert (!GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, shutpipe));
-  sock = GNUNET_NETWORK_connection_create_from_accept (tc->sched,
+  sock = GNUNET_CONNECTION_create_from_accept (tc->sched,
                                                    server->access,
                                                    server->access_cls,
                                                    server->listen_socket,
@@ -870,7 +870,7 @@ sock_receive (void *cls,
               struct GNUNET_TIME_Relative timeout,
               GNUNET_NETWORK_Receiver receiver, void *receiver_cls)
 {
-  return GNUNET_NETWORK_connection_receive (cls, max, timeout, receiver, receiver_cls);
+  return GNUNET_CONNECTION_receive (cls, max, timeout, receiver, receiver_cls);
 }
 
 
@@ -878,12 +878,12 @@ sock_receive (void *cls,
  * Wrapper to cancel receiving from a socket.
  * 
  * @param cls handle to the GNUNET_NETWORK_ConnectionHandle to cancel
- * @param tc task ID that was returned by GNUNET_NETWORK_connection_receive
+ * @param tc task ID that was returned by GNUNET_CONNECTION_receive
  */
 static void
 sock_receive_cancel (void *cls, GNUNET_SCHEDULER_TaskIdentifier ti)
 {
-  GNUNET_NETWORK_connection_receive_cancel (cls, ti);
+  GNUNET_CONNECTION_receive_cancel (cls, ti);
 }
 
 
@@ -897,7 +897,7 @@ sock_notify_transmit_ready (void *cls,
                             GNUNET_NETWORK_TransmitReadyNotify notify,
                             void *notify_cls)
 {
-  return GNUNET_NETWORK_connection_notify_transmit_ready (cls, size, timeout, notify,
+  return GNUNET_CONNECTION_notify_transmit_ready (cls, size, timeout, notify,
                                                notify_cls);
 }
 
@@ -908,7 +908,7 @@ sock_notify_transmit_ready (void *cls,
 static void
 sock_notify_transmit_ready_cancel (void *cls, void *h)
 {
-  GNUNET_NETWORK_connection_notify_transmit_ready_cancel (h);
+  GNUNET_CONNECTION_notify_transmit_ready_cancel (h);
 }
 
 
@@ -921,7 +921,7 @@ sock_notify_transmit_ready_cancel (void *cls, void *h)
 static int
 sock_check (void *cls)
 {
-  return GNUNET_NETWORK_connection_check (cls);
+  return GNUNET_CONNECTION_check (cls);
 }
 
 
@@ -933,7 +933,7 @@ sock_check (void *cls)
 static void
 sock_destroy (void *cls)
 {
-  GNUNET_NETWORK_connection_destroy (cls);
+  GNUNET_CONNECTION_destroy (cls);
 }
 
 
@@ -1067,7 +1067,7 @@ GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client *client,
 {
   if (client->receive != &sock_receive)
     return GNUNET_SYSERR;       /* not a network client */
-  return GNUNET_NETWORK_connection_get_address (client->client_closure,
+  return GNUNET_CONNECTION_get_address (client->client_closure,
                                             addr, addrlen);
 }
 
@@ -1130,7 +1130,7 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
  * @param callback_cls closure for callback
  * @return non-NULL if the notify callback was queued; can be used
  *           to cancel the request using
- *           GNUNET_NETWORK_connection_notify_transmit_ready_cancel.
+ *           GNUNET_CONNECTION_notify_transmit_ready_cancel.
  *         NULL if we are already going to notify someone else (busy)
  */
 struct GNUNET_NETWORK_TransmitHandle *

diff --git a/src/util/test_network.c b/src/util/test_network.c
index 6f09c4fcecea3deaa6d6b1139054fefce801cced..b628a18db5416fe9897635bc18f5d33c7a3997c6 100644 (file)
--- a/src/util/test_network.c
+++ b/src/util/test_network.c
@@ -88,7 +88,7 @@ receive_check (void *cls,
 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receive needs more data\n");
 #endif
-      GNUNET_NETWORK_connection_receive (asock,
+      GNUNET_CONNECTION_receive (asock,
                               1024,
                               GNUNET_TIME_relative_multiply
                               (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
@@ -101,7 +101,7 @@ receive_check (void *cls,
                   "Receive closes accepted socket\n");
 #endif
       *ok = 0;
-      GNUNET_NETWORK_connection_destroy (asock);
+      GNUNET_CONNECTION_destroy (asock);
     }
 }
 
@@ -112,19 +112,19 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test accepts connection\n");
 #endif
-  asock = GNUNET_NETWORK_connection_create_from_accept (tc->sched,
+  asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
                                                     NULL, NULL, ls, 1024);
   GNUNET_assert (asock != NULL);
-  GNUNET_assert (GNUNET_YES == GNUNET_NETWORK_connection_check (asock));
+  GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test destroys listen socket\n");
 #endif
-  GNUNET_NETWORK_connection_destroy (lsock);
+  GNUNET_CONNECTION_destroy (lsock);
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Test asks to receive on accepted socket\n");
 #endif
-  GNUNET_NETWORK_connection_receive (asock,
+  GNUNET_CONNECTION_receive (asock,
                           1024,
                           GNUNET_TIME_relative_multiply
                           (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check, cls);
@@ -146,23 +146,23 @@ static void
 task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ls = open_listen_socket ();
-  lsock = GNUNET_NETWORK_connection_create_from_existing (tc->sched, ls, 0);
+  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
   GNUNET_assert (lsock != NULL);
-  csock = GNUNET_NETWORK_connection_create_from_connect (tc->sched,
+  csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
                                                      "localhost", PORT, 1024);
   GNUNET_assert (csock != NULL);
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test asks for write notification\n");
 #endif
   GNUNET_assert (NULL !=
-                 GNUNET_NETWORK_connection_notify_transmit_ready (csock,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock,
                                                        12,
                                                        GNUNET_TIME_UNIT_SECONDS,
                                                        &make_hello, NULL));
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test destroys client socket\n");
 #endif
-  GNUNET_NETWORK_connection_destroy (csock);
+  GNUNET_CONNECTION_destroy (csock);
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n");
 #endif

diff --git a/src/util/test_network_addressing.c b/src/util/test_network_addressing.c
index a2682a7333f108fc1208976bc25619515073e942..177810eae6bebcc29a50fbccb44d7ff74290d173 100644 (file)
--- a/src/util/test_network_addressing.c
+++ b/src/util/test_network_addressing.c
@@ -82,7 +82,7 @@ receive_check (void *cls,
     sofar += available;
   if (sofar < 12)
     {
-      GNUNET_NETWORK_connection_receive (asock,
+      GNUNET_CONNECTION_receive (asock,
                               1024,
                               GNUNET_TIME_relative_multiply
                               (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
@@ -91,7 +91,7 @@ receive_check (void *cls,
   else
     {
       *ok = 0;
-      GNUNET_NETWORK_connection_destroy (asock);
+      GNUNET_CONNECTION_destroy (asock);
     }
 }
 
@@ -104,12 +104,12 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct sockaddr_in *v4;
   struct sockaddr_in expect;
 
-  asock = GNUNET_NETWORK_connection_create_from_accept (tc->sched,
+  asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
                                                     NULL, NULL, ls, 1024);
   GNUNET_assert (asock != NULL);
-  GNUNET_assert (GNUNET_YES == GNUNET_NETWORK_connection_check (asock));
+  GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_NETWORK_connection_get_address (asock, &addr, &alen));
+                 GNUNET_CONNECTION_get_address (asock, &addr, &alen));
   GNUNET_assert (alen == sizeof (struct sockaddr_in));
   v4 = addr;
   memset (&expect, 0, sizeof (expect));
@@ -118,8 +118,8 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   expect.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
   GNUNET_assert (0 == memcmp (&expect, v4, alen));
   GNUNET_free (addr);
-  GNUNET_NETWORK_connection_destroy (lsock);
-  GNUNET_NETWORK_connection_receive (asock,
+  GNUNET_CONNECTION_destroy (lsock);
+  GNUNET_CONNECTION_receive (asock,
                           1024,
                           GNUNET_TIME_relative_multiply
                           (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check, cls);
@@ -138,24 +138,24 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct sockaddr_in v4;
   ls = open_listen_socket ();
-  lsock = GNUNET_NETWORK_connection_create_from_existing (tc->sched, ls, 0);
+  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
   GNUNET_assert (lsock != NULL);
 
   v4.sin_family = AF_INET;
   v4.sin_port = htons (PORT);
   v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
-  csock = GNUNET_NETWORK_connection_create_from_sockaddr (tc->sched,
+  csock = GNUNET_CONNECTION_create_from_sockaddr (tc->sched,
                                                       AF_INET,
                                                       (const struct sockaddr
                                                        *) &v4, sizeof (v4),
                                                       1024);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
-                 GNUNET_NETWORK_connection_notify_transmit_ready (csock,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock,
                                                        12,
                                                        GNUNET_TIME_UNIT_SECONDS,
                                                        &make_hello, NULL));
-  GNUNET_NETWORK_connection_destroy (csock);
+  GNUNET_CONNECTION_destroy (csock);
   GNUNET_SCHEDULER_add_read_net (tc->sched,
                              GNUNET_NO,
                              GNUNET_SCHEDULER_PRIORITY_HIGH,

diff --git a/src/util/test_network_receive_cancel.c b/src/util/test_network_receive_cancel.c
index 1a3cb4866066424c7c73a6b50e615cb70d139a8c..a9834c0e2635b3f08bc749c76ebf2c51b732c48f 100644 (file)
--- a/src/util/test_network_receive_cancel.c
+++ b/src/util/test_network_receive_cancel.c
@@ -85,13 +85,13 @@ static void
 run_accept_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 
-  asock = GNUNET_NETWORK_connection_create_from_accept (tc->sched,
+  asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
                                                     NULL, NULL, ls, 1024);
   GNUNET_assert (asock != NULL);
-  GNUNET_assert (GNUNET_YES == GNUNET_NETWORK_connection_check (asock));
-  GNUNET_NETWORK_connection_destroy (lsock);
+  GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
+  GNUNET_CONNECTION_destroy (lsock);
   receive_task
-    = GNUNET_NETWORK_connection_receive (asock,
+    = GNUNET_CONNECTION_receive (asock,
                               1024,
                               GNUNET_TIME_relative_multiply
                               (GNUNET_TIME_UNIT_SECONDS, 5), &dead_receive,
@@ -103,9 +103,9 @@ static void
 receive_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   int *ok = cls;
-  GNUNET_NETWORK_connection_receive_cancel (asock, receive_task);
-  GNUNET_NETWORK_connection_destroy (csock);
-  GNUNET_NETWORK_connection_destroy (asock);
+  GNUNET_CONNECTION_receive_cancel (asock, receive_task);
+  GNUNET_CONNECTION_destroy (csock);
+  GNUNET_CONNECTION_destroy (asock);
   *ok = 0;
 }
 
@@ -115,9 +115,9 @@ static void
 task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ls = open_listen_socket ();
-  lsock = GNUNET_NETWORK_connection_create_from_existing (tc->sched, ls, 0);
+  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
   GNUNET_assert (lsock != NULL);
-  csock = GNUNET_NETWORK_connection_create_from_connect (tc->sched,
+  csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
                                                      "localhost", PORT, 1024);
   GNUNET_assert (csock != NULL);
   GNUNET_SCHEDULER_add_read_net (tc->sched,

diff --git a/src/util/test_network_timeout.c b/src/util/test_network_timeout.c
index 442775463c5823e452c7dd3cfc633abe2543d76d..ef39ac2a1c98d3875c061c8859c1c20dae0f1d84 100644 (file)
--- a/src/util/test_network_timeout.c
+++ b/src/util/test_network_timeout.c
@@ -74,8 +74,8 @@ send_kilo (void *cls, size_t size, void *buf)
 #endif
       GNUNET_assert (buf == NULL);
       *ok = 0;
-      GNUNET_NETWORK_connection_destroy (lsock);
-      GNUNET_NETWORK_connection_destroy (csock);
+      GNUNET_CONNECTION_destroy (lsock);
+      GNUNET_CONNECTION_destroy (csock);
       return 0;
     }
 #if VERBOSE
@@ -85,7 +85,7 @@ send_kilo (void *cls, size_t size, void *buf)
   memset (buf, 42, 1024);
 
   GNUNET_assert (NULL !=
-                 GNUNET_NETWORK_connection_notify_transmit_ready (csock,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock,
                                                        1024,
                                                        GNUNET_TIME_UNIT_SECONDS,
                                                        &send_kilo, cls));
@@ -98,13 +98,13 @@ task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 
   ls = open_listen_socket ();
-  lsock = GNUNET_NETWORK_connection_create_from_existing (tc->sched, ls, 0);
+  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls, 0);
   GNUNET_assert (lsock != NULL);
-  csock = GNUNET_NETWORK_connection_create_from_connect (tc->sched,
+  csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
                                                      "localhost", PORT, 1024);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
-                 GNUNET_NETWORK_connection_notify_transmit_ready (csock,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock,
                                                        1024,
                                                        GNUNET_TIME_UNIT_SECONDS,
                                                        &send_kilo, cls));

diff --git a/src/util/test_network_timeout_no_connect.c b/src/util/test_network_timeout_no_connect.c
index 902edd2fa411fb15f38440718882080dc42adc93..823216104f196cf2693ec90ad4ffc896e7fddf0b 100644 (file)
--- a/src/util/test_network_timeout_no_connect.c
+++ b/src/util/test_network_timeout_no_connect.c
@@ -51,11 +51,11 @@ handle_timeout (void *cls, size_t size, void *buf)
 static void
 task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  csock = GNUNET_NETWORK_connection_create_from_connect (tc->sched,
+  csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
                                                      "localhost", PORT, 1024);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
-                 GNUNET_NETWORK_connection_notify_transmit_ready (csock,
+                 GNUNET_CONNECTION_notify_transmit_ready (csock,
                                                        1024,
                                                        GNUNET_TIME_UNIT_SECONDS,
                                                        &handle_timeout, cls));

diff --git a/src/util/test_network_transmit_cancel.c b/src/util/test_network_transmit_cancel.c
index c46fecd2247157816752e588f8508a36b77d09df..edc45bb9f11c84d80ca5ee4bfdd2089b898f2041 100644 (file)
--- a/src/util/test_network_transmit_cancel.c
+++ b/src/util/test_network_transmit_cancel.c
@@ -48,15 +48,15 @@ task_transmit_cancel (void *cls,
   struct GNUNET_NETWORK_TransmitHandle *th;
   struct GNUNET_NETWORK_ConnectionHandle *csock;
 
-  csock = GNUNET_NETWORK_connection_create_from_connect (tc->sched,
+  csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
                                                      "localhost", PORT, 1024);
   GNUNET_assert (csock != NULL);
-  th = GNUNET_NETWORK_connection_notify_transmit_ready (csock,
+  th = GNUNET_CONNECTION_notify_transmit_ready (csock,
                                              12,
                                              GNUNET_TIME_UNIT_MINUTES,
                                              &not_run, cls);
-  GNUNET_NETWORK_connection_notify_transmit_ready_cancel (th);
-  GNUNET_NETWORK_connection_destroy (csock);
+  GNUNET_CONNECTION_notify_transmit_ready_cancel (th);
+  GNUNET_CONNECTION_destroy (csock);
   *ok = 0;
 }