Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 0b81cad0 in mainline for uspace/srv/net/tl/tcp/tcp.c


Ignore:
Timestamp:
2010-11-06T00:19:13Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
1712f87
Parents:
0485135 (diff), 0578271 (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 from lp:~jakub/helenos/net.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/tl/tcp/tcp.c

    r0485135 r0b81cad0  
    4747#include <stdio.h>
    4848#include <errno.h>
    49 #include <err.h>
    5049
    5150#include <ipc/ipc.h>
     
    235234int tcp_initialize(async_client_conn_t client_connection)
    236235{
    237         ERROR_DECLARE;
     236        int rc;
    238237
    239238        assert(client_connection);
     
    246245        tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
    247246            SERVICE_TCP, client_connection);
    248         if (tcp_globals.ip_phone < 0)
     247        if (tcp_globals.ip_phone < 0) {
     248                fibril_rwlock_write_unlock(&tcp_globals.lock);
    249249                return tcp_globals.ip_phone;
     250        }
    250251       
    251         ERROR_PROPAGATE(socket_ports_initialize(&tcp_globals.sockets));
    252         if (ERROR_OCCURRED(packet_dimensions_initialize(
    253             &tcp_globals.dimensions))) {
     252        rc = socket_ports_initialize(&tcp_globals.sockets);
     253        if (rc != EOK)
     254                goto out;
     255
     256        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
     257        if (rc != EOK) {
    254258                socket_ports_destroy(&tcp_globals.sockets);
    255                 return ERROR_CODE;
     259                goto out;
    256260        }
    257261
    258262        tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
     263
     264out:
    259265        fibril_rwlock_write_unlock(&tcp_globals.lock);
    260 
    261         return EOK;
     266        return rc;
    262267}
    263268
     
    266271    services_t error)
    267272{
    268         ERROR_DECLARE;
     273        int rc;
    269274
    270275        if (receiver != SERVICE_TCP)
     
    272277
    273278        fibril_rwlock_write_lock(&tcp_globals.lock);
    274         if (ERROR_OCCURRED(tcp_process_packet(device_id, packet, error)))
     279        rc = tcp_process_packet(device_id, packet, error);
     280        if (rc != EOK)
    275281                fibril_rwlock_write_unlock(&tcp_globals.lock);
    276282
    277         printf("receive %d \n", ERROR_CODE);
    278 
    279         return ERROR_CODE;
     283        printf("receive %d \n", rc);
     284
     285        return rc;
    280286}
    281287
    282288int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error)
    283289{
    284         ERROR_DECLARE;
    285 
    286290        size_t length;
    287291        size_t offset;
     
    299303        struct sockaddr *dest;
    300304        size_t addrlen;
     305        int rc;
    301306
    302307        switch (error) {
     
    311316
    312317                length = (size_t) result;
    313                 if (ERROR_OCCURRED(packet_trim(packet, length, 0)))
    314                         return tcp_release_and_return(packet, ERROR_CODE);
     318                rc = packet_trim(packet, length, 0);
     319                if (rc != EOK)
     320                        return tcp_release_and_return(packet, rc);
    315321                break;
    316322        default:
     
    333339
    334340        // trim all but TCP header
    335         if (ERROR_OCCURRED(packet_trim(packet, offset, 0)))
    336                 return tcp_release_and_return(packet, ERROR_CODE);
     341        rc = packet_trim(packet, offset, 0);
     342        if (rc != EOK)
     343                return tcp_release_and_return(packet, rc);
    337344
    338345        // get tcp header
     
    350357        addrlen = (size_t) result;
    351358
    352         if (ERROR_OCCURRED(tl_set_address_port(src, addrlen,
    353             ntohs(header->source_port))))
    354                 return tcp_release_and_return(packet, ERROR_CODE);
     359        rc = tl_set_address_port(src, addrlen, ntohs(header->source_port));
     360        if (rc != EOK)
     361                return tcp_release_and_return(packet, rc);
    355362       
    356363        // find the destination socket
     
    413420                }
    414421
    415                 if (ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_TCP, src,
    416                     addrlen, dest, addrlen, total_length,
    417                     &socket_data->pseudo_header, &socket_data->headerlen))) {
     422                rc = ip_client_get_pseudo_header(IPPROTO_TCP, src, addrlen,
     423                    dest, addrlen, total_length, &socket_data->pseudo_header,
     424                    &socket_data->headerlen);
     425                if (rc != EOK) {
    418426                        fibril_rwlock_write_unlock(socket_data->local_lock);
    419                         return tcp_release_and_return(packet, ERROR_CODE);
    420                 }
    421 
    422         } else if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
    423             socket_data->pseudo_header, socket_data->headerlen,
    424             total_length))) {
    425                 fibril_rwlock_write_unlock(socket_data->local_lock);
    426                 return tcp_release_and_return(packet, ERROR_CODE);
     427                        return tcp_release_and_return(packet, rc);
     428                }
     429        } else {
     430                rc = ip_client_set_pseudo_header_data_length(
     431                    socket_data->pseudo_header, socket_data->headerlen,
     432                    total_length);
     433                if (rc != EOK) {
     434                        fibril_rwlock_write_unlock(socket_data->local_lock);
     435                        return tcp_release_and_return(packet, rc);
     436                }
    427437        }
    428438       
     
    434444                fibril_rwlock_write_unlock(socket_data->local_lock);
    435445
    436                 if (ERROR_NONE(tl_prepare_icmp_packet(tcp_globals.net_phone,
    437                     tcp_globals.icmp_phone, packet, error))) {
     446                rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
     447                    tcp_globals.icmp_phone, packet, error);
     448                if (rc == EOK) {
    438449                        // checksum error ICMP
    439450                        icmp_parameter_problem_msg(tcp_globals.icmp_phone,
     
    452463        switch (socket_data->state) {
    453464        case TCP_SOCKET_LISTEN:
    454                 ERROR_CODE = tcp_process_listen(socket, socket_data, header,
    455                     packet, src, dest, addrlen);
     465                rc = tcp_process_listen(socket, socket_data, header, packet,
     466                    src, dest, addrlen);
    456467                break;
    457468        case TCP_SOCKET_SYN_RECEIVED:
    458                 ERROR_CODE = tcp_process_syn_received(socket, socket_data,
    459                     header, packet);
     469                rc = tcp_process_syn_received(socket, socket_data, header,
     470                    packet);
    460471                break;
    461472        case TCP_SOCKET_SYN_SENT:
    462                 ERROR_CODE = tcp_process_syn_sent(socket, socket_data, header,
    463                     packet);
     473                rc = tcp_process_syn_sent(socket, socket_data, header, packet);
    464474                break;
    465475        case TCP_SOCKET_FIN_WAIT_1:
     
    472482                // ack releasing the socket gets processed later
    473483        case TCP_SOCKET_ESTABLISHED:
    474                 ERROR_CODE = tcp_process_established(socket, socket_data,
    475                     header, packet, fragments, total_length);
     484                rc = tcp_process_established(socket, socket_data, header,
     485                    packet, fragments, total_length);
    476486                break;
    477487        default:
     
    479489        }
    480490
    481         if (ERROR_CODE != EOK) {
    482                 printf("process %d\n", ERROR_CODE);
     491        if (rc != EOK) {
    483492                fibril_rwlock_write_unlock(socket_data->local_lock);
     493                printf("process %d\n", rc);
    484494        }
    485495
     
    491501    tcp_header_ref header, packet_t packet, int fragments, size_t total_length)
    492502{
    493         ERROR_DECLARE;
    494 
    495503        packet_t next_packet;
    496504        packet_t tmp_packet;
     
    501509        size_t offset;
    502510        uint32_t new_sequence_number;
     511        int rc;
    503512
    504513        assert(socket);
     
    541550                }
    542551
    543                 if ((offset > 0) && (ERROR_OCCURRED(packet_trim(packet,
    544                     offset, 0))))
    545                         return tcp_release_and_return(packet, ERROR_CODE);
     552                if (offset > 0) {
     553                        rc = packet_trim(packet, offset, 0);
     554                        if (rc != EOK)
     555                                return tcp_release_and_return(packet, rc);
     556                }
    546557
    547558                assert(new_sequence_number == socket_data->next_incoming);
     
    575586                        if (length <= offset)
    576587                                next_packet = pq_next(next_packet);
    577                         else if (ERROR_OCCURRED(packet_trim(next_packet, 0,
    578                             length - offset)))
    579                                 return tcp_release_and_return(packet,
    580                                     ERROR_CODE);
     588                        else {
     589                                rc = packet_trim(next_packet, 0,
     590                                    length - offset));
     591                                if (rc != EOK)
     592                                        return tcp_release_and_return(packet,
     593                                            rc);
     594                        }
    581595                        offset -= length;
    582596                        total_length -= length - offset;
     
    603617                // remove the header
    604618                total_length -= TCP_HEADER_LENGTH(header);
    605                 if (ERROR_OCCURRED(packet_trim(packet,
    606                     TCP_HEADER_LENGTH(header), 0)))
    607                         return tcp_release_and_return(packet, ERROR_CODE);
     619                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
     620                if (rc != EOK)
     621                        return tcp_release_and_return(packet, rc);
    608622
    609623                if (total_length) {
    610                         ERROR_PROPAGATE(tcp_queue_received_packet(socket,
    611                             socket_data, packet, fragments, total_length));
     624                        rc = tcp_queue_received_packet(socket, socket_data,
     625                            packet, fragments, total_length);
     626                        if (rc != EOK)
     627                                return rc;
    612628                } else {
    613629                        total_length = 1;
     
    617633                packet = socket_data->incoming;
    618634                while (packet) {
    619 
    620                         if (ERROR_OCCURRED(pq_get_order(socket_data->incoming,
    621                             &order, NULL))) {
     635                        rc = pq_get_order(socket_data->incoming, &order, NULL);
     636                        if (rc != EOK) {
    622637                                // remove the corrupted packet
    623638                                next_packet = pq_detach(packet);
     
    656671                                    socket_data->next_incoming) {
    657672                                        // queue received data
    658                                         ERROR_PROPAGATE(
    659                                             tcp_queue_received_packet(socket,
     673                                        rc = tcp_queue_received_packet(socket,
    660674                                            socket_data, packet, 1,
    661                                             packet_get_data_length(packet)));
     675                                            packet_get_data_length(packet));
     676                                        if (rc != EOK)
     677                                                return rc;
    662678                                        socket_data->next_incoming =
    663679                                            new_sequence_number;
     
    677693                                                    new_sequence_number;
    678694                                        }
    679                                         if (ERROR_NONE(packet_trim(packet,
    680                                             length, 0))) {
     695                                        rc = packet_trim(packet,length, 0);
     696                                        if (rc == EOK) {
    681697                                                // queue received data
    682                                                 ERROR_PROPAGATE(
    683                                                     tcp_queue_received_packet(
     698                                                rc = tcp_queue_received_packet(
    684699                                                    socket, socket_data, packet,
    685700                                                    1, packet_get_data_length(
    686                                                     packet)));
     701                                                    packet));
     702                                                if (rc != EOK)
     703                                                        return rc;
    687704                                                socket_data->next_incoming =
    688705                                                    new_sequence_number;
     
    709726                // remove the header
    710727                total_length -= TCP_HEADER_LENGTH(header);
    711                 if (ERROR_OCCURRED(packet_trim(packet,
    712                     TCP_HEADER_LENGTH(header), 0)))
    713                         return tcp_release_and_return(packet, ERROR_CODE);
     728                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
     729                if (rc != EOK)
     730                        return tcp_release_and_return(packet, rc);
    714731
    715732                next_packet = pq_detach(packet);
    716733                length = packet_get_data_length(packet);
    717                 if (ERROR_OCCURRED(pq_add(&socket_data->incoming, packet,
    718                     new_sequence_number, length))) {
     734                rc = pq_add(&socket_data->incoming, packet, new_sequence_number,
     735                    length);
     736                if (rc != EOK) {
    719737                        // remove the corrupted packets
    720738                        pq_release_remote(tcp_globals.net_phone,
     
    727745                                tmp_packet = pq_detach(next_packet);
    728746                                length = packet_get_data_length(next_packet);
    729                                 if (ERROR_OCCURRED(pq_set_order(next_packet,
    730                                     new_sequence_number, length)) ||
    731                                     ERROR_OCCURRED(pq_insert_after(packet,
    732                                     next_packet))) {
     747
     748                                rc = pq_set_order(next_packet,
     749                                    new_sequence_number, length);
     750                                if (rc != EOK) {
     751                                        pq_release_remote(tcp_globals.net_phone,
     752                                            packet_get_id(next_packet));
     753                                }
     754                                rc = pq_insert_after(packet, next_packet);
     755                                if (rc != EOK) {
    733756                                        pq_release_remote(tcp_globals.net_phone,
    734757                                            packet_get_id(next_packet));
     
    762785        if (!packet) {
    763786                // create the notification packet
    764                 ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
    765                     socket_data, 0, 0));
    766                 ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data,
    767                     packet, 1));
     787                rc = tcp_create_notification_packet(&packet, socket,
     788                    socket_data, 0, 0);
     789                if (rc != EOK)
     790                        return rc;
     791                rc = tcp_queue_prepare_packet(socket, socket_data, packet, 1);
     792                if (rc != EOK)
     793                        return rc;
    768794                packet = tcp_send_prepare_packet(socket, socket_data, packet, 1,
    769795                    socket_data->last_outgoing + 1);
     
    783809    size_t total_length)
    784810{
    785         ERROR_DECLARE;
    786 
    787811        packet_dimension_ref packet_dimension;
     812        int rc;
    788813
    789814        assert(socket);
     
    795820
    796821        // queue the received packet
    797         if (ERROR_OCCURRED(dyn_fifo_push(&socket->received,
    798             packet_get_id(packet), SOCKET_MAX_RECEIVED_SIZE)) ||
    799             ERROR_OCCURRED(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    800             &tcp_globals.dimensions, socket_data->device_id,
    801             &packet_dimension))) {
    802                 return tcp_release_and_return(packet, ERROR_CODE);
    803         }
     822        rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
     823            SOCKET_MAX_RECEIVED_SIZE);
     824        if (rc != EOK)
     825                return tcp_release_and_return(packet, rc);
     826        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     827            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
     828        if (rc != EOK)
     829                return tcp_release_and_return(packet, rc);
    804830
    805831        // decrease the window size
     
    820846    tcp_header_ref header, packet_t packet)
    821847{
    822         ERROR_DECLARE;
    823 
    824848        packet_t next_packet;
     849        int rc;
    825850
    826851        assert(socket);
     
    844869        }
    845870        // trim if longer than the header
    846         if ((packet_get_data_length(packet) > sizeof(*header)) &&
    847             ERROR_OCCURRED(packet_trim(packet, 0,
    848             packet_get_data_length(packet) - sizeof(*header)))) {
    849                 return tcp_release_and_return(packet, ERROR_CODE);
     871        if (packet_get_data_length(packet) > sizeof(*header)) {
     872                rc = packet_trim(packet, 0,
     873                    packet_get_data_length(packet) - sizeof(*header));
     874                if (rc != EOK)
     875                        return tcp_release_and_return(packet, rc);
    850876        }
    851877        tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
     
    876902    size_t addrlen)
    877903{
    878         ERROR_DECLARE;
    879 
    880904        packet_t next_packet;
    881905        socket_core_ref socket;
     
    884908        int listening_socket_id = listening_socket->socket_id;
    885909        int listening_port = listening_socket->port;
     910        int rc;
    886911
    887912        assert(listening_socket);
     
    913938        memcpy(socket_data->addr, src, socket_data->addrlen);
    914939        socket_data->dest_port = ntohs(header->source_port);
    915         if (ERROR_OCCURRED(tl_set_address_port(socket_data->addr,
    916             socket_data->addrlen, socket_data->dest_port))) {
     940        rc = tl_set_address_port(socket_data->addr, socket_data->addrlen,
     941            socket_data->dest_port);
     942        if (rc != EOK) {
    917943                free(socket_data->addr);
    918944                free(socket_data);
    919                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    920                 return ERROR_CODE;
     945                return tcp_release_and_return(packet, rc);
    921946        }
    922947
    923948        // create a socket
    924949        socket_id = -1;
    925         if (ERROR_OCCURRED(socket_create(socket_data->local_sockets,
    926             listening_socket->phone, socket_data, &socket_id))) {
     950        rc = socket_create(socket_data->local_sockets, listening_socket->phone,
     951            socket_data, &socket_id);
     952        if (rc != EOK) {
    927953                free(socket_data->addr);
    928954                free(socket_data);
    929                 return tcp_release_and_return(packet, ERROR_CODE);
     955                return tcp_release_and_return(packet, rc);
    930956        }
    931957
     
    964990        assert(socket_data);
    965991
    966         ERROR_CODE = socket_port_add(&tcp_globals.sockets, listening_port,
    967             socket, (const char *) socket_data->addr, socket_data->addrlen);
     992        rc = socket_port_add(&tcp_globals.sockets, listening_port, socket,
     993            (const char *) socket_data->addr, socket_data->addrlen);
    968994        assert(socket == socket_port_find(&tcp_globals.sockets, listening_port,
    969995            (const char *) socket_data->addr, socket_data->addrlen));
    970996
    971 //      ERROR_CODE = socket_bind_free_port(&tcp_globals.sockets, socket,
     997//      rc = socket_bind_free_port(&tcp_globals.sockets, socket,
    972998//          TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    973999//          tcp_globals.last_used_port);
    9741000//      tcp_globals.last_used_port = socket->port;
    9751001        fibril_rwlock_write_unlock(&tcp_globals.lock);
    976         if (ERROR_CODE != EOK) {
     1002        if (rc != EOK) {
    9771003                socket_destroy(tcp_globals.net_phone, socket->socket_id,
    9781004                    socket_data->local_sockets, &tcp_globals.sockets,
    9791005                    tcp_free_socket_data);
    980                 return tcp_release_and_return(packet, ERROR_CODE);
     1006                return tcp_release_and_return(packet, rc);
    9811007        }
    9821008
     
    9921018
    9931019        // trim if longer than the header
    994         if ((packet_get_data_length(packet) > sizeof(*header)) &&
    995             ERROR_OCCURRED(packet_trim(packet, 0,
    996             packet_get_data_length(packet) - sizeof(*header)))) {
     1020        if (packet_get_data_length(packet) > sizeof(*header)) {
     1021                rc = packet_trim(packet, 0,
     1022                    packet_get_data_length(packet) - sizeof(*header));
     1023                if (rc != EOK) {
     1024                        socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1025                            socket_data->local_sockets, &tcp_globals.sockets,
     1026                            tcp_free_socket_data);
     1027                        return tcp_release_and_return(packet, rc);
     1028                }
     1029        }
     1030
     1031        tcp_prepare_operation_header(socket, socket_data, header, 1, 0);
     1032
     1033        rc = tcp_queue_packet(socket, socket_data, packet, 1);
     1034        if (rc != EOK) {
    9971035                socket_destroy(tcp_globals.net_phone, socket->socket_id,
    9981036                    socket_data->local_sockets, &tcp_globals.sockets,
    9991037                    tcp_free_socket_data);
    1000                 return tcp_release_and_return(packet, ERROR_CODE);
    1001         }
    1002 
    1003         tcp_prepare_operation_header(socket, socket_data, header, 1, 0);
    1004 
    1005         if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1))) {
    1006                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
    1007                     socket_data->local_sockets, &tcp_globals.sockets,
    1008                     tcp_free_socket_data);
    1009                 return ERROR_CODE;
     1038                return rc;
    10101039        }
    10111040
     
    10311060    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet)
    10321061{
    1033         ERROR_DECLARE;
    1034 
    10351062        socket_core_ref listening_socket;
    10361063        tcp_socket_data_ref listening_socket_data;
     1064        int rc;
    10371065
    10381066        assert(socket);
     
    10591087
    10601088                // queue the received packet
    1061                 if (ERROR_NONE(dyn_fifo_push(&listening_socket->accepted,
    1062                     (-1 * socket->socket_id),
    1063                     listening_socket_data->backlog))) {
    1064 
     1089                rc = dyn_fifo_push(&listening_socket->accepted,
     1090                    (-1 * socket->socket_id), listening_socket_data->backlog);
     1091                if (rc == EOK) {
    10651092                        // notify the destination socket
    10661093                        async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
     
    10771104
    10781105        // create the notification packet
    1079         ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
    1080             socket_data, 0, 1));
     1106        rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
     1107        if (rc != EOK)
     1108                return rc;
    10811109
    10821110        // send the packet
    1083         ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1));
     1111        rc = tcp_queue_packet(socket, socket_data, packet, 1);
     1112        if (rc != EOK)
     1113                return rc;
    10841114
    10851115        // flush packets
     
    11981228    ipc_call_t *answer, int *answer_count)
    11991229{
    1200         ERROR_DECLARE;
    1201 
    12021230        packet_t packet;
     1231        int rc;
    12031232
    12041233        assert(call);
     
    12091238        switch (IPC_GET_METHOD(*call)) {
    12101239        case NET_TL_RECEIVED:
    1211                 //fibril_rwlock_read_lock(&tcp_globals.lock);
    1212                 if (ERROR_NONE(packet_translate_remote(tcp_globals.net_phone,
    1213                     &packet, IPC_GET_PACKET(call)))) {
    1214                         ERROR_CODE = tcp_received_msg(IPC_GET_DEVICE(call),
    1215                             packet, SERVICE_TCP, IPC_GET_ERROR(call));
    1216                 }
    1217                 //fibril_rwlock_read_unlock(&tcp_globals.lock);
    1218                 return ERROR_CODE;
    1219 
     1240//              fibril_rwlock_read_lock(&tcp_globals.lock);
     1241                rc = packet_translate_remote(tcp_globals.net_phone, &packet,
     1242                    IPC_GET_PACKET(call));
     1243                if (rc != EOK) {
     1244//                      fibril_rwlock_read_unlock(&tcp_globals.lock);
     1245                        return rc;
     1246                }
     1247                rc = tcp_received_msg(IPC_GET_DEVICE(call), packet, SERVICE_TCP,
     1248                    IPC_GET_ERROR(call));
     1249//              fibril_rwlock_read_unlock(&tcp_globals.lock);
     1250                return rc;
    12201251        case IPC_M_CONNECT_TO_ME:
    12211252                return tcp_process_client_messages(callid, *call);
     
    16621693    struct sockaddr *addr, socklen_t addrlen)
    16631694{
    1664         ERROR_DECLARE;
    1665 
    16661695        socket_core_ref socket;
     1696        int rc;
    16671697
    16681698        assert(local_sockets);
     
    16751705                return ENOTSOCK;
    16761706       
    1677         if (ERROR_OCCURRED(tcp_connect_core(socket, local_sockets, addr,
    1678             addrlen))) {
     1707        rc = tcp_connect_core(socket, local_sockets, addr, addrlen);
     1708        if (rc != EOK) {
    16791709                tcp_free_socket_data(socket);
    16801710                // unbind if bound
     
    16851715                }
    16861716        }
    1687         return ERROR_CODE;
     1717        return rc;
    16881718}
    16891719
     
    16921722    struct sockaddr *addr, socklen_t addrlen)
    16931723{
    1694         ERROR_DECLARE;
    1695 
    16961724        tcp_socket_data_ref socket_data;
    16971725        packet_t packet;
     1726        int rc;
    16981727
    16991728        assert(socket);
     
    17111740
    17121741        // get the destination port
    1713         ERROR_PROPAGATE(tl_get_address_port(addr, addrlen,
    1714             &socket_data->dest_port));
     1742        rc = tl_get_address_port(addr, addrlen, &socket_data->dest_port);
     1743        if (rc != EOK)
     1744                return rc;
     1745       
    17151746        if (socket->port <= 0) {
    17161747                // try to find a free port
    1717                 ERROR_PROPAGATE(socket_bind_free_port(&tcp_globals.sockets,
    1718                     socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    1719                     tcp_globals.last_used_port));
     1748                rc = socket_bind_free_port(&tcp_globals.sockets, socket,
     1749                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     1750                    tcp_globals.last_used_port);
     1751                if (rc != EOK)
     1752                        return rc;
    17201753                // set the next port as the search starting port number
    17211754                tcp_globals.last_used_port = socket->port;
    17221755        }
    17231756
    1724         ERROR_PROPAGATE(ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
     1757        rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
    17251758            addr, addrlen, &socket_data->device_id,
    1726             &socket_data->pseudo_header, &socket_data->headerlen));
     1759            &socket_data->pseudo_header, &socket_data->headerlen);
     1760        if (rc != EOK)
     1761                return rc;
    17271762
    17281763        // create the notification packet
    1729         ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
    1730             socket_data, 1, 0));
     1764        rc = tcp_create_notification_packet(&packet, socket, socket_data, 1, 0);
     1765        if (rc != EOK)
     1766                return rc;
    17311767
    17321768        // unlock the globals and wait for an operation
     
    17361772        socket_data->addrlen = addrlen;
    17371773        // send the packet
    1738         if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1)) ||
    1739             ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data,
    1740             0, TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false))) {
     1774
     1775        if (((rc = tcp_queue_packet(socket, socket_data, packet, 1)) != EOK) ||
     1776            ((rc = tcp_prepare_timeout(tcp_timeout, socket, socket_data, 0,
     1777            TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false)) !=
     1778            EOK)) {
    17411779                socket_data->addr = NULL;
    17421780                socket_data->addrlen = 0;
     
    17541792                        fibril_condvar_wait(&socket_data->operation.condvar,
    17551793                            &socket_data->operation.mutex);
    1756                         ERROR_CODE = socket_data->operation.result;
    1757                         if (ERROR_CODE != EOK) {
     1794                        rc = socket_data->operation.result;
     1795                        if (rc != EOK) {
    17581796                                socket_data->addr = NULL;
    17591797                                socket_data->addrlen = 0;
     
    17621800                        socket_data->addr = NULL;
    17631801                        socket_data->addrlen = 0;
    1764                         ERROR_CODE = EINTR;
     1802                        rc = EINTR;
    17651803                }
    17661804        }
     
    17691807
    17701808        // return the result
    1771         return ERROR_CODE;
     1809        return rc;
    17721810}
    17731811
     
    17761814    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length)
    17771815{
    1778         ERROR_DECLARE;
    1779 
    17801816        tcp_header_ref header;
     1817        int rc;
    17811818
    17821819        assert(socket);
     
    17931830        header->sequence_number = htonl(socket_data->next_outgoing);
    17941831
    1795         if (ERROR_OCCURRED(packet_set_addr(packet, NULL,
    1796             (uint8_t *) socket_data->addr, socket_data->addrlen)))
     1832        rc = packet_set_addr(packet, NULL, (uint8_t *) socket_data->addr,
     1833            socket_data->addrlen);
     1834        if (rc != EOK)
    17971835                return tcp_release_and_return(packet, EINVAL);
    17981836
     
    18081846    packet_t packet, size_t data_length)
    18091847{
    1810         ERROR_DECLARE;
     1848        int rc;
    18111849
    18121850        assert(socket);
     
    18141852        assert(socket->specific_data == socket_data);
    18151853
    1816         ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet,
    1817             data_length));
    1818 
    1819         if (ERROR_OCCURRED(pq_add(&socket_data->outgoing, packet,
    1820             socket_data->next_outgoing, data_length)))
    1821                 return tcp_release_and_return(packet, ERROR_CODE);
     1854        rc = tcp_queue_prepare_packet(socket, socket_data, packet, data_length);
     1855        if (rc != EOK)
     1856                return rc;
     1857
     1858        rc = pq_add(&socket_data->outgoing, packet, socket_data->next_outgoing,
     1859            data_length);
     1860        if (rc != EOK)
     1861                return tcp_release_and_return(packet, rc);
    18221862
    18231863        socket_data->next_outgoing += data_length;
     
    18281868tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data)
    18291869{
    1830         ERROR_DECLARE;
    1831 
    18321870        packet_t packet;
    18331871        packet_t copy;
     
    18351873        packet_t previous = NULL;
    18361874        size_t data_length;
     1875        int rc;
    18371876
    18381877        assert(socket);
     
    18591898                if (!sending) {
    18601899                        sending = copy;
    1861                 } else if (ERROR_OCCURRED(pq_insert_after(previous, copy))) {
    1862                         pq_release_remote(tcp_globals.net_phone,
    1863                             packet_get_id(copy));
    1864                         return sending;
     1900                } else {
     1901                        rc = pq_insert_after(previous, copy);
     1902                        if (rc != EOK) {
     1903                                pq_release_remote(tcp_globals.net_phone,
     1904                                    packet_get_id(copy));
     1905                                return sending;
     1906                        }
    18651907                }
    18661908
     
    18841926    packet_t packet, size_t data_length, size_t sequence_number)
    18851927{
    1886         ERROR_DECLARE;
    1887 
    18881928        tcp_header_ref header;
    18891929        uint32_t checksum;
     1930        int rc;
    18901931
    18911932        assert(socket);
     
    18941935
    18951936        // adjust the pseudo header
    1896         if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
    1897             socket_data->pseudo_header, socket_data->headerlen,
    1898             packet_get_data_length(packet)))) {
     1937        rc = ip_client_set_pseudo_header_data_length(socket_data->pseudo_header,
     1938            socket_data->headerlen, packet_get_data_length(packet));
     1939        if (rc != EOK) {
    18991940                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    19001941                return NULL;
     
    19211962        checksum = compute_checksum(0, socket_data->pseudo_header,
    19221963            socket_data->headerlen);
    1923         checksum = compute_checksum(checksum, (uint8_t *) packet_get_data(packet),
     1964        checksum = compute_checksum(checksum,
     1965            (uint8_t *) packet_get_data(packet),
    19241966            packet_get_data_length(packet));
    19251967        header->checksum = htons(flip_checksum(compact_checksum(checksum)));
    19261968
    19271969        // prepare the packet
    1928         if (ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0,
    1929             0, 0)) || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket,
    1930             socket_data, sequence_number, socket_data->state,
    1931             socket_data->timeout, true))) {
     1970        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
     1971        if (rc != EOK) {
     1972                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1973                return NULL;
     1974        }
     1975        rc = tcp_prepare_timeout(tcp_timeout, socket, socket_data,
     1976            sequence_number, socket_data->state, socket_data->timeout, true);
     1977        if (rc != EOK) {
    19321978                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    19331979                return NULL;
     
    20382084    size_t *addrlen)
    20392085{
    2040         ERROR_DECLARE;
    2041 
    20422086        socket_core_ref socket;
    20432087        tcp_socket_data_ref socket_data;
     
    20452089        packet_t packet;
    20462090        size_t length;
     2091        int rc;
    20472092
    20482093        assert(local_sockets);
     
    20662111        // send the source address if desired
    20672112        if (addrlen) {
    2068                 ERROR_PROPAGATE(data_reply(socket_data->addr,
    2069                     socket_data->addrlen));
     2113                rc = data_reply(socket_data->addr, socket_data->addrlen);
     2114                if (rc != EOK)
     2115                        return rc;
    20702116                *addrlen = socket_data->addrlen;
    20712117        }
     
    20762122                return NO_DATA;
    20772123
    2078         ERROR_PROPAGATE(packet_translate_remote(tcp_globals.net_phone, &packet,
    2079             packet_id));
     2124        rc = packet_translate_remote(tcp_globals.net_phone, &packet, packet_id);
     2125        if (rc != EOK)
     2126                return rc;
    20802127
    20812128        // reply the packets
    2082         ERROR_PROPAGATE(socket_reply_packets(packet, &length));
     2129        rc = socket_reply_packets(packet, &length);
     2130        if (rc != EOK)
     2131                return rc;
    20832132
    20842133        // release the packet
     
    20932142    size_t *data_fragment_size, int flags)
    20942143{
    2095         ERROR_DECLARE;
    2096 
    20972144        socket_core_ref socket;
    20982145        tcp_socket_data_ref socket_data;
     
    21032150        int index;
    21042151        int result;
     2152        int rc;
    21052153
    21062154        assert(local_sockets);
     
    21232171                return ENOTCONN;
    21242172
    2125         ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    2126            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension));
     2173        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2174            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
     2175        if (rc != EOK)
     2176                return rc;
    21272177
    21282178        *data_fragment_size =
     
    21452195
    21462196                tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
    2147                 ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet,
    2148                     0));
     2197                rc = tcp_queue_packet(socket, socket_data, packet, 0);
     2198                if (rc != EOK)
     2199                        return rc;
    21492200        }
    21502201
     
    21652216tcp_close_message(socket_cores_ref local_sockets, int socket_id)
    21662217{
    2167         ERROR_DECLARE;
    2168 
    21692218        socket_core_ref socket;
    21702219        tcp_socket_data_ref socket_data;
    21712220        packet_t packet;
     2221        int rc;
    21722222
    21732223        // find the socket
     
    21942244        default:
    21952245                // just destroy
    2196                 if (ERROR_NONE(socket_destroy(tcp_globals.net_phone, socket_id,
     2246                rc = socket_destroy(tcp_globals.net_phone, socket_id,
    21972247                    local_sockets, &tcp_globals.sockets,
    2198                     tcp_free_socket_data))) {
     2248                    tcp_free_socket_data);
     2249                if (rc == EOK) {
    21992250                        fibril_rwlock_write_unlock(socket_data->local_lock);
    22002251                        fibril_rwlock_write_unlock(&tcp_globals.lock);
    22012252                }
    2202                 return ERROR_CODE;
     2253                return rc;
    22032254        }
    22042255
     
    22072258
    22082259        // create the notification packet
    2209         ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
    2210             socket_data, 0, 1));
     2260        rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
     2261        if (rc != EOK)
     2262                return rc;
    22112263
    22122264        // send the packet
    2213         ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1));
     2265        rc = tcp_queue_packet(socket, socket_data, packet, 1);
     2266        if (rc != EOK)
     2267                return rc;
    22142268
    22152269        // flush packets
     
    22302284    tcp_socket_data_ref socket_data, int synchronize, int finalize)
    22312285{
    2232         ERROR_DECLARE;
    2233 
    22342286        packet_dimension_ref packet_dimension;
    22352287        tcp_header_ref header;
     2288        int rc;
    22362289
    22372290        assert(packet);
    22382291
    22392292        // get the device packet dimension
    2240         ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    2241             &tcp_globals.dimensions, socket_data->device_id,
    2242             &packet_dimension));
     2293        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2294            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
     2295        if (rc != EOK)
     2296                return rc;
    22432297
    22442298        // get a new packet
     
    22652319    int new_socket_id, size_t *data_fragment_size, size_t *addrlen)
    22662320{
    2267         ERROR_DECLARE;
    2268 
    22692321        socket_core_ref accepted;
    22702322        socket_core_ref socket;
    22712323        tcp_socket_data_ref socket_data;
    22722324        packet_dimension_ref packet_dimension;
     2325        int rc;
    22732326
    22742327        assert(local_sockets);
     
    23042357                // TODO can it be in another state?
    23052358                if (socket_data->state == TCP_SOCKET_ESTABLISHED) {
    2306                         ERROR_PROPAGATE(data_reply(socket_data->addr,
    2307                             socket_data->addrlen));
    2308                         ERROR_PROPAGATE(tl_get_ip_packet_dimension(
    2309                             tcp_globals.ip_phone, &tcp_globals.dimensions,
    2310                             socket_data->device_id, &packet_dimension));
     2359                        rc = data_reply(socket_data->addr,
     2360                            socket_data->addrlen);
     2361                        if (rc != EOK)
     2362                                return rc;
     2363                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2364                            &tcp_globals.dimensions, socket_data->device_id,
     2365                            &packet_dimension);
     2366                        if (rc != EOK)
     2367                                return rc;
    23112368                        *addrlen = socket_data->addrlen;
    23122369
     
    23182375       
    23192376                        if (new_socket_id > 0) {
    2320                                 ERROR_PROPAGATE(socket_cores_update(
    2321                                     local_sockets, accepted->socket_id,
    2322                                     new_socket_id));
     2377                                rc = socket_cores_update(local_sockets,
     2378                                    accepted->socket_id, new_socket_id);
     2379                                if (rc != EOK)
     2380                                        return rc;
    23232381                                accepted->socket_id = new_socket_id;
    23242382                        }
     
    24302488main(int argc, char *argv[])
    24312489{
    2432         ERROR_DECLARE;
    2433 
    2434         /*
    2435            Start the module
    2436          */
    2437         if (ERROR_OCCURRED(tl_module_start_standalone(tl_client_connection)))
    2438                 return ERROR_CODE;
    2439 
    2440         return EOK;
     2490        int rc;
     2491
     2492        rc = tl_module_start_standalone(tl_client_connection);
     2493        return rc;
    24412494}
    24422495
Note: See TracChangeset for help on using the changeset viewer.