Changes in / [0b81cad0:0485135] in mainline

Location:

uspace

Files:

• lib/packet/generic/packet_server.c (modified) (1 diff)
• srv/net/il/arp/arp.c (modified) (20 diffs)
• srv/net/il/arp/arp_module.c (modified) (2 diffs)
• srv/net/il/ip/ip.c (modified) (44 diffs)
• srv/net/il/ip/ip_module.c (modified) (2 diffs)
• srv/net/netif/lo/lo.c (modified) (5 diffs)
• srv/net/nil/eth/eth.c (modified) (20 diffs)
• srv/net/nil/eth/eth_module.c (modified) (2 diffs)
• srv/net/nil/nildummy/nildummy.c (modified) (11 diffs)
• srv/net/nil/nildummy/nildummy.h (modified) (2 diffs)
• srv/net/nil/nildummy/nildummy_module.c (modified) (2 diffs)
• srv/net/tl/icmp/icmp.c (modified) (31 diffs)
• srv/net/tl/icmp/icmp_module.c (modified) (4 diffs)
• srv/net/tl/tcp/tcp.c (modified) (74 diffs)
• srv/net/tl/tcp/tcp_module.c (modified) (2 diffs)
• srv/net/tl/udp/udp.c (modified) (26 diffs)
• srv/net/tl/udp/udp_module.c (modified) (3 diffs)

uspace/lib/packet/generic/packet_server.c

@@ -212 +212 @@
         
         for (index = 0; index < FREE_QUEUES_COUNT; index++) {
-                if ((length > ps_globals.sizes[index]) &&
-                    (index < FREE_QUEUES_COUNT - 1))
+                if (length > ps_globals.sizes[index])
                         continue;
                 

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

@@ -55 +55 @@
 #include <ipc/il.h>
 #include <byteorder.h>
-#include <errno.h>
+#include <err.h>
 
 #include <net/modules.h>
@@ -179 +179 @@
     measured_string_ref address)
 {
-        int rc;
+        ERROR_DECLARE;
 
         *proto = (arp_proto_ref) malloc(sizeof(arp_proto_t));
         if (!*proto)
                 return ENOMEM;
-        
         (*proto)->service = service;
         (*proto)->addr = address;
         (*proto)->addr_data = address->value;
-        
-        rc = arp_addr_initialize(&(*proto)->addresses);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(arp_addr_initialize(&(*proto)->addresses))) {
                 free(*proto);
-                return rc;
-        }
-        
+                return ERROR_CODE;
+        }
         return EOK;
 }
@@ -218 +214 @@
     services_t protocol, measured_string_ref address)
 {
+        ERROR_DECLARE;
+
         arp_device_ref device;
         arp_proto_ref proto;
+        int index;
         hw_type_t hardware;
-        int index;
-        int rc;
 
         fibril_rwlock_write_lock(&arp_globals.lock);
@@ -240 +237 @@
                         proto->addr_data = address->value;
                 } else {
-                        rc = arp_proto_create(&proto, protocol, address);
-                        if (rc != EOK) {
+                        if (ERROR_OCCURRED(arp_proto_create(&proto, protocol,
+                            address))) {
                                 fibril_rwlock_write_unlock(&arp_globals.lock);
-                                return rc;
+                                return ERROR_CODE;
                         }
                         index = arp_protos_add(&device->protos, proto->service,
@@ -268 +265 @@
                 device->hardware = hardware;
                 device->device_id = device_id;
-                rc = arp_protos_initialize(&device->protos);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(arp_protos_initialize(&device->protos)) ||
+                    ERROR_OCCURRED(arp_proto_create(&proto, protocol,
+                    address))) {
                         fibril_rwlock_write_unlock(&arp_globals.lock);
                         free(device);
-                        return rc;
-                }
-                rc = arp_proto_create(&proto, protocol, address);
-                if (rc != EOK) {
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
-                        free(device);
-                        return rc;
+                        return ERROR_CODE;
                 }
                 index = arp_protos_add(&device->protos, proto->service, proto);
@@ -301 +293 @@
                 
                 // get packet dimensions
-                rc = nil_packet_size_req(device->phone, device_id,
-                    &device->packet_dimension);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(nil_packet_size_req(device->phone, device_id,
+                    &device->packet_dimension))) {
                         fibril_rwlock_write_unlock(&arp_globals.lock);
                         arp_protos_destroy(&device->protos);
                         free(device);
-                        return rc;
+                        return ERROR_CODE;
                 }
                 
                 // get hardware address
-                rc = nil_get_addr_req(device->phone, device_id, &device->addr,
-                    &device->addr_data);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(nil_get_addr_req(device->phone, device_id,
+                    &device->addr, &device->addr_data))) {
                         fibril_rwlock_write_unlock(&arp_globals.lock);
                         arp_protos_destroy(&device->protos);
                         free(device);
-                        return rc;
+                        return ERROR_CODE;
                 }
                 
                 // get broadcast address
-                rc = nil_get_broadcast_addr_req(device->phone, device_id,
-                    &device->broadcast_addr, &device->broadcast_data);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(nil_get_broadcast_addr_req(device->phone,
+                    device_id, &device->broadcast_addr,
+                    &device->broadcast_data))) {
                         fibril_rwlock_write_unlock(&arp_globals.lock);
                         free(device->addr);
@@ -329 +319 @@
                         arp_protos_destroy(&device->protos);
                         free(device);
-                        return rc;
-                }
-                
-                rc = arp_cache_add(&arp_globals.cache, device->device_id,
-                    device);
-                if (rc != EOK) {
+                        return ERROR_CODE;
+                }
+                
+                if (ERROR_OCCURRED(arp_cache_add(&arp_globals.cache,
+                    device->device_id, device))) {
                         fibril_rwlock_write_unlock(&arp_globals.lock);
                         free(device->addr);
@@ -342 +331 @@
                         arp_protos_destroy(&device->protos);
                         free(device);
-                        return rc;
+                        return ERROR_CODE;
                 }
                 printf("%s: Device registered (id: %d, type: 0x%x, service: %d,"
@@ -362 +351 @@
 int arp_initialize(async_client_conn_t client_connection)
 {
-        int rc;
+        ERROR_DECLARE;
 
         fibril_rwlock_initialize(&arp_globals.lock);
         fibril_rwlock_write_lock(&arp_globals.lock);
         arp_globals.client_connection = client_connection;
-        rc = arp_cache_initialize(&arp_globals.cache);
+        ERROR_PROPAGATE(arp_cache_initialize(&arp_globals.cache));
         fibril_rwlock_write_unlock(&arp_globals.lock);
-        
-        return rc;
+        return EOK;
 }
 
@@ -418 +406 @@
 static int arp_receive_message(device_id_t device_id, packet_t packet)
 {
+        ERROR_DECLARE;
+
         size_t length;
         arp_header_ref header;
@@ -427 +417 @@
         uint8_t *des_hw;
         uint8_t *des_proto;
-        int rc;
 
         length = packet_get_data_length(packet);
@@ -478 +467 @@
                                 return ENOMEM;
 
-                        rc = arp_addr_add(&proto->addresses, (char *) src_proto,
-                            CONVERT_SIZE(uint8_t, char,
-                            header->protocol_length), hw_source);
-                        if (rc != EOK)
-                                return rc;
+                        ERROR_PROPAGATE(arp_addr_add(&proto->addresses,
+                            (char *) src_proto, CONVERT_SIZE(uint8_t, char,
+                            header->protocol_length), hw_source));
                 }
                 if (ntohs(header->operation) == ARPOP_REQUEST) {
@@ -493 +480 @@
                         memcpy(des_hw, hw_source->value,
                             header->hardware_length);
-                        
-                        rc = packet_set_addr(packet, src_hw, des_hw,
-                            header->hardware_length);
-                        if (rc != EOK)
-                                return rc;
-                        
+                        ERROR_PROPAGATE(packet_set_addr(packet, src_hw, des_hw,
+                            header->hardware_length));
                         nil_send_msg(device->phone, device_id, packet,
                             SERVICE_ARP);
@@ -613 +596 @@
     ipc_call_t *answer, int *answer_count)
 {
+        ERROR_DECLARE;
+        
         measured_string_ref address;
         measured_string_ref translation;
@@ -618 +603 @@
         packet_t packet;
         packet_t next;
-        int rc;
         
         *answer_count = 0;
@@ -626 +610 @@
         
         case NET_ARP_DEVICE:
-                rc = measured_strings_receive(&address, &data, 1);
-                if (rc != EOK)
-                        return rc;
-                
-                rc = arp_device_message(IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address);
-                if (rc != EOK) {
+                ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
+                if (ERROR_OCCURRED(arp_device_message(IPC_GET_DEVICE(call),
+                    IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address))) {
                         free(address);
                         free(data);
                 }
-                return rc;
+                return ERROR_CODE;
         
         case NET_ARP_TRANSLATE:
-                rc = measured_strings_receive(&address, &data, 1);
-                if (rc != EOK)
-                        return rc;
-                
+                ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
                 fibril_rwlock_read_lock(&arp_globals.lock);
                 translation = arp_translate_message(IPC_GET_DEVICE(call),
@@ -652 +629 @@
                         return ENOENT;
                 }
-                rc = measured_strings_reply(translation, 1);
+                ERROR_CODE = measured_strings_reply(translation, 1);
                 fibril_rwlock_read_unlock(&arp_globals.lock);
-                return rc;
+                return ERROR_CODE;
 
         case NET_ARP_CLEAR_DEVICE:
@@ -660 +637 @@
 
         case NET_ARP_CLEAR_ADDRESS:
-                rc = measured_strings_receive(&address, &data, 1);
-                if (rc != EOK)
-                        return rc;
-                
+                ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
                 arp_clear_address_req(0, IPC_GET_DEVICE(call),
                     IPC_GET_SERVICE(call), address);
@@ -678 +652 @@
         
         case NET_IL_RECEIVED:
-                rc = packet_translate_remote(arp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                
-                fibril_rwlock_read_lock(&arp_globals.lock);
-                do {
-                        next = pq_detach(packet);
-                        rc = arp_receive_message(IPC_GET_DEVICE(call), packet);
-                        if (rc != 1) {
-                                pq_release_remote(arp_globals.net_phone,
-                                    packet_get_id(packet));
-                        }
-                        packet = next;
-                } while (packet);
-                fibril_rwlock_read_unlock(&arp_globals.lock);
-                
-                return EOK;
+                if (ERROR_NONE(packet_translate_remote(arp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        fibril_rwlock_read_lock(&arp_globals.lock);
+                        do {
+                                next = pq_detach(packet);
+                                ERROR_CODE =
+                                    arp_receive_message(IPC_GET_DEVICE(call),
+                                    packet);
+                                if (ERROR_CODE != 1) {
+                                        pq_release_remote(arp_globals.net_phone,
+                                            packet_get_id(packet));
+                                }
+                                packet = next;
+                        } while (packet);
+                        fibril_rwlock_read_unlock(&arp_globals.lock);
+                }
+                return ERROR_CODE;
         
         case NET_IL_MTU_CHANGED:
@@ -754 +727 @@
 int main(int argc, char *argv[])
 {
-        int rc;
+        ERROR_DECLARE;
         
         /* Start the module */
-        rc = il_module_start_standalone(il_client_connection);
-        return rc;
+        ERROR_PROPAGATE(il_module_start_standalone(il_client_connection));
+        return EOK;
 }
 

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

@@ -41 +41 @@
 #include <async.h>
 #include <stdio.h>
-#include <errno.h>
+#include <err.h>
 
 #include <ipc/ipc.h>
@@ -66 +66 @@
 int il_module_start_standalone(async_client_conn_t client_connection)
 {
-        ipcarg_t phonehash;
-        int rc;
+        ERROR_DECLARE;
         
         async_set_client_connection(client_connection);
         arp_globals.net_phone = net_connect_module();
+        ERROR_PROPAGATE(pm_init());
         
-        rc = pm_init();
-        if (rc != EOK)
-                return rc;
-        
-        rc = arp_initialize(client_connection);
-        if (rc != EOK)
-                goto out;
-        
-        rc = REGISTER_ME(SERVICE_ARP, &phonehash);
-        if (rc != EOK)
-                goto out;
+        ipcarg_t phonehash;
+        if (ERROR_OCCURRED(arp_initialize(client_connection)) ||
+            ERROR_OCCURRED(REGISTER_ME(SERVICE_ARP, &phonehash))) {
+                pm_destroy();
+                return ERROR_CODE;
+        }
         
         async_manager();
-
-out:
+        
         pm_destroy();
-        return rc;
+        return EOK;
 }
 

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

@@ -41 +41 @@
 #include <async.h>
 #include <errno.h>
+#include <err.h>
 #include <fibril_synch.h>
 #include <stdio.h>
@@ -253 +254 @@
 int ip_initialize(async_client_conn_t client_connection)
 {
-        int rc;
+        ERROR_DECLARE;
 
         fibril_rwlock_initialize(&ip_globals.lock);
@@ -264 +265 @@
         ip_globals.gateway.gateway.s_addr = 0;
         ip_globals.gateway.netif = NULL;
+        ERROR_PROPAGATE(ip_netifs_initialize(&ip_globals.netifs));
+        ERROR_PROPAGATE(ip_protos_initialize(&ip_globals.protos));
         ip_globals.client_connection = client_connection;
-        
-        rc = ip_netifs_initialize(&ip_globals.netifs);
-        if (rc != EOK)
-                goto out;
-        rc = ip_protos_initialize(&ip_globals.protos);
-        if (rc != EOK)
-                goto out;
-        rc = modules_initialize(&ip_globals.modules);
-        if (rc != EOK)
-                goto out;
-        rc = add_module(NULL, &ip_globals.modules, ARP_NAME, ARP_FILENAME,
-            SERVICE_ARP, 0, arp_connect_module);
-
-out:
+        ERROR_PROPAGATE(modules_initialize(&ip_globals.modules));
+        ERROR_PROPAGATE(add_module(NULL, &ip_globals.modules, ARP_NAME,
+            ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module));
         fibril_rwlock_write_unlock(&ip_globals.lock);
 
-        return rc;
+        return EOK;
 }
 
@@ -310 +302 @@
 static int ip_netif_initialize(ip_netif_ref ip_netif)
 {
+        ERROR_DECLARE;
+
         measured_string_t names[] = {
                 {
@@ -348 +342 @@
         char *data;
         measured_string_t address;
+        int index;
         ip_route_ref route;
         in_addr_t gateway;
-        int index;
-        int rc;
 
         ip_netif->arp = NULL;
@@ -361 +354 @@
 
         // get configuration
-        rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
-            &configuration, count, &data);
-        if (rc != EOK)
-                return rc;
-        
+        ERROR_PROPAGATE(net_get_device_conf_req(ip_globals.net_phone,
+            ip_netif->device_id, &configuration, count, &data));
         if (configuration) {
                 if (configuration[0].value)
@@ -393 +383 @@
                                 return index;
                         }
-                        
-                        if ((inet_pton(AF_INET, configuration[2].value,
-                            (uint8_t *) &route->address.s_addr) != EOK) ||
-                            (inet_pton(AF_INET, configuration[3].value,
-                            (uint8_t *) &route->netmask.s_addr) != EOK) ||
+                        if (ERROR_OCCURRED(inet_pton(AF_INET,
+                            configuration[2].value,
+                            (uint8_t *) &route->address.s_addr)) ||
+                            ERROR_OCCURRED(inet_pton(AF_INET,
+                            configuration[3].value,
+                            (uint8_t *) &route->netmask.s_addr)) ||
                             (inet_pton(AF_INET, configuration[4].value,
                             (uint8_t *) &gateway.s_addr) == EINVAL) ||
@@ -443 +434 @@
                         address.value = (char *) &route->address.s_addr;
                         address.length = CONVERT_SIZE(in_addr_t, char, 1);
-                        
-                        rc = arp_device_req(ip_netif->arp->phone,
+                        ERROR_PROPAGATE(arp_device_req(ip_netif->arp->phone,
                             ip_netif->device_id, SERVICE_IP, ip_netif->service,
-                            &address);
-                        if (rc != EOK)
-                                return rc;
+                            &address));
                 } else {
                         ip_netif->arp = 0;
@@ -455 +443 @@
 
         // get packet dimensions
-        rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
-            &ip_netif->packet_dimension);
-        if (rc != EOK)
-                return rc;
-        
+        ERROR_PROPAGATE(nil_packet_size_req(ip_netif->phone,
+            ip_netif->device_id, &ip_netif->packet_dimension));
         if (ip_netif->packet_dimension.content < IP_MIN_CONTENT) {
                 printf("Maximum transmission unit %d bytes is too small, at "
@@ -625 +610 @@
     measured_string_ref destination)
 {
+        ERROR_DECLARE;
+
         size_t length;
         ip_header_ref header;
@@ -630 +617 @@
         ip_header_ref middle_header;
         packet_t next;
-        int rc;
 
         length = packet_get_data_length(packet);
@@ -638 +624 @@
         header = (ip_header_ref) packet_get_data(packet);
         if (destination) {
-                rc = packet_set_addr(packet, NULL, (uint8_t *) destination->value,
-                    CONVERT_SIZE(char, uint8_t, destination->length));
+                ERROR_PROPAGATE(packet_set_addr(packet, NULL,
+                    (uint8_t *) destination->value,
+                    CONVERT_SIZE(char, uint8_t, destination->length)));
         } else {
-                rc = packet_set_addr(packet, NULL, NULL, 0);
-        }
-        if (rc != EOK)
-                return rc;
-        
+                ERROR_PROPAGATE(packet_set_addr(packet, NULL, NULL, 0));
+        }
         header->version = IPV4;
         header->fragment_offset_high = 0;
@@ -685 +669 @@
                             IP_HEADER_CHECKSUM(middle_header);
                         if (destination) {
-                                rc = packet_set_addr(next, NULL,
+                                if (ERROR_OCCURRED(packet_set_addr(next, NULL,
                                     (uint8_t *) destination->value,
                                     CONVERT_SIZE(char, uint8_t,
-                                    destination->length));
-                                if (rc != EOK) {
+                                    destination->length)))) {
                                         free(last_header);
-                                        return rc;
+                                        return ERROR_CODE;
                                 }
                         }
@@ -716 +699 @@
                     IP_HEADER_CHECKSUM(middle_header);
                 if (destination) {
-                        rc = packet_set_addr(next, NULL,
+                        if (ERROR_OCCURRED(packet_set_addr(next, NULL,
                             (uint8_t *) destination->value,
-                            CONVERT_SIZE(char, uint8_t, destination->length));
-                        if (rc != EOK) {
+                            CONVERT_SIZE(char, uint8_t,
+                            destination->length)))) {
                                 free(last_header);
-                                return rc;
-                        }
+                                return ERROR_CODE;
+                            }
                 }
                 length += packet_get_data_length(next);
@@ -758 +741 @@
     const struct sockaddr *src, const struct sockaddr *dest, socklen_t addrlen)
 {
+        ERROR_DECLARE;
+
         void *data;
         size_t offset;
-        int rc;
 
         data = packet_suffix(new_packet, length);
@@ -768 +752 @@
         memcpy(data, ((void *) header) + IP_TOTAL_LENGTH(header) - length,
             length);
-        
-        rc = packet_trim(packet, 0, length);
-        if (rc != EOK)
-                return rc;
-        
+        ERROR_PROPAGATE(packet_trim(packet, 0, length));
         header->total_length = htons(IP_TOTAL_LENGTH(header) - length);
         new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
@@ -781 +761 @@
             IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
         new_header->header_checksum = IP_HEADER_CHECKSUM(new_header);
-        
-        rc = packet_set_addr(new_packet, (const uint8_t *) src,
-            (const uint8_t *) dest, addrlen);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(packet_set_addr(new_packet, (const uint8_t *) src,
+            (const uint8_t *) dest, addrlen));
 
         return pq_insert_after(packet, new_packet);
@@ -819 +796 @@
     socklen_t addr_len)
 {
+        ERROR_DECLARE;
+
         packet_t new_packet;
         ip_header_ref header;
@@ -827 +806 @@
         socklen_t addrlen;
         int result;
-        int rc;
 
         result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
@@ -861 +839 @@
 
         // trim the unused space
-        rc = packet_trim(new_packet, 0,
-            IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header));
-        if (rc != EOK)
-                return ip_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(packet_trim(new_packet, 0,
+            IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header)))) {
+                return ip_release_and_return(packet, ERROR_CODE);
+        }
 
         // biggest multiple of 8 lower than content
         // TODO even fragmentation?
         length = length & ~0x7;
-        
-        rc = ip_fragment_packet_data(packet, new_packet, header, last_header,
+        if (ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet, header,
+            last_header,
             ((IP_HEADER_DATA_LENGTH(header) -
             ((length - IP_HEADER_LENGTH(header)) & ~0x7)) %
-            ((length - IP_HEADER_LENGTH(last_header)) & ~0x7)),
-            src, dest, addrlen);
-        if (rc != EOK)
-                return ip_release_and_return(packet, rc);
+            ((length - IP_HEADER_LENGTH(last_header)) & ~0x7)), src, dest,
+            addrlen))) {
+                return ip_release_and_return(packet, ERROR_CODE);
+        }
 
         // mark the first as fragmented
@@ -894 +872 @@
                         return ip_release_and_return(packet, ENOMEM);
 
-                rc = ip_fragment_packet_data(packet, new_packet, header,
-                    middle_header,
-                    (length - IP_HEADER_LENGTH(middle_header)) & ~0x7,
-                    src, dest, addrlen);
-                if (rc != EOK)
-                        return ip_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet,
+                    header, middle_header,
+                    (length - IP_HEADER_LENGTH(middle_header)) & ~0x7, src,
+                    dest, addrlen))) {
+                        return ip_release_and_return(packet, ERROR_CODE);
+                }
         }
 
