Changeset a852181 in mainline


Ignore:
Timestamp:
2010-11-03T21:45:26Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
02314f8
Parents:
4ef32e0c
Message:

Get rid of the ERROR_CODE madness in arp.

Location:
uspace/srv/net/il/arp
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r4ef32e0c ra852181  
    5555#include <ipc/il.h>
    5656#include <byteorder.h>
    57 #include <err.h>
     57#include <errno.h>
    5858
    5959#include <net/modules.h>
    … …  
    179179    measured_string_ref address)
    180180{
    181         ERROR_DECLARE;
     181        int rc;
    182182
    183183        *proto = (arp_proto_ref) malloc(sizeof(arp_proto_t));
    184184        if (!*proto)
    185185                return ENOMEM;
     186       
    186187        (*proto)->service = service;
    187188        (*proto)->addr = address;
    188189        (*proto)->addr_data = address->value;
    189         if (ERROR_OCCURRED(arp_addr_initialize(&(*proto)->addresses))) {
     190       
     191        rc = arp_addr_initialize(&(*proto)->addresses);
     192        if (rc != EOK) {
    190193                free(*proto);
    191                 return ERROR_CODE;
    192         }
     194                return rc;
     195        }
     196       
    193197        return EOK;
    194198}
    … …  
    214218    services_t protocol, measured_string_ref address)
    215219{
    216         ERROR_DECLARE;
    217 
    218220        arp_device_ref device;
    219221        arp_proto_ref proto;
     222        hw_type_t hardware;
    220223        int index;
    221         hw_type_t hardware;
     224        int rc;
    222225
    223226        fibril_rwlock_write_lock(&arp_globals.lock);
    … …  
    237240                        proto->addr_data = address->value;
    238241                } else {
    239                         if (ERROR_OCCURRED(arp_proto_create(&proto, protocol,
    240                             address))) {
     242                        rc = arp_proto_create(&proto, protocol, address);
     243                        if (rc != EOK) {
    241244                                fibril_rwlock_write_unlock(&arp_globals.lock);
    242                                 return ERROR_CODE;
     245                                return rc;
    243246                        }
    244247                        index = arp_protos_add(&device->protos, proto->service,
    … …  
    265268                device->hardware = hardware;
    266269                device->device_id = device_id;
    267                 if (ERROR_OCCURRED(arp_protos_initialize(&device->protos)) ||
    268                     ERROR_OCCURRED(arp_proto_create(&proto, protocol,
    269                     address))) {
     270                rc = arp_protos_initialize(&device->protos);
     271                if (rc != EOK) {
    270272                        fibril_rwlock_write_unlock(&arp_globals.lock);
    271273                        free(device);
    272                         return ERROR_CODE;
     274                        return rc;
     275                }
     276                rc = arp_proto_create(&proto, protocol, address);
     277                if (rc != EOK) {
     278                        fibril_rwlock_write_unlock(&arp_globals.lock);
     279                        free(device);
     280                        return rc;
    273281                }
    274282                index = arp_protos_add(&device->protos, proto->service, proto);
    … …  
    293301               
    294302                // get packet dimensions
    295                 if (ERROR_OCCURRED(nil_packet_size_req(device->phone, device_id,
    296                     &device->packet_dimension))) {
     303                rc = nil_packet_size_req(device->phone, device_id,
     304                    &device->packet_dimension);
     305                if (rc != EOK) {
    297306                        fibril_rwlock_write_unlock(&arp_globals.lock);
    298307                        arp_protos_destroy(&device->protos);
    299308                        free(device);
    300                         return ERROR_CODE;
     309                        return rc;
    301310                }
    302311               
    303312                // get hardware address
    304                 if (ERROR_OCCURRED(nil_get_addr_req(device->phone, device_id,
    305                     &device->addr, &device->addr_data))) {
     313                rc = nil_get_addr_req(device->phone, device_id, &device->addr,
     314                    &device->addr_data);
     315                if (rc != EOK) {
    306316                        fibril_rwlock_write_unlock(&arp_globals.lock);
    307317                        arp_protos_destroy(&device->protos);
    308318                        free(device);
    309                         return ERROR_CODE;
     319                        return rc;
    310320                }
    311321               
    312322                // get broadcast address
    313                 if (ERROR_OCCURRED(nil_get_broadcast_addr_req(device->phone,
    314                     device_id, &device->broadcast_addr,
    315                     &device->broadcast_data))) {
     323                rc = nil_get_broadcast_addr_req(device->phone, device_id,
     324                    &device->broadcast_addr, &device->broadcast_data);
     325                if (rc != EOK) {
    316326                        fibril_rwlock_write_unlock(&arp_globals.lock);
    317327                        free(device->addr);
    … …  
    319329                        arp_protos_destroy(&device->protos);
    320330                        free(device);
    321                         return ERROR_CODE;
    322                 }
    323                
    324                 if (ERROR_OCCURRED(arp_cache_add(&arp_globals.cache,
    325                     device->device_id, device))) {
     331                        return rc;
     332                }
     333               
     334                rc = arp_cache_add(&arp_globals.cache, device->device_id,
     335                    device);
     336                if (rc != EOK) {
    326337                        fibril_rwlock_write_unlock(&arp_globals.lock);
    327338                        free(device->addr);
    … …  
    331342                        arp_protos_destroy(&device->protos);
    332343                        free(device);
    333                         return ERROR_CODE;
     344                        return rc;
    334345                }
    335346                printf("%s: Device registered (id: %d, type: 0x%x, service: %d,"
    … …  
    351362int arp_initialize(async_client_conn_t client_connection)
    352363{
    353         ERROR_DECLARE;
     364        int rc;
    354365
    355366        fibril_rwlock_initialize(&arp_globals.lock);
    356367        fibril_rwlock_write_lock(&arp_globals.lock);
    357368        arp_globals.client_connection = client_connection;
    358         ERROR_PROPAGATE(arp_cache_initialize(&arp_globals.cache));
     369        rc = arp_cache_initialize(&arp_globals.cache);
    359370        fibril_rwlock_write_unlock(&arp_globals.lock);
    360         return EOK;
     371       
     372        return rc;
    361373}
    362374
    … …  
    406418static int arp_receive_message(device_id_t device_id, packet_t packet)
    407419{
    408         ERROR_DECLARE;
    409 
    410420        size_t length;
    411421        arp_header_ref header;
    … …  
    417427        uint8_t *des_hw;
    418428        uint8_t *des_proto;
     429        int rc;
    419430
    420431        length = packet_get_data_length(packet);
    … …  
    467478                                return ENOMEM;
    468479
    469                         ERROR_PROPAGATE(arp_addr_add(&proto->addresses,
    470                             (char *) src_proto, CONVERT_SIZE(uint8_t, char,
    471                             header->protocol_length), hw_source));
     480                        rc = arp_addr_add(&proto->addresses, (char *) src_proto,
     481                            CONVERT_SIZE(uint8_t, char,
     482                            header->protocol_length), hw_source);
     483                        if (rc != EOK)
     484                                return rc;
    472485                }
    473486                if (ntohs(header->operation) == ARPOP_REQUEST) {
    … …  
    480493                        memcpy(des_hw, hw_source->value,
    481494                            header->hardware_length);
    482                         ERROR_PROPAGATE(packet_set_addr(packet, src_hw, des_hw,
    483                             header->hardware_length));
     495                       
     496                        rc = packet_set_addr(packet, src_hw, des_hw,
     497                            header->hardware_length);
     498                        if (rc != EOK)
     499                                return rc;
     500                       
    484501                        nil_send_msg(device->phone, device_id, packet,
    485502                            SERVICE_ARP);
    … …  
    596613    ipc_call_t *answer, int *answer_count)
    597614{
    598         ERROR_DECLARE;
    599        
    600615        measured_string_ref address;
    601616        measured_string_ref translation;
    … …  
    603618        packet_t packet;
    604619        packet_t next;
     620        int rc;
    605621       
    606622        *answer_count = 0;
    … …  
    610626       
    611627        case NET_ARP_DEVICE:
    612                 ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
    613                 if (ERROR_OCCURRED(arp_device_message(IPC_GET_DEVICE(call),
    614                     IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address))) {
     628                rc = measured_strings_receive(&address, &data, 1);
     629                if (rc != EOK)
     630                        return rc;
     631               
     632                rc = arp_device_message(IPC_GET_DEVICE(call),
     633                    IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address);
     634                if (rc != EOK) {
    615635                        free(address);
    616636                        free(data);
    617637                }
    618                 return ERROR_CODE;
     638                return rc;
    619639       
    620640        case NET_ARP_TRANSLATE:
    621                 ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
     641                rc = measured_strings_receive(&address, &data, 1);
     642                if (rc != EOK)
     643                        return rc;
     644               
    622645                fibril_rwlock_read_lock(&arp_globals.lock);
    623646                translation = arp_translate_message(IPC_GET_DEVICE(call),
    … …  
    629652                        return ENOENT;
    630653                }
    631                 ERROR_CODE = measured_strings_reply(translation, 1);
     654                rc = measured_strings_reply(translation, 1);
    632655                fibril_rwlock_read_unlock(&arp_globals.lock);
    633                 return ERROR_CODE;
     656                return rc;
    634657
    635658        case NET_ARP_CLEAR_DEVICE:
    … …  
    637660
    638661        case NET_ARP_CLEAR_ADDRESS:
    639                 ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
     662                rc = measured_strings_receive(&address, &data, 1);
     663                if (rc != EOK)
     664                        return rc;
     665               
    640666                arp_clear_address_req(0, IPC_GET_DEVICE(call),
    641667                    IPC_GET_SERVICE(call), address);
    … …  
    652678       
    653679        case NET_IL_RECEIVED:
    654                 if (ERROR_NONE(packet_translate_remote(arp_globals.net_phone,
    655                     &packet, IPC_GET_PACKET(call)))) {
    656                         fibril_rwlock_read_lock(&arp_globals.lock);
    657                         do {
    658                                 next = pq_detach(packet);
    659                                 ERROR_CODE =
    660                                     arp_receive_message(IPC_GET_DEVICE(call),
    661                                     packet);
    662                                 if (ERROR_CODE != 1) {
    663                                         pq_release_remote(arp_globals.net_phone,
    664                                             packet_get_id(packet));
    665                                 }
    666                                 packet = next;
    667                         } while (packet);
    668                         fibril_rwlock_read_unlock(&arp_globals.lock);
    669                 }
    670                 return ERROR_CODE;
     680                rc = packet_translate_remote(arp_globals.net_phone, &packet,
     681                    IPC_GET_PACKET(call));
     682                if (rc != EOK)
     683                        return rc;
     684               
     685                fibril_rwlock_read_lock(&arp_globals.lock);
     686                do {
     687                        next = pq_detach(packet);
     688                        rc = arp_receive_message(IPC_GET_DEVICE(call), packet);
     689                        if (rc != 1) {
     690                                pq_release_remote(arp_globals.net_phone,
     691                                    packet_get_id(packet));
     692                        }
     693                        packet = next;
     694                } while (packet);
     695                fibril_rwlock_read_unlock(&arp_globals.lock);
     696               
     697                return EOK;
    671698       
    672699        case NET_IL_MTU_CHANGED:
    … …  
    727754int main(int argc, char *argv[])
    728755{
    729         ERROR_DECLARE;
     756        int rc;
    730757       
    731758        /* Start the module */
    732         ERROR_PROPAGATE(il_module_start_standalone(il_client_connection));
    733         return EOK;
     759        rc = il_module_start_standalone(il_client_connection);
     760        return rc;
    734761}
    735762

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

    r4ef32e0c ra852181  
    4141#include <async.h>
    4242#include <stdio.h>
    43 #include <err.h>
     43#include <errno.h>
    4444
    4545#include <ipc/ipc.h>
    … …  
    6666int il_module_start_standalone(async_client_conn_t client_connection)
    6767{
    68         ERROR_DECLARE;
     68        ipcarg_t phonehash;
     69        int rc;
    6970       
    7071        async_set_client_connection(client_connection);
    7172        arp_globals.net_phone = net_connect_module();
    72         ERROR_PROPAGATE(pm_init());
    7373       
    74         ipcarg_t phonehash;
    75         if (ERROR_OCCURRED(arp_initialize(client_connection)) ||
    76             ERROR_OCCURRED(REGISTER_ME(SERVICE_ARP, &phonehash))) {
     74        rc = pm_init();
     75        if (rc != EOK)
     76                return rc;
     77       
     78        rc = arp_initialize(client_connection);
     79        if (rc != EOK) {
    7780                pm_destroy();
    78                 return ERROR_CODE;
     81                return rc;
     82        }
     83       
     84        rc = REGISTER_ME(SERVICE_ARP, &phonehash);
     85        if (rc != EOK) {
     86                pm_destroy();
     87                return rc;
    7988        }
    8089       
Note: See TracChangeset for help on using the changeset viewer.