Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/net/socket_client.c

    rb35fea3 r228e490  
    220220                fibril_rwlock_read_lock(&socket_globals.lock);
    221221
    222                 /* Find the socket */
     222                // find the socket
    223223                socket = sockets_find(socket_get_sockets(),
    224224                    SOCKET_GET_SOCKET_ID(call));
    … …  
    232232                case NET_SOCKET_RECEIVED:
    233233                        fibril_mutex_lock(&socket->receive_lock);
    234                         /* Push the number of received packet fragments */
     234                        // push the number of received packet fragments
    235235                        rc = dyn_fifo_push(&socket->received,
    236236                            SOCKET_GET_DATA_FRAGMENTS(call),
    237237                            SOCKET_MAX_RECEIVED_SIZE);
    238238                        if (rc == EOK) {
    239                                 /* Signal the received packet */
     239                                // signal the received packet
    240240                                fibril_condvar_signal(&socket->receive_signal);
    241241                        }
    … …  
    244244
    245245                case NET_SOCKET_ACCEPTED:
    246                         /* Push the new socket identifier */
     246                        // push the new socket identifier
    247247                        fibril_mutex_lock(&socket->accept_lock);
    248248                        rc = dyn_fifo_push(&socket->accepted, 1,
    249249                            SOCKET_MAX_ACCEPTED_SIZE);
    250250                        if (rc == EOK) {
    251                                 /* Signal the accepted socket */
     251                                // signal the accepted socket
    252252                                fibril_condvar_signal(&socket->accept_signal);
    253253                        }
    … …  
    264264                        fibril_rwlock_write_lock(&socket->sending_lock);
    265265
    266                         /* Set the data fragment size */
     266                        // set the data fragment size
    267267                        socket->data_fragment_size =
    268268                            SOCKET_GET_DATA_FRAGMENT_SIZE(call);
    … …  
    342342                        socket_id = 1;
    343343                        ++count;
    344                 /* Only this branch for last_id */
     344                // only this branch for last_id
    345345                } else {
    346346                        if (socket_id < INT_MAX) {
    … …  
    408408        int rc;
    409409
    410         /* Find the appropriate service */
     410        // find the appropriate service
    411411        switch (domain) {
    412412        case PF_INET:
    … …  
    457457                return phone;
    458458
    459         /* Create a new socket structure */
     459        // create a new socket structure
    460460        socket = (socket_t *) malloc(sizeof(socket_t));
    461461        if (!socket)
    … …  
    465465        fibril_rwlock_write_lock(&socket_globals.lock);
    466466
    467         /* Request a new socket */
     467        // request a new socket
    468468        socket_id = socket_generate_new_id();
    469469        if (socket_id <= 0) {
    … …  
    484484        socket->header_size = (size_t) header_size;
    485485
    486         /* Finish the new socket initialization */
     486        // finish the new socket initialization
    487487        socket_initialize(socket, socket_id, phone, service);
    488         /* Store the new socket */
     488        // store the new socket
    489489        rc = sockets_add(socket_get_sockets(), socket_id, socket);
    490490
    … …  
    531531        fibril_rwlock_read_lock(&socket_globals.lock);
    532532
    533         /* Find the socket */
     533        // find the socket
    534534        socket = sockets_find(socket_get_sockets(), socket_id);
    535535        if (!socket) {
    … …  
    538538        }
    539539
    540         /* Request the message */
     540        // request the message
    541541        message_id = async_send_3(socket->phone, message,
    542542            (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
    543         /* Send the address */
     543        // send the address
    544544        async_data_write_start(socket->phone, data, datalength);
    545545
    … …  
    566566                return EINVAL;
    567567
    568         /* Send the address */
     568        // send the address
    569569        return socket_send_data(socket_id, NET_SOCKET_BIND, 0, my_addr,
    570570            (size_t) addrlen);
    … …  
    591591        fibril_rwlock_read_lock(&socket_globals.lock);
    592592
    593         /* Find the socket */
     593        // find the socket
    594594        socket = sockets_find(socket_get_sockets(), socket_id);
    595595        if (!socket) {
    … …  
    598598        }
    599599
    600         /* Request listen backlog change */
     600        // request listen backlog change
    601601        result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN,
    602602            (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service);
    … …  
    634634        fibril_rwlock_write_lock(&socket_globals.lock);
    635635
    636         /* Find the socket */
     636        // find the socket
    637637        socket = sockets_find(socket_get_sockets(), socket_id);
    638638        if (!socket) {
    … …  
    643643        fibril_mutex_lock(&socket->accept_lock);
    644644
    645         /* Wait for an accepted socket */
     645        // wait for an accepted socket
    646646        ++ socket->blocked;
    647647        while (dyn_fifo_value(&socket->accepted) <= 0) {
    648648                fibril_rwlock_write_unlock(&socket_globals.lock);
    649649                fibril_condvar_wait(&socket->accept_signal, &socket->accept_lock);
    650                 /* Drop the accept lock to avoid deadlock */
     650                // drop the accept lock to avoid deadlock
    651651                fibril_mutex_unlock(&socket->accept_lock);
    652652                fibril_rwlock_write_lock(&socket_globals.lock);
    … …  
    655655        -- socket->blocked;
    656656
    657         /* Create a new socket */
     657        // create a new scoket
    658658        new_socket = (socket_t *) malloc(sizeof(socket_t));
    659659        if (!new_socket) {
    … …  
    681681        }
    682682
    683         /* Request accept */
     683        // request accept
    684684        message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT,
    685685            (sysarg_t) socket->socket_id, 0, socket->service, 0,
    686686            new_socket->socket_id, &answer);
    687687
    688         /* Read address */
     688        // read address
    689689        ipc_data_read_start(socket->phone, cliaddr, *addrlen);
    690690        fibril_rwlock_write_unlock(&socket_globals.lock);
    … …  
    695695                        result = EINVAL;
    696696
    697                 /* Dequeue the accepted socket if successful */
     697                // dequeue the accepted socket if successful
    698698                dyn_fifo_pop(&socket->accepted);
    699                 /* Set address length */
     699                // set address length
    700700                *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    701701                new_socket->data_fragment_size =
    702702                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    703703        } else if (result == ENOTSOCK) {
    704                 /* Empty the queue if no accepted sockets */
     704                // empty the queue if no accepted sockets
    705705                while (dyn_fifo_pop(&socket->accepted) > 0)
    706706                        ;
    … …  
    731731                return EDESTADDRREQ;
    732732
    733         /* Send the address */
     733        // send the address
    734734        return socket_send_data(socket_id, NET_SOCKET_CONNECT, 0, serv_addr,
    735735            addrlen);
    … …  
    744744        int accepted_id;
    745745
    746         /* Destroy all accepted sockets */
     746        // destroy all accepted sockets
    747747        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
    748748                socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
    … …  
    780780        }
    781781
    782         /* Request close */
     782        // request close
    783783        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
    784784            (sysarg_t) socket->socket_id, 0, socket->service);
    … …  
    787787                return rc;
    788788        }
    789         /* Free the socket structure */
     789        // free the socket structure
    790790        socket_destroy(socket);
    791791
    … …  
    833833        fibril_rwlock_read_lock(&socket_globals.lock);
    834834
    835         /* Find socket */
     835        // find socket
    836836        socket = sockets_find(socket_get_sockets(), socket_id);
    837837        if (!socket) {
    … …  
    842842        fibril_rwlock_read_lock(&socket->sending_lock);
    843843
    844         /* Compute data fragment count */
     844        // compute data fragment count
    845845        if (socket->data_fragment_size > 0) {
    846846                fragments = (datalength + socket->header_size) /
    … …  
    853853        }
    854854
    855         /* Request send */
     855        // request send
    856856        message_id = async_send_5(socket->phone, message,
    857857            (sysarg_t) socket->socket_id,
    … …  
    859859            socket->service, (sysarg_t) flags, fragments, &answer);
    860860
    861         /* Send the address if given */
     861        // send the address if given
    862862        if (!toaddr ||
    863863            (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)) {
    864864                if (fragments == 1) {
    865                         /* Send all if only one fragment */
     865                        // send all if only one fragment
    866866                        async_data_write_start(socket->phone, data, datalength);
    867867                } else {
    868                         /* Send the first fragment */
     868                        // send the first fragment
    869869                        async_data_write_start(socket->phone, data,
    870870                            socket->data_fragment_size - socket->header_size);
    … …  
    872872                            socket->data_fragment_size - socket->header_size;
    873873       
    874                         /* Send the middle fragments */
     874                        // send the middle fragments
    875875                        while (--fragments > 1) {
    876876                                async_data_write_start(socket->phone, data,
    … …  
    880880                        }
    881881
    882                         /* Send the last fragment */
     882                        // send the last fragment
    883883                        async_data_write_start(socket->phone, data,
    884884                            (datalength + socket->header_size) %
    … …  
    892892            (SOCKET_GET_DATA_FRAGMENT_SIZE(answer) !=
    893893            socket->data_fragment_size)) {
    894                 /* Set the data fragment size */
     894                // set the data fragment size
    895895                socket->data_fragment_size =
    896896                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    … …  
    917917int send(int socket_id, void *data, size_t datalength, int flags)
    918918{
    919         /* Without the address */
     919        // without the address
    920920        return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags,
    921921            NULL, 0);
    … …  
    950950                return EDESTADDRREQ;
    951951
    952         /* With the address */
     952        // with the address
    953953        return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength,
    954954            flags, toaddr, addrlen);
    … …  
    966966 *                      read. The actual address length is set. Used only if
    967967 *                      fromaddr is not NULL.
    968  * @return              Positive received message size in bytes on success.
    969  * @return              Zero if no more data (other side closed the connection).
     968 * @return              EOK on success.
    970969 * @return              ENOTSOCK if the socket is not found.
    971970 * @return              EBADMEM if the data parameter is NULL.
    … …  
    973972 * @return              Other error codes as defined for the spcific message.
    974973 */
    975 static ssize_t
     974static int
    976975recvfrom_core(sysarg_t message, int socket_id, void *data, size_t datalength,
    977976    int flags, struct sockaddr *fromaddr, socklen_t *addrlen)
    … …  
    985984        size_t index;
    986985        ipc_call_t answer;
    987         ssize_t retval;
    988986
    989987        if (!data)
    … …  
    998996        fibril_rwlock_read_lock(&socket_globals.lock);
    999997
    1000         /* Find the socket */
     998        // find the socket
    1001999        socket = sockets_find(socket_get_sockets(), socket_id);
    10021000        if (!socket) {
    … …  
    10061004
    10071005        fibril_mutex_lock(&socket->receive_lock);
    1008         /* Wait for a received packet */
     1006        // wait for a received packet
    10091007        ++socket->blocked;
    1010         while ((result = dyn_fifo_value(&socket->received)) < 0) {
     1008        while ((result = dyn_fifo_value(&socket->received)) <= 0) {
    10111009                fibril_rwlock_read_unlock(&socket_globals.lock);
    10121010                fibril_condvar_wait(&socket->receive_signal,
    10131011                    &socket->receive_lock);
    10141012
    1015                 /* Drop the receive lock to avoid deadlock */
     1013                // drop the receive lock to avoid deadlock
    10161014                fibril_mutex_unlock(&socket->receive_lock);
    10171015                fibril_rwlock_read_lock(&socket_globals.lock);
    … …  
    10211019        fragments = (size_t) result;
    10221020
    1023         if (fragments == 0) {
    1024                 /* No more data, other side has closed the connection. */
    1025                 fibril_mutex_unlock(&socket->receive_lock);
    1026                 fibril_rwlock_read_unlock(&socket_globals.lock);
    1027                 return 0;
    1028         }
    1029 
    1030         /* Prepare lengths if more fragments */
     1021        // prepare lengths if more fragments
    10311022        if (fragments > 1) {
    10321023                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    … …  
    10381029                }
    10391030
    1040                 /* Request packet data */
     1031                // request packet data
    10411032                message_id = async_send_4(socket->phone, message,
    10421033                    (sysarg_t) socket->socket_id, 0, socket->service,
    10431034                    (sysarg_t) flags, &answer);
    10441035
    1045                 /* Read the address if desired */
     1036                // read the address if desired
    10461037                if(!fromaddr ||
    10471038                    (async_data_read_start(socket->phone, fromaddr,
    10481039                    *addrlen) == EOK)) {
    1049                         /* Read the fragment lengths */
     1040                        // read the fragment lengths
    10501041                        if (async_data_read_start(socket->phone, lengths,
    10511042                            sizeof(int) * (fragments + 1)) == EOK) {
    10521043                                if (lengths[fragments] <= datalength) {
    10531044
    1054                                         /* Read all fragments if long enough */
     1045                                        // read all fragments if long enough
    10551046                                        for (index = 0; index < fragments;
    10561047                                            ++index) {
    … …  
    10661057
    10671058                free(lengths);
    1068         } else { /* fragments == 1 */
    1069                 /* Request packet data */
     1059        } else {
     1060                // request packet data
    10701061                message_id = async_send_4(socket->phone, message,
    10711062                    (sysarg_t) socket->socket_id, 0, socket->service,
    10721063                    (sysarg_t) flags, &answer);
    10731064
    1074                 /* Read the address if desired */
     1065                // read the address if desired
    10751066                if (!fromaddr ||
    10761067                    (async_data_read_start(socket->phone, fromaddr,
    10771068                        *addrlen) == EOK)) {
    1078                         /* Read all if only one fragment */
     1069                        // read all if only one fragment
    10791070                        async_data_read_start(socket->phone, data, datalength);
    10801071                }
    … …  
    10841075        result = (int) ipc_result;
    10851076        if (result == EOK) {
    1086                 /* Dequeue the received packet */
     1077                // dequeue the received packet
    10871078                dyn_fifo_pop(&socket->received);
    1088                 /* Return read data length */
    1089                 retval = SOCKET_GET_READ_DATA_LENGTH(answer);
    1090                 /* Set address length */
     1079                // return read data length
     1080                result = SOCKET_GET_READ_DATA_LENGTH(answer);
     1081                // set address length
    10911082                if (fromaddr && addrlen)
    10921083                        *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    1093         } else {
    1094                 retval = (ssize_t) result;
    10951084        }
    10961085
    10971086        fibril_mutex_unlock(&socket->receive_lock);
    10981087        fibril_rwlock_read_unlock(&socket_globals.lock);
    1099         return retval;
     1088        return result;
    11001089}
    11011090
    … …  
    11061095 * @param[in] datalength The data length.
    11071096 * @param[in] flags     Various receive flags.
    1108  * @return              Positive received message size in bytes on success.
    1109  * @return              Zero if no more data (other side closed the connection).
     1097 * @return              EOK on success.
    11101098 * @return              ENOTSOCK if the socket is not found.
    11111099 * @return              EBADMEM if the data parameter is NULL.
    … …  
    11141102 *                      message.
    11151103 */
    1116 ssize_t recv(int socket_id, void *data, size_t datalength, int flags)
    1117 {
    1118         /* Without the address */
     1104int recv(int socket_id, void *data, size_t datalength, int flags)
     1105{
     1106        // without the address
    11191107        return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength,
    11201108            flags, NULL, NULL);
    … …  
    11301118 * @param[in,out] addrlen The address length. The maximum address length is
    11311119 *                      read. The actual address length is set.
    1132  * @return              Positive received message size in bytes on success.
    1133  * @return              Zero if no more data (other side closed the connection).
     1120 * @return              EOK on success.
    11341121 * @return              ENOTSOCK if the socket is not found.
    11351122 * @return              EBADMEM if the data or fromaddr parameter is NULL.
    … …  
    11381125 *                      message.
    11391126 */
    1140 ssize_t
     1127int
    11411128recvfrom(int socket_id, void *data, size_t datalength, int flags,
    11421129    struct sockaddr *fromaddr, socklen_t *addrlen)
    … …  
    11481135                return NO_DATA;
    11491136
    1150         /* With the address */
     1137        // with the address
    11511138        return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength,
    11521139            flags, fromaddr, addrlen);
    … …  
    11831170        fibril_rwlock_read_lock(&socket_globals.lock);
    11841171
    1185         /* Find the socket */
     1172        // find the socket
    11861173        socket = sockets_find(socket_get_sockets(), socket_id);
    11871174        if (!socket) {
    … …  
    11901177        }
    11911178
    1192         /* Request option value */
     1179        // request option value
    11931180        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
    11941181            (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
    11951182            NULL);
    11961183
    1197         /* Read the length */
     1184        // read the length
    11981185        if (async_data_read_start(socket->phone, optlen,
    11991186            sizeof(*optlen)) == EOK) {
    1200                 /* Read the value */
     1187                // read the value
    12011188                async_data_read_start(socket->phone, value, *optlen);
    12021189        }
    … …  
    12251212    size_t optlen)
    12261213{
    1227         /* Send the value */
     1214        // send the value
    12281215        return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT,
    12291216            (sysarg_t) optname, value, optlen);
Note: See TracChangeset for help on using the changeset viewer.