Changeset 6610565b in mainline for uspace/srv/net

Timestamp:

2011-01-10T16:20:56Z (15 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

1ffa73b, 8048c648, 8426912a, 977fcea, f401312

Parents:

a97ea0f (diff), 4a5c6c1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

Location:

uspace/srv/net

Files:

• cfg/ne2k (modified) (1 diff)
• il/arp/arp.c (modified) (16 diffs)
• il/arp/arp.h (modified) (3 diffs)
• il/arp/arp_module.c (modified) (1 diff)
• il/arp/arp_module.h (modified) (1 diff)
• il/ip/ip.c (modified) (23 diffs)
• il/ip/ip_module.c (modified) (1 diff)
• il/ip/ip_module.h (modified) (1 diff)
• net/net.c (modified) (25 diffs)
• net/net.h (modified) (2 diffs)
• net/net_standalone.c (modified) (2 diffs)
• netif/lo/lo.c (modified) (5 diffs)
• nil/eth/eth.c (modified) (14 diffs)
• nil/eth/eth.h (modified) (1 diff)
• nil/eth/eth_header.h (modified) (1 diff)
• nil/eth/eth_module.c (modified) (1 diff)
• nil/nildummy/nildummy.c (modified) (11 diffs)
• nil/nildummy/nildummy.h (modified) (1 diff)
• nil/nildummy/nildummy_module.c (modified) (1 diff)
• tl/icmp/icmp.c (modified) (8 diffs)
• tl/icmp/icmp_module.c (modified) (1 diff)
• tl/icmp/icmp_module.h (modified) (1 diff)
• tl/tcp/tcp.c (modified) (10 diffs)
• tl/tcp/tcp_module.c (modified) (1 diff)
• tl/tcp/tcp_module.h (modified) (1 diff)
• tl/udp/udp.c (modified) (8 diffs)
• tl/udp/udp_module.c (modified) (1 diff)
• tl/udp/udp_module.h (modified) (1 diff)

uspace/srv/net/cfg/ne2k

@@ -22 +22 @@
 ARP=arp
 
-MTU=1492
+MTU=1500

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

@@ -457 +457 @@
         uint8_t *des_proto;
         int rc;
-
+        
         length = packet_get_data_length(packet);
         if (length <= sizeof(arp_header_t))
@@ -482 +482 @@
         des_hw = src_proto + header->protocol_length;
         des_proto = des_hw + header->hardware_length;
-        trans = arp_addr_find(&proto->addresses, (char *) src_proto,
+        trans = arp_addr_find(&proto->addresses, src_proto,
             header->protocol_length);
         /* Exists? */
@@ -493 +493 @@
         if (proto->addr->length != header->protocol_length)
                 return EINVAL;
-        if (!str_lcmp(proto->addr->value, (char *) des_proto,
-            proto->addr->length)) {
+        
+        if (!bcmp(proto->addr->value, des_proto, proto->addr->length)) {
                 /* Not already updated? */
                 if (!trans) {
@@ -502 +502 @@
                         trans->hw_addr = NULL;
                         fibril_condvar_initialize(&trans->cv);
-                        rc = arp_addr_add(&proto->addresses, (char *) src_proto,
+                        rc = arp_addr_add(&proto->addresses, src_proto,
                             header->protocol_length, trans);
                         if (rc != EOK) {
@@ -510 +510 @@
                 }
                 if (!trans->hw_addr) {
-                        trans->hw_addr = measured_string_create_bulk(
-                            (char *) src_hw, header->hardware_length);
+                        trans->hw_addr = measured_string_create_bulk(src_hw,
+                            header->hardware_length);
                         if (!trans->hw_addr)
                                 return ENOMEM;
-
+                        
                         /* Notify the fibrils that wait for the translation. */
                         fibril_condvar_broadcast(&trans->cv);
@@ -677 +677 @@
 int
 arp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *answer_count)
 {
         measured_string_t *address;
         measured_string_t *translation;
-        char *data;
+        uint8_t *data;
         packet_t *packet;
         packet_t *next;
@@ -696 +696 @@
                         return rc;
                 
-                rc = arp_device_message(IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address);
+                rc = arp_device_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), ARP_GET_NETIF(*call), address);
                 if (rc != EOK) {
                         free(address);
@@ -710 +710 @@
                 
                 fibril_mutex_lock(&arp_globals.lock);
-                rc = arp_translate_message(IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), address, &translation);
+                rc = arp_translate_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), address, &translation);
                 free(address);
                 free(data);
@@ -727 +727 @@
 
         case NET_ARP_CLEAR_DEVICE:
-                return arp_clear_device_req(0, IPC_GET_DEVICE(call));
+                return arp_clear_device_req(0, IPC_GET_DEVICE(*call));
 
         case NET_ARP_CLEAR_ADDRESS:
@@ -734 +734 @@
                         return rc;
                 
-                arp_clear_address_req(0, IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), address);
+                arp_clear_address_req(0, IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), address);
                 free(address);
                 free(data);
@@ -748 +748 @@
         
         case NET_IL_RECEIVED:
+                
                 rc = packet_translate_remote(arp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
@@ -756 +757 @@
                 do {
                         next = pq_detach(packet);
-                        rc = arp_receive_message(IPC_GET_DEVICE(call), packet);
+                        rc = arp_receive_message(IPC_GET_DEVICE(*call), packet);
                         if (rc != 1) {
                                 pq_release_remote(arp_globals.net_phone,
@@ -768 +769 @@
         
         case NET_IL_MTU_CHANGED:
-                return arp_mtu_changed_message(IPC_GET_DEVICE(call),
-                    IPC_GET_MTU(call));
+                return arp_mtu_changed_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_MTU(*call));
         }
         
@@ -790 +791 @@
         while (true) {
                 ipc_call_t answer;
-                int answer_count;
+                size_t count;
                 
                 /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
+                refresh_answer(&answer, &count);
                 
                 /* Fetch the next message */
@@ -801 +802 @@
                 /* Process the message */
                 int res = il_module_message_standalone(callid, &call, &answer,
-                    &answer_count);
+                    &count);
                 
                 /*
@@ -812 +813 @@
                 
                 /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+                answer_call(callid, res, &answer, count);
         }
 }

uspace/srv/net/il/arp/arp.h

@@ -96 +96 @@
         measured_string_t *addr;
         /** Actual device hardware address data. */
-        char *addr_data;
+        uint8_t *addr_data;
         /** Broadcast device hardware address. */
         measured_string_t *broadcast_addr;
         /** Broadcast device hardware address data. */
-        char *broadcast_data;
+        uint8_t *broadcast_data;
         /** Device identifier. */
         device_id_t device_id;
@@ -142 +142 @@
         measured_string_t *addr;
         /** Actual device protocol address data. */
-        char *addr_data;
+        uint8_t *addr_data;
         /** Address map. */
         arp_addr_t addresses;
@@ -154 +154 @@
          * Hardware address for the translation. NULL denotes an incomplete
          * record with possible waiters.
-         */ 
+         */
         measured_string_t *hw_addr;
         /** Condition variable used for waiting for completion of the record. */

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

@@ -58 +58 @@
 
 int il_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
 {
-        return arp_message_standalone(callid, call, answer, answer_count);
+        return arp_message_standalone(callid, call, answer, count);
 }
 

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

@@ -44 +44 @@
 extern int arp_initialize(async_client_conn_t);
 extern int arp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
-    int *);
+    size_t *);
 
 #endif

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

@@ -275 +275 @@
         if (rc != EOK)
                 goto out;
-        rc = add_module(NULL, &ip_globals.modules, ARP_NAME, ARP_FILENAME,
-            SERVICE_ARP, 0, arp_connect_module);
+        rc = add_module(NULL, &ip_globals.modules, (uint8_t *) ARP_NAME,
+            (uint8_t *) ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module);
 
 out:
@@ -312 +312 @@
         measured_string_t names[] = {
                 {
-                        (char *) "IPV",
+                        (uint8_t *) "IPV",
                         3
                 },
                 {
-                        (char *) "IP_CONFIG",
+                        (uint8_t *) "IP_CONFIG",
                         9
                 },
                 {
-                        (char *) "IP_ADDR",
+                        (uint8_t *) "IP_ADDR",
                         7
                 },
                 {
-                        (char *) "IP_NETMASK",
+                        (uint8_t *) "IP_NETMASK",
                         10
                 },
                 {
-                        (char *) "IP_GATEWAY",
+                        (uint8_t *) "IP_GATEWAY",
                         10
                 },
                 {
-                        (char *) "IP_BROADCAST",
+                        (uint8_t *) "IP_BROADCAST",
                         12
                 },
                 {
-                        (char *) "ARP",
+                        (uint8_t *) "ARP",
                         3
                 },
                 {
-                        (char *) "IP_ROUTING",
+                        (uint8_t *) "IP_ROUTING",
                         10
                 }
@@ -346 +346 @@
         measured_string_t *configuration;
         size_t count = sizeof(names) / sizeof(measured_string_t);
-        char *data;
+        uint8_t *data;
         measured_string_t address;
         ip_route_t *route;
@@ -368 +368 @@
         if (configuration) {
                 if (configuration[0].value)
-                        ip_netif->ipv = strtol(configuration[0].value, NULL, 0);
-
-                ip_netif->dhcp = !str_lcmp(configuration[1].value, "dhcp",
+                        ip_netif->ipv = strtol((char *) configuration[0].value, NULL, 0);
+                
+                ip_netif->dhcp = !str_lcmp((char *) configuration[1].value, "dhcp",
                     configuration[1].length);
                 
@@ -394 +394 @@
                         }
                         
-                        if ((inet_pton(AF_INET, configuration[2].value,
+                        if ((inet_pton(AF_INET, (char *) configuration[2].value,
                             (uint8_t *) &route->address.s_addr) != EOK) ||
-                            (inet_pton(AF_INET, configuration[3].value,
+                            (inet_pton(AF_INET, (char *) configuration[3].value,
                             (uint8_t *) &route->netmask.s_addr) != EOK) ||
-                            (inet_pton(AF_INET, configuration[4].value,
+                            (inet_pton(AF_INET, (char *) configuration[4].value,
                             (uint8_t *) &gateway.s_addr) == EINVAL) ||
-                            (inet_pton(AF_INET, configuration[5].value,
+                            (inet_pton(AF_INET, (char *) configuration[5].value,
                             (uint8_t *) &ip_netif->broadcast.s_addr) == EINVAL))
                             {
@@ -441 +441 @@
         if (ip_netif->arp) {
                 if (route) {
-                        address.value = (char *) &route->address.s_addr;
+                        address.value = (uint8_t *) &route->address.s_addr;
                         address.length = sizeof(in_addr_t);
                         
@@ -477 +477 @@
                 ip_globals.gateway.gateway.s_addr = gateway.s_addr;
                 ip_globals.gateway.netif = ip_netif;
+                
+                char defgateway[INET_ADDRSTRLEN];
+                inet_ntop(AF_INET, (uint8_t *) &gateway.s_addr,
+                    defgateway, INET_ADDRSTRLEN);
+                printf("%s: Default gateway (%s)\n", NAME, defgateway);
         }
 
@@ -997 +1002 @@
         measured_string_t destination;
         measured_string_t *translation;
-        char *data;
+        uint8_t *data;
         int phone;
         int rc;
@@ -1004 +1009 @@
         if (netif->arp && (route->address.s_addr != dest.s_addr)) {
                 destination.value = route->gateway.s_addr ?
-                    (char *) &route->gateway.s_addr : (char *) &dest.s_addr;
+                    (uint8_t *) &route->gateway.s_addr : (uint8_t *) &dest.s_addr;
                 destination.length = sizeof(dest.s_addr);
 
@@ -1069 +1074 @@
         int index;
         ip_route_t *route;
-
+        
         if (!netif)
                 return NULL;
-
-        // start with the first one - the direct route
+        
+        /* Start with the first one (the direct route) */
         for (index = 0; index < ip_routes_count(&netif->routes); index++) {
                 route = ip_routes_get_index(&netif->routes, index);
-                if (route &&
+                if ((route) &&
                     ((route->address.s_addr & route->netmask.s_addr) ==
-                    (destination.s_addr & route->netmask.s_addr))) {
+                    (destination.s_addr & route->netmask.s_addr)))
                         return route;
-                }
         }
 
@@ -1288 +1292 @@
         if (device_id > 0) {
                 netif = ip_netifs_find(&ip_globals.netifs, device_id);
-                route = ip_netif_find_route(netif, * dest);
+                route = ip_netif_find_route(netif, *dest);
                 if (netif && !route && (ip_globals.gateway.netif == netif))
                         route = &ip_globals.gateway;
@@ -1318 +1322 @@
                 }
         }
-
+        
         // if the local host is the destination
         if ((route->address.s_addr == dest->s_addr) &&
@@ -1562 +1566 @@
         socklen_t addrlen;
         int rc;
-
+        
         header = (ip_header_t *) packet_get_data(packet);
         if (!header)
@@ -1588 +1592 @@
                 return EINVAL;
         }
-
+        
         // process ipopt and get destination
         dest = ip_get_destination(header);
@@ -1609 +1613 @@
         if (rc != EOK)
                 return rc;
-
+        
         route = ip_find_route(dest);
         if (!route) {
@@ -1756 +1760 @@
                     (header->destination_address & route->netmask.s_addr))) {
                         // clear the ARP mapping if any
-                        address.value = (char *) &header->destination_address;
+                        address.value = (uint8_t *) &header->destination_address;
                         address.length = sizeof(header->destination_address);
                         arp_clear_address_req(netif->arp->phone,
@@ -1886 +1890 @@
 int
 ip_message_standalone(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
-    int *answer_count)
+    size_t *answer_count)
 {
         packet_t *packet;
@@ -1905 +1909 @@
         
         case IPC_M_CONNECT_TO_ME:
-                return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call),
-                    IPC_GET_PHONE(call), NULL);
+                return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call),
+                    IPC_GET_PHONE(*call), NULL);
         
         case NET_IL_DEVICE:
-                return ip_device_req_local(0, IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call));
+                return ip_device_req_local(0, IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call));
         
         case NET_IL_SEND:
                 rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return ip_send_msg_local(0, IPC_GET_DEVICE(call), packet, 0,
-                    IPC_GET_ERROR(call));
+                return ip_send_msg_local(0, IPC_GET_DEVICE(*call), packet, 0,
+                    IPC_GET_ERROR(*call));
         
         case NET_IL_DEVICE_STATE:
-                return ip_device_state_message(IPC_GET_DEVICE(call),
-                    IPC_GET_STATE(call));
+                return ip_device_state_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_STATE(*call));
         
         case NET_IL_RECEIVED:
                 rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return ip_receive_message(IPC_GET_DEVICE(call), packet);
+                return ip_receive_message(IPC_GET_DEVICE(*call), packet);
         
         case NET_IP_RECEIVED_ERROR:
                 rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return ip_received_error_msg_local(0, IPC_GET_DEVICE(call),
-                    packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
+                return ip_received_error_msg_local(0, IPC_GET_DEVICE(*call),
+                    packet, IPC_GET_TARGET(*call), IPC_GET_ERROR(*call));
         
         case NET_IP_ADD_ROUTE:
-                return ip_add_route_req_local(0, IPC_GET_DEVICE(call),
-                    IP_GET_ADDRESS(call), IP_GET_NETMASK(call),
-                    IP_GET_GATEWAY(call));
+                return ip_add_route_req_local(0, IPC_GET_DEVICE(*call),
+                    IP_GET_ADDRESS(*call), IP_GET_NETMASK(*call),
+                    IP_GET_GATEWAY(*call));
 
         case NET_IP_SET_GATEWAY:
-                return ip_set_gateway_req_local(0, IPC_GET_DEVICE(call),
-                    IP_GET_GATEWAY(call));
+                return ip_set_gateway_req_local(0, IPC_GET_DEVICE(*call),
+                    IP_GET_GATEWAY(*call));
 
         case NET_IP_GET_ROUTE:
@@ -1954 +1958 @@
                         return rc;
                 
-                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(call), addr,
+                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr,
                     (socklen_t) addrlen, &device_id, &header, &headerlen);
                 if (rc != EOK)
                         return rc;
                 
-                IPC_SET_DEVICE(answer, device_id);
-                IP_SET_HEADERLEN(answer, headerlen);
+                IPC_SET_DEVICE(*answer, device_id);
+                IP_SET_HEADERLEN(*answer, headerlen);
                 
                 *answer_count = 2;
@@ -1972 +1976 @@
         
         case NET_IL_PACKET_SPACE:
-                rc = ip_packet_size_message(IPC_GET_DEVICE(call), &addrlen,
+                rc = ip_packet_size_message(IPC_GET_DEVICE(*call), &addrlen,
                     &prefix, &content, &suffix);
                 if (rc != EOK)
                         return rc;
                 
-                IPC_SET_ADDR(answer, addrlen);
-                IPC_SET_PREFIX(answer, prefix);
-                IPC_SET_CONTENT(answer, content);
-                IPC_SET_SUFFIX(answer, suffix);
+                IPC_SET_ADDR(*answer, addrlen);
+                IPC_SET_PREFIX(*answer, prefix);
+                IPC_SET_CONTENT(*answer, content);
+                IPC_SET_SUFFIX(*answer, suffix);
                 *answer_count = 4;
                 return EOK;
         
         case NET_IL_MTU_CHANGED:
-                return ip_mtu_changed_message(IPC_GET_DEVICE(call),
-                    IPC_GET_MTU(call));
+                return ip_mtu_changed_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_MTU(*call));
         }
         
@@ -2007 +2011 @@
         while (true) {
                 ipc_call_t answer;
-                int answer_count;
+                size_t count;
                 
                 /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
+                refresh_answer(&answer, &count);
                 
                 /* Fetch the next message */
@@ -2018 +2022 @@
                 /* Process the message */
                 int res = il_module_message_standalone(callid, &call, &answer,
-                    &answer_count);
+                    &count);
                 
                 /*
@@ -2030 +2034 @@
                 
                 /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+                answer_call(callid, res, &answer, count);
         }
 }

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

@@ -59 +59 @@
 int
 il_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
 {
-        return ip_message_standalone(callid, call, answer, answer_count);
+        return ip_message_standalone(callid, call, answer, count);
 }
 

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

@@ -43 +43 @@
 extern int ip_initialize(async_client_conn_t);
 extern int ip_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
-    int *);
+    size_t *);
 
 #endif

uspace/srv/net/net/net.c

@@ -90 +90 @@
  *
  */
-int add_configuration(measured_strings_t *configuration, const char *name,
-    const char *value)
+int add_configuration(measured_strings_t *configuration, const uint8_t *name,
+    const uint8_t *value)
 {
         int rc;
@@ -119 +119 @@
 }
 
-static int parse_line(measured_strings_t *configuration, char *line)
+static int parse_line(measured_strings_t *configuration, uint8_t *line)
 {
         int rc;
         
         /* From the beginning */
-        char *name = line;
+        uint8_t *name = line;
         
         /* Skip comments and blank lines */
@@ -135 +135 @@
         
         /* Remember the name start */
-        char *value = name;
+        uint8_t *value = name;
         
         /* Skip the name */
@@ -186 +186 @@
         
         /* Construct the full filename */
-        char line[BUFFER_SIZE];
-        if (snprintf(line, BUFFER_SIZE, "%s/%s", directory, filename) > BUFFER_SIZE)
+        char fname[BUFFER_SIZE];
+        if (snprintf(fname, BUFFER_SIZE, "%s/%s", directory, filename) > BUFFER_SIZE)
                 return EOVERFLOW;
         
         /* Open the file */
-        FILE *cfg = fopen(line, "r");
+        FILE *cfg = fopen(fname, "r");
         if (!cfg)
                 return ENOENT;
@@ -201 +201 @@
         unsigned int line_number = 0;
         size_t index = 0;
+        uint8_t line[BUFFER_SIZE];
+        
         while (!ferror(cfg) && !feof(cfg)) {
                 int read = fgetc(cfg);
@@ -207 +209 @@
                                 line[BUFFER_SIZE - 1] = '\0';
                                 fprintf(stderr, "%s: Configuration line %u too "
-                                    "long: %s\n", NAME, line_number, line);
+                                    "long: %s\n", NAME, line_number, (char *) line);
                                 
                                 /* No space left in the line buffer */
@@ -213 +215 @@
                         }
                         /* Append the character */
-                        line[index] = (char) read;
+                        line[index] = (uint8_t) read;
                         index++;
                 } else {
@@ -221 +223 @@
                         if (parse_line(configuration, line) != EOK) {
                                 fprintf(stderr, "%s: Configuration error on "
-                                    "line %u: %s\n", NAME, line_number, line);
+                                    "line %u: %s\n", NAME, line_number, (char *) line);
                         }
                         
@@ -282 +284 @@
                 return rc;
         
-        rc = add_module(NULL, &net_globals.modules, LO_NAME, LO_FILENAME,
-            SERVICE_LO, 0, connect_to_service);
-        if (rc != EOK)
-                return rc;
-        rc = add_module(NULL, &net_globals.modules, DP8390_NAME,
-            DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service);
-        if (rc != EOK)
-                return rc;
-        rc = add_module(NULL, &net_globals.modules, ETHERNET_NAME,
-            ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
-        if (rc != EOK)
-                return rc;
-        rc = add_module(NULL, &net_globals.modules, NILDUMMY_NAME,
-            NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) LO_NAME,
+            (uint8_t *) LO_FILENAME, SERVICE_LO, 0, connect_to_service);
+        if (rc != EOK)
+                return rc;
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) DP8390_NAME,
+            (uint8_t *) DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service);
+        if (rc != EOK)
+                return rc;
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME,
+            (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
+        if (rc != EOK)
+                return rc;
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) NILDUMMY_NAME,
+            (uint8_t *) NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
         if (rc != EOK)
                 return rc;
@@ -364 +366 @@
  */
 static int net_get_conf(measured_strings_t *netif_conf,
-    measured_string_t *configuration, size_t count, char **data)
+    measured_string_t *configuration, size_t count, uint8_t **data)
 {
         if (data)
@@ -390 +392 @@
 
 int net_get_conf_req(int net_phone, measured_string_t **configuration,
-    size_t count, char **data)
+    size_t count, uint8_t **data)
 {
         if (!configuration || (count <= 0))
@@ -399 +401 @@
 
 int net_get_device_conf_req(int net_phone, device_id_t device_id,
-    measured_string_t **configuration, size_t count, char **data)
+    measured_string_t **configuration, size_t count, uint8_t **data)
 {
         if ((!configuration) || (count == 0))
@@ -411 +413 @@
 }
 
-void net_free_settings(measured_string_t *settings, char *data)
+void net_free_settings(measured_string_t *settings, uint8_t *data)
 {
 }
@@ -437 +439 @@
         /* Mandatory netif */
         measured_string_t *setting =
-            measured_strings_find(&netif->configuration, CONF_NETIF, 0);
+            measured_strings_find(&netif->configuration, (uint8_t *) CONF_NETIF, 0);
         
         netif->driver = get_running_module(&net_globals.modules, setting->value);
@@ -447 +449 @@
         
         /* Optional network interface layer */
-        setting = measured_strings_find(&netif->configuration, CONF_NIL, 0);
+        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_NIL, 0);
         if (setting) {
                 netif->nil = get_running_module(&net_globals.modules, setting->value);
@@ -459 +461 @@
         
         /* Mandatory internet layer */
-        setting = measured_strings_find(&netif->configuration, CONF_IL, 0);
+        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_IL, 0);
         netif->il = get_running_module(&net_globals.modules, setting->value);
         if (!netif->il) {
@@ -468 +470 @@
         
         /* Hardware configuration */
-        setting = measured_strings_find(&netif->configuration, CONF_IRQ, 0);
-        int irq = setting ? strtol(setting->value, NULL, 10) : 0;
-        
-        setting = measured_strings_find(&netif->configuration, CONF_IO, 0);
-        int io = setting ? strtol(setting->value, NULL, 16) : 0;
-        
-        rc = netif_probe_req_remote(netif->driver->phone, netif->id, irq, io);
+        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_IRQ, 0);
+        int irq = setting ? strtol((char *) setting->value, NULL, 10) : 0;
+        
+        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_IO, 0);
+        uintptr_t io = setting ? strtol((char *) setting->value, NULL, 16) : 0;
+        
+        rc = netif_probe_req(netif->driver->phone, netif->id, irq, (void *) io);
         if (rc != EOK)
                 return rc;