@@ -996 +974 @@
     in_addr_t *src, in_addr_t dest, services_t error)
 {
+        ERROR_DECLARE;
+
         measured_string_t destination;
         measured_string_ref translation;
         char *data;
         int phone;
-        int rc;
 
         // get destination hardware address
@@ -1008 +987 @@
                 destination.length = CONVERT_SIZE(dest.s_addr, char, 1);
 
-                rc = arp_translate_req(netif->arp->phone, netif->device_id,
-                    SERVICE_IP, &destination, &translation, &data);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(arp_translate_req(netif->arp->phone,
+                    netif->device_id, SERVICE_IP, &destination, &translation,
+                    &data))) {
                         pq_release_remote(ip_globals.net_phone,
                             packet_get_id(packet));
-                        return rc;
+                        return ERROR_CODE;
                 }
 
@@ -1035 +1014 @@
         }
 
-        rc = ip_prepare_packet(src, dest, packet, translation);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(ip_prepare_packet(src, dest, packet, translation))) {
                 pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
         } else {
@@ -1054 +1032 @@
         }
 
-        return rc;
+        return ERROR_CODE;
 }
 
@@ -1180 +1158 @@
 ip_device_req_local(int il_phone, device_id_t device_id, services_t netif)
 {
+        ERROR_DECLARE;
+
         ip_netif_ref ip_netif;
         ip_route_ref route;
         int index;
-        int rc;
 
         ip_netif = (ip_netif_ref) malloc(sizeof(ip_netif_t));
@@ -1189 +1168 @@
                 return ENOMEM;
 
-        rc = ip_routes_initialize(&ip_netif->routes);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(ip_routes_initialize(&ip_netif->routes))) {
                 free(ip_netif);
-                return rc;
+                return ERROR_CODE;
         }
 
@@ -1200 +1178 @@
 
         fibril_rwlock_write_lock(&ip_globals.netifs_lock);
-
-        rc = ip_netif_initialize(ip_netif);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(ip_netif_initialize(ip_netif))) {
                 fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
                 ip_routes_destroy(&ip_netif->routes);
                 free(ip_netif);
-                return rc;
+                return ERROR_CODE;
         }
         if (ip_netif->arp)
@@ -1250 +1226 @@
     services_t sender, services_t error)
 {
+        ERROR_DECLARE;
+
         int addrlen;
         ip_netif_ref netif;
@@ -1258 +1236 @@
         in_addr_t *src;
         int phone;
-        int rc;
 
         // addresses in the host byte order
@@ -1346 +1323 @@
         }
 
-        rc = ip_send_route(packet, netif, route, src, *dest, error);
+        ERROR_CODE = ip_send_route(packet, netif, route, src, *dest, error);
         fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
 
-        return rc;
+        return ERROR_CODE;
 }
 
@@ -1454 +1431 @@
     services_t error)
 {
+        ERROR_DECLARE;
+
         ip_proto_ref proto;
         int phone;
@@ -1463 +1442 @@
         struct sockaddr_in dest_in;
         socklen_t addrlen;
-        int rc;
 
         if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
@@ -1489 +1467 @@
         }
 
-        rc = packet_set_addr(packet, (uint8_t *) src, (uint8_t *) dest,
-            addrlen);
-        if (rc != EOK)
-                return ip_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(packet_set_addr(packet, (uint8_t *) src,
+            (uint8_t *) dest, addrlen))) {
+                return ip_release_and_return(packet, ERROR_CODE);
+        }
 
         // trim padding if present
         if (!error &&
             (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
-                rc = packet_trim(packet, 0,
-                    packet_get_data_length(packet) - IP_TOTAL_LENGTH(header));
-                if (rc != EOK)
-                        return ip_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(packet_trim(packet, 0,
+                    packet_get_data_length(packet) - IP_TOTAL_LENGTH(header))))
+                        return ip_release_and_return(packet, ERROR_CODE);
         }
 
@@ -1521 +1498 @@
                 received_msg = proto->received_msg;
                 fibril_rwlock_read_unlock(&ip_globals.protos_lock);
-                rc = received_msg(device_id, packet, service, error);
+                ERROR_CODE = received_msg(device_id, packet, service, error);
         } else {
-                rc = tl_received_msg(proto->phone, device_id, packet,
+                ERROR_CODE = tl_received_msg(proto->phone, device_id, packet,
                     proto->service, error);
                 fibril_rwlock_read_unlock(&ip_globals.protos_lock);
         }
 
-        return rc;
+        return ERROR_CODE;
 }
 
@@ -1555 +1532 @@
 ip_process_packet(device_id_t device_id, packet_t packet)
 {
+        ERROR_DECLARE;
+
         ip_header_ref header;
         in_addr_t dest;
@@ -1562 +1541 @@
         struct sockaddr_in addr_in;
         socklen_t addrlen;
-        int rc;
 
         header = (ip_header_ref) packet_get_data(packet);
@@ -1607 +1585 @@
         }
 
-        rc = packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(packet_set_addr(packet, NULL, (uint8_t *) &addr,
+            addrlen));
 
         route = ip_find_route(dest);
