Changeset a2e3ee6 in mainline for uspace/lib/c


Ignore:
Timestamp:
2013-06-20T16:45:58Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
08bb73b
Parents:
19a4f73
Message:

use new network address infrastructure (towards IPv6 support)

Location:
uspace/lib/c
Files:
2 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    r19a4f73 ra2e3ee6  
    9393        generic/futex.c \
    9494        generic/inet/addr.c \
    95         generic/inet/addr2.c \
    9695        generic/inet.c \
    9796        generic/inetcfg.c \

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

    r19a4f73 ra2e3ee6  
    108108
    109109        info->cname = str_dup(cname_buf);
    110         inet2_addr_unpack(IPC_GET_ARG1(answer), &info->addr);
     110        inet_addr_unpack(IPC_GET_ARG1(answer), &info->addr);
    111111
    112112        *rinfo = info;
    … …  
    123123}
    124124
    125 int dnsr_get_srvaddr(inet2_addr_t *srvaddr)
     125int dnsr_get_srvaddr(inet_addr_t *srvaddr)
    126126{
    127127        async_exch_t *exch = dnsr_exchange_begin();
    … …  
    129129        ipc_call_t answer;
    130130        aid_t req = async_send_0(exch, DNSR_GET_SRVADDR, &answer);
    131         int rc = async_data_read_start(exch, srvaddr, sizeof(inet2_addr_t));
     131        int rc = async_data_read_start(exch, srvaddr, sizeof(inet_addr_t));
    132132       
    133133        loc_exchange_end(exch);
    … …  
    144144}
    145145
    146 int dnsr_set_srvaddr(inet2_addr_t *srvaddr)
     146int dnsr_set_srvaddr(inet_addr_t *srvaddr)
    147147{
    148148        async_exch_t *exch = dnsr_exchange_begin();
    … …  
    150150        ipc_call_t answer;
    151151        aid_t req = async_send_0(exch, DNSR_SET_SRVADDR, &answer);
    152         int rc = async_data_write_start(exch, srvaddr, sizeof(inet2_addr_t));
     152        int rc = async_data_write_start(exch, srvaddr, sizeof(inet_addr_t));
    153153       
    154154        loc_exchange_end(exch);

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

    r19a4f73 ra2e3ee6  
    107107int inet_send(inet_dgram_t *dgram, uint8_t ttl, inet_df_t df)
    108108{
    109         async_exch_t *exch = async_exchange_begin(inet_sess);
    110 
     109        uint32_t src;
     110        int rc = inet_addr_pack(&dgram->src, &src);
     111        if (rc != EOK)
     112                return rc;
     113       
     114        uint32_t dest;
     115        rc = inet_addr_pack(&dgram->dest, &dest);
     116        if (rc != EOK)
     117                return EOK;
     118       
     119        async_exch_t *exch = async_exchange_begin(inet_sess);
     120       
    111121        ipc_call_t answer;
    112         aid_t req = async_send_5(exch, INET_SEND, dgram->src.ipv4,
    113             dgram->dest.ipv4, dgram->tos, ttl, df, &answer);
    114         int rc = async_data_write_start(exch, dgram->data, dgram->size);
    115         async_exchange_end(exch);
    116 
     122        aid_t req = async_send_5(exch, INET_SEND, (sysarg_t) src,
     123            (sysarg_t) dest, dgram->tos, ttl, df, &answer);
     124        rc = async_data_write_start(exch, dgram->data, dgram->size);
     125       
     126        async_exchange_end(exch);
     127       
    117128        if (rc != EOK) {
    118129                async_forget(req);
    119130                return rc;
    120131        }
    121 
     132       
    122133        sysarg_t retval;
    123134        async_wait_for(req, &retval);
    124135        if (retval != EOK)
    125136                return retval;
    126 
     137       
    127138        return EOK;
    128139}
    … …  
    130141int inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local)
    131142{
    132         sysarg_t local_addr;
    133         async_exch_t *exch = async_exchange_begin(inet_sess);
    134 
    135         int rc = async_req_2_1(exch, INET_GET_SRCADDR, remote->ipv4,
    136             tos, &local_addr);
    137         async_exchange_end(exch);
    138 
    139         if (rc != EOK)
    140                 return rc;
    141 
    142         local->ipv4 = local_addr;
    143         return EOK;
    144 }
    145 
    146 int inet2_get_srcaddr(inet2_addr_t *remote, uint8_t tos, inet2_addr_t *local)
    147 {
    148143        uint32_t remote_addr;
    149         int rc = inet2_addr_pack(remote, &remote_addr);
     144        int rc = inet_addr_pack(remote, &remote_addr);
    150145        if (rc != EOK)
    151146                return rc;
    … …  
    162157                return rc;
    163158       
    164         inet2_addr_unpack(local_addr, local);
     159        inet_addr_unpack(local_addr, local);
    165160        return EOK;
    166161}
    … …  
    170165        int rc;
    171166        inet_dgram_t dgram;
    172 
    173         dgram.src.ipv4 = IPC_GET_ARG1(*call);
    174         dgram.dest.ipv4 = IPC_GET_ARG2(*call);
     167       
     168        inet_addr_unpack(IPC_GET_ARG1(*call), &dgram.src);
     169        inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
    175170        dgram.tos = IPC_GET_ARG3(*call);
    176171

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

    r19a4f73 ra2e3ee6  
    3434
    3535#include <errno.h>
     36#include <unistd.h>
     37#include <net/socket_codes.h>
    3638#include <inet/addr.h>
     39#include <net/inet.h>
    3740#include <stdio.h>
    3841
     42static inet_addr_t inet_addr_any_addr = {
     43        .family = AF_INET,
     44        .addr = {0, 0, 0, 0}
     45};
     46
     47static inet_addr_t inet_addr_any_addr6 = {
     48        .family = AF_INET6,
     49        .addr = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
     50};
     51
     52/** Parse network address family.
     53 *
     54 * @param text Network address in common notation.
     55 * @param af   Place to store network address family.
     56 *
     57 * @return EOK on success, EINVAL if input is not in valid format.
     58 *
     59 */
     60int inet_addr_family(const char *text, uint16_t *af)
     61{
     62        char *dot = str_chr(text, '.');
     63        if (dot != NULL) {
     64                *af = AF_INET;
     65                return EOK;
     66        }
     67       
     68        char *collon = str_chr(text, ':');
     69        if (collon != NULL) {
     70                *af = AF_INET6;
     71                return EOK;
     72        }
     73       
     74        *af = AF_NONE;
     75        return EINVAL;
     76}
     77
     78/** Parse node address.
     79 *
     80 * @param text Network address in common notation.
     81 * @param addr Place to store node address.
     82 *
     83 * @return EOK on success, EINVAL if input is not in valid format.
     84 *
     85 */
     86int inet_addr_parse(const char *text, inet_addr_t *addr)
     87{
     88        int rc = inet_addr_family(text, &addr->family);
     89        if (rc != EOK)
     90                return rc;
     91       
     92        rc = inet_pton(addr->family, text, addr->addr);
     93        if (rc != EOK)
     94                return rc;
     95       
     96        return EOK;
     97}
     98
    3999/** Parse network address.
    40100 *
    41  * @param text  Network address in CIDR notation (a.b.c.d/w)
    42  * @param naddr Place to store network address
    43  *
    44  * @return      EOK on success, EINVAL if input is not in valid format
     101 * @param text  Network address in common notation.
     102 * @param naddr Place to store network address.
     103 *
     104 * @return EOK on success, EINVAL if input is not in valid format.
     105 *
    45106 */
    46107int inet_naddr_parse(const char *text, inet_naddr_t *naddr)
    47108{
    48         unsigned long a[4], bits;
    49         char *cp = (char *)text;
    50         int i;
    51 
    52         for (i = 0; i < 3; i++) {
    53                 a[i] = strtoul(cp, &cp, 10);
    54                 if (*cp != '.')
     109        char *slash = str_chr(text, '/');
     110        if (slash == NULL)
     111                return EINVAL;
     112       
     113        *slash = 0;
     114       
     115        int rc = inet_addr_family(text, &naddr->family);
     116        if (rc != EOK)
     117                return rc;
     118       
     119        rc = inet_pton(naddr->family, text, naddr->addr);
     120        *slash = '/';
     121       
     122        if (rc != EOK)
     123                return rc;
     124       
     125        slash++;
     126       
     127        switch (naddr->family) {
     128        case AF_INET:
     129                naddr->prefix = strtoul(slash, &slash, 10);
     130                if (naddr->prefix > 32)
    55131                        return EINVAL;
    56                 ++cp;
    57         }
    58 
    59         a[3] = strtoul(cp, &cp, 10);
    60         if (*cp != '/')
    61                 return EINVAL;
    62         ++cp;
    63 
    64         bits = strtoul(cp, &cp, 10);
    65         if (*cp != '\0')
    66                 return EINVAL;
    67 
    68         naddr->ipv4 = 0;
    69         for (i = 0; i < 4; i++) {
    70                 if (a[i] > 255)
     132                break;
     133        case AF_INET6:
     134                naddr->prefix = strtoul(slash, &slash, 10);
     135                if (naddr->prefix > 128)
    71136                        return EINVAL;
    72                 naddr->ipv4 = (naddr->ipv4 << 8) | a[i];
    73         }
    74 
    75         if (bits > 31)
    76                 return EINVAL;
    77 
    78         naddr->bits = bits;
    79         return EOK;
    80 }
    81 
    82 /** Parse node address.
    83  *
    84  * @param text  Network address in dot notation (a.b.c.d)
    85  * @param addr  Place to store node address
    86  *
    87  * @return      EOK on success, EINVAL if input is not in valid format
    88  */
    89 int inet_addr_parse(const char *text, inet_addr_t *addr)
    90 {
    91         unsigned long a[4];
    92         char *cp = (char *)text;
    93         int i;
    94 
    95         for (i = 0; i < 3; i++) {
    96                 a[i] = strtoul(cp, &cp, 10);
    97                 if (*cp != '.')
    98                         return EINVAL;
    99                 ++cp;
    100         }
    101 
    102         a[3] = strtoul(cp, &cp, 10);
    103         if (*cp != '\0')
    104                 return EINVAL;
    105 
    106         addr->ipv4 = 0;
    107         for (i = 0; i < 4; i++) {
    108                 if (a[i] > 255)
    109                         return EINVAL;
    110                 addr->ipv4 = (addr->ipv4 << 8) | a[i];
    111         }
    112 
    113         return EOK;
    114 }
    115 
    116 /** Format network address.
    117  *
    118  * @param naddr Network address
    119  * @param bufp  Place to store pointer to formatted string (CIDR notation)
    120  *
    121  * @return      EOK on success, ENOMEM if out of memory.
    122  */
    123 int inet_naddr_format(inet_naddr_t *naddr, char **bufp)
     137                break;
     138        default:
     139                return ENOTSUP;
     140        }
     141       
     142        return EOK;
     143}
     144
     145/** Format node address.
     146 *
     147 * @param addr Node address.
     148 * @param bufp Place to store pointer to formatted string.
     149 *
     150 * @return EOK on success.
     151 * @return ENOMEM if out of memory.
     152 * @return ENOTSUP on unsupported address family.
     153 *
     154 */
     155int inet_addr_format(inet_addr_t *addr, char **bufp)
    124156{
    125157        int rc;
    126 
    127         rc = asprintf(bufp, "%d.%d.%d.%d/%d", naddr->ipv4 >> 24,
    128             (naddr->ipv4 >> 16) & 0xff, (naddr->ipv4 >> 8) & 0xff,
    129             naddr->ipv4 & 0xff, naddr->bits);
    130 
     158       
     159        switch (addr->family) {
     160        case AF_NONE:
     161                rc = asprintf(bufp, "none");
     162                break;
     163        case AF_INET:
     164                rc = asprintf(bufp, "%u.%u.%u.%u", addr->addr[0],
     165                    addr->addr[1], addr->addr[2], addr->addr[3]);
     166                break;
     167        case AF_INET6:
     168                // FIXME TODO
     169                break;
     170        default:
     171                return ENOTSUP;
     172        }
     173       
    131174        if (rc < 0)
    132175                return ENOMEM;
    133 
    134         return EOK;
    135 }
    136 
    137 /** Format node address.
    138  *
    139  * @param addr  Node address
    140  * @param bufp  Place to store pointer to formatted string (dot notation)
    141  *
    142  * @return      EOK on success, ENOMEM if out of memory.
    143  */
    144 int inet_addr_format(inet_addr_t *addr, char **bufp)
     176       
     177        return EOK;
     178}
     179
     180/** Format network address.
     181 *
     182 * @param naddr Network address.
     183 * @param bufp  Place to store pointer to formatted string.
     184 *
     185 * @return EOK on success.
     186 * @return ENOMEM if out of memory.
     187 * @return ENOTSUP on unsupported address family.
     188 *
     189 */
     190int inet_naddr_format(inet_naddr_t *naddr, char **bufp)
    145191{
    146192        int rc;
    147 
    148         rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
    149             (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
    150             addr->ipv4 & 0xff);
    151 
     193       
     194        switch (naddr->family) {
     195        case AF_NONE:
     196                rc = asprintf(bufp, "none");
     197                break;
     198        case AF_INET:
     199                rc = asprintf(bufp, "%u.%u.%u.%u/%u", naddr->addr[0],
     200                    naddr->addr[1], naddr->addr[2], naddr->addr[3],
     201                    naddr->prefix);
     202                break;
     203        case AF_INET6:
     204                // FIXME TODO
     205                break;
     206        default:
     207                return ENOTSUP;
     208        }
     209       
    152210        if (rc < 0)
    153211                return ENOMEM;
    154 
    155         return EOK;
     212       
     213        return EOK;
     214}
     215
     216/** Create packed IPv4 address
     217 *
     218 * Convert an IPv4 address to a packed 32 bit representation.
     219 *
     220 * @param addr   Source address.
     221 * @param packed Place to store the packed 32 bit representation.
     222 *
     223 * @return EOK on success.
     224 * @return EINVAL if addr is not an IPv4 address.
     225 *
     226 */
     227int inet_addr_pack(inet_addr_t *addr, uint32_t *packed)
     228{
     229        if (addr->family != AF_INET)
     230                return EINVAL;
     231       
     232        *packed = (addr->addr[0] << 24) | (addr->addr[1] << 16) |
     233            (addr->addr[2] << 8) | addr->addr[3];
     234        return EOK;
     235}
     236
     237/** Create packed IPv4 address
     238 *
     239 * Convert an IPv4 address to a packed 32 bit representation.
     240 *
     241 * @param naddr  Source address.
     242 * @param packed Place to store the packed 32 bit representation.
     243 * @param prefix Place to store the number of valid bits.
     244 *
     245 * @return EOK on success.
     246 * @return EINVAL if addr is not an IPv4 address.
     247 *
     248 */
     249int inet_naddr_pack(inet_naddr_t *naddr, uint32_t *packed, uint8_t *prefix)
     250{
     251        if (naddr->family != AF_INET)
     252                return EINVAL;
     253       
     254        *packed = (naddr->addr[0] << 24) | (naddr->addr[1] << 16) |
     255            (naddr->addr[2] << 8) | naddr->addr[3];
     256        *prefix = naddr->prefix;
     257       
     258        return EOK;
     259}
     260
     261void inet_addr_unpack(uint32_t packed, inet_addr_t *addr)
     262{
     263        addr->family = AF_INET;
     264        addr->addr[0] = (packed >> 24) & 0xff;
     265        addr->addr[1] = (packed >> 16) & 0xff;
     266        addr->addr[2] = (packed >> 8) & 0xff;
     267        addr->addr[3] = packed & 0xff;
     268}
     269
     270void inet_naddr_unpack(uint32_t packed, uint8_t prefix, inet_naddr_t *naddr)
     271{
     272        naddr->family = AF_INET;
     273        naddr->addr[0] = (packed >> 24) & 0xff;
     274        naddr->addr[1] = (packed >> 16) & 0xff;
     275        naddr->addr[2] = (packed >> 8) & 0xff;
     276        naddr->addr[3] = packed & 0xff;
     277        naddr->prefix = prefix;
     278}
     279
     280int inet_addr_sockaddr_in(inet_addr_t *addr, sockaddr_in_t *sockaddr_in)
     281{
     282        uint32_t packed;
     283        int rc = inet_addr_pack(addr, &packed);
     284        if (rc != EOK)
     285                return rc;
     286       
     287        sockaddr_in->sin_family = AF_INET;
     288        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(packed);
     289        return EOK;
     290}
     291
     292void inet_naddr_addr(inet_naddr_t *naddr, inet_addr_t *addr)
     293{
     294        addr->family = naddr->family;
     295        memcpy(addr->addr, naddr->addr, INET_ADDR_SIZE);
     296}
     297
     298void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
     299{
     300        addr->family = AF_INET;
     301        addr->addr[0] = a;
     302        addr->addr[1] = b;
     303        addr->addr[2] = c;
     304        addr->addr[3] = d;
     305}
     306
     307void inet_naddr(inet_naddr_t *naddr, uint8_t a, uint8_t b, uint8_t c, uint8_t d,
     308    uint8_t prefix)
     309{
     310        naddr->family = AF_INET;
     311        naddr->addr[0] = a;
     312        naddr->addr[1] = b;
     313        naddr->addr[2] = c;
     314        naddr->addr[3] = d;
     315        naddr->prefix = prefix;
     316}
     317
     318void inet_addr_any(inet_addr_t *addr)
     319{
     320        addr->family = 0;
     321        memset(addr->addr, 0, INET_ADDR_SIZE);
     322}
     323
     324void inet_naddr_any(inet_naddr_t *naddr)
     325{
     326        naddr->family = 0;
     327        memset(naddr->addr, 0, INET_ADDR_SIZE);
     328        naddr->prefix = 0;
     329}
     330
     331int inet_addr_compare(inet_addr_t *a, inet_addr_t *b)
     332{
     333        if (a->family != b->family)
     334                return 0;
     335       
     336        switch (a->family) {
     337        case AF_INET:
     338                return ((a->addr[0] == b->addr[0]) && (a->addr[1] == b->addr[1]) &&
     339                    (a->addr[2] == b->addr[2]) && (a->addr[3] == b->addr[3]));
     340        case AF_INET6:
     341                // FIXME TODO
     342                return 0;
     343        default:
     344                return 0;
     345        }
     346}
     347
     348int inet_addr_is_any(inet_addr_t *addr)
     349{
     350        return ((addr->family == 0) ||
     351            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
     352            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    156353}
    157354

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

    r19a4f73 ra2e3ee6  
    136136    sysarg_t link_id, sysarg_t *addr_id)
    137137{
    138         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    139 
    140         ipc_call_t answer;
    141         aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC, naddr->ipv4,
    142             naddr->bits, link_id, &answer);
     138        uint32_t naddr_addr;
     139        uint8_t naddr_bits;
     140        int rc = inet_naddr_pack(naddr, &naddr_addr, &naddr_bits);
     141        if (rc != EOK)
     142                return rc;
     143       
     144        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     145       
     146        ipc_call_t answer;
     147        aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC,
     148            (sysarg_t) naddr_addr, (sysarg_t) naddr_bits, link_id, &answer);
    143149        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    144 
    145         async_exchange_end(exch);
    146 
    147         if (retval != EOK) {
    148                 async_forget(req);
    149                 return retval;
    150         }
    151 
     150       
     151        async_exchange_end(exch);
     152       
     153        if (retval != EOK) {
     154                async_forget(req);
     155                return retval;
     156        }
     157       
    152158        async_wait_for(req, &retval);
    153159        *addr_id = IPC_GET_ARG1(answer);
    154 
     160       
    155161        return retval;
    156162}
    … …  
    196202        assert(act_size <= LOC_NAME_MAXLEN);
    197203        name_buf[act_size] = '\0';
    198 
    199         ainfo->naddr.ipv4 = IPC_GET_ARG1(answer);
    200         ainfo->naddr.bits = IPC_GET_ARG2(answer);
     204       
     205        inet_naddr_unpack(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     206            &ainfo->naddr);
    201207        ainfo->ilink = IPC_GET_ARG3(answer);
    202208        ainfo->name = str_dup(name_buf);
    … …  
    284290    inet_addr_t *router, sysarg_t *sroute_id)
    285291{
    286         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
    287 
     292        uint32_t dest_addr;
     293        uint8_t dest_bits;
     294        int rc = inet_naddr_pack(dest, &dest_addr, &dest_bits);
     295        if (rc != EOK)
     296                return rc;
     297       
     298        uint32_t router_addr;
     299        rc = inet_addr_pack(router, &router_addr);
     300        if (rc != EOK)
     301                return rc;
     302       
     303        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     304       
    288305        ipc_call_t answer;
    289306        aid_t req = async_send_3(exch, INETCFG_SROUTE_CREATE,
    290             dest->ipv4, dest->bits, router->ipv4, &answer);
     307            (sysarg_t) dest_addr, (sysarg_t) dest_bits, (sysarg_t) router_addr,
     308            &answer);
    291309        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
    292 
    293         async_exchange_end(exch);
    294 
    295         if (retval != EOK) {
    296                 async_forget(req);
    297                 return retval;
    298         }
    299 
     310       
     311        async_exchange_end(exch);
     312       
     313        if (retval != EOK) {
     314                async_forget(req);
     315                return retval;
     316        }
     317       
    300318        async_wait_for(req, &retval);
    301319        *sroute_id = IPC_GET_ARG1(answer);
    302 
     320       
    303321        return retval;
    304322}
    … …  
    345363        name_buf[act_size] = '\0';
    346364
    347         srinfo->dest.ipv4 = IPC_GET_ARG1(answer);
    348         srinfo->dest.bits = IPC_GET_ARG2(answer);
    349         srinfo->router.ipv4 = IPC_GET_ARG3(answer);
     365        inet_naddr_unpack(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer),
     366            &srinfo->dest);
     367        inet_addr_unpack(IPC_GET_ARG3(answer), &srinfo->router);
    350368        srinfo->name = str_dup(name_buf);
    351369

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

    r19a4f73 ra2e3ee6  
    3939#include <errno.h>
    4040#include <inet/iplink.h>
     41#include <inet/addr.h>
    4142#include <ipc/iplink.h>
    4243#include <ipc/services.h>
    … …  
    8384{
    8485        async_exch_t *exch = async_exchange_begin(iplink->sess);
    85 
     86       
    8687        ipc_call_t answer;
    87         aid_t req = async_send_2(exch, IPLINK_SEND, sdu->lsrc.ipv4,
    88             sdu->ldest.ipv4, &answer);
     88        aid_t req = async_send_2(exch, IPLINK_SEND, (sysarg_t) sdu->lsrc,
     89            (sysarg_t) sdu->ldest, &answer);
    8990        int rc = async_data_write_start(exch, sdu->data, sdu->size);
     91       
    9092        async_exchange_end(exch);
    91 
     93       
    9294        if (rc != EOK) {
    9395                async_forget(req);
    9496                return rc;
    9597        }
    96 
     98       
    9799        sysarg_t retval;
    98100        async_wait_for(req, &retval);
    99101        if (retval != EOK)
    100102                return retval;
    101 
     103       
    102104        return EOK;
    103105}
    … …  
    118120}
    119121
    120 int iplink_addr_add(iplink_t *iplink, iplink_addr_t *addr)
     122int iplink_addr_add(iplink_t *iplink, inet_addr_t *addr)
    121123{
     124        uint32_t addr_addr;
     125        int rc = inet_addr_pack(addr, &addr_addr);
     126        if (rc != EOK)
     127                return rc;
     128       
    122129        async_exch_t *exch = async_exchange_begin(iplink->sess);
    123 
    124         int rc = async_req_1_0(exch, IPLINK_ADDR_ADD, (sysarg_t)addr->ipv4);
     130        rc = async_req_1_0(exch, IPLINK_ADDR_ADD, (sysarg_t) addr_addr);
    125131        async_exchange_end(exch);
    126 
     132       
    127133        return rc;
    128134}
    129135
    130 int iplink_addr_remove(iplink_t *iplink, iplink_addr_t *addr)
     136int iplink_addr_remove(iplink_t *iplink, inet_addr_t *addr)
    131137{
     138        uint32_t addr_addr;
     139        int rc = inet_addr_pack(addr, &addr_addr);
     140        if (rc != EOK)
     141                return rc;
     142       
    132143        async_exch_t *exch = async_exchange_begin(iplink->sess);
    133 
    134         int rc = async_req_1_0(exch, IPLINK_ADDR_REMOVE, (sysarg_t)addr->ipv4);
     144        rc = async_req_1_0(exch, IPLINK_ADDR_REMOVE, (sysarg_t) addr_addr);
    135145        async_exchange_end(exch);
    136 
     146       
    137147        return rc;
    138148}
    … …  
    141151    ipc_call_t *call)
    142152{
    143         int rc;
    144153        iplink_sdu_t sdu;
    145 
    146         sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
    147         sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
    148 
    149         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     154       
     155        sdu.lsrc = IPC_GET_ARG1(*call);
     156        sdu.ldest = IPC_GET_ARG2(*call);
     157       
     158        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    150159        if (rc != EOK) {
    151160                async_answer_0(callid, rc);
    152161                return;
    153162        }
    154 
     163       
    155164        rc = iplink->ev_ops->recv(iplink, &sdu);
    156165        free(sdu.data);

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

    r19a4f73 ra2e3ee6  
    5454    ipc_call_t *call)
    5555{
    56         int rc;
    57         iplink_srv_addr_t addr;
    58 
    59         addr.ipv4 = IPC_GET_ARG1(*call);
    60 
    61         rc = srv->ops->addr_add(srv, &addr);
     56        int rc = srv->ops->addr_add(srv, IPC_GET_ARG1(*call));
    6257        async_answer_0(callid, rc);
    6358}
    … …  
    6661    ipc_call_t *call)
    6762{
    68         int rc;
    69         iplink_srv_addr_t addr;
    70 
    71         addr.ipv4 = IPC_GET_ARG1(*call);
    72 
    73         rc = srv->ops->addr_remove(srv, &addr);
     63        int rc = srv->ops->addr_remove(srv, IPC_GET_ARG1(*call));
    7464        async_answer_0(callid, rc);
    7565}
    … …  
    8171        int rc;
    8272
    83         sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
    84         sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
     73        sdu.lsrc = IPC_GET_ARG1(*call);
     74        sdu.ldest = IPC_GET_ARG2(*call);
    8575
    8676        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    … …  
    139129                if (!method) {
    140130                        /* The other side has hung up */
    141                         fibril_mutex_lock(&srv->lock);
     131                        fibril_mutex_lock(&srv->lock);
    142132                        srv->connected = false;
    143                         fibril_mutex_unlock(&srv->lock);
     133                        fibril_mutex_unlock(&srv->lock);
    144134                        async_answer_0(callid, EOK);
    145135                        break;
    … …  
    175165
    176166        ipc_call_t answer;
    177         aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4,
    178             sdu->ldest.ipv4, &answer);
     167        aid_t req = async_send_2(exch, IPLINK_EV_RECV, (sysarg_t) sdu->lsrc,
     168            (sysarg_t) sdu->ldest, &answer);
    179169        int rc = async_data_write_start(exch, sdu->data, sdu->size);
    180170        async_exchange_end(exch);

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

    r19a4f73 ra2e3ee6  
    3939#include <net/in6.h>
    4040#include <net/inet.h>
    41 
     41#include <inet/addr.h>
    4242#include <errno.h>
    4343#include <mem.h>

  • uspace/lib/c/generic/net/socket_client.c

    r19a4f73 ra2e3ee6  
    8787        /** Parent module service. */
    8888        services_t service;
     89        /** Socket family */
     90        int family;
    8991
    9092        /**
    … …  
    395397        switch (domain) {
    396398        case PF_INET:
     399        case PF_INET6:
    397400                switch (type) {
    398401                case SOCK_STREAM:
    … …  
    433436                break;
    434437
    435         case PF_INET6:
    436438        default:
    437439                return EPFNOSUPPORT;
    … …  
    447449
    448450        memset(socket, 0, sizeof(*socket));
     451        socket->family = domain;
    449452        fibril_rwlock_write_lock(&socket_globals.lock);
    450453

  • uspace/lib/c/generic/net/socket_parse.c

    r19a4f73 ra2e3ee6  
    7979int socket_parse_protocol_family(const char *name, int *pf)
    8080{
     81        if (str_lcmp(name, "PF_INET6", 8) == 0) {
     82                *pf = PF_INET6;
     83                return EOK;
     84        }
     85
    8186        if (str_lcmp(name, "PF_INET", 7) == 0) {
    8287                *pf = PF_INET;
    83                 return EOK;
    84         }
    85        
    86         if (str_lcmp(name, "PF_INET6", 8) == 0) {
    87                 *pf = PF_INET6;
    8888                return EOK;
    8989        }

  • uspace/lib/c/include/inet/addr.h

    r19a4f73 ra2e3ee6  
    3737
    3838#include <stdint.h>
     39#include <net/in.h>
     40
     41#define INET_ADDR_SIZE  16
    3942
    4043/** Node address */
    4144typedef struct {
    42         uint32_t ipv4;
     45        uint16_t family;
     46        uint8_t addr[INET_ADDR_SIZE];
    4347} inet_addr_t;
    4448
    4549/** Network address */
    4650typedef struct {
     51        /** Address family */
     52        uint16_t family;
     53       
    4754        /** Address */
    48         uint32_t ipv4;
    49         /** Number of valid bits in @c ipv4 */
    50         int bits;
     55        uint8_t addr[INET_ADDR_SIZE];
     56       
     57        /** Number of valid bits */
     58        uint8_t prefix;
    5159} inet_naddr_t;
    5260
     61extern int inet_addr_family(const char *, uint16_t *);
     62
     63extern int inet_addr_parse(const char *, inet_addr_t *);
    5364extern int inet_naddr_parse(const char *, inet_naddr_t *);
    54 extern int inet_addr_parse(const char *, inet_addr_t *);
     65
     66extern int inet_addr_format(inet_addr_t *, char **);
    5567extern int inet_naddr_format(inet_naddr_t *, char **);
    56 extern int inet_addr_format(inet_addr_t *, char **);
     68
     69extern int inet_addr_pack(inet_addr_t *, uint32_t *);
     70extern int inet_naddr_pack(inet_naddr_t *, uint32_t *, uint8_t *);
     71
     72extern void inet_addr_unpack(uint32_t, inet_addr_t *);
     73extern void inet_naddr_unpack(uint32_t, uint8_t, inet_naddr_t *);
     74
     75extern int inet_addr_sockaddr_in(inet_addr_t *, sockaddr_in_t *);
     76extern void inet_naddr_addr(inet_naddr_t *, inet_addr_t *);
     77
     78extern void inet_addr(inet_addr_t *, uint8_t, uint8_t, uint8_t, uint8_t);
     79extern void inet_naddr(inet_naddr_t *, uint8_t, uint8_t, uint8_t, uint8_t,
     80    uint8_t);
     81
     82extern void inet_addr_any(inet_addr_t *);
     83extern void inet_naddr_any(inet_naddr_t *);
     84
     85extern int inet_addr_compare(inet_addr_t *, inet_addr_t *);
     86extern int inet_addr_is_any(inet_addr_t *);
    5787
    5888#endif

  • uspace/lib/c/include/inet/dnsr.h

    r19a4f73 ra2e3ee6  
    3737
    3838#include <inet/inet.h>
    39 #include <inet/addr2.h>
     39#include <inet/addr.h>
    4040
    4141enum {
    … …  
    4747        char *cname;
    4848        /** Host address */
    49         inet2_addr_t addr;
     49        inet_addr_t addr;
    5050} dnsr_hostinfo_t;
    5151
    … …  
    5353extern int dnsr_name2host(const char *, dnsr_hostinfo_t **);
    5454extern void dnsr_hostinfo_destroy(dnsr_hostinfo_t *);
    55 extern int dnsr_get_srvaddr(inet2_addr_t *);
    56 extern int dnsr_set_srvaddr(inet2_addr_t *);
     55extern int dnsr_get_srvaddr(inet_addr_t *);
     56extern int dnsr_set_srvaddr(inet_addr_t *);
    5757
    5858#endif

  • uspace/lib/c/include/inet/inet.h

    r19a4f73 ra2e3ee6  
    3737
    3838#include <inet/addr.h>
    39 #include <inet/addr2.h>
    4039#include <sys/types.h>
    4140
    … …  
    6160extern int inet_send(inet_dgram_t *, uint8_t, inet_df_t);
    6261extern int inet_get_srcaddr(inet_addr_t *, uint8_t, inet_addr_t *);
    63 extern int inet2_get_srcaddr(inet2_addr_t *, uint8_t, inet2_addr_t *);
    6462
    6563#endif

  • uspace/lib/c/include/inet/iplink.h

    r19a4f73 ra2e3ee6  
    3838#include <async.h>
    3939#include <sys/types.h>
     40#include <inet/addr.h>
    4041
    4142struct iplink_ev_ops;
    … …  
    4647} iplink_t;
    4748
    48 typedef struct {
    49         uint32_t ipv4;
    50 } iplink_addr_t;
    51 
    52 /** IP link Service Data Unit */
     49/** IPv4 link Service Data Unit */
    5350typedef struct {
    5451        /** Local source address */
    55         iplink_addr_t lsrc;
     52        uint32_t lsrc;
    5653        /** Local destination address */
    57         iplink_addr_t ldest;
     54        uint32_t ldest;
    5855        /** Serialized IP packet */
    5956        void *data;
    … …  
    6158        size_t size;
    6259} iplink_sdu_t;
     60
     61/** IPv6 link Service Data Unit */
     62typedef struct {
     63        /** Target MAC address */
     64        uint64_t hwaddr;
     65        /** Serialized IP packet */
     66        void *data;
     67        /** Size of @c data in bytes */
     68        size_t size;
     69} iplink_sdu6_t;
    6370
    6471typedef struct iplink_ev_ops {
    … …  
    6976extern void iplink_close(iplink_t *);
    7077extern int iplink_send(iplink_t *, iplink_sdu_t *);
    71 extern int iplink_addr_add(iplink_t *, iplink_addr_t *);
    72 extern int iplink_addr_remove(iplink_t *, iplink_addr_t *);
     78extern int iplink_addr_add(iplink_t *, inet_addr_t *);
     79extern int iplink_addr_remove(iplink_t *, inet_addr_t *);
    7380extern int iplink_get_mtu(iplink_t *, size_t *);
    7481

  • uspace/lib/c/include/inet/iplink_srv.h

    r19a4f73 ra2e3ee6  
    5151} iplink_srv_t;
    5252
    53 typedef struct {
    54         uint32_t ipv4;
    55 } iplink_srv_addr_t;
    56 
    5753/** IP link Service Data Unit */
    5854typedef struct {
    5955        /** Local source address */
    60         iplink_srv_addr_t lsrc;
     56        uint32_t lsrc;
    6157        /** Local destination address */
    62         iplink_srv_addr_t ldest;
     58        uint32_t ldest;
    6359        /** Serialized IP packet */
    6460        void *data;
    … …  
    7268        int (*send)(iplink_srv_t *, iplink_srv_sdu_t *);
    7369        int (*get_mtu)(iplink_srv_t *, size_t *);
    74         int (*addr_add)(iplink_srv_t *, iplink_srv_addr_t *);
    75         int (*addr_remove)(iplink_srv_t *, iplink_srv_addr_t *);
     70        int (*addr_add)(iplink_srv_t *, uint32_t);
     71        int (*addr_remove)(iplink_srv_t *, uint32_t);
    7672} iplink_ops_t;
    7773
Note: See TracChangeset for help on using the changeset viewer.