Changeset 3090715 in mainline

Timestamp:

2010-11-07T21:16:56Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

1d0d06a

Parents:

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

Message:

Merge from lp:~jakub/helenos/net/.

Location:

uspace

Files:

• lib/c/generic/adt/measured_strings.c (modified) (14 diffs)
• lib/c/include/adt/generic_char_map.h (modified) (4 diffs)
• lib/c/include/err.h (modified) (2 diffs)
• lib/net/adt/module_map.c (modified) (3 diffs)
• lib/net/generic/packet_remote.c (modified) (7 diffs)
• lib/net/netif/netif_local.c (modified) (15 diffs)
• lib/net/tl/socket_core.c (modified) (13 diffs)
• lib/net/tl/tl_common.c (modified) (5 diffs)
• lib/packet/generic/packet_server.c (modified) (3 diffs)
• srv/hw/netif/dp8390/dp8390_module.c (modified) (8 diffs)

uspace/lib/c/generic/adt/measured_strings.c

@@ -41 +41 @@
 #include <unistd.h>
 #include <errno.h>
-#include <err.h>
 #include <async.h>
 
@@ -135 +134 @@
     size_t count)
 {
-        ERROR_DECLARE;
-
         size_t *lengths;
         size_t index;
@@ -142 +139 @@
         char *next;
         ipc_callid_t callid;
+        int rc;
 
         if ((!strings) || (!data) || (count <= 0))
@@ -155 +153 @@
                 return EINVAL;
         }
-        if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
-            length))) {
-                free(lengths);
-                return ERROR_CODE;
+        rc = async_data_write_finalize(callid, lengths, length);
+        if (rc != EOK) {
+                free(lengths);
+                return rc;
         }
 
@@ -187 +185 @@
                                 return EINVAL;
                         }
-                        if (ERROR_OCCURRED(async_data_write_finalize(callid,
-                            next, lengths[index]))) {
+                        rc = async_data_write_finalize(callid, next,
+                            lengths[index]);
+                        if (rc != EOK) {
                                 free(*data);
                                 free(*strings);
                                 free(lengths);
-                                return ERROR_CODE;
+                                return rc;
                         }
                         (*strings)[index].value = next;
@@ -251 +250 @@
 int measured_strings_reply(const measured_string_ref strings, size_t count)
 {
-        ERROR_DECLARE;
-
         size_t *lengths;
         size_t index;
         size_t length;
         ipc_callid_t callid;
+        int rc;
 
         if ((!strings) || (count <= 0))
@@ -270 +268 @@
                 return EINVAL;
         }
-        if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) {
-                free(lengths);
-                return ERROR_CODE;
+        rc = async_data_read_finalize(callid, lengths, length);
+        if (rc != EOK) {
+                free(lengths);
+                return rc;
         }
         free(lengths);
@@ -282 +281 @@
                                 return EINVAL;
                         }
-                        ERROR_PROPAGATE(async_data_read_finalize(callid,
-                            strings[index].value, strings[index].length));
+                        rc = async_data_read_finalize(callid,
+                            strings[index].value, strings[index].length);
+                        if (rc != EOK)
+                                return rc;
                 }
         }