@@ -1890 +1867 @@
     int *answer_count)
 {
+        ERROR_DECLARE;
+        
         packet_t packet;
         struct sockaddr *addr;
@@ -1899 +1878 @@
         size_t headerlen;
         device_id_t device_id;
-        int rc;
         
         *answer_count = 0;
@@ -1915 +1893 @@
         
         case NET_IL_SEND:
-                rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)));
                 return ip_send_msg_local(0, IPC_GET_DEVICE(call), packet, 0,
                     IPC_GET_ERROR(call));
@@ -1927 +1903 @@
         
         case NET_IL_RECEIVED:
-                rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)));
                 return ip_receive_message(IPC_GET_DEVICE(call), packet);
         
         case NET_IP_RECEIVED_ERROR:
-                rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)));
                 return ip_received_error_msg_local(0, IPC_GET_DEVICE(call),
                     packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
@@ -1951 +1923 @@
 
         case NET_IP_GET_ROUTE:
-                rc = data_receive((void **) &addr, &addrlen);
-                if (rc != EOK)
-                        return rc;
-                
-                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(call), addr,
-                    (socklen_t) addrlen, &device_id, &header, &headerlen);
-                if (rc != EOK)
-                        return rc;
-                
+                ERROR_PROPAGATE(data_receive((void **) &addr, &addrlen));
+                ERROR_PROPAGATE(ip_get_route_req_local(0, IP_GET_PROTOCOL(call),
+                    addr, (socklen_t) addrlen, &device_id, &header,
+                    &headerlen));
                 IPC_SET_DEVICE(answer, device_id);
                 IP_SET_HEADERLEN(answer, headerlen);
                 
                 *answer_count = 2;
-                
-                rc = data_reply(&headerlen, sizeof(headerlen));
-                if (rc == EOK)
-                        rc = data_reply(header, headerlen);
+                        
+                if (ERROR_NONE(data_reply(&headerlen, sizeof(headerlen))))
+                        ERROR_CODE = data_reply(header, headerlen);
                         
                 free(header);
-                return rc;
+                return ERROR_CODE;
         
         case NET_IL_PACKET_SPACE:
-                rc = ip_packet_size_message(IPC_GET_DEVICE(call), &addrlen,
-                    &prefix, &content, &suffix);
-                if (rc != EOK)
-                        return rc;
-                
+                ERROR_PROPAGATE(ip_packet_size_message(IPC_GET_DEVICE(call),
+                    &addrlen, &prefix, &content, &suffix));
                 IPC_SET_ADDR(answer, addrlen);
                 IPC_SET_PREFIX(answer, prefix);
@@ -2042 +2005 @@
 int main(int argc, char *argv[])
 {
-        int rc;
+        ERROR_DECLARE;
         
         /* Start the module */
-        rc = il_module_start_standalone(il_client_connection);
-        return rc;
+        ERROR_PROPAGATE(il_module_start_standalone(il_client_connection));
+        return EOK;
 }
 

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

@@ -44 +44 @@
 #include <ipc/ipc.h>
 #include <ipc/services.h>
-#include <errno.h>
+#include <err.h>
 
 #include <net/modules.h>
@@ -66 +66 @@
 int il_module_start_standalone(async_client_conn_t client_connection)
 {
-        ipcarg_t phonehash;
-        int rc;
+        ERROR_DECLARE;
         
         async_set_client_connection(client_connection);
         ip_globals.net_phone = net_connect_module();
-
-        rc = pm_init();
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(pm_init());
         
-        rc = ip_initialize(client_connection);
-        if (rc != EOK)
-                goto out;
-        
-        rc = REGISTER_ME(SERVICE_IP, &phonehash);
-        if (rc != EOK)
-                goto out;
+        ipcarg_t phonehash;
+        if (ERROR_OCCURRED(ip_initialize(client_connection)) ||
+            ERROR_OCCURRED(REGISTER_ME(SERVICE_IP, &phonehash))) {
+                pm_destroy();
+                return ERROR_CODE;
+        }
         
         async_manager();
-
-out:
+        
         pm_destroy();
-        return rc;
+        return EOK;
 }
 

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

@@ -37 +37 @@
 #include <async.h>
 #include <errno.h>
+#include <err.h>
 #include <stdio.h>
 #include <str.h>
@@ -82 +83 @@
 int netif_get_device_stats(device_id_t device_id, device_stats_ref stats)
 {
+        ERROR_DECLARE;
+
         netif_device_t *device;
-        int rc;
 
         if (!stats)
                 return EBADMEM;
-        rc = find_device(device_id, &device);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(find_device(device_id, &device));
         memcpy(stats, (device_stats_ref) device->specific,
             sizeof(device_stats_t));
@@ -164 +164 @@
 int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
 {
+        ERROR_DECLARE;
+
         netif_device_t *device;
-        int rc;
 
         // create a new device
-        rc = create(device_id, &device);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(create(device_id, &device));
         // print the settings
         printf("%s: Device created (id: %d)\n", NAME, device->device_id);
@@ -178 +177 @@
 int netif_send_message(device_id_t device_id, packet_t packet, services_t sender)
 {
+        ERROR_DECLARE;
+
         netif_device_t *device;
         size_t length;
         packet_t next;
         int phone;
-        int rc;
-
-        rc = find_device(device_id, &device);
-        if (rc != EOK)
-                return EOK;
+
+        ERROR_PROPAGATE(find_device(device_id, &device));
         if (device->state != NETIF_ACTIVE) {
                 netif_pq_release(packet_get_id(packet));
@@ -261 +259 @@
 int main(int argc, char *argv[])
 {
-        int rc;
+        ERROR_DECLARE;
         
         /* Start the module */
-        rc = netif_module_start(netif_client_connection);
-        return rc;
+        ERROR_PROPAGATE(netif_module_start(netif_client_connection));
+        return EOK;
 }
 

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

@@ -42 +42 @@
 #include <byteorder.h>
 #include <str.h>
-#include <errno.h>
+#include <err.h>
 
 #include <ipc/ipc.h>
@@ -196 +196 @@
 int nil_initialize(int net_phone)
 {
-        int rc;
+        ERROR_DECLARE;
 
         fibril_rwlock_initialize(&eth_globals.devices_lock);
@@ -208 +208 @@
             CONVERT_SIZE(uint8_t, char, ETH_ADDR));
         if (!eth_globals.broadcast_addr) {
-                rc = ENOMEM;
+                ERROR_CODE = ENOMEM;
                 goto out;
         }
-        rc = eth_devices_initialize(&eth_globals.devices);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(eth_devices_initialize(&eth_globals.devices))) {
                 free(eth_globals.broadcast_addr);
                 goto out;
         }
-        rc = eth_protos_initialize(&eth_globals.protos);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(eth_protos_initialize(&eth_globals.protos))) {
                 free(eth_globals.broadcast_addr);
                 eth_devices_destroy(&eth_globals.devices);
@@ -225 +223 @@
         fibril_rwlock_write_unlock(&eth_globals.devices_lock);
         
-        return rc;
+        return ERROR_CODE;
 }
 
@@ -236 +234 @@
 static void eth_receiver(ipc_callid_t iid, ipc_call_t *icall)
 {
+        ERROR_DECLARE;
+
         packet_t packet;
-        int rc;
 
         while (true) {
@@ -247 +246 @@
                         break;
                 case NET_NIL_RECEIVED:
-                        rc = packet_translate_remote(eth_globals.net_phone,
-                            &packet, IPC_GET_PACKET(icall));
-                        if (rc == EOK) {
-                                rc = nil_received_msg_local(0,
+                        if (ERROR_NONE(packet_translate_remote(
+                            eth_globals.net_phone, &packet,
+                            IPC_GET_PACKET(icall)))) {
+                                ERROR_CODE = nil_received_msg_local(0,
                                     IPC_GET_DEVICE(icall), packet, 0);
                         }
-                        ipc_answer_0(iid, (ipcarg_t) rc);
+                        ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
                         break;
                 default:
@@ -283 +282 @@
 eth_device_message(device_id_t device_id, services_t service, size_t mtu)
 {
+        ERROR_DECLARE;
+
         eth_device_ref device;
         int index;
@@ -299 +300 @@
         char *data;
         eth_proto_ref proto;
-        int rc;
 
         fibril_rwlock_write_lock(&eth_globals.devices_lock);
@@ -351 +351 @@
 
         configuration = &names[0];
-        rc = net_get_device_conf_req(eth_globals.net_phone, device->device_id,
-            &configuration, count, &data);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(net_get_device_conf_req(eth_globals.net_phone,
+            device->device_id, &configuration, count, &data))) {
                 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
                 free(device);
-                return rc;
+                return ERROR_CODE;
         }
         if (configuration) {
@@ -388 +387 @@
         
         // get hardware address
-        rc = netif_get_addr_req(device->phone, device->device_id, &device->addr,
-            &device->addr_data);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id,
+            &device->addr, &device->addr_data))) {
                 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
                 free(device);
-                return rc;
+                return ERROR_CODE;
         }
         
@@ -431 +429 @@
 static eth_proto_ref eth_process_packet(int flags, packet_t packet)
 {
+        ERROR_DECLARE;
+
         eth_header_snap_ref header;
         size_t length;
@@ -437 +437 @@
         size_t suffix;
         eth_fcs_ref fcs;
-        uint8_t *data;
-        int rc;
+        uint8_t * data;
 
         length = packet_get_data_length(packet);
@@ -489 +488 @@
         
         if (IS_DUMMY(flags)) {
-                if (~compute_crc32(~0U, data, length * 8) != ntohl(*fcs))
+                if ((~compute_crc32(~0U, data, length * 8)) != ntohl(*fcs))
                         return NULL;
                 suffix += sizeof(eth_fcs_t);
         }
         
-        rc = packet_set_addr(packet, header->header.source_address,
-            header->header.destination_address, ETH_ADDR);
-        if (rc != EOK)
+        if (ERROR_OCCURRED(packet_set_addr(packet,
+            header->header.source_address, header->header.destination_address,
+            ETH_ADDR)) || ERROR_OCCURRED(packet_trim(packet, prefix, suffix))) {
                 return NULL;
-
-        rc = packet_trim(packet, prefix, suffix);
-        if (rc != EOK)
-                return NULL;
+        }
         
         return eth_protos_find(&eth_globals.protos, type);
@@ -785 +781 @@
 eth_send_message(device_id_t device_id, packet_t packet, services_t sender)
 {
+        ERROR_DECLARE;
+
         eth_device_ref device;
         packet_t next;
         packet_t tmp;
         int ethertype;
-        int rc;
 
         ethertype = htons(protocol_map(SERVICE_ETHERNET, sender));
@@ -807 +804 @@
         next = packet;
         do {
-                rc = eth_prepare_packet(device->flags, next,
-                    (uint8_t *) device->addr->value, ethertype, device->mtu);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(eth_prepare_packet(device->flags, next,
+                    (uint8_t *) device->addr->value, ethertype, device->mtu))) {
                         // release invalid packet
                         tmp = pq_detach(next);
@@ -836 +832 @@
     ipc_call_t *answer, int *answer_count)
 {
+        ERROR_DECLARE;
+        
         measured_string_ref address;
         packet_t packet;
@@ -842 +840 @@
         size_t suffix;
         size_t content;
-        int rc;
         
         *answer_count = 0;
@@ -853 +850 @@
                     IPC_GET_SERVICE(call), IPC_GET_MTU(call));
         case NET_NIL_SEND:
-                rc = packet_translate_remote(eth_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(packet_translate_remote(eth_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)));
                 return eth_send_message(IPC_GET_DEVICE(call), packet,
                     IPC_GET_SERVICE(call));
         case NET_NIL_PACKET_SPACE:
-                rc = eth_packet_space_message(IPC_GET_DEVICE(call), &addrlen,
-                    &prefix, &content, &suffix);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(eth_packet_space_message(IPC_GET_DEVICE(call),
+                    &addrlen, &prefix, &content, &suffix));
                 IPC_SET_ADDR(answer, addrlen);
                 IPC_SET_PREFIX(answer, prefix);
@@ -871 +864 @@
                 return EOK;
         case NET_NIL_ADDR:
-                rc = eth_addr_message(IPC_GET_DEVICE(call), ETH_LOCAL_ADDR,
-                    &address);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call),
+                    ETH_LOCAL_ADDR, &address));
                 return measured_strings_reply(address, 1);
         case NET_NIL_BROADCAST_ADDR:
-                rc = eth_addr_message(IPC_GET_DEVICE(call), ETH_BROADCAST_ADDR,
-                    &address);
-                if (rc != EOK)
-                        return EOK;
+                ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call),
+                    ETH_BROADCAST_ADDR, &address));
                 return measured_strings_reply(address, 1);
         case IPC_M_CONNECT_TO_ME:
@@ -934 +923 @@
 int main(int argc, char *argv[])
 {
-        int rc;
+        ERROR_DECLARE;
         
         /* Start the module */
-        rc = nil_module_start_standalone(nil_client_connection);
-        return rc;
+        ERROR_PROPAGATE(nil_module_start_standalone(nil_client_connection));
+        return EOK;
 }
 

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

@@ -40 +40 @@
 #include <async.h>
 #include <stdio.h>
-#include <errno.h>
+#include <err.h>
 
 #include <ipc/ipc.h>
@@ -52 +52 @@
 int nil_module_start_standalone(async_client_conn_t client_connection)
 {
-        ipcarg_t phonehash;
-        int rc;
+        ERROR_DECLARE;
         
         async_set_client_connection(client_connection);
         int net_phone = net_connect_module();
-
-        rc = pm_init();
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(pm_init());
         
-        rc = nil_initialize(net_phone);
-        if (rc != EOK)
-                goto out;
-
-        rc = REGISTER_ME(SERVICE_ETHERNET, &phonehash);
-        if (rc != EOK)
-                goto out;
+        ipcarg_t phonehash;
+        if (ERROR_OCCURRED(nil_initialize(net_phone)) ||
+            ERROR_OCCURRED(REGISTER_ME(SERVICE_ETHERNET, &phonehash))) {
+                pm_destroy();
+                return ERROR_CODE;
+        }
         
         async_manager();
-
-out:
+        
         pm_destroy();
-        return rc;
+        return EOK;
 }
 

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

