Changeset 02314f8 in mainline


Ignore:
Timestamp:
2010-11-03T22:28:19Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
08e3ca4
Parents:
a852181
Message:

Get rid of the ERROR_CODE madness in ip.

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

Legend:

Unmodified
Added
Removed

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

    ra852181 r02314f8  
    4141#include <async.h>
    4242#include <errno.h>
    43 #include <err.h>
    4443#include <fibril_synch.h>
    4544#include <stdio.h>
    … …  
    254253int ip_initialize(async_client_conn_t client_connection)
    255254{
    256         ERROR_DECLARE;
     255        int rc;
    257256
    258257        fibril_rwlock_initialize(&ip_globals.lock);
    … …  
    265264        ip_globals.gateway.gateway.s_addr = 0;
    266265        ip_globals.gateway.netif = NULL;
    267         ERROR_PROPAGATE(ip_netifs_initialize(&ip_globals.netifs));
    268         ERROR_PROPAGATE(ip_protos_initialize(&ip_globals.protos));
    269266        ip_globals.client_connection = client_connection;
    270         ERROR_PROPAGATE(modules_initialize(&ip_globals.modules));
    271         ERROR_PROPAGATE(add_module(NULL, &ip_globals.modules, ARP_NAME,
    272             ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module));
     267       
     268        rc = ip_netifs_initialize(&ip_globals.netifs);
     269        if (rc != EOK)
     270                goto out;
     271        rc = ip_protos_initialize(&ip_globals.protos);
     272        if (rc != EOK)
     273                goto out;
     274        rc = modules_initialize(&ip_globals.modules);
     275        if (rc != EOK)
     276                goto out;
     277        rc = add_module(NULL, &ip_globals.modules, ARP_NAME, ARP_FILENAME,
     278            SERVICE_ARP, 0, arp_connect_module);
     279
     280out:
    273281        fibril_rwlock_write_unlock(&ip_globals.lock);
    274282
    275         return EOK;
     283        return rc;
    276284}
    277285
    … …  
    302310static int ip_netif_initialize(ip_netif_ref ip_netif)
    303311{
    304         ERROR_DECLARE;
    305 
    306312        measured_string_t names[] = {
    307313                {
    … …  
    342348        char *data;
    343349        measured_string_t address;
    344         int index;
    345350        ip_route_ref route;
    346351        in_addr_t gateway;
     352        int index;
     353        int rc;
    347354
    348355        ip_netif->arp = NULL;
    … …  
    354361
    355362        // get configuration
    356         ERROR_PROPAGATE(net_get_device_conf_req(ip_globals.net_phone,
    357             ip_netif->device_id, &configuration, count, &data));
     363        rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
     364            &configuration, count, &data);
     365        if (rc != EOK)
     366                return rc;
     367       
    358368        if (configuration) {
    359369                if (configuration[0].value)
    … …  
    383393                                return index;
    384394                        }
    385                         if (ERROR_OCCURRED(inet_pton(AF_INET,
    386                             configuration[2].value,
    387                             (uint8_t *) &route->address.s_addr)) ||
    388                             ERROR_OCCURRED(inet_pton(AF_INET,
    389                             configuration[3].value,
    390                             (uint8_t *) &route->netmask.s_addr)) ||
     395                       
     396                        if ((inet_pton(AF_INET, configuration[2].value,
     397                            (uint8_t *) &route->address.s_addr) != EOK) ||
     398                            (inet_pton(AF_INET, configuration[3].value,
     399                            (uint8_t *) &route->netmask.s_addr) != EOK) ||
    391400                            (inet_pton(AF_INET, configuration[4].value,
    392401                            (uint8_t *) &gateway.s_addr) == EINVAL) ||
    … …  
    434443                        address.value = (char *) &route->address.s_addr;
    435444                        address.length = CONVERT_SIZE(in_addr_t, char, 1);
    436                         ERROR_PROPAGATE(arp_device_req(ip_netif->arp->phone,
     445                       
     446                        rc = arp_device_req(ip_netif->arp->phone,
    437447                            ip_netif->device_id, SERVICE_IP, ip_netif->service,
    438                             &address));
     448                            &address);
     449                        if (rc != EOK)
     450                                return rc;
    439451                } else {
    440452                        ip_netif->arp = 0;
    … …  
    443455
    444456        // get packet dimensions
    445         ERROR_PROPAGATE(nil_packet_size_req(ip_netif->phone,
    446             ip_netif->device_id, &ip_netif->packet_dimension));
     457        rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
     458            &ip_netif->packet_dimension);
     459        if (rc != EOK)
     460                return rc;
     461       
    447462        if (ip_netif->packet_dimension.content < IP_MIN_CONTENT) {
    448463                printf("Maximum transmission unit %d bytes is too small, at "
    … …  
    610625    measured_string_ref destination)
    611626{
    612         ERROR_DECLARE;
    613 
    614627        size_t length;
    615628        ip_header_ref header;
    … …  
    617630        ip_header_ref middle_header;
    618631        packet_t next;
     632        int rc;
    619633
    620634        length = packet_get_data_length(packet);
    … …  
    624638        header = (ip_header_ref) packet_get_data(packet);
    625639        if (destination) {
    626                 ERROR_PROPAGATE(packet_set_addr(packet, NULL,
    627                     (uint8_t *) destination->value,
    628                     CONVERT_SIZE(char, uint8_t, destination->length)));
     640                rc = packet_set_addr(packet, NULL, (uint8_t *) destination->value,
     641                    CONVERT_SIZE(char, uint8_t, destination->length));
    629642        } else {
    630                 ERROR_PROPAGATE(packet_set_addr(packet, NULL, NULL, 0));
    631         }
     643                rc = packet_set_addr(packet, NULL, NULL, 0);
     644        }
     645        if (rc != EOK)
     646                return rc;
     647       
    632648        header->version = IPV4;
    633649        header->fragment_offset_high = 0;
    … …  
    669685                            IP_HEADER_CHECKSUM(middle_header);
    670686                        if (destination) {
    671                                 if (ERROR_OCCURRED(packet_set_addr(next, NULL,
     687                                rc = packet_set_addr(next, NULL,
    672688                                    (uint8_t *) destination->value,
    673689                                    CONVERT_SIZE(char, uint8_t,
    674                                     destination->length)))) {
     690                                    destination->length));
     691                                if (rc != EOK) {
    675692                                        free(last_header);
    676                                         return ERROR_CODE;
     693                                        return rc;
    677694                                }
    678695                        }
    … …  
    699716                    IP_HEADER_CHECKSUM(middle_header);
    700717                if (destination) {
    701                         if (ERROR_OCCURRED(packet_set_addr(next, NULL,
     718                        rc = packet_set_addr(next, NULL,
    702719                            (uint8_t *) destination->value,
    703                             CONVERT_SIZE(char, uint8_t,
    704                             destination->length)))) {
     720                            CONVERT_SIZE(char, uint8_t, destination->length));
     721                        if (rc != EOK) {
    705722                                free(last_header);
    706                                 return ERROR_CODE;
    707                             }
     723                                return rc;
     724                        }
    708725                }
    709726                length += packet_get_data_length(next);
    … …  
    741758    const struct sockaddr *src, const struct sockaddr *dest, socklen_t addrlen)
    742759{
    743         ERROR_DECLARE;
    744 
    745760        void *data;
    746761        size_t offset;
     762        int rc;
    747763
    748764        data = packet_suffix(new_packet, length);
    … …  
    752768        memcpy(data, ((void *) header) + IP_TOTAL_LENGTH(header) - length,
    753769            length);
    754         ERROR_PROPAGATE(packet_trim(packet, 0, length));
     770       
     771        rc = packet_trim(packet, 0, length);
     772        if (rc != EOK)
     773                return rc;
     774       
    755775        header->total_length = htons(IP_TOTAL_LENGTH(header) - length);
    756776        new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
    … …  
    761781            IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
    762782        new_header->header_checksum = IP_HEADER_CHECKSUM(new_header);
    763         ERROR_PROPAGATE(packet_set_addr(new_packet, (const uint8_t *) src,
    764             (const uint8_t *) dest, addrlen));
     783       
     784        rc = packet_set_addr(new_packet, (const uint8_t *) src,
     785            (const uint8_t *) dest, addrlen);
     786        if (rc != EOK)
     787                return rc;
    765788
    766789        return pq_insert_after(packet, new_packet);
    … …  
    796819    socklen_t addr_len)
    797820{
    798         ERROR_DECLARE;
    799 
    800821        packet_t new_packet;
    801822        ip_header_ref header;
    … …  
    806827        socklen_t addrlen;
    807828        int result;
     829        int rc;
    808830
    809831        result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
    … …  
    839861
    840862        // trim the unused space
    841         if (ERROR_OCCURRED(packet_trim(new_packet, 0,
    842             IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header)))) {
    843                 return ip_release_and_return(packet, ERROR_CODE);
    844         }
     863        rc = packet_trim(new_packet, 0,
     864            IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header));
     865        if (rc != EOK)
     866                return ip_release_and_return(packet, rc);
    845867
    846868        // biggest multiple of 8 lower than content
    847869        // TODO even fragmentation?
    848870        length = length & ~0x7;
    849         if (ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet, header,
    850             last_header,
     871       
     872        rc = ip_fragment_packet_data(packet, new_packet, header, last_header,
    851873            ((IP_HEADER_DATA_LENGTH(header) -
    852874            ((length - IP_HEADER_LENGTH(header)) & ~0x7)) %
    853             ((length - IP_HEADER_LENGTH(last_header)) & ~0x7)), src, dest,
    854             addrlen))) {
    855                 return ip_release_and_return(packet, ERROR_CODE);
    856         }
     875            ((length - IP_HEADER_LENGTH(last_header)) & ~0x7)),
     876            src, dest, addrlen);
     877        if (rc != EOK)
     878                return ip_release_and_return(packet, rc);
    857879
    858880        // mark the first as fragmented
    … …  
    872894                        return ip_release_and_return(packet, ENOMEM);
    873895
    874                 if (ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet,
    875                     header, middle_header,
    876                     (length - IP_HEADER_LENGTH(middle_header)) & ~0x7, src,
    877                     dest, addrlen))) {
    878                         return ip_release_and_return(packet, ERROR_CODE);
    879                 }
     896                rc = ip_fragment_packet_data(packet, new_packet, header,
     897                    middle_header,
     898                    (length - IP_HEADER_LENGTH(middle_header)) & ~0x7,
     899                    src, dest, addrlen);
     900                if (rc != EOK)
     901                        return ip_release_and_return(packet, rc);
    880902        }
    881903
    … …  
    974996    in_addr_t *src, in_addr_t dest, services_t error)
    975997{
    976         ERROR_DECLARE;
    977 
    978998        measured_string_t destination;
    979999        measured_string_ref translation;
    9801000        char *data;
    9811001        int phone;
     1002        int rc;
    9821003
    9831004        // get destination hardware address
    … …  
    9871008                destination.length = CONVERT_SIZE(dest.s_addr, char, 1);
    9881009
    989                 if (ERROR_OCCURRED(arp_translate_req(netif->arp->phone,
    990                     netif->device_id, SERVICE_IP, &destination, &translation,
    991                     &data))) {
     1010                rc = arp_translate_req(netif->arp->phone, netif->device_id,
     1011                    SERVICE_IP, &destination, &translation, &data);
     1012                if (rc != EOK) {
    9921013                        pq_release_remote(ip_globals.net_phone,
    9931014                            packet_get_id(packet));
    994                         return ERROR_CODE;
     1015                        return rc;
    9951016                }
    9961017
    … …  
    10141035        }
    10151036
    1016         if (ERROR_OCCURRED(ip_prepare_packet(src, dest, packet, translation))) {
     1037        rc = ip_prepare_packet(src, dest, packet, translation);
     1038        if (rc != EOK) {
    10171039                pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    10181040        } else {
    … …  
    10321054        }
    10331055
    1034         return ERROR_CODE;
     1056        return rc;
    10351057}
    10361058
    … …  
    11581180ip_device_req_local(int il_phone, device_id_t device_id, services_t netif)
    11591181{
    1160         ERROR_DECLARE;
    1161 
    11621182        ip_netif_ref ip_netif;
    11631183        ip_route_ref route;
    11641184        int index;
     1185        int rc;
    11651186
    11661187        ip_netif = (ip_netif_ref) malloc(sizeof(ip_netif_t));
    … …  
    11681189                return ENOMEM;
    11691190
    1170         if (ERROR_OCCURRED(ip_routes_initialize(&ip_netif->routes))) {
     1191        rc = ip_routes_initialize(&ip_netif->routes);
     1192        if (rc != EOK) {
    11711193                free(ip_netif);
    1172                 return ERROR_CODE;
     1194                return rc;
    11731195        }
    11741196
    … …  
    11781200
    11791201        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
    1180         if (ERROR_OCCURRED(ip_netif_initialize(ip_netif))) {
     1202
     1203        rc = ip_netif_initialize(ip_netif);
     1204        if (rc != EOK) {
    11811205                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    11821206                ip_routes_destroy(&ip_netif->routes);
    11831207                free(ip_netif);
    1184                 return ERROR_CODE;
     1208                return rc;
    11851209        }
    11861210        if (ip_netif->arp)
    … …  
    12261250    services_t sender, services_t error)
    12271251{
    1228         ERROR_DECLARE;
    1229 
    12301252        int addrlen;
    12311253        ip_netif_ref netif;
    … …  
    12361258        in_addr_t *src;
    12371259        int phone;
     1260        int rc;
    12381261
    12391262        // addresses in the host byte order
    … …  
    13231346        }
    13241347
    1325         ERROR_CODE = ip_send_route(packet, netif, route, src, *dest, error);
     1348        rc = ip_send_route(packet, netif, route, src, *dest, error);
    13261349        fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
    13271350
    1328         return ERROR_CODE;
     1351        return rc;
    13291352}
    13301353
    … …  
    14311454    services_t error)
    14321455{
    1433         ERROR_DECLARE;
    1434 
    14351456        ip_proto_ref proto;
    14361457        int phone;
    … …  
    14421463        struct sockaddr_in dest_in;
    14431464        socklen_t addrlen;
     1465        int rc;
    14441466
    14451467        if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
    … …  
    14671489        }
    14681490
    1469         if (ERROR_OCCURRED(packet_set_addr(packet, (uint8_t *) src,
    1470             (uint8_t *) dest, addrlen))) {
    1471                 return ip_release_and_return(packet, ERROR_CODE);
    1472         }
     1491        rc = packet_set_addr(packet, (uint8_t *) src, (uint8_t *) dest,
     1492            addrlen);
     1493        if (rc != EOK)
     1494                return ip_release_and_return(packet, rc);
    14731495
    14741496        // trim padding if present
    14751497        if (!error &&
    14761498            (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
    1477                 if (ERROR_OCCURRED(packet_trim(packet, 0,
    1478                     packet_get_data_length(packet) - IP_TOTAL_LENGTH(header))))
    1479                         return ip_release_and_return(packet, ERROR_CODE);
     1499                rc = packet_trim(packet, 0,
     1500                    packet_get_data_length(packet) - IP_TOTAL_LENGTH(header));
     1501                if (rc != EOK)
     1502                        return ip_release_and_return(packet, rc);
    14801503        }
    14811504
    … …  
    14981521                received_msg = proto->received_msg;
    14991522                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    1500                 ERROR_CODE = received_msg(device_id, packet, service, error);
     1523                rc = received_msg(device_id, packet, service, error);
    15011524        } else {
    1502                 ERROR_CODE = tl_received_msg(proto->phone, device_id, packet,
     1525                rc = tl_received_msg(proto->phone, device_id, packet,
    15031526                    proto->service, error);
    15041527                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    15051528        }
    15061529
    1507         return ERROR_CODE;
     1530        return rc;
    15081531}
    15091532
    … …  
    15321555ip_process_packet(device_id_t device_id, packet_t packet)
    15331556{
    1534         ERROR_DECLARE;
    1535 
    15361557        ip_header_ref header;
    15371558        in_addr_t dest;
    … …  
    15411562        struct sockaddr_in addr_in;
    15421563        socklen_t addrlen;
     1564        int rc;
    15431565
    15441566        header = (ip_header_ref) packet_get_data(packet);
    … …  
    15851607        }
    15861608
    1587         ERROR_PROPAGATE(packet_set_addr(packet, NULL, (uint8_t *) &addr,
    1588             addrlen));
     1609        rc = packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen);
     1610        if (rc != EOK)
     1611                return rc;
    15891612
    15901613        route = ip_find_route(dest);
    … …  
    18671890    int *answer_count)
    18681891{
    1869         ERROR_DECLARE;
    1870        
    18711892        packet_t packet;
    18721893        struct sockaddr *addr;
    … …  
    18781899        size_t headerlen;
    18791900        device_id_t device_id;
     1901        int rc;
    18801902       
    18811903        *answer_count = 0;
    … …  
    18931915       
    18941916        case NET_IL_SEND:
    1895                 ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
    1896                     &packet, IPC_GET_PACKET(call)));
     1917                rc = packet_translate_remote(ip_globals.net_phone, &packet,
     1918                    IPC_GET_PACKET(call));
     1919                if (rc != EOK)
     1920                        return rc;
    18971921                return ip_send_msg_local(0, IPC_GET_DEVICE(call), packet, 0,
    18981922                    IPC_GET_ERROR(call));
    … …  
    19031927       
    19041928        case NET_IL_RECEIVED:
    1905                 ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
    1906                     &packet, IPC_GET_PACKET(call)));
     1929                rc = packet_translate_remote(ip_globals.net_phone, &packet,
     1930                    IPC_GET_PACKET(call));
     1931                if (rc != EOK)
     1932                        return rc;
    19071933                return ip_receive_message(IPC_GET_DEVICE(call), packet);
    19081934       
    19091935        case NET_IP_RECEIVED_ERROR:
    1910                 ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
    1911                     &packet, IPC_GET_PACKET(call)));
     1936                rc = packet_translate_remote(ip_globals.net_phone, &packet,
     1937                    IPC_GET_PACKET(call));
     1938                if (rc != EOK)
     1939                        return rc;
    19121940                return ip_received_error_msg_local(0, IPC_GET_DEVICE(call),
    19131941                    packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
    … …  
    19231951
    19241952        case NET_IP_GET_ROUTE:
    1925                 ERROR_PROPAGATE(data_receive((void **) &addr, &addrlen));
    1926                 ERROR_PROPAGATE(ip_get_route_req_local(0, IP_GET_PROTOCOL(call),
    1927                     addr, (socklen_t) addrlen, &device_id, &header,
    1928                     &headerlen));
     1953                rc = data_receive((void **) &addr, &addrlen);
     1954                if (rc != EOK)
     1955                        return rc;
     1956               
     1957                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(call), addr,
     1958                    (socklen_t) addrlen, &device_id, &header, &headerlen);
     1959                if (rc != EOK)
     1960                        return rc;
     1961               
    19291962                IPC_SET_DEVICE(answer, device_id);
    19301963                IP_SET_HEADERLEN(answer, headerlen);
    19311964               
    19321965                *answer_count = 2;
    1933                        
    1934                 if (ERROR_NONE(data_reply(&headerlen, sizeof(headerlen))))
    1935                         ERROR_CODE = data_reply(header, headerlen);
     1966               
     1967                rc = data_reply(&headerlen, sizeof(headerlen));
     1968                if (rc == EOK)
     1969                        rc = data_reply(header, headerlen);
    19361970                       
    19371971                free(header);
    1938                 return ERROR_CODE;
     1972                return rc;
    19391973       
    19401974        case NET_IL_PACKET_SPACE:
    1941                 ERROR_PROPAGATE(ip_packet_size_message(IPC_GET_DEVICE(call),
    1942                     &addrlen, &prefix, &content, &suffix));
     1975                rc = ip_packet_size_message(IPC_GET_DEVICE(call), &addrlen,
     1976                    &prefix, &content, &suffix);
     1977                if (rc != EOK)
     1978                        return rc;
     1979               
    19431980                IPC_SET_ADDR(answer, addrlen);
    19441981                IPC_SET_PREFIX(answer, prefix);
    … …  
    20052042int main(int argc, char *argv[])
    20062043{
    2007         ERROR_DECLARE;
     2044        int rc;
    20082045       
    20092046        /* Start the module */
    2010         ERROR_PROPAGATE(il_module_start_standalone(il_client_connection));
    2011         return EOK;
     2047        rc = il_module_start_standalone(il_client_connection);
     2048        return rc;
    20122049}
    20132050

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

    ra852181 r02314f8  
    4444#include <ipc/ipc.h>
    4545#include <ipc/services.h>
    46 #include <err.h>
     46#include <errno.h>
    4747
    4848#include <net/modules.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        ip_globals.net_phone = net_connect_module();
    72         ERROR_PROPAGATE(pm_init());
     73
     74        rc = pm_init();
     75        if (rc != EOK)
     76                return rc;
    7377       
    74         ipcarg_t phonehash;
    75         if (ERROR_OCCURRED(ip_initialize(client_connection)) ||
    76             ERROR_OCCURRED(REGISTER_ME(SERVICE_IP, &phonehash))) {
    77                 pm_destroy();
    78                 return ERROR_CODE;
    79         }
     78        rc = ip_initialize(client_connection);
     79        if (rc != EOK)
     80                goto out;
     81       
     82        rc = REGISTER_ME(SERVICE_IP, &phonehash);
     83        if (rc != EOK)
     84                goto out;
    8085       
    8186        async_manager();
    82        
     87
     88out:
    8389        pm_destroy();
    84         return EOK;
     90        return rc;
    8591}
    8692
Note: See TracChangeset for help on using the changeset viewer.