Changeset 4c14b88 in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2013-12-31T07:57:14Z (12 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1b973dc
Parents:
6297465 (diff), 208b5f5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

mainline changes

Location:
uspace/lib/c/generic
Files:
3 added
1 deleted
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/dnsr.c

    r6297465 r4c14b88  
    6767}
    6868
    69 int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo, uint16_t af)
     69int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo, ip_ver_t ver)
    7070{
    7171        dnsr_hostinfo_t *info = calloc(1, sizeof(dnsr_hostinfo_t));
    … …  
    7676       
    7777        ipc_call_t answer;
    78         aid_t req = async_send_1(exch, DNSR_NAME2HOST, (sysarg_t) af,
     78        aid_t req = async_send_1(exch, DNSR_NAME2HOST, (sysarg_t) ver,
    7979            &answer);
    8080       

  • uspace/lib/c/generic/inet.c

    r6297465 r4c14b88  
    3030#include <assert.h>
    3131#include <errno.h>
    32 #include <net/socket_codes.h>
    3332#include <inet/inet.h>
    3433#include <ipc/inet.h>

  • uspace/lib/c/generic/inet/addr.c

    r6297465 r4c14b88  
    3333 */
    3434
     35#include <assert.h>
    3536#include <errno.h>
    3637#include <unistd.h>
    … …  
    5960
    6061static const inet_addr_t inet_addr_any_addr = {
    61         .family = AF_INET,
     62        .version = ip_v4,
    6263        .addr = 0
    6364};
    6465
    6566static const inet_addr_t inet_addr_any_addr6 = {
    66         .family = AF_INET6,
     67        .version = ip_v6,
    6768        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    6869};
    … …  
    7879}
    7980
     81/** Compare addr48.
     82  *
     83  * @return Non-zero if equal, zero if not equal.
     84  */
    8085int addr48_compare(const addr48_t a, const addr48_t b)
    8186{
    82         return memcmp(a, b, 6);
    83 }
    84 
     87        return memcmp(a, b, 6) == 0;
     88}
     89
     90/** Compare addr128.
     91  *
     92  * @return Non-zero if equal, zero if not equal.
     93  */
    8594int addr128_compare(const addr128_t a, const addr128_t b)
    8695{
    87         return memcmp(a, b, 16);
     96        return memcmp(a, b, 16) == 0;
    8897}
    8998
    … …  
    102111void host2addr128_t_be(const addr128_t host, addr128_t be)
    103112{
    104 #ifdef __BE__
    105113        memcpy(be, host, 16);
    106 #else
    107         be[0] = host[15];
    108         be[1] = host[14];
    109         be[2] = host[13];
    110         be[3] = host[12];
    111         be[4] = host[11];
    112         be[5] = host[10];
    113         be[6] = host[9];
    114         be[7] = host[8];
    115         be[8] = host[7];
    116         be[9] = host[6];
    117         be[10] = host[5];
    118         be[11] = host[4];
    119         be[12] = host[3];
    120         be[13] = host[2];
    121         be[14] = host[1];
    122         be[15] = host[0];
    123 #endif
    124114}
    125115
    126116void addr128_t_be2host(const addr128_t be, addr128_t host)
    127117{
    128 #ifdef __BE__
    129118        memcpy(host, be, 16);
    130 #else
    131         host[0] = be[15];
    132         host[1] = be[14];
    133         host[2] = be[13];
    134         host[3] = be[12];
    135         host[4] = be[11];
    136         host[5] = be[10];
    137         host[6] = be[9];
    138         host[7] = be[8];
    139         host[8] = be[7];
    140         host[9] = be[6];
    141         host[10] = be[5];
    142         host[11] = be[4];
    143         host[12] = be[3];
    144         host[13] = be[2];
    145         host[14] = be[1];
    146         host[15] = be[0];
    147 #endif
    148119}
    149120
    150121void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
    151122{
    152         addr->family = AF_INET;
     123        addr->version = ip_v4;
    153124        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    154125            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    158129    uint8_t prefix)
    159130{
    160         naddr->family = AF_INET;
     131        naddr->version = ip_v4;
    161132        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    162133            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    167138    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
    168139{
    169         addr->family = AF_INET6;
     140        addr->version = ip_v6;
    170141        addr->addr6[0] = (a >> 8) & 0xff;
    171142        addr->addr6[1] = a & 0xff;
    … …  
    189160    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
    190161{
    191         naddr->family = AF_INET6;
     162        naddr->version = ip_v6;
    192163        naddr->addr6[0] = (a >> 8) & 0xff;
    193164        naddr->addr6[1] = a & 0xff;
    … …  
    209180}
    210181
    211 /** Parse network address family.
    212  *
    213  * @param text Network address in common notation.
    214  * @param af   Place to store network address family.
     182/** Determine address version.
     183 *
     184 * @param text Address in common notation.
     185 * @param af   Place to store address version.
    215186 *
    216187 * @return EOK on success, EINVAL if input is not in valid format.
    217188 *
    218189 */
    219 int inet_addr_family(const char *text, uint16_t *af)
     190static int inet_addr_version(const char *text, ip_ver_t *ver)
    220191{
    221192        char *dot = str_chr(text, '.');
    222193        if (dot != NULL) {
    223                 *af = AF_INET;
     194                *ver = ip_v4;
    224195                return EOK;
    225196        }
    226        
     197
    227198        char *collon = str_chr(text, ':');
    228199        if (collon != NULL) {
    229                 *af = AF_INET6;
     200                *ver = ip_v6;
    230201                return EOK;
    231202        }
    232        
     203
    233204        return EINVAL;
    234205}
    235206
     207static int ipver_af(ip_ver_t ver)
     208{
     209        switch (ver) {
     210        case ip_any:
     211                return AF_NONE;
     212        case ip_v4:
     213                return AF_INET;
     214        case ip_v6:
     215                return AF_INET6;
     216        default:
     217                assert(false);
     218                return EINVAL;
     219        }
     220}
     221
     222ip_ver_t ipver_from_af(int af)
     223{
     224        switch (af) {
     225        case AF_NONE:
     226                return ip_any;
     227        case AF_INET:
     228                return ip_v4;
     229        case AF_INET6:
     230                return ip_v6;
     231        default:
     232                assert(false);
     233                return EINVAL;
     234        }
     235}
     236
    236237void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
    237238{
    238         addr->family = naddr->family;
     239        addr->version = naddr->version;
    239240        memcpy(addr->addr6, naddr->addr6, 16);
    240241}
    … …  
    243244    inet_naddr_t *naddr)
    244245{
    245         naddr->family = addr->family;
     246        naddr->version = addr->version;
    246247        memcpy(naddr->addr6, addr->addr6, 16);
    247248        naddr->prefix = prefix;
    … …  
    250251void inet_addr_any(inet_addr_t *addr)
    251252{
    252         addr->family = AF_NONE;
     253        addr->version = ip_any;
    253254        memset(addr->addr6, 0, 16);
    254255}
    … …  
    256257void inet_naddr_any(inet_naddr_t *naddr)
    257258{
    258         naddr->family = AF_NONE;
     259        naddr->version = ip_any;
    259260        memset(naddr->addr6, 0, 16);
    260261        naddr->prefix = 0;
    … …  
    263264int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
    264265{
    265         if (a->family != b->family)
     266        if (a->version != b->version)
    266267                return 0;
    267        
    268         switch (a->family) {
    269         case AF_INET:
     268
     269        switch (a->version) {
     270        case ip_v4:
    270271                return (a->addr == b->addr);
    271         case AF_INET6:
     272        case ip_v6:
    272273                return addr128_compare(a->addr6, b->addr6);
    273274        default:
    … …  
    278279int inet_addr_is_any(const inet_addr_t *addr)
    279280{
    280         return ((addr->family == 0) ||
     281        return ((addr->version == ip_any) ||
    281282            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
    282283            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    … …  
    285286int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
    286287{
    287         if (naddr->family != addr->family)
     288        if (naddr->version != addr->version)
    288289                return 0;
    289290       
    290         switch (naddr->family) {
    291         case AF_INET:
     291        switch (naddr->version) {
     292        case ip_v4:
    292293                return (naddr->addr == addr->addr);
    293         case AF_INET6:
     294        case ip_v6:
    294295                return addr128_compare(naddr->addr6, addr->addr6);
    295296        default:
    … …  
    300301int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
    301302{
    302         if (naddr->family != addr->family)
     303        if (naddr->version != addr->version)
    303304                return 0;
    304        
    305         switch (naddr->family) {
    306         case AF_INET:
     305
     306        switch (naddr->version) {
     307        case ip_v4:
    307308                if (naddr->prefix > 32)
    308309                        return 0;
    309                
     310
    310311                addr32_t mask =
    311312                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
    312313                return ((naddr->addr & mask) == (addr->addr & mask));
    313         case AF_INET6:
     314        case ip_v6:
    314315                if (naddr->prefix > 128)
    315316                        return 0;
    … …  
    352353int inet_addr_parse(const char *text, inet_addr_t *addr)
    353354{
    354         int rc = inet_addr_family(text, &addr->family);
     355        int rc = inet_addr_version(text, &addr->version);
    355356        if (rc != EOK)
    356357                return rc;
    357358       
    358359        uint8_t buf[16];
    359         rc = inet_pton(addr->family, text, buf);
     360        rc = inet_pton(ipver_af(addr->version), text, buf);
    360361        if (rc != EOK)
    361362                return rc;
    362363       
    363         switch (addr->family) {
    364         case AF_INET:
     364        switch (addr->version) {
     365        case ip_v4:
    365366                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    366367                    buf[3];
    367368                break;
    368         case AF_INET6:
     369        case ip_v6:
    369370                memcpy(addr->addr6, buf, 16);
    370371                break;
    … …  
    392393        *slash = 0;
    393394       
    394         int rc = inet_addr_family(text, &naddr->family);
     395        int rc = inet_addr_version(text, &naddr->version);
    395396        if (rc != EOK)
    396397                return rc;
    397398       
    398399        uint8_t buf[16];
    399         rc = inet_pton(naddr->family, text, buf);
     400        rc = inet_pton(ipver_af(naddr->version), text, buf);
    400401        *slash = '/';
    401402       
    … …  
    406407        uint8_t prefix;
    407408       
    408         switch (naddr->family) {
    409         case AF_INET:
     409        switch (naddr->version) {
     410        case ip_v4:
    410411                prefix = strtoul(slash, &slash, 10);
    411412                if (prefix > 32)
    … …  
    417418               
    418419                break;
    419         case AF_INET6:
     420        case ip_v6:
    420421                prefix = strtoul(slash, &slash, 10);
    421422                if (prefix > 128)
    … …  
    447448        int rc = 0;
    448449       
    449         switch (addr->family) {
    450         case AF_NONE:
     450        switch (addr->version) {
     451        case ip_any:
    451452                rc = asprintf(bufp, "none");
    452453                break;
    453         case AF_INET:
     454        case ip_v4:
    454455                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
    455456                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
    456457                    addr->addr & 0xff);
    457458                break;
    458         case AF_INET6:
     459        case ip_v6:
    459460                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
    460461                if (*bufp == NULL)
    … …  
    487488        char prefix[INET_PREFIXSTRSIZE];
    488489       
    489         switch (naddr->family) {
    490         case AF_NONE:
     490        switch (naddr->version) {
     491        case ip_any:
    491492                rc = asprintf(bufp, "none");
    492493                break;
    493         case AF_INET:
     494        case ip_v4:
    494495                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
    495496                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
    … …  
    497498                    naddr->addr & 0xff, naddr->prefix);
    498499                break;
    499         case AF_INET6:
     500        case ip_v6:
    500501                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    501502                if (*bufp == NULL)
    … …  
    529530}
    530531
    531 uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
    532 {
    533         switch (addr->family) {
    534         case AF_INET:
     532ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
     533{
     534        switch (addr->version) {
     535        case ip_v4:
    535536                if (v4 != NULL)
    536537                        *v4 = addr->addr;
    537                
    538                 break;
    539         case AF_INET6:
     538                break;
     539        case ip_v6:
    540540                if (v6 != NULL)
    541541                        memcpy(*v6, addr->addr6, 16);
    542                
    543                 break;
    544         }
    545        
    546         return addr->family;
    547 }
    548 
    549 uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
     542                break;
     543        default:
     544                assert(false);
     545                break;
     546        }
     547
     548        return addr->version;
     549}
     550
     551ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
    550552    uint8_t *prefix)
    551553{
    552         switch (naddr->family) {
    553         case AF_INET:
     554        switch (naddr->version) {
     555        case ip_v4:
    554556                if (v4 != NULL)
    555557                        *v4 = naddr->addr;
    556                
    557558                if (prefix != NULL)
    558559                        *prefix = naddr->prefix;
    559                
    560                 break;
    561         case AF_INET6:
     560                break;
     561        case ip_v6:
    562562                if (v6 != NULL)
    563563                        memcpy(*v6, naddr->addr6, 16);
    564                
    565564                if (prefix != NULL)
    566565                        *prefix = naddr->prefix;
    567                
    568                 break;
    569         }
    570        
    571         return naddr->family;
     566                break;
     567        default:
     568                assert(false);
     569                break;
     570        }
     571
     572        return naddr->version;
    572573}
    573574
    574575void inet_addr_set(addr32_t v4, inet_addr_t *addr)
    575576{
    576         addr->family = AF_INET;
     577        addr->version = ip_v4;
    577578        addr->addr = v4;
    578579}
    … …  
    580581void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
    581582{
    582         naddr->family = AF_INET;
     583        naddr->version = ip_v4;
    583584        naddr->addr = v4;
    584585        naddr->prefix = prefix;
    … …  
    587588void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
    588589{
    589         addr->family = AF_INET;
     590        addr->version = ip_v4;
    590591        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
    591592}
    … …  
    593594void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    594595{
    595         addr->family = AF_INET6;
     596        addr->version = ip_v6;
    596597        memcpy(addr->addr6, v6, 16);
    597598}
    … …  
    599600void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
    600601{
    601         naddr->family = AF_INET6;
     602        naddr->version = ip_v6;
    602603        memcpy(naddr->addr6, v6, 16);
    603604        naddr->prefix = prefix;
    … …  
    607608    inet_addr_t *addr)
    608609{
    609         addr->family = AF_INET6;
     610        addr->version = ip_v6;
    610611        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
    611612}
    … …  
    614615    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
    615616{
    616         switch (addr->family) {
    617         case AF_INET:
     617        switch (addr->version) {
     618        case ip_v4:
    618619                if (sockaddr_in != NULL) {
    619620                        sockaddr_in->sin_family = AF_INET;
    620621                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    621622                }
    622                
    623                 break;
    624         case AF_INET6:
     623                break;
     624        case ip_v6:
    625625                if (sockaddr_in6 != NULL) {
    626626                        sockaddr_in6->sin6_family = AF_INET6;
    627627                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
    628628                }
    629                
    630                 break;
    631         }
    632        
    633         return addr->family;
     629                break;
     630        default:
     631                assert(false);
     632                break;
     633        }
     634
     635        return ipver_af(addr->version);
     636}
     637
     638int inet_addr_sockaddr(const inet_addr_t *addr, uint16_t port,
     639    sockaddr_t **nsockaddr, socklen_t *naddrlen)
     640{
     641        sockaddr_in_t *sa4;
     642        sockaddr_in6_t *sa6;
     643
     644        switch (addr->version) {
     645        case ip_v4:
     646                sa4 = calloc(1, sizeof(sockaddr_in_t));
     647                if (sa4 == NULL)
     648                        return ENOMEM;
     649
     650                sa4->sin_family = AF_INET;
     651                sa4->sin_port = host2uint16_t_be(port);
     652                sa4->sin_addr.s_addr = host2uint32_t_be(addr->addr);
     653                if (nsockaddr != NULL)
     654                        *nsockaddr = (sockaddr_t *)sa4;
     655                if (naddrlen != NULL)
     656                        *naddrlen = sizeof(*sa4);
     657                break;
     658        case ip_v6:
     659                sa6 = calloc(1, sizeof(sockaddr_in6_t));
     660                if (sa6 == NULL)
     661                        return ENOMEM;
     662
     663                sa6->sin6_family = AF_INET6;
     664                sa6->sin6_port = host2uint16_t_be(port);
     665                host2addr128_t_be(addr->addr6, sa6->sin6_addr.s6_addr);
     666                if (nsockaddr != NULL)
     667                        *nsockaddr = (sockaddr_t *)sa6;
     668                if (naddrlen != NULL)
     669                        *naddrlen = sizeof(*sa6);
     670                break;
     671        default:
     672                assert(false);
     673                break;
     674        }
     675
     676        return EOK;
    634677}
    635678

  • uspace/lib/c/generic/inetcfg.c

    r6297465 r4c14b88  
    267267}
    268268
     269int inetcfg_link_add(sysarg_t link_id)
     270{
     271        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     272
     273        int rc = async_req_1_0(exch, INETCFG_LINK_ADD, link_id);
     274        async_exchange_end(exch);
     275
     276        return rc;
     277}
     278
    269279int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    270280{
    … …  
    305315}
    306316
     317int inetcfg_link_remove(sysarg_t link_id)
     318{
     319        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     320
     321        int rc = async_req_1_0(exch, INETCFG_LINK_REMOVE, link_id);
     322        async_exchange_end(exch);
     323
     324        return rc;
     325}
     326
    307327int inetcfg_sroute_create(const char *name, inet_naddr_t *dest,
    308328    inet_addr_t *router, sysarg_t *sroute_id)

  • uspace/lib/c/generic/inetping.c

    r6297465 r4c14b88  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
     3 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    4950
    5051        assert(inetping_sess == NULL);
    51        
     52
    5253        inetping_ev_ops = ev_ops;
    53        
     54
    5455        rc = loc_service_get_id(SERVICE_NAME_INETPING, &inetping_svc,
    5556            IPC_FLAG_BLOCKING);
    5657        if (rc != EOK)
    5758                return ENOENT;
    58        
     59
    5960        inetping_sess = loc_service_connect(EXCHANGE_SERIALIZE, inetping_svc,
    6061            IPC_FLAG_BLOCKING);
    6162        if (inetping_sess == NULL)
    6263                return ENOENT;
    63        
     64
    6465        async_exch_t *exch = async_exchange_begin(inetping_sess);
    6566
    6667        rc = async_connect_to_me(exch, 0, 0, 0, inetping_cb_conn, NULL);
    6768        async_exchange_end(exch);
    68        
     69
    6970        if (rc != EOK) {
    7071                async_hangup(inetping_sess);
    … …  
    7273                return rc;
    7374        }
    74        
     75
    7576        return EOK;
    7677}
    … …  
    7980{
    8081        async_exch_t *exch = async_exchange_begin(inetping_sess);
    81        
     82
    8283        ipc_call_t answer;
    83         aid_t req = async_send_3(exch, INETPING_SEND, (sysarg_t) sdu->src,
    84             (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    85         sysarg_t retval = async_data_write_start(exch, sdu->data, sdu->size);
    86        
     84        aid_t req = async_send_1(exch, INETPING_SEND, sdu->seq_no, &answer);
     85
     86        int rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
     87        if (rc != EOK) {
     88                async_exchange_end(exch);
     89                async_forget(req);
     90                return rc;
     91        }
     92
     93        rc = async_data_write_start(exch, &sdu->dest, sizeof(sdu->dest));
     94        if (rc != EOK) {
     95                async_exchange_end(exch);
     96                async_forget(req);
     97                return rc;
     98        }
     99
     100        rc = async_data_write_start(exch, sdu->data, sdu->size);
     101
    87102        async_exchange_end(exch);
    88        
    89         if (retval != EOK) {
    90                 async_forget(req);
    91                 return retval;
    92         }
    93        
     103
     104        if (rc != EOK) {
     105                async_forget(req);
     106                return rc;
     107        }
     108
     109        sysarg_t retval;
    94110        async_wait_for(req, &retval);
    95         return retval;
    96 }
    97 
    98 int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
     111
     112        return (int) retval;
     113}
     114
     115int inetping_get_srcaddr(const inet_addr_t *remote, inet_addr_t *local)
    99116{
    100117        async_exch_t *exch = async_exchange_begin(inetping_sess);
    101        
    102         sysarg_t local_addr;
    103         int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
    104             &local_addr);
    105        
     118
     119        ipc_call_t answer;
     120        aid_t req = async_send_0(exch, INETPING_GET_SRCADDR, &answer);
     121
     122        int rc = async_data_write_start(exch, remote, sizeof(*remote));
     123        if (rc != EOK) {
     124                async_exchange_end(exch);
     125                async_forget(req);
     126                return rc;
     127        }
     128
     129        ipc_call_t answer_local;
     130        aid_t req_local = async_data_read(exch, local, sizeof(*local),
     131            &answer_local);
     132
    106133        async_exchange_end(exch);
    107        
    108         if (rc != EOK)
    109                 return rc;
    110        
    111         *local = (uint32_t) local_addr;
    112         return EOK;
    113 }
    114 
    115 static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
     134
     135        sysarg_t retval_local;
     136        async_wait_for(req_local, &retval_local);
     137
     138        if (retval_local != EOK) {
     139                async_forget(req);
     140                return (int) retval_local;
     141        }
     142
     143        sysarg_t retval;
     144        async_wait_for(req, &retval);
     145
     146        return (int) retval;
     147}
     148
     149static void inetping_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
    116150{
    117151        inetping_sdu_t sdu;
    118        
    119         sdu.src = IPC_GET_ARG1(*call);
    120         sdu.dest = IPC_GET_ARG2(*call);
    121         sdu.seq_no = IPC_GET_ARG3(*call);
    122        
    123         int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     152
     153        sdu.seq_no = IPC_GET_ARG1(*icall);
     154
     155        ipc_callid_t callid;
     156        size_t size;
     157        if (!async_data_write_receive(&callid, &size)) {
     158                async_answer_0(callid, EREFUSED);
     159                async_answer_0(iid, EREFUSED);
     160                return;
     161        }
     162
     163        if (size != sizeof(sdu.src)) {
     164                async_answer_0(callid, EINVAL);
     165                async_answer_0(iid, EINVAL);
     166                return;
     167        }
     168
     169        int rc = async_data_write_finalize(callid, &sdu.src, size);
    124170        if (rc != EOK) {
    125171                async_answer_0(callid, rc);
    126                 return;
    127         }
    128        
     172                async_answer_0(iid, rc);
     173                return;
     174        }
     175
     176        if (!async_data_write_receive(&callid, &size)) {
     177                async_answer_0(callid, EREFUSED);
     178                async_answer_0(iid, EREFUSED);
     179                return;
     180        }
     181
     182        if (size != sizeof(sdu.dest)) {
     183                async_answer_0(callid, EINVAL);
     184                async_answer_0(iid, EINVAL);
     185                return;
     186        }
     187
     188        rc = async_data_write_finalize(callid, &sdu.dest, size);
     189        if (rc != EOK) {
     190                async_answer_0(callid, rc);
     191                async_answer_0(iid, rc);
     192                return;
     193        }
     194
     195        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     196        if (rc != EOK) {
     197                async_answer_0(iid, rc);
     198                return;
     199        }
     200
    129201        rc = inetping_ev_ops->recv(&sdu);
    130202        free(sdu.data);
    131         async_answer_0(callid, rc);
     203        async_answer_0(iid, rc);
    132204}
    133205

  • uspace/lib/c/generic/iplink.c

    r6297465 r4c14b88  
    218218        iplink_recv_sdu_t sdu;
    219219       
    220         uint16_t af = IPC_GET_ARG1(*icall);
     220        ip_ver_t ver = IPC_GET_ARG1(*icall);
    221221       
    222222        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
    … …  
    227227        }
    228228       
    229         rc = iplink->ev_ops->recv(iplink, &sdu, af);
     229        rc = iplink->ev_ops->recv(iplink, &sdu, ver);
    230230        free(sdu.data);
    231231        async_answer_0(iid, rc);

  • uspace/lib/c/generic/iplink_srv.c

    r6297465 r4c14b88  
    272272}
    273273
    274 int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, uint16_t af)
     274/* XXX Version should be part of @a sdu */
     275int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, ip_ver_t ver)
    275276{
    276277        if (srv->client_sess == NULL)
    … …  
    280281       
    281282        ipc_call_t answer;
    282         aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t) af,
     283        aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t)ver,
    283284            &answer);
    284285       

  • uspace/lib/c/generic/rtld/module.c

    r6297465 r4c14b88  
    9393module_t *module_find(const char *name)
    9494{
    95         module_t *m;
    9695        const char *p, *soname;
    9796
    … …  
    107106
    108107        /* Traverse list of all modules. Not extremely fast, but simple */
    109         list_foreach(runtime_env->modules, cur) {
    110                 DPRINTF("cur = %p\n", cur);
    111                 m = list_get_instance(cur, module_t, modules_link);
     108        list_foreach(runtime_env->modules, modules_link, module_t, m) {
     109                DPRINTF("m = %p\n", m);
    112110                if (str_cmp(m->dyn.soname, soname) == 0) {
    113111                        return m; /* Found */
    … …  
    245243void modules_process_relocs(module_t *start)
    246244{
    247         module_t *m;
    248 
    249         list_foreach(runtime_env->modules, cur) {
    250                 m = list_get_instance(cur, module_t, modules_link);
    251 
     245        list_foreach(runtime_env->modules, modules_link, module_t, m) {
    252246                /* Skip rtld, since it has already been processed */
    253247                if (m != &runtime_env->rtld) {
    … …  
    261255void modules_untag(void)
    262256{
    263         module_t *m;
    264 
    265         list_foreach(runtime_env->modules, cur) {
    266                 m = list_get_instance(cur, module_t, modules_link);
     257        list_foreach(runtime_env->modules, modules_link, module_t, m) {
    267258                m->bfs_tag = false;
    268259        }

  • uspace/lib/c/generic/vfs/vfs.c

    r6297465 r4c14b88  
    342342}
    343343
    344 ssize_t read(int fildes, void *buf, size_t nbyte) 
     344ssize_t read(int fildes, void *buf, size_t nbyte)
    345345{
    346346        sysarg_t rc;
    … …  
    348348        aid_t req;
    349349       
     350        if (nbyte > DATA_XFER_LIMIT)
     351                nbyte = DATA_XFER_LIMIT;
     352       
    350353        async_exch_t *exch = vfs_exchange_begin();
    351354       
    352355        req = async_send_1(exch, VFS_IN_READ, fildes, &answer);
    353         rc = async_data_read_start(exch, (void *)buf, nbyte);
     356        rc = async_data_read_start(exch, (void *) buf, nbyte);
    354357        if (rc != EOK) {
    355358                vfs_exchange_end(exch);
    … …  
    377380        aid_t req;
    378381       
     382        if (nbyte > DATA_XFER_LIMIT)
     383                nbyte = DATA_XFER_LIMIT;
     384       
    379385        async_exch_t *exch = vfs_exchange_begin();
    380386       
    381387        req = async_send_1(exch, VFS_IN_WRITE, fildes, &answer);
    382         rc = async_data_write_start(exch, (void *)buf, nbyte);
     388        rc = async_data_write_start(exch, (void *) buf, nbyte);
    383389        if (rc != EOK) {
    384390                vfs_exchange_end(exch);
    … …  
    736742}
    737743
     744int remove(const char *path)
     745{
     746        return unlink(path);
     747}
     748
    738749int chdir(const char *path)
    739750{
Note: See TracChangeset for help on using the changeset viewer.