@@ -481 +483 @@
         services_t internet_service;
         if (netif->nil) {
-                setting = measured_strings_find(&netif->configuration, CONF_MTU, 0);
+                setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_MTU, 0);
                 if (!setting)
                         setting = measured_strings_find(&net_globals.configuration,
-                            CONF_MTU, 0);
-                
-                int mtu = setting ? strtol(setting->value, NULL, 10) : 0;
+                            (uint8_t *) CONF_MTU, 0);
+                
+                int mtu = setting ? strtol((char *) setting->value, NULL, 10) : 0;
                 
                 rc = nil_device_req(netif->nil->phone, netif->id, mtu,
@@ -509 +511 @@
         }
         
-        return netif_start_req_remote(netif->driver->phone, netif->id);
+        return netif_start_req(netif->driver->phone, netif->id);
 }
 
@@ -558 +560 @@
                 /* Mandatory name */
                 measured_string_t *setting =
-                    measured_strings_find(&netif->configuration, CONF_NAME, 0);
+                    measured_strings_find(&netif->configuration, (uint8_t *) CONF_NAME, 0);
                 if (!setting) {
                         fprintf(stderr, "%s: Network interface name is missing\n", NAME);
@@ -602 +604 @@
                 printf("%s: Network interface started (name: %s, id: %d, driver: %s, "
                     "nil: %s, il: %s)\n", NAME, netif->name, netif->id,
-                    netif->driver->name,  netif->nil ? netif->nil->name : "[none]",
+                    netif->driver->name, netif->nil ? (char *) netif->nil->name : "[none]",
                     netif->il->name);
         }
