Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r5a6cc679 rb752a31  
    331331 * Handle client request to create callback session.
    332332 *
    333  * @param client   UDP client
    334  * @param iid      Async request ID
    335  * @param icall    Async request data
    336  */
    337 static void udp_callback_create_srv(udp_client_t *client, ipc_callid_t iid,
     333 * @param client        UDP client
     334 * @param icall_handle  Async request call handle
     335 * @param icall         Async request data
     336 */
     337static void
     338udp_callback_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    338339    ipc_call_t *icall)
    339340{
    … …  
    342343        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    343344        if (sess == NULL) {
    344                 async_answer_0(iid, ENOMEM);
     345                async_answer_0(icall_handle, ENOMEM);
    345346                return;
    346347        }
    347348
    348349        client->sess = sess;
    349         async_answer_0(iid, EOK);
     350        async_answer_0(icall_handle, EOK);
    350351}
    351352
    … …  
    354355 * Handle client request to create association.
    355356 *
    356  * @param client   UDP client
    357  * @param iid      Async request ID
    358  * @param icall    Async request data
    359  */
    360 static void udp_assoc_create_srv(udp_client_t *client, ipc_callid_t iid,
     357 * @param client        UDP client
     358 * @param icall_handle  Async request call handle
     359 * @param icall         Async request data
     360 */
     361static
     362void udp_assoc_create_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    361363    ipc_call_t *icall)
    362364{
    363         ipc_callid_t callid;
     365        cap_call_handle_t chandle;
    364366        size_t size;
    365367        inet_ep2_t epp;
    … …  
    369371        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_create_srv()");
    370372
    371         if (!async_data_write_receive(&callid, &size)) {
    372                 async_answer_0(callid, EREFUSED);
    373                 async_answer_0(iid, EREFUSED);
     373        if (!async_data_write_receive(&chandle, &size)) {
     374                async_answer_0(chandle, EREFUSED);
     375                async_answer_0(icall_handle, EREFUSED);
    374376                return;
    375377        }
    376378
    377379        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);
     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);
    387389                return;
    388390        }
    … …  
    390392        rc = udp_assoc_create_impl(client, &epp, &assoc_id);
    391393        if (rc != EOK) {
    392                 async_answer_0(iid, rc);
    393                 return;
    394         }
    395 
    396         async_answer_1(iid, EOK, assoc_id);
     394                async_answer_0(icall_handle, rc);
     395                return;
     396        }
     397
     398        async_answer_1(icall_handle, EOK, assoc_id);
    397399}
    398400
    … …  
    401403 * Handle client request to destroy association.
    402404 *
    403  * @param client   UDP client
    404  * @param iid      Async request ID
    405  * @param icall    Async request data
    406  */
    407 static void udp_assoc_destroy_srv(udp_client_t *client, ipc_callid_t iid,
     405 * @param client        UDP client
     406 * @param icall_handle  Async request call handle
     407 * @param icall         Async request data
     408 */
     409static void
     410udp_assoc_destroy_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    408411    ipc_call_t *icall)
    409412{
    … …  
    415418        assoc_id = IPC_GET_ARG1(*icall);
    416419        rc = udp_assoc_destroy_impl(client, assoc_id);
    417         async_answer_0(iid, rc);
     420        async_answer_0(icall_handle, rc);
    418421}
    419422
    … …  
    422425 * Handle client request to set no local address flag.
    423426 *
    424  * @param client   UDP client
    425  * @param iid      Async request ID
    426  * @param icall    Async request data
    427  */
    428 static void udp_assoc_set_nolocal_srv(udp_client_t *client, ipc_callid_t iid,
     427 * @param client        UDP client
     428 * @param icall_handle  Async request call handle
     429 * @param icall         Async request data
     430 */
     431static void
     432udp_assoc_set_nolocal_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    429433    ipc_call_t *icall)
    430434{
    … …  
    436440        assoc_id = IPC_GET_ARG1(*icall);
    437441        rc = udp_assoc_set_nolocal_impl(client, assoc_id);
    438         async_answer_0(iid, rc);
     442        async_answer_0(icall_handle, rc);
    439443}
    440444
    … …  
    443447 * Handle client request to send message.
    444448 *
    445  * @param client   UDP client
    446  * @param iid      Async request ID
    447  * @param icall    Async request data
    448  */
    449 static void udp_assoc_send_msg_srv(udp_client_t *client, ipc_callid_t iid,
     449 * @param client        UDP client
     450 * @param icall_handle  Async request call handle
     451 * @param icall         Async request data
     452 */
     453static void
     454udp_assoc_send_msg_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    450455    ipc_call_t *icall)
    451456{
    452         ipc_callid_t callid;
     457        cap_call_handle_t chandle;
    453458        size_t size;
    454459        inet_ep_t dest;
    … …  
    461466        /* Receive dest */
    462467
    463         if (!async_data_write_receive(&callid, &size)) {
    464                 async_answer_0(callid, EREFUSED);
    465                 async_answer_0(iid, EREFUSED);
     468        if (!async_data_write_receive(&chandle, &size)) {
     469                async_answer_0(chandle, EREFUSED);
     470                async_answer_0(icall_handle, EREFUSED);
    466471                return;
    467472        }
    468473
    469474        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);
     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);
    479484                return;
    480485        }
    … …  
    482487        /* Receive message data */
    483488
    484         if (!async_data_write_receive(&callid, &size)) {
    485                 async_answer_0(callid, EREFUSED);
    486                 async_answer_0(iid, EREFUSED);
     489        if (!async_data_write_receive(&chandle, &size)) {
     490                async_answer_0(chandle, EREFUSED);
     491                async_answer_0(icall_handle, EREFUSED);
    487492                return;
    488493        }
    489494
    490495        if (size > MAX_MSG_SIZE) {
    491                 async_answer_0(callid, EINVAL);
    492                 async_answer_0(iid, EINVAL);
     496                async_answer_0(chandle, EINVAL);
     497                async_answer_0(icall_handle, EINVAL);
    493498                return;
    494499        }
    … …  
    496501        data = malloc(size);
    497502        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);
     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);
    506511                free(data);
    507512                return;
    … …  
    512517        rc = udp_assoc_send_msg_impl(client, assoc_id, &dest, data, size);
    513518        if (rc != EOK) {
    514                 async_answer_0(iid, rc);
     519                async_answer_0(icall_handle, rc);
    515520                free(data);
    516521                return;
    517522        }
    518523
    519         async_answer_0(iid, EOK);
     524        async_answer_0(icall_handle, EOK);
    520525        free(data);
    521526}
    … …  
    541546 * Handle client request to get information on received message.
    542547 *
    543  * @param client   UDP client
    544  * @param iid      Async request ID
    545  * @param icall    Async request data
    546  */
    547 static void udp_rmsg_info_srv(udp_client_t *client, ipc_callid_t iid,
     548 * @param client        UDP client
     549 * @param icall_handle  Async request call handle
     550 * @param icall         Async request data
     551 */
     552static void
     553udp_rmsg_info_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    548554    ipc_call_t *icall)
    549555{
    550         ipc_callid_t callid;
     556        cap_call_handle_t chandle;
    551557        size_t size;
    552558        udp_crcv_queue_entry_t *enext;
    … …  
    557563        enext = udp_rmsg_get_next(client);
    558564
    559         if (!async_data_read_receive(&callid, &size)) {
    560                 async_answer_0(callid, EREFUSED);
    561                 async_answer_0(iid, EREFUSED);
     565        if (!async_data_read_receive(&chandle, &size)) {
     566                async_answer_0(chandle, EREFUSED);
     567                async_answer_0(icall_handle, EREFUSED);
    562568                return;
    563569        }
    564570
    565571        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,
     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,
    572578            max(size, (size_t)sizeof(inet_ep_t)));
    573579        if (rc != EOK) {
    574                 async_answer_0(iid, rc);
     580                async_answer_0(icall_handle, rc);
    575581                return;
    576582        }
    … …  
    581587        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_info_srv(): assoc_id=%zu, "
    582588            "size=%zu", assoc_id, size);
    583         async_answer_2(iid, EOK, assoc_id, size);
     589        async_answer_2(icall_handle, EOK, assoc_id, size);
    584590}
    585591
    … …  
    588594 * Handle client request to read data from first received message.
    589595 *
    590  * @param client   UDP client
    591  * @param iid      Async request ID
    592  * @param icall    Async request data
    593  */
    594 static void udp_rmsg_read_srv(udp_client_t *client, ipc_callid_t iid,
     596 * @param client        UDP client
     597 * @param icall_handle  Async request call handle
     598 * @param icall         Async request data
     599 */
     600static void
     601udp_rmsg_read_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    595602    ipc_call_t *icall)
    596603{
    597         ipc_callid_t callid;
     604        cap_call_handle_t chandle;
    598605        size_t msg_size;
    599606        udp_crcv_queue_entry_t *enext;
    … …  
    608615        enext = udp_rmsg_get_next(client);
    609616
    610         if (!async_data_read_receive(&callid, &size)) {
    611                 async_answer_0(callid, EREFUSED);
    612                 async_answer_0(iid, EREFUSED);
     617        if (!async_data_read_receive(&chandle, &size)) {
     618                async_answer_0(chandle, EREFUSED);
     619                async_answer_0(icall_handle, EREFUSED);
    613620                return;
    614621        }
    615622
    616623        if (enext == NULL) {
    617                 async_answer_0(callid, ENOENT);
    618                 async_answer_0(iid, ENOENT);
     624                async_answer_0(chandle, ENOENT);
     625                async_answer_0(icall_handle, ENOENT);
    619626                return;
    620627        }
    … …  
    624631
    625632        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);
     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);
    638645        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_rmsg_read_srv(): OK");
    639646}
    … …  
    644651 * to the next one.
    645652 *
    646  * @param client   UDP client
    647  * @param iid      Async request ID
    648  * @param icall    Async request data
    649  */
    650 static void udp_rmsg_discard_srv(udp_client_t *client, ipc_callid_t iid,
     653 * @param client        UDP client
     654 * @param icall_handle  Async request call handle
     655 * @param icall         Async request data
     656 */
     657static void
     658udp_rmsg_discard_srv(udp_client_t *client, cap_call_handle_t icall_handle,
    651659    ipc_call_t *icall)
    652660{
    … …  
    658666        if (enext == NULL) {
    659667                log_msg(LOG_DEFAULT, LVL_DEBUG, "usg_rmsg_discard_srv: enext==NULL");
    660                 async_answer_0(iid, ENOENT);
     668                async_answer_0(icall_handle, ENOENT);
    661669                return;
    662670        }
    … …  
    665673        udp_msg_delete(enext->msg);
    666674        free(enext);
    667         async_answer_0(iid, EOK);
     675        async_answer_0(icall_handle, EOK);
    668676}
    669677
    670678/** Handle UDP client connection.
    671679 *
    672  * @param iid   Connect call ID
    673  * @param icall Connect call data
    674  * @param arg   Connection argument
    675  */
    676 static void udp_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     680 * @param icall_handle  Connect call handle
     681 * @param icall         Connect call data
     682 * @param arg           Connection argument
     683 */
     684static void udp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
     685    void *arg)
    677686{
    678687        udp_client_t client;
    … …  
    680689
    681690        /* Accept the connection */
    682         async_answer_0(iid, EOK);
     691        async_answer_0(icall_handle, EOK);
    683692
    684693        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn()");
    … …  
    691700                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_client_conn: wait req");
    692701                ipc_call_t call;
    693                 ipc_callid_t callid = async_get_call(&call);
     702                cap_call_handle_t chandle = async_get_call(&call);
    694703                sysarg_t method = IPC_GET_IMETHOD(call);
    695704
    … …  
    698707                if (!method) {
    699708                        /* The other side has hung up */
    700                         async_answer_0(callid, EOK);
     709                        async_answer_0(chandle, EOK);
    701710                        break;
    702711                }
    … …  
    704713                switch (method) {
    705714                case UDP_CALLBACK_CREATE:
    706                         udp_callback_create_srv(&client, callid, &call);
     715                        udp_callback_create_srv(&client, chandle, &call);
    707716                        break;
    708717                case UDP_ASSOC_CREATE:
    709                         udp_assoc_create_srv(&client, callid, &call);
     718                        udp_assoc_create_srv(&client, chandle, &call);
    710719                        break;
    711720                case UDP_ASSOC_DESTROY:
    712                         udp_assoc_destroy_srv(&client, callid, &call);
     721                        udp_assoc_destroy_srv(&client, chandle, &call);
    713722                        break;
    714723                case UDP_ASSOC_SET_NOLOCAL:
    715                         udp_assoc_set_nolocal_srv(&client, callid, &call);
     724                        udp_assoc_set_nolocal_srv(&client, chandle, &call);
    716725                        break;
    717726                case UDP_ASSOC_SEND_MSG:
    718                         udp_assoc_send_msg_srv(&client, callid, &call);
     727                        udp_assoc_send_msg_srv(&client, chandle, &call);
    719728                        break;
    720729                case UDP_RMSG_INFO:
    721                         udp_rmsg_info_srv(&client, callid, &call);
     730                        udp_rmsg_info_srv(&client, chandle, &call);
    722731                        break;
    723732                case UDP_RMSG_READ:
    724                         udp_rmsg_read_srv(&client, callid, &call);
     733                        udp_rmsg_read_srv(&client, chandle, &call);
    725734                        break;
    726735                case UDP_RMSG_DISCARD:
    727                         udp_rmsg_discard_srv(&client, callid, &call);
     736                        udp_rmsg_discard_srv(&client, chandle, &call);
    728737                        break;
    729738                default:
    730                         async_answer_0(callid, ENOTSUP);
     739                        async_answer_0(chandle, ENOTSUP);
    731740                        break;
    732741                }
Note: See TracChangeset for help on using the changeset viewer.