Ignore:
File:
1 edited

Legend:

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

    re948fde r959d2ec  
    6060        rc = transport_init();
    6161        if (rc != EOK) {
    62                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing transport.");
     62                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing tarnsport.");
    6363                return EIO;
    6464        }
     
    8484}
    8585
    86 static void dnsr_name2host_srv(dnsr_client_t *client, ipc_callid_t iid,
    87     ipc_call_t *icall)
    88 {
     86static void dnsr_name2host_srv(dnsr_client_t *client, ipc_callid_t callid,
     87    ipc_call_t *call)
     88{
     89        char *name;
     90        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
    8997        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    90        
    91         ip_ver_t ver = IPC_GET_ARG1(*icall);
    92        
    93         char *name;
    94         int rc = async_data_write_accept((void **) &name, true, 0,
     98
     99        rc = async_data_write_accept((void **) &name, true, 0,
    95100            DNS_NAME_MAX_SIZE, 0, NULL);
    96101        if (rc != EOK) {
    97                 async_answer_0(iid, rc);
    98                 return;
    99         }
    100        
    101         dns_host_info_t *hinfo;
    102         rc = dns_name2host(name, &hinfo, ver);
    103         if (rc != EOK) {
    104                 async_answer_0(iid, rc);
    105                 return;
    106         }
    107        
    108         ipc_callid_t callid;
    109         size_t size;
    110         if (!async_data_read_receive(&callid, &size)) {
     102                async_answer_0(callid, rc);
     103                return;
     104        }
     105
     106        if (!async_data_read_receive(&rcallid, &size)) {
     107                async_answer_0(rcallid, EREFUSED);
    111108                async_answer_0(callid, EREFUSED);
    112                 async_answer_0(iid, EREFUSED);
    113                 return;
    114         }
    115        
    116         if (size != sizeof(inet_addr_t)) {
    117                 async_answer_0(callid, EINVAL);
    118                 async_answer_0(iid, EINVAL);
    119                 return;
    120         }
    121        
    122         rc = async_data_read_finalize(callid, &hinfo->addr, size);
    123         if (rc != EOK) {
     109                return;
     110        }
     111
     112        rc = dns_name2host(name, &hinfo);
     113        if (rc != EOK) {
     114                async_answer_0(rcallid, rc);
    124115                async_answer_0(callid, rc);
    125                 async_answer_0(iid, rc);
    126                 return;
    127         }
    128        
    129         if (!async_data_read_receive(&callid, &size)) {
    130                 async_answer_0(callid, EREFUSED);
    131                 async_answer_0(iid, EREFUSED);
    132                 return;
    133         }
    134        
    135         size_t act_size = str_size(hinfo->cname);
     116                return;
     117        }
     118
     119        act_size = str_size(hinfo->cname);
    136120        if (act_size > size) {
    137                 async_answer_0(callid, EINVAL);
    138                 async_answer_0(iid, EINVAL);
    139                 return;
    140         }
    141        
    142         rc = async_data_read_finalize(callid, hinfo->cname, act_size);
    143         if (rc != EOK)
    144                 async_answer_0(callid, rc);
    145        
    146         async_answer_0(iid, (sysarg_t) rc);
    147        
     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
    148129        dns_hostinfo_destroy(hinfo);
    149130}
    150131
    151 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
    152     ipc_call_t *icall)
     132static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t callid,
     133    ipc_call_t *call)
    153134{
    154135        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    155        
    156         ipc_callid_t callid;
    157         size_t size;
    158         if (!async_data_read_receive(&callid, &size)) {
    159                 async_answer_0(callid, EREFUSED);
    160                 async_answer_0(iid, EREFUSED);
    161                 return;
    162         }
    163        
    164         if (size != sizeof(inet_addr_t)) {
    165                 async_answer_0(callid, EINVAL);
    166                 async_answer_0(iid, EINVAL);
    167                 return;
    168         }
    169        
    170         // FIXME locking
    171        
    172         int rc = async_data_read_finalize(callid, &dns_server_addr, size);
    173         if (rc != EOK)
    174                 async_answer_0(callid, rc);
    175        
    176         async_answer_0(iid, rc);
    177 }
    178 
    179 static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
    180     ipc_call_t *icall)
     136        async_answer_1(callid, EOK, dns_server_addr.ipv4);
     137}
     138
     139static void dnsr_set_srvaddr_srv(dnsr_client_t *client, ipc_callid_t callid,
     140    ipc_call_t *call)
    181141{
    182142        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
    183        
    184         ipc_callid_t callid;
    185         size_t size;
    186         if (!async_data_write_receive(&callid, &size)) {
    187                 async_answer_0(callid, EREFUSED);
    188                 async_answer_0(iid, EREFUSED);
    189                 return;
    190         }
    191        
    192         if (size != sizeof(inet_addr_t)) {
    193                 async_answer_0(callid, EINVAL);
    194                 async_answer_0(iid, EINVAL);
    195                 return;
    196         }
    197        
    198         // FIXME locking
    199        
    200         int rc = async_data_write_finalize(callid, &dns_server_addr, size);
    201         if (rc != EOK) {
    202                 async_answer_0(callid, rc);
    203                 async_answer_0(iid, rc);
    204         }
    205        
    206         async_answer_0(iid, (sysarg_t) rc);
     143
     144        dns_server_addr.ipv4 = IPC_GET_ARG1(*call);
     145
     146        async_answer_0(callid, EOK);
    207147}
    208148
Note: See TracChangeset for help on using the changeset viewer.