@@ -611 +613 @@
 /** Process the networking message.
  *
- * @param[in] callid        The message identifier.
- * @param[in] call          The message parameters.
+ * @param[in]  callid       The message identifier.
+ * @param[in]  call         The message parameters.
  * @param[out] answer       The message answer parameters.
  * @param[out] answer_count The last parameter for the actual answer
@@ -625 +627 @@
  */
 int net_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
-    int *answer_count)
+    size_t *answer_count)
 {
         measured_string_t *strings;
-        char *data;
+        uint8_t *data;
         int rc;
         
@@ -637 +639 @@
         case NET_NET_GET_DEVICE_CONF:
                 rc = measured_strings_receive(&strings, &data,
-                    IPC_GET_COUNT(call));
+                    IPC_GET_COUNT(*call));
                 if (rc != EOK)
                         return rc;
-                net_get_device_conf_req(0, IPC_GET_DEVICE(call), &strings,
-                    IPC_GET_COUNT(call), NULL);
+                net_get_device_conf_req(0, IPC_GET_DEVICE(*call), &strings,
+                    IPC_GET_COUNT(*call), NULL);
                 
                 /* Strings should not contain received data anymore */
                 free(data);
                 
-                rc = measured_strings_reply(strings, IPC_GET_COUNT(call));
+                rc = measured_strings_reply(strings, IPC_GET_COUNT(*call));
                 free(strings);
                 return rc;
         case NET_NET_GET_CONF:
                 rc = measured_strings_receive(&strings, &data,
-                    IPC_GET_COUNT(call));
+                    IPC_GET_COUNT(*call));
                 if (rc != EOK)
                         return rc;
