Changeset 0ab68f6 in mainline

Timestamp:

2010-11-07T20:48:21Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

3a5d238f

Parents:

88b127b

Message:

Get rid of the ERROR_CODE madness in libnet.

Location:

uspace/lib/net

Files:

• adt/module_map.c (modified) (3 diffs)
• generic/packet_remote.c (modified) (7 diffs)
• netif/netif_local.c (modified) (15 diffs)
• tl/socket_core.c (modified) (13 diffs)
• tl/tl_common.c (modified) (5 diffs)

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;
         }