@@ -41 +41 @@
 #include <stdio.h>
 #include <str.h>
+#include <err.h>
 #include <ipc/ipc.h>
 #include <ipc/net.h>
@@ -81 +82 @@
 int nil_initialize(int net_phone)
 {
-        int rc;
+        ERROR_DECLARE;
         
         fibril_rwlock_initialize(&nildummy_globals.devices_lock);
@@ -90 +91 @@
         nildummy_globals.net_phone = net_phone;
         nildummy_globals.proto.phone = 0;
-        rc = nildummy_devices_initialize(&nildummy_globals.devices);
+        ERROR_CODE = nildummy_devices_initialize(&nildummy_globals.devices);
         
         fibril_rwlock_write_unlock(&nildummy_globals.protos_lock);
         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
         
-        return rc;
+        return ERROR_CODE;
 }
 
@@ -106 +107 @@
 static void nildummy_receiver(ipc_callid_t iid, ipc_call_t *icall)
 {
+        ERROR_DECLARE;
+
         packet_t packet;
-        int rc;
 
         while (true) {
                 switch (IPC_GET_METHOD(*icall)) {
                 case NET_NIL_DEVICE_STATE:
-                        rc = nil_device_state_msg_local(0,
+                        ERROR_CODE = nil_device_state_msg_local(0,
                             IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
-                        ipc_answer_0(iid, (ipcarg_t) rc);
+                        ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
                         break;
                 
                 case NET_NIL_RECEIVED:
-                        rc = packet_translate_remote(nildummy_globals.net_phone,
-                            &packet, IPC_GET_PACKET(icall));
-                        if (rc == EOK) {
-                                rc = nil_received_msg_local(0,
+                        if (ERROR_NONE(packet_translate_remote(
+                            nildummy_globals.net_phone, &packet,
+                            IPC_GET_PACKET(icall)))) {
+                                ERROR_CODE = nil_received_msg_local(0,
                                     IPC_GET_DEVICE(icall), packet, 0);
                         }
-                        ipc_answer_0(iid, (ipcarg_t) rc);
+                        ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
                         break;
                 
@@ -153 +155 @@
 nildummy_device_message(device_id_t device_id, services_t service, size_t mtu)
 {
+        ERROR_DECLARE;
+
         nildummy_device_ref device;
         int index;
-        int rc;
 
         fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
@@ -213 +216 @@
         
         // get hardware address
-        rc = netif_get_addr_req(device->phone, device->device_id, &device->addr,
-            &device->addr_data);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id,
+            &device->addr, &device->addr_data))) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
                 free(device);
-                return rc;
+                return ERROR_CODE;
         }
         
@@ -378 +380 @@
     ipc_call_t *answer, int *answer_count)
 {
+        ERROR_DECLARE;
+        
         measured_string_ref address;
         packet_t packet;
@@ -384 +388 @@
         size_t suffix;
         size_t content;
-        int rc;
         
         *answer_count = 0;
@@ -396 +399 @@
         
         case NET_NIL_SEND:
-                rc = packet_translate_remote(nildummy_globals.net_phone,
-                    &packet, IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(packet_translate_remote(
+                    nildummy_globals.net_phone, &packet, IPC_GET_PACKET(call)));
                 return nildummy_send_message(IPC_GET_DEVICE(call), packet,
                     IPC_GET_SERVICE(call));
         
         case NET_NIL_PACKET_SPACE:
-                rc = nildummy_packet_space_message(IPC_GET_DEVICE(call),
-                    &addrlen, &prefix, &content, &suffix);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(nildummy_packet_space_message(
+                    IPC_GET_DEVICE(call), &addrlen, &prefix, &content,
+                    &suffix));
                 IPC_SET_ADDR(answer, addrlen);
                 IPC_SET_PREFIX(answer, prefix);
@@ -416 +416 @@
         
         case NET_NIL_ADDR:
-                rc = nildummy_addr_message(IPC_GET_DEVICE(call), &address);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(nildummy_addr_message(IPC_GET_DEVICE(call),
+                    &address));
                 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;
+                ERROR_PROPAGATE(nildummy_addr_message(IPC_GET_DEVICE(call),
+                    &address));
                 return measured_strings_reply(address, 1);
         
@@ -478 +476 @@
 int main(int argc, char *argv[])
 {
-        int rc;
+        ERROR_DECLARE;
         
         /* Start the module */
-        rc = nil_module_start_standalone(nil_client_connection);
-        return rc;
+        ERROR_PROPAGATE(nil_module_start_standalone(nil_client_connection));
+        return EOK;
 }
 

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

@@ -62 +62 @@
  * @see nildummy_proto
  */
-typedef struct nildummy_proto nildummy_proto_t;
+typedef struct nildummy_proto   nildummy_proto_t;
 
 /** Type definition of the dummy nil protocol specific data pointer.
@@ -100 +100 @@
 
 /** Dummy nil global data. */
-struct nildummy_globals {
+struct  nildummy_globals {
         /** Networking module phone. */
         int net_phone;

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

@@ -38 +38 @@
 #include <async.h>
 #include <stdio.h>
-#include <errno.h>
+#include <err.h>
 
 #include <ipc/ipc.h>
@@ -52 +52 @@
 int nil_module_start_standalone(async_client_conn_t client_connection)
 {
-        ipcarg_t phonehash;
-        int rc;
+        ERROR_DECLARE;
         
         async_set_client_connection(client_connection);
         int net_phone = net_connect_module();
+        ERROR_PROPAGATE(pm_init());
         
-        rc = pm_init();
-        if (rc != EOK)
-                return rc;
-        
-        
-        rc = nil_initialize(net_phone);
-        if (rc != EOK)
-                goto out;
-        
-        rc = REGISTER_ME(SERVICE_NILDUMMY, &phonehash);
-        if (rc != EOK)
-                goto out;
+        ipcarg_t phonehash;
+        if (ERROR_OCCURRED(nil_initialize(net_phone)) ||
+            ERROR_OCCURRED(REGISTER_ME(SERVICE_NILDUMMY, &phonehash))) {
+                pm_destroy();
+                return ERROR_CODE;
+        }
         
         async_manager();
-
-out:
+        
         pm_destroy();
-        return rc;
+        return EOK;
 }
 

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

@@ -54 +54 @@
 #include <byteorder.h>
 #include <errno.h>
+#include <err.h>
 
 #include <net/socket_codes.h>
@@ -160 +161 @@
     int dont_fragment)
 {
-        int rc;
+        ERROR_DECLARE;
 
         // do not send an error if disabled
@@ -171 +172 @@
         header->checksum = ICMP_CHECKSUM(header,
             packet_get_data_length(packet));
-        
-        rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos,
-            dont_fragment, 0);
-        if (rc != EOK)
-                return icmp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl,
+            tos, dont_fragment, 0))) {
+                return icmp_release_and_return(packet, ERROR_CODE);
+        }
 
         return ip_send_msg(icmp_globals.ip_phone, -1, packet, SERVICE_ICMP,
@@ -249 +249 @@
     const struct sockaddr * addr, socklen_t addrlen)
 {
+        ERROR_DECLARE;
+
         icmp_header_ref header;
         packet_t packet;
@@ -255 +257 @@
         icmp_reply_ref reply;
         int reply_key;
+        int result;
         int index;
-        int rc;
 
         if (addrlen <= 0)
@@ -263 +265 @@
         length = (size_t) addrlen;
         // TODO do not ask all the time
-        rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
-            &icmp_globals.packet_dimension);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(ip_packet_size_req(icmp_globals.ip_phone, -1,
+            &icmp_globals.packet_dimension));
 
         packet = packet_get_4_remote(icmp_globals.net_phone, size,
@@ -277 +277 @@
         // prepare the requesting packet
         // set the destination address
-        rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length);
-        if (rc != EOK)
-                return icmp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(packet_set_addr(packet, NULL, (const uint8_t *) addr,
+            length))) {
+                return icmp_release_and_return(packet, ERROR_CODE);
+        }
 
         // allocate space in the packet
@@ -328 +329 @@
         // wait for the reply
         // timeout in microseconds
-        rc = fibril_condvar_wait_timeout(&reply->condvar, &reply->mutex,
-            timeout * 1000);
-        if (rc == EOK)
-                rc = reply->result;
+        if (ERROR_OCCURRED(fibril_condvar_wait_timeout(&reply->condvar,
+            &reply->mutex, timeout * 1000))) {
+                result = ERROR_CODE;
+        } else {
+                // read the result
+                result = reply->result;
+        }
 
         // drop the reply mutex before locking the globals again
@@ -340 +344 @@
         icmp_replies_exclude_index(&icmp_globals.replies, index);
 
-        return rc;
+        return result;
 }
 
@@ -409 +413 @@
 int icmp_initialize(async_client_conn_t client_connection)
 {
+        ERROR_DECLARE;
+
         measured_string_t names[] = {
                 {
@@ -422 +428 @@
         size_t count = sizeof(names) / sizeof(measured_string_t);
         char *data;
-        int rc;
 
         fibril_rwlock_initialize(&icmp_globals.lock);
@@ -428 +433 @@
         icmp_replies_initialize(&icmp_globals.replies);
         icmp_echo_data_initialize(&icmp_globals.echo_data);
-        
         icmp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_ICMP,
             SERVICE_ICMP, client_connection);
-        if (icmp_globals.ip_phone < 0) {
-                fibril_rwlock_write_unlock(&icmp_globals.lock);
+        if (icmp_globals.ip_phone < 0)
                 return icmp_globals.ip_phone;
-        }
-        
-        rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
-            &icmp_globals.packet_dimension);
-        if (rc != EOK) {
-                fibril_rwlock_write_unlock(&icmp_globals.lock);
-                return rc;
-        }
-
+
+        ERROR_PROPAGATE(ip_packet_size_req(icmp_globals.ip_phone, -1,
+            &icmp_globals.packet_dimension));
         icmp_globals.packet_dimension.prefix += ICMP_HEADER_SIZE;
         icmp_globals.packet_dimension.content -= ICMP_HEADER_SIZE;
@@ -451 +448 @@
         // get configuration
         configuration = &names[0];
-        rc = net_get_conf_req(icmp_globals.net_phone, &configuration, count,
-            &data);
-        if (rc != EOK) {
-                fibril_rwlock_write_unlock(&icmp_globals.lock);
-                return rc;
-        }
-        
+        ERROR_PROPAGATE(net_get_conf_req(icmp_globals.net_phone, &configuration,
+            count, &data));
         if (configuration) {
                 if (configuration[0].value) {
@@ -527 +519 @@
 static int icmp_process_packet(packet_t packet, services_t error)
 {
+        ERROR_DECLARE;
+
         size_t length;
         uint8_t *src;
@@ -535 +529 @@
         icmp_type_t type;
         icmp_code_t code;
-        int rc;
 
         switch (error) {
@@ -548 +541 @@
                 length = (size_t) result;
                 // remove the error header
-                rc = packet_trim(packet, length, 0);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(packet_trim(packet, length, 0));
                 break;
         default:
@@ -558 +549 @@
         // get rid of the ip header
         length = ip_client_header_length(packet);
-        rc = packet_trim(packet, length, 0);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(packet_trim(packet, length, 0));
 
         length = packet_get_data_length(packet);
@@ -593 +582 @@
         switch (header->type) {
         case ICMP_ECHOREPLY:
-                if (error)
+                if (error) 
                         icmp_process_echo_reply(packet, header, type, code);
                 else
@@ -665 +654 @@
     services_t receiver, services_t error)
 {
-        int rc;
-
-        rc = icmp_process_packet(packet, error);
-        if (rc != EOK)
-                return icmp_release_and_return(packet, rc);
+        ERROR_DECLARE;
+
+        if (ERROR_OCCURRED(icmp_process_packet(packet, error)))
+                return icmp_release_and_return(packet, ERROR_CODE);
 
         return EOK;
@@ -694 +682 @@
 static int icmp_process_message(ipc_call_t *call)
 {
+        ERROR_DECLARE;
+
         packet_t packet;
-        int rc;
 
         switch (IPC_GET_METHOD(*call)) {
         case NET_ICMP_DEST_UNREACH:
-                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                return icmp_destination_unreachable_msg_local(0,
-                    ICMP_GET_CODE(call), ICMP_GET_MTU(call), packet);
+                if (ERROR_NONE(packet_translate_remote(icmp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        ERROR_CODE = icmp_destination_unreachable_msg_local(0,
+                            ICMP_GET_CODE(call), ICMP_GET_MTU(call), packet);
+                }
+                return ERROR_CODE;
         case NET_ICMP_SOURCE_QUENCH:
-                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                return icmp_source_quench_msg_local(0, packet);
+                if (ERROR_NONE(packet_translate_remote(icmp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        ERROR_CODE = icmp_source_quench_msg_local(0, packet);
+                }
+                return ERROR_CODE;
         case NET_ICMP_TIME_EXCEEDED:
-                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(call),
-                    packet);
+                if (ERROR_NONE(packet_translate_remote(icmp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        ERROR_CODE = icmp_time_exceeded_msg_local(0,
+                            ICMP_GET_CODE(call), packet);
+                }
+                return ERROR_CODE;
         case NET_ICMP_PARAMETERPROB:
-                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                return icmp_parameter_problem_msg_local(0, ICMP_GET_CODE(call),
-                    ICMP_GET_POINTER(call), packet);
+                if (ERROR_NONE(packet_translate_remote(icmp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        ERROR_CODE = icmp_parameter_problem_msg_local(0,
+                            ICMP_GET_CODE(call), ICMP_GET_POINTER(call),
+                            packet);
+                }
+                return ERROR_CODE;
         default:
                 return ENOTSUP;
@@ -767 +757 @@
                         break;
                 }
-        } while (icmp_echo_data_find(&icmp_globals.echo_data, index) != NULL);
+        } while(icmp_echo_data_find(&icmp_globals.echo_data, index) != NULL);
 
         echo_data->identifier = index;
@@ -789 +779 @@
 static int icmp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
 {
+        ERROR_DECLARE;
+
         bool keep_on_going = true;
         ipc_call_t answer;
@@ -796 +788 @@
         ipc_callid_t data_callid;
         icmp_echo_ref echo_data;
-        int rc = EOK;
+        int res;
 
         /*
@@ -802 +794 @@
          *  - Answer the first NET_ICMP_INIT call.
          */
+        res = EOK;
         answer_count = 0;
 
@@ -810 +803 @@
         // assign a new identifier
         fibril_rwlock_write_lock(&icmp_globals.lock);
-        rc = icmp_bind_free_id(echo_data);
+        res = icmp_bind_free_id(echo_data);
         fibril_rwlock_write_unlock(&icmp_globals.lock);
-        if (rc < 0) {
+        if (res < 0) {
                 free(echo_data);
-                return rc;
+                return res;
         }
 
         while (keep_on_going) {
                 // answer the call
-                answer_call(callid, rc, &answer, answer_count);
+                answer_call(callid, res, &answer, answer_count);
 
                 // refresh data
@@ -831 +824 @@
                 case IPC_M_PHONE_HUNGUP:
                         keep_on_going = false;
-                        rc = EHANGUP;
+                        res = EHANGUP;
                         break;
                 
                 case NET_ICMP_ECHO:
                         if (!async_data_write_receive(&data_callid, &length)) {
-                                rc = EINVAL;
+                                res = EINVAL;
                                 break;
                         }
@@ -842 +835 @@
                         addr = malloc(length);
                         if (!addr) {
-                                rc = ENOMEM;
+                                res = ENOMEM;
                                 break;
                         }
                         
-                        rc = async_data_write_finalize(data_callid, addr,
-                            length);
-                        if (rc != EOK) {
+                        if (ERROR_OCCURRED(async_data_write_finalize(
+                            data_callid, addr, length))) {
                                 free(addr);
+                                res = ERROR_CODE;
                                 break;
                         }
 
                         fibril_rwlock_write_lock(&icmp_globals.lock);
-                        rc = icmp_echo(echo_data->identifier,
+                        res = icmp_echo(echo_data->identifier,
                             echo_data->sequence_number, ICMP_GET_SIZE(call),
                             ICMP_GET_TIMEOUT(call), ICMP_GET_TTL(call),
@@ -871 +864 @@
 
                 default:
-                        rc = icmp_process_message(&call);
+                        res = icmp_process_message(&call);
                 }
 
@@ -881 +874 @@
         fibril_rwlock_write_unlock(&icmp_globals.lock);
 
-        return rc;
+        return res;
 }
 
@@ -901 +894 @@
     ipc_call_t *answer, int *answer_count)
 {
+        ERROR_DECLARE;
+
         packet_t packet;
-        int rc;
 
         *answer_count = 0;
         switch (IPC_GET_METHOD(*call)) {
         case NET_TL_RECEIVED:
-                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                return icmp_received_msg_local(IPC_GET_DEVICE(call), packet,
-                    SERVICE_ICMP, IPC_GET_ERROR(call));
+                if (ERROR_NONE(packet_translate_remote(icmp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        ERROR_CODE =
+                            icmp_received_msg_local(IPC_GET_DEVICE(call),
+                            packet, SERVICE_ICMP, IPC_GET_ERROR(call));
+                }
+                return ERROR_CODE;
         
         case NET_ICMP_INIT:
@@ -975 +970 @@
 int main(int argc, char *argv[])
 {
-        int rc;
+        ERROR_DECLARE;
         
         /* Start the module */
-        rc = tl_module_start_standalone(tl_client_connection);
-        return rc;
+        ERROR_PROPAGATE(tl_module_start_standalone(tl_client_connection));
+        return EOK;
 }
 

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

@@ -43 +43 @@
 #include <async.h>
 #include <stdio.h>
-#include <errno.h>
+#include <err.h>
 #include <ipc/ipc.h>
 #include <ipc/services.h>
@@ -58 +58 @@
 int tl_module_start_standalone(async_client_conn_t client_connection)
 {
+        ERROR_DECLARE;
+
         ipcarg_t phonehash;
-        int rc;
 
         async_set_client_connection(client_connection);
@@ -66 +67 @@
                 return icmp_globals.net_phone;
 
-        rc = pm_init();
-        if (rc != EOK)
-                return rc;
-        
-        rc = icmp_initialize(client_connection);
-        if (rc != EOK)
-                goto out;
-
-        rc = REGISTER_ME(SERVICE_ICMP, &phonehash);
-        if (rc != EOK)
-                goto out;
+        ERROR_PROPAGATE(pm_init());
+        if (ERROR_OCCURRED(icmp_initialize(client_connection)) ||
+            ERROR_OCCURRED(REGISTER_ME(SERVICE_ICMP, &phonehash))) {
+                pm_destroy();
+                return ERROR_CODE;
+        }
 
         async_manager();
 
-out:
         pm_destroy();
-        return rc;
+        return EOK;
 }
 
@@ -94 +89 @@
 /** @}
  */
+

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

@@ -47 +47 @@
 #include <stdio.h>
 #include <errno.h>
+#include <err.h>
 
 #include <ipc/ipc.h>
@@ -234 +235 @@
 int tcp_initialize(async_client_conn_t client_connection)
 {
-        int rc;
+        ERROR_DECLARE;
 
         assert(client_connection);
@@ -245 +246 @@
         tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
             SERVICE_TCP, client_connection);
-        if (tcp_globals.ip_phone < 0) {
-                fibril_rwlock_write_unlock(&tcp_globals.lock);
+        if (tcp_globals.ip_phone < 0)
                 return tcp_globals.ip_phone;
-        }
         
-        rc = socket_ports_initialize(&tcp_globals.sockets);
-        if (rc != EOK)
-                goto out;
-
-        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
-        if (rc != EOK) {
+        ERROR_PROPAGATE(socket_ports_initialize(&tcp_globals.sockets));
+        if (ERROR_OCCURRED(packet_dimensions_initialize(
+            &tcp_globals.dimensions))) {
                 socket_ports_destroy(&tcp_globals.sockets);
-                goto out;
+                return ERROR_CODE;
         }
 
         tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
-
-out:
         fibril_rwlock_write_unlock(&tcp_globals.lock);
-        return rc;
+
+        return EOK;
 }
 
@@ -271 +266 @@
     services_t error)
 {
-        int rc;
+        ERROR_DECLARE;
 
         if (receiver != SERVICE_TCP)
@@ -277 +272 @@
 
         fibril_rwlock_write_lock(&tcp_globals.lock);
-        rc = tcp_process_packet(device_id, packet, error);
-        if (rc != EOK)
+        if (ERROR_OCCURRED(tcp_process_packet(device_id, packet, error)))
                 fibril_rwlock_write_unlock(&tcp_globals.lock);
 
-        printf("receive %d \n", rc);
-
-        return rc;
+        printf("receive %d \n", ERROR_CODE);
+
+        return ERROR_CODE;
 }
 
 int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error)
 {
+        ERROR_DECLARE;
+
         size_t length;
         size_t offset;
@@ -303 +299 @@
         struct sockaddr *dest;
         size_t addrlen;
-        int rc;
 
         switch (error) {
@@ -316 +311 @@
 
                 length = (size_t) result;
-                rc = packet_trim(packet, length, 0);
-                if (rc != EOK)
-                        return tcp_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(packet_trim(packet, length, 0)))
+                        return tcp_release_and_return(packet, ERROR_CODE);
                 break;
         default:
@@ -339 +333 @@
 
         // trim all but TCP header
-        rc = packet_trim(packet, offset, 0);
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(packet_trim(packet, offset, 0)))
+                return tcp_release_and_return(packet, ERROR_CODE);
 
         // get tcp header
@@ -357 +350 @@
         addrlen = (size_t) result;
 
-        rc = tl_set_address_port(src, addrlen, ntohs(header->source_port));
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(tl_set_address_port(src, addrlen,
+            ntohs(header->source_port)))) 
+                return tcp_release_and_return(packet, ERROR_CODE);
         
         // find the destination socket
@@ -420 +413 @@
                 }
 
-                rc = ip_client_get_pseudo_header(IPPROTO_TCP, src, addrlen,
-                    dest, addrlen, total_length, &socket_data->pseudo_header,
-                    &socket_data->headerlen);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_TCP, src,
+                    addrlen, dest, addrlen, total_length,
+                    &socket_data->pseudo_header, &socket_data->headerlen))) {
                         fibril_rwlock_write_unlock(socket_data->local_lock);
-                        return tcp_release_and_return(packet, rc);
-                }
-        } else {
-                rc = ip_client_set_pseudo_header_data_length(
-                    socket_data->pseudo_header, socket_data->headerlen,
-                    total_length);
-                if (rc != EOK) {
-                        fibril_rwlock_write_unlock(socket_data->local_lock);
-                        return tcp_release_and_return(packet, rc);
-                }
+                        return tcp_release_and_return(packet, ERROR_CODE);
+                }
+
+        } else if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
+            socket_data->pseudo_header, socket_data->headerlen,
+            total_length))) {
+                fibril_rwlock_write_unlock(socket_data->local_lock);
+                return tcp_release_and_return(packet, ERROR_CODE);
         }
         
@@ -444 +434 @@
                 fibril_rwlock_write_unlock(socket_data->local_lock);
 
-                rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
-                    tcp_globals.icmp_phone, packet, error);
-                if (rc == EOK) {
+                if (ERROR_NONE(tl_prepare_icmp_packet(tcp_globals.net_phone,
+                    tcp_globals.icmp_phone, packet, error))) {
                         // checksum error ICMP
                         icmp_parameter_problem_msg(tcp_globals.icmp_phone,
@@ -463 +452 @@
         switch (socket_data->state) {
         case TCP_SOCKET_LISTEN:
-                rc = tcp_process_listen(socket, socket_data, header, packet,
-                    src, dest, addrlen);
+                ERROR_CODE = tcp_process_listen(socket, socket_data, header,
+                    packet, src, dest, addrlen);
                 break;
         case TCP_SOCKET_SYN_RECEIVED:
-                rc = tcp_process_syn_received(socket, socket_data, header,
-                    packet);
+                ERROR_CODE = tcp_process_syn_received(socket, socket_data,
+                    header, packet);
                 break;
         case TCP_SOCKET_SYN_SENT:
-                rc = tcp_process_syn_sent(socket, socket_data, header, packet);
+                ERROR_CODE = tcp_process_syn_sent(socket, socket_data, header,
+                    packet);
                 break;
         case TCP_SOCKET_FIN_WAIT_1:
@@ -482 +472 @@
                 // ack releasing the socket gets processed later
         case TCP_SOCKET_ESTABLISHED:
-                rc = tcp_process_established(socket, socket_data, header,
-                    packet, fragments, total_length);
+                ERROR_CODE = tcp_process_established(socket, socket_data,
+                    header, packet, fragments, total_length);
                 break;
         default:
@@ -489 +479 @@
         }
 
-        if (rc != EOK) {
+        if (ERROR_CODE != EOK) {
+                printf("process %d\n", ERROR_CODE);
                 fibril_rwlock_write_unlock(socket_data->local_lock);
-                printf("process %d\n", rc);
         }
 
@@ -501 +491 @@
     tcp_header_ref header, packet_t packet, int fragments, size_t total_length)
 {
+        ERROR_DECLARE;
+
         packet_t next_packet;
         packet_t tmp_packet;
@@ -509 +501 @@
         size_t offset;
         uint32_t new_sequence_number;
-        int rc;
 
         assert(socket);
@@ -550 +541 @@
                 }
 
-                if (offset > 0) {
-                        rc = packet_trim(packet, offset, 0);
-                        if (rc != EOK)
-                                return tcp_release_and_return(packet, rc);
-                }
+                if ((offset > 0) && (ERROR_OCCURRED(packet_trim(packet,
+                    offset, 0))))
+                        return tcp_release_and_return(packet, ERROR_CODE);
 
                 assert(new_sequence_number == socket_data->next_incoming);
@@ -586 +575 @@
                         if (length <= offset)
                                 next_packet = pq_next(next_packet);
-                        else {
-                                rc = packet_trim(next_packet, 0,
-                                    length - offset));
-                                if (rc != EOK)
-                                        return tcp_release_and_return(packet,
-                                            rc);
-                        }
+                        else if (ERROR_OCCURRED(packet_trim(next_packet, 0,
+                            length - offset)))
+                                return tcp_release_and_return(packet,
+                                    ERROR_CODE);
                         offset -= length;
                         total_length -= length - offset;
@@ -617 +603 @@
                 // remove the header
                 total_length -= TCP_HEADER_LENGTH(header);
-                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
-                if (rc != EOK)
-                        return tcp_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(packet_trim(packet,
+                    TCP_HEADER_LENGTH(header), 0)))
+                        return tcp_release_and_return(packet, ERROR_CODE);
 
                 if (total_length) {
-                        rc = tcp_queue_received_packet(socket, socket_data,
-                            packet, fragments, total_length);
-                        if (rc != EOK)
-                                return rc;
+                        ERROR_PROPAGATE(tcp_queue_received_packet(socket,
+                            socket_data, packet, fragments, total_length));
                 } else {
                         total_length = 1;
@@ -633 +617 @@
                 packet = socket_data->incoming;
                 while (packet) {
-                        rc = pq_get_order(socket_data->incoming, &order, NULL);
-                        if (rc != EOK) {
+
+                        if (ERROR_OCCURRED(pq_get_order(socket_data->incoming,
+                            &order, NULL))) {
                                 // remove the corrupted packet
                                 next_packet = pq_detach(packet);
@@ -671 +656 @@
                                     socket_data->next_incoming) {
                                         // queue received data
-                                        rc = tcp_queue_received_packet(socket,
+                                        ERROR_PROPAGATE(
+                                            tcp_queue_received_packet(socket,
                                             socket_data, packet, 1,
-                                            packet_get_data_length(packet));
-                                        if (rc != EOK)
-                                                return rc;
+                                            packet_get_data_length(packet)));
                                         socket_data->next_incoming =
                                             new_sequence_number;
@@ -693 +677 @@
                                                     new_sequence_number;
                                         }
-                                        rc = packet_trim(packet,length, 0);
-                                        if (rc == EOK) {
+                                        if (ERROR_NONE(packet_trim(packet,
+                                            length, 0))) {
                                                 // queue received data
-                                                rc = tcp_queue_received_packet(
+                                                ERROR_PROPAGATE(
+                                                    tcp_queue_received_packet(
                                                     socket, socket_data, packet,
                                                     1, packet_get_data_length(
-                                                    packet));
-                                                if (rc != EOK)
-                                                        return rc;
+                                                    packet)));
                                                 socket_data->next_incoming =
                                                     new_sequence_number;
@@ -726 +709 @@
                 // remove the header
                 total_length -= TCP_HEADER_LENGTH(header);
-                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
-                if (rc != EOK)
-                        return tcp_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(packet_trim(packet,
+                    TCP_HEADER_LENGTH(header), 0)))
+                        return tcp_release_and_return(packet, ERROR_CODE);
 
                 next_packet = pq_detach(packet);
                 length = packet_get_data_length(packet);
-                rc = pq_add(&socket_data->incoming, packet, new_sequence_number,
-                    length);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(pq_add(&socket_data->incoming, packet,
+                    new_sequence_number, length))) {
                         // remove the corrupted packets
                         pq_release_remote(tcp_globals.net_phone,
@@ -745 +727 @@
                                 tmp_packet = pq_detach(next_packet);
                                 length = packet_get_data_length(next_packet);
-
-                                rc = pq_set_order(next_packet,
-                                    new_sequence_number, length);
-                                if (rc != EOK) {
-                                        pq_release_remote(tcp_globals.net_phone,
-                                            packet_get_id(next_packet));
-                                }
-                                rc = pq_insert_after(packet, next_packet);
-                                if (rc != EOK) {
+                                if (ERROR_OCCURRED(pq_set_order(next_packet,
+                                    new_sequence_number, length)) ||
+                                    ERROR_OCCURRED(pq_insert_after(packet,
+                                    next_packet))) {
                                         pq_release_remote(tcp_globals.net_phone,
                                             packet_get_id(next_packet));
@@ -785 +762 @@
         if (!packet) {
                 // create the notification packet
-                rc = tcp_create_notification_packet(&packet, socket,
-                    socket_data, 0, 0);
-                if (rc != EOK)
-                        return rc;
-                rc = tcp_queue_prepare_packet(socket, socket_data, packet, 1);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
+                    socket_data, 0, 0));
+                ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data,
+                    packet, 1));
                 packet = tcp_send_prepare_packet(socket, socket_data, packet, 1,
                     socket_data->last_outgoing + 1);
@@ -809 +783 @@
     size_t total_length)
 {
+        ERROR_DECLARE;
+
         packet_dimension_ref packet_dimension;
-        int rc;
 
         assert(socket);
@@ -820 +795 @@
 
         // queue the received packet
-        rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
-            SOCKET_MAX_RECEIVED_SIZE);
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(dyn_fifo_push(&socket->received,
+            packet_get_id(packet), SOCKET_MAX_RECEIVED_SIZE)) ||
+            ERROR_OCCURRED(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+            &tcp_globals.dimensions, socket_data->device_id,
+            &packet_dimension))) {
+                return tcp_release_and_return(packet, ERROR_CODE);
+        }
 
         // decrease the window size
@@ -846 +820 @@
     tcp_header_ref header, packet_t packet)
 {
+        ERROR_DECLARE;
+
         packet_t next_packet;
-        int rc;
 
         assert(socket);
@@ -869 +844 @@
         }
         // trim if longer than the header
-        if (packet_get_data_length(packet) > sizeof(*header)) {
-                rc = packet_trim(packet, 0,
-                    packet_get_data_length(packet) - sizeof(*header));
-                if (rc != EOK)
-                        return tcp_release_and_return(packet, rc);
+        if ((packet_get_data_length(packet) > sizeof(*header)) &&
+            ERROR_OCCURRED(packet_trim(packet, 0,
+            packet_get_data_length(packet) - sizeof(*header)))) {
+                return tcp_release_and_return(packet, ERROR_CODE);
         }
         tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
@@ -902 +876 @@
     size_t addrlen)
 {
+        ERROR_DECLARE;
+
         packet_t next_packet;
         socket_core_ref socket;
@@ -908 +884 @@
         int listening_socket_id = listening_socket->socket_id;
         int listening_port = listening_socket->port;
-        int rc;
 
         assert(listening_socket);
@@ -938 +913 @@
         memcpy(socket_data->addr, src, socket_data->addrlen);
         socket_data->dest_port = ntohs(header->source_port);
-        rc = tl_set_address_port(socket_data->addr, socket_data->addrlen,
-            socket_data->dest_port);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(tl_set_address_port(socket_data->addr,
+            socket_data->addrlen, socket_data->dest_port))) {
                 free(socket_data->addr);
                 free(socket_data);
-                return tcp_release_and_return(packet, rc);
+                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+                return ERROR_CODE;
         }
 
         // create a socket
         socket_id = -1;
-        rc = socket_create(socket_data->local_sockets, listening_socket->phone,
-            socket_data, &socket_id);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(socket_create(socket_data->local_sockets,
+            listening_socket->phone, socket_data, &socket_id))) {
                 free(socket_data->addr);
                 free(socket_data);
-                return tcp_release_and_return(packet, rc);
+                return tcp_release_and_return(packet, ERROR_CODE);
         }
 
@@ -990 +964 @@
         assert(socket_data);
 
-        rc = socket_port_add(&tcp_globals.sockets, listening_port, socket,
-            (const char *) socket_data->addr, socket_data->addrlen);
+        ERROR_CODE = socket_port_add(&tcp_globals.sockets, listening_port,
+            socket, (const char *) socket_data->addr, socket_data->addrlen);
         assert(socket == socket_port_find(&tcp_globals.sockets, listening_port,
             (const char *) socket_data->addr, socket_data->addrlen));
 
-//      rc = socket_bind_free_port(&tcp_globals.sockets, socket,
+//      ERROR_CODE = socket_bind_free_port(&tcp_globals.sockets, socket,
 //          TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
 //          tcp_globals.last_used_port);
 //      tcp_globals.last_used_port = socket->port;
         fibril_rwlock_write_unlock(&tcp_globals.lock);
-        if (rc != EOK) {
+        if (ERROR_CODE != EOK) {
                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
                     socket_data->local_sockets, &tcp_globals.sockets,
                     tcp_free_socket_data);
-                return tcp_release_and_return(packet, rc);
+                return tcp_release_and_return(packet, ERROR_CODE);
         }
 
@@ -1018 +992 @@
 
         // trim if longer than the header
-        if (packet_get_data_length(packet) > sizeof(*header)) {
-                rc = packet_trim(packet, 0,
-                    packet_get_data_length(packet) - sizeof(*header));
-                if (rc != EOK) {
-                        socket_destroy(tcp_globals.net_phone, socket->socket_id,
-                            socket_data->local_sockets, &tcp_globals.sockets,
-                            tcp_free_socket_data);
-                        return tcp_release_and_return(packet, rc);
-                }
-        }
-
-        tcp_prepare_operation_header(socket, socket_data, header, 1, 0);
-
-        rc = tcp_queue_packet(socket, socket_data, packet, 1);
-        if (rc != EOK) {
+        if ((packet_get_data_length(packet) > sizeof(*header)) &&
+            ERROR_OCCURRED(packet_trim(packet, 0,
+            packet_get_data_length(packet) - sizeof(*header)))) {
                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
                     socket_data->local_sockets, &tcp_globals.sockets,
                     tcp_free_socket_data);
-                return rc;
+                return tcp_release_and_return(packet, ERROR_CODE);
+        }
+
+        tcp_prepare_operation_header(socket, socket_data, header, 1, 0);
+
+        if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1))) {
+                socket_destroy(tcp_globals.net_phone, socket->socket_id,
+                    socket_data->local_sockets, &tcp_globals.sockets,
+                    tcp_free_socket_data);
+                return ERROR_CODE;
         }
 
@@ -1060 +1031 @@
     tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet)
 {
+        ERROR_DECLARE;
+
         socket_core_ref listening_socket;
         tcp_socket_data_ref listening_socket_data;
-        int rc;
 
         assert(socket);
@@ -1087 +1059 @@
 
                 // queue the received packet
-                rc = dyn_fifo_push(&listening_socket->accepted,
-                    (-1 * socket->socket_id), listening_socket_data->backlog);
-                if (rc == EOK) {
+                if (ERROR_NONE(dyn_fifo_push(&listening_socket->accepted,
+                    (-1 * socket->socket_id),
+                    listening_socket_data->backlog))) {
+
                         // notify the destination socket
                         async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
@@ -1104 +1077 @@
 
         // create the notification packet
-        rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
+            socket_data, 0, 1));
 
         // send the packet
-        rc = tcp_queue_packet(socket, socket_data, packet, 1);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1));
 
         // flush packets
@@ -1228 +1198 @@
     ipc_call_t *answer, int *answer_count)
 {
+        ERROR_DECLARE;
+
         packet_t packet;
-        int rc;
 
         assert(call);
@@ -1238 +1209 @@
         switch (IPC_GET_METHOD(*call)) {
         case NET_TL_RECEIVED:
-//              fibril_rwlock_read_lock(&tcp_globals.lock);
-                rc = packet_translate_remote(tcp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK) {
-//                      fibril_rwlock_read_unlock(&tcp_globals.lock);
-                        return rc;
-                }
-                rc = tcp_received_msg(IPC_GET_DEVICE(call), packet, SERVICE_TCP,
-                    IPC_GET_ERROR(call));
-//              fibril_rwlock_read_unlock(&tcp_globals.lock);
-                return rc;
+                //fibril_rwlock_read_lock(&tcp_globals.lock);
+                if (ERROR_NONE(packet_translate_remote(tcp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        ERROR_CODE = tcp_received_msg(IPC_GET_DEVICE(call),
+                            packet, SERVICE_TCP, IPC_GET_ERROR(call));
+                }
+                //fibril_rwlock_read_unlock(&tcp_globals.lock);
+                return ERROR_CODE;
+
         case IPC_M_CONNECT_TO_ME:
                 return tcp_process_client_messages(callid, *call);
@@ -1693 +1662 @@
     struct sockaddr *addr, socklen_t addrlen)
 {
+        ERROR_DECLARE;
+
         socket_core_ref socket;
-        int rc;
 
         assert(local_sockets);
@@ -1705 +1675 @@
                 return ENOTSOCK;
         
-        rc = tcp_connect_core(socket, local_sockets, addr, addrlen);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(tcp_connect_core(socket, local_sockets, addr,
+            addrlen))) {
                 tcp_free_socket_data(socket);
                 // unbind if bound
@@ -1715 +1685 @@
                 }
         }
-        return rc;
+        return ERROR_CODE;
 }
 
@@ -1722 +1692 @@
     struct sockaddr *addr, socklen_t addrlen)
 {
+        ERROR_DECLARE;
+
         tcp_socket_data_ref socket_data;
         packet_t packet;
-        int rc;
 
         assert(socket);
@@ -1740 +1711 @@
 
         // get the destination port
-        rc = tl_get_address_port(addr, addrlen, &socket_data->dest_port);
-        if (rc != EOK)
-                return rc;
-        
+        ERROR_PROPAGATE(tl_get_address_port(addr, addrlen,
+            &socket_data->dest_port));
         if (socket->port <= 0) {
                 // try to find a free port
-                rc = socket_bind_free_port(&tcp_globals.sockets, socket,
-                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
-                    tcp_globals.last_used_port);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(socket_bind_free_port(&tcp_globals.sockets,
+                    socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
+                    tcp_globals.last_used_port));
                 // set the next port as the search starting port number
                 tcp_globals.last_used_port = socket->port;
         }
 
-        rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
+        ERROR_PROPAGATE(ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
             addr, addrlen, &socket_data->device_id,
-            &socket_data->pseudo_header, &socket_data->headerlen);
-        if (rc != EOK)
-                return rc;
+            &socket_data->pseudo_header, &socket_data->headerlen));
 
         // create the notification packet