-                net_get_conf_req(0, &strings, IPC_GET_COUNT(call), NULL);
+                net_get_conf_req(0, &strings, IPC_GET_COUNT(*call), NULL);
                 
                 /* Strings should not contain received data anymore */
                 free(data);
                 
-                rc = measured_strings_reply(strings, IPC_GET_COUNT(call));
+                rc = measured_strings_reply(strings, IPC_GET_COUNT(*call));
                 free(strings);
                 return rc;
@@ -686 +688 @@
                 /* Clear the answer structure */
                 ipc_call_t answer;
-                int answer_count;
+                size_t answer_count;
                 refresh_answer(&answer, &answer_count);
                 

uspace/srv/net/net/net.h

@@ -105 +105 @@
         module_t *driver;
         
-        device_id_t id; /**< System-unique network interface identifier. */
-        module_t *il;   /**< Serving internet layer module index. */
-        char *name;     /**< System-unique network interface name. */
-        module_t *nil;  /**< Serving link layer module index. */
+        device_id_t id;  /**< System-unique network interface identifier. */
+        module_t *il;    /**< Serving internet layer module index. */
+        uint8_t *name;   /**< System-unique network interface name. */
+        module_t *nil;   /**< Serving link layer module index. */
 } netif_t;
 
@@ -133 +133 @@
 } net_globals_t;
 
