Changeset 98abd40 in mainline for uspace/srv/net/dnsrsrv/dnsrsrv.c


Ignore:
Timestamp:
2013-07-06T21:57:22Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c8bb1633, cdc8a391
Parents:
b8e72fd1 (diff), 507c6f3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    rb8e72fd1 r98abd40  
    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;
     100        rc = dns_name2host(name, &hinfo);
     101        if (rc != EOK) {
     102                async_answer_0(iid, rc);
     103                return;
     104        }
     105       
     106        ipc_callid_t callid;
    92107        size_t size;
    93         sysarg_t retval;
    94         size_t act_size;
    95         int rc;
    96 
     108        if (!async_data_read_receive(&callid, &size)) {
     109                async_answer_0(callid, EREFUSED);
     110                async_answer_0(iid, EREFUSED);
     111                return;
     112        }
     113       
     114        if (size != sizeof(inet_addr_t)) {
     115                async_answer_0(callid, EINVAL);
     116                async_answer_0(iid, EINVAL);
     117                return;
     118        }
     119       
     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{
    97152        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 
    112         rc = dns_name2host(name, &hinfo);
    113         if (rc != EOK) {
    114                 async_answer_0(rcallid, rc);
    115                 async_answer_0(callid, rc);
    116                 return;
    117         }
    118 
    119         act_size = str_size(hinfo->cname);
    120         if (act_size > size) {
    121                 async_answer_0(rcallid, EOVERFLOW);
    122                 async_answer_0(callid, EOVERFLOW);
    123                 return;
    124         }
    125 
    126         retval = async_data_read_finalize(rcallid, hinfo->cname, act_size);
    127         async_answer_1(callid, retval, hinfo->addr.ipv4);
    128 
    129         dns_hostinfo_destroy(hinfo);
    130 }
    131 
    132 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t callid,
    133     ipc_call_t *call)
    134 {
    135         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)
     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       
     168        // FIXME locking
     169       
     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);
     175}
     176
     177static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
     178    ipc_call_t *icall)
    141179{
    142180        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);
     181       
     182        ipc_callid_t callid;
     183        size_t size;
     184        if (!async_data_write_receive(&callid, &size)) {
     185                async_answer_0(callid, EREFUSED);
     186                async_answer_0(iid, EREFUSED);
     187                return;
     188        }
     189       
     190        if (size != sizeof(inet_addr_t)) {
     191                async_answer_0(callid, EINVAL);
     192                async_answer_0(iid, EINVAL);
     193                return;
     194        }
     195       
     196        // FIXME locking
     197       
     198        int rc = async_data_write_finalize(callid, &dns_server_addr, size);
     199        if (rc != EOK) {
     200                async_answer_0(callid, rc);
     201                async_answer_0(iid, rc);
     202        }
     203       
     204        async_answer_0(iid, (sysarg_t) rc);
    147205}
    148206
Note: See TracChangeset for help on using the changeset viewer.