Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • TabularUnified uspace/lib/c/generic/dnsr.c

    r02a09ed r959d2ec  
    4444static async_exch_t *dnsr_exchange_begin(void)
    4545{
     46        async_sess_t *sess;
     47        service_id_t dnsr_svc;
     48
    4649        fibril_mutex_lock(&dnsr_sess_mutex);
    47        
     50
    4851        if (dnsr_sess == NULL) {
    49                 service_id_t dnsr_svc;
    50                
    5152                (void) loc_service_get_id(SERVICE_NAME_DNSR, &dnsr_svc,
    5253                    IPC_FLAG_BLOCKING);
    53                
     54
    5455                dnsr_sess = loc_service_connect(EXCHANGE_SERIALIZE, dnsr_svc,
    5556                    IPC_FLAG_BLOCKING);
    5657        }
    57        
    58         async_sess_t *sess = dnsr_sess;
     58
     59        sess = dnsr_sess;
    5960        fibril_mutex_unlock(&dnsr_sess_mutex);
    60        
     61
    6162        return async_exchange_begin(sess);
    6263}
     
    6970int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo)
    7071{
    71         dnsr_hostinfo_t *info = calloc(1, sizeof(dnsr_hostinfo_t));
     72        async_exch_t *exch = dnsr_exchange_begin();
     73        char cname_buf[DNSR_NAME_MAX_SIZE + 1];
     74        ipc_call_t cnreply;
     75        size_t act_size;
     76        dnsr_hostinfo_t *info;
     77
     78        ipc_call_t answer;
     79        aid_t req = async_send_0(exch, DNSR_NAME2HOST, &answer);
     80        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
     81        aid_t cnreq = async_data_read(exch, cname_buf, DNSR_NAME_MAX_SIZE,
     82            &cnreply);
     83
     84        dnsr_exchange_end(exch);
     85
     86        if (retval != EOK) {
     87                async_forget(req);
     88                async_forget(cnreq);
     89                return retval;
     90        }
     91
     92        async_wait_for(req, &retval);
     93        if (retval != EOK) {
     94                async_forget(cnreq);
     95                return EIO;
     96        }
     97
     98        async_wait_for(cnreq, &retval);
     99        if (retval != EOK)
     100                return EIO;
     101
     102        info = calloc(1, sizeof(dnsr_hostinfo_t));
    72103        if (info == NULL)
    73104                return ENOMEM;
    74        
    75         async_exch_t *exch = dnsr_exchange_begin();
    76        
    77         ipc_call_t answer;
    78         aid_t req = async_send_0(exch, DNSR_NAME2HOST, &answer);
    79        
    80         int rc = async_data_write_start(exch, name, str_size(name));
    81         if (rc != EOK) {
    82                 async_exchange_end(exch);
    83                 async_forget(req);
    84                 return rc;
    85         }
    86        
    87         ipc_call_t answer_addr;
    88         aid_t req_addr = async_data_read(exch, &info->addr,
    89             sizeof(inet_addr_t), &answer_addr);
    90        
    91         sysarg_t retval_addr;
    92         async_wait_for(req_addr, &retval_addr);
    93        
    94         if (retval_addr != EOK) {
    95                 async_exchange_end(exch);
    96                 async_forget(req);
    97                 return (int) retval_addr;
    98         }
    99        
    100         ipc_call_t answer_cname;
    101         char cname_buf[DNSR_NAME_MAX_SIZE + 1];
    102         aid_t req_cname = async_data_read(exch, cname_buf, DNSR_NAME_MAX_SIZE,
    103             &answer_cname);
    104        
    105         dnsr_exchange_end(exch);
    106        
    107         sysarg_t retval_cname;
    108         async_wait_for(req_cname, &retval_cname);
    109        
    110         if (retval_cname != EOK) {
    111                 async_forget(req);
    112                 return (int) retval_cname;
    113         }
    114        
    115         sysarg_t retval;
    116         async_wait_for(req, &retval);
    117        
    118         if (retval != EOK)
    119                 return (int) retval;
    120        
    121         size_t act_size = IPC_GET_ARG2(answer_cname);
     105
     106        act_size = IPC_GET_ARG2(cnreply);
    122107        assert(act_size <= DNSR_NAME_MAX_SIZE);
    123        
    124108        cname_buf[act_size] = '\0';
    125        
     109
    126110        info->cname = str_dup(cname_buf);
    127        
     111        info->addr.ipv4 = IPC_GET_ARG1(answer);
     112
    128113        *rinfo = info;
    129114        return EOK;
     
    134119        if (info == NULL)
    135120                return;
    136        
     121
    137122        free(info->cname);
    138123        free(info);
     
    141126int dnsr_get_srvaddr(inet_addr_t *srvaddr)
    142127{
     128        sysarg_t addr;
    143129        async_exch_t *exch = dnsr_exchange_begin();
    144        
    145         ipc_call_t answer;
    146         aid_t req = async_send_0(exch, DNSR_GET_SRVADDR, &answer);
    147         int rc = async_data_read_start(exch, srvaddr, sizeof(inet_addr_t));
    148        
    149         loc_exchange_end(exch);
    150        
    151         if (rc != EOK) {
    152                 async_forget(req);
     130
     131        int rc = async_req_0_1(exch, DNSR_GET_SRVADDR, &addr);
     132        dnsr_exchange_end(exch);
     133
     134        if (rc != EOK)
    153135                return rc;
    154         }
    155        
    156         sysarg_t retval;
    157         async_wait_for(req, &retval);
    158        
    159         return (int) retval;
     136
     137        srvaddr->ipv4 = addr;
     138        return EOK;
    160139}
    161140
     
    163142{
    164143        async_exch_t *exch = dnsr_exchange_begin();
    165        
    166         ipc_call_t answer;
    167         aid_t req = async_send_0(exch, DNSR_SET_SRVADDR, &answer);
    168         int rc = async_data_write_start(exch, srvaddr, sizeof(inet_addr_t));
    169        
    170         loc_exchange_end(exch);
    171        
    172         if (rc != EOK) {
    173                 async_forget(req);
     144
     145        int rc = async_req_1_0(exch, DNSR_SET_SRVADDR, srvaddr->ipv4);
     146        dnsr_exchange_end(exch);
     147
     148        if (rc != EOK)
    174149                return rc;
    175         }
    176        
    177         sysarg_t retval;
    178         async_wait_for(req, &retval);
    179        
    180         return (int) retval;
     150
     151        return EOK;
    181152}
    182153
Note: See TracChangeset for help on using the changeset viewer.