-        rc = tcp_create_notification_packet(&packet, socket, socket_data, 1, 0);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
+            socket_data, 1, 0));
 
         // unlock the globals and wait for an operation
@@ -1772 +1736 @@
         socket_data->addrlen = addrlen;
         // send the packet
-
-        if (((rc = tcp_queue_packet(socket, socket_data, packet, 1)) != EOK) ||
-            ((rc = tcp_prepare_timeout(tcp_timeout, socket, socket_data, 0,
-            TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false)) !=
-            EOK)) {
+        if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1)) ||
+            ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data,
+            0, TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false))) {
                 socket_data->addr = NULL;
                 socket_data->addrlen = 0;
@@ -1792 +1754 @@
                         fibril_condvar_wait(&socket_data->operation.condvar,
                             &socket_data->operation.mutex);
-                        rc = socket_data->operation.result;
-                        if (rc != EOK) {
+                        ERROR_CODE = socket_data->operation.result;
+                        if (ERROR_CODE != EOK) {
                                 socket_data->addr = NULL;
                                 socket_data->addrlen = 0;
@@ -1800 +1762 @@
                         socket_data->addr = NULL;
                         socket_data->addrlen = 0;
-                        rc = EINTR;
+                        ERROR_CODE = EINTR;
                 }
         }
@@ -1807 +1769 @@
 
         // return the result
-        return rc;
+        return ERROR_CODE;
 }
 
