Diff [ef689ef0053c82c87f31cd2ea039a68dc6004d89:a7a85d16a8c965959d2a721c191833e692d098ed] for / – HelenOS

uspace/lib/c/include/net/icmp_api.h

ref689ef0	ra7a85d16
44	44
45	45	#include <adt/measured_strings.h>
46		~~#include <net/packet.h>~~
47	46	#include <net/ip_codes.h>
48	47	#include <net/icmp_codes.h>

uspace/lib/net/adt/module_map.c

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup net
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  Character string to module map implementation.
+ * Character string to module map implementation.
  */
 …
 GENERIC_CHAR_MAP_IMPLEMENT(modules, module_t)
+int add_module(module_ref * module, modules_ref modules, const char * name, const char * filename, services_t service, task_id_t task_id, connect_module_t connect_module){
+/** Adds module to the module map.
+ *
+ * @param[out] module   The module structure added.
+ * @param[in] modules   The module map.
+ * @param[in] name      The module name.
+ * @param[in] filename  The full path filename.
+ * @param[in] service   The module service.
+ * @param[in] task_id   The module current task identifier. Zero means not
+ *                      running.
+ * @param[in] connect_module The module connecting function.
+ * @returns             EOK on success.
+ * @returns             ENOMEM if there is not enough memory left.
+ */
+int
+add_module(module_ref *module, modules_ref modules, const char *name,
+    const char *filename, services_t service, task_id_t task_id,
+    connect_module_t connect_module)
+{
         ERROR_DECLARE;
 …
         tmp_module = (module_ref) malloc(sizeof(module_t));
         if(! tmp_module){
+        if (!tmp_module)
                 return ENOMEM;
+        }
         tmp_module->task_id = task_id;
         tmp_module->phone = 0;
 …
         tmp_module->service = service;
         tmp_module->connect_module = connect_module;
+        if(ERROR_OCCURRED(modules_add(modules, tmp_module->name, 0, tmp_module))){
+        if (ERROR_OCCURRED(modules_add(modules, tmp_module->name, 0,
+            tmp_module))) {
                 free(tmp_module);
                 return ERROR_CODE;
+        }
         if(module){
+        if (module)
                 *module = tmp_module;
+        }
         return EOK;
+}
+module_ref get_running_module(modules_ref modules, char * name){
+/** Searches and returns the specified module.
+ *
+ * If the module is not running, the module filaname is spawned.
+ * If the module is not connected, the connect_function is called.
+ *
+ * @param[in] modules   The module map.
+ * @param[in] name      The module name.
+ * @returns             The running module found. It does not have to be
+ *                      connected.
+ * @returns             NULL if there is no such module.
+ */
+module_ref get_running_module(modules_ref modules, char *name)
+{
         module_ref module;
         module = modules_find(modules, name, 0);
         if(! module){
+        if (!module)
                 return NULL;
+        if (!module->task_id) {
+                module->task_id = spawn(module->filename);
+                if (!module->task_id)
+                        return NULL;
+        }
+        if(! module->task_id){
+                module->task_id = spawn(module->filename);
+                if(! module->task_id){
+                        return NULL;
+                }
+        }
+        if(! module->phone){
+        if (!module->phone)
                 module->phone = module->connect_module(module->service);
+        }
         return module;
+}
+/** Starts the given module.
+ *
+ * @param[in] fname     The module full or relative path filename.
+ * @returns             The new module task identifier on success.
+ * @returns             Zero if there is no such module.
+ */
 task_id_t spawn(const char *fname)
+{

uspace/lib/net/generic/generic.c

ref689ef0	ra7a85d16
27	27	*/
28	28
29		/** @addtogroup net
	29	/** @addtogroup libnet
30	30	* @{
31	31	*/

uspace/lib/net/generic/net_checksum.c

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup net
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  General CRC and checksum computation implementation.
+ * General CRC and checksum computation implementation.
  */
 …
 #include <net_checksum.h>
+/** Big-endian encoding CRC divider.
+ */
+#define CRC_DIVIDER_BE  0x04C11DB7
+/** Little-endian encoding CRC divider.
+ */
+#define CRC_DIVIDER_LE  0xEDB88320
+uint16_t compact_checksum(uint32_t sum){
+/** Big-endian encoding CRC divider. */
+#define CRC_DIVIDER_BE  0x04c11db7
+/** Little-endian encoding CRC divider. */
+#define CRC_DIVIDER_LE  0xedb88320
+/** Compacts the computed checksum to the 16 bit number adding the carries.
+ *
+ * @param[in] sum       Computed checksum.
+ * @returns             Compacted computed checksum to the 16 bits.
+ */
+uint16_t compact_checksum(uint32_t sum)
+{
         // shorten to the 16 bits
+        while(sum >> 16){
+                sum = (sum &0xFFFF) + (sum >> 16);
+        }
+        while (sum >> 16)
+                sum = (sum & 0xffff) + (sum >> 16);
         return (uint16_t) sum;
+}
+uint32_t compute_checksum(uint32_t seed, uint8_t * data, size_t length){
+/** Computes sum of the 2 byte fields.
+ *
+ * Padds one zero (0) byte if odd.
+ *
+ * @param[in] seed      Initial value. Often used as 0 or ~0.
+ * @param[in] data      Pointer to the beginning of data to process.
+ * @param[in] length    Length of the data in bytes.
+ * @returns             The computed checksum of the length bytes of the data.
+ */
+uint32_t compute_checksum(uint32_t seed, uint8_t *data, size_t length)
+{
         size_t index;
         // sum all the 16 bit fields
         for(index = 0; index + 1 < length; index += 2){
+        for (index = 0; index + 1 < length; index += 2)
                 seed += (data[index] << 8) + data[index + 1];
+        }
         // last odd byte with zero padding
         if(index + 1 == length){
+        if (index + 1 == length)
                 seed += data[index] << 8;
+        }
         return seed;
+}
+uint32_t compute_crc32_be(uint32_t seed, uint8_t * data, size_t length){
+/** Computes CRC32 value in the big-endian environment.
+ *
+ * @param[in] seed      Initial value. Often used as 0 or ~0.
+ * @param[in] data      Pointer to the beginning of data to process.
+ * @param[in] length    Length of the data in bits.
+ * @returns             The computed CRC32 of the length bits of the data.
+ */
+uint32_t compute_crc32_be(uint32_t seed, uint8_t * data, size_t length)
+{
         size_t index;
         // process full bytes
         while(length >= 8){
+        while (length >= 8) {
                 // add the data
                 seed ^= (*data) << 24;
                 // for each added bit
                 for(index = 0; index < 8; ++ index){
+                for (index = 0; index < 8; ++index) {
                         // if the first bit is set
                         if(seed &0x80000000){
+                        if (seed & 0x80000000) {
                                 // shift and divide the checksum
                                 seed = (seed << 1) ^ ((uint32_t) CRC_DIVIDER_BE);
                         }else{
+                        } else {
                                 // shift otherwise
                                 seed <<= 1;
+                        }
+                }
                 // move to the next byte
                 ++ data;
+                ++data;
                 length -= 8;
+        }
         // process the odd bits
         if(length > 0){
+        if (length > 0) {
                 // add the data with zero padding
+                seed ^= ((*data) &(0xFF << (8 - length))) << 24;
+                seed ^= ((*data) & (0xff << (8 - length))) << 24;
                 // for each added bit
                 for(index = 0; index < length; ++ index){
+                for (index = 0; index < length; ++index) {
                         // if the first bit is set
                         if(seed &0x80000000){
+                        if (seed & 0x80000000) {
                                 // shift and divide the checksum
                                 seed = (seed << 1) ^ ((uint32_t) CRC_DIVIDER_BE);
                         }else{
+                        } else {
                                 // shift otherwise
                                 seed <<= 1;
 …
+}
+uint32_t compute_crc32_le(uint32_t seed, uint8_t * data, size_t length){
+/** Computes CRC32 value in the little-endian environment.
+ *
+ * @param[in] seed      Initial value. Often used as 0 or ~0.
+ * @param[in] data      Pointer to the beginning of data to process.
+ * @param[in] length    Length of the data in bits.
+ * @returns             The computed CRC32 of the length bits of the data.
+ */
+uint32_t compute_crc32_le(uint32_t seed, uint8_t * data, size_t length)
+{
         size_t index;
         // process full bytes
         while(length >= 8){
+        while (length >= 8) {
                 // add the data
                 seed ^= (*data);
                 // for each added bit
                 for(index = 0; index < 8; ++ index){
+                for (index = 0; index < 8; ++index) {
                         // if the last bit is set
                         if(seed &1){
+                        if (seed & 1) {
                                 // shift and divide the checksum
                                 seed = (seed >> 1) ^ ((uint32_t) CRC_DIVIDER_LE);
                         }else{
+                        } else {
                                 // shift otherwise
                                 seed >>= 1;
+                        }
+                }
                 // move to the next byte
                 ++ data;
+                ++data;
                 length -= 8;
+        }
         // process the odd bits
         if(length > 0){
+        if (length > 0) {
                 // add the data with zero padding
                 seed ^= (*data) >> (8 - length);
+                for(index = 0; index < length; ++ index){
+                for (index = 0; index < length; ++index) {
                         // if the last bit is set
                         if(seed &1){
+                        if (seed & 1) {
                                 // shift and divide the checksum
                                 seed = (seed >> 1) ^ ((uint32_t) CRC_DIVIDER_LE);
                         }else{
+                        } else {
                                 // shift otherwise
                                 seed >>= 1;
 …
+}
+uint16_t flip_checksum(uint16_t checksum){
+/** Returns or flips the checksum if zero.
+ *
+ * @param[in] checksum  The computed checksum.
+ * @returns             The internet protocol header checksum.
+ * @returns             0xFFFF if the computed checksum is zero.
+ */
+uint16_t flip_checksum(uint16_t checksum)
+{
         // flip, zero is returned as 0xFFFF (not flipped)
         checksum = ~ checksum;
+        checksum = ~checksum;
         return checksum ? checksum : IP_CHECKSUM_ZERO;
+}
+uint16_t ip_checksum(uint8_t * data, size_t length){
+/** Computes the ip header checksum.
+ *
+ * To compute the checksum of a new packet, the checksum header field must be
+ * zero. To check the checksum of a received packet, the checksum may be left
+ * set. Zero will be returned in this case if valid.
+ *
+ * @param[in] data      The header data.
+ * @param[in] length    The header length in bytes.
+ * @returns             The internet protocol header checksum.
+ * @returns             0xFFFF if the computed checksum is zero.
+ */
+uint16_t ip_checksum(uint8_t *data, size_t length)
+{
         // compute, compact and flip the data checksum
+        return flip_checksum(compact_checksum(compute_checksum(0, data, length)));
+        return flip_checksum(compact_checksum(compute_checksum(0, data,
+            length)));
+}

uspace/lib/net/generic/net_remote.c

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup net
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  Networking interface implementation for remote modules.
  *  @see net_interface.h
+ * Networking interface implementation for remote modules.
+ * @see net_interface.h
  */
 #include <ipc/services.h>
+#include <ipc/net_net.h>
 #include <malloc.h>
 …
 #include <net_interface.h>
 #include <adt/measured_strings.h>
-#include <net_net_messages.h>
+int net_connect_module(services_t service)
+/** Connects to the networking module.
+ *
+ * @returns             The networking module phone on success.
+ */
+int net_connect_module(void)
+{
         return connect_to_service(SERVICE_NETWORKING);
+}
+void net_free_settings(measured_string_ref settings, char * data)
+/** Frees the received settings.
+ *
+ * @param[in] settings  The received settings.
+ * @param[in] data      The received settings data.
+ * @see net_get_device_conf_req()
+ * @see net_get_conf_req()
+ */
+void net_free_settings(measured_string_ref settings, char *data)
+{
         if (settings)
                 free(settings);
         if (data)
                 free(data);
+}
+/** Returns the global configuration.
+ *
+ * The configuration names are read and the appropriate settings are set
+ * instead. Call net_free_settings() function to release the returned
+ * configuration.
+ *
+ * @param[in] net_phone The networking module phone.
+ * @param[in,out] configuration The requested configuration. The names are read
+ * and the appropriate settings are set instead.
+ *
+ * @param[in] count     The configuration entries count.
+ * @param[in,out] data  The configuration and settings data.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the configuration is NULL.
+ * @returns             EINVAL if the count is zero.
+ * @returns             Other error codes as defined for the
+ *                      generic_translate_req() function.
+ */
 int
 net_get_conf_req(int net_phone, measured_string_ref * configuration,
     size_t count, char ** data)
+net_get_conf_req(int net_phone, measured_string_ref *configuration,
+    size_t count, char **data)
+{
         return generic_translate_req(net_phone, NET_NET_GET_DEVICE_CONF, 0, 0,
 …
+}
+/** Returns the device specific configuration.
+ *
+ * Returns the global configuration if the device specific is not found.
+ * The configuration names are read and the appropriate settings are set
+ * instead. Call net_free_settings() function to release the returned
+ * configuration.
+ *
+ * @param[in] net_phone The networking module phone.
+ * @param[in] device_id The device identifier.
+ * @param[in,out] configuration The requested device configuration. The names
+ *                      are read and the appropriate settings are set instead.
+ * @param[in] count     The configuration entries count.
+ * @param[in,out] data  The configuration and settings data.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the configuration is NULL.
+ * @returns             EINVAL if the count is zero.
+ * @returns             Other error codes as defined for the
+ *                      generic_translate_req() function.
+ */
 int
 net_get_device_conf_req(int net_phone, device_id_t device_id,
     measured_string_ref * configuration, size_t count, char ** data)
+    measured_string_ref *configuration, size_t count, char **data)
+{
         return generic_translate_req(net_phone, NET_NET_GET_DEVICE_CONF,

uspace/lib/net/generic/packet_client.c

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup packet
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  Packet client implementation.
+ * Packet client implementation.
  */
 …
 #include <mem.h>
 #include <unistd.h>
 #include <sys/mman.h>
 #include <packet_client.h>
+#include <packet_remote.h>
 #include <net/packet.h>
 #include <net/packet_header.h>
+int packet_copy_data(packet_t packet, const void * data, size_t length)
+/** Copies the specified data to the beginning of the actual packet content.
+ *
+ * Pushes the content end if needed.
+ *
+ * @param[in] packet    The packet to be filled.
+ * @param[in] data      The data to be copied.
+ * @param[in] length    The length of the copied data.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the packet is not valid.
+ * @returns             ENOMEM if there is not enough memory left.
+ */
+int packet_copy_data(packet_t packet, const void *data, size_t length)
+{
         if (!packet_is_valid(packet))
 …
+}
+/** Allocates the specified space right before the actual packet content and
+ * returns its pointer.
+ *
+ * @param[in] packet    The packet to be used.
+ * @param[in] length    The space length to be allocated at the beginning of the
+ *                      packet content.
+ * @returns             The pointer to the allocated memory.
+ * @returns             NULL if there is not enough memory left.
+ */
 void *packet_prefix(packet_t packet, size_t length)
+{
 …
+}
+/** Allocates the specified space right after the actual packet content and
+ * returns its pointer.
+ *
+ * @param[in] packet    The packet to be used.
+ * @param[in] length    The space length to be allocated at the end of the
+ *                       packet content.
+ * @returns             The pointer to the allocated memory.
+ * @returns             NULL if there is not enough memory left.
+ */
 void *packet_suffix(packet_t packet, size_t length)
+{
 …
+}
+/** Trims the actual packet content by the specified prefix and suffix lengths.
+ *
+ * @param[in] packet    The packet to be trimmed.
+ * @param[in] prefix    The prefix length to be removed from the beginning of
+ *                      the packet content.
+ * @param[in] suffix    The suffix length to be removed from the end of the
+ *                      packet content.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the packet is not valid.
+ * @returns             ENOMEM if there is not enough memory left.
+ */
 int packet_trim(packet_t packet, size_t prefix, size_t suffix)
+{
 …
+}
+/** Returns the packet identifier.
+ *
+ * @param[in] packet    The packet.
+ * @returns             The packet identifier.
+ * @returns             Zero if the packet is not valid.
+ */
 packet_id_t packet_get_id(const packet_t packet)
+{
 …
+}
+int packet_get_addr(const packet_t packet, uint8_t ** src, uint8_t ** dest)
+/** Returns the stored packet addresses and their length.
+ *
+ * @param[in] packet    The packet.
+ * @param[out] src      The source address. May be NULL if not desired.
+ * @param[out] dest     The destination address. May be NULL if not desired.
+ * @returns             The stored addresses length.
+ * @returns             Zero if the addresses are not present.
+ * @returns             EINVAL if the packet is not valid.
+ */
+int packet_get_addr(const packet_t packet, uint8_t **src, uint8_t **dest)
+{
         if (!packet_is_valid(packet))
 …
+}
+/** Returns the packet content length.
+ *
+ * @param[in] packet    The packet.
+ * @returns             The packet content length in bytes.
+ * @returns             Zero if the packet is not valid.
+ */
 size_t packet_get_data_length(const packet_t packet)
+{
 …
+}
+/** Returns the pointer to the beginning of the packet content.
+ *
+ * @param[in] packet    The packet.
+ * @returns             The pointer to the beginning of the packet content.
+ * @returns             NULL if the packet is not valid.
+ */
 void *packet_get_data(const packet_t packet)
+{
 …
+}
+/** Sets the packet addresses.
+ *
+ * @param[in] packet    The packet.
+ * @param[in] src       The new source address. May be NULL.
+ * @param[in] dest      The new destination address. May be NULL.
+ * @param[in] addr_len  The addresses length.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the packet is not valid.
+ * @returns             ENOMEM if there is not enough memory left.
+ */
 int
 packet_set_addr(packet_t packet, const uint8_t * src, const uint8_t * dest,
+packet_set_addr(packet_t packet, const uint8_t *src, const uint8_t *dest,
     size_t addr_len)
+{
 …
+}
+/** Returns the packet copy.
+ *
+ * Copies the addresses, data, order and metric values.
+ * Does not copy the queue placement.
+ *
+ * @param[in] phone     The packet server module phone.
+ * @param[in] packet    The original packet.
+ * @returns             The packet copy.
+ * @returns             NULL on error.
+ */
 packet_t packet_get_copy(int phone, packet_t packet)
+{

uspace/lib/net/generic/packet_remote.c

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup packet
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  Packet client interface implementation for remote modules.
  *  @see packet_client.h
+ * Packet client interface implementation for remote modules.
+ * @see packet_client.h
  */
 …
+}
+/** Translates the packet identifier to the packet reference.
+ *
+ * Tries to find mapping first.
+ * Contacts the packet server to share the packet if the mapping is not present.
+ *
+ * @param[in] phone     The packet server module phone.
+ * @param[out] packet   The packet reference.
+ * @param[in] packet_id The packet identifier.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the packet parameter is NULL.
+ * @returns             Other error codes as defined for the NET_PACKET_GET_SIZE
+ *                      message.
+ * @returns             Other error codes as defined for the packet_return()
+ *                      function.
+ */
 int packet_translate_remote(int phone, packet_ref packet, packet_id_t packet_id)
+{
 …
+}
+/** Obtains the packet of the given dimensions.
+ *
+ * Contacts the packet server to return the appropriate packet.
+ *
+ * @param[in] phone     The packet server module phone.
+ * @param[in] addr_len  The source and destination addresses maximal length in
+ *                      bytes.
+ * @param[in] max_prefix The maximal prefix length in bytes.
+ * @param[in] max_content The maximal content length in bytes.
+ * @param[in] max_suffix The maximal suffix length in bytes.
+ * @returns             The packet reference.
+ * @returns             NULL on error.
+ */
 packet_t packet_get_4_remote(int phone, size_t max_content, size_t addr_len,
     size_t max_prefix, size_t max_suffix)
 …
+}
+/** Obtains the packet of the given content size.
+ *
+ * Contacts the packet server to return the appropriate packet.
+ *
+ * @param[in] phone     The packet server module phone.
+ * @param[in] content   The maximal content length in bytes.
+ * @returns             The packet reference.
+ * @returns             NULL on error.
+ */
 packet_t packet_get_1_remote(int phone, size_t content)
+{
 …
+}
+/** Releases the packet queue.
+ *
+ * All packets in the queue are marked as free for use.
+ * The packet queue may be one packet only.
+ * The module should not use the packets after this point until they are
+ * received or obtained again.
+ *
+ * @param[in] phone     The packet server module phone.
+ * @param[in] packet_id The packet identifier.
+ */
 void pq_release_remote(int phone, packet_id_t packet_id)
+{

uspace/lib/net/generic/socket_core.c

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup socket
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
+ *  Socket common core implementation.
+ */
+ * Socket common core implementation.
+ */
+#include <socket_core.h>
+#include <packet_client.h>
+#include <packet_remote.h>
 #include <net/socket_codes.h>
 #include <net/in.h>
 #include <net/inet.h>
+#include <net/packet.h>
+#include <net/modules.h>
 #include <stdint.h>
 …
 #include <adt/dynamic_fifo.h>
 #include <adt/int_map.h>
+#include <net/packet.h>
+#include <packet_client.h>
+#include <packet_remote.h>
+#include <net/modules.h>
+#include <socket_core.h>
+/** Maximum number of random attempts to find a new socket identifier before switching to the sequence.
+ */
+#define SOCKET_ID_TRIES                                 100
+/** Bound port sockets.
+ */
+struct socket_port{
+        /** The bound sockets map.
+         */
+/**
+ * Maximum number of random attempts to find a new socket identifier before
+ * switching to the sequence.
+ */
+#define SOCKET_ID_TRIES 100
+/** Bound port sockets.*/
+struct socket_port {
+        /** The bound sockets map. */
         socket_port_map_t map;
+        /** The bound sockets count.
+         */
+        /** The bound sockets count. */
         int count;
 };
 …
 /** Destroys the socket.
+ *  If the socket is bound, the port is released.
+ *  Releases all buffered packets, calls the release function and removes the socket from the local sockets.
+ *  @param[in] packet_phone The packet server phone to release buffered packets.
+ *  @param[in] socket The socket to be destroyed.
+ *  @param[in,out] local_sockets The local sockets to be updated.
+ *  @param[in,out] global_sockets The global sockets to be updated.
+ *  @param[in] socket_release The client release callback function.
+ */
+static void socket_destroy_core(int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
+ *
+ * If the socket is bound, the port is released.
+ * Releases all buffered packets, calls the release function and removes the
+ * socket from the local sockets.
+ *
+ * @param[in] packet_phone The packet server phone to release buffered packets.
+ * @param[in] socket    The socket to be destroyed.
+ * @param[in,out] local_sockets The local sockets to be updated.
+ * @param[in,out] global_sockets The global sockets to be updated.
+ * @param[in] socket_release The client release callback function.
+ */
+static void
+socket_destroy_core(int packet_phone, socket_core_ref socket,
+    socket_cores_ref local_sockets, socket_ports_ref global_sockets,
+    void (* socket_release)(socket_core_ref socket))
+{
         int packet_id;
         // if bound
         if(socket->port){
+        if (socket->port) {
                 // release the port
                 socket_port_release(global_sockets, socket);
+        }
         // release all received packets
         while((packet_id = dyn_fifo_pop(&socket->received)) >= 0){
+        while ((packet_id = dyn_fifo_pop(&socket->received)) >= 0)
                 pq_release_remote(packet_phone, packet_id);
+        }
         dyn_fifo_destroy(&socket->received);
         dyn_fifo_destroy(&socket->accepted);
+        if(socket_release){
+        if (socket_release)
                 socket_release(socket);
+        }
         socket_cores_exclude(local_sockets, socket->socket_id);
+}
+void socket_cores_release(int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
+        if(socket_cores_is_valid(local_sockets)){
+                int index;
+                local_sockets->magic = 0;
+                for(index = 0; index < local_sockets->next; ++ index){
+                        if(socket_cores_item_is_valid(&(local_sockets->items[index]))){
+                                local_sockets->items[index].magic = 0;
+                                if(local_sockets->items[index].value){
+                                        socket_destroy_core(packet_phone, local_sockets->items[index].value, local_sockets, global_sockets, socket_release);
+                                        free(local_sockets->items[index].value);
+                                        local_sockets->items[index].value = NULL;
+                                }
+/** Destroys local sockets.
+ *
+ * Releases all buffered packets and calls the release function for each of the
+ * sockets.
+ *
+ * @param[in] packet_phone The packet server phone to release buffered packets.
+ * @param[in] local_sockets The local sockets to be destroyed.
+ * @param[in,out] global_sockets The global sockets to be updated.
+ * @param[in] socket_release The client release callback function.
+ */
+void
+socket_cores_release(int packet_phone, socket_cores_ref local_sockets,
+    socket_ports_ref global_sockets,
+    void (* socket_release)(socket_core_ref socket))
+{
+        int index;
+        if (!socket_cores_is_valid(local_sockets))
+                return;
+        local_sockets->magic = 0;
+        for (index = 0; index < local_sockets->next; ++index) {
+                if (socket_cores_item_is_valid(&local_sockets->items[index])) {
+                        local_sockets->items[index].magic = 0;
+                        if (local_sockets->items[index].value) {
+                                socket_destroy_core(packet_phone,
+                                    local_sockets->items[index].value,
+                                    local_sockets, global_sockets,
+                                    socket_release);
+                                free(local_sockets->items[index].value);
+                                local_sockets->items[index].value = NULL;
+                        }
+                }
+                free(local_sockets->items);
+        }
+        }
+        free(local_sockets->items);
+}
 /** Adds the socket to a socket port.
+ *  @param[in,out] socket_port The socket port structure.
+ *  @param[in] socket The socket to be added.
+ *  @param[in] key The socket key identifier.
+ *  @param[in] key_length The socket key length.
+ *  @returns EOK on success.
+ *  @returns ENOMEM if there is not enough memory left.
+ */
+static int socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length){
+ *
+ * @param[in,out] socket_port The socket port structure.
+ * @param[in] socket    The socket to be added.
+ * @param[in] key       The socket key identifier.
+ * @param[in] key_length The socket key length.
+ * @returns             EOK on success.
+ * @returns             ENOMEM if there is not enough memory left.
+ */
+static int
+socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket,
+    const char *key, size_t key_length)
+{
         ERROR_DECLARE;
         socket_core_ref * socket_ref;
+        socket_core_ref *socket_ref;
         // create a wrapper
         socket_ref = malloc(sizeof(*socket_ref));
         if(! socket_ref){
+        if (!socket_ref)
                 return ENOMEM;
+        }
         *socket_ref = socket;
         // add the wrapper
+        if(ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key, key_length, socket_ref))){
+        if (ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key,
+            key_length, socket_ref))) {
                 free(socket_ref);
                 return ERROR_CODE;
+        }
+        ++ socket_port->count;
+        ++socket_port->count;
         socket->key = key;
         socket->key_length = key_length;
         return EOK;
+}
 /** Binds the socket to the port.
+ *  The SOCKET_MAP_KEY_LISTENING key identifier is used.
+ *  @param[in] global_sockets The global sockets to be updated.
+ *  @param[in] socket The socket to be added.
+ *  @param[in] port The port number to be bound to.
+ *  @returns EOK on success.
+ *  @returns ENOMEM if there is not enough memory left.
+ *  @returns Other error codes as defined for the socket_ports_add() function.
+ */
+static int socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket, int port){
+ *
+ * The SOCKET_MAP_KEY_LISTENING key identifier is used.
+ *
+ * @param[in] global_sockets The global sockets to be updated.
+ * @param[in] socket    The socket to be added.
+ * @param[in] port      The port number to be bound to.
+ * @returns             EOK on success.
+ * @returns             ENOMEM if there is not enough memory left.
+ * @returns             Other error codes as defined for the
+ *                       socket_ports_add() function.
+ */
+static int
+socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket,
+    int port)
+{
         ERROR_DECLARE;
 …
         // create a wrapper
         socket_port = malloc(sizeof(*socket_port));
         if(! socket_port){
+        if (!socket_port)
                 return ENOMEM;
+        }
         socket_port->count = 0;
+        if(ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map))
+                || ERROR_OCCURRED(socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING, 0))){
+        if (ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map)) ||
+            ERROR_OCCURRED(socket_port_add_core(socket_port, socket,
+            SOCKET_MAP_KEY_LISTENING, 0))) {
                 socket_port_map_destroy(&socket_port->map);
                 free(socket_port);
                 return ERROR_CODE;
+        }
         // register the incomming port
         ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
         if(ERROR_CODE < 0){
+        if (ERROR_CODE < 0) {
                 socket_port_map_destroy(&socket_port->map);
                 free(socket_port);
                 return ERROR_CODE;
+        }
         socket->port = port;
         return EOK;
+}
+int socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port){
+/** Binds the socket to the port.
+ *
+ * The address port is used if set, a free port is used if not.
+ *
+ * @param[in] local_sockets The local sockets to be searched.
+ * @param[in,out] global_sockets The global sockets to be updated.
+ * @param[in] socket_id The new socket identifier.
+ * @param[in] addr      The address to be bound to.
+ * @param[in] addrlen   The address length.
+ * @param[in] free_ports_start The minimum free port.
+ * @param[in] free_ports_end The maximum free port.
+ * @param[in] last_used_port The last used free port.
+ * @returns             EOK on success.
+ * @returns             ENOTSOCK if the socket was not found.
+ * @returns             EAFNOSUPPORT if the address family is not supported.
+ * @returns             EADDRINUSE if the port is already in use.
+ * @returns             Other error codes as defined for the
+ *                      socket_bind_free_port() function.
+ * @returns             Other error codes as defined for the
+ *                      socket_bind_insert() function.
+ */
+int
+socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets,
+    int socket_id, void *addr, size_t addrlen, int free_ports_start,
+    int free_ports_end, int last_used_port)
+{
         socket_core_ref socket;
         socket_port_ref socket_port;
         struct sockaddr * address;
         struct sockaddr_in * address_in;
         if(addrlen < sizeof(struct sockaddr)){
+        struct sockaddr *address;
+        struct sockaddr_in *address_in;
+        if (addrlen < sizeof(struct sockaddr))
                 return EINVAL;
+        }
         address = (struct sockaddr *) addr;
+        switch(address->sa_family){
+                case AF_INET:
+                        if(addrlen != sizeof(struct sockaddr_in)){
+                                return EINVAL;
+                        }
+                        address_in = (struct sockaddr_in *) addr;
+                        // find the socket
+                        socket = socket_cores_find(local_sockets, socket_id);
+                        if(! socket){
+                                return ENOTSOCK;
+                        }
+                        // bind a free port?
+                        if(address_in->sin_port <= 0){
+                                return socket_bind_free_port(global_sockets, socket, free_ports_start, free_ports_end, last_used_port);
+                        }
+                        // try to find the port
+                        socket_port = socket_ports_find(global_sockets, ntohs(address_in->sin_port));
+                        if(socket_port){
+                                // already used
+                                return EADDRINUSE;
+                        }
+                        // if bound
+                        if(socket->port){
+                                // release the port
+                                socket_port_release(global_sockets, socket);
+                        }
+                        socket->port = -1;
+                        return socket_bind_insert(global_sockets, socket, ntohs(address_in->sin_port));
+                        break;
+        switch (address->sa_family) {
+        case AF_INET:
+                if (addrlen != sizeof(struct sockaddr_in))
+                        return EINVAL;
+                address_in = (struct sockaddr_in *) addr;
+                // find the socket
+                socket = socket_cores_find(local_sockets, socket_id);
+                if (!socket)
+                        return ENOTSOCK;
+                // bind a free port?
+                if (address_in->sin_port <= 0)
+                        return socket_bind_free_port(global_sockets, socket,
+                             free_ports_start, free_ports_end, last_used_port);
+                // try to find the port
+                socket_port = socket_ports_find(global_sockets,
+                    ntohs(address_in->sin_port));
+                if (socket_port) {
+                        // already used
+                        return EADDRINUSE;
+                }
+                // if bound
+                if (socket->port) {
+                        // release the port
+                        socket_port_release(global_sockets, socket);
+                }
+                socket->port = -1;
+                return socket_bind_insert(global_sockets, socket,
+                    ntohs(address_in->sin_port));
+        case AF_INET6:
                 // TODO IPv6
+        }
+                break;
+        }
         return EAFNOSUPPORT;
+}
+int socket_bind_free_port(socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port){
+/** Binds the socket to a free port.
+ *
+ * The first free port is used.
+ *
+ * @param[in,out] global_sockets The global sockets to be updated.
+ * @param[in,out] socket The socket to be bound.
+ * @param[in] free_ports_start The minimum free port.
+ * @param[in] free_ports_end The maximum free port.
+ * @param[in] last_used_port The last used free port.
+ * @returns             EOK on success.
+ * @returns             ENOTCONN if no free port was found.
+ * @returns             Other error codes as defined for the
+ *                      socket_bind_insert() function.
+ */
+int
+socket_bind_free_port(socket_ports_ref global_sockets, socket_core_ref socket,
+    int free_ports_start, int free_ports_end, int last_used_port)
+{
         int index;
         // from the last used one
         index = last_used_port;
+        do{
+                ++ index;
+        do {
+                ++index;
                 // til the range end
                 if(index >= free_ports_end){
+                if (index >= free_ports_end) {
                         // start from the range beginning
                         index = free_ports_start - 1;
                         do{
                                 ++ index;
+                        do {
+                                ++index;
                                 // til the last used one
                                 if(index >= last_used_port){
+                                if (index >= last_used_port) {
                                         // none found
                                         return ENOTCONN;
+                                }
+                        }while(socket_ports_find(global_sockets, index) != NULL);
+                        } while (socket_ports_find(global_sockets, index));
                         // found, break immediately
                         break;
+                }
+        }while(socket_ports_find(global_sockets, index) != NULL);
+        } while (socket_ports_find(global_sockets, index));
         return socket_bind_insert(global_sockets, socket, index);
+}
 /** Tries to find a new free socket identifier.
+ *  @param[in] local_sockets The local sockets to be searched.
+ *  @param[in] positive A value indicating whether a positive identifier is requested. A negative identifier is requested if set to false.
+ *      @returns The new socket identifier.
+ *  @returns ELIMIT if there is no socket identifier available.
+ */
+static int socket_generate_new_id(socket_cores_ref local_sockets, int positive){
+ *
+ * @param[in] local_sockets The local sockets to be searched.
+ * @param[in] positive  A value indicating whether a positive identifier is
+ *                      requested. A negative identifier is requested if set to
+ *                      false.
+ * @returns             The new socket identifier.
+ * @returns             ELIMIT if there is no socket identifier available.
+ */
+static int socket_generate_new_id(socket_cores_ref local_sockets, int positive)
+{
         int socket_id;
         int count;
 …
         count = 0;
 //      socket_id = socket_globals.last_id;
         do{
                 if(count < SOCKET_ID_TRIES){
+        do {
+                if (count < SOCKET_ID_TRIES) {
                         socket_id = rand() % INT_MAX;
                         ++ count;
                 }else if(count == SOCKET_ID_TRIES){
+                        ++count;
+                } else if (count == SOCKET_ID_TRIES) {
                         socket_id = 1;
                         ++ count;
+                        ++count;
                 // only this branch for last_id
                 }else{
                         if(socket_id < INT_MAX){
+                } else {
+                        if (socket_id < INT_MAX) {
                                 ++ socket_id;
 /*                      }else if(socket_globals.last_id){
+/*                      } else if(socket_globals.last_id) {
 *                               socket_globals.last_id = 0;
 *                               socket_id = 1;
 */                      }else{
+*/                      } else {
                                 return ELIMIT;
+                        }
+                }
+        }while(socket_cores_find(local_sockets, ((positive ? 1 : -1) * socket_id)));
+        } while (socket_cores_find(local_sockets,
+            ((positive ? 1 : -1) * socket_id)));
 //      last_id = socket_id
         return socket_id;
+}
+int socket_create(socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id){
+/** Creates a new socket.
+ *
+ * @param[in,out] local_sockets The local sockets to be updated.
+ * @param[in] app_phone The application phone.
+ * @param[in] specific_data The socket specific data.
+ * @param[in,out] socket_id The new socket identifier. A new identifier is
+ *                      chosen if set to zero or negative. A negative identifier
+ *                      is chosen if set to negative.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the socket_id parameter is NULL.
+ * @returns             ENOMEM if there is not enough memory left.
+ */
+int
+socket_create(socket_cores_ref local_sockets, int app_phone,
+    void *specific_data, int *socket_id)
+{
         ERROR_DECLARE;
 …
         int positive;
         if(! socket_id){
+        if (!socket_id)
                 return EINVAL;
+        }
         // store the socket
         if(*socket_id <= 0){
+        if (*socket_id <= 0) {
                 positive = (*socket_id == 0);
                 *socket_id = socket_generate_new_id(local_sockets, positive);
+                if(*socket_id <= 0){
+                        return * socket_id;
+                }
+                if(! positive){
+                if (*socket_id <= 0)
+                        return *socket_id;
+                if (!positive)
                         *socket_id *= -1;
+                }
+        }else if(socket_cores_find(local_sockets, * socket_id)){
+        } else if(socket_cores_find(local_sockets, *socket_id)) {
                 return EEXIST;
+        }
         socket = (socket_core_ref) malloc(sizeof(*socket));
         if(! socket){
+        if (!socket)
                 return ENOMEM;
+        }
         // initialize
         socket->phone = app_phone;
 …
         socket->key_length = 0;
         socket->specific_data = specific_data;
+        if(ERROR_OCCURRED(dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE))){
+        if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->received,
+            SOCKET_INITIAL_RECEIVED_SIZE))) {
                 free(socket);
                 return ERROR_CODE;
+        }
+        if(ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE))){
+        if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted,
+            SOCKET_INITIAL_ACCEPTED_SIZE))) {
                 dyn_fifo_destroy(&socket->received);
                 free(socket);
                 return ERROR_CODE;
+        }
         socket->socket_id = * socket_id;
+        socket->socket_id = *socket_id;
         res = socket_cores_add(local_sockets, socket->socket_id, socket);
         if(res < 0){
+        if (res < 0) {
                 dyn_fifo_destroy(&socket->received);
                 dyn_fifo_destroy(&socket->accepted);
 …
                 return res;
+        }
         return EOK;
+}
+int socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
+/** Destroys the socket.
+ *
+ * If the socket is bound, the port is released.
+ * Releases all buffered packets, calls the release function and removes the
+ * socket from the local sockets.
+ *
+ * @param[in] packet_phone The packet server phone to release buffered packets.
+ * @param[in] socket_id The socket identifier.
+ * @param[in,out] local_sockets The local sockets to be updated.
+ * @param[in,out] global_sockets The global sockets to be updated.
+ * @param[in] socket_release The client release callback function.
+ * @returns             EOK on success.
+ * @returns             ENOTSOCK if the socket is not found.
+ */
+int
+socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets,
+    socket_ports_ref global_sockets,
+    void (*socket_release)(socket_core_ref socket))
+{
         socket_core_ref socket;
         int accepted_id;
 …
         // find the socket
         socket = socket_cores_find(local_sockets, socket_id);
         if(! socket){
+        if (!socket)
                 return ENOTSOCK;
+        }
         // destroy all accepted sockets
+        while((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0){
+                socket_destroy(packet_phone, accepted_id, local_sockets, global_sockets, socket_release);
+        }
+        socket_destroy_core(packet_phone, socket, local_sockets, global_sockets, socket_release);
+        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
+                socket_destroy(packet_phone, accepted_id, local_sockets,
+                    global_sockets, socket_release);
+        socket_destroy_core(packet_phone, socket, local_sockets, global_sockets,
+            socket_release);
         return EOK;
+}
+int socket_reply_packets(packet_t packet, size_t * length){
+/** Replies the packet or the packet queue data to the application via the
+ * socket.
+ *
+ * Uses the current message processing fibril.
+ *
+ * @param[in] packet    The packet to be transfered.
+ * @param[out] length   The total data length.
+ * @returns             EOK on success.
+ * @returns             EBADMEM if the length parameter is NULL.
+ * @returns             ENOMEM if there is not enough memory left.
+ * @returns             Other error codes as defined for the data_reply()
+ *                      function.
+ */
+int socket_reply_packets(packet_t packet, size_t *length)
+{
         ERROR_DECLARE;
         packet_t next_packet;
         size_t fragments;
         size_t * lengths;
+        size_t *lengths;
         size_t index;
         if(! length){
+        if (!length)
                 return EBADMEM;
+        }
         next_packet = pq_next(packet);
         if(! next_packet){
+        if (!next_packet) {
                 // write all if only one fragment
+                ERROR_PROPAGATE(data_reply(packet_get_data(packet), packet_get_data_length(packet)));
+                ERROR_PROPAGATE(data_reply(packet_get_data(packet),
+                    packet_get_data_length(packet)));
                 // store the total length
                 *length = packet_get_data_length(packet);
         }else{
+        } else {
                 // count the packet fragments
                 fragments = 1;
                 next_packet = pq_next(packet);
                 while((next_packet = pq_next(next_packet))){
                         ++ fragments;
+                }
+                while ((next_packet = pq_next(next_packet)))
+                        ++fragments;
                 // compute and store the fragment lengths
+                lengths = (size_t *) malloc(sizeof(size_t) * fragments + sizeof(size_t));
+                if(! lengths){
+                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
+                    sizeof(size_t));
+                if (!lengths)
                         return ENOMEM;
+                }
                 lengths[0] = packet_get_data_length(packet);
                 lengths[fragments] = lengths[0];
                 next_packet = pq_next(packet);
+                for(index = 1; index < fragments; ++ index){
+                for (index = 1; index < fragments; ++index) {
                         lengths[index] = packet_get_data_length(next_packet);
                         lengths[fragments] += lengths[index];
                         next_packet = pq_next(packet);
+                }while(next_packet);
+                }
                 // write the fragment lengths
+                ERROR_PROPAGATE(data_reply(lengths, sizeof(int) * (fragments + 1)));
+                if (ERROR_OCCURRED(data_reply(lengths,
+                    sizeof(int) * (fragments + 1)))) {
+                        free(lengths);
+                        return ERROR_CODE;
+                }
                 next_packet = packet;
                 // write the fragments
+                for(index = 0; index < fragments; ++ index){
+                        ERROR_PROPAGATE(data_reply(packet_get_data(next_packet), lengths[index]));
+                for (index = 0; index < fragments; ++index) {
+                        ERROR_CODE = data_reply(packet_get_data(next_packet),
+                            lengths[index]);
+                        if (ERROR_OCCURRED(ERROR_CODE)) {
+                                free(lengths);
+                                return ERROR_CODE;
+                        }
                         next_packet = pq_next(next_packet);
+                }while(next_packet);
+                }
                 // store the total length
                 *length = lengths[fragments];
                 free(lengths);
+        }
         return EOK;
+}
+socket_core_ref socket_port_find(socket_ports_ref global_sockets, int port, const char * key, size_t key_length){
+/** Finds the bound port socket.
+ *
+ * @param[in] global_sockets The global sockets to be searched.
+ * @param[in] port      The port number.
+ * @param[in] key       The socket key identifier.
+ * @param[in] key_length The socket key length.
+ * @returns             The found socket.
+ * @returns             NULL if no socket was found.
+ */
+socket_core_ref
+socket_port_find(socket_ports_ref global_sockets, int port, const char *key,
+    size_t key_length)
+{
         socket_port_ref socket_port;
         socket_core_ref * socket_ref;
+        socket_core_ref *socket_ref;
         socket_port = socket_ports_find(global_sockets, port);
+        if(socket_port && (socket_port->count > 0)){
+                socket_ref = socket_port_map_find(&socket_port->map, key, key_length);
+                if(socket_ref){
+                        return * socket_ref;
+                }
+        }
+        if (socket_port && (socket_port->count > 0)) {
+                socket_ref = socket_port_map_find(&socket_port->map, key,
+                    key_length);
+                if (socket_ref)
+                        return *socket_ref;
+        }
         return NULL;
+}
+void socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket){
+/** Releases the socket port.
+ *
+ * If the socket is bound the port entry is released.
+ * If there are no more port entries the port is release.
+ *
+ * @param[in] global_sockets The global sockets to be updated.
+ * @param[in] socket    The socket to be unbound.
+ */
+void
+socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket)
+{
         socket_port_ref socket_port;
+        socket_core_ref * socket_ref;
+        if(socket->port){
+                // find ports
+                socket_port = socket_ports_find(global_sockets, socket->port);
+                if(socket_port){
+                        // find the socket
+                        socket_ref = socket_port_map_find(&socket_port->map, socket->key, socket->key_length);
+                        if(socket_ref){
+                                -- socket_port->count;
+                                // release if empty
+                                if(socket_port->count <= 0){
+                                        // destroy the map
+                                        socket_port_map_destroy(&socket_port->map);
+                                        // release the port
+                                        socket_ports_exclude(global_sockets, socket->port);
+                                }else{
+                                        // remove
+                                        socket_port_map_exclude(&socket_port->map, socket->key, socket->key_length);
+                                }
+        socket_core_ref *socket_ref;
+        if (!socket->port)
+                return;
+        // find ports
+        socket_port = socket_ports_find(global_sockets, socket->port);
+        if (socket_port) {
+                // find the socket
+                socket_ref = socket_port_map_find(&socket_port->map,
+                    socket->key, socket->key_length);
+                if (socket_ref) {
+                        --socket_port->count;
+                        // release if empty
+                        if (socket_port->count <= 0) {
+                                // destroy the map
+                                socket_port_map_destroy(&socket_port->map);
+                                // release the port
+                                socket_ports_exclude(global_sockets,
+                                    socket->port);
+                        } else {
+                                // remove
+                                socket_port_map_exclude(&socket_port->map,
+                                    socket->key, socket->key_length);
+                        }
+                }
+                socket->port = 0;
+                socket->key = NULL;
+                socket->key_length = 0;
+        }
+}
+int socket_port_add(socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length){
+        }
+        socket->port = 0;
+        socket->key = NULL;
+        socket->key_length = 0;
+}
+/** Adds the socket to an already bound port.
+ *
+ * @param[in] global_sockets The global sockets to be updated.
+ * @param[in] port      The port number to be bound to.
+ * @param[in] socket    The socket to be added.
+ * @param[in] key       The socket key identifier.
+ * @param[in] key_length The socket key length.
+ * @returns             EOK on success.
+ * @returns             ENOENT if the port is not already used.
+ * @returns             Other error codes as defined for the
+ *                      socket_port_add_core() function.
+ */
+int
+socket_port_add(socket_ports_ref global_sockets, int port,
+    socket_core_ref socket, const char *key, size_t key_length)
+{
         ERROR_DECLARE;
 …
         // find ports
         socket_port = socket_ports_find(global_sockets, port);
         if(! socket_port){
+        if (!socket_port)
                 return ENOENT;
+        }
         // add the socket
+        ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key, key_length));
+        ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key,
+            key_length));
         socket->port = port;
         return EOK;

uspace/lib/net/il/arp_remote.c

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup arp
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  ARP interface implementation for remote modules.
  *  @see arp_interface.h
+ * ARP interface implementation for remote modules.
+ * @see arp_interface.h
  */
 #include <arp_interface.h>
-#include <arp_messages.h>
 #include <generic.h>
 …
 #include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <ipc/arp.h>
 #include <net/modules.h>
 …
 #include <adt/measured_strings.h>
+int arp_connect_module(services_t service){
+        if(service != SERVICE_ARP){
+/** Connects to the ARP module.
+ *
+ * @param service       The ARP module service. Ignored parameter.
+ * @returns             The ARP module phone on success.
+ */
+int arp_connect_module(services_t service)
+{
+        if (service != SERVICE_ARP)
                 return EINVAL;
+        }
         return connect_to_service(SERVICE_ARP);
+}
+int arp_clean_cache_req(int arp_phone){
+/** Cleans the cache.
+ *
+ * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ * @returns             EOK on success.
+ */
+int arp_clean_cache_req(int arp_phone)
+{
         return (int) async_req_0_0(arp_phone, NET_ARP_CLEAN_CACHE);
+}
+int arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address){
+/** Clears the given protocol address from the cache.
+ *
+ * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ * @param[in] device_id The device identifier.
+ * @param[in] protocol  The requesting protocol service.
+ * @param[in] address   The protocol address to be cleared.
+ * @returns             EOK on success.
+ * @returns             ENOENT if the mapping is not found.
+ */
+int
+arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol,
+    measured_string_ref address)
+{
         aid_t message_id;
         ipcarg_t result;
+        message_id = async_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS, (ipcarg_t) device_id, protocol, NULL);
+        message_id = async_send_2(arp_phone, NET_ARP_CLEAR_ADDRESS,
+            (ipcarg_t) device_id, protocol, NULL);
         measured_strings_send(arp_phone, address, 1);
         async_wait_for(message_id, &result);
         return (int) result;
+}
+int arp_clear_device_req(int arp_phone, device_id_t device_id){
+        return (int) async_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE, (ipcarg_t) device_id);
+/** Clears the device cache.
+ *
+ * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ * @param[in] device_id The device identifier.
+ * @returns             EOK on success.
+ * @returns             ENOENT if the device is not found.
+ */
+int arp_clear_device_req(int arp_phone, device_id_t device_id)
+{
+        return (int) async_req_1_0(arp_phone, NET_ARP_CLEAR_DEVICE,
+            (ipcarg_t) device_id);
+}
+int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address){
+/** Registers the new device and the requesting protocol service.
+ *
+ * Connects to the network interface layer service.
+ * Determines the device broadcast address, its address lengths and packet size.
+ *
+ * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ * @param[in] device_id The new device identifier.
+ * @param[in] protocol  The requesting protocol service.
+ * @param[in] netif     The underlying device network interface layer service.
+ * @param[in] address   The local requesting protocol address of the device.
+ * @returns             EOK on success.
+ * @returns             EEXIST if the device is already used.
+ * @returns             ENOMEM if there is not enough memory left.
+ * @returns             ENOENT if the network interface service is not known.
+ * @returns             EREFUSED if the network interface service is not
+ *                      responding.
+ * @returns             Other error codes as defined for the
+ *                      nil_packet_get_size() function.
+ * @returns             Other error codes as defined for the nil_get_addr()
+ *                      function.
+ * @returns             Other error codes as defined for the
+ *                      nil_get_broadcast_addr() function.
+ */
+int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol,
+    services_t netif, measured_string_ref address)
+{
         aid_t message_id;
         ipcarg_t result;
+        message_id = async_send_3(arp_phone, NET_ARP_DEVICE, (ipcarg_t) device_id, protocol, netif, NULL);
+        message_id = async_send_3(arp_phone, NET_ARP_DEVICE,
+            (ipcarg_t) device_id, protocol, netif, NULL);
         measured_strings_send(arp_phone, address, 1);
         async_wait_for(message_id, &result);
         return (int) result;
+}
+task_id_t arp_task_get_id(void){
+        return 0;
+}
+int arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data){
+        return generic_translate_req(arp_phone, NET_ARP_TRANSLATE, device_id, protocol, address, 1, translation, data);
+/** Translates the given protocol address to the network interface address.
+ *
+ * Broadcasts the ARP request if the mapping is not found.
+ * Allocates and returns the needed memory block as the data parameter.
+ *
+ * @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ * @param[in] device_id The device identifier.
+ * @param[in] protocol  The requesting protocol service.
+ * @param[in] address   The local requesting protocol address.
+ * @param[out] translation The translation of the local protocol address.
+ * @param[out] data     The allocated raw translation data container.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the address parameter is NULL.
+ * @returns             EBADMEM if the translation or the data parameters are
+ *                      NULL.
+ * @returns             ENOENT if the mapping is not found.
+ */
+int
+arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol,
+    measured_string_ref address, measured_string_ref *translation, char **data)
+{
+        return generic_translate_req(arp_phone, NET_ARP_TRANSLATE, device_id,
+            protocol, address, 1, translation, data);
+}

uspace/lib/net/il/ip_client.c

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup ip
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  IP client interface implementation.
  *  @see ip_client.h
+ * IP client interface implementation.
+ * @see ip_client.h
  */
 …
 #include <net/packet.h>
+size_t ip_client_header_length(packet_t packet){
+/** Returns the IP header length.
+ *
+ * @param[in] packet    The packet.
+ * @returns             The IP header length in bytes.
+ * @returns             Zero if there is no IP header.
+ */
+size_t ip_client_header_length(packet_t packet)
+{
         ip_header_ref header;
         header = (ip_header_ref) packet_get_data(packet);
+        if((! header)
+                || (packet_get_data_length(packet) < sizeof(ip_header_t))){
+        if (!header || (packet_get_data_length(packet) < sizeof(ip_header_t)))
                 return 0;
+        }
         return IP_HEADER_LENGTH(header);
+}
+int ip_client_get_pseudo_header(ip_protocol_t protocol, struct sockaddr * src, socklen_t srclen, struct sockaddr * dest, socklen_t destlen, size_t data_length, void **header, size_t * headerlen){
+/** Constructs the IPv4 pseudo header.
+ *
+ * @param[in] protocol  The transport protocol.
+ * @param[in] src       The source address.
+ * @param[in] srclen    The source address length.
+ * @param[in] dest      The destination address.
+ * @param[in] destlen   The destination address length.
+ * @param[in] data_length The data length to be set.
+ * @param[out] header   The constructed IPv4 pseudo header.
+ * @param[out] headerlen The length of the IP pseudo header in bytes.
+ * @returns             EOK on success.
+ * @returns             EBADMEM if the header and/or the headerlen parameter is
+ *                      NULL.
+ * @returns             EINVAL if the source address and/or the destination
+ *                      address parameter is NULL.
+ * @returns             EINVAL if the source address length is less than struct
+ *                      sockaddr length.
+ * @returns             EINVAL if the source address length differs from the
+ *                      destination address length.
+ * @returns             EINVAL if the source address family differs from the
+ *                      destination family.
+ * @returns             EAFNOSUPPORT if the address family is not supported.
+ * @returns             ENOMEM if there is not enough memory left.
+ */
+int
+ip_client_get_pseudo_header(ip_protocol_t protocol, struct sockaddr *src,
+    socklen_t srclen, struct sockaddr *dest, socklen_t destlen,
+    size_t data_length, void **header, size_t *headerlen)
+{
         ipv4_pseudo_header_ref header_in;
         struct sockaddr_in * address_in;
         if(!(header && headerlen)){
+        struct sockaddr_in *address_in;
+        if (!header || !headerlen)
                 return EBADMEM;
+        }
+        if(!(src && dest && (srclen > 0) && ((size_t) srclen >= sizeof(struct sockaddr)) && (srclen == destlen) && (src->sa_family == dest->sa_family))){
+        if (!src || !dest || srclen <= 0 ||
+            (((size_t) srclen < sizeof(struct sockaddr))) ||
+            (srclen != destlen) || (src->sa_family != dest->sa_family)) {
                 return EINVAL;
+        }
+        switch(src->sa_family){
+                case AF_INET:
+                        if(srclen != sizeof(struct sockaddr_in)){
+                                return EINVAL;
+                        }
+                        *headerlen = sizeof(*header_in);
+                        header_in = (ipv4_pseudo_header_ref) malloc(*headerlen);
+                        if(! header_in){
+                                return ENOMEM;
+                        }
+                        bzero(header_in, * headerlen);
+                        address_in = (struct sockaddr_in *) dest;
+                        header_in->destination_address = address_in->sin_addr.s_addr;
+                        address_in = (struct sockaddr_in *) src;
+                        header_in->source_address = address_in->sin_addr.s_addr;
+                        header_in->protocol = protocol;
+                        header_in->data_length = htons(data_length);
+                        *header = header_in;
+                        return EOK;
+                // TODO IPv6
+/*              case AF_INET6:
+                        if(addrlen != sizeof(struct sockaddr_in6)){
+                                return EINVAL;
+                        }
+                        address_in6 = (struct sockaddr_in6 *) addr;
+                        return EOK;
+*/              default:
+                        return EAFNOSUPPORT;
+        }
+}
+int ip_client_prepare_packet(packet_t packet, ip_protocol_t protocol, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, size_t ipopt_length){
+        switch (src->sa_family) {
+        case AF_INET:
+                if (srclen != sizeof(struct sockaddr_in))
+                        return EINVAL;
+                *headerlen = sizeof(*header_in);
+                header_in = (ipv4_pseudo_header_ref) malloc(*headerlen);
+                if (!header_in)
+                        return ENOMEM;
+                bzero(header_in, *headerlen);
+                address_in = (struct sockaddr_in *) dest;
+                header_in->destination_address = address_in->sin_addr.s_addr;
+                address_in = (struct sockaddr_in *) src;
+                header_in->source_address = address_in->sin_addr.s_addr;
+                header_in->protocol = protocol;
+                header_in->data_length = htons(data_length);
+                *header = header_in;
+                return EOK;
+        // TODO IPv6
+/*      case AF_INET6:
+                if (addrlen != sizeof(struct sockaddr_in6))
+                        return EINVAL;
+                address_in6 = (struct sockaddr_in6 *) addr;
+                return EOK;
+*/
+        default:
+                return EAFNOSUPPORT;
+        }
+}
+/** Prepares the packet to be transfered via IP.
+ *
+ * The IP header is prefixed.
+ *
+ * @param[in,out] packet The packet to be prepared.
+ * @param[in] protocol  The transport protocol.
+ * @param[in] ttl       The time to live counter. The IPDEFTTL is set if zero.
+ * @param[in] tos       The type of service.
+ * @param[in] dont_fragment The value indicating whether fragmentation is
+ *                      disabled.
+ * @param[in] ipopt_length The prefixed IP options length in bytes.
+ * @returns             EOK on success.
+ * @returns             ENOMEM if there is not enough memory left in the packet.
+ */
+int
+ip_client_prepare_packet(packet_t packet, ip_protocol_t protocol, ip_ttl_t ttl,
+    ip_tos_t tos, int dont_fragment, size_t ipopt_length)
+{
         ip_header_ref header;
         uint8_t * data;
+        uint8_t *data;
         size_t padding;
 …
         // multiple of 4 bytes
         padding =  ipopt_length % 4;
         if(padding){
+        if (padding) {
                 padding = 4 - padding;
                 ipopt_length += padding;
 …
         // prefix the header
         data = (uint8_t *) packet_prefix(packet, sizeof(ip_header_t) + padding);
         if(! data){
+        if (!data)
                 return ENOMEM;
+        }
         // add the padding
         while(padding --){
+        while (padding--)
                 data[sizeof(ip_header_t) + padding] = IPOPT_NOOP;
+        }
         // set the header
         header = (ip_header_ref) data;
+        header->header_length = IP_COMPUTE_HEADER_LENGTH(sizeof(ip_header_t) + ipopt_length);
+        header->ttl = (ttl ? ttl : IPDEFTTL); //(((ttl) <= MAXTTL) ? ttl : MAXTTL) : IPDEFTTL;
+        header->header_length = IP_COMPUTE_HEADER_LENGTH(sizeof(ip_header_t) +
+            ipopt_length);
+        header->ttl = (ttl ? ttl : IPDEFTTL);
         header->tos = tos;
         header->protocol = protocol;
         if(dont_fragment){
+        if (dont_fragment)
                 header->flags = IPFLAG_DONT_FRAGMENT;
+        }
         return EOK;
+}
+int ip_client_process_packet(packet_t packet, ip_protocol_t * protocol, ip_ttl_t * ttl, ip_tos_t * tos, int * dont_fragment, size_t * ipopt_length){
+/** Processes the received IP packet.
+ *
+ * Fills set header fields.
+ * Returns the prefixed IP header length.
+ *
+ * @param[in] packet    The received packet.
+ * @param[out] protocol The transport protocol. May be NULL if not desired.
+ * @param[out] ttl      The time to live counter. May be NULL if not desired.
+ * @param[out] tos      The type of service. May be NULL if not desired.
+ * @param[out] dont_fragment The value indicating whether the fragmentation is
+ *                      disabled. May be NULL if not desired.
+ * @param[out] ipopt_length The IP options length in bytes. May be NULL if not
+ *                      desired.
+ * @returns             The prefixed IP header length in bytes on success.
+ * @returns             ENOMEM if the packet is too short to contain the IP
+ *                      header.
+ */
+int
+ip_client_process_packet(packet_t packet, ip_protocol_t *protocol,
+    ip_ttl_t *ttl, ip_tos_t *tos, int *dont_fragment, size_t *ipopt_length)
+{
         ip_header_ref header;
         header = (ip_header_ref) packet_get_data(packet);
+        if((! header)
+                || (packet_get_data_length(packet) < sizeof(ip_header_t))){
+        if (!header || (packet_get_data_length(packet) < sizeof(ip_header_t)))
                 return ENOMEM;
+        }
+        if(protocol){
+        if (protocol)
                 *protocol = header->protocol;
+        }
+        if(ttl){
+        if (ttl)
                 *ttl = header->ttl;
+        }
+        if(tos){
+        if (tos)
                 *tos = header->tos;
+        }
+        if(dont_fragment){
+                *dont_fragment = header->flags &IPFLAG_DONT_FRAGMENT;
+        }
+        if(ipopt_length){
+        if (dont_fragment)
+                *dont_fragment = header->flags & IPFLAG_DONT_FRAGMENT;
+        if (ipopt_length) {
                 *ipopt_length = IP_HEADER_LENGTH(header) - sizeof(ip_header_t);
                 return sizeof(ip_header_t);
         }else{
+        } else {
                 return IP_HEADER_LENGTH(header);
+        }
+}
+int ip_client_set_pseudo_header_data_length(void *header, size_t headerlen, size_t data_length){
+/** Updates the IPv4 pseudo header data length field.
+ *
+ * @param[in,out] header The IPv4 pseudo header to be updated.
+ * @param[in] headerlen The length of the IP pseudo header in bytes.
+ * @param[in] data_length The data length to be set.
+ * @returns             EOK on success.
+ * @returns             EBADMEM if the header parameter is NULL.
+ * @returns             EINVAL if the headerlen parameter is not IPv4 pseudo
+ *                      header length.
+ */
+int
+ip_client_set_pseudo_header_data_length(void *header, size_t headerlen,
+    size_t data_length)
+{
         ipv4_pseudo_header_ref header_in;
         if(! header){
+        if (!header)
                 return EBADMEM;
+        }
+        if(headerlen == sizeof(ipv4_pseudo_header_t)){
+        if (headerlen == sizeof(ipv4_pseudo_header_t)) {
                 header_in = (ipv4_pseudo_header_ref) header;
                 header_in->data_length = htons(data_length);
                 return EOK;
         // TODO IPv6
         }else{
+        } else {
                 return EINVAL;
+        }

uspace/lib/net/il/ip_remote.c

-              ref689ef0
+              ra7a85d16
 #include <ip_remote.h>
 #include <ip_interface.h>
-#include <ip_messages.h>
-#include <il_messages.h>
 #include <packet_client.h>
 #include <generic.h>
 #include <ipc/services.h>
+#include <ipc/il.h>
+#include <ipc/ip.h>
 #include <net/modules.h>

uspace/lib/net/include/adt/module_map.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup net
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  Character string to module map.
+ * Character string to module map.
  */
 #ifndef __NET_MODULES_MAP_H__
 #define __NET_MODULES_MAP_H__
+#ifndef LIBNET_MODULES_MAP_H_
+#define LIBNET_MODULES_MAP_H_
 #include <task.h>
 #include <ipc/services.h>
 #include <net/modules.h>
 #include <adt/generic_char_map.h>
 /** Type definition of the module structure.
  *  @see module_struct
+ * @see module_struct
  */
 typedef struct module_struct    module_t;
+typedef struct module_struct module_t;
 /** Type definition of the module structure pointer.
  *  @see module_struct
+ * @see module_struct
  */
 typedef module_t *                              module_ref;
+typedef module_t *module_ref;
 /** Module map.
  *  Sorted by module names.
  *  @see generic_char_map.h
+ * Sorted by module names.
+ * @see generic_char_map.h
  */
 GENERIC_CHAR_MAP_DECLARE(modules, module_t)
+/** Module structure.
+ */
+struct  module_struct{
+        /** Module task identifier if running.
+         */
+/** Module structure. */
+struct module_struct {
+        /** Module task identifier if running. */
         task_id_t task_id;
+        /** Module service identifier.
+         */
+        /** Module service identifier. */
         services_t service;
+        /** Module phone if running and connected.
+         */
+        /** Module phone if running and connected. */
         int phone;
+        /** Usage counter.
+         */
+        /** Usage counter. */
         int usage;
+        /** Module name.
+         */
+        const char * name;
+        /** Module full path filename.
+         */
+        const char * filename;
+        /** Connecting function.
+         */
+        connect_module_t * connect_module;
+        /** Module name. */
+        const char *name;
+        /** Module full path filename. */
+        const char *filename;
+        /** Connecting function. */
+        connect_module_t *connect_module;
 };
+/** Adds module to the module map.
+ *  @param[out] module The module structure added.
+ *  @param[in] modules The module map.
+ *  @param[in] name The module name.
+ *  @param[in] filename The full path filename.
+ *  @param[in] service The module service.
+ *  @param[in] task_id The module current task identifier. Zero (0) means not running.
+ *  @param[in] connect_module The module connecting function.
+ *  @returns EOK on success.
+ *  @returns ENOMEM if there is not enough memory left.
+ */
+int add_module(module_ref * module, modules_ref modules, const char * name, const char * filename, services_t service, task_id_t task_id, connect_module_t * connect_module);
+/** Searches and returns the specified module.
+ *  If the module is not running, the module filaname is spawned.
+ *  If the module is not connected, the connect_function is called.
+ *  @param[in] modules The module map.
+ *  @param[in] name The module name.
+ *  @returns The running module found. It does not have to be connected.
+ *  @returns NULL if there is no such module.
+ */
+module_ref get_running_module(modules_ref modules, char * name);
+/** Starts the given module.
+ *  @param[in] fname The module full or relative path filename.
+ *  @returns The new module task identifier on success.
+ *  @returns 0 if there is no such module.
+ */
+task_id_t spawn(const char * fname);
+extern int add_module(module_ref *, modules_ref, const char *, const char *,
+    services_t, task_id_t, connect_module_t *);
+extern module_ref get_running_module(modules_ref, char *);
+extern task_id_t spawn(const char *);
 #endif

uspace/lib/net/include/arp_interface.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup arp
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 #ifndef __NET_ARP_INTERFACE_H__
 #define __NET_ARP_INTERFACE_H__
+#ifndef LIBNET_ARP_INTERFACE_H_
+#define LIBNET_ARP_INTERFACE_H_
 #include <adt/measured_strings.h>
 …
 /** @name ARP module interface
  *  This interface is used by other modules.
+ * This interface is used by other modules.
  */
 /*@{*/
+/** Registers the new device and the requesting protocol service.
+ *  Connects to the network interface layer service.
+ *  Determines the device broadcast address, its address lengths and packet size.
+ *  @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ *  @param[in] device_id The new device identifier.
+ *  @param[in] protocol The requesting protocol service.
+ *  @param[in] netif The underlying device network interface layer service.
+ *  @param[in] address The local requesting protocol address of the device.
+ *  @returns EOK on success.
+ *  @returns EEXIST if the device is already used.
+ *  @returns ENOMEM if there is not enough memory left.
+ *  @returns ENOENT if the network interface service is not known.
+ *  @returns EREFUSED if the network interface service is not responding.
+ *  @returns Other error codes as defined for the nil_packet_get_size() function.
+ *  @returns Other error codes as defined for the nil_get_addr() function.
+ *  @returns Other error codes as defined for the nil_get_broadcast_addr() function.
+ */
+extern int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address);
+/** Translates the given protocol address to the network interface address.
+ *  Broadcasts the ARP request if the mapping is not found.
+ *  Allocates and returns the needed memory block as the data parameter.
+ *  @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ *  @param[in] device_id The device identifier.
+ *  @param[in] protocol The requesting protocol service.
+ *  @param[in] address The local requesting protocol address.
+ *  @param[out] translation The translation of the local protocol address.
+ *  @param[out] data The allocated raw translation data container.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the address parameter is NULL.
+ *  @returns EBADMEM if the translation or the data parameters are NULL.
+ *  @returns ENOENT if the mapping is not found.
+ */
+extern int arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data);
+/** Clears the device cache.
+ *  @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ *  @param[in] device_id The device identifier.
+ *  @returns EOK on success.
+ *  @returns ENOENT if the device is not found.
+ */
+extern int arp_clear_device_req(int arp_phone, device_id_t device_id);
+/** Clears the given protocol address from the cache.
+ *  @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ *  @param[in] device_id The device identifier.
+ *  @param[in] protocol The requesting protocol service.
+ *  @param[in] address The protocol address to be cleared.
+ *  @returns EOK on success.
+ *  @returns ENOENT if the mapping is not found.
+ */
+extern int arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address);
+/** Cleans the cache.
+ *  @param[in] arp_phone The ARP module phone used for (semi)remote calls.
+ *  @returns EOK on success.
+ */
+extern int arp_clean_cache_req(int arp_phone);
+/** Connects to the ARP module.
+ *  @param service The ARP module service. Ignored parameter.
+ *  @returns The ARP module phone on success.
+ */
+extern int arp_connect_module(services_t service);
+/** Returns the ARP task identifier.
+ *  @returns 0 if called by the remote module.
+ */
+extern task_id_t arp_task_get_id(void);
+extern int arp_device_req(int, device_id_t, services_t, services_t,
+    measured_string_ref);
+extern int arp_translate_req(int, device_id_t, services_t, measured_string_ref,
+    measured_string_ref *, char **);
+extern int arp_clear_device_req(int, device_id_t);
+extern int arp_clear_address_req(int, device_id_t, services_t,
+    measured_string_ref);
+extern int arp_clean_cache_req(int);
+extern int arp_connect_module(services_t);
 /*@}*/

uspace/lib/net/include/generic.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup net
+/** @addtogroup libnet
  * @{
  */
 …
  */
 #ifndef NET_GENERIC_H_
 #define NET_GENERIC_H_
+#ifndef LIBNET_GENERIC_H_
+#define LIBNET_GENERIC_H_
 #include <async.h>

uspace/lib/net/include/il_interface.h

-              ref689ef0
+              ra7a85d16
 #include <ipc/services.h>
+#include <ipc/il.h>
 #include <net/device.h>
 #include <net/packet.h>
-#include <il_messages.h>
 #include <packet_client.h>

uspace/lib/net/include/ip_client.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup ip
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  IP client interface.
+ * IP client interface.
  */
 #ifndef __NET_IP_CLIENT_H__
 #define __NET_IP_CLIENT_H__
+#ifndef LIBNET_IP_CLIENT_H_
+#define LIBNET_IP_CLIENT_H_
 #include <net/socket_codes.h>
 …
 #include <ip_interface.h>
+/** Prepares the packet to be transfered via IP.
+ *  The IP header is prefixed.
+ *  @param[in,out] packet The packet to be prepared.
+ *  @param[in] protocol The transport protocol.
+ *  @param[in] ttl The time to live counter. The IPDEFTTL is set if zero (0).
+ *  @param[in] tos The type of service.
+ *  @param[in] dont_fragment The value indicating whether fragmentation is disabled.
+ *  @param[in] ipopt_length The prefixed IP options length in bytes.
+ *  @returns EOK on success.
+ *  @returns ENOMEM if there is not enough memory left in the packet.
+ */
+extern int ip_client_prepare_packet(packet_t packet, ip_protocol_t protocol, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, size_t ipopt_length);
+/** Processes the received IP packet.
+ *  Fills set header fields.
+ *  Returns the prefixed IP header length.
+ *  @param[in] packet The received packet.
+ *  @param[out] protocol The transport protocol. May be NULL if not desired.
+ *  @param[out] ttl The time to live counter. May be NULL if not desired.
+ *  @param[out] tos The type of service. May be NULL if not desired.
+ *  @param[out] dont_fragment The value indicating whether the fragmentation is disabled. May be NULL if not desired.
+ *  @param[out] ipopt_length The IP options length in bytes. May be NULL if not desired.
+ *  @returns The prefixed IP header length in bytes on success.
+ *  @returns ENOMEM if the packet is too short to contain the IP header.
+ */
+extern int ip_client_process_packet(packet_t packet, ip_protocol_t * protocol, ip_ttl_t * ttl, ip_tos_t * tos, int * dont_fragment, size_t * ipopt_length);
+/** Returns the IP header length.
+ *  @param[in] packet The packet.
+ *  @returns The IP header length in bytes.
+ *  @returns Zero (0) if there is no IP header.
+ */
+extern size_t ip_client_header_length(packet_t packet);
+/** Updates the IPv4 pseudo header data length field.
+ *  @param[in,out] header The IPv4 pseudo header to be updated.
+ *  @param[in] headerlen The length of the IP pseudo header in bytes.
+ *  @param[in] data_length The data length to be set.
+ *  @returns EOK on success.
+ *  @returns EBADMEM if the header parameter is NULL.
+ *  @returns EINVAL if the headerlen parameter is not IPv4 pseudo header length.
+ */
+extern int ip_client_set_pseudo_header_data_length(void *header, size_t headerlen, size_t data_length);
+/** Constructs the IPv4 pseudo header.
+ *  @param[in] protocol The transport protocol.
+ *  @param[in] src The source address.
+ *  @param[in] srclen The source address length.
+ *  @param[in] dest The destination address.
+ *  @param[in] destlen The destination address length.
+ *  @param[in] data_length The data length to be set.
+ *  @param[out] header The constructed IPv4 pseudo header.
+ *  @param[out] headerlen The length of the IP pseudo header in bytes.
+ *  @returns EOK on success.
+ *  @returns EBADMEM if the header and/or the headerlen parameter is NULL.
+ *  @returns EINVAL if the source address and/or the destination address parameter is NULL.
+ *  @returns EINVAL if the source address length is less than struct sockaddr length.
+ *  @returns EINVAL if the source address length differs from the destination address length.
+ *  @returns EINVAL if the source address family differs from the destination family.
+ *  @returns EAFNOSUPPORT if the address family is not supported.
+ *  @returns ENOMEM if there is not enough memory left.
+ */
+extern int ip_client_get_pseudo_header(ip_protocol_t protocol, struct sockaddr * src, socklen_t srclen, struct sockaddr * dest, socklen_t destlen, size_t data_length, void **header, size_t * headerlen);
+extern int ip_client_prepare_packet(packet_t, ip_protocol_t, ip_ttl_t, ip_tos_t,
+    int, size_t);
+extern int ip_client_process_packet(packet_t, ip_protocol_t *, ip_ttl_t *,
+    ip_tos_t *, int *, size_t *);
+extern size_t ip_client_header_length(packet_t);
+extern int ip_client_set_pseudo_header_data_length(void *, size_t, size_t);
+extern int ip_client_get_pseudo_header(ip_protocol_t, struct sockaddr *,
+    socklen_t, struct sockaddr *, socklen_t, size_t, void **, size_t *);
 // TODO ipopt manipulation

uspace/lib/net/include/net_checksum.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup net
  *  @{
+/** @addtogroup libnet
+ * @{
  */
 /** @file
  *  General CRC and checksum computation.
+ * General CRC and checksum computation.
  */
 #ifndef __NET_CHECKSUM_H__
 #define __NET_CHECKSUM_H__
+#ifndef LIBNET_CHECKSUM_H_
+#define LIBNET_CHECKSUM_H_
 #include <byteorder.h>
 #include <sys/types.h>
 /** IP checksum value for computed zero checksum.
  *  Zero is returned as 0xFFFF (not flipped)
+ * Zero is returned as 0xFFFF (not flipped)
  */
 #define IP_CHECKSUM_ZERO                        0xFFFFu
+#define IP_CHECKSUM_ZERO        0xffffU
-/**     Computes CRC32 value.
- *  @param[in] seed Initial value. Often used as 0 or ~0.
- *  @param[in] data Pointer to the beginning of data to process.
- *  @param[in] length Length of the data in bits.
- *  @returns The computed CRC32 of the length bits of the data.
- */
 #ifdef ARCH_IS_BIG_ENDIAN
+        #define compute_crc32(seed, data, length)       compute_crc32_be(seed, (uint8_t *) data, length)
+#define compute_crc32(seed, data, length) \
+        compute_crc32_be(seed, (uint8_t *) data, length)
 #else
+        #define compute_crc32(seed, data, length)       compute_crc32_le(seed, (uint8_t *) data, length)
+#define compute_crc32(seed, data, length) \
+        compute_crc32_le(seed, (uint8_t *) data, length)
 #endif
+/**     Computes CRC32 value in the little-endian environment.
+ *  @param[in] seed Initial value. Often used as 0 or ~0.
+ *  @param[in] data Pointer to the beginning of data to process.
+ *  @param[in] length Length of the data in bits.
+ *  @returns The computed CRC32 of the length bits of the data.
+ */
+extern uint32_t compute_crc32_le(uint32_t seed, uint8_t * data, size_t length);
+/**     Computes CRC32 value in the big-endian environment.
+ *  @param[in] seed Initial value. Often used as 0 or ~0.
+ *  @param[in] data Pointer to the beginning of data to process.
+ *  @param[in] length Length of the data in bits.
+ *  @returns The computed CRC32 of the length bits of the data.
+ */
+extern uint32_t compute_crc32_be(uint32_t seed, uint8_t * data, size_t length);
+/** Computes sum of the 2 byte fields.
+ *  Padds one zero (0) byte if odd.
+ *  @param[in] seed Initial value. Often used as 0 or ~0.
+ *  @param[in] data Pointer to the beginning of data to process.
+ *  @param[in] length Length of the data in bytes.
+ *  @returns The computed checksum of the length bytes of the data.
+ */
+extern uint32_t compute_checksum(uint32_t seed, uint8_t * data, size_t length);
+/** Compacts the computed checksum to the 16 bit number adding the carries.
+ *  @param[in] sum Computed checksum.
+ *  @returns Compacted computed checksum to the 16 bits.
+ */
+extern uint16_t compact_checksum(uint32_t sum);
+/** Returns or flips the checksum if zero.
+ *  @param[in] checksum The computed checksum.
+ *  @returns The internet protocol header checksum.
+ *  @returns 0xFFFF if the computed checksum is zero.
+ */
+extern uint16_t flip_checksum(uint16_t checksum);
+/** Computes the ip header checksum.
+ *  To compute the checksum of a new packet, the checksum header field must be zero.
+ *  To check the checksum of a received packet, the checksum may be left set.
+ *  The zero (0) value will be returned in this case if valid.
+ *  @param[in] data The header data.
+ *  @param[in] length The header length in bytes.
+ *  @returns The internet protocol header checksum.
+ *  @returns 0xFFFF if the computed checksum is zero.
+ */
+extern uint16_t ip_checksum(uint8_t * data, size_t length);
+extern uint32_t compute_crc32_le(uint32_t, uint8_t *, size_t);
+extern uint32_t compute_crc32_be(uint32_t, uint8_t *, size_t);
+extern uint32_t compute_checksum(uint32_t, uint8_t *, size_t);
+extern uint16_t compact_checksum(uint32_t);
+extern uint16_t flip_checksum(uint16_t);
+extern uint16_t ip_checksum(uint8_t *, size_t);
 #endif

uspace/lib/net/include/net_interface.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup net
+/** @addtogroup libnet
  *  @{
  */
 #ifndef __NET_NET_INTERFACE_H__
 #define __NET_NET_INTERFACE_H__
+#ifndef LIBNET_NET_INTERFACE_H_
+#define LIBNET_NET_INTERFACE_H_
 #include <ipc/services.h>
 …
 /** @name Networking module interface
  *  This interface is used by other modules.
+ * This interface is used by other modules.
  */
 /*@{*/
+/** Returns the device specific configuration.
+ *  Returns the global configuration if the device specific is not found.
+ *  The configuration names are read and the appropriate settings are set instead.
+ *  Call net_free_settings() function to release the returned configuration.
+ *  @param[in] net_phone The networking module phone.
+ *  @param[in] device_id The device identifier.
+ *  @param[in,out] configuration The requested device configuration. The names are read and the appropriate settings are set instead.
+ *  @param[in] count The configuration entries count.
+ *  @param[in,out] data The configuration and settings data.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the configuration is NULL.
+ *  @returns EINVAL if the count is zero (0).
+ *  @returns Other error codes as defined for the generic_translate_req() function.
+ */
+extern int net_get_device_conf_req(int net_phone, device_id_t device_id, measured_string_ref * configuration, size_t count, char ** data);
+/** Returns the global configuration.
+ *  The configuration names are read and the appropriate settings are set instead.
+ *  Call net_free_settings() function to release the returned configuration.
+ *  @param[in] net_phone The networking module phone.
+ *  @param[in,out] configuration The requested configuration. The names are read and the appropriate settings are set instead.
+ *  @param[in] count The configuration entries count.
+ *  @param[in,out] data The configuration and settings data.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the configuration is NULL.
+ *  @returns EINVAL if the count is zero (0).
+ *  @returns Other error codes as defined for the generic_translate_req() function.
+ */
+extern int net_get_conf_req(int net_phone, measured_string_ref * configuration, size_t count, char ** data);
+/** Frees the received settings.
+ *  @param[in] settings The received settings.
+ *  @param[in] data The received settings data.
+ *  @see net_get_device_conf_req()
+ *  @see net_get_conf_req()
+ */
+extern void net_free_settings(measured_string_ref settings, char * data);
+/** Connects to the networking module.
+ *  @param service The networking module service. Ignored parameter.
+ *  @returns The networking module phone on success.
+ */
+extern int net_connect_module(services_t service);
+extern int net_get_device_conf_req(int, device_id_t, measured_string_ref *,
+    size_t, char **);
+extern int net_get_conf_req(int, measured_string_ref *, size_t, char **);
+extern void net_free_settings(measured_string_ref, char *);
+extern int net_connect_module(void);
 /*@}*/

uspace/lib/net/include/nil_interface.h

-              ref689ef0
+              ra7a85d16
 #include <ipc/ipc.h>
+#include <ipc/nil.h>
 #include <generic.h>
-#include <nil_messages.h>
 #include <nil_remote.h>

uspace/lib/net/include/packet_client.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup packet
+/** @addtogroup libnet
  *  @{
  */
 /** @file
+ *  Packet client.
+ *  The hosting module has to be compiled with both the packet.c and the packet_client.c source files.
+ *  To function correctly, initialization of the packet map by the pm_init() function has to happen at the first place.
+ *  The module should not send the packet messages to the packet server but use the functions provided.
+ *  The packet map should be released by the pm_destroy() function during the module termination.
+ *  The packets and the packet queues can't be locked at all.
+ *  The processing modules should process them sequentially -&nbsp;by passing the packets to the next module and stopping using the passed ones.
+ *  @see packet.h
+ * Packet client.
+ *
+ * To function correctly, initialization of the packet map by the pm_init()
+ * function has to happen at the first place. The module should not send the
+ * packet messages to the packet server but use the functions provided. The
+ * packet map should be released by the pm_destroy() function during the module
+ * termination. The packets and the packet queues can't be locked at all. The
+ * processing modules should process them sequentially - by passing the packets
+ * to the next module and stopping using the passed ones.
+ *
+ * @see packet.h
  */
 #ifndef __NET_PACKET_CLIENT_H__
 #define __NET_PACKET_CLIENT_H__
+#ifndef LIBNET_PACKET_CLIENT_H_
+#define LIBNET_PACKET_CLIENT_H_
 #include <net/packet.h>
+/** @name Packet client interface
+ */
+/** @name Packet client interface */
 /*@{*/
+/** Allocates the specified type right before the actual packet content and returns its pointer.
+ *  The wrapper of the packet_prepend() function.
+ *  @param[in] packet The packet to be used.
+ *  @param[in] type The type to be allocated at the beginning of the packet content.
+ *  @returns The typed pointer to the allocated memory.
+ *  @returns NULL if the packet is not valid.
+ *  @returns NULL if there is not enough memory left.
+/** Allocates the specified type right before the actual packet content and
+ * returns its pointer.
+ *
+ * The wrapper of the packet_prepend() function.
+ *
+ * @param[in] packet    The packet to be used.
+ * @param[in] type      The type to be allocated at the beginning of the packet
+ *                      content.
+ * @returns             The typed pointer to the allocated memory.
+ * @returns             NULL if the packet is not valid.
+ * @returns             NULL if there is not enough memory left.
  */
+#define PACKET_PREFIX(packet, type)     (type *) packet_prefix((packet), sizeof(type))
+#define PACKET_PREFIX(packet, type) \
+        (type *) packet_prefix((packet), sizeof(type))
+/** Allocates the specified type right after the actual packet content and returns its pointer.
+ *  The wrapper of the packet_append() function.
+ *  @param[in] packet The packet to be used.
+ *  @param[in] type The type to be allocated at the end of the packet content.
+ *  @returns The typed pointer to the allocated memory.
+ *  @returns NULL if the packet is not valid.
+ *  @returns NULL if there is not enough memory left.
+/** Allocates the specified type right after the actual packet content and
+ * returns its pointer.
+ *
+ * The wrapper of the packet_append() function.
+ *
+ * @param[in] packet    The packet to be used.
+ * @param[in] type      The type to be allocated at the end of the packet
+ *                      content.
+ * @returns             The typed pointer to the allocated memory.
+ * @returns             NULL if the packet is not valid.
+ * @returns             NULL if there is not enough memory left.
  */
+#define PACKET_SUFFIX(packet, type)     (type *) packet_suffix((packet), sizeof(type))
+#define PACKET_SUFFIX(packet, type) \
+        (type *) packet_suffix((packet), sizeof(type))
 /** Trims the actual packet content by the specified prefix and suffix types.
+ *  The wrapper of the packet_trim() function.
+ *  @param[in] packet The packet to be trimmed.
+ *  @param[in] prefix The type of the prefix to be removed from the beginning of the packet content.
+ *  @param[in] suffix The type of the suffix to be removed from the end of the packet content.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the packet is not valid.
+ *  @returns ENOMEM if there is not enough memory left.
+ *
+ * The wrapper of the packet_trim() function.
+ *
+ * @param[in] packet    The packet to be trimmed.
+ * @param[in] prefix    The type of the prefix to be removed from the beginning
+ *                      of the packet content.
+ * @param[in] suffix    The type of the suffix to be removed from the end of
+ *                      the packet content.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the packet is not valid.
+ * @returns             ENOMEM if there is not enough memory left.
  */
+#define PACKET_TRIM(packet, prefix, suffix)     packet_trim((packet), sizeof(prefix), sizeof(suffix))
+#define PACKET_TRIM(packet, prefix, suffix) \
+        packet_trim((packet), sizeof(prefix), sizeof(suffix))
+/** Allocates the specified space right before the actual packet content and returns its pointer.
+ *  @param[in] packet The packet to be used.
+ *  @param[in] length The space length to be allocated at the beginning of the packet content.
+ *  @returns The pointer to the allocated memory.
+ *  @returns NULL if there is not enough memory left.
+ */
+extern void * packet_prefix(packet_t packet, size_t length);
+/** Allocates the specified space right after the actual packet content and returns its pointer.
+ *  @param[in] packet The packet to be used.
+ *  @param[in] length The space length to be allocated at the end of the packet content.
+ *  @returns The pointer to the allocated memory.
+ *  @returns NULL if there is not enough memory left.
+ */
+extern void * packet_suffix(packet_t packet, size_t length);
+/** Trims the actual packet content by the specified prefix and suffix lengths.
+ *  @param[in] packet The packet to be trimmed.
+ *  @param[in] prefix The prefix length to be removed from the beginning of the packet content.
+ *  @param[in] suffix The suffix length to be removed from the end of the packet content.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the packet is not valid.
+ *  @returns ENOMEM if there is not enough memory left.
+ */
+extern int packet_trim(packet_t packet, size_t prefix, size_t suffix);
+/** Copies the specified data to the beginning of the actual packet content.
+ *  Pushes the content end if needed.
+ *  @param[in] packet The packet to be filled.
+ *  @param[in] data The data to be copied.
+ *  @param[in] length The length of the copied data.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the packet is not valid.
+ *  @returns ENOMEM if there is not enough memory left.
+ */
+extern int packet_copy_data(packet_t packet, const void * data, size_t length);
+/** Returns the packet identifier.
+ *  @param[in] packet The packet.
+ *  @returns The packet identifier.
+ *  @returns Zero (0) if the packet is not valid.
+ */
+extern packet_id_t packet_get_id(const packet_t packet);
+/** Returns the packet content length.
+ *  @param[in] packet The packet.
+ *  @returns The packet content length in bytes.
+ *  @returns Zero (0) if the packet is not valid.
+ */
+extern size_t packet_get_data_length(const packet_t packet);
+/** Returns the pointer to the beginning of the packet content.
+ *  @param[in] packet The packet.
+ *  @returns The pointer to the beginning of the packet content.
+ *  @returns NULL if the packet is not valid.
+ */
+extern void * packet_get_data(const packet_t packet);
+/** Returns the stored packet addresses and their length.
+ *  @param[in] packet The packet.
+ *  @param[out] src The source address. May be NULL if not desired.
+ *  @param[out] dest The destination address. May be NULL if not desired.
+ *  @returns The stored addresses length.
+ *  @returns Zero (0) if the addresses are not present.
+ *  @returns EINVAL if the packet is not valid.
+ */
+extern int packet_get_addr(const packet_t packet, uint8_t ** src, uint8_t ** dest);
+/** Sets the packet addresses.
+ *  @param[in] packet The packet.
+ *  @param[in] src The new source address. May be NULL.
+ *  @param[in] dest The new destination address. May be NULL.
+ *  @param[in] addr_len The addresses length.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the packet is not valid.
+ *  @returns ENOMEM if there is not enough memory left.
+ */
+extern int packet_set_addr(packet_t packet, const uint8_t * src, const uint8_t * dest, size_t addr_len);
+/** Translates the packet identifier to the packet reference.
+ *  Tries to find mapping first.
+ *  Contacts the packet server to share the packet if the mapping is not present.
+ *  @param[in] phone The packet server module phone.
+ *  @param[out] packet The packet reference.
+ *  @param[in] packet_id The packet identifier.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the packet parameter is NULL.
+ *  @returns Other error codes as defined for the NET_PACKET_GET_SIZE message.
+ *  @returns Other error codes as defined for the packet_return() function.
+ */
+extern int packet_translate_remote(int phone, packet_ref packet, packet_id_t packet_id);
+/** Obtains the packet of the given dimensions.
+ *  Contacts the packet server to return the appropriate packet.
+ *  @param[in] phone The packet server module phone.
+ *  @param[in] addr_len The source and destination addresses maximal length in bytes.
+ *  @param[in] max_prefix The maximal prefix length in bytes.
+ *  @param[in] max_content The maximal content length in bytes.
+ *  @param[in] max_suffix The maximal suffix length in bytes.
+ *  @returns The packet reference.
+ *  @returns NULL on error.
+ */
+extern packet_t packet_get_4_remote(int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix);
+/** Obtains the packet of the given content size.
+ *  Contacts the packet server to return the appropriate packet.
+ *  @param[in] phone The packet server module phone.
+ *  @param[in] content The maximal content length in bytes.
+ *  @returns The packet reference.
+ *  @returns NULL on error.
+ */
+extern packet_t packet_get_1_remote(int phone, size_t content);
+/** Releases the packet queue.
+ *  All packets in the queue are marked as free for use.
+ *  The packet queue may be one packet only.
+ *  The module should not use the packets after this point until they are received or obtained again.
+ *  @param[in] phone The packet server module phone.
+ *  @param[in] packet_id The packet identifier.
+ */
+extern void pq_release_remote(int phone, packet_id_t packet_id);
+/** Returns the packet copy.
+ *  Copies the addresses, data, order and metric values.
+ *  Does not copy the queue placement.
+ *  @param[in] phone The packet server module phone.
+ *  @param[in] packet The original packet.
+ *  @returns The packet copy.
+ *  @returns NULL on error.
+ */
+extern void *packet_prefix(packet_t, size_t);
+extern void *packet_suffix(packet_t, size_t);
+extern int packet_trim(packet_t, size_t, size_t);
+extern int packet_copy_data(packet_t, const void *, size_t);
+extern packet_id_t packet_get_id(const packet_t);
+extern size_t packet_get_data_length(const packet_t);
+extern void *packet_get_data(const packet_t);
+extern int packet_get_addr(const packet_t, uint8_t **, uint8_t **);
+extern int packet_set_addr(packet_t, const uint8_t *, const uint8_t *, size_t);
 extern packet_t packet_get_copy(int phone, packet_t packet);

uspace/lib/net/include/packet_remote.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup packet
+/** @addtogroup libnet
  * @{
  */
 #ifndef __NET_PACKET_REMOTE_H__
 #define __NET_PACKET_REMOTE_H__
+#ifndef LIBNET_PACKET_REMOTE_H_
+#define LIBNET_PACKET_REMOTE_H_
 #include <net/packet.h>
+#include <sys/types.h>
 extern int packet_translate_remote(int, packet_ref, packet_id_t);

uspace/lib/net/include/socket_core.h

-              ref689ef0
+              ra7a85d16
  */
 /** @addtogroup socket
+/** @addtogroup libnet
  *  @{
  */
 /** @file
  *  Socket common core.
+ * Socket common core.
  */
 #ifndef __NET_SOCKET_CORE_H__
 #define __NET_SOCKET_CORE_H__
+#ifndef LIBNET_SOCKET_CORE_H_
+#define LIBNET_SOCKET_CORE_H_
 #include <sys/types.h>
-#include <net/in.h>
-#include <net/device.h>
 #include <adt/generic_char_map.h>
 #include <adt/dynamic_fifo.h>
 #include <adt/int_map.h>
+#include <net/in.h>
+#include <net/device.h>
 #include <net/packet.h>
+/** Initial size of the received packet queue.
+ */
+/** Initial size of the received packet queue. */
 #define SOCKET_INITIAL_RECEIVED_SIZE    4
+/** Maximum size of the received packet queue.
+ */
+#define SOCKET_MAX_RECEIVED_SIZE                0
+/** Maximum size of the received packet queue. */
+#define SOCKET_MAX_RECEIVED_SIZE        0
+/** Initial size of the sockets for acceptance queue.
+ */
+/** Initial size of the sockets for acceptance queue. */
 #define SOCKET_INITIAL_ACCEPTED_SIZE    1
+/** Maximum size of the sockets for acceptance queue.
+ */
+#define SOCKET_MAX_ACCEPTEDED_SIZE              0
+/** Maximum size of the sockets for acceptance queue. */
+#define SOCKET_MAX_ACCEPTEDED_SIZE      0
+/** Listening sockets' port map key.
+ */
+/** Listening sockets' port map key. */
 #define SOCKET_MAP_KEY_LISTENING        "L"
 /** Type definition of the socket core.
  *  @see socket_core
+ * @see socket_core
  */
 typedef struct socket_core      socket_core_t;
+typedef struct socket_core socket_core_t;
 /** Type definition of the socket core pointer.
  *  @see socket_core
+ * @see socket_core
  */
 typedef socket_core_t * socket_core_ref;
+typedef socket_core_t *socket_core_ref;
 /** Type definition of the socket port.
  *  @see socket_port
+ * @see socket_port
  */
 typedef struct socket_port      socket_port_t;
+typedef struct socket_port socket_port_t;
 /** Type definition of the socket port pointer.
  *  @see socket_port
+ * @see socket_port
  */
 typedef socket_port_t * socket_port_ref;
+typedef socket_port_t *socket_port_ref;
+/** Socket core.
+ */
+struct socket_core{
+        /** Socket identifier.
+         */
+/** Socket core. */
+struct socket_core {
+        /** Socket identifier. */
         int socket_id;
+        /** Client application phone.
+         */
+        /** Client application phone. */
         int phone;
+        /** Bound port.
+         */
+        /** Bound port. */
         int port;
+        /** Received packets queue.
+         */
+        /** Received packets queue. */
         dyn_fifo_t received;
+        /** Sockets for acceptance queue.
+         */
+        /** Sockets for acceptance queue. */
         dyn_fifo_t accepted;
+        /** Protocol specific data.
+         */
+        void * specific_data;
+        /** Socket ports map key.
+         */
+        const char * key;
+        /** Length of the Socket ports map key.
+         */
+        /** Protocol specific data. */
+        void *specific_data;
+        /** Socket ports map key. */
+        const char *key;
+        /** Length of the Socket ports map key. */
         size_t key_length;
 };
 /** Sockets map.
  *  The key is the socket identifier.
+ * The key is the socket identifier.
  */
 INT_MAP_DECLARE(socket_cores, socket_core_t);
 /** Bount port sockets map.
+ *  The listening socket has the SOCKET_MAP_KEY_LISTENING key identifier whereas the other use the remote addresses.
+ *
+ * The listening socket has the SOCKET_MAP_KEY_LISTENING key identifier whereas
+ * the other use the remote addresses.
  */
 GENERIC_CHAR_MAP_DECLARE(socket_port_map, socket_core_ref);
 /** Ports map.
  *  The key is the port number.
+ * The key is the port number.
  */
 INT_MAP_DECLARE(socket_ports, socket_port_t);
+/** Destroys local sockets.
+ *  Releases all buffered packets and calls the release function for each of the sockets.
+ *  @param[in] packet_phone The packet server phone to release buffered packets.
+ *  @param[in] local_sockets The local sockets to be destroyed.
+ *  @param[in,out] global_sockets The global sockets to be updated.
+ *  @param[in] socket_release The client release callback function.
+ */
+extern void socket_cores_release(int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
+/** Binds the socket to the port.
+ *  The address port is used if set, a free port is used if not.
+ *  @param[in] local_sockets The local sockets to be searched.
+ *  @param[in,out] global_sockets The global sockets to be updated.
+ *  @param[in] socket_id The new socket identifier.
+ *  @param[in] addr The address to be bound to.
+ *  @param[in] addrlen The address length.
+ *  @param[in] free_ports_start The minimum free port.
+ *  @param[in] free_ports_end The maximum free port.
+ *  @param[in] last_used_port The last used free port.
+ *  @returns EOK on success.
+ *  @returns ENOTSOCK if the socket was not found.
+ *  @returns EAFNOSUPPORT if the address family is not supported.
+ *  @returns EADDRINUSE if the port is already in use.
+ *  @returns Other error codes as defined for the socket_bind_free_port() function.
+ *  @returns Other error codes as defined for the socket_bind_insert() function.
+ */
+extern int socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port);
+/** Binds the socket to a free port.
+ *  The first free port is used.
+ *  @param[in,out] global_sockets The global sockets to be updated.
+ *  @param[in,out] socket The socket to be bound.
+ *  @param[in] free_ports_start The minimum free port.
+ *  @param[in] free_ports_end The maximum free port.
+ *  @param[in] last_used_port The last used free port.
+ *  @returns EOK on success.
+ *  @returns ENOTCONN if no free port was found.
+ *  @returns Other error codes as defined for the socket_bind_insert() function.
+ */
+extern int socket_bind_free_port(socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port);
+/** Creates a new socket.
+ *  @param[in,out] local_sockets The local sockets to be updated.
+ *  @param[in] app_phone The application phone.
+ *  @param[in] specific_data The socket specific data.
+ *  @param[in,out] socket_id The new socket identifier. A new identifier is chosen if set to zero (0) or negative. A negative identifier is chosen if set to negative.
+ *  @returns EOK on success.
+ *  @returns EINVAL if the socket_id parameter is NULL.
+ *  @returns ENOMEM if there is not enough memory left.
+ */
+extern int socket_create(socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id);
+/** Destroys the socket.
+ *  If the socket is bound, the port is released.
+ *  Releases all buffered packets, calls the release function and removes the socket from the local sockets.
+ *  @param[in] packet_phone The packet server phone to release buffered packets.
+ *  @param[in] socket_id The socket identifier.
+ *  @param[in,out] local_sockets The local sockets to be updated.
+ *  @param[in,out] global_sockets The global sockets to be updated.
+ *  @param[in] socket_release The client release callback function.
+ *  @returns EOK on success.
+ *  @returns ENOTSOCK if the socket is not found.
+ */
+extern int socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
+/** Replies the packet or the packet queue data to the application via the socket.
+ *  Uses the current message processing fibril.
+ *  @param[in] packet The packet to be transfered.
+ *  @param[out] length The total data length.
+ *  @returns EOK on success.
+ *  @returns EBADMEM if the length parameter is NULL.
+ *  @returns ENOMEM if there is not enough memory left.
+ *  @returns Other error codes as defined for the data_reply() function.
+ */
+extern int socket_reply_packets(packet_t packet, size_t * length);
+/** Finds the bound port socket.
+ *  @param[in] global_sockets The global sockets to be searched.
+ *  @param[in] port The port number.
+ *  @param[in] key The socket key identifier.
+ *  @param[in] key_length The socket key length.
+ *  @returns The found socket.
+ *  @returns NULL if no socket was found.
+ */
+extern socket_core_ref socket_port_find(socket_ports_ref global_sockets, int port, const char * key, size_t key_length);
+/** Releases the socket port.
+ *  If the socket is bound the port entry is released.
+ *  If there are no more port entries the port is release.
+ *  @param[in] global_sockets The global sockets to be updated.
+ *  @param[in] socket The socket to be unbound.
+ */
+extern void socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket);
+/** Adds the socket to an already bound port.
+ *  @param[in] global_sockets The global sockets to be updated.
+ *  @param[in] port The port number to be bound to.
+ *  @param[in] socket The socket to be added.
+ *  @param[in] key The socket key identifier.
+ *  @param[in] key_length The socket key length.
+ *  @returns EOK on success.
+ *  @returns ENOENT if the port is not already used.
+ *  @returns Other error codes as defined for the socket_port_add_core() function.
+ */
+extern int socket_port_add(socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length);
+extern void socket_cores_release(int, socket_cores_ref, socket_ports_ref,
+    void (*)(socket_core_ref));
+extern int socket_bind(socket_cores_ref, socket_ports_ref, int, void *, size_t,
+    int, int, int);
+extern int socket_bind_free_port(socket_ports_ref, socket_core_ref, int, int,
+    int);
+extern int socket_create(socket_cores_ref, int, void *, int *);
+extern int socket_destroy(int, int, socket_cores_ref, socket_ports_ref,
+    void (*)(socket_core_ref));
+extern int socket_reply_packets(packet_t, size_t *);
+extern socket_core_ref socket_port_find(socket_ports_ref, int, const char *,
+    size_t);
+extern void socket_port_release(socket_ports_ref, socket_core_ref);
+extern int socket_port_add(socket_ports_ref, int, socket_core_ref,
+    const char *, size_t);
 #endif

uspace/lib/net/include/tl_interface.h

-              ref689ef0
+              ra7a85d16
 #include <async.h>
 #include <ipc/services.h>
+#include <ipc/tl.h>
 #include <generic.h>
 …
 #include <net/packet.h>
 #include <packet_client.h>
-#include <tl_messages.h>
 /** @name Transport layer module interface

uspace/lib/net/netif/netif_local.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <ipc/netif.h>
 #include <err.h>
 …
 #include <nil_interface.h>
 #include <netif_local.h>
-#include <netif_messages.h>
 #include <netif_interface.h>

uspace/lib/net/netif/netif_remote.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/services.h>
+#include <ipc/netif.h>
 #include <net/modules.h>
 …
 #include <net/device.h>
 #include <netif_remote.h>
-#include <netif_messages.h>
 #include <generic.h>

uspace/lib/net/nil/nil_remote.c

-              ref689ef0
+              ra7a85d16
 #include <nil_remote.h>
 #include <nil_interface.h>
-#include <nil_messages.h>
 #include <generic.h>
 #include <net/device.h>
 #include <net/packet.h>
 #include <packet_client.h>
+#include <ipc/nil.h>
 /** Notify the network interface layer about the device state change.

uspace/srv/net/il/arp/arp.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/services.h>
 #include <ipc/net.h>
+#include <ipc/arp.h>
+#include <ipc/il.h>
 #include <byteorder.h>
 #include <err.h>
 …
 #include <packet_client.h>
 #include <packet_remote.h>
-#include <il_messages.h>
 #include <il_interface.h>
 #include <il_local.h>
-#include <arp_messages.h>
 #include "arp.h"
 …
+        }
         return EOK;
+}
-task_id_t arp_task_get_id(void){
-        return task_get_id();
+}

uspace/srv/net/il/arp/arp_module.c

ref689ef0	ra7a85d16
80	80
81	81	async_set_client_connection(client_connection);
82		arp_globals.net_phone = net_connect_module(~~SERVICE_NETWORKING~~);
	82	arp_globals.net_phone = net_connect_module();
83	83	ERROR_PROPAGATE(pm_init());
84	84

uspace/srv/net/il/ip/ip.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/services.h>
 #include <ipc/net.h>
+#include <ipc/nil.h>
+#include <ipc/il.h>
+#include <ipc/ip.h>
 #include <sys/types.h>
 #include <byteorder.h>
 …
 #include <packet_client.h>
 #include <packet_remote.h>
-#include <nil_messages.h>
-#include <il_messages.h>
 #include <il_local.h>
-#include <ip_local.h>
 #include "ip.h"
 #include "ip_header.h"
-#include "ip_messages.h"
 #include "ip_module.h"
+#include "ip_local.h"
 /** IP module name.
 …
         ip_globals.client_connection = client_connection;
         ERROR_PROPAGATE(modules_initialize(&ip_globals.modules));
         ERROR_PROPAGATE(add_module(NULL, &ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module));
+        ERROR_PROPAGATE(add_module(NULL, &ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module));
         fibril_rwlock_write_unlock(&ip_globals.lock);
         return EOK;

uspace/srv/net/il/ip/ip_module.c

ref689ef0	ra7a85d16
79	79
80	80	async_set_client_connection(client_connection);
81		ip_globals.net_phone = net_connect_module(~~SERVICE_NETWORKING~~);
	81	ip_globals.net_phone = net_connect_module();
82	82	ERROR_PROPAGATE(pm_init());
83	83

uspace/srv/net/net/net.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/ipc.h>
+#include <ipc/services.h>
 #include <ipc/net.h>
+#include <ipc/services.h>
+#include <ipc/net_net.h>
+#include <ipc/il.h>
 #include <net/modules.h>
 …
 #include <adt/module_map.h>
 #include <net/packet.h>
-#include <il_messages.h>
 #include <netif_remote.h>
 #include <net/device.h>
 …
 #include <net_interface.h>
 #include <ip_interface.h>
-#include <net_net_messages.h>
 #include "net.h"

uspace/srv/net/netif/lo/lo.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <ipc/nil.h>
 #include <net/modules.h>
 …
 #include <net/device.h>
 #include <nil_interface.h>
-#include <nil_messages.h>
 #include <netif_interface.h>
 #include <netif_local.h>

uspace/srv/net/netstart/netstart.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <ipc/net_net.h>
 #include <net/modules.h>
-#include <net_net_messages.h>
 #include "self_test.h"

uspace/srv/net/nil/eth/eth_module.c

ref689ef0	ra7a85d16
63	63
64	64	async_set_client_connection(client_connection);
65		int net_phone = net_connect_module(~~SERVICE_NETWORKING~~);
	65	int net_phone = net_connect_module();
66	66	ERROR_PROPAGATE(pm_init());
67	67

uspace/srv/net/nil/nildummy/nildummy_module.c

ref689ef0	ra7a85d16
71	71
72	72	async_set_client_connection(client_connection);
73		int net_phone = net_connect_module(~~SERVICE_NETWORKING~~);
	73	int net_phone = net_connect_module();
74	74	ERROR_PROPAGATE(pm_init());
75	75

uspace/srv/net/tl/icmp/icmp.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/services.h>
 #include <ipc/net.h>
+#include <ipc/tl.h>
 #include <ipc/icmp.h>
 #include <sys/time.h>
 …
 #include <ip_interface.h>
 #include <net_interface.h>
-#include <tl_messages.h>
 #include <tl_interface.h>
 #include <tl_local.h>

uspace/srv/net/tl/icmp/icmp_module.c

ref689ef0	ra7a85d16
69	69
70	70	async_set_client_connection(client_connection);
71		icmp_globals.net_phone = net_connect_module(~~SERVICE_NETWORKING~~);
	71	icmp_globals.net_phone = net_connect_module();
72	72	if(icmp_globals.net_phone < 0){
73	73	return icmp_globals.net_phone;

uspace/srv/net/tl/tcp/tcp.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/services.h>
 #include <ipc/net.h>
+#include <ipc/tl.h>
 #include <ipc/socket.h>
 …
 #include <socket_core.h>
 #include <tl_common.h>
-#include <tl_messages.h>
 #include <tl_local.h>
 #include <tl_interface.h>

uspace/srv/net/tl/tcp/tcp_module.c

ref689ef0	ra7a85d16
71	71
72	72	async_set_client_connection(client_connection);
73		tcp_globals.net_phone = net_connect_module(~~SERVICE_NETWORKING~~);
	73	tcp_globals.net_phone = net_connect_module();
74	74	ERROR_PROPAGATE(pm_init());
75	75

uspace/srv/net/tl/udp/udp.c

-              ref689ef0
+              ra7a85d16
 #include <ipc/services.h>
 #include <ipc/net.h>
+#include <ipc/tl.h>
 #include <ipc/socket.h>
 #include <errno.h>
 …
 #include <tl_local.h>
 #include <tl_interface.h>
-#include <tl_messages.h>
 #include "udp.h"

uspace/srv/net/tl/udp/udp_module.c

ref689ef0	ra7a85d16
69	69
70	70	async_set_client_connection(client_connection);
71		udp_globals.net_phone = net_connect_module(~~SERVICE_NETWORKING~~);
	71	udp_globals.net_phone = net_connect_module();
72	72	if(udp_globals.net_phone < 0){
73	73	return udp_globals.net_phone;

Context Navigation

Changes in / [ef689ef0:a7a85d16] in mainline

Legend:

Download in other formats: