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

    r3e242d2 ra46e56b  
    335335 * @param icall    Async request data
    336336 */
    337 static void udp_callback_create_srv(udp_client_t *client, cap_call_handle_t iid,
     337static void udp_callback_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    338338    ipc_call_t *icall)
    339339{
    … …  
    342342        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    343343        if (sess == NULL) {
    344                 async_answer_0(iid, ENOMEM);
     344                async_answer_0(icall_handle, ENOMEM);
    345345                return;
    346346        }
    347347
    348348        client->sess = sess;
    349         async_answer_0(iid, EOK);
     349        async_answer_0(icall_handle, EOK);
    350350}
    351351
    … …  
    358358 * @param icall    Async request data
    359359 */
    360 static void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t iid,
     360static void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    361361    ipc_call_t *icall)
    362362{
    363         cap_call_handle_t callid;
     363        cap_call_handle_t chandle;
    364364        size_t size;
    365365        inet_ep2_t epp;
    … …  
    369369        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_srv()");
    370370
    371         if (!async_data_write_receive(&callid, &size)) {
    372                 async_answer_0(callid, EREFUSED);
    373                 async_answer_0(iid, EREFUSED);
     371        if (!async_data_write_receive(&chandle, &size)) {
     372                async_answer_0(chandle, EREFUSED);
     373                async_answer_0(icall_handle, EREFUSED);
    374374                return;
    375375        }
    376376
    377377        if (size != sizeof(inet_ep2_t)) {
    378                 async_answer_0(callid, EINVAL);
    379                 async_answer_0(iid, EINVAL);
    380                 return;
    381         }
    382 
    383         rc = async_data_write_finalize(callid, &epp, size);
    384         if (rc != EOK) {
    385                 async_answer_0(callid, rc);
    386                 async_answer_0(iid, rc);
     378                async_answer_0(chandle, EINVAL);
     379                async_answer_0(icall_handle, EINVAL);
     380                return;
     381        }
     382
     383        rc = async_data_write_finalize(chandle, &epp, size);
     384        if (rc != EOK) {
     385                async_answer_0(chandle, rc);
     386                async_answer_0(icall_handle, rc);
    387387                return;
    388388        }
    … …  
    390390        rc = udp_assoc_create_impl(client, &epp, &assoc_id);
    391391        if (rc != EOK) {
    392                 async_answer_0(iid, rc);
    393                 return;
    394         }
    395 
    396         async_answer_1(iid, EOK, assoc_id);
     392                async_answer_0(icall_handle, rc);
     393                return;
     394        }
     395
     396        async_answer_1(icall_handle, EOK, assoc_id);
    397397}
    398398
    … …  
    405405 * @param icall    Async request data
    406406 */
    407 static void udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t iid,
     407static void udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    408408    ipc_call_t *icall)
    409409{
    … …  
    415415        assoc_id = IPC_GET_ARG1(*icall);
    416416        rc = udp_assoc_destroy_impl(client, assoc_id);
    417         async_answer_0(iid, rc);
     417        async_answer_0(icall_handle, rc);
    418418}
    419419
    … …  
    426426 * @param icall    Async request data
    427427 */
    428 static void udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t iid,
     428static void udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    429429    ipc_call_t *icall)
    430430{
    … …  
    436436        assoc_id = IPC_GET_ARG1(*icall);
    437437        rc = udp_assoc_set_nolocal_impl(client, assoc_id);
    438         async_answer_0(iid, rc);
     438        async_answer_0(icall_handle, rc);
    439439}
    440440
    … …  
    447447 * @param icall    Async request data
    448448 */
    449 static void udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t iid,
     449static void udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    450450    ipc_call_t *icall)
    451451{
    452         cap_call_handle_t callid;
     452        cap_call_handle_t chandle;
    453453        size_t size;
    454454        inet_ep_t dest;
    … …  
    461461        /* Receive dest */
    462462
    463         if (!async_data_write_receive(&callid, &size)) {
    464                 async_answer_0(callid, EREFUSED);
    465                 async_answer_0(iid, EREFUSED);
     463        if (!async_data_write_receive(&chandle, &size)) {
     464                async_answer_0(chandle, EREFUSED);
     465                async_answer_0(icall_handle, EREFUSED);
    466466                return;
    467467        }
    468468
    469469        if (size != sizeof(inet_ep_t)) {
    470                 async_answer_0(callid, EINVAL);
    471                 async_answer_0(iid, EINVAL);
    472                 return;
    473         }
    474 
    475         rc = async_data_write_finalize(callid, &dest, size);
    476         if (rc != EOK) {
    477                 async_answer_0(callid, rc);
    478                 async_answer_0(iid, rc);
     470                async_answer_0(chandle, EINVAL);
     471                async_answer_0(icall_handle, EINVAL);
     472                return;
     473        }
     474
     475        rc = async_data_write_finalize(chandle, &dest, size);
     476        if (rc != EOK) {
     477                async_answer_0(chandle, rc);
     478                async_answer_0(icall_handle, rc);
    479479                return;
    480480        }
    … …  
    482482        /* Receive message data */
    483483
    484         if (!async_data_write_receive(&callid, &size)) {
    485                 async_answer_0(callid, EREFUSED);
    486                 async_answer_0(iid, EREFUSED);
     484        if (!async_data_write_receive(&chandle, &size)) {
     485                async_answer_0(chandle, EREFUSED);
     486                async_answer_0(icall_handle, EREFUSED);
    487487                return;
    488488        }
    489489
    490490        if (size > MAX_MSG_SIZE) {
    491                 async_answer_0(callid, EINVAL);
    492                 async_answer_0(iid, EINVAL);
     491                async_answer_0(chandle, EINVAL);
     492                async_answer_0(icall_handle, EINVAL);
    493493                return;
    494494        }
    … …  
    496496        data = malloc(size);
    497497        if (data == NULL) {
    498                 async_answer_0(callid, ENOMEM);
    499                 async_answer_0(iid, ENOMEM);
    500         }
    501 
    502         rc = async_data_write_finalize(callid, data, size);
    503         if (rc != EOK) {
    504                 async_answer_0(callid, rc);
    505                 async_answer_0(iid, rc);
     498                async_answer_0(chandle, ENOMEM);
     499                async_answer_0(icall_handle, ENOMEM);
     500        }
     501
     502        rc = async_data_write_finalize(chandle, data, size);
     503        if (rc != EOK) {
     504                async_answer_0(chandle, rc);
     505                async_answer_0(icall_handle, rc);
    506506                free(data);
    507507                return;
    … …  
    512512        rc = udp_assoc_send_msg_impl(client, assoc_id, &dest, data, size);
    513513        if (rc != EOK) {
    514                 async_answer_0(iid, rc);
     514                async_answer_0(icall_handle, rc);
    515515                free(data);
    516516                return;
    517517        }
    518518
    519         async_answer_0(iid, EOK);
     519        async_answer_0(icall_handle, EOK);
    520520        free(data);
    521521}
    … …  
    545545 * @param icall    Async request data
    546546 */
    547 static void udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t iid,
     547static void udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    548548    ipc_call_t *icall)
    549549{
    550         cap_call_handle_t callid;
     550        cap_call_handle_t chandle;
    551551        size_t size;
    552552        udp_crcv_queue_entry_t *enext;
    … …  
    557557        enext = udp_rmsg_get_next(client);
    558558
    559         if (!async_data_read_receive(&callid, &size)) {
    560                 async_answer_0(callid, EREFUSED);
    561                 async_answer_0(iid, EREFUSED);
     559        if (!async_data_read_receive(&chandle, &size)) {
     560                async_answer_0(chandle, EREFUSED);
     561                async_answer_0(icall_handle, EREFUSED);
    562562                return;
    563563        }
    564564
    565565        if (enext == NULL) {
    566                 async_answer_0(callid, ENOENT);
    567                 async_answer_0(iid, ENOENT);
    568                 return;
    569         }
    570 
    571         rc = async_data_read_finalize(callid, &enext->epp.remote,
     566                async_answer_0(chandle, ENOENT);
     567                async_answer_0(icall_handle, ENOENT);
     568                return;
     569        }
     570
     571        rc = async_data_read_finalize(chandle, &enext->epp.remote,
    572572            max(size, (size_t)sizeof(inet_ep_t)));
    573573        if (rc != EOK) {
    574                 async_answer_0(iid, rc);
     574                async_answer_0(icall_handle, rc);
    575575                return;
    576576        }
    … …  
    581581        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv(): assoc_id=%zu, "
    582582            "size=%zu", assoc_id, size);
    583         async_answer_2(iid, EOK, assoc_id, size);
     583        async_answer_2(icall_handle, EOK, assoc_id, size);
    584584}
    585585
    … …  
    592592 * @param icall    Async request data
    593593 */
    594 static void udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t iid,
     594static void udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    595595    ipc_call_t *icall)
    596596{
    597         cap_call_handle_t callid;
     597        cap_call_handle_t chandle;
    598598        size_t msg_size;
    599599        udp_crcv_queue_entry_t *enext;
    … …  
    608608        enext = udp_rmsg_get_next(client);
    609609
    610         if (!async_data_read_receive(&callid, &size)) {
    611                 async_answer_0(callid, EREFUSED);
    612                 async_answer_0(iid, EREFUSED);
     610        if (!async_data_read_receive(&chandle, &size)) {
     611                async_answer_0(chandle, EREFUSED);
     612                async_answer_0(icall_handle, EREFUSED);
    613613                return;
    614614        }
    615615
    616616        if (enext == NULL) {
    617                 async_answer_0(callid, ENOENT);
    618                 async_answer_0(iid, ENOENT);
     617                async_answer_0(chandle, ENOENT);
     618                async_answer_0(icall_handle, ENOENT);
    619619                return;
    620620        }
    … …  
    624624
    625625        if (off > msg_size) {
    626                 async_answer_0(callid, EINVAL);
    627                 async_answer_0(iid, EINVAL);
    628                 return;
    629         }
    630 
    631         rc = async_data_read_finalize(callid, data, min(msg_size - off, size));
    632         if (rc != EOK) {
    633                 async_answer_0(iid, rc);
    634                 return;
    635         }
    636 
    637         async_answer_0(iid, EOK);
     626                async_answer_0(chandle, EINVAL);
     627                async_answer_0(icall_handle, EINVAL);
     628                return;
     629        }
     630
     631        rc = async_data_read_finalize(chandle, data, min(msg_size - off, size));
     632        if (rc != EOK) {
     633                async_answer_0(icall_handle, rc);
     634                return;
     635        }
     636
     637        async_answer_0(icall_handle, EOK);
    638638        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv(): OK");
    639639}
    … …  
    648648 * @param icall    Async request data
    649649 */
    650 static void udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t iid,
     650static void udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    651651    ipc_call_t *icall)
    652652{
    … …  
    658658        if (enext == NULL) {
    659659                log_msg(LOG_DEFAULT, LVL_DEBUG, "usg_rmsg_discard_srv: enext==NULL");
    660                 async_answer_0(iid, ENOENT);
     660                async_answer_0(icall_handle, ENOENT);
    661661                return;
    662662        }
    … …  
    665665        udp_msg_delete(enext->msg);
    666666        free(enext);
    667         async_answer_0(iid, EOK);
     667        async_answer_0(icall_handle, EOK);
    668668}
    669669
    … …  
    674674 * @param arg   Connection argument
    675675 */
    676 static void udp_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     676static void udp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall, void *arg)
    677677{
    678678        udp_client_t client;
    … …  
    680680
    681681        /* Accept the connection */
    682         async_answer_0(iid, EOK);
     682        async_answer_0(icall_handle, EOK);
    683683
    684684        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn()");
    … …  
    691691                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: wait req");
    692692                ipc_call_t call;
    693                 cap_call_handle_t callid = async_get_call(&call);
     693                cap_call_handle_t chandle = async_get_call(&call);
    694694                sysarg_t method = IPC_GET_IMETHOD(call);
    695695
    … …  
    698698                if (!method) {
    699699                        /* The other side has hung up */
    700                         async_answer_0(callid, EOK);
     700                        async_answer_0(chandle, EOK);
    701701                        break;
    702702                }
    … …  
    704704                switch (method) {
    705705                case UDP_CALLBACK_CREATE:
    706                         udp_callback_create_srv(&client, callid, &call);
     706                        udp_callback_create_srv(&client, chandle, &call);
    707707                        break;
    708708                case UDP_ASSOC_CREATE:
    709                         udp_assoc_create_srv(&client, callid, &call);
     709                        udp_assoc_create_srv(&client, chandle, &call);
    710710                        break;
    711711                case UDP_ASSOC_DESTROY:
    712                         udp_assoc_destroy_srv(&client, callid, &call);
     712                        udp_assoc_destroy_srv(&client, chandle, &call);
    713713                        break;
    714714                case UDP_ASSOC_SET_NOLOCAL:
    715                         udp_assoc_set_nolocal_srv(&client, callid, &call);
     715                        udp_assoc_set_nolocal_srv(&client, chandle, &call);
    716716                        break;
    717717                case UDP_ASSOC_SEND_MSG:
    718                         udp_assoc_send_msg_srv(&client, callid, &call);
     718                        udp_assoc_send_msg_srv(&client, chandle, &call);
    719719                        break;
    720720                case UDP_RMSG_INFO:
    721                         udp_rmsg_info_srv(&client, callid, &call);
     721                        udp_rmsg_info_srv(&client, chandle, &call);
    722722                        break;
    723723                case UDP_RMSG_READ:
    724                         udp_rmsg_read_srv(&client, callid, &call);
     724                        udp_rmsg_read_srv(&client, chandle, &call);
    725725                        break;
    726726                case UDP_RMSG_DISCARD:
    727                         udp_rmsg_discard_srv(&client, callid, &call);
     727                        udp_rmsg_discard_srv(&client, chandle, &call);
    728728                        break;
    729729                default:
    730                         async_answer_0(callid, ENOTSUP);
     730                        async_answer_0(chandle, ENOTSUP);
    731731                        break;
    732732                }
Note: See TracChangeset for help on using the changeset viewer.