@@ -1814 +1776 @@
     tcp_socket_data_ref socket_data, packet_t packet, size_t data_length)
 {
+        ERROR_DECLARE;
+
         tcp_header_ref header;
-        int rc;
 
         assert(socket);
@@ -1830 +1793 @@
         header->sequence_number = htonl(socket_data->next_outgoing);
 
-        rc = packet_set_addr(packet, NULL, (uint8_t *) socket_data->addr,
-            socket_data->addrlen);
-        if (rc != EOK)
+        if (ERROR_OCCURRED(packet_set_addr(packet, NULL,
+            (uint8_t *) socket_data->addr, socket_data->addrlen)))
                 return tcp_release_and_return(packet, EINVAL);
 
@@ -1846 +1808 @@
     packet_t packet, size_t data_length)
 {
-        int rc;
+        ERROR_DECLARE;
 
         assert(socket);
@@ -1852 +1814 @@
         assert(socket->specific_data == socket_data);
 
-        rc = tcp_queue_prepare_packet(socket, socket_data, packet, data_length);
-        if (rc != EOK)
-                return rc;
-
-        rc = pq_add(&socket_data->outgoing, packet, socket_data->next_outgoing,
-            data_length);
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
+        ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet,
+            data_length));
+
+        if (ERROR_OCCURRED(pq_add(&socket_data->outgoing, packet,
+            socket_data->next_outgoing, data_length)))
+                return tcp_release_and_return(packet, ERROR_CODE);
 
         socket_data->next_outgoing += data_length;
