Changeset a46e56b in mainline for uspace/srv/net/inetsrv/inetping.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/inetsrv/inetping.c

    r3e242d2 ra46e56b  
    136136}
    137137
    138 static void inetping_send_srv(inetping_client_t *client, cap_call_handle_t iid,
     138static void inetping_send_srv(inetping_client_t *client, cap_call_handle_t icall_handle,
    139139    ipc_call_t *icall)
    140140{
    … …  
    146146        sdu.seq_no = IPC_GET_ARG1(*icall);
    147147
    148         cap_call_handle_t callid;
     148        cap_call_handle_t chandle;
    149149        size_t size;
    150         if (!async_data_write_receive(&callid, &size)) {
    151                 async_answer_0(callid, EREFUSED);
    152                 async_answer_0(iid, EREFUSED);
     150        if (!async_data_write_receive(&chandle, &size)) {
     151                async_answer_0(chandle, EREFUSED);
     152                async_answer_0(icall_handle, EREFUSED);
    153153                return;
    154154        }
    155155
    156156        if (size != sizeof(sdu.src)) {
    157                 async_answer_0(callid, EINVAL);
    158                 async_answer_0(iid, EINVAL);
    159                 return;
    160         }
    161 
    162         rc = async_data_write_finalize(callid, &sdu.src, size);
    163         if (rc != EOK) {
    164                 async_answer_0(callid, rc);
    165                 async_answer_0(iid, rc);
    166                 return;
    167         }
    168 
    169         if (!async_data_write_receive(&callid, &size)) {
    170                 async_answer_0(callid, EREFUSED);
    171                 async_answer_0(iid, EREFUSED);
     157                async_answer_0(chandle, EINVAL);
     158                async_answer_0(icall_handle, EINVAL);
     159                return;
     160        }
     161
     162        rc = async_data_write_finalize(chandle, &sdu.src, size);
     163        if (rc != EOK) {
     164                async_answer_0(chandle, rc);
     165                async_answer_0(icall_handle, rc);
     166                return;
     167        }
     168
     169        if (!async_data_write_receive(&chandle, &size)) {
     170                async_answer_0(chandle, EREFUSED);
     171                async_answer_0(icall_handle, EREFUSED);
    172172                return;
    173173        }
    174174
    175175        if (size != sizeof(sdu.dest)) {
    176                 async_answer_0(callid, EINVAL);
    177                 async_answer_0(iid, EINVAL);
    178                 return;
    179         }
    180 
    181         rc = async_data_write_finalize(callid, &sdu.dest, size);
    182         if (rc != EOK) {
    183                 async_answer_0(callid, rc);
    184                 async_answer_0(iid, rc);
     176                async_answer_0(chandle, EINVAL);
     177                async_answer_0(icall_handle, EINVAL);
     178                return;
     179        }
     180
     181        rc = async_data_write_finalize(chandle, &sdu.dest, size);
     182        if (rc != EOK) {
     183                async_answer_0(chandle, rc);
     184                async_answer_0(icall_handle, rc);
    185185                return;
    186186        }
    … …  
    189189            &sdu.size);
    190190        if (rc != EOK) {
    191                 async_answer_0(iid, rc);
     191                async_answer_0(icall_handle, rc);
    192192                return;
    193193        }
    … …  
    196196        free(sdu.data);
    197197
    198         async_answer_0(iid, rc);
     198        async_answer_0(icall_handle, rc);
    199199}
    200200
    201201static void inetping_get_srcaddr_srv(inetping_client_t *client,
    202     cap_call_handle_t iid, ipc_call_t *icall)
     202    cap_call_handle_t icall_handle, ipc_call_t *icall)
    203203{
    204204        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    205205
    206         cap_call_handle_t callid;
     206        cap_call_handle_t chandle;
    207207        size_t size;
    208208
    … …  
    210210        inet_addr_t remote;
    211211
    212         if (!async_data_write_receive(&callid, &size)) {
    213                 async_answer_0(callid, EREFUSED);
    214                 async_answer_0(iid, EREFUSED);
     212        if (!async_data_write_receive(&chandle, &size)) {
     213                async_answer_0(chandle, EREFUSED);
     214                async_answer_0(icall_handle, EREFUSED);
    215215                return;
    216216        }
    217217
    218218        if (size != sizeof(remote)) {
    219                 async_answer_0(callid, EINVAL);
    220                 async_answer_0(iid, EINVAL);
    221                 return;
    222         }
    223 
    224         errno_t rc = async_data_write_finalize(callid, &remote, size);
    225         if (rc != EOK) {
    226                 async_answer_0(callid, rc);
    227                 async_answer_0(iid, rc);
     219                async_answer_0(chandle, EINVAL);
     220                async_answer_0(icall_handle, EINVAL);
     221                return;
     222        }
     223
     224        errno_t rc = async_data_write_finalize(chandle, &remote, size);
     225        if (rc != EOK) {
     226                async_answer_0(chandle, rc);
     227                async_answer_0(icall_handle, rc);
    228228                return;
    229229        }
    … …  
    231231        rc = inetping_get_srcaddr(client, &remote, &local);
    232232        if (rc != EOK) {
    233                 async_answer_0(iid, rc);
    234                 return;
    235         }
    236 
    237         if (!async_data_read_receive(&callid, &size)) {
    238                 async_answer_0(callid, EREFUSED);
    239                 async_answer_0(iid, EREFUSED);
     233                async_answer_0(icall_handle, rc);
     234                return;
     235        }
     236
     237        if (!async_data_read_receive(&chandle, &size)) {
     238                async_answer_0(chandle, EREFUSED);
     239                async_answer_0(icall_handle, EREFUSED);
    240240                return;
    241241        }
    242242
    243243        if (size != sizeof(local)) {
    244                 async_answer_0(callid, EINVAL);
    245                 async_answer_0(iid, EINVAL);
    246                 return;
    247         }
    248 
    249         rc = async_data_read_finalize(callid, &local, size);
     244                async_answer_0(chandle, EINVAL);
     245                async_answer_0(icall_handle, EINVAL);
     246                return;
     247        }
     248
     249        rc = async_data_read_finalize(chandle, &local, size);
    250250        if (rc != EOK)
    251                 async_answer_0(callid, rc);
    252 
    253         async_answer_0(iid, rc);
     251                async_answer_0(chandle, rc);
     252
     253        async_answer_0(icall_handle, rc);
    254254}
    255255
    … …  
    281281}
    282282
    283 void inetping_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     283void inetping_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    284284{
    285285        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    286286
    287287        /* Accept the connection */
    288         async_answer_0(iid, EOK);
     288        async_answer_0(icall_handle, EOK);
    289289
    290290        inetping_client_t client;
    … …  
    295295        while (true) {
    296296                ipc_call_t call;
    297                 cap_call_handle_t callid = async_get_call(&call);
     297                cap_call_handle_t chandle = async_get_call(&call);
    298298                sysarg_t method = IPC_GET_IMETHOD(call);
    299299
    300300                if (!method) {
    301301                        /* The other side has hung up */
    302                         async_answer_0(callid, EOK);
     302                        async_answer_0(chandle, EOK);
    303303                        break;
    304304                }
    … …  
    306306                switch (method) {
    307307                case INETPING_SEND:
    308                         inetping_send_srv(&client, callid, &call);
     308                        inetping_send_srv(&client, chandle, &call);
    309309                        break;
    310310                case INETPING_GET_SRCADDR:
    311                         inetping_get_srcaddr_srv(&client, callid, &call);
     311                        inetping_get_srcaddr_srv(&client, chandle, &call);
    312312                        break;
    313313                default:
    314                         async_answer_0(callid, EINVAL);
     314                        async_answer_0(chandle, EINVAL);
    315315                }
    316316        }
Note: See TracChangeset for help on using the changeset viewer.