@@ -313 +314 @@
     size_t count)
 {
-        ERROR_DECLARE;
-
         size_t *lengths;
         size_t index;
         char *next;
+        int rc;
 
         if ((phone < 0) || (!strings) || (!data) || (count <= 0))
@@ -326 +326 @@
                 return ENOMEM;
 
-        if (ERROR_OCCURRED(async_data_read_start(phone, lengths,
-            sizeof(size_t) * (count + 1)))) {
-                free(lengths);
-                return ERROR_CODE;
+        rc = async_data_read_start(phone, lengths,
+            sizeof(size_t) * (count + 1));
+        if (rc != EOK) {
+                free(lengths);
+                return rc;
         }
 
@@ -350 +351 @@
                 (*strings)[index].length = lengths[index];
                 if (lengths[index] > 0) {
-                        if (ERROR_OCCURRED(async_data_read_start(phone, next,
-                            lengths[index]))) {
+                        rc = async_data_read_start(phone, next, lengths[index]);
+                        if (rc != EOK) {
                                 free(lengths);
                                 free(data);
                                 free(strings);
-                                return ERROR_CODE;
+                                return rc;
                         }
                         (*strings)[index].value = next;
@@ -387 +388 @@
     size_t count)
 {
-        ERROR_DECLARE;
-
         size_t *lengths;
         size_t index;
+        int rc;
 
         if ((phone < 0) || (!strings) || (count <= 0))
@@ -399 +399 @@
                 return ENOMEM;
 
-        if (ERROR_OCCURRED(async_data_write_start(phone, lengths,
-            sizeof(size_t) * (count + 1)))) {
-                free(lengths);
-                return ERROR_CODE;
+        rc = async_data_write_start(phone, lengths,
+            sizeof(size_t) * (count + 1));
+        if (rc != EOK) {
+                free(lengths);
+                return rc;
         }
 
@@ -409 +410 @@
         for (index = 0; index < count; index++) {
                 if (strings[index].length > 0) {
-                        ERROR_PROPAGATE(async_data_write_start(phone,
-                            strings[index].value, strings[index].length));
+                        rc = async_data_write_start(phone, strings[index].value,
+                            strings[index].length);
+                        if (rc != EOK)
+                                return rc;
                 }
         }

uspace/lib/c/include/adt/generic_char_map.h

@@ -40 +40 @@
 #include <unistd.h>
 #include <errno.h>
-#include <err.h>
 
 #include <adt/char_map.h>
@@ -85 +84 @@
              type *value) \
         { \
-                ERROR_DECLARE; \
+                int rc; \
                 int index; \
                 if (!name##_is_valid(map)) \
@@ -92 +91 @@
                 if (index < 0) \
                         return index; \
-                if (ERROR_OCCURRED(char_map_add(&map->names, name, length, \
-                    index))) { \
+                rc = char_map_add(&map->names, name, length, index); \
+                if (rc != EOK) { \
                         name##_items_exclude_index(&map->values, index); \
-                        return ERROR_CODE; \
+                        return rc; \
                 } \
                 return EOK; \
@@ -141 +140 @@
         int name##_initialize(name##_ref map) \
         { \
-                ERROR_DECLARE; \
+                int rc; \
                 if (!map) \
                         return EINVAL; \
-                ERROR_PROPAGATE(char_map_initialize(&map->names)); \
-                if (ERROR_OCCURRED(name##_items_initialize(&map->values))) { \
+                rc = char_map_initialize(&map->names); \
+                if (rc != EOK) \
+                        return rc; \
+                rc = name##_items_initialize(&map->values); \
+                if (rc != EOK) { \
                         char_map_destroy(&map->names); \
-                        return ERROR_CODE; \
+                        return rc; \
                 } \
                 map->magic = GENERIC_CHAR_MAP_MAGIC_VALUE; \

uspace/lib/c/include/err.h

@@ -37 +37 @@
 
 #include <stdio.h>
-#include <errno.h>
-
-#ifdef CONFIG_DEBUG
-#include <str_error.h>
-#endif
 
 #define errx(status, fmt, ...) { \
@@ -48 +43 @@
 }
 
-
-/** An actual stored error code.  */
-#define ERROR_CODE  error_check_return_value
-
-/** An error processing routines declaration.
- *
- * This has to be declared in the block where the error processing
- * is desired.
- */
-#define ERROR_DECLARE  int ERROR_CODE
-
-/** Store the value as an error code and checks if an error occurred.
- *
- * @param[in] value     The value to be checked. May be a function call.
- * @return              False if the value indicates success (EOK).
- * @return              True otherwise.
- */
-#ifdef CONFIG_DEBUG
-
-#define ERROR_OCCURRED(value) \
-        (((ERROR_CODE = (value)) != EOK) && \
-        ({ \
-                fprintf(stderr, "libsocket error at %s:%d (%s)\n", \
-                __FILE__, __LINE__, str_error(ERROR_CODE)); \
-                1; \
-        }))
-
-#else
-
-#define ERROR_OCCURRED(value)   ((ERROR_CODE = (value)) != EOK)
-
-#endif
-
-#define ERROR_NONE(value)       !ERROR_OCCURRED((value))
-
-/** Error propagation
- *
- * Check if an error occurred and immediately exit the actual
- * function returning the error code.
- *
- * @param[in] value     The value to be checked. May be a function call.
- *
- */
-
-#define ERROR_PROPAGATE(value) \
-        if (ERROR_OCCURRED(value)) \
-                return ERROR_CODE
-
 #endif
 
 /** @}
  */
+

uspace/lib/net/adt/module_map.c

@@ -38 +38 @@
 #include <task.h>
 #include <unistd.h>
-#include <err.h>
+#include <errno.h>
 
 #include <ipc/services.h>
@@ -67 +67 @@
     connect_module_t connect_module)
 {
-        ERROR_DECLARE;
-
         module_ref tmp_module;
+        int rc;
 
         tmp_module = (module_ref) malloc(sizeof(module_t));
@@ -83 +82 @@
         tmp_module->connect_module = connect_module;
 
-        if (ERROR_OCCURRED(modules_add(modules, tmp_module->name, 0,
-            tmp_module))) {
+        rc = modules_add(modules, tmp_module->name, 0, tmp_module);
+        if (rc != EOK) {
                 free(tmp_module);
-                return ERROR_CODE;
+                return rc;
         }
         if (module)

uspace/lib/net/generic/packet_remote.c

@@ -38 +38 @@
 #include <async.h>
 #include <errno.h>
-#include <err.h>
 #include <ipc/ipc.h>
 #include <ipc/packet.h>
@@ -67 +66 @@
 packet_return(int phone, packet_ref packet, packet_id_t packet_id, size_t size)
 {
-        ERROR_DECLARE;
-        
         ipc_call_t answer;
-        aid_t message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
+        aid_t message;
+        int rc;
+        
+        message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
 
         *packet = (packet_t) as_get_mappable_page(size);
-        if (ERROR_OCCURRED(async_share_in_start_0_0(phone, *packet, size)) ||
-            ERROR_OCCURRED(pm_add(*packet))) {
+        rc = async_share_in_start_0_0(phone, *packet, size);
+        if (rc != EOK) {
                 munmap(*packet, size);
                 async_wait_for(message, NULL);
-                return ERROR_CODE;
+                return rc;
+        }
+        rc = pm_add(*packet);
+        if (rc != EOK) {
+                munmap(*packet, size);
+                async_wait_for(message, NULL);
+                return rc;
         }
         
@@ -103 +109 @@
 int packet_translate_remote(int phone, packet_ref packet, packet_id_t packet_id)
 {
-        ERROR_DECLARE;
+        int rc;
         
         if (!packet)
@@ -112 +118 @@
                 ipcarg_t size;
                 
-                ERROR_PROPAGATE(async_req_1_1(phone, NET_PACKET_GET_SIZE,
-                    packet_id, &size));
-                ERROR_PROPAGATE(packet_return(phone, packet, packet_id, size));
+                rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
+                    &size);
+                if (rc != EOK)
+                        return rc;
+                rc = packet_return(phone, packet, packet_id, size);
+                if (rc != EOK)
+                        return rc;
         }
         if ((*packet)->next) {
@@ -141 +151 @@
     size_t max_prefix, size_t max_suffix)
 {
-        ERROR_DECLARE;
-        
         ipcarg_t packet_id;
         ipcarg_t size;
-        
-        if (ERROR_OCCURRED(async_req_4_2(phone, NET_PACKET_CREATE_4,
-            max_content, addr_len, max_prefix, max_suffix, &packet_id, &size)))
+        int rc;
+        
+        rc = async_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
+            max_prefix, max_suffix, &packet_id, &size);
+        if (rc != EOK)
                 return NULL;
         
@@ -153 +163 @@
         packet_t packet = pm_find(packet_id);
         if (!packet) {
-                if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
-                    size)))
+                rc = packet_return(phone, &packet, packet_id, size);
+                if (rc != EOK)
                         return NULL;
         }
@@ -172 +182 @@
 packet_t packet_get_1_remote(int phone, size_t content)
 {
-        ERROR_DECLARE;
-        
         ipcarg_t packet_id;
         ipcarg_t size;
-        
-        if (ERROR_OCCURRED(async_req_1_2(phone, NET_PACKET_CREATE_1, content,
-            &packet_id, &size)))
+        int rc;
+        
+        rc = async_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
+            &size);
+        if (rc != EOK)
                 return NULL;
         
         packet_t packet = pm_find(packet_id);
         if (!packet) {
-                if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
-                    size)))
+                rc = packet_return(phone, &packet, packet_id, size);
+                if (rc != EOK)
                         return NULL;
         }

uspace/lib/net/netif/netif_local.c

@@ -43 +43 @@
 #include <ipc/services.h>
 #include <ipc/netif.h>
-#include <err.h>
+#include <errno.h>
 
 #include <generic.h>
@@ -113 +113 @@
 int netif_start_req_local(int netif_phone, device_id_t device_id)
 {
-        ERROR_DECLARE;
+        int rc;
         
         fibril_rwlock_write_lock(&netif_globals.lock);
         
         netif_device_t *device;
-        if (ERROR_OCCURRED(find_device(device_id, &device))) {
+        rc = find_device(device_id, &device);
+        if (rc != EOK) {
                 fibril_rwlock_write_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -148 +149 @@
 int netif_stop_req_local(int netif_phone, device_id_t device_id)
 {
-        ERROR_DECLARE;
+        int rc;
         
         fibril_rwlock_write_lock(&netif_globals.lock);
         
         netif_device_t *device;
-        if (ERROR_OCCURRED(find_device(device_id, &device))) {
+        rc = find_device(device_id, &device);
+        if (rc != EOK) {
                 fibril_rwlock_write_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -203 +205 @@
     measured_string_ref *address, char **data)
 {
-        ERROR_DECLARE;
+        int rc;
         
         if (!address || !data)
@@ -211 +213 @@
         
         measured_string_t translation;
-        if (!ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))) {
+        rc = netif_get_addr_message(device_id, &translation);
+        if (rc == EOK) {
                 *address = measured_string_copy(&translation);
-                ERROR_CODE = (*address) ? EOK : ENOMEM;
+                rc = (*address) ? EOK : ENOMEM;
         }
         
@@ -220 +223 @@
         *data = (**address).value;
         
-        return ERROR_CODE;
+        return rc;
 }
 
@@ -264 +267 @@
 int netif_init_module(async_client_conn_t client_connection)
 {
-        ERROR_DECLARE;
+        int rc;
         
         async_set_client_connection(client_connection);
@@ -271 +274 @@
         netif_device_map_initialize(&netif_globals.device_map);
         
-        ERROR_PROPAGATE(pm_init());
+        rc = pm_init();
+        if (rc != EOK)
+                return rc;
         
         fibril_rwlock_initialize(&netif_globals.lock);
-        if (ERROR_OCCURRED(netif_initialize())) {
+        
+        rc = netif_initialize();
+        if (rc != EOK) {
                 pm_destroy();
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -317 +324 @@
 static int register_message(const char *name, device_id_t device_id, int phone)
 {
-        ERROR_DECLARE;
-        
         netif_device_t *device;
-        ERROR_PROPAGATE(find_device(device_id, &device));
-        if(device->nil_phone > 0)
+        int rc;
+        
+        rc = find_device(device_id, &device);
+        if (rc != EOK)
+                return rc;
+        
+        if (device->nil_phone > 0)
                 return ELIMIT;
         
@@ -349 +359 @@
     ipc_call_t *call, ipc_call_t *answer, int *answer_count)
 {
-        ERROR_DECLARE;
-        
         size_t length;
         device_stats_t stats;
         packet_t packet;
         measured_string_t address;
+        int rc;
         
         *answer_count = 0;
@@ -367 +376 @@
         case IPC_M_CONNECT_TO_ME:
                 fibril_rwlock_write_lock(&netif_globals.lock);
-                ERROR_CODE = register_message(name, IPC_GET_DEVICE(call),
+                rc = register_message(name, IPC_GET_DEVICE(call),
                     IPC_GET_PHONE(call));
                 fibril_rwlock_write_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
                 
         case NET_NETIF_SEND:
-                ERROR_PROPAGATE(packet_translate_remote(netif_globals.net_phone,
-                    &packet, IPC_GET_PACKET(call)));
+                rc = packet_translate_remote(netif_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+                if (rc != EOK)
+                        return rc;
                 return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet,
                     IPC_GET_SENDER(call));
-                    
+                
         case NET_NETIF_START:
                 return netif_start_req_local(0, IPC_GET_DEVICE(call));
@@ -384 +395 @@
                 fibril_rwlock_read_lock(&netif_globals.lock);
 
-                if (ERROR_OCCURRED(async_data_read_receive(&callid, &length))) {
+                rc = async_data_read_receive(&callid, &length);
+                if (rc != EOK) {
                         fibril_rwlock_read_unlock(&netif_globals.lock);
-                        return ERROR_CODE;
+                        return rc;
                 }
                 if (length < sizeof(device_stats_t)) {
@@ -393 +405 @@
                 }
 
-                if (ERROR_NONE(netif_get_device_stats(IPC_GET_DEVICE(call),
-                    &stats))) {
-                        ERROR_CODE = async_data_read_finalize(callid, &stats,
+                rc = netif_get_device_stats(IPC_GET_DEVICE(call), &stats);
+                if (rc == EOK) {
+                        rc = async_data_read_finalize(callid, &stats,
                             sizeof(device_stats_t));
                 }
 
                 fibril_rwlock_read_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
 
         case NET_NETIF_STOP:
@@ -407 +419 @@
         case NET_NETIF_GET_ADDR:
                 fibril_rwlock_read_lock(&netif_globals.lock);
-                if (ERROR_NONE(netif_get_addr_message(IPC_GET_DEVICE(call),
-                    &address)))
-                        ERROR_CODE = measured_strings_reply(&address, 1);
+                rc = netif_get_addr_message(IPC_GET_DEVICE(call), &address);
+                if (rc == EOK)
+                        rc = measured_strings_reply(&address, 1);
                 fibril_rwlock_read_unlock(&netif_globals.lock);
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -431 +443 @@
 int netif_module_start_standalone(async_client_conn_t client_connection)
 {
-        ERROR_DECLARE;
-        
-        ERROR_PROPAGATE(netif_init_module(client_connection));
+        int rc;
+        
+        rc = netif_init_module(client_connection);
+        if (rc != EOK)
+                return rc;
         
         async_manager();

uspace/lib/net/tl/socket_core.c

@@ -48 +48 @@
 #include <stdlib.h>
 #include <errno.h>
-#include <err.h>
 
 #include <adt/dynamic_fifo.h>
@@ -164 +163 @@
     const char *key, size_t key_length)
 {
-        ERROR_DECLARE;
-
         socket_core_ref *socket_ref;
+        int rc;
 
         // create a wrapper
@@ -175 +173 @@
         *socket_ref = socket;
         // add the wrapper
-        if (ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key,
-            key_length, socket_ref))) {
+        rc = socket_port_map_add(&socket_port->map, key, key_length,
+            socket_ref);
+        if (rc != EOK) {
                 free(socket_ref);
-                return ERROR_CODE;
+                return rc;
         }
         
@@ -204 +203 @@
     int port)
 {
-        ERROR_DECLARE;
-
         socket_port_ref socket_port;
+        int rc;
 
         // create a wrapper
@@ -214 +212 @@
 
         socket_port->count = 0;
-        if (ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map)) ||
-            ERROR_OCCURRED(socket_port_add_core(socket_port, socket,
-            SOCKET_MAP_KEY_LISTENING, 0))) {
-                socket_port_map_destroy(&socket_port->map);
-                free(socket_port);
-                return ERROR_CODE;
-        }
+        rc = socket_port_map_initialize(&socket_port->map);
+        if (rc != EOK)
+                goto fail;
+        
+        rc = socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING,
+            0);
+        if (rc != EOK)
+                goto fail;
         
         // register the incomming port
-        ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
-        if (ERROR_CODE < 0) {
-                socket_port_map_destroy(&socket_port->map);
-                free(socket_port);
-                return ERROR_CODE;
-        }
+        rc = socket_ports_add(global_sockets, port, socket_port);
+        if (rc < 0)
+                goto fail;
         
         socket->port = port;
         return EOK;
+
+fail:
+        socket_port_map_destroy(&socket_port->map);
+        free(socket_port);
+        return rc;
+        
 }
 
@@ -416 +418 @@
     void *specific_data, int *socket_id)
 {
-        ERROR_DECLARE;
-
         socket_core_ref socket;
-        int res;
         int positive;
+        int rc;
 
         if (!socket_id)
@@ -447 +447 @@
         socket->key_length = 0;
         socket->specific_data = specific_data;
-        if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->received,
-            SOCKET_INITIAL_RECEIVED_SIZE))) {
+        rc = dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
+        if (rc != EOK) {
                 free(socket);
-                return ERROR_CODE;
-        }
-        if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted,
-            SOCKET_INITIAL_ACCEPTED_SIZE))) {
+                return rc;
+        }
+        
+        rc = dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
+        if (rc != EOK) {
                 dyn_fifo_destroy(&socket->received);
                 free(socket);
-                return ERROR_CODE;
+                return rc;
         }
         socket->socket_id = *socket_id;
-        res = socket_cores_add(local_sockets, socket->socket_id, socket);
-        if (res < 0) {
+        rc = socket_cores_add(local_sockets, socket->socket_id, socket);
+        if (rc < 0) {
                 dyn_fifo_destroy(&socket->received);
                 dyn_fifo_destroy(&socket->accepted);
                 free(socket);
-                return res;
+                return rc;
         }
         
@@ -523 +524 @@
 int socket_reply_packets(packet_t packet, size_t *length)
 {
-        ERROR_DECLARE;
-
         packet_t next_packet;
         size_t fragments;
         size_t *lengths;
         size_t index;
+        int rc;
 
         if (!length)
@@ -536 +536 @@
         if (!next_packet) {
                 // write all if only one fragment
-                ERROR_PROPAGATE(data_reply(packet_get_data(packet),
-                    packet_get_data_length(packet)));
+                rc = data_reply(packet_get_data(packet),
+                    packet_get_data_length(packet));
+                if (rc != EOK)
+                        return rc;
                 // store the total length
                 *length = packet_get_data_length(packet);
@@ -564 +566 @@
                 
                 // write the fragment lengths
-                if (ERROR_OCCURRED(data_reply(lengths,
-                    sizeof(int) * (fragments + 1)))) {
+                rc = data_reply(lengths, sizeof(int) * (fragments + 1));
+                if (rc != EOK) {
                         free(lengths);
-                        return ERROR_CODE;
+                        return rc;
                 }
                 next_packet = packet;
@@ -573 +575 @@
                 // write the fragments
                 for (index = 0; index < fragments; ++index) {
-                        ERROR_CODE = data_reply(packet_get_data(next_packet),
+                        rc = data_reply(packet_get_data(next_packet),
                             lengths[index]);
-                        if (ERROR_OCCURRED(ERROR_CODE)) {
+                        if (rc != EOK) {
                                 free(lengths);
-                                return ERROR_CODE;
+                                return rc;
                         }
                         next_packet = pq_next(next_packet);
@@ -680 +682 @@
     socket_core_ref socket, const char *key, size_t key_length)
 {
-        ERROR_DECLARE;
-
         socket_port_ref socket_port;
+        int rc;
 
         // find ports
@@ -690 +691 @@
         
         // add the socket
-        ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key,
-            key_length));
+        rc = socket_port_add_core(socket_port, socket, key, key_length);
+        if (rc != EOK)
+                return rc;
         
         socket->port = port;

uspace/lib/net/tl/tl_common.c

@@ -54 +54 @@
 #include <ipc/services.h>
 #include <errno.h>
-#include <err.h>
 
 DEVICE_MAP_IMPLEMENT(packet_dimensions, packet_dimension_t);
@@ -124 +123 @@
     packet_dimension_ref *packet_dimension)
 {
-        ERROR_DECLARE;
+        int rc;
         
         if (!packet_dimension)
@@ -137 +136 @@
                         return ENOMEM;
                 
-                if (ERROR_OCCURRED(ip_packet_size_req(ip_phone, device_id,
-                    *packet_dimension))) {
+                rc = ip_packet_size_req(ip_phone, device_id, *packet_dimension);
+                if (rc != EOK) {
                         free(*packet_dimension);
-                        return ERROR_CODE;
+                        return rc;
                 }
                 
-                ERROR_CODE = packet_dimensions_add(packet_dimensions, device_id,
+                rc = packet_dimensions_add(packet_dimensions, device_id,
                     *packet_dimension);
-                if (ERROR_CODE < 0) {
+                if (rc < 0) {
                         free(*packet_dimension);
-                        return ERROR_CODE;
+                        return rc;
                 }
         }
@@ -292 +291 @@
     socklen_t addrlen)
 {
-        ERROR_DECLARE;
-
         ipc_callid_t callid;
         size_t length;
-        void * data;
+        void *data;
+        int rc;
 
         if (!dimension)
@@ -319 +317 @@
 
         // read the data into the packet
-        if (ERROR_OCCURRED(async_data_write_finalize(callid, data, length)) ||
-            // set the packet destination address
-            ERROR_OCCURRED(packet_set_addr(*packet, NULL, (uint8_t *) addr,
-            addrlen))) {
+        rc = async_data_write_finalize(callid, data, length);
+        if (rc != EOK) {
                 pq_release_remote(packet_phone, packet_get_id(*packet));
-                return ERROR_CODE;
+                return rc;
+        }
+        
+        // set the packet destination address
+        rc = packet_set_addr(*packet, NULL, (uint8_t *) addr, addrlen);
+        if (rc != EOK) {
+                pq_release_remote(packet_phone, packet_get_id(*packet));
+                return rc;
         }
 

uspace/lib/packet/generic/packet_server.c

@@ -42 +42 @@
 #include <async.h>
 #include <errno.h>
-#include <err.h>
 #include <fibril_synch.h>
 #include <unistd.h>
@@ -162 +161 @@
     size_t max_content, size_t max_suffix)
 {
-        ERROR_DECLARE;
-
         packet_t packet;
+        int rc;
 
         // already locked
@@ -177 +175 @@
         packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
         packet->magic_value = PACKET_MAGIC_VALUE;
-        if (ERROR_OCCURRED(pm_add(packet))) {
+        rc = pm_add(packet);
+        if (rc != EOK) {
                 munmap(packet, packet->length);
                 return NULL;

uspace/srv/hw/netif/dp8390/dp8390_module.c

@@ -158 +158 @@
 
 int netif_get_device_stats(device_id_t device_id, device_stats_ref stats){
-        ERROR_DECLARE;
-
         netif_device_t * device;
         eth_stat_t * de_stat;
+        int rc;
 
         if(! stats){
                 return EBADMEM;
         }
-        ERROR_PROPAGATE(find_device(device_id, &device));
+        rc = find_device(device_id, &device);
+        if (rc != EOK)
+                return rc;
         de_stat = &((dpeth_t *) device->specific)->de_stat;
         null_device_stats(stats);
@@ -185 +186 @@
 
 int netif_get_addr_message(device_id_t device_id, measured_string_ref address){
-        ERROR_DECLARE;
-
-        netif_device_t * device;
+        netif_device_t * device;
+        int rc;
 
         if(! address){
                 return EBADMEM;
         }
-        ERROR_PROPAGATE(find_device(device_id, &device));
+        rc = find_device(device_id, &device);
+        if (rc != EOK)
+                return rc;
         address->value = (char *) (&((dpeth_t *) device->specific)->de_address);
         address->length = CONVERT_SIZE(ether_addr_t, char, 1);
@@ -201 +203 @@
 
 int netif_probe_message(device_id_t device_id, int irq, uintptr_t io){
-        ERROR_DECLARE;
-
-        netif_device_t * device;
-        dpeth_t * dep;
+        netif_device_t * device;
+        dpeth_t * dep;
+        int rc;
 
         device = (netif_device_t *) malloc(sizeof(netif_device_t));
@@ -224 +225 @@
         dep->de_mode = DEM_DISABLED;
         //TODO address?
-        if(ERROR_OCCURRED(pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port))
-                || ERROR_OCCURRED(do_probe(dep))){
+        rc = pio_enable((void *) io, DP8390_IO_SIZE, (void **) &dep->de_base_port);
+        if (rc != EOK) {
                 free(dep);
                 free(device);
-                return ERROR_CODE;
-        }
-        if(ERROR_OCCURRED(netif_device_map_add(&netif_globals.device_map, device->device_id, device))){
+                return rc;
+        }       
+        rc = do_probe(dep);
+        if (rc != EOK) {
                 free(dep);
                 free(device);
-                return ERROR_CODE;
+                return rc;
+        }
+        rc = netif_device_map_add(&netif_globals.device_map, device->device_id, device);
+        if (rc != EOK){
+                free(dep);
+                free(device);
+                return rc;
         }
         return EOK;
@@ -239 +247 @@
 
 int netif_send_message(device_id_t device_id, packet_t packet, services_t sender){
-        ERROR_DECLARE;
-
         netif_device_t * device;
         dpeth_t * dep;
         packet_t next;
-
-        ERROR_PROPAGATE(find_device(device_id, &device));
+        int rc;
+
+        rc = find_device(device_id, &device);
+        if (rc != EOK)
+                return rc;
         if(device->state != NETIF_ACTIVE){
                 netif_pq_release(packet_get_id(packet));
@@ -263 +272 @@
 
 int netif_start_message(netif_device_t * device){
-        ERROR_DECLARE;
-
-        dpeth_t * dep;
+        dpeth_t * dep;
+        int rc;
 
         if(device->state != NETIF_ACTIVE){
@@ -271 +279 @@
                 dp8390_cmds[0].addr = (void *) (uintptr_t) (dep->de_dp8390_port + DP_ISR);
                 dp8390_cmds[2].addr = dp8390_cmds[0].addr;
-                ERROR_PROPAGATE(ipc_register_irq(dep->de_irq, device->device_id, device->device_id, &dp8390_code));
-                if(ERROR_OCCURRED(do_init(dep, DL_BROAD_REQ))){
+                rc = ipc_register_irq(dep->de_irq, device->device_id, device->device_id, &dp8390_code);
+                if (rc != EOK)
+                        return rc;
+                rc = do_init(dep, DL_BROAD_REQ);
+                if (rc != EOK) {
                         ipc_unregister_irq(dep->de_irq, device->device_id);
-                        return ERROR_CODE;
+                        return rc;
                 }
                 return change_state(device, NETIF_ACTIVE);
@@ -350 +361 @@
 int main(int argc, char *argv[])
 {
-        ERROR_DECLARE;
+        int rc;
         
         /* Start the module */
-        if (ERROR_OCCURRED(netif_module_start(netif_client_connection)))
-                return ERROR_CODE;
-        
-        return EOK;
+        rc = netif_module_start(netif_client_connection);
+        return rc;
 }