@@ -1868 +1828 @@
 tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data)
 {
+        ERROR_DECLARE;
+
         packet_t packet;
         packet_t copy;
@@ -1873 +1835 @@
         packet_t previous = NULL;
         size_t data_length;
-        int rc;
 
         assert(socket);
@@ -1898 +1859 @@
                 if (!sending) {
                         sending = copy;
-                } else {
-                        rc = pq_insert_after(previous, copy);
-                        if (rc != EOK) {
-                                pq_release_remote(tcp_globals.net_phone,
-                                    packet_get_id(copy));
-                                return sending;
-                        }
+                } else if (ERROR_OCCURRED(pq_insert_after(previous, copy))) {
+                        pq_release_remote(tcp_globals.net_phone,
+                            packet_get_id(copy));
+                        return sending;
                 }
 
@@ -1926 +1884 @@
     packet_t packet, size_t data_length, size_t sequence_number)
 {
+        ERROR_DECLARE;
+
         tcp_header_ref header;
         uint32_t checksum;
-        int rc;
 
         assert(socket);
@@ -1935 +1894 @@
 
         // adjust the pseudo header
-        rc = ip_client_set_pseudo_header_data_length(socket_data->pseudo_header,
-            socket_data->headerlen, packet_get_data_length(packet));
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
+            socket_data->pseudo_header, socket_data->headerlen,
+            packet_get_data_length(packet)))) {
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
                 return NULL;
@@ -1962 +1921 @@
         checksum = compute_checksum(0, socket_data->pseudo_header,
             socket_data->headerlen);
-        checksum = compute_checksum(checksum,
-            (uint8_t *) packet_get_data(packet),
+        checksum = compute_checksum(checksum, (uint8_t *) packet_get_data(packet),
             packet_get_data_length(packet));
         header->checksum = htons(flip_checksum(compact_checksum(checksum)));
 
         // prepare the packet
-        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
-        if (rc != EOK) {
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
-                return NULL;
-        }
-        rc = tcp_prepare_timeout(tcp_timeout, socket, socket_data,
-            sequence_number, socket_data->state, socket_data->timeout, true);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0,
+            0, 0)) || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket,
+            socket_data, sequence_number, socket_data->state,
+            socket_data->timeout, true))) {
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
                 return NULL;
@@ -2084 +2038 @@
     size_t *addrlen)
 {
+        ERROR_DECLARE;
+
         socket_core_ref socket;
         tcp_socket_data_ref socket_data;
@@ -2089 +2045 @@
         packet_t packet;
         size_t length;
-        int rc;
 
         assert(local_sockets);
@@ -2111 +2066 @@
         // send the source address if desired
         if (addrlen) {
-                rc = data_reply(socket_data->addr, socket_data->addrlen);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(data_reply(socket_data->addr,
+                    socket_data->addrlen));
                 *addrlen = socket_data->addrlen;
         }
@@ -2122 +2076 @@
                 return NO_DATA;
 
-        rc = packet_translate_remote(tcp_globals.net_phone, &packet, packet_id);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(packet_translate_remote(tcp_globals.net_phone, &packet,
+            packet_id));
 
         // reply the packets
-        rc = socket_reply_packets(packet, &length);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(socket_reply_packets(packet, &length));
 
         // release the packet
@@ -2142 +2093 @@
     size_t *data_fragment_size, int flags)
 {
+        ERROR_DECLARE;
+
         socket_core_ref socket;
         tcp_socket_data_ref socket_data;
@@ -2150 +2103 @@
         int index;
         int result;
-        int rc;
 
         assert(local_sockets);
@@ -2171 +2123 @@
                 return ENOTCONN;
 
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+           &tcp_globals.dimensions, socket_data->device_id, &packet_dimension));
 
         *data_fragment_size =
@@ -2195 +2145 @@
 
                 tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
-                rc = tcp_queue_packet(socket, socket_data, packet, 0);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet,
+                    0));
         }
 
@@ -2216 +2165 @@
 tcp_close_message(socket_cores_ref local_sockets, int socket_id)
 {
+        ERROR_DECLARE;
+
         socket_core_ref socket;
         tcp_socket_data_ref socket_data;
         packet_t packet;
-        int rc;
 
         // find the socket
@@ -2244 +2194 @@
         default:
                 // just destroy
-                rc = socket_destroy(tcp_globals.net_phone, socket_id,
+                if (ERROR_NONE(socket_destroy(tcp_globals.net_phone, socket_id,
                     local_sockets, &tcp_globals.sockets,
-                    tcp_free_socket_data);
-                if (rc == EOK) {
+                    tcp_free_socket_data))) {
                         fibril_rwlock_write_unlock(socket_data->local_lock);
                         fibril_rwlock_write_unlock(&tcp_globals.lock);
                 }
-                return rc;
+                return ERROR_CODE;
         }
 
@@ -2258 +2207 @@
 
         // create the notification packet
-        rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
+            socket_data, 0, 1));
 
         // send the packet
-        rc = tcp_queue_packet(socket, socket_data, packet, 1);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1));
 
         // flush packets
@@ -2284 +2230 @@
     tcp_socket_data_ref socket_data, int synchronize, int finalize)
 {
+        ERROR_DECLARE;
+
         packet_dimension_ref packet_dimension;
         tcp_header_ref header;
-        int rc;
 
         assert(packet);
 
         // get the device packet dimension
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+            &tcp_globals.dimensions, socket_data->device_id,
+            &packet_dimension));
 
         // get a new packet
