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

    r3e242d2 ra46e56b  
    724724 * Handle client request to create callback session.
    725725 *
    726  * @param client  TCP client
    727  * @param iid     Async request ID
    728  * @param icall   Async request data
    729  */
    730 static void tcp_callback_create_srv(tcp_client_t *client, cap_call_handle_t iid,
    731     ipc_call_t *icall)
     726 * @param client        TCP client
     727 * @param icall_handle  Async request call handle
     728 * @param icall         Async request data
     729 */
     730static void tcp_callback_create_srv(tcp_client_t *client,
     731    cap_call_handle_t icall_handle, ipc_call_t *icall)
    732732{
    733733        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_callback_create_srv()");
    … …  
    735735        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    736736        if (sess == NULL) {
    737                 async_answer_0(iid, ENOMEM);
     737                async_answer_0(icall_handle, ENOMEM);
    738738                return;
    739739        }
    740740
    741741        client->sess = sess;
    742         async_answer_0(iid, EOK);
     742        async_answer_0(icall_handle, EOK);
    743743}
    744744
    … …  
    747747 * Handle client request to create connection.
    748748 *
    749  * @param client   TCP client
    750  * @param iid      Async request ID
    751  * @param icall    Async request data
    752  */
    753 static void tcp_conn_create_srv(tcp_client_t *client, cap_call_handle_t iid,
    754     ipc_call_t *icall)
    755 {
    756         cap_call_handle_t callid;
     749 * @param client        TCP client
     750 * @param icall_handle  Async request call handle
     751 * @param icall         Async request data
     752 */
     753static void tcp_conn_create_srv(tcp_client_t *client,
     754    cap_call_handle_t icall_handle, ipc_call_t *icall)
     755{
     756        cap_call_handle_t chandle;
    757757        size_t size;
    758758        inet_ep2_t epp;
    … …  
    762762        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_srv()");
    763763
    764         if (!async_data_write_receive(&callid, &size)) {
    765                 async_answer_0(callid, EREFUSED);
    766                 async_answer_0(iid, EREFUSED);
     764        if (!async_data_write_receive(&chandle, &size)) {
     765                async_answer_0(chandle, EREFUSED);
     766                async_answer_0(icall_handle, EREFUSED);
    767767                return;
    768768        }
    769769
    770770        if (size != sizeof(inet_ep2_t)) {
    771                 async_answer_0(callid, EINVAL);
    772                 async_answer_0(iid, EINVAL);
    773                 return;
    774         }
    775 
    776         rc = async_data_write_finalize(callid, &epp, size);
    777         if (rc != EOK) {
    778                 async_answer_0(callid, rc);
    779                 async_answer_0(iid, rc);
     771                async_answer_0(chandle, EINVAL);
     772                async_answer_0(icall_handle, EINVAL);
     773                return;
     774        }
     775
     776        rc = async_data_write_finalize(chandle, &epp, size);
     777        if (rc != EOK) {
     778                async_answer_0(chandle, rc);
     779                async_answer_0(icall_handle, rc);
    780780                return;
    781781        }
    … …  
    783783        rc = tcp_conn_create_impl(client, &epp, &conn_id);
    784784        if (rc != EOK) {
    785                 async_answer_0(iid, rc);
    786                 return;
    787         }
    788 
    789         async_answer_1(iid, EOK, conn_id);
     785                async_answer_0(icall_handle, rc);
     786                return;
     787        }
     788
     789        async_answer_1(icall_handle, EOK, conn_id);
    790790}
    791791
    … …  
    794794 * Handle client request to destroy connection.
    795795 *
    796  * @param client   TCP client
    797  * @param iid      Async request ID
    798  * @param icall    Async request data
    799  */
    800 static void tcp_conn_destroy_srv(tcp_client_t *client, cap_call_handle_t iid,
    801     ipc_call_t *icall)
     796 * @param client        TCP client
     797 * @param icall_handle  Async request call handle
     798 * @param icall         Async request data
     799 */
     800static void tcp_conn_destroy_srv(tcp_client_t *client,
     801    cap_call_handle_t icall_handle, ipc_call_t *icall)
    802802{
    803803        sysarg_t conn_id;
    … …  
    808808        conn_id = IPC_GET_ARG1(*icall);
    809809        rc = tcp_conn_destroy_impl(client, conn_id);
    810         async_answer_0(iid, rc);
     810        async_answer_0(icall_handle, rc);
    811811}
    812812
    … …  
    815815 * Handle client request to create listener.
    816816 *
    817  * @param client   TCP client
    818  * @param iid      Async request ID
    819  * @param icall    Async request data
    820  */
    821 static void tcp_listener_create_srv(tcp_client_t *client, cap_call_handle_t iid,
    822     ipc_call_t *icall)
    823 {
    824         cap_call_handle_t callid;
     817 * @param client        TCP client
     818 * @param icall_handle  Async request call handle
     819 * @param icall         Async request data
     820 */
     821static void tcp_listener_create_srv(tcp_client_t *client,
     822    cap_call_handle_t icall_handle, ipc_call_t *icall)
     823{
     824        cap_call_handle_t chandle;
    825825        size_t size;
    826826        inet_ep_t ep;
    … …  
    830830        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_create_srv()");
    831831
    832         if (!async_data_write_receive(&callid, &size)) {
    833                 async_answer_0(callid, EREFUSED);
    834                 async_answer_0(iid, EREFUSED);
     832        if (!async_data_write_receive(&chandle, &size)) {
     833                async_answer_0(chandle, EREFUSED);
     834                async_answer_0(icall_handle, EREFUSED);
    835835                return;
    836836        }
    837837
    838838        if (size != sizeof(inet_ep_t)) {
    839                 async_answer_0(callid, EINVAL);
    840                 async_answer_0(iid, EINVAL);
    841                 return;
    842         }
    843 
    844         rc = async_data_write_finalize(callid, &ep, size);
    845         if (rc != EOK) {
    846                 async_answer_0(callid, rc);
    847                 async_answer_0(iid, rc);
     839                async_answer_0(chandle, EINVAL);
     840                async_answer_0(icall_handle, EINVAL);
     841                return;
     842        }
     843
     844        rc = async_data_write_finalize(chandle, &ep, size);
     845        if (rc != EOK) {
     846                async_answer_0(chandle, rc);
     847                async_answer_0(icall_handle, rc);
    848848                return;
    849849        }
    … …  
    851851        rc = tcp_listener_create_impl(client, &ep, &lst_id);
    852852        if (rc != EOK) {
    853                 async_answer_0(iid, rc);
    854                 return;
    855         }
    856 
    857         async_answer_1(iid, EOK, lst_id);
     853                async_answer_0(icall_handle, rc);
     854                return;
     855        }
     856
     857        async_answer_1(icall_handle, EOK, lst_id);
    858858}
    859859
    … …  
    862862 * Handle client request to destroy listener.
    863863 *
    864  * @param client   TCP client
    865  * @param iid      Async request ID
    866  * @param icall    Async request data
    867  */
    868 static void tcp_listener_destroy_srv(tcp_client_t *client, cap_call_handle_t iid,
    869     ipc_call_t *icall)
     864 * @param client        TCP client
     865 * @param icall_handle  Async request call handle
     866 * @param icall         Async request data
     867 */
     868static void tcp_listener_destroy_srv(tcp_client_t *client,
     869    cap_call_handle_t icall_handle, ipc_call_t *icall)
    870870{
    871871        sysarg_t lst_id;
    … …  
    876876        lst_id = IPC_GET_ARG1(*icall);
    877877        rc = tcp_listener_destroy_impl(client, lst_id);
    878         async_answer_0(iid, rc);
     878        async_answer_0(icall_handle, rc);
    879879}
    880880
    … …  
    883883 * Handle client request to send FIN.
    884884 *
    885  * @param client   TCP client
    886  * @param iid      Async request ID
    887  * @param icall    Async request data
    888  */
    889 static void tcp_conn_send_fin_srv(tcp_client_t *client, cap_call_handle_t iid,
    890     ipc_call_t *icall)
     885 * @param client        TCP client
     886 * @param icall_handle  Async request call handle
     887 * @param icall         Async request data
     888 */
     889static void tcp_conn_send_fin_srv(tcp_client_t *client,
     890    cap_call_handle_t icall_handle, ipc_call_t *icall)
    891891{
    892892        sysarg_t conn_id;
    … …  
    897897        conn_id = IPC_GET_ARG1(*icall);
    898898        rc = tcp_conn_send_fin_impl(client, conn_id);
    899         async_answer_0(iid, rc);
     899        async_answer_0(icall_handle, rc);
    900900}
    901901
    … …  
    904904 * Handle client request to push connection.
    905905 *
    906  * @param client   TCP client
    907  * @param iid      Async request ID
    908  * @param icall    Async request data
    909  */
    910 static void tcp_conn_push_srv(tcp_client_t *client, cap_call_handle_t iid,
    911     ipc_call_t *icall)
     906 * @param client        TCP client
     907 * @param icall_handle  Async request call handle
     908 * @param icall         Async request data
     909 */
     910static void tcp_conn_push_srv(tcp_client_t *client,
     911    cap_call_handle_t icall_handle, ipc_call_t *icall)
    912912{
    913913        sysarg_t conn_id;
    … …  
    918918        conn_id = IPC_GET_ARG1(*icall);
    919919        rc = tcp_conn_push_impl(client, conn_id);
    920         async_answer_0(iid, rc);
     920        async_answer_0(icall_handle, rc);
    921921}
    922922
    … …  
    925925 * Handle client request to reset connection.
    926926 *
    927  * @param client   TCP client
    928  * @param iid      Async request ID
    929  * @param icall    Async request data
    930  */
    931 static void tcp_conn_reset_srv(tcp_client_t *client, cap_call_handle_t iid,
    932     ipc_call_t *icall)
     927 * @param client        TCP client
     928 * @param icall_handle  Async request call handle
     929 * @param icall         Async request data
     930 */
     931static void tcp_conn_reset_srv(tcp_client_t *client,
     932    cap_call_handle_t icall_handle, ipc_call_t *icall)
    933933{
    934934        sysarg_t conn_id;
    … …  
    939939        conn_id = IPC_GET_ARG1(*icall);
    940940        rc = tcp_conn_reset_impl(client, conn_id);
    941         async_answer_0(iid, rc);
     941        async_answer_0(icall_handle, rc);
    942942}
    943943
    … …  
    946946 * Handle client request to send data via connection.
    947947 *
    948  * @param client   TCP client
    949  * @param iid      Async request ID
    950  * @param icall    Async request data
    951  */
    952 static void tcp_conn_send_srv(tcp_client_t *client, cap_call_handle_t iid,
    953     ipc_call_t *icall)
    954 {
    955         cap_call_handle_t callid;
     948 * @param client        TCP client
     949 * @param icall_handle  Async request call handle
     950 * @param icall         Async request data
     951 */
     952static void tcp_conn_send_srv(tcp_client_t *client,
     953    cap_call_handle_t icall_handle, ipc_call_t *icall)
     954{
     955        cap_call_handle_t chandle;
    956956        size_t size;
    957957        sysarg_t conn_id;
    … …  
    963963        /* Receive message data */
    964964
    965         if (!async_data_write_receive(&callid, &size)) {
    966                 async_answer_0(callid, EREFUSED);
    967                 async_answer_0(iid, EREFUSED);
     965        if (!async_data_write_receive(&chandle, &size)) {
     966                async_answer_0(chandle, EREFUSED);
     967                async_answer_0(icall_handle, EREFUSED);
    968968                return;
    969969        }
    970970
    971971        if (size > MAX_MSG_SIZE) {
    972                 async_answer_0(callid, EINVAL);
    973                 async_answer_0(iid, EINVAL);
     972                async_answer_0(chandle, EINVAL);
     973                async_answer_0(icall_handle, EINVAL);
    974974                return;
    975975        }
    … …  
    977977        data = malloc(size);
    978978        if (data == NULL) {
    979                 async_answer_0(callid, ENOMEM);
    980                 async_answer_0(iid, ENOMEM);
    981                 return;
    982         }
    983 
    984         rc = async_data_write_finalize(callid, data, size);
    985         if (rc != EOK) {
    986                 async_answer_0(callid, rc);
    987                 async_answer_0(iid, rc);
     979                async_answer_0(chandle, ENOMEM);
     980                async_answer_0(icall_handle, ENOMEM);
     981                return;
     982        }
     983
     984        rc = async_data_write_finalize(chandle, data, size);
     985        if (rc != EOK) {
     986                async_answer_0(chandle, rc);
     987                async_answer_0(icall_handle, rc);
    988988                free(data);
    989989                return;
    … …  
    994994        rc = tcp_conn_send_impl(client, conn_id, data, size);
    995995        if (rc != EOK) {
    996                 async_answer_0(iid, rc);
     996                async_answer_0(icall_handle, rc);
    997997                free(data);
    998998                return;
    999999        }
    10001000
    1001         async_answer_0(iid, EOK);
     1001        async_answer_0(icall_handle, EOK);
    10021002        free(data);
    10031003}
    … …  
    10071007 * Handle client request to read received data via connection without blocking.
    10081008 *
    1009  * @param client   TCP client
    1010  * @param iid      Async request ID
    1011  * @param icall    Async request data
    1012  */
    1013 static void tcp_conn_recv_srv(tcp_client_t *client, cap_call_handle_t iid,
    1014     ipc_call_t *icall)
    1015 {
    1016         cap_call_handle_t callid;
     1009 * @param client        TCP client
     1010 * @param icall_handle  Async request call handle
     1011 * @param icall         Async request data
     1012 */
     1013static void tcp_conn_recv_srv(tcp_client_t *client,
     1014    cap_call_handle_t icall_handle, ipc_call_t *icall)
     1015{
     1016        cap_call_handle_t chandle;
    10171017        sysarg_t conn_id;
    10181018        size_t size, rsize;
    … …  
    10241024        conn_id = IPC_GET_ARG1(*icall);
    10251025
    1026         if (!async_data_read_receive(&callid, &size)) {
    1027                 async_answer_0(callid, EREFUSED);
    1028                 async_answer_0(iid, EREFUSED);
     1026        if (!async_data_read_receive(&chandle, &size)) {
     1027                async_answer_0(chandle, EREFUSED);
     1028                async_answer_0(icall_handle, EREFUSED);
    10291029                return;
    10301030        }
    … …  
    10331033        data = malloc(size);
    10341034        if (data == NULL) {
    1035                 async_answer_0(callid, ENOMEM);
    1036                 async_answer_0(iid, ENOMEM);
     1035                async_answer_0(chandle, ENOMEM);
     1036                async_answer_0(icall_handle, ENOMEM);
    10371037                return;
    10381038        }
    … …  
    10401040        rc = tcp_conn_recv_impl(client, conn_id, data, size, &rsize);
    10411041        if (rc != EOK) {
    1042                 async_answer_0(callid, rc);
    1043                 async_answer_0(iid, rc);
     1042                async_answer_0(chandle, rc);
     1043                async_answer_0(icall_handle, rc);
    10441044                free(data);
    10451045                return;
    10461046        }
    10471047
    1048         rc = async_data_read_finalize(callid, data, size);
    1049         if (rc != EOK) {
    1050                 async_answer_0(iid, rc);
     1048        rc = async_data_read_finalize(chandle, data, size);
     1049        if (rc != EOK) {
     1050                async_answer_0(icall_handle, rc);
    10511051                free(data);
    10521052                return;
    10531053        }
    10541054
    1055         async_answer_1(iid, EOK, rsize);
     1055        async_answer_1(icall_handle, EOK, rsize);
    10561056        free(data);
    10571057
    … …  
    10631063 * Handle client request to read received data via connection with blocking.
    10641064 *
    1065  * @param client   TCP client
    1066  * @param iid      Async request ID
    1067  * @param icall    Async request data
    1068  */
    1069 static void tcp_conn_recv_wait_srv(tcp_client_t *client, cap_call_handle_t iid,
    1070     ipc_call_t *icall)
    1071 {
    1072         cap_call_handle_t callid;
     1065 * @param client        TCP client
     1066 * @param icall_handle  Async request call handle
     1067 * @param icall         Async request data
     1068 */
     1069static void tcp_conn_recv_wait_srv(tcp_client_t *client,
     1070    cap_call_handle_t icall_handle, ipc_call_t *icall)
     1071{
     1072        cap_call_handle_t chandle;
    10731073        sysarg_t conn_id;
    10741074        size_t size, rsize;
    … …  
    10801080        conn_id = IPC_GET_ARG1(*icall);
    10811081
    1082         if (!async_data_read_receive(&callid, &size)) {
     1082        if (!async_data_read_receive(&chandle, &size)) {
    10831083                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - data_receive failed");
    1084                 async_answer_0(callid, EREFUSED);
    1085                 async_answer_0(iid, EREFUSED);
     1084                async_answer_0(chandle, EREFUSED);
     1085                async_answer_0(icall_handle, EREFUSED);
    10861086                return;
    10871087        }
    … …  
    10911091        if (data == NULL) {
    10921092                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - allocation failed");
    1093                 async_answer_0(callid, ENOMEM);
    1094                 async_answer_0(iid, ENOMEM);
     1093                async_answer_0(chandle, ENOMEM);
     1094                async_answer_0(icall_handle, ENOMEM);
    10951095                return;
    10961096        }
    … …  
    10991099        if (rc != EOK) {
    11001100                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - recv_impl failed rc=%s", str_error_name(rc));
    1101                 async_answer_0(callid, rc);
    1102                 async_answer_0(iid, rc);
     1101                async_answer_0(chandle, rc);
     1102                async_answer_0(icall_handle, rc);
    11031103                free(data);
    11041104                return;
    11051105        }
    11061106
    1107         rc = async_data_read_finalize(callid, data, size);
     1107        rc = async_data_read_finalize(chandle, data, size);
    11081108        if (rc != EOK) {
    11091109                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - finalize failed");
    1110                 async_answer_0(iid, rc);
     1110                async_answer_0(icall_handle, rc);
    11111111                free(data);
    11121112                return;
    … …  
    11141114
    11151115        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv(): rsize=%zu", size);
    1116         async_answer_1(iid, EOK, rsize);
     1116        async_answer_1(icall_handle, EOK, rsize);
    11171117        free(data);
    11181118
    … …  
    11681168/** Handle TCP client connection.
    11691169 *
    1170  * @param iid   Connect call ID
    1171  * @param icall Connect call data
    1172  * @param arg   Connection argument
    1173  */
    1174 static void tcp_client_conn(cap_call_handle_t iid, ipc_call_t *icall, void *arg)
     1170 * @param icall_handle  Connect call handle
     1171 * @param icall         Connect call data
     1172 * @param arg           Connection argument
     1173 */
     1174static void tcp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
     1175    void *arg)
    11751176{
    11761177        tcp_client_t client;
    11771178
    11781179        /* Accept the connection */
    1179         async_answer_0(iid, EOK);
     1180        async_answer_0(icall_handle, EOK);
    11801181
    11811182        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn() - client=%p",
    … …  
    11871188                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn: wait req");
    11881189                ipc_call_t call;
    1189                 cap_call_handle_t callid = async_get_call(&call);
     1190                cap_call_handle_t chandle = async_get_call(&call);
    11901191                sysarg_t method = IPC_GET_IMETHOD(call);
    11911192
    … …  
    11941195                if (!method) {
    11951196                        /* The other side has hung up */
    1196                         async_answer_0(callid, EOK);
     1197                        async_answer_0(chandle, EOK);
    11971198                        break;
    11981199                }
    … …  
    12001201                switch (method) {
    12011202                case TCP_CALLBACK_CREATE:
    1202                         tcp_callback_create_srv(&client, callid, &call);
     1203                        tcp_callback_create_srv(&client, chandle, &call);
    12031204                        break;
    12041205                case TCP_CONN_CREATE:
    1205                         tcp_conn_create_srv(&client, callid, &call);
     1206                        tcp_conn_create_srv(&client, chandle, &call);
    12061207                        break;
    12071208                case TCP_CONN_DESTROY:
    1208                         tcp_conn_destroy_srv(&client, callid, &call);
     1209                        tcp_conn_destroy_srv(&client, chandle, &call);
    12091210                        break;
    12101211                case TCP_LISTENER_CREATE:
    1211                         tcp_listener_create_srv(&client, callid, &call);
     1212                        tcp_listener_create_srv(&client, chandle, &call);
    12121213                        break;
    12131214                case TCP_LISTENER_DESTROY:
    1214                         tcp_listener_destroy_srv(&client, callid, &call);
     1215                        tcp_listener_destroy_srv(&client, chandle, &call);
    12151216                        break;
    12161217                case TCP_CONN_SEND_FIN:
    1217                         tcp_conn_send_fin_srv(&client, callid, &call);
     1218                        tcp_conn_send_fin_srv(&client, chandle, &call);
    12181219                        break;
    12191220                case TCP_CONN_PUSH:
    1220                         tcp_conn_push_srv(&client, callid, &call);
     1221                        tcp_conn_push_srv(&client, chandle, &call);
    12211222                        break;
    12221223                case TCP_CONN_RESET:
    1223                         tcp_conn_reset_srv(&client, callid, &call);
     1224                        tcp_conn_reset_srv(&client, chandle, &call);
    12241225                        break;
    12251226                case TCP_CONN_SEND:
    1226                         tcp_conn_send_srv(&client, callid, &call);
     1227                        tcp_conn_send_srv(&client, chandle, &call);
    12271228                        break;
    12281229                case TCP_CONN_RECV:
    1229                         tcp_conn_recv_srv(&client, callid, &call);
     1230                        tcp_conn_recv_srv(&client, chandle, &call);
    12301231                        break;
    12311232                case TCP_CONN_RECV_WAIT:
    1232                         tcp_conn_recv_wait_srv(&client, callid, &call);
     1233                        tcp_conn_recv_wait_srv(&client, chandle, &call);
    12331234                        break;
    12341235                default:
    1235                         async_answer_0(callid, ENOTSUP);
     1236                        async_answer_0(chandle, ENOTSUP);
    12361237                        break;
    12371238                }
Note: See TracChangeset for help on using the changeset viewer.