-extern int add_configuration(measured_strings_t *, const char *, const char *);
-extern int net_module_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, int *);
+extern int add_configuration(measured_strings_t *, const uint8_t *,
+    const uint8_t *);
+extern int net_module_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, size_t *);
 extern int net_initialize_build(async_client_conn_t);
-extern int net_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, int *);
+extern int net_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, size_t *);
 
 #endif

uspace/srv/net/net/net_standalone.c

@@ -63 +63 @@
         int rc;
         
-        task_id_t task_id = spawn("/srv/ip");
+        task_id_t task_id = net_spawn((uint8_t *) "/srv/ip");
         if (!task_id)
                 return EINVAL;
         
-        rc = add_module(NULL, &net_globals.modules, IP_NAME,
-            IP_FILENAME, SERVICE_IP, task_id, ip_connect_module);
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) IP_NAME,
+            (uint8_t *) IP_FILENAME, SERVICE_IP, task_id, ip_connect_module);
         if (rc != EOK)
                 return rc;
         
-        if (!spawn("/srv/icmp"))
+        if (!net_spawn((uint8_t *) "/srv/icmp"))
                 return EINVAL;
         
-        if (!spawn("/srv/udp"))
+        if (!net_spawn((uint8_t *) "/srv/udp"))
                 return EINVAL;
         
-        if (!spawn("/srv/tcp"))
+        if (!net_spawn((uint8_t *) "/srv/tcp"))
                 return EINVAL;
         
@@ -100 +100 @@
  */
 int net_module_message(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
 {
-        if (IS_NET_PACKET_MESSAGE(call))
-                return packet_server_message(callid, call, answer, answer_count);
+        if (IS_NET_PACKET_MESSAGE(*call))
+                return packet_server_message(callid, call, answer, count);
         
-        return net_message(callid, call, answer, answer_count);
+        return net_message(callid, call, answer, count);
 }
 

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

@@ -49 +49 @@
 #include <net/device.h>
 #include <nil_interface.h>
-#include <netif_interface.h>
-#include <netif_local.h>
+#include <netif_skel.h>
 
 /** Default hardware address. */
-#define DEFAULT_ADDR            "\0\0\0\0\0\0"
+#define DEFAULT_ADDR  0
 
 /** Default address length. */
-#define DEFAULT_ADDR_LEN        (sizeof(DEFAULT_ADDR) / sizeof(char))
+#define DEFAULT_ADDR_LEN  6
 
 /** Loopback module name. */
@@ -62 +61 @@
 
 /** Network interface global data. */
-netif_globals_t netif_globals;
+netif_globals_t netif_globals;
 
 int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
 {
         return ENOTSUP;
@@ -74 +73 @@
         if (!address)
                 return EBADMEM;
-
-        address->value = str_dup(DEFAULT_ADDR);
+        
+        uint8_t *addr = (uint8_t *) malloc(DEFAULT_ADDR_LEN);
+        memset(addr, DEFAULT_ADDR, DEFAULT_ADDR_LEN);
+        
+        address->value = addr;
         address->length = DEFAULT_ADDR_LEN;
-
+        
         return EOK;
 }
@@ -169 +171 @@
 }
 
-int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
+int netif_probe_message(device_id_t device_id, int irq, void *io)
 {
         netif_device_t *device;
@@ -230 +232 @@
 }
 
