Changeset 984a9ba in mainline for uspace/srv/net/tcp/service.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (6 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r76f566d r984a9ba  
    727727 * Handle client request to create callback session.
    728728 *
    729  * @param client        TCP client
    730  * @param icall_handle  Async request call handle
    731  * @param icall         Async request data
    732  */
    733 static void tcp_callback_create_srv(tcp_client_t *client,
    734     cap_call_handle_t icall_handle, ipc_call_t *icall)
     729 * @param client TCP client
     730 * @param icall  Async request data
     731 *
     732 */
     733static void tcp_callback_create_srv(tcp_client_t *client, ipc_call_t *icall)
    735734{
    736735        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_callback_create_srv()");
    … …  
    738737        async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
    739738        if (sess == NULL) {
    740                 async_answer_0(icall_handle, ENOMEM);
     739                async_answer_0(icall, ENOMEM);
    741740                return;
    742741        }
    743742
    744743        client->sess = sess;
    745         async_answer_0(icall_handle, EOK);
     744        async_answer_0(icall, EOK);
    746745}
    747746
    … …  
    750749 * Handle client request to create connection.
    751750 *
    752  * @param client        TCP client
    753  * @param icall_handle  Async request call handle
    754  * @param icall         Async request data
    755  */
    756 static void tcp_conn_create_srv(tcp_client_t *client,
    757     cap_call_handle_t icall_handle, ipc_call_t *icall)
    758 {
    759         cap_call_handle_t chandle;
     751 * @param client TCP client
     752 * @param icall  Async request data
     753 *
     754 */
     755static void tcp_conn_create_srv(tcp_client_t *client, ipc_call_t *icall)
     756{
     757        ipc_call_t call;
    760758        size_t size;
    761759        inet_ep2_t epp;
    … …  
    765763        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_create_srv()");
    766764
    767         if (!async_data_write_receive(&chandle, &size)) {
    768                 async_answer_0(chandle, EREFUSED);
    769                 async_answer_0(icall_handle, EREFUSED);
     765        if (!async_data_write_receive(&call, &size)) {
     766                async_answer_0(&call, EREFUSED);
     767                async_answer_0(icall, EREFUSED);
    770768                return;
    771769        }
    772770
    773771        if (size != sizeof(inet_ep2_t)) {
    774                 async_answer_0(chandle, EINVAL);
    775                 async_answer_0(icall_handle, EINVAL);
    776                 return;
    777         }
    778 
    779         rc = async_data_write_finalize(chandle, &epp, size);
    780         if (rc != EOK) {
    781                 async_answer_0(chandle, rc);
    782                 async_answer_0(icall_handle, rc);
     772                async_answer_0(&call, EINVAL);
     773                async_answer_0(icall, EINVAL);
     774                return;
     775        }
     776
     777        rc = async_data_write_finalize(&call, &epp, size);
     778        if (rc != EOK) {
     779                async_answer_0(&call, rc);
     780                async_answer_0(icall, rc);
    783781                return;
    784782        }
    … …  
    786784        rc = tcp_conn_create_impl(client, &epp, &conn_id);
    787785        if (rc != EOK) {
    788                 async_answer_0(icall_handle, rc);
    789                 return;
    790         }
    791 
    792         async_answer_1(icall_handle, EOK, conn_id);
     786                async_answer_0(icall, rc);
     787                return;
     788        }
     789
     790        async_answer_1(icall, EOK, conn_id);
    793791}
    794792
    … …  
    797795 * Handle client request to destroy connection.
    798796 *
    799  * @param client        TCP client
    800  * @param icall_handle  Async request call handle
    801  * @param icall         Async request data
    802  */
    803 static void tcp_conn_destroy_srv(tcp_client_t *client,
    804     cap_call_handle_t icall_handle, ipc_call_t *icall)
     797 * @param client TCP client
     798 * @param icall  Async request data
     799 *
     800 */
     801static void tcp_conn_destroy_srv(tcp_client_t *client, ipc_call_t *icall)
    805802{
    806803        sysarg_t conn_id;
    … …  
    811808        conn_id = IPC_GET_ARG1(*icall);
    812809        rc = tcp_conn_destroy_impl(client, conn_id);
    813         async_answer_0(icall_handle, rc);
     810        async_answer_0(icall, rc);
    814811}
    815812
    … …  
    818815 * Handle client request to create listener.
    819816 *
    820  * @param client        TCP client
    821  * @param icall_handle  Async request call handle
    822  * @param icall         Async request data
    823  */
    824 static void tcp_listener_create_srv(tcp_client_t *client,
    825     cap_call_handle_t icall_handle, ipc_call_t *icall)
    826 {
    827         cap_call_handle_t chandle;
     817 * @param client TCP client
     818 * @param icall  Async request data
     819 *
     820 */
     821static void tcp_listener_create_srv(tcp_client_t *client, ipc_call_t *icall)
     822{
     823        ipc_call_t call;
    828824        size_t size;
    829825        inet_ep_t ep;
    … …  
    833829        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_listener_create_srv()");
    834830
    835         if (!async_data_write_receive(&chandle, &size)) {
    836                 async_answer_0(chandle, EREFUSED);
    837                 async_answer_0(icall_handle, EREFUSED);
     831        if (!async_data_write_receive(&call, &size)) {
     832                async_answer_0(&call, EREFUSED);
     833                async_answer_0(icall, EREFUSED);
    838834                return;
    839835        }
    840836
    841837        if (size != sizeof(inet_ep_t)) {
    842                 async_answer_0(chandle, EINVAL);
    843                 async_answer_0(icall_handle, EINVAL);
    844                 return;
    845         }
    846 
    847         rc = async_data_write_finalize(chandle, &ep, size);
    848         if (rc != EOK) {
    849                 async_answer_0(chandle, rc);
    850                 async_answer_0(icall_handle, rc);
     838                async_answer_0(&call, EINVAL);
     839                async_answer_0(icall, EINVAL);
     840                return;
     841        }
     842
     843        rc = async_data_write_finalize(&call, &ep, size);
     844        if (rc != EOK) {
     845                async_answer_0(&call, rc);
     846                async_answer_0(icall, rc);
    851847                return;
    852848        }
    … …  
    854850        rc = tcp_listener_create_impl(client, &ep, &lst_id);
    855851        if (rc != EOK) {
    856                 async_answer_0(icall_handle, rc);
    857                 return;
    858         }
    859 
    860         async_answer_1(icall_handle, EOK, lst_id);
     852                async_answer_0(icall, rc);
     853                return;
     854        }
     855
     856        async_answer_1(icall, EOK, lst_id);
    861857}
    862858
    … …  
    865861 * Handle client request to destroy listener.
    866862 *
    867  * @param client        TCP client
    868  * @param icall_handle  Async request call handle
    869  * @param icall         Async request data
    870  */
    871 static void tcp_listener_destroy_srv(tcp_client_t *client,
    872     cap_call_handle_t icall_handle, ipc_call_t *icall)
     863 * @param client TCP client
     864 * @param icall  Async request data
     865 *
     866 */
     867static void tcp_listener_destroy_srv(tcp_client_t *client, ipc_call_t *icall)
    873868{
    874869        sysarg_t lst_id;
    … …  
    879874        lst_id = IPC_GET_ARG1(*icall);
    880875        rc = tcp_listener_destroy_impl(client, lst_id);
    881         async_answer_0(icall_handle, rc);
     876        async_answer_0(icall, rc);
    882877}
    883878
    … …  
    886881 * Handle client request to send FIN.
    887882 *
    888  * @param client        TCP client
    889  * @param icall_handle  Async request call handle
    890  * @param icall         Async request data
    891  */
    892 static void tcp_conn_send_fin_srv(tcp_client_t *client,
    893     cap_call_handle_t icall_handle, ipc_call_t *icall)
     883 * @param client TCP client
     884 * @param icall  Async request data
     885 *
     886 */
     887static void tcp_conn_send_fin_srv(tcp_client_t *client, ipc_call_t *icall)
    894888{
    895889        sysarg_t conn_id;
    … …  
    900894        conn_id = IPC_GET_ARG1(*icall);
    901895        rc = tcp_conn_send_fin_impl(client, conn_id);
    902         async_answer_0(icall_handle, rc);
     896        async_answer_0(icall, rc);
    903897}
    904898
    … …  
    907901 * Handle client request to push connection.
    908902 *
    909  * @param client        TCP client
    910  * @param icall_handle  Async request call handle
    911  * @param icall         Async request data
    912  */
    913 static void tcp_conn_push_srv(tcp_client_t *client,
    914     cap_call_handle_t icall_handle, ipc_call_t *icall)
     903 * @param client TCP client
     904 * @param icall  Async request data
     905 *
     906 */
     907static void tcp_conn_push_srv(tcp_client_t *client, ipc_call_t *icall)
    915908{
    916909        sysarg_t conn_id;
    … …  
    921914        conn_id = IPC_GET_ARG1(*icall);
    922915        rc = tcp_conn_push_impl(client, conn_id);
    923         async_answer_0(icall_handle, rc);
     916        async_answer_0(icall, rc);
    924917}
    925918
    … …  
    928921 * Handle client request to reset connection.
    929922 *
    930  * @param client        TCP client
    931  * @param icall_handle  Async request call handle
    932  * @param icall         Async request data
    933  */
    934 static void tcp_conn_reset_srv(tcp_client_t *client,
    935     cap_call_handle_t icall_handle, ipc_call_t *icall)
     923 * @param client TCP client
     924 * @param icall  Async request data
     925 *
     926 */
     927static void tcp_conn_reset_srv(tcp_client_t *client, ipc_call_t *icall)
    936928{
    937929        sysarg_t conn_id;
    … …  
    942934        conn_id = IPC_GET_ARG1(*icall);
    943935        rc = tcp_conn_reset_impl(client, conn_id);
    944         async_answer_0(icall_handle, rc);
     936        async_answer_0(icall, rc);
    945937}
    946938
    … …  
    949941 * Handle client request to send data via connection.
    950942 *
    951  * @param client        TCP client
    952  * @param icall_handle  Async request call handle
    953  * @param icall         Async request data
    954  */
    955 static void tcp_conn_send_srv(tcp_client_t *client,
    956     cap_call_handle_t icall_handle, ipc_call_t *icall)
    957 {
    958         cap_call_handle_t chandle;
     943 * @param client TCP client
     944 * @param icall  Async request data
     945 *
     946 */
     947static void tcp_conn_send_srv(tcp_client_t *client, ipc_call_t *icall)
     948{
     949        ipc_call_t call;
    959950        size_t size;
    960951        sysarg_t conn_id;
    … …  
    966957        /* Receive message data */
    967958
    968         if (!async_data_write_receive(&chandle, &size)) {
    969                 async_answer_0(chandle, EREFUSED);
    970                 async_answer_0(icall_handle, EREFUSED);
     959        if (!async_data_write_receive(&call, &size)) {
     960                async_answer_0(&call, EREFUSED);
     961                async_answer_0(icall, EREFUSED);
    971962                return;
    972963        }
    973964
    974965        if (size > MAX_MSG_SIZE) {
    975                 async_answer_0(chandle, EINVAL);
    976                 async_answer_0(icall_handle, EINVAL);
     966                async_answer_0(&call, EINVAL);
     967                async_answer_0(icall, EINVAL);
    977968                return;
    978969        }
    … …  
    980971        data = malloc(size);
    981972        if (data == NULL) {
    982                 async_answer_0(chandle, ENOMEM);
    983                 async_answer_0(icall_handle, ENOMEM);
    984                 return;
    985         }
    986 
    987         rc = async_data_write_finalize(chandle, data, size);
    988         if (rc != EOK) {
    989                 async_answer_0(chandle, rc);
    990                 async_answer_0(icall_handle, rc);
     973                async_answer_0(&call, ENOMEM);
     974                async_answer_0(icall, ENOMEM);
     975                return;
     976        }
     977
     978        rc = async_data_write_finalize(&call, data, size);
     979        if (rc != EOK) {
     980                async_answer_0(&call, rc);
     981                async_answer_0(icall, rc);
    991982                free(data);
    992983                return;
    … …  
    997988        rc = tcp_conn_send_impl(client, conn_id, data, size);
    998989        if (rc != EOK) {
    999                 async_answer_0(icall_handle, rc);
     990                async_answer_0(icall, rc);
    1000991                free(data);
    1001992                return;
    1002993        }
    1003994
    1004         async_answer_0(icall_handle, EOK);
     995        async_answer_0(icall, EOK);
    1005996        free(data);
    1006997}
    … …  
    10101001 * Handle client request to read received data via connection without blocking.
    10111002 *
    1012  * @param client        TCP client
    1013  * @param icall_handle  Async request call handle
    1014  * @param icall         Async request data
    1015  */
    1016 static void tcp_conn_recv_srv(tcp_client_t *client,
    1017     cap_call_handle_t icall_handle, ipc_call_t *icall)
    1018 {
    1019         cap_call_handle_t chandle;
     1003 * @param client TCP client
     1004 * @param icall  Async request data
     1005 *
     1006 */
     1007static void tcp_conn_recv_srv(tcp_client_t *client, ipc_call_t *icall)
     1008{
     1009        ipc_call_t call;
    10201010        sysarg_t conn_id;
    10211011        size_t size, rsize;
    … …  
    10271017        conn_id = IPC_GET_ARG1(*icall);
    10281018
    1029         if (!async_data_read_receive(&chandle, &size)) {
    1030                 async_answer_0(chandle, EREFUSED);
    1031                 async_answer_0(icall_handle, EREFUSED);
     1019        if (!async_data_read_receive(&call, &size)) {
     1020                async_answer_0(&call, EREFUSED);
     1021                async_answer_0(icall, EREFUSED);
    10321022                return;
    10331023        }
    … …  
    10361026        data = malloc(size);
    10371027        if (data == NULL) {
    1038                 async_answer_0(chandle, ENOMEM);
    1039                 async_answer_0(icall_handle, ENOMEM);
     1028                async_answer_0(&call, ENOMEM);
     1029                async_answer_0(icall, ENOMEM);
    10401030                return;
    10411031        }
    … …  
    10431033        rc = tcp_conn_recv_impl(client, conn_id, data, size, &rsize);
    10441034        if (rc != EOK) {
    1045                 async_answer_0(chandle, rc);
    1046                 async_answer_0(icall_handle, rc);
     1035                async_answer_0(&call, rc);
     1036                async_answer_0(icall, rc);
    10471037                free(data);
    10481038                return;
    10491039        }
    10501040
    1051         rc = async_data_read_finalize(chandle, data, size);
    1052         if (rc != EOK) {
    1053                 async_answer_0(icall_handle, rc);
     1041        rc = async_data_read_finalize(&call, data, size);
     1042        if (rc != EOK) {
     1043                async_answer_0(icall, rc);
    10541044                free(data);
    10551045                return;
    10561046        }
    10571047
    1058         async_answer_1(icall_handle, EOK, rsize);
     1048        async_answer_1(icall, EOK, rsize);
    10591049        free(data);
    10601050
    … …  
    10661056 * Handle client request to read received data via connection with blocking.
    10671057 *
    1068  * @param client        TCP client
    1069  * @param icall_handle  Async request call handle
    1070  * @param icall         Async request data
    1071  */
    1072 static void tcp_conn_recv_wait_srv(tcp_client_t *client,
    1073     cap_call_handle_t icall_handle, ipc_call_t *icall)
    1074 {
    1075         cap_call_handle_t chandle;
     1058 * @param client TCP client
     1059 * @param icall  Async request data
     1060 *
     1061 */
     1062static void tcp_conn_recv_wait_srv(tcp_client_t *client, ipc_call_t *icall)
     1063{
     1064        ipc_call_t call;
    10761065        sysarg_t conn_id;
    10771066        size_t size, rsize;
    … …  
    10831072        conn_id = IPC_GET_ARG1(*icall);
    10841073
    1085         if (!async_data_read_receive(&chandle, &size)) {
     1074        if (!async_data_read_receive(&call, &size)) {
    10861075                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - data_receive failed");
    1087                 async_answer_0(chandle, EREFUSED);
    1088                 async_answer_0(icall_handle, EREFUSED);
     1076                async_answer_0(&call, EREFUSED);
     1077                async_answer_0(icall, EREFUSED);
    10891078                return;
    10901079        }
    … …  
    10941083        if (data == NULL) {
    10951084                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - allocation failed");
    1096                 async_answer_0(chandle, ENOMEM);
    1097                 async_answer_0(icall_handle, ENOMEM);
     1085                async_answer_0(&call, ENOMEM);
     1086                async_answer_0(icall, ENOMEM);
    10981087                return;
    10991088        }
    … …  
    11021091        if (rc != EOK) {
    11031092                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - recv_impl failed rc=%s", str_error_name(rc));
    1104                 async_answer_0(chandle, rc);
    1105                 async_answer_0(icall_handle, rc);
     1093                async_answer_0(&call, rc);
     1094                async_answer_0(icall, rc);
    11061095                free(data);
    11071096                return;
    11081097        }
    11091098
    1110         rc = async_data_read_finalize(chandle, data, size);
     1099        rc = async_data_read_finalize(&call, data, size);
    11111100        if (rc != EOK) {
    11121101                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv - finalize failed");
    1113                 async_answer_0(icall_handle, rc);
     1102                async_answer_0(icall, rc);
    11141103                free(data);
    11151104                return;
    … …  
    11171106
    11181107        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_recv_wait_srv(): rsize=%zu", size);
    1119         async_answer_1(icall_handle, EOK, rsize);
     1108        async_answer_1(icall, EOK, rsize);
    11201109        free(data);
    11211110
    … …  
    11711160/** Handle TCP client connection.
    11721161 *
    1173  * @param icall_handle  Connect call handle
    1174  * @param icall         Connect call data
    1175  * @param arg           Connection argument
    1176  */
    1177 static void tcp_client_conn(cap_call_handle_t icall_handle, ipc_call_t *icall,
    1178     void *arg)
     1162 * @param icall Connect call data
     1163 * @param arg   Connection argument
     1164 *
     1165 */
     1166static void tcp_client_conn(ipc_call_t *icall, void *arg)
    11791167{
    11801168        tcp_client_t client;
    11811169
    11821170        /* Accept the connection */
    1183         async_answer_0(icall_handle, EOK);
     1171        async_answer_0(icall, EOK);
    11841172
    11851173        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn() - client=%p",
    … …  
    11911179                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_client_conn: wait req");
    11921180                ipc_call_t call;
    1193                 cap_call_handle_t chandle = async_get_call(&call);
     1181                async_get_call(&call);
    11941182                sysarg_t method = IPC_GET_IMETHOD(call);
    11951183
    … …  
    11981186                if (!method) {
    11991187                        /* The other side has hung up */
    1200                         async_answer_0(chandle, EOK);
     1188                        async_answer_0(&call, EOK);
    12011189                        break;
    12021190                }
    … …  
    12041192                switch (method) {
    12051193                case TCP_CALLBACK_CREATE:
    1206                         tcp_callback_create_srv(&client, chandle, &call);
     1194                        tcp_callback_create_srv(&client, &call);
    12071195                        break;
    12081196                case TCP_CONN_CREATE:
    1209                         tcp_conn_create_srv(&client, chandle, &call);
     1197                        tcp_conn_create_srv(&client, &call);
    12101198                        break;
    12111199                case TCP_CONN_DESTROY:
    1212                         tcp_conn_destroy_srv(&client, chandle, &call);
     1200                        tcp_conn_destroy_srv(&client, &call);
    12131201                        break;
    12141202                case TCP_LISTENER_CREATE:
    1215                         tcp_listener_create_srv(&client, chandle, &call);
     1203                        tcp_listener_create_srv(&client, &call);
    12161204                        break;
    12171205                case TCP_LISTENER_DESTROY:
    1218                         tcp_listener_destroy_srv(&client, chandle, &call);
     1206                        tcp_listener_destroy_srv(&client, &call);
    12191207                        break;
    12201208                case TCP_CONN_SEND_FIN:
    1221                         tcp_conn_send_fin_srv(&client, chandle, &call);
     1209                        tcp_conn_send_fin_srv(&client, &call);
    12221210                        break;
    12231211                case TCP_CONN_PUSH:
    1224                         tcp_conn_push_srv(&client, chandle, &call);
     1212                        tcp_conn_push_srv(&client, &call);
    12251213                        break;
    12261214                case TCP_CONN_RESET:
    1227                         tcp_conn_reset_srv(&client, chandle, &call);
     1215                        tcp_conn_reset_srv(&client, &call);
    12281216                        break;
    12291217                case TCP_CONN_SEND:
    1230                         tcp_conn_send_srv(&client, chandle, &call);
     1218                        tcp_conn_send_srv(&client, &call);
    12311219                        break;
    12321220                case TCP_CONN_RECV:
    1233                         tcp_conn_recv_srv(&client, chandle, &call);
     1221                        tcp_conn_recv_srv(&client, &call);
    12341222                        break;
    12351223                case TCP_CONN_RECV_WAIT:
    1236                         tcp_conn_recv_wait_srv(&client, chandle, &call);
     1224                        tcp_conn_recv_wait_srv(&client, &call);
    12371225                        break;
    12381226                default:
    1239                         async_answer_0(chandle, ENOTSUP);
     1227                        async_answer_0(&call, ENOTSUP);
    12401228                        break;
    12411229                }
Note: See TracChangeset for help on using the changeset viewer.