Ignore:
Timestamp:
2011-02-09T11:46:47Z (14 years ago)
Author:
Martin Sucha <sucha14@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
cb15135a
Parents:
a49c4002 (diff), 0b37882 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

Local modifications:

  • change pipefs and ext2 to build again (use async_* calls instead of ipc_*)
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    ra49c4002 rcf2af94  
    4343#include <stdlib.h>
    4444#include <errno.h>
    45 
     45#include <task.h>
    4646#include <ipc/services.h>
    4747#include <ipc/socket.h>
    48 
    4948#include <net/modules.h>
    5049#include <net/in.h>
    … …  
    214213        callid = async_get_call(&call);
    215214
    216         switch (IPC_GET_METHOD(call)) {
     215        switch (IPC_GET_IMETHOD(call)) {
    217216        case NET_SOCKET_RECEIVED:
    218217        case NET_SOCKET_ACCEPTED:
    … …  
    220219                fibril_rwlock_read_lock(&socket_globals.lock);
    221220
    222                 // find the socket
     221                /* Find the socket */
    223222                socket = sockets_find(socket_get_sockets(),
    224223                    SOCKET_GET_SOCKET_ID(call));
    … …  
    229228                }
    230229               
    231                 switch (IPC_GET_METHOD(call)) {
     230                switch (IPC_GET_IMETHOD(call)) {
    232231                case NET_SOCKET_RECEIVED:
    233232                        fibril_mutex_lock(&socket->receive_lock);
    234                         // push the number of received packet fragments
     233                        /* Push the number of received packet fragments */
    235234                        rc = dyn_fifo_push(&socket->received,
    236235                            SOCKET_GET_DATA_FRAGMENTS(call),
    237236                            SOCKET_MAX_RECEIVED_SIZE);
    238237                        if (rc == EOK) {
    239                                 // signal the received packet
     238                                /* Signal the received packet */
    240239                                fibril_condvar_signal(&socket->receive_signal);
    241240                        }
    … …  
    244243
    245244                case NET_SOCKET_ACCEPTED:
    246                         // push the new socket identifier
     245                        /* Push the new socket identifier */
    247246                        fibril_mutex_lock(&socket->accept_lock);
    248247                        rc = dyn_fifo_push(&socket->accepted, 1,
    249248                            SOCKET_MAX_ACCEPTED_SIZE);
    250249                        if (rc == EOK) {
    251                                 // signal the accepted socket
     250                                /* Signal the accepted socket */
    252251                                fibril_condvar_signal(&socket->accept_signal);
    253252                        }
    … …  
    264263                        fibril_rwlock_write_lock(&socket->sending_lock);
    265264
    266                         // set the data fragment size
     265                        /* Set the data fragment size */
    267266                        socket->data_fragment_size =
    268267                            SOCKET_GET_DATA_FRAGMENT_SIZE(call);
    … …  
    278277        }
    279278
    280         ipc_answer_0(callid, (ipcarg_t) rc);
     279        async_answer_0(callid, (sysarg_t) rc);
    281280        goto loop;
    282281}
    … …  
    342341                        socket_id = 1;
    343342                        ++count;
    344                 // only this branch for last_id
     343                /* Only this branch for last_id */
    345344                } else {
    346345                        if (socket_id < INT_MAX) {
    … …  
    404403        int socket_id;
    405404        services_t service;
    406         ipcarg_t fragment_size;
    407         ipcarg_t header_size;
     405        sysarg_t fragment_size;
     406        sysarg_t header_size;
    408407        int rc;
    409408
    410         // find the appropriate service
     409        /* Find the appropriate service */
    411410        switch (domain) {
    412411        case PF_INET:
    … …  
    457456                return phone;
    458457
    459         // create a new socket structure
     458        /* Create a new socket structure */
    460459        socket = (socket_t *) malloc(sizeof(socket_t));
    461460        if (!socket)
    … …  
    465464        fibril_rwlock_write_lock(&socket_globals.lock);
    466465
    467         // request a new socket
     466        /* Request a new socket */
    468467        socket_id = socket_generate_new_id();
    469468        if (socket_id <= 0) {
    … …  
    484483        socket->header_size = (size_t) header_size;
    485484
    486         // finish the new socket initialization
     485        /* Finish the new socket initialization */
    487486        socket_initialize(socket, socket_id, phone, service);
    488         // store the new socket
     487        /* Store the new socket */
    489488        rc = sockets_add(socket_get_sockets(), socket_id, socket);
    490489
    … …  
    494493                dyn_fifo_destroy(&socket->accepted);
    495494                free(socket);
    496                 async_msg_3(phone, NET_SOCKET_CLOSE, (ipcarg_t) socket_id, 0,
     495                async_msg_3(phone, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
    497496                    service);
    498497                return rc;
    … …  
    516515 */
    517516static int
    518 socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2,
     517socket_send_data(int socket_id, sysarg_t message, sysarg_t arg2,
    519518    const void *data, size_t datalength)
    520519{
    521520        socket_t *socket;
    522521        aid_t message_id;
    523         ipcarg_t result;
     522        sysarg_t result;
    524523
    525524        if (!data)
    … …  
    531530        fibril_rwlock_read_lock(&socket_globals.lock);
    532531
    533         // find the socket
     532        /* Find the socket */
    534533        socket = sockets_find(socket_get_sockets(), socket_id);
    535534        if (!socket) {
    … …  
    538537        }
    539538
    540         // request the message
     539        /* Request the message */
    541540        message_id = async_send_3(socket->phone, message,
    542             (ipcarg_t) socket->socket_id, arg2, socket->service, NULL);
    543         // send the address
     541            (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
     542        /* Send the address */
    544543        async_data_write_start(socket->phone, data, datalength);
    545544
    … …  
    566565                return EINVAL;
    567566
    568         // send the address
     567        /* Send the address */
    569568        return socket_send_data(socket_id, NET_SOCKET_BIND, 0, my_addr,
    570569            (size_t) addrlen);
    … …  
    591590        fibril_rwlock_read_lock(&socket_globals.lock);
    592591
    593         // find the socket
     592        /* Find the socket */
    594593        socket = sockets_find(socket_get_sockets(), socket_id);
    595594        if (!socket) {
    … …  
    598597        }
    599598
    600         // request listen backlog change
     599        /* Request listen backlog change */
    601600        result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN,
    602             (ipcarg_t) socket->socket_id, (ipcarg_t) backlog, socket->service);
     601            (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service);
    603602
    604603        fibril_rwlock_read_unlock(&socket_globals.lock);
    … …  
    625624        socket_t *new_socket;
    626625        aid_t message_id;
    627         ipcarg_t ipc_result;
     626        sysarg_t ipc_result;
    628627        int result;
    629628        ipc_call_t answer;
    … …  
    634633        fibril_rwlock_write_lock(&socket_globals.lock);
    635634
    636         // find the socket
     635        /* Find the socket */
    637636        socket = sockets_find(socket_get_sockets(), socket_id);
    638637        if (!socket) {
    … …  
    643642        fibril_mutex_lock(&socket->accept_lock);
    644643
    645         // wait for an accepted socket
     644        /* Wait for an accepted socket */
    646645        ++ socket->blocked;
    647646        while (dyn_fifo_value(&socket->accepted) <= 0) {
    648647                fibril_rwlock_write_unlock(&socket_globals.lock);
    649648                fibril_condvar_wait(&socket->accept_signal, &socket->accept_lock);
    650                 // drop the accept lock to avoid deadlock
     649                /* Drop the accept lock to avoid deadlock */
    651650                fibril_mutex_unlock(&socket->accept_lock);
    652651                fibril_rwlock_write_lock(&socket_globals.lock);
    … …  
    655654        -- socket->blocked;
    656655
    657         // create a new scoket
     656        /* Create a new socket */
    658657        new_socket = (socket_t *) malloc(sizeof(socket_t));
    659658        if (!new_socket) {
    … …  
    681680        }
    682681
    683         // request accept
     682        /* Request accept */
    684683        message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT,
    685             (ipcarg_t) socket->socket_id, 0, socket->service, 0,
     684            (sysarg_t) socket->socket_id, 0, socket->service, 0,
    686685            new_socket->socket_id, &answer);
    687686
    688         // read address
    689         ipc_data_read_start(socket->phone, cliaddr, *addrlen);
     687        /* Read address */
     688        async_data_read_start(socket->phone, cliaddr, *addrlen);
    690689        fibril_rwlock_write_unlock(&socket_globals.lock);
    691690        async_wait_for(message_id, &ipc_result);
    … …  
    695694                        result = EINVAL;
    696695
    697                 // dequeue the accepted socket if successful
     696                /* Dequeue the accepted socket if successful */
    698697                dyn_fifo_pop(&socket->accepted);
    699                 // set address length
     698                /* Set address length */
    700699                *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    701700                new_socket->data_fragment_size =
    702701                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    703702        } else if (result == ENOTSOCK) {
    704                 // empty the queue if no accepted sockets
     703                /* Empty the queue if no accepted sockets */
    705704                while (dyn_fifo_pop(&socket->accepted) > 0)
    706705                        ;
    … …  
    731730                return EDESTADDRREQ;
    732731
    733         // send the address
     732        /* Send the address */
    734733        return socket_send_data(socket_id, NET_SOCKET_CONNECT, 0, serv_addr,
    735734            addrlen);
    … …  
    744743        int accepted_id;
    745744
    746         // destroy all accepted sockets
     745        /* Destroy all accepted sockets */
    747746        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
    748747                socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
    … …  
    780779        }
    781780
    782         // request close
     781        /* Request close */
    783782        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
    784             (ipcarg_t) socket->socket_id, 0, socket->service);
     783            (sysarg_t) socket->socket_id, 0, socket->service);
    785784        if (rc != EOK) {
    786785                fibril_rwlock_write_unlock(&socket_globals.lock);
    787786                return rc;
    788787        }
    789         // free the socket structure
     788        /* Free the socket structure */
    790789        socket_destroy(socket);
    791790
    … …  
    815814 */
    816815static int
    817 sendto_core(ipcarg_t message, int socket_id, const void *data,
     816sendto_core(sysarg_t message, int socket_id, const void *data,
    818817    size_t datalength, int flags, const struct sockaddr *toaddr,
    819818    socklen_t addrlen)
    … …  
    821820        socket_t *socket;
    822821        aid_t message_id;
    823         ipcarg_t result;
     822        sysarg_t result;
    824823        size_t fragments;
    825824        ipc_call_t answer;
    … …  
    833832        fibril_rwlock_read_lock(&socket_globals.lock);
    834833
    835         // find socket
     834        /* Find socket */
    836835        socket = sockets_find(socket_get_sockets(), socket_id);
    837836        if (!socket) {
    … …  
    842841        fibril_rwlock_read_lock(&socket->sending_lock);
    843842
    844         // compute data fragment count
     843        /* Compute data fragment count */
    845844        if (socket->data_fragment_size > 0) {
    846845                fragments = (datalength + socket->header_size) /
    … …  
    853852        }
    854853
    855         // request send
     854        /* Request send */
    856855        message_id = async_send_5(socket->phone, message,
    857             (ipcarg_t) socket->socket_id,
     856            (sysarg_t) socket->socket_id,
    858857            (fragments == 1 ? datalength : socket->data_fragment_size),
    859             socket->service, (ipcarg_t) flags, fragments, &answer);
    860 
    861         // send the address if given
     858            socket->service, (sysarg_t) flags, fragments, &answer);
     859
     860        /* Send the address if given */
    862861        if (!toaddr ||
    863862            (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)) {
    864863                if (fragments == 1) {
    865                         // send all if only one fragment
     864                        /* Send all if only one fragment */
    866865                        async_data_write_start(socket->phone, data, datalength);
    867866                } else {
    868                         // send the first fragment
     867                        /* Send the first fragment */
    869868                        async_data_write_start(socket->phone, data,
    870869                            socket->data_fragment_size - socket->header_size);
    … …  
    872871                            socket->data_fragment_size - socket->header_size;
    873872       
    874                         // send the middle fragments
     873                        /* Send the middle fragments */
    875874                        while (--fragments > 1) {
    876875                                async_data_write_start(socket->phone, data,
    … …  
    880879                        }
    881880
    882                         // send the last fragment
     881                        /* Send the last fragment */
    883882                        async_data_write_start(socket->phone, data,
    884883                            (datalength + socket->header_size) %
    … …  
    892891            (SOCKET_GET_DATA_FRAGMENT_SIZE(answer) !=
    893892            socket->data_fragment_size)) {
    894                 // set the data fragment size
     893                /* Set the data fragment size */
    895894                socket->data_fragment_size =
    896895                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    … …  
    917916int send(int socket_id, void *data, size_t datalength, int flags)
    918917{
    919         // without the address
     918        /* Without the address */
    920919        return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags,
    921920            NULL, 0);
    … …  
    950949                return EDESTADDRREQ;
    951950
    952         // with the address
     951        /* With the address */
    953952        return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength,
    954953            flags, toaddr, addrlen);
    … …  
    966965 *                      read. The actual address length is set. Used only if
    967966 *                      fromaddr is not NULL.
    968  * @return              EOK on success.
     967 * @return              Positive received message size in bytes on success.
     968 * @return              Zero if no more data (other side closed the connection).
    969969 * @return              ENOTSOCK if the socket is not found.
    970970 * @return              EBADMEM if the data parameter is NULL.
    … …  
    972972 * @return              Other error codes as defined for the spcific message.
    973973 */
    974 static int
    975 recvfrom_core(ipcarg_t message, int socket_id, void *data, size_t datalength,
     974static ssize_t
     975recvfrom_core(sysarg_t message, int socket_id, void *data, size_t datalength,
    976976    int flags, struct sockaddr *fromaddr, socklen_t *addrlen)
    977977{
    978978        socket_t *socket;
    979979        aid_t message_id;
    980         ipcarg_t ipc_result;
     980        sysarg_t ipc_result;
    981981        int result;
    982982        size_t fragments;
    … …  
    984984        size_t index;
    985985        ipc_call_t answer;
     986        ssize_t retval;
    986987
    987988        if (!data)
    … …  
    996997        fibril_rwlock_read_lock(&socket_globals.lock);
    997998
    998         // find the socket
     999        /* Find the socket */
    9991000        socket = sockets_find(socket_get_sockets(), socket_id);
    10001001        if (!socket) {
    … …  
    10041005
    10051006        fibril_mutex_lock(&socket->receive_lock);
    1006         // wait for a received packet
     1007        /* Wait for a received packet */
    10071008        ++socket->blocked;
    1008         while ((result = dyn_fifo_value(&socket->received)) <= 0) {
     1009        while ((result = dyn_fifo_value(&socket->received)) < 0) {
    10091010                fibril_rwlock_read_unlock(&socket_globals.lock);
    10101011                fibril_condvar_wait(&socket->receive_signal,
    10111012                    &socket->receive_lock);
    10121013
    1013                 // drop the receive lock to avoid deadlock
     1014                /* Drop the receive lock to avoid deadlock */
    10141015                fibril_mutex_unlock(&socket->receive_lock);
    10151016                fibril_rwlock_read_lock(&socket_globals.lock);
    … …  
    10191020        fragments = (size_t) result;
    10201021
    1021         // prepare lengths if more fragments
     1022        if (fragments == 0) {
     1023                /* No more data, other side has closed the connection. */
     1024                fibril_mutex_unlock(&socket->receive_lock);
     1025                fibril_rwlock_read_unlock(&socket_globals.lock);
     1026                return 0;
     1027        }
     1028
     1029        /* Prepare lengths if more fragments */
    10221030        if (fragments > 1) {
    10231031                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    … …  
    10291037                }
    10301038
    1031                 // request packet data
     1039                /* Request packet data */
    10321040                message_id = async_send_4(socket->phone, message,
    1033                     (ipcarg_t) socket->socket_id, 0, socket->service,
    1034                     (ipcarg_t) flags, &answer);
    1035 
    1036                 // read the address if desired
     1041                    (sysarg_t) socket->socket_id, 0, socket->service,
     1042                    (sysarg_t) flags, &answer);
     1043
     1044                /* Read the address if desired */
    10371045                if(!fromaddr ||
    10381046                    (async_data_read_start(socket->phone, fromaddr,
    10391047                    *addrlen) == EOK)) {
    1040                         // read the fragment lengths
     1048                        /* Read the fragment lengths */
    10411049                        if (async_data_read_start(socket->phone, lengths,
    10421050                            sizeof(int) * (fragments + 1)) == EOK) {
    10431051                                if (lengths[fragments] <= datalength) {
    10441052
    1045                                         // read all fragments if long enough
     1053                                        /* Read all fragments if long enough */
    10461054                                        for (index = 0; index < fragments;
    10471055                                            ++index) {
    … …  
    10571065
    10581066                free(lengths);
    1059         } else {
    1060                 // request packet data
     1067        } else { /* fragments == 1 */
     1068                /* Request packet data */
    10611069                message_id = async_send_4(socket->phone, message,
    1062                     (ipcarg_t) socket->socket_id, 0, socket->service,
    1063                     (ipcarg_t) flags, &answer);
    1064 
    1065                 // read the address if desired
     1070                    (sysarg_t) socket->socket_id, 0, socket->service,
     1071                    (sysarg_t) flags, &answer);
     1072
     1073                /* Read the address if desired */
    10661074                if (!fromaddr ||
    10671075                    (async_data_read_start(socket->phone, fromaddr,
    10681076                        *addrlen) == EOK)) {
    1069                         // read all if only one fragment
     1077                        /* Read all if only one fragment */
    10701078                        async_data_read_start(socket->phone, data, datalength);
    10711079                }
    … …  
    10751083        result = (int) ipc_result;
    10761084        if (result == EOK) {
    1077                 // dequeue the received packet
     1085                /* Dequeue the received packet */
    10781086                dyn_fifo_pop(&socket->received);
    1079                 // return read data length
    1080                 result = SOCKET_GET_READ_DATA_LENGTH(answer);
    1081                 // set address length
     1087                /* Return read data length */
     1088                retval = SOCKET_GET_READ_DATA_LENGTH(answer);
     1089                /* Set address length */
    10821090                if (fromaddr && addrlen)
    10831091                        *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
     1092        } else {
     1093                retval = (ssize_t) result;
    10841094        }
    10851095
    10861096        fibril_mutex_unlock(&socket->receive_lock);
    10871097        fibril_rwlock_read_unlock(&socket_globals.lock);
    1088         return result;
     1098        return retval;
    10891099}
    10901100
    … …  
    10951105 * @param[in] datalength The data length.
    10961106 * @param[in] flags     Various receive flags.
    1097  * @return              EOK on success.
     1107 * @return              Positive received message size in bytes on success.
     1108 * @return              Zero if no more data (other side closed the connection).
    10981109 * @return              ENOTSOCK if the socket is not found.
    10991110 * @return              EBADMEM if the data parameter is NULL.
    … …  
    11021113 *                      message.
    11031114 */
    1104 int recv(int socket_id, void *data, size_t datalength, int flags)
    1105 {
    1106         // without the address
     1115ssize_t recv(int socket_id, void *data, size_t datalength, int flags)
     1116{
     1117        /* Without the address */
    11071118        return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength,
    11081119            flags, NULL, NULL);
    … …  
    11181129 * @param[in,out] addrlen The address length. The maximum address length is
    11191130 *                      read. The actual address length is set.
    1120  * @return              EOK on success.
     1131 * @return              Positive received message size in bytes on success.
     1132 * @return              Zero if no more data (other side closed the connection).
    11211133 * @return              ENOTSOCK if the socket is not found.
    11221134 * @return              EBADMEM if the data or fromaddr parameter is NULL.
    … …  
    11251137 *                      message.
    11261138 */
    1127 int
     1139ssize_t
    11281140recvfrom(int socket_id, void *data, size_t datalength, int flags,
    11291141    struct sockaddr *fromaddr, socklen_t *addrlen)
    … …  
    11351147                return NO_DATA;
    11361148
    1137         // with the address
     1149        /* With the address */
    11381150        return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength,
    11391151            flags, fromaddr, addrlen);
    … …  
    11601172        socket_t *socket;
    11611173        aid_t message_id;
    1162         ipcarg_t result;
     1174        sysarg_t result;
    11631175
    11641176        if (!value || !optlen)
    … …  
    11701182        fibril_rwlock_read_lock(&socket_globals.lock);
    11711183
    1172         // find the socket
     1184        /* Find the socket */
    11731185        socket = sockets_find(socket_get_sockets(), socket_id);
    11741186        if (!socket) {
    … …  
    11771189        }
    11781190
    1179         // request option value
     1191        /* Request option value */
    11801192        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
    1181             (ipcarg_t) socket->socket_id, (ipcarg_t) optname, socket->service,
     1193            (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
    11821194            NULL);
    11831195
    1184         // read the length
     1196        /* Read the length */
    11851197        if (async_data_read_start(socket->phone, optlen,
    11861198            sizeof(*optlen)) == EOK) {
    1187                 // read the value
     1199                /* Read the value */
    11881200                async_data_read_start(socket->phone, value, *optlen);
    11891201        }
    … …  
    12121224    size_t optlen)
    12131225{
    1214         // send the value
     1226        /* Send the value */
    12151227        return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT,
    1216             (ipcarg_t) optname, value, optlen);
     1228            (sysarg_t) optname, value, optlen);
    12171229}
    12181230
Note: See TracChangeset for help on using the changeset viewer.