-/** Default thread for new connections.
- *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
- */
-static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
-{
-        /*
-         * Accept the connection
-         *  - Answer the first IPC_M_CONNECT_ME_TO call.
-         */
-        ipc_answer_0(iid, EOK);
-        
-        while (true) {
-                ipc_call_t answer;
-                int answer_count;
-                
-                /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
-                
-                /* Fetch the next message */
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-                
-                /* Process the message */
-                int res = netif_module_message(NAME, callid, &call, &answer,
-                    &answer_count);
-                
-                /*
-                 * End if told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
-        }
-}
-
 int main(int argc, char *argv[])
 {
-        int rc;
-        
         /* Start the module */
-        rc = netif_module_start(netif_client_connection);
-        return rc;
+        return netif_module_start();
 }
 

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

@@ -54 +54 @@
 #include <protocol_map.h>
 #include <net/device.h>
-#include <netif_interface.h>
+#include <netif_remote.h>
 #include <net_interface.h>
 #include <nil_interface.h>
@@ -201 +201 @@
 
         eth_globals.broadcast_addr =
-            measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF", ETH_ADDR);
+            measured_string_create_bulk((uint8_t *) "\xFF\xFF\xFF\xFF\xFF\xFF", ETH_ADDR);
         if (!eth_globals.broadcast_addr) {
                 rc = ENOMEM;
@@ -239 +239 @@
                 switch (IPC_GET_IMETHOD(*icall)) {
                 case NET_NIL_DEVICE_STATE:
-                        nil_device_state_msg_local(0, IPC_GET_DEVICE(icall),
-                            IPC_GET_STATE(icall));
+                        nil_device_state_msg_local(0, IPC_GET_DEVICE(*icall),
+                            IPC_GET_STATE(*icall));
                         ipc_answer_0(iid, EOK);
                         break;
                 case NET_NIL_RECEIVED:
                         rc = packet_translate_remote(eth_globals.net_phone,
-                            &packet, IPC_GET_PACKET(icall));
+                            &packet, IPC_GET_PACKET(*icall));
                         if (rc == EOK) {
                                 rc = nil_received_msg_local(0,
-                                    IPC_GET_DEVICE(icall), packet, 0);
+                                    IPC_GET_DEVICE(*icall), packet, 0);
                         }
                         ipc_answer_0(iid, (sysarg_t) rc);
@@ -284 +284 @@
         measured_string_t names[2] = {
                 {
-                        (char *) "ETH_MODE",
+                        (uint8_t *) "ETH_MODE",
                         8
                 },
                 {
-                        (char *) "ETH_DUMMY",
+                        (uint8_t *) "ETH_DUMMY",
                         9
                 }
@@ -294 +294 @@
         measured_string_t *configuration;
         size_t count = sizeof(names) / sizeof(measured_string_t);
-        char *data;
+        uint8_t *data;
         eth_proto_t *proto;
         int rc;
@@ -358 +358 @@
 
         if (configuration) {
-                if (!str_lcmp(configuration[0].value, "DIX",
+                if (!str_lcmp((char *) configuration[0].value, "DIX",
                     configuration[0].length)) {
                         device->flags |= ETH_DIX;
-                } else if(!str_lcmp(configuration[0].value, "8023_2_LSAP",
+                } else if(!str_lcmp((char *) configuration[0].value, "8023_2_LSAP",
                     configuration[0].length)) {
                         device->flags |= ETH_8023_2_LSAP;
@@ -407 +407 @@
         
         printf("%s: Device registered (id: %d, service: %d: mtu: %zu, "
-            "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n",
+            "mac: %02x:%02x:%02x:%02x:%02x:%02x, flags: 0x%x)\n",
             NAME, device->device_id, device->service, device->mtu,
             device->addr_data[0], device->addr_data[1],
@@ -837 +837 @@
 
 int nil_message_standalone(const char *name, ipc_callid_t callid,
-    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
+    ipc_call_t *call, ipc_call_t *answer, size_t *answer_count)
 {
         measured_string_t *address;
@@ -853 +853 @@
         
         case NET_NIL_DEVICE:
-                return eth_device_message(IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), IPC_GET_MTU(call));
+                return eth_device_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
         case NET_NIL_SEND:
                 rc = packet_translate_remote(eth_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return eth_send_message(IPC_GET_DEVICE(call), packet,
-                    IPC_GET_SERVICE(call));
+                return eth_send_message(IPC_GET_DEVICE(*call), packet,
+                    IPC_GET_SERVICE(*call));
         case NET_NIL_PACKET_SPACE:
-                rc = eth_packet_space_message(IPC_GET_DEVICE(call), &addrlen,
+                rc = eth_packet_space_message(IPC_GET_DEVICE(*call), &addrlen,
                     &prefix, &content, &suffix);
                 if (rc != EOK)
                         return rc;
-                IPC_SET_ADDR(answer, addrlen);
-                IPC_SET_PREFIX(answer, prefix);
-                IPC_SET_CONTENT(answer, content);
-                IPC_SET_SUFFIX(answer, suffix);
+                IPC_SET_ADDR(*answer, addrlen);
+                IPC_SET_PREFIX(*answer, prefix);
+                IPC_SET_CONTENT(*answer, content);
+                IPC_SET_SUFFIX(*answer, suffix);
                 *answer_count = 4;
                 return EOK;
         case NET_NIL_ADDR:
-                rc = eth_addr_message(IPC_GET_DEVICE(call), ETH_LOCAL_ADDR,
+                rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_LOCAL_ADDR,
                     &address);
                 if (rc != EOK)
@@ -880 +880 @@
                 return measured_strings_reply(address, 1);
         case NET_NIL_BROADCAST_ADDR:
-                rc = eth_addr_message(IPC_GET_DEVICE(call), ETH_BROADCAST_ADDR,
+                rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_BROADCAST_ADDR,
                     &address);
                 if (rc != EOK)
@@ -886 +886 @@
                 return measured_strings_reply(address, 1);
         case IPC_M_CONNECT_TO_ME:
-                return eth_register_message(NIL_GET_PROTO(call),
-                    IPC_GET_PHONE(call));
+                return eth_register_message(NIL_GET_PROTO(*call),
+                    IPC_GET_PHONE(*call));
         }
         
@@ -908 +908 @@
         while (true) {
                 ipc_call_t answer;
-                int answer_count;
+                size_t count;
                 
                 /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
+                refresh_answer(&answer, &count);
                 
                 /* Fetch the next message */
@@ -919 +919 @@
                 /* Process the message */
                 int res = nil_module_message_standalone(NAME, callid, &call,
-                    &answer, &answer_count);
+                    &answer, &count);
                 
                 /*
@@ -930 +930 @@
                 
                 /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+                answer_call(callid, res, &answer, count);
         }
 }

uspace/srv/net/nil/eth/eth.h

@@ -91 +91 @@
         /** Actual device hardware address. */
         measured_string_t *addr;
+        
         /** Actual device hardware address data. */
-        char *addr_data;
+        uint8_t *addr_data;
 };
 

uspace/srv/net/nil/eth/eth_header.h

@@ -42 +42 @@
 
 /** Ethernet address length. */
-#define ETH_ADDR        6
+#define ETH_ADDR  6
 
 /** Ethernet header preamble value. */
-#define ETH_PREAMBLE    0x55
+#define ETH_PREAMBLE  0x55
 
 /** Ethernet header start of frame value. */
-#define ETH_SFD         0xD5
+#define ETH_SFD  0xD5
 
 /** IEEE 802.2 unordered information control field. */
-#define IEEE_8023_2_UI  0x03
+#define IEEE_8023_2_UI  0x03
 
 /** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions.

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

@@ -78 +78 @@
 
 int nil_module_message_standalone(const char *name, ipc_callid_t callid,
-    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
+    ipc_call_t *call, ipc_call_t *answer, size_t *count)
 {
-        return nil_message_standalone(name, callid, call, answer, answer_count);
+        return nil_message_standalone(name, callid, call, answer, count);
 }
 

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

@@ -47 +47 @@
 #include <net/modules.h>
 #include <net/device.h>
-#include <netif_interface.h>
 #include <nil_interface.h>
 #include <il_interface.h>
@@ -53 +52 @@
 #include <net/packet.h>
 #include <packet_remote.h>
+#include <netif_remote.h>
 #include <nil_local.h>
 
@@ -113 +113 @@
                 case NET_NIL_DEVICE_STATE:
                         rc = nil_device_state_msg_local(0,
-                            IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
+                            IPC_GET_DEVICE(*icall), IPC_GET_STATE(*icall));
                         ipc_answer_0(iid, (sysarg_t) rc);
                         break;
@@ -119 +119 @@
                 case NET_NIL_RECEIVED:
                         rc = packet_translate_remote(nildummy_globals.net_phone,
-                            &packet, IPC_GET_PACKET(icall));
+                            &packet, IPC_GET_PACKET(*icall));
                         if (rc == EOK) {
                                 rc = nil_received_msg_local(0,
-                                    IPC_GET_DEVICE(icall), packet, 0);
+                                    IPC_GET_DEVICE(*icall), packet, 0);
                         }
                         ipc_answer_0(iid, (sysarg_t) rc);
@@ -375 +375 @@
 
 int nil_message_standalone(const char *name, ipc_callid_t callid,
-    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
+    ipc_call_t *call, ipc_call_t *answer, size_t *answer_count)
 {
         measured_string_t *address;
@@ -391 +391 @@
         
         case NET_NIL_DEVICE:
-                return nildummy_device_message(IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), IPC_GET_MTU(call));
+                return nildummy_device_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
         
         case NET_NIL_SEND:
                 rc = packet_translate_remote(nildummy_globals.net_phone,
-                    &packet, IPC_GET_PACKET(call));
+                    &packet, IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return nildummy_send_message(IPC_GET_DEVICE(call), packet,
-                    IPC_GET_SERVICE(call));
+                return nildummy_send_message(IPC_GET_DEVICE(*call), packet,
+                    IPC_GET_SERVICE(*call));
         
         case NET_NIL_PACKET_SPACE:
-                rc = nildummy_packet_space_message(IPC_GET_DEVICE(call),
+                rc = nildummy_packet_space_message(IPC_GET_DEVICE(*call),
                     &addrlen, &prefix, &content, &suffix);
                 if (rc != EOK)
                         return rc;
-                IPC_SET_ADDR(answer, addrlen);
-                IPC_SET_PREFIX(answer, prefix);
-                IPC_SET_CONTENT(answer, content);
-                IPC_SET_SUFFIX(answer, suffix);
+                IPC_SET_ADDR(*answer, addrlen);
+                IPC_SET_PREFIX(*answer, prefix);
+                IPC_SET_CONTENT(*answer, content);
+                IPC_SET_SUFFIX(*answer, suffix);
                 *answer_count = 4;
                 return EOK;
         
         case NET_NIL_ADDR:
-                rc = nildummy_addr_message(IPC_GET_DEVICE(call), &address);
+                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
                 if (rc != EOK)
                         return rc;
@@ -421 +421 @@
         
         case NET_NIL_BROADCAST_ADDR:
-                rc = nildummy_addr_message(IPC_GET_DEVICE(call), &address);
+                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
                 if (rc != EOK)
                         return rc;
@@ -427 +427 @@
         
         case IPC_M_CONNECT_TO_ME:
-                return nildummy_register_message(NIL_GET_PROTO(call),
-                    IPC_GET_PHONE(call));
+                return nildummy_register_message(NIL_GET_PROTO(*call),
+                    IPC_GET_PHONE(*call));
         }
         
@@ -449 +449 @@
         while (true) {
                 ipc_call_t answer;
-                int answer_count;
+                size_t count;
                 
                 /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
+                refresh_answer(&answer, &count);
                 
                 /* Fetch the next message */
@@ -460 +460 @@
                 /* Process the message */
                 int res = nil_module_message_standalone(NAME, callid, &call,
-                    &answer, &answer_count);
+                    &answer, &count);
                 
                 /*
@@ -471 +471 @@
                 
                 /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+                answer_call(callid, res, &answer, count);
         }
 }

uspace/srv/net/nil/nildummy/nildummy.h

@@ -78 +78 @@
         measured_string_t *addr;
         /** Actual device hardware address data. */
-        char *addr_data;
+        uint8_t *addr_data;
 };
 

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

@@ -79 +79 @@
 
 int nil_module_message_standalone(const char *name, ipc_callid_t callid,
-    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
+    ipc_call_t *call, ipc_call_t *answer, size_t *count)
 {
-        return nil_message_standalone(name, callid, call, answer, answer_count);
+        return nil_message_standalone(name, callid, call, answer, count);
 }
 

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

@@ -405 +405 @@
         measured_string_t names[] = {
                 {
-                        (char *) "ICMP_ERROR_REPORTING",
+                        (uint8_t *) "ICMP_ERROR_REPORTING",
                         20
                 },
                 {
-                        (char *) "ICMP_ECHO_REPLYING",
+                        (uint8_t *) "ICMP_ECHO_REPLYING",
                         18
                 }
@@ -415 +415 @@
         measured_string_t *configuration;
         size_t count = sizeof(names) / sizeof(measured_string_t);
-        char *data;
+        uint8_t *data;
         int rc;
 
@@ -696 +696 @@
         case NET_ICMP_DEST_UNREACH:
                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
                 return icmp_destination_unreachable_msg_local(0,
-                    ICMP_GET_CODE(call), ICMP_GET_MTU(call), packet);
+                    ICMP_GET_CODE(*call), ICMP_GET_MTU(*call), packet);
         case NET_ICMP_SOURCE_QUENCH:
                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
@@ -709 +709 @@
         case NET_ICMP_TIME_EXCEEDED:
                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(call),
+                return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(*call),
                     packet);
         case NET_ICMP_PARAMETERPROB:
                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return icmp_parameter_problem_msg_local(0, ICMP_GET_CODE(call),
-                    ICMP_GET_POINTER(call), packet);
+                return icmp_parameter_problem_msg_local(0, ICMP_GET_CODE(*call),
+                    ICMP_GET_POINTER(*call), packet);
         default:
                 return ENOTSUP;
@@ -787 +787 @@
         bool keep_on_going = true;
         ipc_call_t answer;
-        int answer_count;
+        size_t answer_count;
         size_t length;
         struct sockaddr *addr;
@@ -894 +894 @@
  */
 int icmp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *answer_count)
 {
         packet_t *packet;
@@ -903 +903 @@
         case NET_TL_RECEIVED:
                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return icmp_received_msg_local(IPC_GET_DEVICE(call), packet,
-                    SERVICE_ICMP, IPC_GET_ERROR(call));
+                return icmp_received_msg_local(IPC_GET_DEVICE(*call), packet,
+                    SERVICE_ICMP, IPC_GET_ERROR(*call));
         
         case NET_ICMP_INIT:
-                return icmp_process_client_messages(callid, * call);
+                return icmp_process_client_messages(callid, *call);
         
         default:
@@ -936 +936 @@
         while (true) {
                 ipc_call_t answer;
-                int answer_count;
+                size_t answer_count;
                 
                 /* Clear the answer structure */

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

@@ -86 +86 @@
 
 int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
 {
-        return icmp_message_standalone(callid, call, answer, answer_count);
+        return icmp_message_standalone(callid, call, answer, count);
 }
 

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

@@ -44 +44 @@
 extern int icmp_initialize(async_client_conn_t);
 extern int icmp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
-    int *);
+    size_t *);
 
 #endif

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

@@ -154 +154 @@
 
         /** Port map key. */
-        char *key;
+        uint8_t *key;
 
         /** Port map key length. */
@@ -358 +358 @@
         /* Find the destination socket */
         socket = socket_port_find(&tcp_globals.sockets,
-            ntohs(header->destination_port), (const char *) src, addrlen);
+            ntohs(header->destination_port), (uint8_t *) src, addrlen);
         if (!socket) {
                 /* Find the listening destination socket */
                 socket = socket_port_find(&tcp_globals.sockets,
-                    ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING,
-                    0);
+                    ntohs(header->destination_port),
+                    (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
         }
 
@@ -998 +998 @@
         /* Find the destination socket */
         listening_socket = socket_port_find(&tcp_globals.sockets,
-            listening_port, SOCKET_MAP_KEY_LISTENING, 0);
+            listening_port, (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
         if (!listening_socket ||
             (listening_socket->socket_id != listening_socket_id)) {
@@ -1022 +1022 @@
 
         rc = socket_port_add(&tcp_globals.sockets, listening_port, socket,
-            (const char *) socket_data->addr, socket_data->addrlen);
+            (uint8_t *) socket_data->addr, socket_data->addrlen);
         assert(socket == socket_port_find(&tcp_globals.sockets, listening_port,
-            (const char *) socket_data->addr, socket_data->addrlen));
+            (uint8_t *) socket_data->addr, socket_data->addrlen));
 
 //      rc = socket_bind_free_port(&tcp_globals.sockets, socket,
@@ -1262 +1262 @@
 int
 tcp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *answer_count)
 {
         packet_t *packet;
@@ -1276 +1276 @@
 //              fibril_rwlock_read_lock(&tcp_globals.lock);
                 rc = packet_translate_remote(tcp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK) {
 //                      fibril_rwlock_read_unlock(&tcp_globals.lock);
                         return rc;
                 }
-                rc = tcp_received_msg(IPC_GET_DEVICE(call), packet, SERVICE_TCP,
-                    IPC_GET_ERROR(call));
+                rc = tcp_received_msg(IPC_GET_DEVICE(*call), packet, SERVICE_TCP,
+                    IPC_GET_ERROR(*call));
 //              fibril_rwlock_read_unlock(&tcp_globals.lock);
                 return rc;
@@ -1323 +1323 @@
         bool keep_on_going = true;
         socket_cores_t local_sockets;
-        int app_phone = IPC_GET_PHONE(&call);
+        int app_phone = IPC_GET_PHONE(call);
         struct sockaddr *addr;
         int socket_id;
@@ -1330 +1330 @@
         fibril_rwlock_t lock;
         ipc_call_t answer;
-        int answer_count;
+        size_t answer_count;
         tcp_socket_data_t *socket_data;
         socket_core_t *socket;
@@ -2109 +2109 @@
 
         /* Copy the key */
-        operation_timeout->key = ((char *) operation_timeout) +
+        operation_timeout->key = ((uint8_t *) operation_timeout) +
             sizeof(*operation_timeout);
         operation_timeout->key_length = socket->key_length;
@@ -2502 +2502 @@
         while (true) {
                 ipc_call_t answer;
-                int answer_count;
+                size_t answer_count;
 
                 /* Clear the answer structure */

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

@@ -87 +87 @@
 
 int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
 {
-        return tcp_message_standalone(callid, call, answer, answer_count);
+        return tcp_message_standalone(callid, call, answer, count);
 }
 

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

@@ -44 +44 @@
 extern int tcp_initialize(async_client_conn_t);
 extern int tcp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
-    int *);
+    size_t *);
 
 #endif

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

@@ -104 +104 @@
         measured_string_t names[] = {
                 {
-                        (char *) "UDP_CHECKSUM_COMPUTING",
+                        (uint8_t *) "UDP_CHECKSUM_COMPUTING",
                         22
                 },
                 {
-                        (char *) "UDP_AUTOBINDING",
+                        (uint8_t *) "UDP_AUTOBINDING",
                         15
                 }
@@ -114 +114 @@
         measured_string_t *configuration;
         size_t count = sizeof(names) / sizeof(measured_string_t);
-        char *data;
+        uint8_t *data;
         int rc;
 
@@ -283 +283 @@
         /* Find the destination socket */
         socket = socket_port_find(&udp_globals.sockets,
-        ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING, 0);
+            ntohs(header->destination_port), (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
         if (!socket) {
                 if (tl_prepare_icmp_packet(udp_globals.net_phone,
@@ -707 +707 @@
         bool keep_on_going = true;
         socket_cores_t local_sockets;
-        int app_phone = IPC_GET_PHONE(&call);
+        int app_phone = IPC_GET_PHONE(call);
         struct sockaddr *addr;
         int socket_id;
@@ -713 +713 @@
         size_t size = 0;
         ipc_call_t answer;
-        int answer_count;
+        size_t answer_count;
         packet_dimension_t *packet_dimension;
 
@@ -861 +861 @@
  */
 int udp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *answer_count)
 {
         packet_t *packet;
@@ -871 +871 @@
         case NET_TL_RECEIVED:
                 rc = packet_translate_remote(udp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return udp_received_msg(IPC_GET_DEVICE(call), packet,
-                    SERVICE_UDP, IPC_GET_ERROR(call));
+                return udp_received_msg(IPC_GET_DEVICE(*call), packet,
+                    SERVICE_UDP, IPC_GET_ERROR(*call));
         case IPC_M_CONNECT_TO_ME:
-                return udp_process_client_messages(callid, * call);
+                return udp_process_client_messages(callid, *call);
         }
 
@@ -898 +898 @@
         while (true) {
                 ipc_call_t answer;
-                int answer_count;
+                size_t answer_count;
                 
                 /* Clear the answer structure */

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

@@ -87 +87 @@
 
 int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
 {
-        return udp_message_standalone(callid, call, answer, answer_count);
+        return udp_message_standalone(callid, call, answer, count);
 }
 

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

@@ -44 +44 @@
 extern int udp_initialize(async_client_conn_t);
 extern int udp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
-    int *);
+    size_t *);
 
 #endif