Changeset d7ff048 in mainline for uspace/srv

Timestamp:

2011-10-08T13:08:53Z (14 years ago)

Author:

Maurizio Lombardi <m.lombardi85@…>

Branches:

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

Children:

bf08ff0

Parents:

8367d1d (diff), 80099c19 (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

Files:

• devman/devman.c (modified) (2 diffs)
• devman/main.c (modified) (1 diff)
• fs/fat/fat.h (modified) (1 diff)
• fs/fat/fat_ops.c (modified) (2 diffs)
• hw/irc/apic/apic.c (modified) (1 diff)
• hw/netif/ne2000/ne2000.c (deleted)
• loc/loc.c (modified) (1 diff)
• net/cfg/lo.nic (moved) (moved from uspace/srv/net/cfg/lo ) (1 diff)
• net/cfg/ne2k.nic (moved) (moved from uspace/srv/net/cfg/ne2k ) (2 diffs)
• net/documentation.txt (deleted)
• net/il/arp/arp.c (modified) (15 diffs)
• net/il/arp/arp.h (modified) (1 diff)
• net/il/ip/ip.c (modified) (22 diffs)
• net/il/ip/ip.h (modified) (2 diffs)
• net/net/Makefile (modified) (2 diffs)
• net/net/net.c (modified) (20 diffs)
• net/net/net.h (modified) (9 diffs)
• net/net/net_standalone.c (deleted)
• net/net/packet_server.c (moved) (moved from uspace/lib/packet/generic/packet_server.c ) (18 diffs)
• net/net/packet_server.h (moved) (moved from uspace/lib/packet/include/packet_server.h ) (2 diffs)
• net/netif/lo/lo.c (deleted)
• net/nil/eth/eth.c (modified) (35 diffs)
• net/nil/eth/eth.h (modified) (5 diffs)
• net/nil/nildummy/nildummy.c (modified) (22 diffs)
• net/nil/nildummy/nildummy.h (modified) (4 diffs)
• net/tl/icmp/icmp.c (modified) (1 diff)
• net/tl/tcp/tcp.c (modified) (10 diffs)
• net/tl/tcp/tcp.h (modified) (1 diff)
• net/tl/udp/udp.c (modified) (5 diffs)

uspace/srv/devman/devman.c

@@ -794 +794 @@
         case EOK:
                 dev->state = DEVICE_USABLE;
+                exch = async_exchange_begin(drv->sess);
+                async_msg_1(exch, DRIVER_DEV_ADDED, dev->handle);
+                async_exchange_end(exch);
                 break;
         case ENOENT:
@@ -1066 +1069 @@
         
         link = hash_table_find(&tree->devman_devices, &key);
+        if (link == NULL)
+                return NULL;
+        
         return hash_table_get_instance(link, dev_node_t, devman_dev);
 }

uspace/srv/devman/main.c

@@ -634 +634 @@
                                 fibril_rwlock_read_unlock(&device_tree.rwlock);
                                 dev_del_ref(dev);
+                                if (gone_rc == EOK)
+                                        gone_rc = ENOTSUP;
+                                async_answer_0(callid, gone_rc);
                                 return;
                         }

uspace/srv/fs/fat/fat.h

@@ -141 +141 @@
 } __attribute__ ((packed)) fat_bs_t;
 
+#define FAT32_FSINFO_SIG1       "RRaA"
+#define FAT32_FSINFO_SIG2       "rrAa"
+#define FAT32_FSINFO_SIG3       "\x00\x00\x55\xaa"
+
+typedef struct {
+        uint8_t sig1[4];
+        uint8_t res1[480];
+        uint8_t sig2[4];
+        uint32_t free_clusters;
+        uint32_t last_allocated_cluster;
+        uint8_t res2[12];
+        uint8_t sig3[4];
+} __attribute__ ((packed)) fat32_fsinfo_t;
+
 typedef enum {
         FAT_INVALID,

uspace/srv/fs/fat/fat_ops.c

@@ -1025 +1025 @@
 }
 
+static int fat_update_fat32_fsinfo(service_id_t service_id)
+{
+        fat_bs_t *bs;
+        fat32_fsinfo_t *info;
+        block_t *b;
+        int rc;
+
+        bs = block_bb_get(service_id);
+        assert(FAT_IS_FAT32(bs));
+
+        rc = block_get(&b, service_id, uint16_t_le2host(bs->fat32.fsinfo_sec),
+            BLOCK_FLAGS_NONE);
+        if (rc != EOK)
+                return rc;
+
+        info = (fat32_fsinfo_t *) b->data;
+
+        if (bcmp(info->sig1, FAT32_FSINFO_SIG1, sizeof(info->sig1)) ||
+            bcmp(info->sig2, FAT32_FSINFO_SIG2, sizeof(info->sig2)) ||
+            bcmp(info->sig3, FAT32_FSINFO_SIG3, sizeof(info->sig3))) {
+                (void) block_put(b);
+                return EINVAL;
+        }
+
+        /* For now, invalidate the counter. */
+        info->free_clusters = host2uint16_t_le(-1);
+
+        b->dirty = true;
+        return block_put(b);
+}
+
 static int fat_unmounted(service_id_t service_id)
 {
         fs_node_t *fn;
         fat_node_t *nodep;
-        int rc;
+        fat_bs_t *bs;
+        int rc;
+
+        bs = block_bb_get(service_id);
 
         rc = fat_root_get(&fn, service_id);
@@ -1043 +1077 @@
                 (void) fat_node_put(fn);
                 return EBUSY;
+        }
+
+        if (FAT_IS_FAT32(bs)) {
+                /*
+                 * Attempt to update the FAT32 FS info.
+                 */
+                (void) fat_update_fat32_fsinfo(service_id);
         }
 

uspace/srv/hw/irc/apic/apic.c

@@ -206 +206 @@
         }
 
-        if (pio_enable((void *) IO_APIC_BASE, IO_APIC_SIZE,
-            (void **) &io_apic) != EOK)
+        int rc = pio_enable((void *) IO_APIC_BASE, IO_APIC_SIZE,
+                (void **) &io_apic);
+        if (rc != EOK) {
+                printf("%s: Failed to enable PIO for APIC: %d\n", NAME, rc);
                 return false;   
+        }
         
         async_set_client_connection(apic_connection);

uspace/srv/loc/loc.c

@@ -1288 +1288 @@
         cat = category_new("virtual");
         categ_dir_add_cat(&cdir, cat);
-
-
+        
+        cat = category_new("nic");
+        categ_dir_add_cat(&cdir, cat);
+        
         return true;
 }

uspace/srv/net/cfg/lo.nic

@@ -3 +3 @@
 NAME=lo
 
-NETIF=lo
+HWPATH=/virt/lo/port0
 NIL=nildummy
 IL=ip

uspace/srv/net/cfg/ne2k.nic

@@ -1 @@
-# DP8390 (NE2k) configuration
+# NE2000 configuration
 
 NAME=ne2k
 
-NETIF=ne2000
+HWPATH=/hw/pci0/00:01.0/ne2k/port0
 NIL=eth
 IL=ip
-
-IRQ=5
-IO=300
 
 # 8023_2_LSAP, 8023_2_SNAP
@@ -17 +14 @@
 IP_ADDR=10.0.2.15
 IP_ROUTING=yes
-IP_NETMASK=255.255.255.0
+IP_NETMASK=255.255.255.240
 IP_BROADCAST=10.0.2.255
 IP_GATEWAY=10.0.2.2

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

@@ -174 +174 @@
                     count);
                 
-                if (device) {
+                if (device)
                         arp_clear_device(device);
-                        if (device->addr_data)
-                                free(device->addr_data);
-                        
-                        if (device->broadcast_data)
-                                free(device->broadcast_data);
-                }
         }
         
@@ -190 +184 @@
 }
 
-static int arp_clear_address_req(device_id_t device_id, services_t protocol,
-    measured_string_t *address)
+static int arp_clear_address_req(nic_device_id_t device_id,
+    services_t protocol, measured_string_t *address)
 {
         fibril_mutex_lock(&arp_globals.lock);
@@ -218 +212 @@
 }
 
