Changeset a46e56b in mainline for uspace/srv/net/dnsrsrv/dnsrsrv.c


Ignore:
Timestamp:
2018-03-22T06:49:35Z (7 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
77f0a1d
Parents:
3e242d2
git-author:
Jakub Jermar <jakub@…> (2018-03-21 23:29:06)
git-committer:
Jakub Jermar <jakub@…> (2018-03-22 06:49:35)
Message:

Prefer handle over ID in naming handle variables

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r3e242d2 ra46e56b  
    8686}
    8787
    88 static void dnsr_name2host_srv(dnsr_client_t *client, cap_call_handle_t iid,
     88static void dnsr_name2host_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    8989    ipc_call_t *icall)
    9090{
    … …  
    9797            DNS_NAME_MAX_SIZE, 0, NULL);
    9898        if (rc != EOK) {
    99                 async_answer_0(iid, rc);
     99                async_answer_0(icall_handle, rc);
    100100                return;
    101101        }
    … …  
    104104        rc = dns_name2host(name, &hinfo, ver);
    105105        if (rc != EOK) {
    106                 async_answer_0(iid, rc);
    107                 return;
    108         }
    109 
    110         cap_call_handle_t callid;
     106                async_answer_0(icall_handle, rc);
     107                return;
     108        }
     109
     110        cap_call_handle_t chandle;
    111111        size_t size;
    112         if (!async_data_read_receive(&callid, &size)) {
    113                 async_answer_0(callid, EREFUSED);
    114                 async_answer_0(iid, EREFUSED);
     112        if (!async_data_read_receive(&chandle, &size)) {
     113                async_answer_0(chandle, EREFUSED);
     114                async_answer_0(icall_handle, EREFUSED);
    115115                return;
    116116        }
    117117
    118118        if (size != sizeof(inet_addr_t)) {
    119                 async_answer_0(callid, EINVAL);
    120                 async_answer_0(iid, EINVAL);
    121                 return;
    122         }
    123 
    124         rc = async_data_read_finalize(callid, &hinfo->addr, size);
    125         if (rc != EOK) {
    126                 async_answer_0(callid, rc);
    127                 async_answer_0(iid, rc);
    128                 return;
    129         }
    130 
    131         if (!async_data_read_receive(&callid, &size)) {
    132                 async_answer_0(callid, EREFUSED);
    133                 async_answer_0(iid, EREFUSED);
     119                async_answer_0(chandle, EINVAL);
     120                async_answer_0(icall_handle, EINVAL);
     121                return;
     122        }
     123
     124        rc = async_data_read_finalize(chandle, &hinfo->addr, size);
     125        if (rc != EOK) {
     126                async_answer_0(chandle, rc);
     127                async_answer_0(icall_handle, rc);
     128                return;
     129        }
     130
     131        if (!async_data_read_receive(&chandle, &size)) {
     132                async_answer_0(chandle, EREFUSED);
     133                async_answer_0(icall_handle, EREFUSED);
    134134                return;
    135135        }
    … …  
    137137        size_t act_size = str_size(hinfo->cname);
    138138        if (act_size > size) {
    139                 async_answer_0(callid, EINVAL);
    140                 async_answer_0(iid, EINVAL);
    141                 return;
    142         }
    143 
    144         rc = async_data_read_finalize(callid, hinfo->cname, act_size);
     139                async_answer_0(chandle, EINVAL);
     140                async_answer_0(icall_handle, EINVAL);
     141                return;
     142        }
     143
     144        rc = async_data_read_finalize(chandle, hinfo->cname, act_size);
    145145        if (rc != EOK)
    146                 async_answer_0(callid, rc);
    147 
    148         async_answer_0(iid, rc);
     146                async_answer_0(chandle, rc);
     147
     148        async_answer_0(icall_handle, rc);
    149149
    150150        dns_hostinfo_destroy(hinfo);
    151151}
    152152
    153 static void dnsr_get_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t iid,
     153static void dnsr_get_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    154154    ipc_call_t *icall)
    155155{
    156156        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    157157
    158         cap_call_handle_t callid;
     158        cap_call_handle_t chandle;
    159159        size_t size;
    160         if (!async_data_read_receive(&callid, &size)) {
    161                 async_answer_0(callid, EREFUSED);
    162                 async_answer_0(iid, EREFUSED);
     160        if (!async_data_read_receive(&chandle, &size)) {
     161                async_answer_0(chandle, EREFUSED);
     162                async_answer_0(icall_handle, EREFUSED);
    163163                return;
    164164        }
    165165
    166166        if (size != sizeof(inet_addr_t)) {
    167                 async_answer_0(callid, EINVAL);
    168                 async_answer_0(iid, EINVAL);
     167                async_answer_0(chandle, EINVAL);
     168                async_answer_0(icall_handle, EINVAL);
    169169                return;
    170170        }
    … …  
    172172        // FIXME locking
    173173
    174         errno_t rc = async_data_read_finalize(callid, &dns_server_addr, size);
     174        errno_t rc = async_data_read_finalize(chandle, &dns_server_addr, size);
    175175        if (rc != EOK)
    176                 async_answer_0(callid, rc);
    177 
    178         async_answer_0(iid, rc);
    179 }
    180 
    181 static void dnsr_set_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t iid,
     176                async_answer_0(chandle, rc);
     177
     178        async_answer_0(icall_handle, rc);
     179}
     180
     181static void dnsr_set_srvaddr_srv(dnsr_client_t *client, cap_call_handle_t icall_handle,
    182182    ipc_call_t *icall)
    183183{
    184184        log_msg(LOG_DEFAULT, LVL_DEBUG, "dnsr_set_srvaddr_srv()");
    185185
    186         cap_call_handle_t callid;
     186        cap_call_handle_t chandle;
    187187        size_t size;
    188         if (!async_data_write_receive(&callid, &size)) {
    189                 async_answer_0(callid, EREFUSED);
    190                 async_answer_0(iid, EREFUSED);
     188        if (!async_data_write_receive(&chandle, &size)) {
     189                async_answer_0(chandle, EREFUSED);
     190                async_answer_0(icall_handle, EREFUSED);
    191191                return;
    192192        }
    193193
    194194        if (size != sizeof(inet_addr_t)) {
    195                 async_answer_0(callid, EINVAL);
    196                 async_answer_0(iid, EINVAL);
     195                async_answer_0(chandle, EINVAL);
     196                async_answer_0(icall_handle, EINVAL);
    197197                return;
    198198        }
    … …  
    200200        // FIXME locking
    201201
    202         errno_t rc = async_data_write_finalize(callid, &dns_server_addr, size);
    203         if (rc != EOK) {
    204                 async_answer_0(callid, rc);
    205                 async_answer_0(iid, rc);
    206         }
    207 
    208         async_answer_0(iid, rc);
    209 }
    210 
    211 static void dnsr_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     202        errno_t rc = async_data_write_finalize(chandle, &dns_server_addr, size);
     203        if (rc != EOK) {
     204                async_answer_0(chandle, rc);
     205                async_answer_0(icall_handle, rc);
     206        }
     207
     208        async_answer_0(icall_handle, rc);
     209}
     210
     211static void dnsr_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    212212{
    213213        dnsr_client_t client;
    … …  
    216216
    217217        /* Accept the connection */
    218         async_answer_0(iid, EOK);
     218        async_answer_0(icall_handle, EOK);
    219219
    220220        while (true) {
    221221                ipc_call_t call;
    222                 cap_call_handle_t callid = async_get_call(&call);
     222                cap_call_handle_t chandle = async_get_call(&call);
    223223                sysarg_t method = IPC_GET_IMETHOD(call);
    224224
    225225                if (!method) {
    226226                        /* The other side has hung up */
    227                         async_answer_0(callid, EOK);
     227                        async_answer_0(chandle, EOK);
    228228                        return;
    229229                }
    … …  
    231231                switch (method) {
    232232                case DNSR_NAME2HOST:
    233                         dnsr_name2host_srv(&client, callid, &call);
     233                        dnsr_name2host_srv(&client, chandle, &call);
    234234                        break;
    235235                case DNSR_GET_SRVADDR:
    236                         dnsr_get_srvaddr_srv(&client, callid, &call);
     236                        dnsr_get_srvaddr_srv(&client, chandle, &call);
    237237                        break;
    238238                case DNSR_SET_SRVADDR:
    239                         dnsr_set_srvaddr_srv(&client, callid, &call);
     239                        dnsr_set_srvaddr_srv(&client, chandle, &call);
    240240                        break;
    241241                default:
    242                         async_answer_0(callid, EINVAL);
     242                        async_answer_0(chandle, EINVAL);
    243243                }
    244244        }
Note: See TracChangeset for help on using the changeset viewer.