Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/udp/service.c

    rb752a31 r5a6cc679  
    331331 * Handle client request to create callback session.
    332332 *
    333  * @param client        UDP client
    334  * @param icall_handle  Async request call handle
    335  * @param icall         Async request data
    336  */
    337 static void
    338 udp_callback_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     333 * @param client   UDP client
     334 * @param iid      Async request ID
     335 * @param icall    Async request data
     336 */
     337static void udp_callback_create_srv(udp_client_t *client, ipc_callid_t iid,
    339338    ipc_call_t *icall)
    340339{
    … …  
    343342        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    344343        if (sess == NULL) {
    345                 async_answer_0(icall_handle, ENOMEM);
     344                async_answer_0(iid, ENOMEM);
    346345                return;
    347346        }
    348347
    349348        client->sess = sess;
    350         async_answer_0(icall_handle, EOK);
     349        async_answer_0(iid, EOK);
    351350}
    352351
    … …  
    355354 * Handle client request to create association.
    356355 *
    357  * @param client        UDP client
    358  * @param icall_handle  Async request call handle
    359  * @param icall         Async request data
    360  */
    361 static
    362 void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     356 * @param client   UDP client
     357 * @param iid      Async request ID
     358 * @param icall    Async request data
     359 */
     360static void udp_assoc_create_srv(udp_client_t *client, ipc_callid_t iid,
    363361    ipc_call_t *icall)
    364362{
    365         cap_call_handle_t chandle;
     363        ipc_callid_t callid;
    366364        size_t size;
    367365        inet_ep2_t epp;
    … …  
    371369        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_srv()");
    372370
    373         if (!async_data_write_receive(&chandle, &size)) {
    374                 async_answer_0(chandle, EREFUSED);
    375                 async_answer_0(icall_handle, EREFUSED);
     371        if (!async_data_write_receive(&callid, &size)) {
     372                async_answer_0(callid, EREFUSED);
     373                async_answer_0(iid, EREFUSED);
    376374                return;
    377375        }
    378376
    379377        if (size != sizeof(inet_ep2_t)) {
    380                 async_answer_0(chandle, EINVAL);
    381                 async_answer_0(icall_handle, EINVAL);
    382                 return;
    383         }
    384 
    385         rc = async_data_write_finalize(chandle, &epp, size);
    386         if (rc != EOK) {
    387                 async_answer_0(chandle, rc);
    388                 async_answer_0(icall_handle, rc);
     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);
    389387                return;
    390388        }
    … …  
    392390        rc = udp_assoc_create_impl(client, &epp, &assoc_id);
    393391        if (rc != EOK) {
    394                 async_answer_0(icall_handle, rc);
    395                 return;
    396         }
    397 
    398         async_answer_1(icall_handle, EOK, assoc_id);
     392                async_answer_0(iid, rc);
     393                return;
     394        }
     395
     396        async_answer_1(iid, EOK, assoc_id);
    399397}
    400398
    … …  
    403401 * Handle client request to destroy association.
    404402 *
    405  * @param client        UDP client
    406  * @param icall_handle  Async request call handle
    407  * @param icall         Async request data
    408  */
    409 static void
    410 udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     403 * @param client   UDP client
     404 * @param iid      Async request ID
     405 * @param icall    Async request data
     406 */
     407static void udp_assoc_destroy_srv(udp_client_t *client, ipc_callid_t iid,
    411408    ipc_call_t *icall)
    412409{
    … …  
    418415        assoc_id = IPC_GET_ARG1(*icall);
    419416        rc = udp_assoc_destroy_impl(client, assoc_id);
    420         async_answer_0(icall_handle, rc);
     417        async_answer_0(iid, rc);
    421418}
    422419
    … …  
    425422 * Handle client request to set no local address flag.
    426423 *
    427  * @param client        UDP client
    428  * @param icall_handle  Async request call handle
    429  * @param icall         Async request data
    430  */
    431 static void
    432 udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     424 * @param client   UDP client
     425 * @param iid      Async request ID
     426 * @param icall    Async request data
     427 */
     428static void udp_assoc_set_nolocal_srv(udp_client_t *client, ipc_callid_t iid,
    433429    ipc_call_t *icall)
    434430{
    … …  
    440436        assoc_id = IPC_GET_ARG1(*icall);
    441437        rc = udp_assoc_set_nolocal_impl(client, assoc_id);
    442         async_answer_0(icall_handle, rc);
     438        async_answer_0(iid, rc);
    443439}
    444440
    … …  
    447443 * Handle client request to send message.
    448444 *
    449  * @param client        UDP client
    450  * @param icall_handle  Async request call handle
    451  * @param icall         Async request data
    452  */
    453 static void
    454 udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     445 * @param client   UDP client
     446 * @param iid      Async request ID
     447 * @param icall    Async request data
     448 */
     449static void udp_assoc_send_msg_srv(udp_client_t *client, ipc_callid_t iid,
    455450    ipc_call_t *icall)
    456451{
    457         cap_call_handle_t chandle;
     452        ipc_callid_t callid;
    458453        size_t size;
    459454        inet_ep_t dest;
    … …  
    466461        /* Receive dest */
    467462
    468         if (!async_data_write_receive(&chandle, &size)) {
    469                 async_answer_0(chandle, EREFUSED);
    470                 async_answer_0(icall_handle, EREFUSED);
     463        if (!async_data_write_receive(&callid, &size)) {
     464                async_answer_0(callid, EREFUSED);
     465                async_answer_0(iid, EREFUSED);
    471466                return;
    472467        }
    473468
    474469        if (size != sizeof(inet_ep_t)) {
    475                 async_answer_0(chandle, EINVAL);
    476                 async_answer_0(icall_handle, EINVAL);
    477                 return;
    478         }
    479 
    480         rc = async_data_write_finalize(chandle, &dest, size);
    481         if (rc != EOK) {
    482                 async_answer_0(chandle, rc);
    483                 async_answer_0(icall_handle, rc);
     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);
    484479                return;
    485480        }
    … …  
    487482        /* Receive message data */
    488483
    489         if (!async_data_write_receive(&chandle, &size)) {
    490                 async_answer_0(chandle, EREFUSED);
    491                 async_answer_0(icall_handle, EREFUSED);
     484        if (!async_data_write_receive(&callid, &size)) {
     485                async_answer_0(callid, EREFUSED);
     486                async_answer_0(iid, EREFUSED);
    492487                return;
    493488        }
    494489
    495490        if (size > MAX_MSG_SIZE) {
    496                 async_answer_0(chandle, EINVAL);
    497                 async_answer_0(icall_handle, EINVAL);
     491                async_answer_0(callid, EINVAL);
     492                async_answer_0(iid, EINVAL);
    498493                return;
    499494        }
    … …  
    501496        data = malloc(size);
    502497        if (data == NULL) {
    503                 async_answer_0(chandle, ENOMEM);
    504                 async_answer_0(icall_handle, ENOMEM);
    505         }
    506 
    507         rc = async_data_write_finalize(chandle, data, size);
    508         if (rc != EOK) {
    509                 async_answer_0(chandle, rc);
    510                 async_answer_0(icall_handle, rc);
     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);
    511506                free(data);
    512507                return;
    … …  
    517512        rc = udp_assoc_send_msg_impl(client, assoc_id, &dest, data, size);
    518513        if (rc != EOK) {
    519                 async_answer_0(icall_handle, rc);
     514                async_answer_0(iid, rc);
    520515                free(data);
    521516                return;
    522517        }
    523518
    524         async_answer_0(icall_handle, EOK);
     519        async_answer_0(iid, EOK);
    525520        free(data);
    526521}
    … …  
    546541 * Handle client request to get information on received message.
    547542 *
    548  * @param client        UDP client
    549  * @param icall_handle  Async request call handle
    550  * @param icall         Async request data
    551  */
    552 static void
    553 udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     543 * @param client   UDP client
     544 * @param iid      Async request ID
     545 * @param icall    Async request data
     546 */
     547static void udp_rmsg_info_srv(udp_client_t *client, ipc_callid_t iid,
    554548    ipc_call_t *icall)
    555549{
    556         cap_call_handle_t chandle;
     550        ipc_callid_t callid;
    557551        size_t size;
    558552        udp_crcv_queue_entry_t *enext;
    … …  
    563557        enext = udp_rmsg_get_next(client);
    564558
    565         if (!async_data_read_receive(&chandle, &size)) {
    566                 async_answer_0(chandle, EREFUSED);
    567                 async_answer_0(icall_handle, EREFUSED);
     559        if (!async_data_read_receive(&callid, &size)) {
     560                async_answer_0(callid, EREFUSED);
     561                async_answer_0(iid, EREFUSED);
    568562                return;
    569563        }
    570564
    571565        if (enext == NULL) {
    572                 async_answer_0(chandle, ENOENT);
    573                 async_answer_0(icall_handle, ENOENT);
    574                 return;
    575         }
    576 
    577         rc = async_data_read_finalize(chandle, &enext->epp.remote,
     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,
    578572            max(size, (size_t)sizeof(inet_ep_t)));
    579573        if (rc != EOK) {
    580                 async_answer_0(icall_handle, rc);
     574                async_answer_0(iid, rc);
    581575                return;
    582576        }
    … …  
    587581        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv(): assoc_id=%zu, "
    588582            "size=%zu", assoc_id, size);
    589         async_answer_2(icall_handle, EOK, assoc_id, size);
     583        async_answer_2(iid, EOK, assoc_id, size);
    590584}
    591585
    … …  
    594588 * Handle client request to read data from first received message.
    595589 *
    596  * @param client        UDP client
    597  * @param icall_handle  Async request call handle
    598  * @param icall         Async request data
    599  */
    600 static void
    601 udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     590 * @param client   UDP client
     591 * @param iid      Async request ID
     592 * @param icall    Async request data
     593 */
     594static void udp_rmsg_read_srv(udp_client_t *client, ipc_callid_t iid,
    602595    ipc_call_t *icall)
    603596{
    604         cap_call_handle_t chandle;
     597        ipc_callid_t callid;
    605598        size_t msg_size;
    606599        udp_crcv_queue_entry_t *enext;
    … …  
    615608        enext = udp_rmsg_get_next(client);
    616609
    617         if (!async_data_read_receive(&chandle, &size)) {
    618                 async_answer_0(chandle, EREFUSED);
    619                 async_answer_0(icall_handle, EREFUSED);
     610        if (!async_data_read_receive(&callid, &size)) {
     611                async_answer_0(callid, EREFUSED);
     612                async_answer_0(iid, EREFUSED);
    620613                return;
    621614        }
    622615
    623616        if (enext == NULL) {
    624                 async_answer_0(chandle, ENOENT);
    625                 async_answer_0(icall_handle, ENOENT);
     617                async_answer_0(callid, ENOENT);
     618                async_answer_0(iid, ENOENT);
    626619                return;
    627620        }
    … …  
    631624
    632625        if (off > msg_size) {
    633                 async_answer_0(chandle, EINVAL);
    634                 async_answer_0(icall_handle, EINVAL);
    635                 return;
    636         }
    637 
    638         rc = async_data_read_finalize(chandle, data, min(msg_size - off, size));
    639         if (rc != EOK) {
    640                 async_answer_0(icall_handle, rc);
    641                 return;
    642         }
    643 
    644         async_answer_0(icall_handle, EOK);
     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);
    645638        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv(): OK");
    646639}
    … …  
    651644 * to the next one.
    652645 *
    653  * @param client        UDP client
    654  * @param icall_handle  Async request call handle
    655  * @param icall         Async request data
    656  */
    657 static void
    658 udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t icall_handle,
     646 * @param client   UDP client
     647 * @param iid      Async request ID
     648 * @param icall    Async request data
     649 */
     650static void udp_rmsg_discard_srv(udp_client_t *client, ipc_callid_t iid,
    659651    ipc_call_t *icall)
    660652{
    … …  
    666658        if (enext == NULL) {
    667659                log_msg(LOG_DEFAULT, LVL_DEBUG, "usg_rmsg_discard_srv: enext==NULL");
    668                 async_answer_0(icall_handle, ENOENT);
     660                async_answer_0(iid, ENOENT);
    669661                return;
    670662        }
    … …  
    673665        udp_msg_delete(enext->msg);
    674666        free(enext);
    675         async_answer_0(icall_handle, EOK);
     667        async_answer_0(iid, EOK);
    676668}
    677669
    678670/** Handle UDP client connection.
    679671 *
    680  * @param icall_handle  Connect call handle
    681  * @param icall         Connect call data
    682  * @param arg           Connection argument
    683  */
    684 static void udp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
    685     void *arg)
     672 * @param iid   Connect call ID
     673 * @param icall Connect call data
     674 * @param arg   Connection argument
     675 */
     676static void udp_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    686677{
    687678        udp_client_t client;
    … …  
    689680
    690681        /* Accept the connection */
    691         async_answer_0(icall_handle, EOK);
     682        async_answer_0(iid, EOK);
    692683
    693684        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn()");
    … …  
    700691                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: wait req");
    701692                ipc_call_t call;
    702                 cap_call_handle_t chandle = async_get_call(&call);
     693                ipc_callid_t callid = async_get_call(&call);
    703694                sysarg_t method = IPC_GET_IMETHOD(call);
    704695
    … …  
    707698                if (!method) {
    708699                        /* The other side has hung up */
    709                         async_answer_0(chandle, EOK);
     700                        async_answer_0(callid, EOK);
    710701                        break;
    711702                }
    … …  
    713704                switch (method) {
    714705                case UDP_CALLBACK_CREATE:
    715                         udp_callback_create_srv(&client, chandle, &call);
     706                        udp_callback_create_srv(&client, callid, &call);
    716707                        break;
    717708                case UDP_ASSOC_CREATE:
    718                         udp_assoc_create_srv(&client, chandle, &call);
     709                        udp_assoc_create_srv(&client, callid, &call);
    719710                        break;
    720711                case UDP_ASSOC_DESTROY:
    721                         udp_assoc_destroy_srv(&client, chandle, &call);
     712                        udp_assoc_destroy_srv(&client, callid, &call);
    722713                        break;
    723714                case UDP_ASSOC_SET_NOLOCAL:
    724                         udp_assoc_set_nolocal_srv(&client, chandle, &call);
     715                        udp_assoc_set_nolocal_srv(&client, callid, &call);
    725716                        break;
    726717                case UDP_ASSOC_SEND_MSG:
    727                         udp_assoc_send_msg_srv(&client, chandle, &call);
     718                        udp_assoc_send_msg_srv(&client, callid, &call);
    728719                        break;
    729720                case UDP_RMSG_INFO:
    730                         udp_rmsg_info_srv(&client, chandle, &call);
     721                        udp_rmsg_info_srv(&client, callid, &call);
    731722                        break;
    732723                case UDP_RMSG_READ:
    733                         udp_rmsg_read_srv(&client, chandle, &call);
     724                        udp_rmsg_read_srv(&client, callid, &call);
    734725                        break;
    735726                case UDP_RMSG_DISCARD:
    736                         udp_rmsg_discard_srv(&client, chandle, &call);
     727                        udp_rmsg_discard_srv(&client, callid, &call);
    737728                        break;
    738729                default:
    739                         async_answer_0(chandle, ENOTSUP);
     730                        async_answer_0(callid, ENOTSUP);
    740731                        break;
    741732                }
Note: See TracChangeset for help on using the changeset viewer.