@@ -2319 +2265 @@
     int new_socket_id, size_t *data_fragment_size, size_t *addrlen)
 {
+        ERROR_DECLARE;
+
         socket_core_ref accepted;
         socket_core_ref socket;
         tcp_socket_data_ref socket_data;
         packet_dimension_ref packet_dimension;
-        int rc;
 
         assert(local_sockets);
@@ -2357 +2304 @@
                 // TODO can it be in another state?
                 if (socket_data->state == TCP_SOCKET_ESTABLISHED) {
-                        rc = data_reply(socket_data->addr,
-                            socket_data->addrlen);
-                        if (rc != EOK)
-                                return rc;
-                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-                            &tcp_globals.dimensions, socket_data->device_id,
-                            &packet_dimension);
-                        if (rc != EOK)
-                                return rc;
+                        ERROR_PROPAGATE(data_reply(socket_data->addr,
+                            socket_data->addrlen));
+                        ERROR_PROPAGATE(tl_get_ip_packet_dimension(
+                            tcp_globals.ip_phone, &tcp_globals.dimensions,
+                            socket_data->device_id, &packet_dimension));
                         *addrlen = socket_data->addrlen;
 
@@ -2375 +2318 @@
         
                         if (new_socket_id > 0) {
-                                rc = socket_cores_update(local_sockets,
-                                    accepted->socket_id, new_socket_id);
-                                if (rc != EOK)
-                                        return rc;
+                                ERROR_PROPAGATE(socket_cores_update(
+                                    local_sockets, accepted->socket_id,
+                                    new_socket_id));
                                 accepted->socket_id = new_socket_id;
                         }
@@ -2488 +2430 @@
 main(int argc, char *argv[])
 {
-        int rc;
-
-        rc = tl_module_start_standalone(tl_client_connection);
-        return rc;
+        ERROR_DECLARE;
+
+        /*
+           Start the module 
+         */
+        if (ERROR_OCCURRED(tl_module_start_standalone(tl_client_connection)))
+                return ERROR_CODE;
+
+        return EOK;
 }
 

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

@@ -44 +44 @@
 #include <async.h>
 #include <stdio.h>
-#include <errno.h>
+#include <err.h>
 #include <ipc/ipc.h>
 #include <ipc/services.h>
@@ -61 +61 @@
 int tl_module_start_standalone(async_client_conn_t client_connection)
 {
-        ipcarg_t phonehash;
-        int rc;
-
+        ERROR_DECLARE;
+        
         async_set_client_connection(client_connection);
         tcp_globals.net_phone = net_connect_module();
-
-        rc = pm_init();
-        if (rc != EOK)
-                return rc;
-
-        rc = tcp_initialize(client_connection);
-        if (rc != EOK)
-                goto out;
-
-        rc = REGISTER_ME(SERVICE_TCP, &phonehash);
-        if (rc != EOK)
-                goto out;
+        ERROR_PROPAGATE(pm_init());
+        
+        ipcarg_t phonehash;
+        if (ERROR_OCCURRED(tcp_initialize(client_connection)) ||
+            ERROR_OCCURRED(REGISTER_ME(SERVICE_TCP, &phonehash))) {
+                pm_destroy();
+                return ERROR_CODE;
+        }
         
         async_manager();
         
-out:
         pm_destroy();
-        return rc;
+        return EOK;
 }
 

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

@@ -51 +51 @@
 #include <adt/dynamic_fifo.h>
 #include <errno.h>
+#include <err.h>
 
 #include <net/socket_codes.h>
@@ -102 +103 @@
 int udp_initialize(async_client_conn_t client_connection)
 {
+        ERROR_DECLARE;
+
         measured_string_t names[] = {
                 {
@@ -115 +118 @@
         size_t count = sizeof(names) / sizeof(measured_string_t);
         char *data;
-        int rc;
 
         fibril_rwlock_initialize(&udp_globals.lock);
@@ -122 +124 @@
         udp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP,
             ICMP_CONNECT_TIMEOUT);
-        
         udp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
             SERVICE_UDP, client_connection);
-        if (udp_globals.ip_phone < 0) {
-                fibril_rwlock_write_unlock(&udp_globals.lock);
+        if (udp_globals.ip_phone < 0)
                 return udp_globals.ip_phone;
-        }
 
         // read default packet dimensions
-        rc = ip_packet_size_req(udp_globals.ip_phone, -1,
-            &udp_globals.packet_dimension);
-        if (rc != EOK) {
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return rc;
-        }
-        
-        rc = socket_ports_initialize(&udp_globals.sockets);
-        if (rc != EOK) {
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return rc;
-        }
-        
-        rc = packet_dimensions_initialize(&udp_globals.dimensions);
-        if (rc != EOK) {
+        ERROR_PROPAGATE(ip_packet_size_req(udp_globals.ip_phone, -1,
+            &udp_globals.packet_dimension));
+        ERROR_PROPAGATE(socket_ports_initialize(&udp_globals.sockets));
+        if (ERROR_OCCURRED(packet_dimensions_initialize(
+            &udp_globals.dimensions))) {
                 socket_ports_destroy(&udp_globals.sockets);
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return rc;
-        }
-        
+                return ERROR_CODE;
+        }
         udp_globals.packet_dimension.prefix += sizeof(udp_header_t);
         udp_globals.packet_dimension.content -= sizeof(udp_header_t);
@@ -160 +147 @@
         // get configuration
         configuration = &names[0];
-        rc = net_get_conf_req(udp_globals.net_phone, &configuration, count,
-            &data);
-        if (rc != EOK) {
-                socket_ports_destroy(&udp_globals.sockets);
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return rc;
-        }
-        
+        ERROR_PROPAGATE(net_get_conf_req(udp_globals.net_phone, &configuration,
+            count, &data));
         if (configuration) {
                 if (configuration[0].value)
@@ -220 +201 @@
 udp_process_packet(device_id_t device_id, packet_t packet, services_t error)
 {
+        ERROR_DECLARE;
+
         size_t length;
         size_t offset;
@@ -236 +219 @@
         struct sockaddr *dest;
         packet_dimension_ref packet_dimension;
-        int rc;
 
         switch (error) {
@@ -250 +232 @@
                         return udp_release_and_return(packet, result);
                 length = (size_t) result;
-                rc = packet_trim(packet, length, 0);
-                if (rc != EOK)
-                        return udp_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(packet_trim(packet, length, 0)))
+                        return udp_release_and_return(packet,
+                            ERROR_CODE);
                 break;
         default:
@@ -271 +253 @@
 
         // trim all but UDP header
-        rc = packet_trim(packet, offset, 0);
-        if (rc != EOK)
-                return udp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(packet_trim(packet, offset, 0)))
+                return udp_release_and_return(packet, ERROR_CODE);
 
         // get udp header
@@ -303 +284 @@
                 if (result <= 0)
                         return udp_release_and_return(packet, result);
-                
-                rc = ip_client_get_pseudo_header(IPPROTO_UDP, src, result, dest,
-                    result, total_length, &ip_header, &length);
-                if (rc != EOK) {
-                        return udp_release_and_return(packet, rc);
+
+                if (ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_UDP,
+                    src, result, dest, result, total_length, &ip_header,
+                    &length))) {
+                        return udp_release_and_return(packet, ERROR_CODE);
                 } else {
                         checksum = compute_checksum(0, ip_header, length);
@@ -326 +307 @@
 
                 if (total_length < length) {
-                        rc = packet_trim(next_packet, 0, length - total_length);
-                        if (rc != EOK)
-                                return udp_release_and_return(packet, rc);
+                        if (ERROR_OCCURRED(packet_trim(next_packet, 0,
+                            length - total_length))) {
+                                return udp_release_and_return(packet,
+                                    ERROR_CODE);
+                        }
 
                         // add partial checksum if set
@@ -377 +360 @@
 
         // queue the received packet
-        rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
-            SOCKET_MAX_RECEIVED_SIZE);
-        if (rc != EOK)
-                return udp_release_and_return(packet, rc);
-                
-        rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
-            &udp_globals.dimensions, device_id, &packet_dimension);
-        if (rc != EOK)
-                return udp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(dyn_fifo_push(&socket->received,
+            packet_get_id(packet), SOCKET_MAX_RECEIVED_SIZE)) ||
+            ERROR_OCCURRED(tl_get_ip_packet_dimension(udp_globals.ip_phone,
+            &udp_globals.dimensions, device_id, &packet_dimension))) {
+                return udp_release_and_return(packet, ERROR_CODE);
+        }
 
         // notify the destination socket
@@ -456 +436 @@
     size_t *data_fragment_size, int flags)
 {
+        ERROR_DECLARE;
+
         socket_core_ref socket;
         packet_t packet;
@@ -469 +451 @@
         device_id_t device_id;
         packet_dimension_ref packet_dimension;
-        int rc;
-        
-        rc = tl_get_address_port(addr, addrlen, &dest_port);
-        if (rc != EOK)
-                return rc;
+
+        ERROR_PROPAGATE(tl_get_address_port(addr, addrlen, &dest_port));
 
         socket = socket_cores_find(local_sockets, socket_id);
@@ -481 +460 @@
         if ((socket->port <= 0) && udp_globals.autobinding) {
                 // bind the socket to a random free port if not bound
-                rc = socket_bind_free_port(&udp_globals.sockets, socket,
-                    UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
-                    udp_globals.last_used_port);
-                if (rc != EOK)
-                        return rc;
-                // set the next port as the search starting port number
-                udp_globals.last_used_port = socket->port;
+//              do {
+                        // try to find a free port
+//                      fibril_rwlock_read_unlock(&udp_globals.lock);
+//                      fibril_rwlock_write_lock(&udp_globals.lock);
+                        // might be changed in the meantime
+//                      if (socket->port <= 0) {
+                                if (ERROR_OCCURRED(socket_bind_free_port(
+                                    &udp_globals.sockets, socket,
+                                    UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
+                                    udp_globals.last_used_port))) {
+//                                      fibril_rwlock_write_unlock(
+//                                          &udp_globals.lock);
+//                                      fibril_rwlock_read_lock(
+//                                          &udp_globals.lock);
+                                        return ERROR_CODE;
+                                }
+                                // set the next port as the search starting port
+                                // number
+                                udp_globals.last_used_port = socket->port;
+//                      }
+//                      fibril_rwlock_write_unlock(&udp_globals.lock);
+//                      fibril_rwlock_read_lock(&udp_globals.lock);
+                        // might be changed in the meantime
+//              } while (socket->port <= 0);
         }
 
         if (udp_globals.checksum_computing) {
-                rc = ip_get_route_req(udp_globals.ip_phone, IPPROTO_UDP, addr,
-                    addrlen, &device_id, &ip_header, &headerlen);
-                if (rc != EOK)
-                        return rc;
+                if (ERROR_OCCURRED(ip_get_route_req(udp_globals.ip_phone,
+                    IPPROTO_UDP, addr, addrlen, &device_id, &ip_header,
+                    &headerlen))) {
+                        return udp_release_and_return(packet, ERROR_CODE);
+                }
                 // get the device packet dimension
-//              rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
-//                  &udp_globals.dimensions, device_id, &packet_dimension);
-//              if (rc != EOK)
-//                      return rc;
+//              ERROR_PROPAGATE(tl_get_ip_packet_dimension(udp_globals.ip_phone,
+//                  &udp_globals.dimensions, device_id, &packet_dimension));
         }
 //      } else {
                 // do not ask all the time
-                rc = ip_packet_size_req(udp_globals.ip_phone, -1,
-                    &udp_globals.packet_dimension);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(ip_packet_size_req(udp_globals.ip_phone, -1,
+                    &udp_globals.packet_dimension));
                 packet_dimension = &udp_globals.packet_dimension;
 //      }
@@ -536 +529 @@
                         return udp_release_and_return(packet, result);
 
-                rc = pq_add(&packet, next_packet, index, 0);
-                if (rc != EOK)
-                        return udp_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(pq_add(&packet, next_packet, index, 0)))
+                        return udp_release_and_return(packet, ERROR_CODE);
 
                 total_length += (size_t) result;
@@ -555 +547 @@
         if (udp_globals.checksum_computing) {
                 // update the pseudo header
-                rc = ip_client_set_pseudo_header_data_length(ip_header,
-                    headerlen, total_length + UDP_HEADER_SIZE);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
+                    ip_header, headerlen, total_length + UDP_HEADER_SIZE))) {
                         free(ip_header);
-                        return udp_release_and_return(packet, rc);
+                        return udp_release_and_return(packet, ERROR_CODE);
                 }
 
@@ -574 +565 @@
 
         // prepare the first packet fragment
-        rc = ip_client_prepare_packet(packet, IPPROTO_UDP, 0, 0, 0, 0);
-        if (rc != EOK)
-                return udp_release_and_return(packet, rc);
-
-        /* Release the UDP global lock on success. */
+        if (ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_UDP, 0, 0,
+            0, 0))) {
+                return udp_release_and_return(packet, ERROR_CODE);
+        }
+
+        // send the packet
         fibril_rwlock_write_unlock(&udp_globals.lock);
-
-        // send the packet
         ip_send_msg(udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0);
 
@@ -610 +600 @@
     size_t *addrlen)
 {
+        ERROR_DECLARE;
+
         socket_core_ref socket;
         int packet_id;
@@ -618 +610 @@
         uint8_t *data;
         int result;
-        int rc;
 
         // find the socket
@@ -629 +620 @@
         if (packet_id < 0)
                 return NO_DATA;
-        
-        rc = packet_translate_remote(udp_globals.net_phone, &packet, packet_id);
-        if (rc != EOK) {
-                (void) dyn_fifo_pop(&socket->received);
-                return rc;
-        }
+
+        ERROR_PROPAGATE(packet_translate_remote(udp_globals.net_phone, &packet,
+            packet_id));
 
         // get udp header
         data = packet_get_data(packet);
         if (!data) {
-                (void) dyn_fifo_pop(&socket->received);
-                return udp_release_and_return(packet, NO_DATA);
+                pq_release_remote(udp_globals.net_phone, packet_id);
+                return NO_DATA;
         }
         header = (udp_header_ref) data;
@@ -646 +634 @@
         // set the source address port
         result = packet_get_addr(packet, (uint8_t **) &addr, NULL);
-        rc = tl_set_address_port(addr, result, ntohs(header->source_port));
-        if (rc != EOK) {
-                (void) dyn_fifo_pop(&socket->received);
-                return udp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(tl_set_address_port(addr, result,
+            ntohs(header->source_port)))) {
+                pq_release_remote(udp_globals.net_phone, packet_id);
+                return ERROR_CODE;
         }
         *addrlen = (size_t) result;
 
         // send the source address
-        rc = data_reply(addr, *addrlen);
-        switch (rc) {
-        case EOK:
-                break;
-        case EOVERFLOW:
-                return rc;
-        default:
-                (void) dyn_fifo_pop(&socket->received);
-                return udp_release_and_return(packet, rc);
-        }
+        ERROR_PROPAGATE(data_reply(addr, *addrlen));
 
         // trim the header
-        rc = packet_trim(packet, UDP_HEADER_SIZE, 0);
-        if (rc != EOK) {
-                (void) dyn_fifo_pop(&socket->received);
-                return udp_release_and_return(packet, rc);
-        }
+        ERROR_PROPAGATE(packet_trim(packet, UDP_HEADER_SIZE, 0));
 
         // reply the packets
-        rc = socket_reply_packets(packet, &length);
-        switch (rc) {
-        case EOK:
-                break;
-        case EOVERFLOW:
-                return rc;
-        default:
-                (void) dyn_fifo_pop(&socket->received);
-                return udp_release_and_return(packet, rc);
-        }
-
-        (void) dyn_fifo_pop(&socket->received);
-
-        // release the packet and return the total length
-        return udp_release_and_return(packet, (int) length);
+        ERROR_PROPAGATE(socket_reply_packets(packet, &length));
+
+        // release the packet
+        dyn_fifo_pop(&socket->received);
+        pq_release_remote(udp_globals.net_phone, packet_get_id(packet));
+
+        // return the total length
+        return (int) length;
 }
 
@@ -858 +826 @@
     ipc_call_t *answer, int *answer_count)
 {
+        ERROR_DECLARE;
+
         packet_t packet;
-        int rc;
 
         *answer_count = 0;
@@ -865 +834 @@
         switch (IPC_GET_METHOD(*call)) {
         case NET_TL_RECEIVED:
-                rc = packet_translate_remote(udp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                return udp_received_msg(IPC_GET_DEVICE(call), packet,
-                    SERVICE_UDP, IPC_GET_ERROR(call));
+                if (ERROR_NONE(packet_translate_remote(udp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        ERROR_CODE = udp_received_msg(IPC_GET_DEVICE(call),
+                            packet, SERVICE_UDP, IPC_GET_ERROR(call));
+                }
+                return ERROR_CODE;
+        
         case IPC_M_CONNECT_TO_ME:
                 return udp_process_client_messages(callid, * call);
@@ -880 +850 @@
 /** Default thread for new connections.
  *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
+ *  @param[in] iid      The initial message identifier.
+ *  @param[in] icall    The initial message call structure.
+ *
  */
 static void tl_client_connection(ipc_callid_t iid, ipc_call_t * icall)
@@ -927 +898 @@
 int main(int argc, char *argv[])
 {
-        int rc;
+        ERROR_DECLARE;
         
         /* Start the module */
-        rc = tl_module_start_standalone(tl_client_connection);
-        return rc;
+        if (ERROR_OCCURRED(tl_module_start_standalone(tl_client_connection)))
+                return ERROR_CODE;
+        
+        return EOK;
 }
 

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

@@ -44 +44 @@
 #include <async.h>
 #include <stdio.h>
-#include <errno.h>
+#include <err.h>
 #include <ipc/ipc.h>
 #include <ipc/services.h>
@@ -59 +59 @@
 int tl_module_start_standalone(async_client_conn_t client_connection)
 {
+        ERROR_DECLARE;
+
         ipcarg_t phonehash;
-        int rc;
 
         async_set_client_connection(client_connection);
@@ -66 +67 @@
         if (udp_globals.net_phone < 0)
                 return udp_globals.net_phone;
-        
-        rc = pm_init();
-        if (rc != EOK)
-                return EOK;
-                
-        rc = udp_initialize(client_connection);
-        if (rc != EOK)
-                goto out;
-        
-        rc = REGISTER_ME(SERVICE_UDP, &phonehash);
-        if (rc != EOK)
-                goto out;
+
+        ERROR_PROPAGATE(pm_init());
+        if (ERROR_OCCURRED(udp_initialize(client_connection)) ||
+            ERROR_OCCURRED(REGISTER_ME(SERVICE_UDP, &phonehash))) {
+                pm_destroy();
+                return ERROR_CODE;
+        }
 
         async_manager();
 
-out:
         pm_destroy();
-        return rc;
+        return EOK;
 }