Changeset 0ab68f6 in mainline


Ignore:
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:
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/net/adt/module_map.c

    r88b127b r0ab68f6  
    3838#include <task.h>
    3939#include <unistd.h>
    40 #include <err.h>
     40#include <errno.h>
    4141
    4242#include <ipc/services.h>
     
    6767    connect_module_t connect_module)
    6868{
    69         ERROR_DECLARE;
    70 
    7169        module_ref tmp_module;
     70        int rc;
    7271
    7372        tmp_module = (module_ref) malloc(sizeof(module_t));
     
    8382        tmp_module->connect_module = connect_module;
    8483
    85         if (ERROR_OCCURRED(modules_add(modules, tmp_module->name, 0,
    86             tmp_module))) {
     84        rc = modules_add(modules, tmp_module->name, 0, tmp_module);
     85        if (rc != EOK) {
    8786                free(tmp_module);
    88                 return ERROR_CODE;
     87                return rc;
    8988        }
    9089        if (module)
  • uspace/lib/net/generic/packet_remote.c

    r88b127b r0ab68f6  
    3838#include <async.h>
    3939#include <errno.h>
    40 #include <err.h>
    4140#include <ipc/ipc.h>
    4241#include <ipc/packet.h>
     
    6766packet_return(int phone, packet_ref packet, packet_id_t packet_id, size_t size)
    6867{
    69         ERROR_DECLARE;
    70        
    7168        ipc_call_t answer;
    72         aid_t message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
     69        aid_t message;
     70        int rc;
     71       
     72        message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
    7373
    7474        *packet = (packet_t) as_get_mappable_page(size);
    75         if (ERROR_OCCURRED(async_share_in_start_0_0(phone, *packet, size)) ||
    76             ERROR_OCCURRED(pm_add(*packet))) {
     75        rc = async_share_in_start_0_0(phone, *packet, size);
     76        if (rc != EOK) {
    7777                munmap(*packet, size);
    7878                async_wait_for(message, NULL);
    79                 return ERROR_CODE;
     79                return rc;
     80        }
     81        rc = pm_add(*packet);
     82        if (rc != EOK) {
     83                munmap(*packet, size);
     84                async_wait_for(message, NULL);
     85                return rc;
    8086        }
    8187       
     
    103109int packet_translate_remote(int phone, packet_ref packet, packet_id_t packet_id)
    104110{
    105         ERROR_DECLARE;
     111        int rc;
    106112       
    107113        if (!packet)
     
    112118                ipcarg_t size;
    113119               
    114                 ERROR_PROPAGATE(async_req_1_1(phone, NET_PACKET_GET_SIZE,
    115                     packet_id, &size));
    116                 ERROR_PROPAGATE(packet_return(phone, packet, packet_id, size));
     120                rc = async_req_1_1(phone, NET_PACKET_GET_SIZE, packet_id,
     121                    &size);
     122                if (rc != EOK)
     123                        return rc;
     124                rc = packet_return(phone, packet, packet_id, size);
     125                if (rc != EOK)
     126                        return rc;
    117127        }
    118128        if ((*packet)->next) {
     
    141151    size_t max_prefix, size_t max_suffix)
    142152{
    143         ERROR_DECLARE;
    144        
    145153        ipcarg_t packet_id;
    146154        ipcarg_t size;
    147        
    148         if (ERROR_OCCURRED(async_req_4_2(phone, NET_PACKET_CREATE_4,
    149             max_content, addr_len, max_prefix, max_suffix, &packet_id, &size)))
     155        int rc;
     156       
     157        rc = async_req_4_2(phone, NET_PACKET_CREATE_4, max_content, addr_len,
     158            max_prefix, max_suffix, &packet_id, &size);
     159        if (rc != EOK)
    150160                return NULL;
    151161       
     
    153163        packet_t packet = pm_find(packet_id);
    154164        if (!packet) {
    155                 if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
    156                     size)))
     165                rc = packet_return(phone, &packet, packet_id, size);
     166                if (rc != EOK)
    157167                        return NULL;
    158168        }
     
    172182packet_t packet_get_1_remote(int phone, size_t content)
    173183{
    174         ERROR_DECLARE;
    175        
    176184        ipcarg_t packet_id;
    177185        ipcarg_t size;
    178        
    179         if (ERROR_OCCURRED(async_req_1_2(phone, NET_PACKET_CREATE_1, content,
    180             &packet_id, &size)))
     186        int rc;
     187       
     188        rc = async_req_1_2(phone, NET_PACKET_CREATE_1, content, &packet_id,
     189            &size);
     190        if (rc != EOK)
    181191                return NULL;
    182192       
    183193        packet_t packet = pm_find(packet_id);
    184194        if (!packet) {
    185                 if (ERROR_OCCURRED(packet_return(phone, &packet, packet_id,
    186                     size)))
     195                rc = packet_return(phone, &packet, packet_id, size);
     196                if (rc != EOK)
    187197                        return NULL;
    188198        }
  • uspace/lib/net/netif/netif_local.c

    r88b127b r0ab68f6  
    4343#include <ipc/services.h>
    4444#include <ipc/netif.h>
    45 #include <err.h>
     45#include <errno.h>
    4646
    4747#include <generic.h>
     
    113113int netif_start_req_local(int netif_phone, device_id_t device_id)
    114114{
    115         ERROR_DECLARE;
     115        int rc;
    116116       
    117117        fibril_rwlock_write_lock(&netif_globals.lock);
    118118       
    119119        netif_device_t *device;
    120         if (ERROR_OCCURRED(find_device(device_id, &device))) {
     120        rc = find_device(device_id, &device);
     121        if (rc != EOK) {
    121122                fibril_rwlock_write_unlock(&netif_globals.lock);
    122                 return ERROR_CODE;
     123                return rc;
    123124        }
    124125       
     
    148149int netif_stop_req_local(int netif_phone, device_id_t device_id)
    149150{
    150         ERROR_DECLARE;
     151        int rc;
    151152       
    152153        fibril_rwlock_write_lock(&netif_globals.lock);
    153154       
    154155        netif_device_t *device;
    155         if (ERROR_OCCURRED(find_device(device_id, &device))) {
     156        rc = find_device(device_id, &device);
     157        if (rc != EOK) {
    156158                fibril_rwlock_write_unlock(&netif_globals.lock);
    157                 return ERROR_CODE;
     159                return rc;
    158160        }
    159161       
     
    203205    measured_string_ref *address, char **data)
    204206{
    205         ERROR_DECLARE;
     207        int rc;
    206208       
    207209        if (!address || !data)
     
    211213       
    212214        measured_string_t translation;
    213         if (!ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))) {
     215        rc = netif_get_addr_message(device_id, &translation);
     216        if (rc == EOK) {
    214217                *address = measured_string_copy(&translation);
    215                 ERROR_CODE = (*address) ? EOK : ENOMEM;
     218                rc = (*address) ? EOK : ENOMEM;
    216219        }
    217220       
     
    220223        *data = (**address).value;
    221224       
    222         return ERROR_CODE;
     225        return rc;
    223226}
    224227
     
    264267int netif_init_module(async_client_conn_t client_connection)
    265268{
    266         ERROR_DECLARE;
     269        int rc;
    267270       
    268271        async_set_client_connection(client_connection);
     
    271274        netif_device_map_initialize(&netif_globals.device_map);
    272275       
    273         ERROR_PROPAGATE(pm_init());
     276        rc = pm_init();
     277        if (rc != EOK)
     278                return rc;
    274279       
    275280        fibril_rwlock_initialize(&netif_globals.lock);
    276         if (ERROR_OCCURRED(netif_initialize())) {
     281       
     282        rc = netif_initialize();
     283        if (rc != EOK) {
    277284                pm_destroy();
    278                 return ERROR_CODE;
     285                return rc;
    279286        }
    280287       
     
    317324static int register_message(const char *name, device_id_t device_id, int phone)
    318325{
    319         ERROR_DECLARE;
    320        
    321326        netif_device_t *device;
    322         ERROR_PROPAGATE(find_device(device_id, &device));
    323         if(device->nil_phone > 0)
     327        int rc;
     328       
     329        rc = find_device(device_id, &device);
     330        if (rc != EOK)
     331                return rc;
     332       
     333        if (device->nil_phone > 0)
    324334                return ELIMIT;
    325335       
     
    349359    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
    350360{
    351         ERROR_DECLARE;
    352        
    353361        size_t length;
    354362        device_stats_t stats;
    355363        packet_t packet;
    356364        measured_string_t address;
     365        int rc;
    357366       
    358367        *answer_count = 0;
     
    367376        case IPC_M_CONNECT_TO_ME:
    368377                fibril_rwlock_write_lock(&netif_globals.lock);
    369                 ERROR_CODE = register_message(name, IPC_GET_DEVICE(call),
     378                rc = register_message(name, IPC_GET_DEVICE(call),
    370379                    IPC_GET_PHONE(call));
    371380                fibril_rwlock_write_unlock(&netif_globals.lock);
    372                 return ERROR_CODE;
     381                return rc;
    373382               
    374383        case NET_NETIF_SEND:
    375                 ERROR_PROPAGATE(packet_translate_remote(netif_globals.net_phone,
    376                     &packet, IPC_GET_PACKET(call)));
     384                rc = packet_translate_remote(netif_globals.net_phone, &packet,
     385                    IPC_GET_PACKET(call));
     386                if (rc != EOK)
     387                        return rc;
    377388                return netif_send_msg_local(0, IPC_GET_DEVICE(call), packet,
    378389                    IPC_GET_SENDER(call));
    379                    
     390               
    380391        case NET_NETIF_START:
    381392                return netif_start_req_local(0, IPC_GET_DEVICE(call));
     
    384395                fibril_rwlock_read_lock(&netif_globals.lock);
    385396
    386                 if (ERROR_OCCURRED(async_data_read_receive(&callid, &length))) {
     397                rc = async_data_read_receive(&callid, &length);
     398                if (rc != EOK) {
    387399                        fibril_rwlock_read_unlock(&netif_globals.lock);
    388                         return ERROR_CODE;
     400                        return rc;
    389401                }
    390402                if (length < sizeof(device_stats_t)) {
     
    393405                }
    394406
    395                 if (ERROR_NONE(netif_get_device_stats(IPC_GET_DEVICE(call),
    396                     &stats))) {
    397                         ERROR_CODE = async_data_read_finalize(callid, &stats,
     407                rc = netif_get_device_stats(IPC_GET_DEVICE(call), &stats);
     408                if (rc == EOK) {
     409                        rc = async_data_read_finalize(callid, &stats,
    398410                            sizeof(device_stats_t));
    399411                }
    400412
    401413                fibril_rwlock_read_unlock(&netif_globals.lock);
    402                 return ERROR_CODE;
     414                return rc;
    403415
    404416        case NET_NETIF_STOP:
     
    407419        case NET_NETIF_GET_ADDR:
    408420                fibril_rwlock_read_lock(&netif_globals.lock);
    409                 if (ERROR_NONE(netif_get_addr_message(IPC_GET_DEVICE(call),
    410                     &address)))
    411                         ERROR_CODE = measured_strings_reply(&address, 1);
     421                rc = netif_get_addr_message(IPC_GET_DEVICE(call), &address);
     422                if (rc == EOK)
     423                        rc = measured_strings_reply(&address, 1);
    412424                fibril_rwlock_read_unlock(&netif_globals.lock);
    413                 return ERROR_CODE;
     425                return rc;
    414426        }
    415427       
     
    431443int netif_module_start_standalone(async_client_conn_t client_connection)
    432444{
    433         ERROR_DECLARE;
    434        
    435         ERROR_PROPAGATE(netif_init_module(client_connection));
     445        int rc;
     446       
     447        rc = netif_init_module(client_connection);
     448        if (rc != EOK)
     449                return rc;
    436450       
    437451        async_manager();
  • uspace/lib/net/tl/socket_core.c

    r88b127b r0ab68f6  
    4848#include <stdlib.h>
    4949#include <errno.h>
    50 #include <err.h>
    5150
    5251#include <adt/dynamic_fifo.h>
     
    164163    const char *key, size_t key_length)
    165164{
    166         ERROR_DECLARE;
    167 
    168165        socket_core_ref *socket_ref;
     166        int rc;
    169167
    170168        // create a wrapper
     
    175173        *socket_ref = socket;
    176174        // add the wrapper
    177         if (ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key,
    178             key_length, socket_ref))) {
     175        rc = socket_port_map_add(&socket_port->map, key, key_length,
     176            socket_ref);
     177        if (rc != EOK) {
    179178                free(socket_ref);
    180                 return ERROR_CODE;
     179                return rc;
    181180        }
    182181       
     
    204203    int port)
    205204{
    206         ERROR_DECLARE;
    207 
    208205        socket_port_ref socket_port;
     206        int rc;
    209207
    210208        // create a wrapper
     
    214212
    215213        socket_port->count = 0;
    216         if (ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map)) ||
    217             ERROR_OCCURRED(socket_port_add_core(socket_port, socket,
    218             SOCKET_MAP_KEY_LISTENING, 0))) {
    219                 socket_port_map_destroy(&socket_port->map);
    220                 free(socket_port);
    221                 return ERROR_CODE;
    222         }
     214        rc = socket_port_map_initialize(&socket_port->map);
     215        if (rc != EOK)
     216                goto fail;
     217       
     218        rc = socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING,
     219            0);
     220        if (rc != EOK)
     221                goto fail;
    223222       
    224223        // register the incomming port
    225         ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
    226         if (ERROR_CODE < 0) {
    227                 socket_port_map_destroy(&socket_port->map);
    228                 free(socket_port);
    229                 return ERROR_CODE;
    230         }
     224        rc = socket_ports_add(global_sockets, port, socket_port);
     225        if (rc < 0)
     226                goto fail;
    231227       
    232228        socket->port = port;
    233229        return EOK;
     230
     231fail:
     232        socket_port_map_destroy(&socket_port->map);
     233        free(socket_port);
     234        return rc;
     235       
    234236}
    235237
     
    416418    void *specific_data, int *socket_id)
    417419{
    418         ERROR_DECLARE;
    419 
    420420        socket_core_ref socket;
    421         int res;
    422421        int positive;
     422        int rc;
    423423
    424424        if (!socket_id)
     
    447447        socket->key_length = 0;
    448448        socket->specific_data = specific_data;
    449         if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->received,
    450             SOCKET_INITIAL_RECEIVED_SIZE))) {
     449        rc = dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
     450        if (rc != EOK) {
    451451                free(socket);
    452                 return ERROR_CODE;
    453         }
    454         if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted,
    455             SOCKET_INITIAL_ACCEPTED_SIZE))) {
     452                return rc;
     453        }
     454       
     455        rc = dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
     456        if (rc != EOK) {
    456457                dyn_fifo_destroy(&socket->received);
    457458                free(socket);
    458                 return ERROR_CODE;
     459                return rc;
    459460        }
    460461        socket->socket_id = *socket_id;
    461         res = socket_cores_add(local_sockets, socket->socket_id, socket);
    462         if (res < 0) {
     462        rc = socket_cores_add(local_sockets, socket->socket_id, socket);
     463        if (rc < 0) {
    463464                dyn_fifo_destroy(&socket->received);
    464465                dyn_fifo_destroy(&socket->accepted);
    465466                free(socket);
    466                 return res;
     467                return rc;
    467468        }
    468469       
     
    523524int socket_reply_packets(packet_t packet, size_t *length)
    524525{
    525         ERROR_DECLARE;
    526 
    527526        packet_t next_packet;
    528527        size_t fragments;
    529528        size_t *lengths;
    530529        size_t index;
     530        int rc;
    531531
    532532        if (!length)
     
    536536        if (!next_packet) {
    537537                // write all if only one fragment
    538                 ERROR_PROPAGATE(data_reply(packet_get_data(packet),
    539                     packet_get_data_length(packet)));
     538                rc = data_reply(packet_get_data(packet),
     539                    packet_get_data_length(packet));
     540                if (rc != EOK)
     541                        return rc;
    540542                // store the total length
    541543                *length = packet_get_data_length(packet);
     
    564566               
    565567                // write the fragment lengths
    566                 if (ERROR_OCCURRED(data_reply(lengths,
    567                     sizeof(int) * (fragments + 1)))) {
     568                rc = data_reply(lengths, sizeof(int) * (fragments + 1));
     569                if (rc != EOK) {
    568570                        free(lengths);
    569                         return ERROR_CODE;
     571                        return rc;
    570572                }
    571573                next_packet = packet;
     
    573575                // write the fragments
    574576                for (index = 0; index < fragments; ++index) {
    575                         ERROR_CODE = data_reply(packet_get_data(next_packet),
     577                        rc = data_reply(packet_get_data(next_packet),
    576578                            lengths[index]);
    577                         if (ERROR_OCCURRED(ERROR_CODE)) {
     579                        if (rc != EOK) {
    578580                                free(lengths);
    579                                 return ERROR_CODE;
     581                                return rc;
    580582                        }
    581583                        next_packet = pq_next(next_packet);
     
    680682    socket_core_ref socket, const char *key, size_t key_length)
    681683{
    682         ERROR_DECLARE;
    683 
    684684        socket_port_ref socket_port;
     685        int rc;
    685686
    686687        // find ports
     
    690691       
    691692        // add the socket
    692         ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key,
    693             key_length));
     693        rc = socket_port_add_core(socket_port, socket, key, key_length);
     694        if (rc != EOK)
     695                return rc;
    694696       
    695697        socket->port = port;
  • uspace/lib/net/tl/tl_common.c

    r88b127b r0ab68f6  
    5454#include <ipc/services.h>
    5555#include <errno.h>
    56 #include <err.h>
    5756
    5857DEVICE_MAP_IMPLEMENT(packet_dimensions, packet_dimension_t);
     
    124123    packet_dimension_ref *packet_dimension)
    125124{
    126         ERROR_DECLARE;
     125        int rc;
    127126       
    128127        if (!packet_dimension)
     
    137136                        return ENOMEM;
    138137               
    139                 if (ERROR_OCCURRED(ip_packet_size_req(ip_phone, device_id,
    140                     *packet_dimension))) {
     138                rc = ip_packet_size_req(ip_phone, device_id, *packet_dimension);
     139                if (rc != EOK) {
    141140                        free(*packet_dimension);
    142                         return ERROR_CODE;
     141                        return rc;
    143142                }
    144143               
    145                 ERROR_CODE = packet_dimensions_add(packet_dimensions, device_id,
     144                rc = packet_dimensions_add(packet_dimensions, device_id,
    146145                    *packet_dimension);
    147                 if (ERROR_CODE < 0) {
     146                if (rc < 0) {
    148147                        free(*packet_dimension);
    149                         return ERROR_CODE;
     148                        return rc;
    150149                }
    151150        }
     
    292291    socklen_t addrlen)
    293292{
    294         ERROR_DECLARE;
    295 
    296293        ipc_callid_t callid;
    297294        size_t length;
    298         void * data;
     295        void *data;
     296        int rc;
    299297
    300298        if (!dimension)
     
    319317
    320318        // read the data into the packet
    321         if (ERROR_OCCURRED(async_data_write_finalize(callid, data, length)) ||
    322             // set the packet destination address
    323             ERROR_OCCURRED(packet_set_addr(*packet, NULL, (uint8_t *) addr,
    324             addrlen))) {
     319        rc = async_data_write_finalize(callid, data, length);
     320        if (rc != EOK) {
    325321                pq_release_remote(packet_phone, packet_get_id(*packet));
    326                 return ERROR_CODE;
     322                return rc;
     323        }
     324       
     325        // set the packet destination address
     326        rc = packet_set_addr(*packet, NULL, (uint8_t *) addr, addrlen);
     327        if (rc != EOK) {
     328                pq_release_remote(packet_phone, packet_get_id(*packet));
     329                return rc;
    327330        }
    328331
Note: See TracChangeset for help on using the changeset viewer.