Changeset 02a09ed in mainline for uspace/srv/net/dnsrsrv


Ignore:
Timestamp:
2013-06-28T20:20:03Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1d24ad3
Parents:
edf0d27
Message:

add basic infrastructure for IPv6 (inactive)
make inet_addr_t a universal address type

Location:
uspace/srv/net/dnsrsrv
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    redf0d27 r02a09ed  
    8484}
    8585
    86 static void dnsr_name2host_srv(dnsr_client_t *client, ipc_callid_t callid,
    87     ipc_call_t *call)
    88 {
     86static void dnsr_name2host_srv(dnsr_client_t *client, ipc_callid_t iid,
     87    ipc_call_t *icall)
     88{
     89        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
     90       
    8991        char *name;
     92        int rc = async_data_write_accept((void **) &name, true, 0,
     93            DNS_NAME_MAX_SIZE, 0, NULL);
     94        if (rc != EOK) {
     95                async_answer_0(iid, rc);
     96                return;
     97        }
     98       
    9099        dns_host_info_t *hinfo;
    91         ipc_callid_t rcallid;
    92         size_t size;
    93         sysarg_t retval;
    94         size_t act_size;
    95         int rc;
    96 
    97         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    98 
    99         rc = async_data_write_accept((void **) &name, true, 0,
    100             DNS_NAME_MAX_SIZE, 0, NULL);
    101         if (rc != EOK) {
    102                 async_answer_0(callid, rc);
    103                 return;
    104         }
    105 
    106         if (!async_data_read_receive(&rcallid, &size)) {
    107                 async_answer_0(rcallid, EREFUSED);
    108                 async_answer_0(callid, EREFUSED);
    109                 return;
    110         }
    111 
    112100        rc = dns_name2host(name, &hinfo);
    113101        if (rc != EOK) {
    114                 async_answer_0(rcallid, rc);
    115                 async_answer_0(callid, rc);
    116                 return;
    117         }
    118        
    119         uint32_t addr;
    120         rc = inet_addr_pack(&hinfo->addr, &addr);
    121         if (rc != EOK) {
    122                 async_answer_0(rcallid, rc);
    123                 async_answer_0(callid, rc);
    124                 return;
    125         }
    126 
    127         act_size = str_size(hinfo->cname);
    128         if (act_size > size) {
    129                 async_answer_0(rcallid, EOVERFLOW);
    130                 async_answer_0(callid, EOVERFLOW);
    131                 return;
    132         }
    133 
    134         retval = async_data_read_finalize(rcallid, hinfo->cname, act_size);
    135         async_answer_1(callid, retval, (sysarg_t) addr);
    136 
    137         dns_hostinfo_destroy(hinfo);
    138 }
    139 
    140 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
    141     ipc_call_t *icall)
    142 {
    143         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
     102                async_answer_0(iid, rc);
     103                return;
     104        }
    144105       
    145106        ipc_callid_t callid;
    … …  
    157118        }
    158119       
     120        rc = async_data_read_finalize(callid, &hinfo->addr, size);
     121        if (rc != EOK) {
     122                async_answer_0(callid, rc);
     123                async_answer_0(iid, rc);
     124                return;
     125        }
     126       
     127        if (!async_data_read_receive(&callid, &size)) {
     128                async_answer_0(callid, EREFUSED);
     129                async_answer_0(iid, EREFUSED);
     130                return;
     131        }
     132       
     133        size_t act_size = str_size(hinfo->cname);
     134        if (act_size > size) {
     135                async_answer_0(callid, EINVAL);
     136                async_answer_0(iid, EINVAL);
     137                return;
     138        }
     139       
     140        rc = async_data_read_finalize(callid, hinfo->cname, act_size);
     141        if (rc != EOK)
     142                async_answer_0(callid, rc);
     143       
     144        async_answer_0(iid, (sysarg_t) rc);
     145       
     146        dns_hostinfo_destroy(hinfo);
     147}
     148
     149static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
     150    ipc_call_t *icall)
     151{
     152        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
     153       
     154        ipc_callid_t callid;
     155        size_t size;
     156        if (!async_data_read_receive(&callid, &size)) {
     157                async_answer_0(callid, EREFUSED);
     158                async_answer_0(iid, EREFUSED);
     159                return;
     160        }
     161       
     162        if (size != sizeof(inet_addr_t)) {
     163                async_answer_0(callid, EINVAL);
     164                async_answer_0(iid, EINVAL);
     165                return;
     166        }
     167       
    159168        // FIXME locking
    160169       
    161         sysarg_t retval =
    162             async_data_read_finalize(callid, &dns_server_addr, size);
    163         async_answer_0(iid, retval);
     170        int rc = async_data_read_finalize(callid, &dns_server_addr, size);
     171        if (rc != EOK)
     172                async_answer_0(callid, rc);
     173       
     174        async_answer_0(iid, rc);
    164175}
    165176
    … …  
    185196        // FIXME locking
    186197       
    187         sysarg_t retval =
    188             async_data_write_finalize(callid, &dns_server_addr, size);
    189         async_answer_0(iid, retval);
     198        int rc = async_data_write_finalize(callid, &dns_server_addr, size);
     199        if (rc != EOK)
     200                async_answer_0(callid, rc);
     201       
     202        async_answer_0(iid, (sysarg_t) rc);
    190203}
    191204

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

    redf0d27 r02a09ed  
    128128
    129129                        info->cname = str_dup(rr->name);
    130                         inet_addr_unpack(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
     130                        inet_addr_set(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
    131131                            &info->addr);
    132132                       

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

    redf0d27 r02a09ed  
    183183int dns_request(dns_message_t *req, dns_message_t **rresp)
    184184{
    185         int rc;
     185        trans_req_t *treq = NULL;
     186       
    186187        void *req_data;
    187188        size_t req_size;
     189        int rc = dns_message_encode(req, &req_data, &req_size);
     190        if (rc != EOK)
     191                goto error;
     192       
    188193        struct sockaddr_in addr;
    189         trans_req_t *treq;
    190         int ntry;
    191 
    192         req_data = NULL;
    193         treq = NULL;
    194 
    195         addr.sin_family = AF_INET;
    196         addr.sin_port = htons(DNS_SERVER_PORT);
    197         inet_addr_sockaddr_in(&dns_server_addr, &addr);
    198 
    199         rc = dns_message_encode(req, &req_data, &req_size);
    200         if (rc != EOK)
    201                 goto error;
    202 
    203         ntry = 0;
    204 
     194        struct sockaddr_in6 addr6;
     195        uint16_t af =
     196            inet_addr_sockaddr_in(&dns_server_addr, &addr, &addr6);
     197       
     198        struct sockaddr *address;
     199        socklen_t addrlen;
     200       
     201        switch (af) {
     202        case AF_INET:
     203                addr.sin_port = htons(DNS_SERVER_PORT);
     204                address = (struct sockaddr *) &addr;
     205                addrlen = sizeof(addr);
     206                break;
     207        case AF_INET6:
     208                addr6.sin6_port = htons(DNS_SERVER_PORT);
     209                address = (struct sockaddr *) &addr6;
     210                addrlen = sizeof(addr6);
     211                break;
     212        default:
     213                rc = EAFNOSUPPORT;
     214                goto error;
     215        }
     216       
     217        size_t ntry = 0;
     218       
    205219        while (ntry < REQ_RETRY_MAX) {
    206220                rc = sendto(transport_fd, req_data, req_size, 0,
    207                     (struct sockaddr *) &addr, sizeof(addr));
     221                    (struct sockaddr *) address, addrlen);
    208222                if (rc != EOK)
    209223                        goto error;
Note: See TracChangeset for help on using the changeset viewer.