Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r02314f8 rfd8e8e1  
    4141#include <async.h>
    4242#include <errno.h>
     43#include <err.h>
    4344#include <fibril_synch.h>
    4445#include <stdio.h>
    … …  
    253254int ip_initialize(async_client_conn_t client_connection)
    254255{
    255         int rc;
     256        ERROR_DECLARE;
    256257
    257258        fibril_rwlock_initialize(&ip_globals.lock);
    … …  
    264265        ip_globals.gateway.gateway.s_addr = 0;
    265266        ip_globals.gateway.netif = NULL;
     267        ERROR_PROPAGATE(ip_netifs_initialize(&ip_globals.netifs));
     268        ERROR_PROPAGATE(ip_protos_initialize(&ip_globals.protos));
    266269        ip_globals.client_connection = client_connection;
    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 
    280 out:
     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));
    281273        fibril_rwlock_write_unlock(&ip_globals.lock);
    282274
    283         return rc;
     275        return EOK;
    284276}
    285277
    … …  
    310302static int ip_netif_initialize(ip_netif_ref ip_netif)
    311303{
     304        ERROR_DECLARE;
     305
    312306        measured_string_t names[] = {
    313307                {
    … …  
    348342        char *data;
    349343        measured_string_t address;
     344        int index;
    350345        ip_route_ref route;
    351346        in_addr_t gateway;
    352         int index;
    353         int rc;
    354347
    355348        ip_netif->arp = NULL;
    … …  
    361354
    362355        // get configuration
    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        
     356        ERROR_PROPAGATE(net_get_device_conf_req(ip_globals.net_phone,
     357            ip_netif->device_id, &configuration, count, &data));
    368358        if (configuration) {
    369359                if (configuration[0].value)
    … …  
    393383                                return index;
    394384                        }
    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) ||
     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)) ||
    400391                            (inet_pton(AF_INET, configuration[4].value,
    401392                            (uint8_t *) &gateway.s_addr) == EINVAL) ||
    … …  
    443434                        address.value = (char *) &route->address.s_addr;
    444435                        address.length = CONVERT_SIZE(in_addr_t, char, 1);
    445                        
    446                         rc = arp_device_req(ip_netif->arp->phone,
     436                        ERROR_PROPAGATE(arp_device_req(ip_netif->arp->phone,
    447437                            ip_netif->device_id, SERVICE_IP, ip_netif->service,
    448                             &address);
    449                         if (rc != EOK)
    450                                 return rc;
     438                            &address));
    451439                } else {
    452440                        ip_netif->arp = 0;
    … …  
    455443
    456444        // get packet dimensions
    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        
     445        ERROR_PROPAGATE(nil_packet_size_req(ip_netif->phone,
     446            ip_netif->device_id, &ip_netif->packet_dimension));
    462447        if (ip_netif->packet_dimension.content < IP_MIN_CONTENT) {
    463448                printf("Maximum transmission unit %d bytes is too small, at "
    … …  
    625610    measured_string_ref destination)
    626611{
     612        ERROR_DECLARE;
     613
    627614        size_t length;
    628615        ip_header_ref header;
    … …  
    630617        ip_header_ref middle_header;
    631618        packet_t next;
    632         int rc;
    633619
    634620        length = packet_get_data_length(packet);
    … …  
    638624        header = (ip_header_ref) packet_get_data(packet);
    639625        if (destination) {
    640                 rc = packet_set_addr(packet, NULL, (uint8_t *) destination->value,
    641                     CONVERT_SIZE(char, uint8_t, destination->length));
     626                ERROR_PROPAGATE(packet_set_addr(packet, NULL,
     627                    (uint8_t *) destination->value,
     628                    CONVERT_SIZE(char, uint8_t, destination->length)));
    642629        } else {
    643                 rc = packet_set_addr(packet, NULL, NULL, 0);
    644         }
    645         if (rc != EOK)
    646                 return rc;
    647        
     630                ERROR_PROPAGATE(packet_set_addr(packet, NULL, NULL, 0));
     631        }
    648632        header->version = IPV4;
    649633        header->fragment_offset_high = 0;
    … …  
    685669                            IP_HEADER_CHECKSUM(middle_header);
    686670                        if (destination) {
    687                                 rc = packet_set_addr(next, NULL,
     671                                if (ERROR_OCCURRED(packet_set_addr(next, NULL,
    688672                                    (uint8_t *) destination->value,
    689673                                    CONVERT_SIZE(char, uint8_t,
    690                                     destination->length));
    691                                 if (rc != EOK) {
     674                                    destination->length)))) {
    692675                                        free(last_header);
    693                                         return rc;
     676                                        return ERROR_CODE;
    694677                                }
    695678                        }
    … …  
    716699                    IP_HEADER_CHECKSUM(middle_header);
    717700                if (destination) {
    718                         rc = packet_set_addr(next, NULL,
     701                        if (ERROR_OCCURRED(packet_set_addr(next, NULL,
    719702                            (uint8_t *) destination->value,
    720                             CONVERT_SIZE(char, uint8_t, destination->length));
    721                         if (rc != EOK) {
     703                            CONVERT_SIZE(char, uint8_t,
     704                            destination->length)))) {
    722705                                free(last_header);
    723                                 return rc;
    724                         }
     706                                return ERROR_CODE;
     707                            }
    725708                }
    726709                length += packet_get_data_length(next);
    … …  
    758741    const struct sockaddr *src, const struct sockaddr *dest, socklen_t addrlen)
    759742{
     743        ERROR_DECLARE;
     744
    760745        void *data;
    761746        size_t offset;
    762         int rc;
    763747
    764748        data = packet_suffix(new_packet, length);
    … …  
    768752        memcpy(data, ((void *) header) + IP_TOTAL_LENGTH(header) - length,
    769753            length);
    770        
    771         rc = packet_trim(packet, 0, length);
    772         if (rc != EOK)
    773                 return rc;
    774        
     754        ERROR_PROPAGATE(packet_trim(packet, 0, length));
    775755        header->total_length = htons(IP_TOTAL_LENGTH(header) - length);
    776756        new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
    … …  
    781761            IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
    782762        new_header->header_checksum = IP_HEADER_CHECKSUM(new_header);
    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;
     763        ERROR_PROPAGATE(packet_set_addr(new_packet, (const uint8_t *) src,
     764            (const uint8_t *) dest, addrlen));
    788765
    789766        return pq_insert_after(packet, new_packet);
    … …  
    819796    socklen_t addr_len)
    820797{
     798        ERROR_DECLARE;
     799
    821800        packet_t new_packet;
    822801        ip_header_ref header;
    … …  
    827806        socklen_t addrlen;
    828807        int result;
    829         int rc;
    830808
    831809        result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
    … …  
    861839
    862840        // trim the unused space
    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);
     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        }
    867845
    868846        // biggest multiple of 8 lower than content
    869847        // TODO even fragmentation?
    870848        length = length & ~0x7;
    871        
    872         rc = ip_fragment_packet_data(packet, new_packet, header, last_header,
     849        if (ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet, header,
     850            last_header,
    873851            ((IP_HEADER_DATA_LENGTH(header) -
    874852            ((length - IP_HEADER_LENGTH(header)) & ~0x7)) %
    875             ((length - IP_HEADER_LENGTH(last_header)) & ~0x7)),
    876             src, dest, addrlen);
    877         if (rc != EOK)
    878                 return ip_release_and_return(packet, rc);
     853            ((length - IP_HEADER_LENGTH(last_header)) & ~0x7)), src, dest,
     854            addrlen))) {
     855                return ip_release_and_return(packet, ERROR_CODE);
     856        }
    879857
    880858        // mark the first as fragmented
    … …  
    894872                        return ip_release_and_return(packet, ENOMEM);
    895873
    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);
     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                }
    902880        }
    903881
    … …  
    996974    in_addr_t *src, in_addr_t dest, services_t error)
    997975{
     976        ERROR_DECLARE;
     977
    998978        measured_string_t destination;
    999979        measured_string_ref translation;
    1000980        char *data;
    1001981        int phone;
    1002         int rc;
    1003982
    1004983        // get destination hardware address
    … …  
    1008987                destination.length = CONVERT_SIZE(dest.s_addr, char, 1);
    1009988
    1010                 rc = arp_translate_req(netif->arp->phone, netif->device_id,
    1011                     SERVICE_IP, &destination, &translation, &data);
    1012                 if (rc != EOK) {
     989                if (ERROR_OCCURRED(arp_translate_req(netif->arp->phone,
     990                    netif->device_id, SERVICE_IP, &destination, &translation,
     991                    &data))) {
    1013992                        pq_release_remote(ip_globals.net_phone,
    1014993                            packet_get_id(packet));
    1015                         return rc;
     994                        return ERROR_CODE;
    1016995                }
    1017996
    … …  
    10351014        }
    10361015
    1037         rc = ip_prepare_packet(src, dest, packet, translation);
    1038         if (rc != EOK) {
     1016        if (ERROR_OCCURRED(ip_prepare_packet(src, dest, packet, translation))) {
    10391017                pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    10401018        } else {
    … …  
    10541032        }
    10551033
    1056         return rc;
     1034        return ERROR_CODE;
    10571035}
    10581036
    … …  
    11801158ip_device_req_local(int il_phone, device_id_t device_id, services_t netif)
    11811159{
     1160        ERROR_DECLARE;
     1161
    11821162        ip_netif_ref ip_netif;
    11831163        ip_route_ref route;
    11841164        int index;
    1185         int rc;
    11861165
    11871166        ip_netif = (ip_netif_ref) malloc(sizeof(ip_netif_t));
    … …  
    11891168                return ENOMEM;
    11901169
    1191         rc = ip_routes_initialize(&ip_netif->routes);
    1192         if (rc != EOK) {
     1170        if (ERROR_OCCURRED(ip_routes_initialize(&ip_netif->routes))) {
    11931171                free(ip_netif);
    1194                 return rc;
     1172                return ERROR_CODE;
    11951173        }
    11961174
    … …  
    12001178
    12011179        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
    1202 
    1203         rc = ip_netif_initialize(ip_netif);
    1204         if (rc != EOK) {
     1180        if (ERROR_OCCURRED(ip_netif_initialize(ip_netif))) {
    12051181                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    12061182                ip_routes_destroy(&ip_netif->routes);
    12071183                free(ip_netif);
    1208                 return rc;
     1184                return ERROR_CODE;
    12091185        }
    12101186        if (ip_netif->arp)
    … …  
    12501226    services_t sender, services_t error)
    12511227{
     1228        ERROR_DECLARE;
     1229
    12521230        int addrlen;
    12531231        ip_netif_ref netif;
    … …  
    12581236        in_addr_t *src;
    12591237        int phone;
    1260         int rc;
    12611238
    12621239        // addresses in the host byte order
    … …  
    13461323        }
    13471324
    1348         rc = ip_send_route(packet, netif, route, src, *dest, error);
     1325        ERROR_CODE = ip_send_route(packet, netif, route, src, *dest, error);
    13491326        fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
    13501327
    1351         return rc;
     1328        return ERROR_CODE;
    13521329}
    13531330
    … …  
    14541431    services_t error)
    14551432{
     1433        ERROR_DECLARE;
     1434
    14561435        ip_proto_ref proto;
    14571436        int phone;
    … …  
    14631442        struct sockaddr_in dest_in;
    14641443        socklen_t addrlen;
    1465         int rc;
    14661444
    14671445        if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
    … …  
    14891467        }
    14901468
    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);
     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        }
    14951473
    14961474        // trim padding if present
    14971475        if (!error &&
    14981476            (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
    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);
     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);
    15031480        }
    15041481
    … …  
    15211498                received_msg = proto->received_msg;
    15221499                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    1523                 rc = received_msg(device_id, packet, service, error);
     1500                ERROR_CODE = received_msg(device_id, packet, service, error);
    15241501        } else {
    1525                 rc = tl_received_msg(proto->phone, device_id, packet,
     1502                ERROR_CODE = tl_received_msg(proto->phone, device_id, packet,
    15261503                    proto->service, error);
    15271504                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
    15281505        }
    15291506
    1530         return rc;
     1507        return ERROR_CODE;
    15311508}
    15321509
    … …  
    15551532ip_process_packet(device_id_t device_id, packet_t packet)
    15561533{
     1534        ERROR_DECLARE;
     1535
    15571536        ip_header_ref header;
    15581537        in_addr_t dest;
    … …  
    15621541        struct sockaddr_in addr_in;
    15631542        socklen_t addrlen;
    1564         int rc;
    15651543
    15661544        header = (ip_header_ref) packet_get_data(packet);
    … …  
    16071585        }
    16081586
    1609         rc = packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen);
    1610         if (rc != EOK)
    1611                 return rc;
     1587        ERROR_PROPAGATE(packet_set_addr(packet, NULL, (uint8_t *) &addr,
     1588            addrlen));
    16121589
    16131590        route = ip_find_route(dest);
    … …  
    18901867    int *answer_count)
    18911868{
     1869        ERROR_DECLARE;
     1870       
    18921871        packet_t packet;
    18931872        struct sockaddr *addr;
    … …  
    18991878        size_t headerlen;
    19001879        device_id_t device_id;
    1901         int rc;
    19021880       
    19031881        *answer_count = 0;
    … …  
    19151893       
    19161894        case NET_IL_SEND:
    1917                 rc = packet_translate_remote(ip_globals.net_phone, &packet,
    1918                     IPC_GET_PACKET(call));
    1919                 if (rc != EOK)
    1920                         return rc;
     1895                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
     1896                    &packet, IPC_GET_PACKET(call)));
    19211897                return ip_send_msg_local(0, IPC_GET_DEVICE(call), packet, 0,
    19221898                    IPC_GET_ERROR(call));
    … …  
    19271903       
    19281904        case NET_IL_RECEIVED:
    1929                 rc = packet_translate_remote(ip_globals.net_phone, &packet,
    1930                     IPC_GET_PACKET(call));
    1931                 if (rc != EOK)
    1932                         return rc;
     1905                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
     1906                    &packet, IPC_GET_PACKET(call)));
    19331907                return ip_receive_message(IPC_GET_DEVICE(call), packet);
    19341908       
    19351909        case NET_IP_RECEIVED_ERROR:
    1936                 rc = packet_translate_remote(ip_globals.net_phone, &packet,
    1937                     IPC_GET_PACKET(call));
    1938                 if (rc != EOK)
    1939                         return rc;
     1910                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
     1911                    &packet, IPC_GET_PACKET(call)));
    19401912                return ip_received_error_msg_local(0, IPC_GET_DEVICE(call),
    19411913                    packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
    … …  
    19511923
    19521924        case NET_IP_GET_ROUTE:
    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                
     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));
    19621929                IPC_SET_DEVICE(answer, device_id);
    19631930                IP_SET_HEADERLEN(answer, headerlen);
    19641931               
    19651932                *answer_count = 2;
    1966                
    1967                 rc = data_reply(&headerlen, sizeof(headerlen));
    1968                 if (rc == EOK)
    1969                         rc = data_reply(header, headerlen);
     1933                       
     1934                if (ERROR_NONE(data_reply(&headerlen, sizeof(headerlen))))
     1935                        ERROR_CODE = data_reply(header, headerlen);
    19701936                       
    19711937                free(header);
    1972                 return rc;
     1938                return ERROR_CODE;
    19731939       
    19741940        case NET_IL_PACKET_SPACE:
    1975                 rc = ip_packet_size_message(IPC_GET_DEVICE(call), &addrlen,
    1976                     &prefix, &content, &suffix);
    1977                 if (rc != EOK)
    1978                         return rc;
    1979                
     1941                ERROR_PROPAGATE(ip_packet_size_message(IPC_GET_DEVICE(call),
     1942                    &addrlen, &prefix, &content, &suffix));
    19801943                IPC_SET_ADDR(answer, addrlen);
    19811944                IPC_SET_PREFIX(answer, prefix);
    … …  
    20422005int main(int argc, char *argv[])
    20432006{
    2044         int rc;
     2007        ERROR_DECLARE;
    20452008       
    20462009        /* Start the module */
    2047         rc = il_module_start_standalone(il_client_connection);
    2048         return rc;
     2010        ERROR_PROPAGATE(il_module_start_standalone(il_client_connection));
     2011        return EOK;
    20492012}
    20502013
Note: See TracChangeset for help on using the changeset viewer.