Changeset 3e66428 in mainline for uspace/lib/c


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

new network address infrastructure (towards IPv6 support)

Location:
uspace/lib/c
Files:
2 added
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    rb49d872 r3e66428  
    9393        generic/futex.c \
    9494        generic/inet/addr.c \
     95        generic/inet/addr2.c \
    9596        generic/inet.c \
    9697        generic/inetcfg.c \

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

    rb49d872 r3e66428  
    4444static async_exch_t *dnsr_exchange_begin(void)
    4545{
    46         async_sess_t *sess;
    47         service_id_t dnsr_svc;
    48 
    4946        fibril_mutex_lock(&dnsr_sess_mutex);
    50 
     47       
    5148        if (dnsr_sess == NULL) {
     49                service_id_t dnsr_svc;
     50               
    5251                (void) loc_service_get_id(SERVICE_NAME_DNSR, &dnsr_svc,
    5352                    IPC_FLAG_BLOCKING);
    54 
     53               
    5554                dnsr_sess = loc_service_connect(EXCHANGE_SERIALIZE, dnsr_svc,
    5655                    IPC_FLAG_BLOCKING);
    5756        }
    58 
    59         sess = dnsr_sess;
     57       
     58        async_sess_t *sess = dnsr_sess;
    6059        fibril_mutex_unlock(&dnsr_sess_mutex);
    61 
     60       
    6261        return async_exchange_begin(sess);
    6362}
    … …  
    109108
    110109        info->cname = str_dup(cname_buf);
    111         info->addr.ipv4 = IPC_GET_ARG1(answer);
     110        inet2_addr_unpack(IPC_GET_ARG1(answer), &info->addr);
    112111
    113112        *rinfo = info;
    … …  
    119118        if (info == NULL)
    120119                return;
    121 
     120       
    122121        free(info->cname);
    123122        free(info);
    124123}
    125124
    126 int dnsr_get_srvaddr(inet_addr_t *srvaddr)
     125int dnsr_get_srvaddr(inet2_addr_t *srvaddr)
    127126{
    128         sysarg_t addr;
    129127        async_exch_t *exch = dnsr_exchange_begin();
    130 
    131         int rc = async_req_0_1(exch, DNSR_GET_SRVADDR, &addr);
    132         dnsr_exchange_end(exch);
    133 
    134         if (rc != EOK)
     128       
     129        ipc_call_t answer;
     130        aid_t req = async_send_0(exch, DNSR_GET_SRVADDR, &answer);
     131        int rc = async_data_read_start(exch, srvaddr, sizeof(inet2_addr_t));
     132       
     133        loc_exchange_end(exch);
     134       
     135        if (rc != EOK) {
     136                async_forget(req);
    135137                return rc;
    136 
    137         srvaddr->ipv4 = addr;
    138         return EOK;
     138        }
     139       
     140        sysarg_t retval;
     141        async_wait_for(req, &retval);
     142       
     143        return (int) retval;
    139144}
    140145
    141 int dnsr_set_srvaddr(inet_addr_t *srvaddr)
     146int dnsr_set_srvaddr(inet2_addr_t *srvaddr)
    142147{
    143148        async_exch_t *exch = dnsr_exchange_begin();
    144 
    145         int rc = async_req_1_0(exch, DNSR_SET_SRVADDR, srvaddr->ipv4);
    146         dnsr_exchange_end(exch);
    147 
    148         if (rc != EOK)
     149       
     150        ipc_call_t answer;
     151        aid_t req = async_send_0(exch, DNSR_SET_SRVADDR, &answer);
     152        int rc = async_data_write_start(exch, srvaddr, sizeof(inet2_addr_t));
     153       
     154        loc_exchange_end(exch);
     155       
     156        if (rc != EOK) {
     157                async_forget(req);
    149158                return rc;
    150 
    151         return EOK;
     159        }
     160       
     161        sysarg_t retval;
     162        async_wait_for(req, &retval);
     163       
     164        return (int) retval;
    152165}
    153166

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

    rb49d872 r3e66428  
    7979{
    8080        async_exch_t *exch = async_exchange_begin(inetping_sess);
    81 
     81       
    8282        ipc_call_t answer;
    83         aid_t req = async_send_3(exch, INETPING_SEND, sdu->src.ipv4,
    84             sdu->dest.ipv4, sdu->seq_no, &answer);
     83        aid_t req = async_send_3(exch, INETPING_SEND, (sysarg_t) sdu->src,
     84            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    8585        sysarg_t retval = async_data_write_start(exch, sdu->data, sdu->size);
    86 
     86       
    8787        async_exchange_end(exch);
    88 
     88       
    8989        if (retval != EOK) {
    9090                async_forget(req);
    9191                return retval;
    9292        }
    93 
     93       
    9494        async_wait_for(req, &retval);
    9595        return retval;
    9696}
    9797
    98 int inetping_get_srcaddr(inet_addr_t *remote, inet_addr_t *local)
     98int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
    9999{
     100        async_exch_t *exch = async_exchange_begin(inetping_sess);
     101       
    100102        sysarg_t local_addr;
    101         async_exch_t *exch = async_exchange_begin(inetping_sess);
    102 
    103         int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, remote->ipv4,
     103        int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
    104104            &local_addr);
     105       
    105106        async_exchange_end(exch);
    106 
     107       
    107108        if (rc != EOK)
    108109                return rc;
    109 
    110         local->ipv4 = local_addr;
     110       
     111        *local = (uint32_t) local_addr;
    111112        return EOK;
    112113}
    … …  
    114115static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
    115116{
    116         int rc;
    117117        inetping_sdu_t sdu;
    118 
    119         sdu.src.ipv4 = IPC_GET_ARG1(*call);
    120         sdu.dest.ipv4 = IPC_GET_ARG2(*call);
     118       
     119        sdu.src = IPC_GET_ARG1(*call);
     120        sdu.dest = IPC_GET_ARG2(*call);
    121121        sdu.seq_no = IPC_GET_ARG3(*call);
    122 
    123         rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     122       
     123        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
    124124        if (rc != EOK) {
    125125                async_answer_0(callid, rc);
    126126                return;
    127127        }
    128 
     128       
    129129        rc = inetping_ev_ops->recv(&sdu);
    130130        free(sdu.data);

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

    rb49d872 r3e66428  
    9494}
    9595
     96static int inet_pton4(const char *address, uint8_t *data)
     97{
     98        memset(data, 0, 4);
     99       
     100        const char *cur = address;
     101        size_t i = 0;
     102       
     103        while (i < 4) {
     104                int rc = str_uint8_t(cur, &cur, 10, false, &data[i]);
     105                if (rc != EOK)
     106                        return rc;
     107               
     108                i++;
     109               
     110                if (*cur == 0)
     111                        break;
     112               
     113                if (*cur != '.')
     114                        return EINVAL;
     115               
     116                if (i < 4)
     117                        cur++;
     118        }
     119       
     120        if ((i == 4) && (*cur != 0))
     121                return EINVAL;
     122       
     123        return EOK;
     124}
     125
     126static int inet_pton6(const char *address, uint8_t *data)
     127{
     128        // FIXME TODO
     129        return ENOTSUP;
     130}
     131
    96132/** Parses the character string into the address.
    97133 *
    98  *  If the string is shorter than the full address, zero bytes are added.
     134 * @param[in]  family  The address family.
     135 * @param[in]  address The character buffer to be parsed.
     136 * @param[out] data    The address data to be filled.
    99137 *
    100  *  @param[in] family   The address family.
    101  *  @param[in] address  The character buffer to be parsed.
    102  *  @param[out] data    The address data to be filled.
    103  *  @return             EOK on success.
    104  *  @return             EINVAL if the data parameter is NULL.
    105  *  @return             ENOENT if the address parameter is NULL.
    106  *  @return             ENOTSUP if the address family is not supported.
     138 * @return EOK on success.
     139 * @return EINVAL if the data parameter is NULL.
     140 * @return ENOENT if the address parameter is NULL.
     141 * @return ENOTSUP if the address family is not supported.
     142 *
    107143 */
    108144int inet_pton(uint16_t family, const char *address, uint8_t *data)
    109145{
    110         /** The base number of the values. */
    111         int base;
    112         /** The number of bytes per a section. */
    113         size_t bytes;
    114         /** The number of bytes of the address data. */
    115         int count;
    116 
    117         const char *next;
    118         char *last;
    119         int index;
    120         size_t shift;
    121         unsigned long value;
    122 
    123         if (!data)
    124                 return EINVAL;
    125 
    126         /* Set processing parameters */
    127146        switch (family) {
    128147        case AF_INET:
    129                 count = 4;
    130                 base = 10;
    131                 bytes = 1;
    132                 break;
    133 
     148                return inet_pton4(address, data);
    134149        case AF_INET6:
    135                 count = 16;
    136                 base = 16;
    137                 bytes = 4;
    138                 break;
    139 
     150                return inet_pton6(address, data);
    140151        default:
     152                /** Unknown address family */
    141153                return ENOTSUP;
    142154        }
    143 
    144         /* Erase if no address */
    145         if (!address) {
    146                 memset(data, 0, count);
    147                 return ENOENT;
    148         }
    149 
    150         /* Process string from the beginning */
    151         next = address;
    152         index = 0;
    153         do {
    154                 /* If the actual character is set */
    155                 if (next && *next) {
    156 
    157                         /* If not on the first character */
    158                         if (index) {
    159                                 /* Move to the next character */
    160                                 ++next;
    161                         }
    162 
    163                         /* Parse the actual integral value */
    164                         value = strtoul(next, &last, base);
    165                         /*
    166                          * Remember the last problematic character
    167                          * should be either '.' or ':' but is ignored to be
    168                          * more generic
    169                          */
    170                         next = last;
    171 
    172                         /* Fill the address data byte by byte */
    173                         shift = bytes - 1;
    174                         do {
    175                                 /* like little endian */
    176                                 data[index + shift] = value;
    177                                 value >>= 8;
    178                         } while(shift --);
    179 
    180                         index += bytes;
    181                 } else {
    182                         /* Erase the rest of the address */
    183                         memset(data + index, 0, count - index);
    184                         return EOK;
    185                 }
    186         } while (index < count);
    187 
    188         return EOK;
    189155}
    190156

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

    rb49d872 r3e66428  
    3737
    3838#include <inet/inet.h>
     39#include <inet/addr2.h>
    3940
    4041enum {
    … …  
    4647        char *cname;
    4748        /** Host address */
    48         inet_addr_t addr;
     49        inet2_addr_t addr;
    4950} dnsr_hostinfo_t;
    5051
    … …  
    5253extern int dnsr_name2host(const char *, dnsr_hostinfo_t **);
    5354extern void dnsr_hostinfo_destroy(dnsr_hostinfo_t *);
    54 extern int dnsr_get_srvaddr(inet_addr_t *);
    55 extern int dnsr_set_srvaddr(inet_addr_t *);
     55extern int dnsr_get_srvaddr(inet2_addr_t *);
     56extern int dnsr_set_srvaddr(inet2_addr_t *);
    5657
    5758#endif

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

    rb49d872 r3e66428  
    4040
    4141typedef struct {
    42         inet_addr_t src;
    43         inet_addr_t dest;
     42        uint32_t src;
     43        uint32_t dest;
    4444        uint16_t seq_no;
    4545        void *data;
    … …  
    5353extern int inetping_init(inetping_ev_ops_t *);
    5454extern int inetping_send(inetping_sdu_t *);
    55 extern int inetping_get_srcaddr(inet_addr_t *, inet_addr_t *);
    56 
     55extern int inetping_get_srcaddr(uint32_t, uint32_t *);
    5756
    5857#endif

  • uspace/lib/c/include/net/socket_codes.h

    rb49d872 r3e66428  
    4545
    4646enum {
    47         AF_UNKNOWN = 0,
     47        AF_NONE = 0,
    4848        AF_INET,        /* IPv4 address */
    4949        AF_INET6        /* IPv6 address */
Note: See TracChangeset for help on using the changeset viewer.