Changeset 3e66428 in mainline


Ignore:
Timestamp:
2013-06-20T14:10:51Z (11 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
Files:
2 added
20 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/dnscfg/dnscfg.c

    rb49d872 r3e66428  
    3636
    3737#include <errno.h>
    38 #include <inet/addr.h>
     38#include <inet/addr2.h>
    3939#include <inet/dnsr.h>
    4040#include <ipc/services.h>
    … …  
    4949static void print_syntax(void)
    5050{
    51         printf("syntax:\n");
    52         printf("\t" NAME " set-ns <server-addr>\n");
    53         printf("\t" NAME " unset-ns\n");
     51        printf("Syntax:\n");
     52        printf("\t%s get-ns\n", NAME);
     53        printf("\t%s set-ns <server-addr>\n", NAME);
     54        printf("\t%s unset-ns\n", NAME);
    5455}
    5556
    5657static int dnscfg_set_ns(int argc, char *argv[])
    5758{
    58         char *srv_addr;
    59         inet_addr_t addr;
    60         int rc;
    61 
    6259        if (argc < 1) {
    63                 printf(NAME ": Missing arguments.\n");
     60                printf("%s: Missing arguments.\n", NAME);
    6461                print_syntax();
    6562                return EINVAL;
    6663        }
    67 
     64       
    6865        if (argc > 1) {
    69                 printf(NAME ": Too many arguments.\n");
     66                printf("%s: Too many arguments.\n", NAME);
    7067                print_syntax();
    7168                return EINVAL;
    7269        }
    73 
    74         srv_addr = argv[0];
    75 
    76         rc = inet_addr_parse(srv_addr, &addr);
     70       
     71        char *srv_addr  = argv[0];
     72       
     73        inet2_addr_t addr;
     74        int rc = inet2_addr_parse(srv_addr, &addr);
     75       
    7776        if (rc != EOK) {
    78                 printf(NAME ": Invalid address format '%s'.\n", srv_addr);
    79                 return EINVAL;
     77                printf("%s: Invalid address format '%s'.\n", NAME, srv_addr);
     78                return rc;
    8079        }
    81 
     80       
    8281        rc = dnsr_set_srvaddr(&addr);
    8382        if (rc != EOK) {
    84                 printf(NAME ": Failed setting server address '%s' (%s)\n",
    85                     srv_addr, str_error(rc));
    86                 return EIO;
     83                printf("%s: Failed setting nameserver address '%s' (%s)\n",
     84                    NAME, srv_addr, str_error(rc));
     85                return rc;
    8786        }
    88 
     87       
    8988        return EOK;
    9089}
    9190
    92 static int dnscfg_unset_ns(int argc, char *argv[])
     91static int dnscfg_unset_ns(void)
    9392{
    94         inet_addr_t addr;
    95         int rc;
    96 
    97         if (argc > 0) {
    98                 printf(NAME ": Too many arguments.\n");
    99                 print_syntax();
    100                 return EINVAL;
     93        inet2_addr_t addr;
     94        inet2_addr_empty(&addr);
     95       
     96        int rc = dnsr_set_srvaddr(&addr);
     97        if (rc != EOK) {
     98                printf("%s: Failed unsetting server address (%s)\n",
     99                    NAME, str_error(rc));
     100                return rc;
    101101        }
    102 
    103         addr.ipv4 = 0;
    104         rc = dnsr_set_srvaddr(&addr);
    105         if (rc != EOK) {
    106                 printf(NAME ": Failed unsetting server address (%s)\n",
    107                     str_error(rc));
    108                 return EIO;
    109         }
    110 
     102       
    111103        return EOK;
    112104}
    … …  
    114106static int dnscfg_print(void)
    115107{
    116         inet_addr_t addr;
    117         char *addr_str;
    118         int rc;
    119 
    120         rc = dnsr_get_srvaddr(&addr);
     108        inet2_addr_t addr;
     109        int rc = dnsr_get_srvaddr(&addr);
    121110        if (rc != EOK) {
    122                 printf(NAME ": Failed getting DNS server address.\n");
     111                printf("%s: Failed getting DNS server address.\n", NAME);
    123112                return rc;
    124113        }
    125 
    126         rc = inet_addr_format(&addr, &addr_str);
     114       
     115        char *addr_str;
     116        rc = inet2_addr_format(&addr, &addr_str);
    127117        if (rc != EOK) {
    128                 printf(NAME ": Out of memory.\n");
     118                printf("%s: Out of memory.\n", NAME);
    129119                return rc;
    130120        }
    131 
    132         printf("Server: %s\n", addr_str);
     121       
     122        printf("Nameserver: %s\n", addr_str);
    133123        free(addr_str);
    134124        return EOK;
    … …  
    137127int main(int argc, char *argv[])
    138128{
    139         int rc;
    140 
    141         if (argc < 2) {
    142                 rc = dnscfg_print();
    143                 if (rc != EOK)
    144                         return 1;
    145                 return 0;
    146         }
    147 
    148         if (str_cmp(argv[1], "set-ns") == 0) {
    149                 rc = dnscfg_set_ns(argc - 2, argv + 2);
    150                 if (rc != EOK)
    151                         return 1;
    152         } else if (str_cmp(argv[1], "unset-ns") == 0) {
    153                 rc = dnscfg_unset_ns(argc - 2, argv + 2);
    154                 if (rc != EOK)
    155                         return 1;
    156         } else {
    157                 printf(NAME ": Unknown command '%s'.\n", argv[1]);
     129        if ((argc < 2) || (str_cmp(argv[1], "get-ns") == 0))
     130                return dnscfg_print();
     131        else if (str_cmp(argv[1], "set-ns") == 0)
     132                return dnscfg_set_ns(argc - 2, argv + 2);
     133        else if (str_cmp(argv[1], "unset-ns") == 0)
     134                return dnscfg_unset_ns();
     135        else {
     136                printf("%s: Unknown command '%s'.\n", NAME, argv[1]);
    158137                print_syntax();
    159138                return 1;
    160139        }
    161 
    162 
     140       
    163141        return 0;
    164142}

  • uspace/app/dnsres/dnsres.c

    rb49d872 r3e66428  
    3434
    3535#include <errno.h>
    36 #include <inet/addr.h>
     36#include <inet/addr2.h>
    3737#include <inet/dnsr.h>
    3838#include <stdio.h>
    … …  
    6666        }
    6767
    68         rc = inet_addr_format(&hinfo->addr, &saddr);
     68        rc = inet2_addr_format(&hinfo->addr, &saddr);
    6969        if (rc != EOK) {
    7070                dnsr_hostinfo_destroy(hinfo);

  • uspace/app/nettest1/nettest1.c

    rb49d872 r3e66428  
    359359                        return rc;
    360360                }
    361 
    362                 address_in.sin_addr.s_addr = host2uint32_t_be(hinfo->addr.ipv4);
     361               
     362                rc = inet2_addr_sockaddr_in(&hinfo->addr, &address_in);
     363                if (rc != EOK) {
     364                        printf("Host '%s' not resolved as IPv4 address.\n", argv[argc - 1]);
     365                        return rc;
     366                }
    363367        }
    364368

  • uspace/app/nettest2/nettest2.c

    rb49d872 r3e66428  
    305305                        return rc;
    306306                }
    307 
    308                 address_in.sin_addr.s_addr = host2uint32_t_be(hinfo->addr.ipv4);
     307               
     308                rc = inet2_addr_sockaddr_in(&hinfo->addr, &address_in);
     309                if (rc != EOK) {
     310                        printf("Host '%s' not resolved as IPv4 address.\n", argv[argc - 1]);
     311                        return rc;
     312                }
    309313        }
    310314

  • uspace/app/nettest3/nettest3.c

    rb49d872 r3e66428  
    8383                                return rc;
    8484                        }
    85 
    86                         addr.sin_addr.s_addr = host2uint32_t_be(hinfo->addr.ipv4);
    87                         addr.sin_family = AF_INET;
     85                       
     86                        rc = inet2_addr_sockaddr_in(&hinfo->addr, &addr);
     87                        if (rc != EOK) {
     88                                printf("Host '%s' not resolved as IPv4 address.\n", argv[1]);
     89                                return rc;
     90                        }
    8891                }
    8992                printf("result: rc=%d, family=%d, addr=%x\n", rc,

  • uspace/app/nterm/conn.c

    rb49d872 r3e66428  
    9090                        goto error;
    9191                }
    92 
    93                 addr.sin_addr.s_addr = host2uint32_t_be(hinfo->addr.ipv4);
     92               
     93                rc = inet2_addr_sockaddr_in(&hinfo->addr, &addr);
     94                if (rc != EOK) {
     95                        printf("Host '%s' not resolved as IPv4 address.\n", addr_s);
     96                        return rc;
     97                }
    9498        }
    9599

  • uspace/app/ping/ping.c

    rb49d872 r3e66428  
    6363};
    6464
    65 static inet_addr_t src_addr;
    66 static inet_addr_t dest_addr;
     65static uint32_t src;
     66static uint32_t dest;
    6767
    6868static bool ping_repeat = false;
    … …  
    8383static int ping_ev_recv(inetping_sdu_t *sdu)
    8484{
    85         char *asrc, *adest;
    86         int rc;
    87 
    88         rc = inet_addr_format(&sdu->src, &asrc);
     85        inet2_addr_t src_addr;
     86        inet2_addr_unpack(sdu->src, &src_addr);
     87       
     88        inet2_addr_t dest_addr;
     89        inet2_addr_unpack(sdu->dest, &dest_addr);
     90       
     91        char *asrc;
     92        int rc = inet2_addr_format(&src_addr, &asrc);
    8993        if (rc != EOK)
    9094                return ENOMEM;
    91 
    92         rc = inet_addr_format(&sdu->dest, &adest);
     95       
     96        char *adest;
     97        rc = inet2_addr_format(&dest_addr, &adest);
    9398        if (rc != EOK) {
    9499                free(asrc);
    95100                return ENOMEM;
    96101        }
     102       
    97103        printf("Received ICMP echo reply: from %s to %s, seq. no %u, "
    98104            "payload size %zu\n", asrc, adest, sdu->seq_no, sdu->size);
    99 
    100         if (!ping_repeat) {
     105       
     106        if (!ping_repeat)
    101107                ping_signal_done();
    102         }
    103 
     108       
    104109        free(asrc);
    105110        free(adest);
    … …  
    112117        int rc;
    113118
    114         sdu.src = src_addr;
    115         sdu.dest = dest_addr;
     119        sdu.src = src;
     120        sdu.dest = dest;
    116121        sdu.seq_no = seq_no;
    117122        sdu.data = (void *) "foo";
    … …  
    202207
    203208        /* Parse destination address */
    204         rc = inet_addr_parse(argv[argi], &dest_addr);
     209        inet2_addr_t dest_addr;
     210        rc = inet2_addr_parse(argv[argi], &dest_addr);
    205211        if (rc != EOK) {
    206212                /* Try interpreting as a host name */
    … …  
    210216                        goto error;
    211217                }
    212 
     218               
    213219                dest_addr = hinfo->addr;
    214220        }
    215 
     221       
     222        rc = inet2_addr_pack(&dest_addr, &dest);
     223        if (rc != EOK) {
     224                printf(NAME ": Destination '%s' is not an IPv4 address.\n",
     225                    argv[argi]);
     226                goto error;
     227        }
     228       
    216229        /* Determine source address */
    217         rc = inetping_get_srcaddr(&dest_addr, &src_addr);
     230        rc = inetping_get_srcaddr(dest, &src);
    218231        if (rc != EOK) {
    219232                printf(NAME ": Failed determining source address.\n");
    220233                goto error;
    221234        }
    222 
    223         rc = inet_addr_format(&src_addr, &asrc);
     235       
     236        inet2_addr_t src_addr;
     237        inet2_addr_unpack(src, &src_addr);
     238       
     239        rc = inet2_addr_format(&src_addr, &asrc);
    224240        if (rc != EOK) {
    225241                printf(NAME ": Out of memory.\n");
    226242                goto error;
    227243        }
    228 
    229         rc = inet_addr_format(&dest_addr, &adest);
     244       
     245        rc = inet2_addr_format(&dest_addr, &adest);
    230246        if (rc != EOK) {
    231247                printf(NAME ": Out of memory.\n");
    232248                goto error;
    233249        }
    234 
     250       
    235251        if (hinfo != NULL) {
    236252                rc = asprintf(&sdest, "%s (%s)", hinfo->cname, adest);
    … …  
    287303        dnsr_hostinfo_destroy(hinfo);
    288304        return 0;
     305       
    289306error:
    290307        free(asrc);

  • 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 */

  • uspace/srv/net/dnsrsrv/dns_msg.c

    rb49d872 r3e66428  
    299299        assert(buf_size >= 4);
    300300
    301         w = ((uint32_t)buf[0] << 24) +
    302             ((uint32_t)buf[1] << 16) +
    303             ((uint32_t)buf[2] << 8) +
     301        w = ((uint32_t) buf[0] << 24) +
     302            ((uint32_t) buf[1] << 16) +
     303            ((uint32_t) buf[2] << 8) +
    304304            buf[3];
    305305

  • uspace/srv/net/dnsrsrv/dns_type.h

    rb49d872 r3e66428  
    3939#include <adt/list.h>
    4040#include <inet/inet.h>
     41#include <inet/addr2.h>
    4142#include <stdbool.h>
    4243#include <stdint.h>
    … …  
    115116        char *cname;
    116117        /** Host address */
    117         inet_addr_t addr;
     118        inet2_addr_t addr;
    118119} dns_host_info_t;
    119120

  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    rb49d872 r3e66428  
    116116                return;
    117117        }
     118       
     119        uint32_t addr;
     120        rc = inet2_addr_pack(&hinfo->addr, &addr);
     121        if (rc != EOK) {
     122                async_answer_0(rcallid, rc);
     123                async_answer_0(callid, rc);
     124                return;
     125        }
    118126
    119127        act_size = str_size(hinfo->cname);
    … …  
    125133
    126134        retval = async_data_read_finalize(rcallid, hinfo->cname, act_size);
    127         async_answer_1(callid, retval, hinfo->addr.ipv4);
     135        async_answer_1(callid, retval, (sysarg_t) addr);
    128136
    129137        dns_hostinfo_destroy(hinfo);
    130138}
    131139
    132 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t callid,
    133     ipc_call_t *call)
     140static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
     141    ipc_call_t *icall)
    134142{
    135143        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    136         async_answer_1(callid, EOK, dns_server_addr.ipv4);
    137 }
    138 
    139 static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_callid_t callid,
    140     ipc_call_t *call)
     144       
     145        ipc_callid_t callid;
     146        size_t size;
     147        if (!async_data_read_receive(&callid, &size)) {
     148                async_answer_0(callid, EREFUSED);
     149                async_answer_0(iid, EREFUSED);
     150                return;
     151        }
     152       
     153        if (size != sizeof(inet2_addr_t)) {
     154                async_answer_0(callid, EINVAL);
     155                async_answer_0(iid, EINVAL);
     156                return;
     157        }
     158       
     159        // FIXME locking
     160       
     161        sysarg_t retval =
     162            async_data_read_finalize(callid, &dns_server_addr, size);
     163        async_answer_0(iid, retval);
     164}
     165
     166static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
     167    ipc_call_t *icall)
    141168{
    142169        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
    143 
    144         dns_server_addr.ipv4 = IPC_GET_ARG1(*call);
    145 
    146         async_answer_0(callid, EOK);
     170       
     171        ipc_callid_t callid;
     172        size_t size;
     173        if (!async_data_write_receive(&callid, &size)) {
     174                async_answer_0(callid, EREFUSED);
     175                async_answer_0(iid, EREFUSED);
     176                return;
     177        }
     178       
     179        if (size != sizeof(inet2_addr_t)) {
     180                async_answer_0(callid, EINVAL);
     181                async_answer_0(iid, EINVAL);
     182                return;
     183        }
     184       
     185        // FIXME locking
     186       
     187        sysarg_t retval =
     188            async_data_write_finalize(callid, &dns_server_addr, size);
     189        async_answer_0(iid, retval);
    147190}
    148191

  • uspace/srv/net/dnsrsrv/query.c

    rb49d872 r3e66428  
    128128
    129129                        info->cname = str_dup(rr->name);
    130                         info->addr.ipv4 = dns_uint32_t_decode(rr->rdata, rr->rdata_size);
    131                         log_msg(LOG_DEFAULT, LVL_DEBUG, "info->name = '%s' "
    132                             "info->addr = %x", info->cname, info->addr.ipv4);
    133 
     130                        inet2_addr_unpack(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
     131                            &info->addr);
     132                       
    134133                        dns_message_destroy(msg);
    135134                        dns_message_destroy(amsg);

  • uspace/srv/net/dnsrsrv/transport.c

    rb49d872 r3e66428  
    5252
    5353/** Request timeout (microseconds) */
    54 #define REQ_TIMEOUT (5*1000*1000)
     54#define REQ_TIMEOUT (5 * 1000 * 1000)
    5555
    5656/** Maximum number of retries */
    5757#define REQ_RETRY_MAX 3
     58
     59inet2_addr_t dns_server_addr;
    5860
    5961typedef struct {
    … …  
    7274static fid_t recv_fid;
    7375static int transport_fd = -1;
    74 inet_addr_t dns_server_addr;
    7576
    7677/** Outstanding requests */
    … …  
    194195        addr.sin_family = AF_INET;
    195196        addr.sin_port = htons(DNS_SERVER_PORT);
    196         addr.sin_addr.s_addr = host2uint32_t_be(dns_server_addr.ipv4);
     197        inet2_addr_sockaddr_in(&dns_server_addr, &addr);
    197198
    198199        rc = dns_message_encode(req, &req_data, &req_size);
    … …  
    204205        while (ntry < REQ_RETRY_MAX) {
    205206                rc = sendto(transport_fd, req_data, req_size, 0,
    206                     (struct sockaddr *)&addr, sizeof(addr));
     207                    (struct sockaddr *) &addr, sizeof(addr));
    207208                if (rc != EOK)
    208209                        goto error;

  • uspace/srv/net/dnsrsrv/transport.h

    rb49d872 r3e66428  
    3737#define TRANSPORT_H
    3838
    39 #include <inet/addr.h>
     39#include <inet/addr2.h>
    4040#include "dns_type.h"
     41
     42extern inet2_addr_t dns_server_addr;
    4143
    4244extern int transport_init(void);
    … …  
    4446extern int dns_request(dns_message_t *, dns_message_t **);
    4547
    46 extern inet_addr_t dns_server_addr;
    47 
    48 
    4948#endif
    5049
Note: See TracChangeset for help on using the changeset viewer.