-static int arp_clear_device_req(device_id_t device_id)
+static int arp_clear_device_req(nic_device_id_t device_id)
 {
         fibril_mutex_lock(&arp_globals.lock);
@@ -289 +283 @@
  *
  */
-static int arp_receive_message(device_id_t device_id, packet_t *packet)
+static int arp_receive_message(nic_device_id_t device_id, packet_t *packet)
 {
         int rc;
@@ -365 +359 @@
                         memcpy(src_proto, proto->addr->value,
                             header->protocol_length);
-                        memcpy(src_hw, device->addr->value,
+                        memcpy(src_hw, device->addr,
                             device->packet_dimension.addr_len);
                         memcpy(des_hw, trans->hw_addr->value,
@@ -393 +387 @@
  *
  */
-static int arp_mtu_changed_message(device_id_t device_id, size_t mtu)
+static int arp_mtu_changed_message(nic_device_id_t device_id, size_t mtu)
 {
         fibril_mutex_lock(&arp_globals.lock);
@@ -409 +403 @@
         printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu);
         
+        return EOK;
+}
+
+static int arp_addr_changed_message(nic_device_id_t device_id)
+{
+        uint8_t addr_buffer[NIC_MAX_ADDRESS_LENGTH];
+        size_t length;
+        ipc_callid_t data_callid;
+        if (!async_data_write_receive(&data_callid, &length)) {
+                async_answer_0(data_callid, EINVAL);
+                return EINVAL;
+        }
+        if (length > NIC_MAX_ADDRESS_LENGTH) {
+                async_answer_0(data_callid, ELIMIT);
+                return ELIMIT;
+        }
+        if (async_data_write_finalize(data_callid, addr_buffer, length) != EOK) {
+                return EINVAL;
+        }
+
+        fibril_mutex_lock(&arp_globals.lock);
+
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device) {
+                fibril_mutex_unlock(&arp_globals.lock);
+                return ENOENT;
+        }
+
+        memcpy(device->addr, addr_buffer, length);
+        device->addr_len = length;
+
+        fibril_mutex_unlock(&arp_globals.lock);
         return EOK;
 }
@@ -456 +482 @@
                         async_answer_0(iid, (sysarg_t) rc);
                         break;
+                case NET_IL_ADDR_CHANGED:
+                        rc = arp_addr_changed_message(IPC_GET_DEVICE(*icall));
+                        async_answer_0(iid, (sysarg_t) rc);
                 
                 default:
@@ -483 +512 @@
  *
  */
-static int arp_device_message(device_id_t device_id, services_t service,
+static int arp_device_message(nic_device_id_t device_id, services_t service,
     services_t protocol, measured_string_t *address)
 {
@@ -586 +615 @@
                 
                 /* Get hardware address */
-                rc = nil_get_addr_req(device->sess, device_id, &device->addr,
-                    &device->addr_data);
-                if (rc != EOK) {
+                int len = nil_get_addr_req(device->sess, device_id, device->addr,
+                    NIC_MAX_ADDRESS_LENGTH);
+                if (len < 0) {
                         fibril_mutex_unlock(&arp_globals.lock);
                         arp_protos_destroy(&device->protos, free);
                         free(device);
-                        return rc;
-                }
+                        return len;
+                }
+                
+                device->addr_len = len;
                 
                 /* Get broadcast address */
-                rc = nil_get_broadcast_addr_req(device->sess, device_id,
-                    &device->broadcast_addr, &device->broadcast_data);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&arp_globals.lock);
-                        free(device->addr);
-                        free(device->addr_data);
+                len = nil_get_broadcast_addr_req(device->sess, device_id,
+                    device->broadcast_addr, NIC_MAX_ADDRESS_LENGTH);
+                if (len < 0) {
+                        fibril_mutex_unlock(&arp_globals.lock);
                         arp_protos_destroy(&device->protos, free);
                         free(device);
-                        return rc;
-                }
+                        return len;
+                }
+                
+                device->broadcast_addr_len = len;
                 
                 rc = arp_cache_add(&arp_globals.cache, device->device_id,
@@ -611 +642 @@
                 if (rc != EOK) {
                         fibril_mutex_unlock(&arp_globals.lock);
-                        free(device->addr);
-                        free(device->addr_data);
-                        free(device->broadcast_addr);
-                        free(device->broadcast_data);
                         arp_protos_destroy(&device->protos, free);
                         free(device);
@@ -640 +667 @@
 }
 
-static int arp_send_request(device_id_t device_id, services_t protocol,
+static int arp_send_request(nic_device_id_t device_id, services_t protocol,
     measured_string_t *target, arp_device_t *device, arp_proto_t *proto)
 {
         /* ARP packet content size = header + (address + translation) * 2 */
-        size_t length = 8 + 2 * (proto->addr->length + device->addr->length);
+        size_t length = 8 + 2 * (proto->addr->length + device->addr_len);
         if (length > device->packet_dimension.content)
                 return ELIMIT;
@@ -661 +688 @@
         
         header->hardware = htons(device->hardware);
-        header->hardware_length = (uint8_t) device->addr->length;
+        header->hardware_length = (uint8_t) device->addr_len;
         header->protocol = htons(protocol_map(device->service, protocol));
         header->protocol_length = (uint8_t) proto->addr->length;
@@ -667 +694 @@
         
         length = sizeof(arp_header_t);
-        
-        memcpy(((uint8_t *) header) + length, device->addr->value,
-            device->addr->length);
-        length += device->addr->length;
+        memcpy(((uint8_t *) header) + length, device->addr,
+            device->addr_len);
+        length += device->addr_len;
         memcpy(((uint8_t *) header) + length, proto->addr->value,
             proto->addr->length);
         length += proto->addr->length;
-        bzero(((uint8_t *) header) + length, device->addr->length);
-        length += device->addr->length;
+        bzero(((uint8_t *) header) + length, device->addr_len);
+        length += device->addr_len;
         memcpy(((uint8_t *) header) + length, target->value, target->length);
-        
-        int rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
-            (uint8_t *) device->broadcast_addr->value, device->addr->length);
+
+        int rc = packet_set_addr(packet, device->addr, device->broadcast_addr,
+            device->addr_len);
         if (rc != EOK) {
                 pq_release_remote(arp_globals.net_sess, packet_get_id(packet));
@@ -704 +730 @@
  *
  */
-static int arp_translate_message(device_id_t device_id, services_t protocol,
+static int arp_translate_message(nic_device_id_t device_id, services_t protocol,
     measured_string_t *target, measured_string_t **translation)
 {

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

@@ -92 +92 @@
 struct arp_device {
         /** Actual device hardware address. */
-        measured_string_t *addr;
-        /** Actual device hardware address data. */
-        uint8_t *addr_data;
+        uint8_t addr[NIC_MAX_ADDRESS_LENGTH];
+        /** Actual device hardware address length. */
+        size_t addr_len;
         /** Broadcast device hardware address. */
-        measured_string_t *broadcast_addr;
-        /** Broadcast device hardware address data. */
-        uint8_t *broadcast_data;
+        uint8_t broadcast_addr[NIC_MAX_ADDRESS_LENGTH];
+        /** Broadcast device hardware address length. */
+        size_t broadcast_addr_len;
         /** Device identifier. */
-        device_id_t device_id;
+        nic_device_id_t device_id;
         /** Hardware type. */
         hw_type_t hardware;

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

@@ -354 +354 @@
         ip_netif->routing = NET_DEFAULT_IP_ROUTING;
         configuration = &names[0];
-
+        
         /* Get configuration */
         rc = net_get_device_conf_req(ip_globals.net_sess, ip_netif->device_id,
@@ -406 +406 @@
                         return ENOTSUP;
                 }
-
+                
                 if (configuration[6].value) {
                         ip_netif->arp = get_running_module(&ip_globals.modules,
@@ -417 +417 @@
                         }
                 }
+                
                 if (configuration[7].value)
                         ip_netif->routing = (configuration[7].value[0] == 'y');
-
+                
                 net_free_settings(configuration, data);
         }
-
+        
         /* Bind netif service which also initializes the device */
         ip_netif->sess = nil_bind_service(ip_netif->service,
@@ -432 +433 @@
                 return ENOENT;
         }
-
+        
         /* Has to be after the device netif module initialization */
         if (ip_netif->arp) {
@@ -448 +449 @@
                 }
         }
-
+        
         /* Get packet dimensions */
         rc = nil_packet_size_req(ip_netif->sess, ip_netif->device_id,
@@ -461 +462 @@
                 ip_netif->packet_dimension.content = IP_MIN_CONTENT;
         }
-
+        
         index = ip_netifs_add(&ip_globals.netifs, ip_netif->device_id, ip_netif);
         if (index < 0)
@@ -478 +479 @@
                 printf("%s: Default gateway (%s)\n", NAME, defgateway);
         }
-
+        
         return EOK;
 }
 
-static int ip_device_req_local(device_id_t device_id, services_t netif)
+static int ip_device_req_local(nic_device_id_t device_id, services_t netif)
 {
         ip_netif_t *ip_netif;
@@ -498 +499 @@
                 return rc;
         }
-
+        
         ip_netif->device_id = device_id;
         ip_netif->service = netif;
-        ip_netif->state = NETIF_STOPPED;
-
+        ip_netif->state = NIC_STATE_STOPPED;
+        
         fibril_rwlock_write_lock(&ip_globals.netifs_lock);
 
@@ -594 +595 @@
         while (index >= 0) {
                 netif = ip_netifs_get_index(&ip_globals.netifs, index);
-                if (netif && (netif->state == NETIF_ACTIVE)) {
+                if (netif && (netif->state == NIC_STATE_ACTIVE)) {
                         route = ip_netif_find_route(netif, destination);
                         if (route)
@@ -1142 +1143 @@
 }
 
-static int ip_send_msg_local(device_id_t device_id, packet_t *packet,
+static int ip_send_msg_local(nic_device_id_t device_id, packet_t *packet,
     services_t sender, services_t error)
 {
@@ -1258 +1259 @@
  * @return              ENOENT if device is not found.
  */
-static int ip_device_state_message(device_id_t device_id, device_state_t state)
+static int ip_device_state_message(nic_device_id_t device_id,
+    nic_device_state_t state)
 {
         ip_netif_t *netif;
@@ -1272 +1274 @@
         fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
 
-        printf("%s: Device %d changed state to %d\n", NAME, device_id, state);
+        printf("%s: Device %d changed state to '%s'\n", NAME, device_id,
+            nic_device_state_to_string(state));
 
         return EOK;
@@ -1312 +1315 @@
  *                      tl_received_msg() function.
  */
-static int ip_deliver_local(device_id_t device_id, packet_t *packet,
+static int ip_deliver_local(nic_device_id_t device_id, packet_t *packet,
     ip_header_t *header, services_t error)
 {
@@ -1413 +1416 @@
  *                      is disabled.
  */
-static int ip_process_packet(device_id_t device_id, packet_t *packet)
+static int ip_process_packet(nic_device_id_t device_id, packet_t *packet)
 {
         ip_header_t *header;
@@ -1514 +1517 @@
  *
  */
-static int ip_packet_size_message(device_id_t device_id, size_t *addr_len,
+static int ip_packet_size_message(nic_device_id_t device_id, size_t *addr_len,
     size_t *prefix, size_t *content, size_t *suffix)
 {
@@ -1572 +1575 @@
  * @return              ENOENT if device is not found.
  */
-static int ip_mtu_changed_message(device_id_t device_id, size_t mtu)
+static int ip_mtu_changed_message(nic_device_id_t device_id, size_t mtu)
 {
         ip_netif_t *netif;
@@ -1629 +1632 @@
                         async_answer_0(iid, (sysarg_t) rc);
                         break;
-                
+                case NET_IL_ADDR_CHANGED:
+                        async_answer_0(iid, (sysarg_t) EOK);
+                        break;
+
                 default:
                         async_answer_0(iid, (sysarg_t) ENOTSUP);
@@ -1689 +1695 @@
 }
 
-static int ip_add_route_req_local(device_id_t device_id, in_addr_t address,
+static int ip_add_route_req_local(nic_device_id_t device_id, in_addr_t address,
     in_addr_t netmask, in_addr_t gateway)
 {
@@ -1723 +1729 @@
 }
 
-static int ip_set_gateway_req_local(device_id_t device_id, in_addr_t gateway)
+static int ip_set_gateway_req_local(nic_device_id_t device_id,
+    in_addr_t gateway)
 {
         ip_netif_t *netif;
@@ -1757 +1764 @@
  *
  */
-static int ip_received_error_msg_local(device_id_t device_id,
+static int ip_received_error_msg_local(nic_device_id_t device_id,
     packet_t *packet, services_t target, services_t error)
 {
@@ -1818 +1825 @@
 static int ip_get_route_req_local(ip_protocol_t protocol,
     const struct sockaddr *destination, socklen_t addrlen,
-    device_id_t *device_id, void **header, size_t *headerlen)
+    nic_device_id_t *device_id, void **header, size_t *headerlen)
 {
         struct sockaddr_in *address_in;
@@ -1909 +1916 @@
         size_t suffix;
         size_t content;
-        device_id_t device_id;
+        nic_device_id_t device_id;
         int rc;
         

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

@@ -92 +92 @@
         in_addr_t broadcast;
         /** Device identifier. */
-        device_id_t device_id;
+        nic_device_id_t device_id;
         /** Indicates whether using DHCP. */
         int dhcp;
@@ -108 +108 @@
         services_t service;
         /** Device state. */
-        device_state_t state;
+        nic_device_state_t state;
 };
 

uspace/srv/net/net/Makefile

@@ -30 +30 @@
 USPACE_PREFIX = ../../..
 ROOT_PATH = $(USPACE_PREFIX)/..
-LIBS = $(LIBNET_PREFIX)/libnet.a $(LIBPACKET_PREFIX)/libpacket.a
-EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include -I$(LIBPACKET_PREFIX)/include
+LIBS = $(LIBNET_PREFIX)/libnet.a
+EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
 
 COMMON_MAKEFILE = $(ROOT_PATH)/Makefile.common
@@ -43 +43 @@
 SOURCES = \
         net.c \
-        net_standalone.c
+        packet_server.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/srv/net/net/net.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -31 +32 @@
  */
 
-/** @file
- * Networking subsystem central module implementation.
- *
- */
-
+#include <assert.h>
 #include <async.h>
 #include <ctype.h>
 #include <ddi.h>
 #include <errno.h>
+#include <str_error.h>
 #include <malloc.h>
 #include <stdio.h>
 #include <str.h>
+#include <devman.h>
 #include <str_error.h>
 #include <ns.h>
@@ -49 +48 @@
 #include <ipc/net_net.h>
 #include <ipc/il.h>
+#include <ipc/ip.h>
 #include <ipc/nil.h>
-#include <net/modules.h>
 #include <net/packet.h>
 #include <net/device.h>
@@ -57 +56 @@
 #include <adt/measured_strings.h>
 #include <adt/module_map.h>
-#include <netif_remote.h>
 #include <nil_remote.h>
 #include <net_interface.h>
 #include <ip_interface.h>
+#include <device/nic.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <cfg.h>
 #include "net.h"
-
-/** Networking module name. */
-#define NAME  "net"
-
-/** File read buffer size. */
-#define BUFFER_SIZE  256
+#include "packet_server.h"
+
+#define MAX_PATH_LENGTH  1024
 
 /** Networking module global data. */
@@ -74 +73 @@
 GENERIC_CHAR_MAP_IMPLEMENT(measured_strings, measured_string_t);
 DEVICE_MAP_IMPLEMENT(netifs, netif_t);
-
-static int startup(void);
 
 /** Add the configured setting to the configuration map.
@@ -87 +84 @@
  *
  */
-int add_configuration(measured_strings_t *configuration, const uint8_t *name,
-    const uint8_t *value)
+static int add_configuration(measured_strings_t *configuration,
+    const uint8_t *name, const uint8_t *value)
 {
         int rc;
@@ -109 +106 @@
 /** Generate new system-unique device identifier.
  *
- * @return              The system-unique devic identifier.
- */
-static device_id_t generate_new_device_id(void)
+ * @return The system-unique devic identifier.
+ *
+ */
+static nic_device_id_t generate_new_device_id(void)
 {
         return device_assign_devno();
-}
-
-static int parse_line(measured_strings_t *configuration, uint8_t *line)
-{
-        int rc;
-        
-        /* From the beginning */
-        uint8_t *name = line;
-        
-        /* Skip comments and blank lines */
-        if ((*name == '#') || (*name == '\0'))
-                return EOK;
-        
-        /* Skip spaces */
-        while (isspace(*name))
-                name++;
-        
-        /* Remember the name start */
-        uint8_t *value = name;
-        
-        /* Skip the name */
-        while (isalnum(*value) || (*value == '_'))
-                value++;
-        
-        if (*value == '=') {
-                /* Terminate the name */
-                *value = '\0';
-        } else {
-                /* Terminate the name */
-                *value = '\0';
-                
-                /* Skip until '=' */
-                value++;
-                while ((*value) && (*value != '='))
-                        value++;
-                
-                /* Not found? */
-                if (*value != '=')
-                        return EINVAL;
-        }
-        
-        value++;
-        
-        /* Skip spaces */
-        while (isspace(*value))
-                value++;
-        
-        /* Create a bulk measured string till the end */
-        measured_string_t *setting =
-            measured_string_create_bulk(value, 0);
-        if (!setting)
-                return ENOMEM;
-        
-        /* Add the configuration setting */
-        rc = measured_strings_add(configuration, name, 0, setting);
-        if (rc != EOK) {
-                free(setting);
-                return rc;
-        }
-        
-        return EOK;
 }
 
@@ -182 +119 @@
         printf("%s: Reading configuration file %s/%s\n", NAME, directory, filename);
         
-        /* Construct the full filename */
-        char fname[BUFFER_SIZE];
-        if (snprintf(fname, BUFFER_SIZE, "%s/%s", directory, filename) > BUFFER_SIZE)
-                return EOVERFLOW;
-        
-        /* Open the file */
-        FILE *cfg = fopen(fname, "r");
-        if (!cfg)
+        cfg_file_t cfg;
+        int rc = cfg_load_path(directory, filename, &cfg);
+        if (rc != EOK)
+                return rc;
+        
+        if (cfg_anonymous(&cfg) == NULL) {
+                cfg_unload(&cfg);
                 return ENOENT;
-        
-        /*
-         * Read the configuration line by line
-         * until an error or the end of file
-         */
-        unsigned int line_number = 0;
-        size_t index = 0;
-        uint8_t line[BUFFER_SIZE];
-        
-        while (!ferror(cfg) && !feof(cfg)) {
-                int read = fgetc(cfg);
-                if ((read > 0) && (read != '\n') && (read != '\r')) {
-                        if (index >= BUFFER_SIZE) {
-                                line[BUFFER_SIZE - 1] = '\0';
-                                fprintf(stderr, "%s: Configuration line %u too "
-                                    "long: %s\n", NAME, line_number, (char *) line);
-                                
-                                /* No space left in the line buffer */
-                                return EOVERFLOW;
-                        }
-                        /* Append the character */
-                        line[index] = (uint8_t) read;
-                        index++;
-                } else {
-                        /* On error or new line */
-                        line[index] = '\0';
-                        line_number++;
-                        if (parse_line(configuration, line) != EOK) {
-                                fprintf(stderr, "%s: Configuration error on "
-                                    "line %u: %s\n", NAME, line_number, (char *) line);
-                        }
-                        
-                        index = 0;
+        }
+        
+        cfg_section_foreach(cfg_anonymous(&cfg), link) {
+                const cfg_entry_t *entry = cfg_entry_instance(link);
+                
+                rc = add_configuration(configuration,
+                    (uint8_t *) entry->key, (uint8_t *) entry->value);
+                if (rc != EOK) {
+                        cfg_unload(&cfg);
+                        return rc;
                 }
         }
         
-        fclose(cfg);
+        cfg_unload(&cfg);
         return EOK;
 }
@@ -255 +168 @@
         return read_configuration_file(CONF_DIR, CONF_GENERAL_FILE,
             &net_globals.configuration);
-}
-
-/** Initialize the networking module.
- *
- * @param[in] client_connection The client connection processing
- *                              function. The module skeleton propagates
- *                              its own one.
- *
- * @return EOK on success.
- * @return ENOMEM if there is not enough memory left.
- *
- */
-static int net_initialize(async_client_conn_t client_connection)
-{
-        int rc;
-        
-        netifs_initialize(&net_globals.netifs);
-        char_map_initialize(&net_globals.netif_names);
-        modules_initialize(&net_globals.modules);
-        measured_strings_initialize(&net_globals.configuration);
-        
-        /* TODO: dynamic configuration */
-        rc = read_configuration();
-        if (rc != EOK)
-                return rc;
-        
-        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 *) NE2000_NAME,
-            (uint8_t *) NE2000_FILENAME, SERVICE_NE2000, 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;
-        
-        /* Build specific initialization */
-        return net_initialize_build(client_connection);
-}
-
-/** Start the networking module.
- *
- * Initializes the client connection serving function,
- * initializes the module, registers the module service
- * and starts the async manager, processing IPC messages
- * in an infinite loop.
- *
- * @param[in] client_connection The client connection
- *                              processing function. The
- *                              module skeleton propagates
- *                              its own one.
- *
- * @return EOK on successful module termination.
- * @return Other error codes as defined for the net_initialize() function.
- * @return Other error codes as defined for the REGISTER_ME() macro function.
- *
- */
-static int net_module_start(async_client_conn_t client_connection)
-{
-        int rc;
-        
-        async_set_client_connection(client_connection);
-        rc = pm_init();
-        if (rc != EOK)
-                return rc;
-        
-        rc = net_initialize(client_connection);
-        if (rc != EOK)
-                goto out;
-        
-        rc = service_register(SERVICE_NETWORKING);
-        if (rc != EOK)
-                goto out;
-        
-        rc = startup();
-        if (rc != EOK)
-                goto out;
-        
-        task_retval(0);
-        async_manager();
-
-out:
-        pm_destroy();
-        return rc;
 }
 
@@ -364 +183 @@
  */
 static int net_get_conf(measured_strings_t *netif_conf,
-    measured_string_t *configuration, size_t count, uint8_t **data)
-{
-        if (data)
-                *data = NULL;
+    measured_string_t *configuration, size_t count)
+{
+        if ((!configuration) || (count <= 0))
+                        return EINVAL;
         
         size_t index;
@@ -389 +208 @@
 }
 
-static int net_get_conf_req_local(measured_string_t **configuration,
-    size_t count, uint8_t **data)
-{
-        if (!configuration || (count <= 0))
-                return EINVAL;
-        
-        return net_get_conf(NULL, *configuration, count, data);
-}
-
-static int net_get_device_conf_req_local(device_id_t device_id,
-    measured_string_t **configuration, size_t count, uint8_t **data)
-{
-        if ((!configuration) || (count == 0))
-                return EINVAL;
-
+static int net_get_device_conf(nic_device_id_t device_id,
+    measured_string_t *configuration, size_t count)
+{
         netif_t *netif = netifs_find(&net_globals.netifs, device_id);
         if (netif)
-                return net_get_conf(&netif->configuration, *configuration, count, data);
+                return net_get_conf(&netif->configuration, configuration, count);
         else
-                return net_get_conf(NULL, *configuration, count, data);
-}
-
-void net_free_settings(measured_string_t *settings, uint8_t *data)
-{
+                return net_get_conf(NULL, configuration, count);
+}
+
+static int net_get_devices(measured_string_t **devices, size_t *dev_count)
+{
+        if (!devices)
+                return EBADMEM;
+        
+        size_t max_count = netifs_count(&net_globals.netifs);
+        *devices = malloc(max_count * sizeof(measured_string_t));
+        if (*devices == NULL)
+                return ENOMEM;
+        
+        size_t count = 0;
+        for (size_t i = 0; i < max_count; i++) {
+                netif_t *item = netifs_get_index(&net_globals.netifs, i);
+                if (item->sess != NULL) {
+                        /* 
+                         * Use format "device_id:device_name"
+                         * FIXME: This typecasting looks really ugly
+                         */
+                        (*devices)[count].length = asprintf(
+                            (char **) &((*devices)[count].value),
+                            NIC_DEVICE_PRINT_FMT ":%s", item->id,
+                            (const char *) item->name);
+                        count++;
+                }
+        }
+        
+        *dev_count = (size_t) count;
+        return EOK;
+}
+
+static int net_get_devices_count()
+{
+        size_t max_count = netifs_count(&net_globals.netifs);
+        
+        size_t count = 0;
+        for (size_t i = 0; i < max_count; i++) {
+                netif_t *item = netifs_get_index(&net_globals.netifs, i);
+                if (item->sess != NULL)
+                        count++;
+        }
+        
+        return count;
+}
+
+static void net_free_devices(measured_string_t *devices, size_t count)
+{
+        size_t i;
+        for (i = 0; i < count; ++i)
+                free(devices[i].value);
+        
+        free(devices);
 }
 
@@ -431 +287 @@
  *
  */
-static int start_device(netif_t *netif)
-{
-        int rc;
-        
-        /* Mandatory netif */
-        measured_string_t *setting =
-            measured_strings_find(&netif->configuration, (uint8_t *) CONF_NETIF, 0);
-        
-        netif->driver = get_running_module(&net_globals.modules, setting->value);
-        if (!netif->driver) {
-                fprintf(stderr, "%s: Failed to start network interface driver '%s'\n",
-                    NAME, setting->value);
-                return EINVAL;
+static int init_device(netif_t *netif, devman_handle_t handle)
+{
+        printf("%s: Initializing device '%s'\n", NAME, netif->name);
+        
+        netif->handle = handle;
+        netif->sess = devman_device_connect(EXCHANGE_SERIALIZE, netif->handle,
+            IPC_FLAG_BLOCKING);
+        if (netif->sess == NULL) {
+                printf("%s: Unable to connect to device\n", NAME);
+                return EREFUSED;
         }
         
         /* Optional network interface layer */
-        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_NIL, 0);
+        measured_string_t *setting = measured_strings_find(&netif->configuration,
+            (uint8_t *) CONF_NIL, 0);
         if (setting) {
-                netif->nil = get_running_module(&net_globals.modules, setting->value);
+                netif->nil = get_running_module(&net_globals.modules,
+                    setting->value);
                 if (!netif->nil) {
-                        fprintf(stderr, "%s: Failed to start network interface layer '%s'\n",
+                        printf("%s: Unable to connect to network interface layer '%s'\n",
                             NAME, setting->value);
                         return EINVAL;
@@ -459 +314 @@
         
         /* Mandatory internet layer */
-        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_IL, 0);
-        netif->il = get_running_module(&net_globals.modules, setting->value);
+        setting = measured_strings_find(&netif->configuration,
+            (uint8_t *) CONF_IL, 0);
+        netif->il = get_running_module(&net_globals.modules,
+            setting->value);
         if (!netif->il) {
-                fprintf(stderr, "%s: Failed to start internet layer '%s'\n",
+                printf("%s: Unable to connect to internet layer '%s'\n",
                     NAME, setting->value);
                 return EINVAL;
         }
         
-        /* Hardware configuration */
-        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->sess, netif->id, irq, (void *) io);
-        if (rc != EOK)
-                return rc;
-        
         /* Network interface layer startup */
-        services_t internet_service;
+        int rc;
+        services_t nil_service;
         if (netif->nil) {
-                setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_MTU, 0);
+                setting = measured_strings_find(&netif->configuration,
+                    (uint8_t *) CONF_MTU, 0);
                 if (!setting)
                         setting = measured_strings_find(&net_globals.configuration,
                             (uint8_t *) CONF_MTU, 0);
                 
-                int mtu = setting ? strtol((char *) setting->value, NULL, 10) : 0;
-                rc = nil_device_req(netif->nil->sess, netif->id, mtu,
-                    netif->driver->service);
+                int mtu = setting ?
+                    strtol((const char *) setting->value, NULL, 10) : 0;
+                rc = nil_device_req(netif->nil->sess, netif->id,
+                    netif->handle, mtu);
+                if (rc != EOK) {
+                        printf("%s: Unable to start network interface layer\n",
+                            NAME);
+                        return rc;
+                }
+                
+                nil_service = netif->nil->service;
+        } else
+                nil_service = -1;
+        
+        /* Inter-network layer startup */
+        switch (netif->il->service) {
+        case SERVICE_IP:
+                rc = ip_device_req(netif->il->sess, netif->id, nil_service);
+                if (rc != EOK) {
+                        printf("%s: Unable to start internet layer\n", NAME);
+                        return rc;
+                }
+                
+                break;
+        default:
+                return ENOENT;
+        }
+        
+        printf("%s: Activating device '%s'\n", NAME, netif->name);
+        return nic_set_state(netif->sess, NIC_STATE_ACTIVE);
+}
+
+static int net_port_ready(devman_handle_t handle)
+{
+        char hwpath[MAX_PATH_LENGTH];
+        int rc = devman_fun_get_path(handle, hwpath, MAX_PATH_LENGTH);
+        if (rc != EOK)
+                return EINVAL;
+        
+        int index = char_map_find(&net_globals.netif_hwpaths,
+            (uint8_t *) hwpath, 0);
+        if (index == CHAR_MAP_NULL)
+                return ENOENT;
+        
+        netif_t *netif = netifs_get_index(&net_globals.netifs, index);
+        if (netif == NULL)
+                return ENOENT;
+        
+        rc = init_device(netif, handle);
+        if (rc != EOK)
+                return rc;
+        
+        /* Increment module usage */
+        if (netif->nil)
+                netif->nil->usage++;
+        
+        netif->il->usage++;
+        
+        return EOK;
+}
+
+static int net_driver_ready_local(devman_handle_t handle)
+{
+        devman_handle_t *funs;
+        size_t count;
+        int rc = devman_dev_get_functions(handle, &funs, &count);
+        if (rc != EOK)
+                return rc;
+        
+        for (size_t i = 0; i < count; i++) {
+                rc = net_port_ready(funs[i]);
                 if (rc != EOK)
                         return rc;
-                
-                internet_service = netif->nil->service;
-        } else
-                internet_service = netif->driver->service;
-        
-        /* Inter-network layer startup */
-        rc = ip_device_req(netif->il->sess, netif->id, internet_service);
-        if (rc != EOK)
-                return rc;
-        
-        return netif_start_req(netif->driver->sess, netif->id);
-}
-
-/** Read the configuration and start all network interfaces.
- *
- * @return EOK on success.
- * @return EXDEV if there is no available system-unique device identifier.
- * @return EINVAL if any of the network interface names are not configured.
- * @return ENOMEM if there is not enough memory left.
- * @return Other error codes as defined for the read_configuration()
- *         function.
- * @return Other error codes as defined for the read_netif_configuration()
- *         function.
- * @return Other error codes as defined for the start_device() function.
- *
- */
-static int startup(void)
-{
-        const char *conf_files[] = {
-                "lo",
-                "ne2k"
-        };
-        size_t count = sizeof(conf_files) / sizeof(char *);
-        int rc;
-        
-        size_t i;
-        for (i = 0; i < count; i++) {
-                netif_t *netif = (netif_t *) malloc(sizeof(netif_t));
-                if (!netif)
-                        return ENOMEM;
-                
-                netif->id = generate_new_device_id();
-                if (!netif->id)
-                        return EXDEV;
-                
-                rc = measured_strings_initialize(&netif->configuration);
-                if (rc != EOK)
-                        return rc;
-                
-                /* Read configuration files */
-                rc = read_netif_configuration(conf_files[i], netif);
-                if (rc != EOK) {
-                        measured_strings_destroy(&netif->configuration, free);
-                        free(netif);
-                        return rc;
-                }
-                
-                /* Mandatory name */
-                measured_string_t *setting =
-                    measured_strings_find(&netif->configuration, (uint8_t *) CONF_NAME, 0);
-                if (!setting) {
-                        fprintf(stderr, "%s: Network interface name is missing\n", NAME);
-                        measured_strings_destroy(&netif->configuration, free);
-                        free(netif);
-                        return EINVAL;
-                }
-                netif->name = setting->value;
-                
-                /* Add to the netifs map */
-                int index = netifs_add(&net_globals.netifs, netif->id, netif);
-                if (index < 0) {
-                        measured_strings_destroy(&netif->configuration, free);
-                        free(netif);
-                        return index;
-                }
-                
-                /*
-                 * Add to the netif names map and start network interfaces
-                 * and needed modules.
-                 */
-                rc = char_map_add(&net_globals.netif_names, netif->name, 0,
-                    index);
-                if (rc != EOK) {
-                        measured_strings_destroy(&netif->configuration, free);
-                        netifs_exclude_index(&net_globals.netifs, index, free);
-                        return rc;
-                }
-                
-                rc = start_device(netif);
-                if (rc != EOK) {
-                        printf("%s: Ignoring failed interface %s (%s)\n", NAME,
-                            netif->name, str_error(rc));
-                        measured_strings_destroy(&netif->configuration, free);
-                        netifs_exclude_index(&net_globals.netifs, index, free);
-                        continue;
-                }
-                
-                /* Increment modules' usage */
-                netif->driver->usage++;
-                if (netif->nil)
-                        netif->nil->usage++;
-                netif->il->usage++;
-                
-                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 ? (char *) netif->nil->name : "[none]",
-                    netif->il->name);
         }
         
@@ -618 +427 @@
  *
  */
-int net_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
-    size_t *answer_count)
+static int net_message(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, size_t *answer_count)
 {
         measured_string_t *strings;
         uint8_t *data;
         int rc;
+        size_t count;
         
         *answer_count = 0;
@@ -636 +446 @@
                 if (rc != EOK)
                         return rc;
-                net_get_device_conf_req_local(IPC_GET_DEVICE(*call), &strings,
-                    IPC_GET_COUNT(*call), NULL);
-                
-                /* Strings should not contain received data anymore */
-                free(data);
+                
+                net_get_device_conf(IPC_GET_DEVICE(*call), strings,
+                    IPC_GET_COUNT(*call));
                 
                 rc = measured_strings_reply(strings, IPC_GET_COUNT(*call));
                 free(strings);
+                free(data);
                 return rc;
         case NET_NET_GET_CONF:
@@ -650 +459 @@
                 if (rc != EOK)
                         return rc;
-                net_get_conf_req_local(&strings, IPC_GET_COUNT(*call), NULL);
-                
-                /* Strings should not contain received data anymore */
-                free(data);
+                
+                net_get_conf(NULL, strings, IPC_GET_COUNT(*call));
                 
                 rc = measured_strings_reply(strings, IPC_GET_COUNT(*call));
                 free(strings);
-                return rc;
-        case NET_NET_STARTUP:
-                return startup();
-        }
-        
-        return ENOTSUP;
+                free(data);
+                return rc;
+        case NET_NET_GET_DEVICES_COUNT:
+                count = (size_t) net_get_devices_count();
+                IPC_SET_ARG1(*answer, count);
+                *answer_count = 1;
+                return EOK;
+        case NET_NET_GET_DEVICES:
+                rc = net_get_devices(&strings, &count);
+                if (rc != EOK)
+                        return rc;
+                
+                rc = measured_strings_reply(strings, count);
+                net_free_devices(strings, count);
+                return rc;
+        case NET_NET_DRIVER_READY:
+                rc = net_driver_ready_local(IPC_GET_ARG1(*call));
+                *answer_count = 0;
+                return rc;
+        default:
+                return ENOTSUP;
+        }
 }
 
@@ -684 +507 @@
                 /* Clear the answer structure */
                 ipc_call_t answer;
-                size_t answer_count;
-                refresh_answer(&answer, &answer_count);
+                size_t count;
+                refresh_answer(&answer, &count);
                 
                 /* Fetch the next message */
@@ -692 +515 @@
                 
                 /* Process the message */
-                int res = net_module_message(callid, &call, &answer, &answer_count);
+                int res;
+                if (IS_NET_PACKET_MESSAGE(call))
+                        res = packet_server_message(callid, &call, &answer, &count);
+                else
+                        res = net_message(callid, &call, &answer, &count);
                 
                 /* End if told to either by the message or the processing result */
@@ -699 +526 @@
                 
                 /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+                answer_call(callid, res, &answer, count);
         }
 }
@@ -705 +532 @@
 int main(int argc, char *argv[])
 {
-        return net_module_start(net_client_connection);
+        netifs_initialize(&net_globals.netifs);
+        char_map_initialize(&net_globals.netif_hwpaths);
+        modules_initialize(&net_globals.modules);
+        measured_strings_initialize(&net_globals.configuration);
+        async_set_client_connection(net_client_connection);
+        
+        int rc = pm_init();
+        if (rc != EOK) {
+                printf("%s: Unable to initialize packet management\n", NAME);
+                return rc;
+        }
+        
+        rc = packet_server_init();
+        if (rc != EOK) {
+                printf("%s: Unable to initialize packet server\n", NAME);
+                pm_destroy();
+                return rc;
+        }
+        
+        rc = read_configuration();
+        if (rc != EOK) {
+                printf("%s: Error reading configuration\n", NAME);
+                pm_destroy();
+                return rc;
+        }
+        
+        DIR *config_dir = opendir(CONF_DIR);
+        if (config_dir != NULL) {
+                struct dirent *dir_entry;
+                while ((dir_entry = readdir(config_dir))) {
+                        /* Ignore files without the CONF_EXT extension */
+                        if ((str_size(dir_entry->d_name) < str_size(CONF_EXT)) ||
+                            (str_cmp(dir_entry->d_name + str_size(dir_entry->d_name) -
+                            str_size(CONF_EXT), CONF_EXT) != 0))
+                                continue;
+                        
+                        
+                        netif_t *netif = (netif_t *) malloc(sizeof(netif_t));
+                        if (!netif)
+                                continue;
+                        
+                        netif->handle = -1;
+                        netif->sess = NULL;
+                        
+                        netif->id = generate_new_device_id();
+                        if (!netif->id) {
+                                free(netif);
+                                continue;
+                        }
+                        
+                        rc = measured_strings_initialize(&netif->configuration);
+                        if (rc != EOK) {
+                                free(netif);
+                                continue;
+                        }
+                        
+                        rc = read_netif_configuration(dir_entry->d_name, netif);
+                        if (rc != EOK) {
+                                printf("%s: Error reading configuration %s\n", NAME,
+                                    dir_entry->d_name);
+                                free(netif);
+                                continue;
+                        }
+                        
+                        measured_string_t *name = measured_strings_find(&netif->configuration,
+                            (uint8_t *) CONF_NAME, 0);
+                        if (!name) {
+                                printf("%s: Network interface name is missing in %s\n",
+                                    NAME, dir_entry->d_name);
+                                measured_strings_destroy(&netif->configuration, free);
+                                free(netif);
+                                continue;
+                        }
+                        
+                        netif->name = name->value;
+                        
+                        /* Mandatory hardware path */
+                        measured_string_t *hwpath = measured_strings_find(
+                            &netif->configuration, (const uint8_t *) CONF_HWPATH, 0);
+                        if (!hwpath) {
+                                printf("%s: Hardware path is missing in %s\n",
+                                    NAME, dir_entry->d_name);
+                                measured_strings_destroy(&netif->configuration, free);
+                                free(netif);
+                                continue;
+                        }
+                        
+                        int index = netifs_add(&net_globals.netifs, netif->id, netif);
+                        if (index < 0) {
+                                measured_strings_destroy(&netif->configuration, free);
+                                free(netif);
+                                continue;
+                        }
+                        
+                        /*
+                         * Add to the hardware paths map and init network interfaces
+                         * and needed modules.
+                         */
+                        rc = char_map_add(&net_globals.netif_hwpaths, hwpath->value, 0, index);
+                        if (rc != EOK) {
+                                measured_strings_destroy(&netif->configuration, free);
+                                netifs_exclude_index(&net_globals.netifs, index, free);
+                                continue;
+                        }
+                }
+                
+                closedir(config_dir);
+        }
+        
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME,
+            (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
+        if (rc != EOK) {
+                printf("%s: Error adding module '%s'\n", NAME, ETHERNET_NAME);
+                pm_destroy();
+                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) {
+                printf("%s: Error adding module '%s'\n", NAME, NILDUMMY_NAME);
+                pm_destroy();
+                return rc;
+        }
+        
+        task_id_t task_id = net_spawn((uint8_t *) IP_FILENAME);
+        if (!task_id) {
+                printf("%s: Error spawning IP module\n", NAME);
+                pm_destroy();
+                return EINVAL;
+        }
+        
+        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) {
+                printf("%s: Error adding module '%s'\n", NAME, IP_NAME);
+                pm_destroy();
+                return rc;
+        }
+        
+        if (!net_spawn((uint8_t *) "/srv/icmp")) {
+                printf("%s: Error spawning ICMP module\n", NAME);
+                pm_destroy();
+                return EINVAL;
+        }
+        
+        if (!net_spawn((uint8_t *) "/srv/udp")) {
+                printf("%s: Error spawning UDP module\n", NAME);
+                pm_destroy();
+                return EINVAL;
+        }
+        
+        if (!net_spawn((uint8_t *) "/srv/tcp")) {
+                printf("%s: Error spawning TCP module\n", NAME);
+                pm_destroy();
+                return EINVAL;
+        }
+        
+        rc = service_register(SERVICE_NETWORKING);
+        if (rc != EOK) {
+                printf("%s: Error registering service\n", NAME);
+                pm_destroy();
+                return rc;
+        }
+        
+        task_retval(0);
+        async_manager();
+        return 0;
 }
 

uspace/srv/net/net/net.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -31 +32 @@
  */
 
-/** @file
- * Networking subsystem central module.
- *
- */
-
 #ifndef NET_NET_H_
 #define NET_NET_H_
@@ -45 +41 @@
 #include <adt/module_map.h>
 #include <net/packet.h>
+#include <devman.h>
 
-/** @name Modules definitions
- * @{
- */
-
-#define NE2000_FILENAME  "/srv/ne2000"
-#define NE2000_NAME      "ne2000"
+#define NAME  "net"
 
 #define ETHERNET_FILENAME  "/srv/eth"
@@ -58 +50 @@
 #define IP_FILENAME  "/srv/ip"
 #define IP_NAME      "ip"
-
-#define LO_FILENAME  "/srv/lo"
-#define LO_NAME      "lo"
 
 #define NILDUMMY_FILENAME  "/srv/nildummy"
@@ -77 +66 @@
 #define CONF_MTU    "MTU"    /**< Maximum transmission unit configuration label. */
 #define CONF_NAME   "NAME"   /**< Network interface name configuration label. */
-#define CONF_NETIF  "NETIF"  /**< Network interface module name configuration label. */
+#define CONF_HWPATH "HWPATH" /**< Network interface hardware pathname label. */
 #define CONF_NIL    "NIL"    /**< Network interface layer module name configuration label. */
 
@@ -85 +74 @@
 #define CONF_DIR           "/cfg/net"  /**< Configuration directory. */
 #define CONF_GENERAL_FILE  "general"   /**< General configuration file. */
+#define CONF_EXT           ".nic"      /**< Extension for NIC's configuration files. */
 
 /** Configuration settings.
@@ -98 +88 @@
  */
 typedef struct {
-        measured_strings_t configuration;  /**< Configuration. */
+        /** System-unique network interface name. */
+        uint8_t *name;
+        /** System-unique network interface identifier. */
+        nic_device_id_t id;
+        /** Configuration. */
+        measured_strings_t configuration;
         
         /** Serving network interface driver module index. */
-        module_t *driver;
+        devman_handle_t handle;  /**< Handle for devman */
+        async_sess_t *sess;      /**< Driver session. */
         
-        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. */
+        module_t *nil;  /**< Serving link layer module index. */
+        module_t *il;   /**< Serving internet layer module index. */
 } netif_t;
 
@@ -124 +118 @@
         modules_t modules;                 /**< Available modules. */
         
-        /** Network interface structure indices by names. */
-        char_map_t netif_names;
+        /** Network interface structure indices by hardware path. */
+        char_map_t netif_hwpaths;
         
         /** Present network interfaces. */
@@ -131 +125 @@
 } net_globals_t;
 
-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 *, size_t *);
-
 #endif
 

uspace/srv/net/net/packet_server.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -35 +36 @@
  */
 
-#include <packet_server.h>
 #include <align.h>
 #include <assert.h>
 #include <async.h>
 #include <errno.h>
+#include <str_error.h>
+#include <stdio.h>
 #include <fibril_synch.h>
 #include <unistd.h>
@@ -48 +50 @@
 #include <net/packet_header.h>
 
+#include "packet_server.h"
+
+#define PACKET_SERVER_PROFILE 1
+
+/** Number of queues cacheing the unused packets */
 #define FREE_QUEUES_COUNT       7
+/** Maximum number of packets in each queue */
+#define FREE_QUEUE_MAX_LENGTH   16
 
 /** The default address length reserved for new packets. */
@@ -58 +67 @@
 /** The default suffix reserved for new packets. */
 #define DEFAULT_SUFFIX          64
+
+/** The queue with unused packets */
+typedef struct packet_queue {
+        packet_t *first;        /**< First packet in the queue */
+        size_t packet_size; /**< Maximal size of the packets in this queue */
+        int count;                      /**< Length of the queue */
+} packet_queue_t;
 
 /** Packet server global data. */
@@ -64 +80 @@
         fibril_mutex_t lock;
         /** Free packet queues. */
-        packet_t *free[FREE_QUEUES_COUNT];
-        
-        /**
-         * Packet length upper bounds of the free packet queues. The maximal
-         * lengths of packets in each queue in the ascending order. The last
-         * queue is not limited.
-         */
-        size_t sizes[FREE_QUEUES_COUNT];
+        packet_queue_t free_queues[FREE_QUEUES_COUNT];
         
         /** Total packets allocated. */
-        unsigned int count;
+        packet_id_t next_id;
 } ps_globals = {
         .lock = FIBRIL_MUTEX_INITIALIZER(ps_globals.lock),
-        .free = {
-                NULL,
-                NULL,
-                NULL,
-                NULL,
-                NULL,
-                NULL,
-                NULL
+        .free_queues = {
+                { NULL, PAGE_SIZE, 0},
+                { NULL, PAGE_SIZE * 2, 0},
+                { NULL, PAGE_SIZE * 4, 0},
+                { NULL, PAGE_SIZE * 8, 0},
+                { NULL, PAGE_SIZE * 16, 0},
+                { NULL, PAGE_SIZE * 32, 0},
+                { NULL, PAGE_SIZE * 64, 0},
         },
-        .sizes = {
-                PAGE_SIZE,
-                PAGE_SIZE * 2,
-                PAGE_SIZE * 4,
-                PAGE_SIZE * 8,
-                PAGE_SIZE * 16,
-                PAGE_SIZE * 32,
-                PAGE_SIZE * 64
-        },
-        .count = 0
+        .next_id = 1
 };
 
@@ -107 +107 @@
  * @param[in] max_suffix The maximal suffix length in bytes.
  */
-static void
-packet_init(packet_t *packet, size_t addr_len, size_t max_prefix,
-    size_t max_content, size_t max_suffix)
+static void packet_init(packet_t *packet,
+        size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix)
 {
         /* Clear the packet content */
@@ -120 +119 @@
         packet->previous = 0;
         packet->next = 0;
+        packet->offload_info = 0;
+        packet->offload_mask = 0;
         packet->addr_len = 0;
         packet->src_addr = sizeof(packet_t);
@@ -127 +128 @@
         packet->data_start = packet->dest_addr + addr_len + packet->max_prefix;
         packet->data_end = packet->data_start;
+}
+
+/**
+ * Releases the memory allocated for the packet
+ *
+ * @param[in] packet Pointer to the memory where the packet was allocated
+ */
+static void packet_dealloc(packet_t *packet)
+{
+        pm_remove(packet);
+        munmap(packet, packet->length);
 }
 
@@ -141 +153 @@
  * @return              NULL if there is not enough memory left.
  */
-static packet_t *
-packet_create(size_t length, size_t addr_len, size_t max_prefix,
-    size_t max_content, size_t max_suffix)
+static packet_t *packet_alloc(size_t length, size_t addr_len,
+        size_t max_prefix, size_t max_content, size_t max_suffix)
 {
         packet_t *packet;
         int rc;
 
+        /* Global lock is locked */
         assert(fibril_mutex_is_locked(&ps_globals.lock));
-
-        /* Already locked */
+        /* The length is some multiple of PAGE_SIZE */
+        assert(!(length & (PAGE_SIZE - 1)));
+
         packet = (packet_t *) mmap(NULL, length, PROTO_READ | PROTO_WRITE,
-            MAP_SHARED | MAP_ANONYMOUS, 0, 0);
+                MAP_SHARED | MAP_ANONYMOUS, 0, 0);
         if (packet == MAP_FAILED)
                 return NULL;
-
-        ps_globals.count++;
-        packet->packet_id = ps_globals.count;
+        
+        /* Using 32bit packet_id the id could overflow */
+        packet_id_t pid;
+        do {
+                pid = ps_globals.next_id;
+                ps_globals.next_id++;
+        } while (!pid || pm_find(pid));
+        packet->packet_id = pid;
+
         packet->length = length;
         packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
@@ -163 +182 @@
         rc = pm_add(packet);
         if (rc != EOK) {
-                munmap(packet, packet->length);
+                packet_dealloc(packet);
                 return NULL;
         }
@@ -184 +203 @@
  * @return              NULL if there is not enough memory left.
  */
-static packet_t *
-packet_get_local(size_t addr_len, size_t max_prefix, size_t max_content,
-    size_t max_suffix)
-{
-        size_t length = ALIGN_UP(sizeof(packet_t) + 2 * addr_len +
-            max_prefix + max_content + max_suffix, PAGE_SIZE);
-        
+static packet_t *packet_get_local(size_t addr_len,
+        size_t max_prefix, size_t max_content, size_t max_suffix)
+{
+        size_t length = ALIGN_UP(sizeof(packet_t) + 2 * addr_len
+                + max_prefix + max_content + max_suffix, PAGE_SIZE);
+        
+        if (length > PACKET_MAX_LENGTH)
+                return NULL;
+
         fibril_mutex_lock(&ps_globals.lock);
         
@@ -197 +218 @@
         
         for (index = 0; index < FREE_QUEUES_COUNT; index++) {
-                if ((length > ps_globals.sizes[index]) &&
-                    (index < FREE_QUEUES_COUNT - 1))
+                if ((length > ps_globals.free_queues[index].packet_size) &&
+                        (index < FREE_QUEUES_COUNT - 1))
                         continue;
                 
-                packet = ps_globals.free[index];
+                packet = ps_globals.free_queues[index].first;
                 while (packet_is_valid(packet) && (packet->length < length))
                         packet = pm_find(packet->next);
                 
                 if (packet_is_valid(packet)) {
-                        if (packet == ps_globals.free[index])
-                                ps_globals.free[index] = pq_detach(packet);
-                        else
+                        ps_globals.free_queues[index].count--;
+                        if (packet == ps_globals.free_queues[index].first) {
+                                ps_globals.free_queues[index].first = pq_detach(packet);
+                        } else {
                                 pq_detach(packet);
+                        }
                         
-                        packet_init(packet, addr_len, max_prefix, max_content,
-                            max_suffix);
+                        packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
                         fibril_mutex_unlock(&ps_globals.lock);
                         
@@ -219 +241 @@
         }
         
-        packet = packet_create(length, addr_len, max_prefix, max_content,
-            max_suffix);
+        packet = packet_alloc(length, addr_len,
+                max_prefix, max_content, max_suffix);
         
         fibril_mutex_unlock(&ps_globals.lock);
@@ -240 +262 @@
 
         for (index = 0; (index < FREE_QUEUES_COUNT - 1) &&
-            (packet->length > ps_globals.sizes[index]); index++) {
+            (packet->length > ps_globals.free_queues[index].packet_size); index++) {
                 ;
         }
         
-        result = pq_add(&ps_globals.free[index], packet, packet->length,
-            packet->length);
+        ps_globals.free_queues[index].count++;
+        result = pq_add(&ps_globals.free_queues[index].first, packet,
+                packet->length, packet->length);
         assert(result == EOK);
 }
@@ -328 +351 @@
         case NET_PACKET_CREATE_1:
                 packet = packet_get_local(DEFAULT_ADDR_LEN, DEFAULT_PREFIX,
-                    IPC_GET_CONTENT(*call), DEFAULT_SUFFIX);
+                        IPC_GET_CONTENT(*call), DEFAULT_SUFFIX);
                 if (!packet)
                         return ENOMEM;
@@ -338 +361 @@
         case NET_PACKET_CREATE_4:
                 packet = packet_get_local(
-                    ((DEFAULT_ADDR_LEN < IPC_GET_ADDR_LEN(*call)) ?
+                        ((DEFAULT_ADDR_LEN < IPC_GET_ADDR_LEN(*call)) ?
                     IPC_GET_ADDR_LEN(*call) : DEFAULT_ADDR_LEN),
                     DEFAULT_PREFIX + IPC_GET_PREFIX(*call),
@@ -352 +375 @@
         case NET_PACKET_GET:
                 packet = pm_find(IPC_GET_ID(*call));
-                if (!packet_is_valid(packet))
+                if (!packet_is_valid(packet)) {
                         return ENOENT;
+                }
                 return packet_reply(packet);
         
@@ -371 +395 @@
 }
 
+int packet_server_init()
+{
+        return EOK;
+}
+
 /** @}
  */

uspace/srv/net/net/packet_server.h

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -42 +43 @@
  */
 
-#ifndef LIBPACKET_PACKET_SERVER_H_
-#define LIBPACKET_PACKET_SERVER_H_
+#ifndef NET_PACKET_SERVER_H_
+#define NET_PACKET_SERVER_H_
 
 #include <ipc/common.h>
 
+extern int packet_server_init(void);
 extern int packet_server_message(ipc_callid_t, ipc_call_t *, ipc_call_t *,
     size_t *);

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -36 +37 @@
  */
 
+#include <assert.h>
 #include <async.h>
 #include <malloc.h>
@@ -52 +54 @@
 #include <protocol_map.h>
 #include <net/device.h>
-#include <netif_remote.h>
 #include <net_interface.h>
 #include <il_remote.h>
@@ -58 +59 @@
 #include <packet_client.h>
 #include <packet_remote.h>
+#include <device/nic.h>
 #include <nil_skel.h>
 #include "eth.h"
@@ -167 +169 @@
 INT_MAP_IMPLEMENT(eth_protos, eth_proto_t);
 
-int nil_device_state_msg_local(device_id_t device_id, sysarg_t state)
+int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
 {
         int index;
@@ -196 +198 @@
         fibril_rwlock_write_lock(&eth_globals.protos_lock);
         eth_globals.net_sess = sess;
-
-        eth_globals.broadcast_addr =
-            measured_string_create_bulk((uint8_t *) "\xFF\xFF\xFF\xFF\xFF\xFF", ETH_ADDR);
-        if (!eth_globals.broadcast_addr) {
-                rc = ENOMEM;
-                goto out;
-        }
+        memcpy(eth_globals.broadcast_addr, "\xFF\xFF\xFF\xFF\xFF\xFF",
+                        ETH_ADDR);
 
         rc = eth_devices_initialize(&eth_globals.devices);
@@ -215 +212 @@
                 eth_devices_destroy(&eth_globals.devices, free);
         }
+        
 out:
         fibril_rwlock_write_unlock(&eth_globals.protos_lock);
@@ -222 +220 @@
 }
 
-/** Process IPC messages from the registered device driver modules in an
- * infinite loop.
- *
- * @param[in]     iid   Message identifier.
- * @param[in,out] icall Message parameters.
- * @param[in]     arg   Local argument.
- *
- */
-static void eth_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-        packet_t *packet;
-        int rc;
-
-        while (true) {
-                switch (IPC_GET_IMETHOD(*icall)) {
-                case NET_NIL_DEVICE_STATE:
-                        nil_device_state_msg_local(IPC_GET_DEVICE(*icall),
-                            IPC_GET_STATE(*icall));
-                        async_answer_0(iid, EOK);
-                        break;
-                case NET_NIL_RECEIVED:
-                        rc = packet_translate_remote(eth_globals.net_sess,
-                            &packet, IPC_GET_PACKET(*icall));
-                        if (rc == EOK)
-                                rc = nil_received_msg_local(IPC_GET_DEVICE(*icall),
-                                    packet, 0);
-                        
-                        async_answer_0(iid, (sysarg_t) rc);
-                        break;
-                default:
-                        async_answer_0(iid, (sysarg_t) ENOTSUP);
-                }
-                
-                iid = async_get_call(icall);
-        }
-}
-
-/** Registers new device or updates the MTU of an existing one.
- *
- * Determines the device local hardware address.
- *
- * @param[in] device_id The new device identifier.
- * @param[in] service   The device driver service.
- * @param[in] mtu       The device maximum transmission unit.
- * @return              EOK on success.
- * @return              EEXIST if the device with the different service exists.
- * @return              ENOMEM if there is not enough memory left.
- * @return              Other error codes as defined for the
- *                      net_get_device_conf_req() function.
- * @return              Other error codes as defined for the
- *                      netif_bind_service() function.
- * @return              Other error codes as defined for the
- *                      netif_get_addr_req() function.
- */
-static int eth_device_message(device_id_t device_id, services_t service,
+/** Register new device or updates the MTU of an existing one.
+ *
+ * Determine the device local hardware address.
+ *
+ * @param[in] device_id New device identifier.
+ * @param[in] handle    Device driver handle.
+ * @param[in] mtu       Device maximum transmission unit.
+ *
+ * @return EOK on success.
+ * @return EEXIST if the device with the different service exists.
+ * @return ENOMEM if there is not enough memory left.
+ *
+ */
+static int eth_device_message(nic_device_id_t device_id, devman_handle_t handle,
     size_t mtu)
 {
@@ -301 +258 @@
         device = eth_devices_find(&eth_globals.devices, device_id);
         if (device) {
-                if (device->service != service) {
+                if (device->handle != handle) {
                         printf("Device %d already exists\n", device->device_id);
                         fibril_rwlock_write_unlock(&eth_globals.devices_lock);
@@ -340 +297 @@
 
         device->device_id = device_id;
-        device->service = service;
+        device->handle = handle;
         device->flags = 0;
         if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
@@ -377 +334 @@
         
         /* Bind the device driver */
-        device->sess = netif_bind_service(device->service, device->device_id,
-            SERVICE_ETHERNET, eth_receiver);
+        device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
+            IPC_FLAG_BLOCKING);
         if (device->sess == NULL) {
                 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
@@ -385 +342 @@
         }
         
+        nic_connect_to_nil(device->sess, SERVICE_ETHERNET, device_id);
+        
         /* Get hardware address */
-        rc = netif_get_addr_req(device->sess, device->device_id, &device->addr,
-            &device->addr_data);
+        rc = nic_get_address(device->sess, &device->addr);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
@@ -399 +357 @@
         if (index < 0) {
                 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
-                free(device->addr);
-                free(device->addr_data);
                 free(device);
                 return index;
         }
         
-        printf("%s: Device registered (id: %d, service: %d: mtu: %zu, "
-            "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],
-            device->addr_data[2], device->addr_data[3],
-            device->addr_data[4], device->addr_data[5], device->flags);
+        printf("%s: Device registered (id: %d, handle: %zu: mtu: %zu, "
+            "mac: " PRIMAC ", flags: 0x%x)\n", NAME,
+            device->device_id, device->handle, device->mtu,
+            ARGSMAC(device->addr.address), device->flags);
 
         fibril_rwlock_write_unlock(&eth_globals.devices_lock);
@@ -456 +410 @@
                 fcs = (eth_fcs_t *) data + length - sizeof(eth_fcs_t);
                 length -= sizeof(eth_fcs_t);
-        } else if(type <= ETH_MAX_CONTENT) {
+        } else if (type <= ETH_MAX_CONTENT) {
                 /* Translate "LSAP" values */
                 if ((header->lsap.dsap == ETH_LSAP_GLSAP) &&
@@ -462 +416 @@
                         /* Raw packet -- discard */
                         return NULL;
-                } else if((header->lsap.dsap == ETH_LSAP_SNAP) &&
+                } else if ((header->lsap.dsap == ETH_LSAP_SNAP) &&
                     (header->lsap.ssap == ETH_LSAP_SNAP)) {
                         /*
@@ -469 +423 @@
                          */
                         type = ntohs(header->snap.ethertype);
-                        prefix = sizeof(eth_header_t) +
-                            sizeof(eth_header_lsap_t) +
+                        prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t) +
                             sizeof(eth_header_snap_t);
                 } else {
                         /* IEEE 802.3 + 802.2 LSAP */
                         type = lsap_map(header->lsap.dsap);
-                        prefix = sizeof(eth_header_t) +
-                            sizeof(eth_header_lsap_t);
+                        prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t);
                 }
 
@@ -506 +458 @@
 }
 
-int nil_received_msg_local(device_id_t device_id, packet_t *packet,
-    services_t target)
+int nil_received_msg_local(nic_device_id_t device_id, packet_t *packet)
 {
         eth_proto_t *proto;
@@ -523 +474 @@
         flags = device->flags;
         fibril_rwlock_read_unlock(&eth_globals.devices_lock);
-        
         fibril_rwlock_read_lock(&eth_globals.protos_lock);
+        
         do {
                 next = pq_detach(packet);
@@ -537 +488 @@
                 }
                 packet = next;
-        } while(packet);
+        } while (packet);
 
         fibril_rwlock_read_unlock(&eth_globals.protos_lock);
@@ -554 +505 @@
  * @return              ENOENT if there is no such device.
  */
-static int eth_packet_space_message(device_id_t device_id, size_t *addr_len,
+static int eth_packet_space_message(nic_device_id_t device_id, size_t *addr_len,
     size_t *prefix, size_t *content, size_t *suffix)
 {
@@ -579 +530 @@
 }
 
-/** Returns the device hardware address.
+/** Send the device hardware address.
  *
  * @param[in] device_id The device identifier.
  * @param[in] type      Type of the desired address.
- * @param[out] address  The device hardware address.
  * @return              EOK on success.
  * @return              EBADMEM if the address parameter is NULL.
  * @return              ENOENT if there no such device.
  */
-static int eth_addr_message(device_id_t device_id, eth_addr_type_t type,
-    measured_string_t **address)
-{
-        eth_device_t *device;
-
-        if (!address)
-                return EBADMEM;
-
-        if (type == ETH_BROADCAST_ADDR) {
-                *address = eth_globals.broadcast_addr;
-        } else {
+static int eth_addr_message(nic_device_id_t device_id, eth_addr_type_t type)
+{
+        eth_device_t *device = NULL;
+        uint8_t *address;
+        size_t max_len;
+        ipc_callid_t callid;
+        
+        if (type == ETH_BROADCAST_ADDR)
+                address = eth_globals.broadcast_addr;
+        else {
                 fibril_rwlock_read_lock(&eth_globals.devices_lock);
                 device = eth_devices_find(&eth_globals.devices, device_id);
@@ -605 +554 @@
                         return ENOENT;
                 }
-                *address = device->addr;
+                
+                address = (uint8_t *) &device->addr.address;
+        }
+        
+        int rc = EOK;
+        if (!async_data_read_receive(&callid, &max_len)) {
+                rc = EREFUSED;
+                goto end;
+        }
+        
+        if (max_len < ETH_ADDR) {
+                async_data_read_finalize(callid, NULL, 0);
+                rc = ELIMIT;
+                goto end;
+        }
+        
+        rc = async_data_read_finalize(callid, address, ETH_ADDR);
+        if (rc != EOK)
+                goto end;
+        
+end:
+        
+        if (type == ETH_LOCAL_ADDR)
                 fibril_rwlock_read_unlock(&eth_globals.devices_lock);
-        }
-        
-        return (*address) ? EOK : ENOENT;
+        
+        return rc;
 }
 
@@ -659 +629 @@
         }
         
-        printf("%s: Protocol registered (protocol: %d, service: %d)\n",
+        printf("%s: Protocol registered (protocol: %d, service: %#x)\n",
             NAME, proto->protocol, proto->service);
         
@@ -697 +667 @@
         if (i < 0)
                 return i;
+        
         if (i != ETH_ADDR)
                 return EINVAL;
+        
+        for (i = 0; i < ETH_ADDR; i++) {
+                if (src[i]) {
+                        src_addr = src;
+                        break;
+                }
+        }
 
         length = packet_get_data_length(packet);
@@ -722 +700 @@
                 memcpy(header_dix->destination_address, dest, ETH_ADDR);
                 src = &header_dix->destination_address[0];
-        } else if(IS_8023_2_LSAP(flags)) {
+        } else if (IS_8023_2_LSAP(flags)) {
                 header_lsap = PACKET_PREFIX(packet, eth_header_lsap_t);
                 if (!header_lsap)
@@ -735 +713 @@
                 memcpy(header_lsap->header.destination_address, dest, ETH_ADDR);
                 src = &header_lsap->header.destination_address[0];
-        } else if(IS_8023_2_SNAP(flags)) {
+        } else if (IS_8023_2_SNAP(flags)) {
                 header = PACKET_PREFIX(packet, eth_header_snap_t);
                 if (!header)
@@ -746 +724 @@
                 header->lsap.ctrl = IEEE_8023_2_UI;
                 
-                for (i = 0; i < 3; ++ i)
+                for (i = 0; i < 3; i++)
                         header->snap.protocol[i] = 0;
                 
@@ -760 +738 @@
                         return ENOMEM;
                 
-                for (i = 0; i < 7; ++ i)
+                for (i = 0; i < 7; i++)
                         preamble->preamble[i] = ETH_PREAMBLE;
                 
@@ -787 +765 @@
  * @return              EINVAL if the service parameter is not known.
  */
-static int eth_send_message(device_id_t device_id, packet_t *packet,
+static int eth_send_message(nic_device_id_t device_id, packet_t *packet,
     services_t sender)
 {
@@ -813 +791 @@
         do {
                 rc = eth_prepare_packet(device->flags, next,
-                    (uint8_t *) device->addr->value, ethertype, device->mtu);
+                    (uint8_t *) &device->addr.address, ethertype, device->mtu);
                 if (rc != EOK) {
                         /* Release invalid packet */
@@ -825 +803 @@
                         next = pq_next(next);
                 }
-        } while(next);
+        } while (next);
         
         /* Send packet queue */
-        if (packet) {
-                netif_send_msg(device->sess, device_id, packet,
-                    SERVICE_ETHERNET);
-        }
-
+        if (packet)
+                nic_send_message(device->sess, packet_get_id(packet));
+        
         fibril_rwlock_read_unlock(&eth_globals.devices_lock);
         return EOK;
 }
 
+static int eth_addr_changed(nic_device_id_t device_id)
+{
+        nic_address_t address;
+        size_t length;
+        ipc_callid_t data_callid;
+        if (!async_data_write_receive(&data_callid, &length)) {
+                async_answer_0(data_callid, EINVAL);
+                return EINVAL;
+        }
+        if (length > sizeof (nic_address_t)) {
+                async_answer_0(data_callid, ELIMIT);
+                return ELIMIT;
+        }
+        if (async_data_write_finalize(data_callid, &address, length) != EOK) {
+                return EINVAL;
+        }
+
+        fibril_rwlock_write_lock(&eth_globals.devices_lock);
+        /* An existing device? */
+        eth_device_t *device = eth_devices_find(&eth_globals.devices, device_id);
+        if (device) {
+                printf("Device %d changing address from " PRIMAC " to " PRIMAC "\n",
+                        device_id, ARGSMAC(device->addr.address), ARGSMAC(address.address));
+                memcpy(&device->addr, &address, sizeof (nic_address_t));
+                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
+
+                /* Notify all upper layer modules */
+                fibril_rwlock_read_lock(&eth_globals.protos_lock);
+                int index;
+                for (index = 0; index < eth_protos_count(&eth_globals.protos); index++) {
+                        eth_proto_t *proto = eth_protos_get_index(&eth_globals.protos, index);
+                        if (proto->sess != NULL) {
+                                il_addr_changed_msg(proto->sess, device->device_id,
+                                                ETH_ADDR, address.address);
+                        }
+                }
+
+                fibril_rwlock_read_unlock(&eth_globals.protos_lock);
+                return EOK;
+        } else {
+                return ENOENT;
+        }
+}
+
 int nil_module_message(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, size_t *answer_count)
 {
-        measured_string_t *address;
         packet_t *packet;
         size_t addrlen;
@@ -861 +880 @@
         case NET_NIL_DEVICE:
                 return eth_device_message(IPC_GET_DEVICE(*call),
-                    IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
+                    IPC_GET_DEVICE_HANDLE(*call), IPC_GET_MTU(*call));
         case NET_NIL_SEND:
                 rc = packet_translate_remote(eth_globals.net_sess, &packet,
@@ -867 +886 @@
                 if (rc != EOK)
                         return rc;
+                
                 return eth_send_message(IPC_GET_DEVICE(*call), packet,
                     IPC_GET_SERVICE(*call));
@@ -874 +894 @@
                 if (rc != EOK)
                         return rc;
+                
                 IPC_SET_ADDR(*answer, addrlen);
                 IPC_SET_PREFIX(*answer, prefix);
@@ -879 +900 @@
                 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,
-                    &address);
+                rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_LOCAL_ADDR);
                 if (rc != EOK)
                         return rc;
-                return measured_strings_reply(address, 1);
+                
+                IPC_SET_ADDR(*answer, ETH_ADDR);
+                *answer_count = 1;
+                
+                return EOK;
         case NET_NIL_BROADCAST_ADDR:
-                rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_BROADCAST_ADDR,
-                    &address);
+                rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_BROADCAST_ADDR);
                 if (rc != EOK)
-                        return EOK;
-                return measured_strings_reply(address, 1);
+                        return rc;
+                
+                IPC_SET_ADDR(*answer, ETH_ADDR);
+                *answer_count = 1;
+                
+                return EOK;
+        case NET_NIL_DEVICE_STATE:
+                nil_device_state_msg_local(IPC_GET_DEVICE(*call), IPC_GET_STATE(*call));
+                async_answer_0(callid, EOK);
+                return EOK;
+        case NET_NIL_RECEIVED:
+                rc = packet_translate_remote(eth_globals.net_sess, &packet,
+                    IPC_GET_ARG2(*call));
+                if (rc == EOK)
+                        rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
+                
+                async_answer_0(callid, (sysarg_t) rc);
+                return rc;
+        case NET_NIL_ADDR_CHANGED:
+                rc = eth_addr_changed(IPC_GET_DEVICE(*call));
+                async_answer_0(callid, (sysarg_t) rc);
+                return rc;
         }
         

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -43 +44 @@
 #include <net/device.h>
 #include <adt/measured_strings.h>
+#include <devman.h>
 
 /** Ethernet address length. */
@@ -220 +222 @@
 struct eth_device {
         /** Device identifier. */
-        device_id_t device_id;
-        /** Device driver service. */
-        services_t service;
+        nic_device_id_t device_id;
+        /** Device handle */
+        devman_handle_t handle;
         /** Driver session. */
         async_sess_t *sess;
@@ -236 +238 @@
         
         /** Actual device hardware address. */
-        measured_string_t *addr;
-        
-        /** Actual device hardware address data. */
-        uint8_t *addr_data;
+        nic_address_t addr;
 };
 
@@ -270 +269 @@
         
         /** Broadcast device hardware address. */
-        measured_string_t *broadcast_addr;
+        uint8_t broadcast_addr[ETH_ADDR];
 };
 

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -36 +37 @@
  */
 
+#include <assert.h>
 #include <async.h>
 #include <malloc.h>
@@ -50 +52 @@
 #include <net/packet.h>
 #include <packet_remote.h>
-#include <netif_remote.h>
+#include <packet_client.h>
+#include <devman.h>
+#include <device/nic.h>
 #include <nil_skel.h>
 #include "nildummy.h"
@@ -65 +69 @@
 DEVICE_MAP_IMPLEMENT(nildummy_devices, nildummy_device_t);
 
-int nil_device_state_msg_local(device_id_t device_id, sysarg_t state)
+int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
 {
         fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
@@ -91 +95 @@
         
         return rc;
-}
-
-/** Process IPC messages from the registered device driver modules
- *
- * @param[in]     iid   Message identifier.
- * @param[in,out] icall Message parameters.
- * @param[in]     arg    Local argument.
- *
- */
-static void nildummy_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-        packet_t *packet;
-        int rc;
-        
-        while (true) {
-                switch (IPC_GET_IMETHOD(*icall)) {
-                case NET_NIL_DEVICE_STATE:
-                        rc = nil_device_state_msg_local(IPC_GET_DEVICE(*icall),
-                            IPC_GET_STATE(*icall));
-                        async_answer_0(iid, (sysarg_t) rc);
-                        break;
-                
-                case NET_NIL_RECEIVED:
-                        rc = packet_translate_remote(nildummy_globals.net_sess,
-                            &packet, IPC_GET_PACKET(*icall));
-                        if (rc == EOK)
-                                rc = nil_received_msg_local(IPC_GET_DEVICE(*icall),
-                                    packet, 0);
-                        
-                        async_answer_0(iid, (sysarg_t) rc);
-                        break;
-                
-                default:
-                        async_answer_0(iid, (sysarg_t) ENOTSUP);
-                }
-                
-                iid = async_get_call(icall);
-        }
 }
 
@@ -148 +114 @@
  *
  */
-static int nildummy_device_message(device_id_t device_id, services_t service,
-    size_t mtu)
+static int nildummy_device_message(nic_device_id_t device_id,
+    devman_handle_t handle, size_t mtu)
 {
         fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
@@ -157 +123 @@
             nildummy_devices_find(&nildummy_globals.devices, device_id);
         if (device) {
-                if (device->service != service) {
-                        printf("Device %d already exists\n", device->device_id);
-                        fibril_rwlock_write_unlock(
-                            &nildummy_globals.devices_lock);
+                if (device->handle != handle) {
+                        printf("Device %d exists, handles do not match\n",
+                            device->device_id);
+                        fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
                         return EEXIST;
                 }
@@ -170 +136 @@
                         device->mtu = NET_DEFAULT_MTU;
                 
-                printf("Device %d already exists:\tMTU\t= %zu\n",
-                    device->device_id, device->mtu);
+                printf("Device %d already exists (mtu: %zu)\n", device->device_id,
+                    device->mtu);
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
                 
@@ -192 +158 @@
         
         device->device_id = device_id;
-        device->service = service;
+        device->handle = handle;
         if (mtu > 0)
                 device->mtu = mtu;
         else
                 device->mtu = NET_DEFAULT_MTU;
-
+        
         /* Bind the device driver */
-        device->sess = netif_bind_service(device->service, device->device_id,
-            SERVICE_ETHERNET, nildummy_receiver);
+        device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
+            IPC_FLAG_BLOCKING);
         if (device->sess == NULL) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
@@ -207 +173 @@
         }
         
+        nic_connect_to_nil(device->sess, SERVICE_NILDUMMY, device_id);
+        
         /* Get hardware address */
-        int rc = netif_get_addr_req(device->sess, device->device_id,
-            &device->addr, &device->addr_data);
+        int rc = nic_get_address(device->sess, &device->addr);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
@@ -215 +182 @@
                 return rc;
         }
+        
+        device->addr_len = ETH_ADDR;
         
         /* Add to the cache */
@@ -221 +190 @@
         if (index < 0) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
-                free(device->addr);
-                free(device->addr_data);
                 free(device);
                 return index;
         }
         
-        printf("%s: Device registered (id: %d, service: %d, mtu: %zu)\n",
-            NAME, device->device_id, device->service, device->mtu);
+        printf("%s: Device registered (id: %d, mtu: %zu)\n", NAME,
+            device->device_id, device->mtu);
         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
         return EOK;
@@ -243 +210 @@
  *
  */
-static int nildummy_addr_message(device_id_t device_id,
-    measured_string_t **address)
-{
-        if (!address)
+static int nildummy_addr_message(nic_device_id_t device_id, size_t *addrlen)
+{
+        if (!addrlen)
                 return EBADMEM;
         
@@ -258 +224 @@
         }
         
-        *address = device->addr;
+        ipc_callid_t callid;
+        size_t max_len;
+        if (!async_data_read_receive(&callid, &max_len)) {
+                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
+                return EREFUSED;
+        }
+        
+        if (max_len < device->addr_len) {
+                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
+                async_data_read_finalize(callid, NULL, 0);
+                return ELIMIT;
+        }
+        
+        int rc = async_data_read_finalize(callid,
+            (uint8_t *) &device->addr.address, device->addr_len);
+        if (rc != EOK) {
+                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
+                return rc;
+        }
+        
+        *addrlen = device->addr_len;
         
         fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
-        
-        return (*address) ? EOK : ENOENT;
+        return EOK;
 }
 
@@ -278 +263 @@
  *
  */
-static int nildummy_packet_space_message(device_id_t device_id, size_t *addr_len,
-    size_t *prefix, size_t *content, size_t *suffix)
+static int nildummy_packet_space_message(nic_device_id_t device_id,
+    size_t *addr_len, size_t *prefix, size_t *content, size_t *suffix)
 {
         if ((!addr_len) || (!prefix) || (!content) || (!suffix))
@@ -303 +288 @@
 }
 
-int nil_received_msg_local(device_id_t device_id, packet_t *packet,
-    services_t target)
+int nil_received_msg_local(nic_device_id_t device_id, packet_t *packet)
 {
         fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
@@ -340 +324 @@
         nildummy_globals.proto.sess = sess;
         
-        printf("%s: Protocol registered (service: %d)\n",
+        printf("%s: Protocol registered (service: %#x)\n",
             NAME, nildummy_globals.proto.service);
         
@@ -358 +342 @@
  *
  */
-static int nildummy_send_message(device_id_t device_id, packet_t *packet,
+static int nildummy_send_message(nic_device_id_t device_id, packet_t *packet,
     services_t sender)
 {
@@ -372 +356 @@
         /* Send packet queue */
         if (packet)
-                netif_send_msg(device->sess, device_id, packet,
-                    SERVICE_NILDUMMY);
+                nic_send_message(device->sess, packet_get_id(packet));
         
         fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
@@ -383 +366 @@
     ipc_call_t *answer, size_t *answer_count)
 {
-        measured_string_t *address;
         packet_t *packet;
         size_t addrlen;
@@ -404 +386 @@
         case NET_NIL_DEVICE:
                 return nildummy_device_message(IPC_GET_DEVICE(*call),
-                    IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
+                    IPC_GET_DEVICE_HANDLE(*call), IPC_GET_MTU(*call));
         
         case NET_NIL_SEND:
@@ -427 +409 @@
         
         case NET_NIL_ADDR:
-                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
+        case NET_NIL_BROADCAST_ADDR:
+                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &addrlen);
                 if (rc != EOK)
                         return rc;
-                return measured_strings_reply(address, 1);
-        
-        case NET_NIL_BROADCAST_ADDR:
-                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
-                if (rc != EOK)
-                        return rc;
-                return measured_strings_reply(address, 1);
+                
+                IPC_SET_ADDR(*answer, addrlen);
+                *answer_count = 1;
+                return rc;
+        case NET_NIL_DEVICE_STATE:
+                rc = nil_device_state_msg_local(IPC_GET_DEVICE(*call),
+                    IPC_GET_STATE(*call));
+                async_answer_0(callid, (sysarg_t) rc);
+                return rc;
+        
+        case NET_NIL_RECEIVED:
+                rc = packet_translate_remote(nildummy_globals.net_sess, &packet,
+                    IPC_GET_ARG2(*call));
+                if (rc == EOK)
+                        rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
+                
+                async_answer_0(callid, (sysarg_t) rc);
+                return rc;
         }
         

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -41 +42 @@
 #include <fibril_synch.h>
 #include <ipc/services.h>
+#include <ipc/devman.h>
 #include <net/device.h>
 #include <adt/measured_strings.h>
@@ -76 +78 @@
 struct nildummy_device {
         /** Device identifier. */
-        device_id_t device_id;
-        
-        /** Device driver service. */
-        services_t service;
-        
+        nic_device_id_t device_id;
+        /** Device driver handle. */
+        devman_handle_t handle;
         /** Driver session. */
         async_sess_t *sess;
@@ -88 +88 @@
         
         /** Actual device hardware address. */
-        measured_string_t *addr;
-        
-        /** Actual device hardware address data. */
-        uint8_t *addr_data;
+        nic_address_t addr;
+        /** Actual device hardware address length. */
+        size_t addr_len;
 };
 

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

@@ -753 +753 @@
                         return rc;
                 
-                rc = icmp_echo(icmp_id, icmp_seq, ICMP_GET_SIZE(*call), 
+                rc = icmp_echo(icmp_id, icmp_seq, ICMP_GET_SIZE(*call),
                     ICMP_GET_TIMEOUT(*call), ICMP_GET_TTL(*call),
                     ICMP_GET_TOS(*call), ICMP_GET_DONT_FRAGMENT(*call),

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

@@ -169 +169 @@
 static int tcp_release_after_timeout(void *);
 
-static int tcp_process_packet(device_id_t, packet_t *, services_t);
+static int tcp_process_packet(nic_device_id_t, packet_t *, services_t);
 static int tcp_connect_core(socket_core_t *, socket_cores_t *,
     struct sockaddr *, socklen_t);
@@ -177 +177 @@
     size_t);
 static packet_t *tcp_get_packets_to_send(socket_core_t *, tcp_socket_data_t *);
-static void tcp_send_packets(device_id_t, packet_t *);
+static void tcp_send_packets(nic_device_id_t, packet_t *);
 
 static void tcp_process_acknowledgement(socket_core_t *, tcp_socket_data_t *,
@@ -205 +205 @@
 static void tcp_queue_received_end_of_data(socket_core_t *socket);
 
-static int tcp_received_msg(device_id_t, packet_t *, services_t, services_t);
+static int tcp_received_msg(nic_device_id_t, packet_t *, services_t, services_t);
 static int tcp_process_client_messages(async_sess_t *, ipc_callid_t,
     ipc_call_t);
@@ -220 +220 @@
 tcp_globals_t tcp_globals;
 
-int tcp_received_msg(device_id_t device_id, packet_t *packet,
+int tcp_received_msg(nic_device_id_t device_id, packet_t *packet,
     services_t receiver, services_t error)
 {
@@ -238 +238 @@
 }
 
-int tcp_process_packet(device_id_t device_id, packet_t *packet, services_t error)
+int tcp_process_packet(nic_device_id_t device_id, packet_t *packet, services_t error)
 {
         size_t length;
@@ -1251 +1251 @@
         bzero(socket_data, sizeof(*socket_data));
         socket_data->state = TCP_SOCKET_INITIAL;
-        socket_data->device_id = DEVICE_INVALID_ID;
+        socket_data->device_id = NIC_DEVICE_INVALID_ID;
         socket_data->window = NET_DEFAULT_TCP_WINDOW;
         socket_data->treshold = socket_data->window;
@@ -1335 +1335 @@
                         }
                         if (tl_get_ip_packet_dimension(tcp_globals.ip_sess,
-                            &tcp_globals.dimensions, DEVICE_INVALID_ID,
+                            &tcp_globals.dimensions, NIC_DEVICE_INVALID_ID,
                             &packet_dimension) == EOK) {
                                 SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
@@ -1651 +1651 @@
         /* Sent packet? */
         packet = pq_find(socket_data->outgoing, sequence_number);
-        printf("retransmit %d\n", packet_get_id(packet));
         if (packet) {
                 pq_get_order(packet, NULL, &data_length);
@@ -1790 +1789 @@
 
                         /* Send the packet */
-                        printf("connecting %d\n", packet_get_id(packet));
                         tcp_send_packets(socket_data->device_id, packet);
 
@@ -2004 +2002 @@
 }
 
-void tcp_send_packets(device_id_t device_id, packet_t *packet)
+void tcp_send_packets(nic_device_id_t device_id, packet_t *packet)
 {
         packet_t *next;

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

@@ -182 +182 @@
         
         /** Device identifier. */
-        device_id_t device_id;
+        nic_device_id_t device_id;
         
         /**

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

@@ -124 +124 @@
  *                      ip_client_process_packet() function.
  */
-static int udp_process_packet(device_id_t device_id, packet_t *packet,
+static int udp_process_packet(nic_device_id_t device_id, packet_t *packet,
     services_t error)
 {
@@ -322 +322 @@
  *                      udp_process_packet() function.
  */
-static int udp_received_msg(device_id_t device_id, packet_t *packet,
+static int udp_received_msg(nic_device_id_t device_id, packet_t *packet,
     services_t receiver, services_t error)
 {
@@ -499 +499 @@
         void *ip_header;
         size_t headerlen;
-        device_id_t device_id;
+        nic_device_id_t device_id;
         packet_dimension_t *packet_dimension;
         size_t size;
@@ -617 +617 @@
                     htons(flip_checksum(compact_checksum(checksum)));
                 free(ip_header);
-        } else {
-                device_id = DEVICE_INVALID_ID;
-        }
+        } else
+                device_id = NIC_DEVICE_INVALID_ID;
 
         /* Prepare the first packet fragment */
@@ -806 +805 @@
                         size = MAX_UDP_FRAGMENT_SIZE;
                         if (tl_get_ip_packet_dimension(udp_globals.ip_sess,
-                            &udp_globals.dimensions, DEVICE_INVALID_ID,
+                            &udp_globals.dimensions, NIC_DEVICE_INVALID_ID,
                             &packet_dimension) == EOK) {
                                 if (packet_dimension->content < size)