Index: uspace/srv/net/tl/tcp/tcp.c =================================================================== --- uspace/srv/net/tl/tcp/tcp.c (revision 9539be6c880110557328e7e518cf276b94c1b07f) +++ uspace/srv/net/tl/tcp/tcp.c (revision dc94cb2d6a9d09b061c8a475391db0c6efbf7b85) @@ -76,49 +76,40 @@ #include "tcp_module.h" -/** TCP module name. - */ +/** TCP module name. */ #define NAME "TCP protocol" -/** The TCP window default value. - */ -#define NET_DEFAULT_TCP_WINDOW 10240 - -/** Initial timeout for new connections. - */ +/** The TCP window default value. */ +#define NET_DEFAULT_TCP_WINDOW 10240 + +/** Initial timeout for new connections. */ #define NET_DEFAULT_TCP_INITIAL_TIMEOUT 3000000L -/** Default timeout for closing. - */ -#define NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT 2000L - -/** The initial outgoing sequence number. - */ -#define TCP_INITIAL_SEQUENCE_NUMBER 2999 - -/** Maximum TCP fragment size. - */ -#define MAX_TCP_FRAGMENT_SIZE 65535 - -/** Free ports pool start. - */ -#define TCP_FREE_PORTS_START 1025 - -/** Free ports pool end. - */ +/** Default timeout for closing. */ +#define NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT 2000L + +/** The initial outgoing sequence number. */ +#define TCP_INITIAL_SEQUENCE_NUMBER 2999 + +/** Maximum TCP fragment size. */ +#define MAX_TCP_FRAGMENT_SIZE 65535 + +/** Free ports pool start. */ +#define TCP_FREE_PORTS_START 1025 + +/** Free ports pool end. */ #define TCP_FREE_PORTS_END 65535 -/** Timeout for connection initialization, SYN sent. - */ -#define TCP_SYN_SENT_TIMEOUT 1000000L - -/** The maximum number of timeouts in a row before singaling connection lost. - */ +/** Timeout for connection initialization, SYN sent. */ +#define TCP_SYN_SENT_TIMEOUT 1000000L + +/** The maximum number of timeouts in a row before singaling connection lost. */ #define TCP_MAX_TIMEOUTS 8 -/** The number of acknowledgements before retransmit. - */ +/** The number of acknowledgements before retransmit. */ #define TCP_FAST_RETRANSMIT_COUNT 3 -/** Returns a value indicating whether the value is in the interval respecting the possible overflow. +/** Returns a value indicating whether the value is in the interval respecting + * the possible overflow. + * * The high end and/or the value may overflow, be lower than the low value. * @param[in] lower The last value before the interval. @@ -126,15 +117,18 @@ * @param[in] higher_equal The last value in the interval. */ -#define IS_IN_INTERVAL_OVERFLOW(lower, value, higher_equal) ((((lower) < (value)) && (((value) <= (higher_equal)) || ((higher_equal) < (lower)))) || (((value) <= (higher_equal)) && ((higher_equal) < (lower)))) +#define IS_IN_INTERVAL_OVERFLOW(lower, value, higher_equal) \ + ((((lower) < (value)) && (((value) <= (higher_equal)) || \ + ((higher_equal) < (lower)))) || (((value) <= (higher_equal)) && \ + ((higher_equal) < (lower)))) /** Type definition of the TCP timeout. * @see tcp_timeout */ -typedef struct tcp_timeout tcp_timeout_t; +typedef struct tcp_timeout tcp_timeout_t; /** Type definition of the TCP timeout pointer. * @see tcp_timeout */ -typedef tcp_timeout_t * tcp_timeout_ref; +typedef tcp_timeout_t *tcp_timeout_ref; /** TCP reply timeout data. @@ -142,31 +136,30 @@ * @see tcp_timeout() */ -struct tcp_timeout{ - /** TCP global data are going to be read only. - */ +struct tcp_timeout { + /** TCP global data are going to be read only. */ int globals_read_only; - /** Socket port. - */ + + /** Socket port. */ int port; - /** Local sockets. - */ + + /** Local sockets. */ socket_cores_ref local_sockets; - /** Socket identifier. - */ + + /** Socket identifier. */ int socket_id; - /** Socket state. - */ + + /** Socket state. */ tcp_socket_state_t state; - /** Sent packet sequence number. - */ + + /** Sent packet sequence number. */ int sequence_number; - /** Timeout in microseconds. - */ + + /** Timeout in microseconds. */ suseconds_t timeout; - /** Port map key. - */ - char * key; - /** Port map key length. - */ + + /** Port map key. */ + char *key; + + /** Port map key length. */ size_t key_length; }; @@ -179,72 +172,121 @@ int tcp_release_and_return(packet_t packet, int result); -void tcp_prepare_operation_header(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize); -int tcp_prepare_timeout(int (*timeout_function)(void * tcp_timeout_t), socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout, int globals_read_only); +void tcp_prepare_operation_header(socket_core_ref socket, + tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, + int finalize); +int tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t), + socket_core_ref socket, tcp_socket_data_ref socket_data, + size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout, + int globals_read_only); void tcp_free_socket_data(socket_core_ref socket); -int tcp_timeout(void * data); -int tcp_release_after_timeout(void * data); -int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error); -int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen); -int tcp_queue_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length); -int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length); -packet_t tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data); + +int tcp_timeout(void *data); + +int tcp_release_after_timeout(void *data); + +int tcp_process_packet(device_id_t device_id, packet_t packet, + services_t error); +int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets, + struct sockaddr *addr, socklen_t addrlen); +int tcp_queue_prepare_packet(socket_core_ref socket, + tcp_socket_data_ref socket_data, packet_t packet, size_t data_length); +int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, + packet_t packet, size_t data_length); +packet_t tcp_get_packets_to_send(socket_core_ref socket, + tcp_socket_data_ref socket_data); void tcp_send_packets(device_id_t device_id, packet_t packet); -void tcp_process_acknowledgement(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header); -packet_t tcp_send_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number); -packet_t tcp_prepare_copy(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number); -void tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number); -int tcp_create_notification_packet(packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize); + +void tcp_process_acknowledgement(socket_core_ref socket, + tcp_socket_data_ref socket_data, tcp_header_ref header); +packet_t tcp_send_prepare_packet(socket_core_ref socket, + tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, + size_t sequence_number); +packet_t tcp_prepare_copy(socket_core_ref socket, + tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, + size_t sequence_number); +void tcp_retransmit_packet(socket_core_ref socket, + tcp_socket_data_ref socket_data, size_t sequence_number); +int tcp_create_notification_packet(packet_t * packet, socket_core_ref socket, + tcp_socket_data_ref socket_data, int synchronize, int finalize); void tcp_refresh_socket_data(tcp_socket_data_ref socket_data); + void tcp_initialize_socket_data(tcp_socket_data_ref socket_data); -int tcp_process_listen(socket_core_ref listening_socket, tcp_socket_data_ref listening_socket_data, tcp_header_ref header, packet_t packet, struct sockaddr * src, struct sockaddr * dest, size_t addrlen); -int tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet); -int tcp_process_syn_received(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet); -int tcp_process_established(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet, int fragments, size_t total_length); -int tcp_queue_received_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length); - -int tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver, services_t error); + +int tcp_process_listen(socket_core_ref listening_socket, + tcp_socket_data_ref listening_socket_data, tcp_header_ref header, + packet_t packet, struct sockaddr *src, struct sockaddr *dest, + size_t addrlen); +int tcp_process_syn_sent(socket_core_ref socket, + tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet); +int tcp_process_syn_received(socket_core_ref socket, + tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet); +int tcp_process_established(socket_core_ref socket, + tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet, + int fragments, size_t total_length); +int tcp_queue_received_packet(socket_core_ref socket, + tcp_socket_data_ref socket_data, packet_t packet, int fragments, + size_t total_length); + +int tcp_received_msg(device_id_t device_id, packet_t packet, + services_t receiver, services_t error); int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call); -int tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog); -int tcp_connect_message(socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen); -int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen); -int tcp_send_message(socket_cores_ref local_sockets, int socket_id, int fragments, size_t * data_fragment_size, int flags); -int tcp_accept_message(socket_cores_ref local_sockets, int socket_id, int new_socket_id, size_t * data_fragment_size, size_t * addrlen); + +int tcp_listen_message(socket_cores_ref local_sockets, int socket_id, + int backlog); +int tcp_connect_message(socket_cores_ref local_sockets, int socket_id, + struct sockaddr *addr, socklen_t addrlen); +int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, + int flags, size_t * addrlen); +int tcp_send_message(socket_cores_ref local_sockets, int socket_id, + int fragments, size_t * data_fragment_size, int flags); +int tcp_accept_message(socket_cores_ref local_sockets, int socket_id, + int new_socket_id, size_t * data_fragment_size, size_t * addrlen); int tcp_close_message(socket_cores_ref local_sockets, int socket_id); -/** TCP global data. - */ -tcp_globals_t tcp_globals; - -int tcp_initialize(async_client_conn_t client_connection){ +/** TCP global data. */ +tcp_globals_t tcp_globals; + +int tcp_initialize(async_client_conn_t client_connection) +{ ERROR_DECLARE; assert(client_connection); + fibril_rwlock_initialize(&tcp_globals.lock); fibril_rwlock_write_lock(&tcp_globals.lock); - tcp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP, ICMP_CONNECT_TIMEOUT); - tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP, SERVICE_TCP, client_connection, tcp_received_msg); - if(tcp_globals.ip_phone < 0){ + + tcp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP, + ICMP_CONNECT_TIMEOUT); + tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP, + SERVICE_TCP, client_connection, tcp_received_msg); + if (tcp_globals.ip_phone < 0) return tcp_globals.ip_phone; - } + ERROR_PROPAGATE(socket_ports_initialize(&tcp_globals.sockets)); - if(ERROR_OCCURRED(packet_dimensions_initialize(&tcp_globals.dimensions))){ + if (ERROR_OCCURRED(packet_dimensions_initialize( + &tcp_globals.dimensions))) { socket_ports_destroy(&tcp_globals.sockets); return ERROR_CODE; } + tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1; fibril_rwlock_write_unlock(&tcp_globals.lock); + return EOK; } -int tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver, services_t error){ +int +tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver, + services_t error) +{ ERROR_DECLARE; - if(receiver != SERVICE_TCP){ + if (receiver != SERVICE_TCP) return EREFUSED; - } + fibril_rwlock_write_lock(&tcp_globals.lock); - if(ERROR_OCCURRED(tcp_process_packet(device_id, packet, error))){ + if (ERROR_OCCURRED(tcp_process_packet(device_id, packet, error))) fibril_rwlock_write_unlock(&tcp_globals.lock); - } + printf("receive %d \n", ERROR_CODE); @@ -252,5 +294,6 @@ } -int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error){ +int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error) +{ ERROR_DECLARE; @@ -259,5 +302,5 @@ int result; tcp_header_ref header; - socket_core_ref socket; + socket_core_ref socket; tcp_socket_data_ref socket_data; packet_t next_packet; @@ -267,24 +310,26 @@ icmp_type_t type; icmp_code_t code; - struct sockaddr * src; - struct sockaddr * dest; + struct sockaddr *src; + struct sockaddr *dest; size_t addrlen; - printf("p1 \n"); - if(error){ - switch(error){ - case SERVICE_ICMP: - // process error - result = icmp_client_process_packet(packet, &type, &code, NULL, NULL); - if(result < 0){ - return tcp_release_and_return(packet, result); - } - length = (size_t) result; - if(ERROR_OCCURRED(packet_trim(packet, length, 0))){ - return tcp_release_and_return(packet, ERROR_CODE); - } - break; - default: - return tcp_release_and_return(packet, ENOTSUP); + if (error) { + switch (error) { + case SERVICE_ICMP: + // process error + result = icmp_client_process_packet(packet, &type, + &code, NULL, NULL); + if (result < 0) + return tcp_release_and_return(packet, result); + + length = (size_t) result; + if (ERROR_OCCURRED(packet_trim(packet, length, 0))) { + return tcp_release_and_return(packet, + ERROR_CODE); + } + break; + + default: + return tcp_release_and_return(packet, ENOTSUP); } } @@ -292,50 +337,52 @@ // TODO process received ipopts? result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL); -// printf("ip len %d\n", result); - if(result < 0){ + if (result < 0) return tcp_release_and_return(packet, result); - } + offset = (size_t) result; length = packet_get_data_length(packet); -// printf("packet len %d\n", length); - if(length <= 0){ + if (length <= 0) return tcp_release_and_return(packet, EINVAL); - } - if(length < TCP_HEADER_SIZE + offset){ + + if (length < TCP_HEADER_SIZE + offset) return tcp_release_and_return(packet, NO_DATA); - } // trim all but TCP header - if(ERROR_OCCURRED(packet_trim(packet, offset, 0))){ + if (ERROR_OCCURRED(packet_trim(packet, offset, 0))) return tcp_release_and_return(packet, ERROR_CODE); - } // get tcp header header = (tcp_header_ref) packet_get_data(packet); - if(! header){ + if (!header) return tcp_release_and_return(packet, NO_DATA); - } -// printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header), ntohs(header->destination_port)); + +// printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header), +// ntohs(header->destination_port)); result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest); - if(result <= 0){ + if (result <= 0) return tcp_release_and_return(packet, result); - } + addrlen = (size_t) result; - if(ERROR_OCCURRED(tl_set_address_port(src, addrlen, ntohs(header->source_port)))){ + if (ERROR_OCCURRED(tl_set_address_port(src, addrlen, + ntohs(header->source_port)))) return tcp_release_and_return(packet, ERROR_CODE); - } - + // find the destination socket - socket = socket_port_find(&tcp_globals.sockets, ntohs(header->destination_port), (const char *) src, addrlen); - if(! socket){ -// printf("listening?\n"); + socket = socket_port_find(&tcp_globals.sockets, + ntohs(header->destination_port), (const char *) src, addrlen); + if (!socket) { // find the listening destination socket - socket = socket_port_find(&tcp_globals.sockets, ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING, 0); - if(! socket){ - if(tl_prepare_icmp_packet(tcp_globals.net_phone, tcp_globals.icmp_phone, packet, error) == EOK){ - icmp_destination_unreachable_msg(tcp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet); + socket = socket_port_find(&tcp_globals.sockets, + ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING, + 0); + if (!socket) { + if (tl_prepare_icmp_packet(tcp_globals.net_phone, + tcp_globals.icmp_phone, packet, error) == EOK) { + icmp_destination_unreachable_msg( + tcp_globals.icmp_phone, ICMP_PORT_UNREACH, + 0, packet); } return EADDRNOTAVAIL; @@ -354,85 +401,113 @@ checksum = 0; total_length = 0; - do{ - ++ fragments; + do { + ++fragments; length = packet_get_data_length(next_packet); - if(length <= 0){ + if (length <= 0) return tcp_release_and_return(packet, NO_DATA); - } + total_length += length; + // add partial checksum if set - if(! error){ - checksum = compute_checksum(checksum, packet_get_data(packet), packet_get_data_length(packet)); - } - }while((next_packet = pq_next(next_packet))); -// printf("fragments %d of %d bytes\n", fragments, total_length); - -// printf("lock?\n"); + if (!error) { + checksum = compute_checksum(checksum, + packet_get_data(packet), + packet_get_data_length(packet)); + } + + } while ((next_packet = pq_next(next_packet))); + fibril_rwlock_write_lock(socket_data->local_lock); -// printf("locked\n"); - if(! error){ - if(socket_data->state == TCP_SOCKET_LISTEN){ - if(socket_data->pseudo_header){ - free(socket_data->pseudo_header); - socket_data->pseudo_header = NULL; - socket_data->headerlen = 0; - } - if(ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_TCP, src, addrlen, dest, addrlen, total_length, &socket_data->pseudo_header, &socket_data->headerlen))){ - fibril_rwlock_write_unlock(socket_data->local_lock); - return tcp_release_and_return(packet, ERROR_CODE); - } - }else if(ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(socket_data->pseudo_header, socket_data->headerlen, total_length))){ + + if (error) + goto error; + + if (socket_data->state == TCP_SOCKET_LISTEN) { + + if (socket_data->pseudo_header) { + free(socket_data->pseudo_header); + socket_data->pseudo_header = NULL; + socket_data->headerlen = 0; + } + + if (ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_TCP, src, + addrlen, dest, addrlen, total_length, + &socket_data->pseudo_header, &socket_data->headerlen))) { fibril_rwlock_write_unlock(socket_data->local_lock); return tcp_release_and_return(packet, ERROR_CODE); } - checksum = compute_checksum(checksum, socket_data->pseudo_header, socket_data->headerlen); - if(flip_checksum(compact_checksum(checksum)) != IP_CHECKSUM_ZERO){ - printf("checksum err %x -> %x\n", header->checksum, flip_checksum(compact_checksum(checksum))); - fibril_rwlock_write_unlock(socket_data->local_lock); - if(! ERROR_OCCURRED(tl_prepare_icmp_packet(tcp_globals.net_phone, tcp_globals.icmp_phone, packet, error))){ - // checksum error ICMP - icmp_parameter_problem_msg(tcp_globals.icmp_phone, ICMP_PARAM_POINTER, ((size_t) ((void *) &header->checksum)) - ((size_t) ((void *) header)), packet); - } - return EINVAL; - } - } - + + } else if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length( + socket_data->pseudo_header, socket_data->headerlen, + total_length))) { + fibril_rwlock_write_unlock(socket_data->local_lock); + return tcp_release_and_return(packet, ERROR_CODE); + } + + checksum = compute_checksum(checksum, socket_data->pseudo_header, + socket_data->headerlen); + if (flip_checksum(compact_checksum(checksum)) != IP_CHECKSUM_ZERO) { + printf("checksum err %x -> %x\n", header->checksum, + flip_checksum(compact_checksum(checksum))); + fibril_rwlock_write_unlock(socket_data->local_lock); + + if (ERROR_NONE(tl_prepare_icmp_packet(tcp_globals.net_phone, + tcp_globals.icmp_phone, packet, error))) { + // checksum error ICMP + icmp_parameter_problem_msg(tcp_globals.icmp_phone, + ICMP_PARAM_POINTER, + ((size_t) ((void *) &header->checksum)) - + ((size_t) ((void *) header)), packet); + } + + return EINVAL; + } + +error: fibril_rwlock_read_unlock(&tcp_globals.lock); // TODO error reporting/handling -// printf("st %d\n", socket_data->state); - switch(socket_data->state){ - case TCP_SOCKET_LISTEN: - ERROR_CODE = tcp_process_listen(socket, socket_data, header, packet, src, dest, addrlen); - break; - case TCP_SOCKET_SYN_RECEIVED: - ERROR_CODE = tcp_process_syn_received(socket, socket_data, header, packet); - break; - case TCP_SOCKET_SYN_SENT: - ERROR_CODE = tcp_process_syn_sent(socket, socket_data, header, packet); - break; - case TCP_SOCKET_FIN_WAIT_1: - // ack changing the state to FIN_WAIT_2 gets processed later - case TCP_SOCKET_FIN_WAIT_2: - // fin changing state to LAST_ACK gets processed later - case TCP_SOCKET_LAST_ACK: - // ack releasing the socket get processed later - case TCP_SOCKET_CLOSING: - // ack releasing the socket gets processed later - case TCP_SOCKET_ESTABLISHED: - ERROR_CODE = tcp_process_established(socket, socket_data, header, packet, fragments, total_length); - break; - default: - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); - } - - if(ERROR_CODE != EOK){ + switch (socket_data->state) { + case TCP_SOCKET_LISTEN: + ERROR_CODE = tcp_process_listen(socket, socket_data, header, + packet, src, dest, addrlen); + break; + case TCP_SOCKET_SYN_RECEIVED: + ERROR_CODE = tcp_process_syn_received(socket, socket_data, + header, packet); + break; + case TCP_SOCKET_SYN_SENT: + ERROR_CODE = tcp_process_syn_sent(socket, socket_data, header, + packet); + break; + case TCP_SOCKET_FIN_WAIT_1: + // ack changing the state to FIN_WAIT_2 gets processed later + case TCP_SOCKET_FIN_WAIT_2: + // fin changing state to LAST_ACK gets processed later + case TCP_SOCKET_LAST_ACK: + // ack releasing the socket get processed later + case TCP_SOCKET_CLOSING: + // ack releasing the socket gets processed later + case TCP_SOCKET_ESTABLISHED: + ERROR_CODE = tcp_process_established(socket, socket_data, + header, packet, fragments, total_length); + break; + default: + pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); + } + + if (ERROR_CODE != EOK) { printf("process %d\n", ERROR_CODE); fibril_rwlock_write_unlock(socket_data->local_lock); } + return EOK; } -int tcp_process_established(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet, int fragments, size_t total_length){ +int +tcp_process_established(socket_core_ref socket, tcp_socket_data_ref socket_data, + tcp_header_ref header, packet_t packet, int fragments, + size_t total_length) +{ ERROR_DECLARE; @@ -455,60 +530,72 @@ old_incoming = socket_data->next_incoming; - if(header->finalize){ + if (header->finalize) socket_data->fin_incoming = new_sequence_number; - } - -// printf("pe %d < %d <= %d\n", new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length); + // trim begining if containing expected data - if(IS_IN_INTERVAL_OVERFLOW(new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length)){ + if (IS_IN_INTERVAL_OVERFLOW(new_sequence_number, + socket_data->next_incoming, new_sequence_number + total_length)) { + // get the acknowledged offset - if(socket_data->next_incoming < new_sequence_number){ - offset = new_sequence_number - socket_data->next_incoming; - }else{ - offset = socket_data->next_incoming - new_sequence_number; - } -// printf("offset %d\n", offset); + if (socket_data->next_incoming < new_sequence_number) { + offset = new_sequence_number - + socket_data->next_incoming; + } else { + offset = socket_data->next_incoming - + new_sequence_number; + } + new_sequence_number += offset; total_length -= offset; length = packet_get_data_length(packet); // trim the acknowledged data - while(length <= offset){ + while (length <= offset) { // release the acknowledged packets next_packet = pq_next(packet); - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); + pq_release_remote(tcp_globals.net_phone, + packet_get_id(packet)); packet = next_packet; offset -= length; length = packet_get_data_length(packet); } - if((offset > 0) - && (ERROR_OCCURRED(packet_trim(packet, offset, 0)))){ + + if ((offset > 0) && (ERROR_OCCURRED(packet_trim(packet, + offset, 0)))) return tcp_release_and_return(packet, ERROR_CODE); - } + assert(new_sequence_number == socket_data->next_incoming); } // release if overflowing the window -// if(IS_IN_INTERVAL_OVERFLOW(socket_data->next_incoming + socket_data->window, new_sequence_number, new_sequence_number + total_length)){ -// return tcp_release_and_return(packet, EOVERFLOW); -// } - /* + if (IS_IN_INTERVAL_OVERFLOW(socket_data->next_incoming + + socket_data->window, new_sequence_number, new_sequence_number + + total_length)) { + return tcp_release_and_return(packet, EOVERFLOW); + } + // trim end if overflowing the window - if(IS_IN_INTERVAL_OVERFLOW(new_sequence_number, socket_data->next_incoming + socket_data->window, new_sequence_number + total_length)){ + if (IS_IN_INTERVAL_OVERFLOW(new_sequence_number, + socket_data->next_incoming + socket_data->window, + new_sequence_number + total_length)) { // get the allowed data length - if(socket_data->next_incoming + socket_data->window < new_sequence_number){ - offset = new_sequence_number - socket_data->next_incoming + socket_data->window; - }else{ - offset = socket_data->next_incoming + socket_data->window - new_sequence_number; + if (socket_data->next_incoming + socket_data->window < + new_sequence_number) { + offset = new_sequence_number - + socket_data->next_incoming + socket_data->window; + } else { + offset = socket_data->next_incoming + + socket_data->window - new_sequence_number; } next_packet = packet; // trim the overflowing data - while(next_packet && (offset > 0)){ + while (next_packet && (offset > 0)) { length = packet_get_data_length(packet); - if(length <= offset){ + if (length <= offset) next_packet = pq_next(next_packet); - }else if(ERROR_OCCURRED(packet_trim(next_packet, 0, length - offset))){ - return tcp_release_and_return(packet, ERROR_CODE); - } + else if (ERROR_OCCURRED(packet_trim(next_packet, 0, + length - offset))) + return tcp_release_and_return(packet, + ERROR_CODE); offset -= length; total_length -= length - offset; @@ -516,15 +603,17 @@ // release the overflowing packets next_packet = pq_next(next_packet); - if(next_packet){ + if (next_packet) { tmp_packet = next_packet; next_packet = pq_next(next_packet); pq_insert_after(tmp_packet, next_packet); - pq_release_remote(tcp_globals.net_phone, packet_get_id(tmp_packet)); - } - assert(new_sequence_number + total_length == socket_data->next_incoming + socket_data->window); + pq_release_remote(tcp_globals.net_phone, + packet_get_id(tmp_packet)); + } + assert(new_sequence_number + total_length == + socket_data->next_incoming + socket_data->window); } */ // the expected one arrived? - if(new_sequence_number == socket_data->next_incoming){ + if (new_sequence_number == socket_data->next_incoming) { printf("expected\n"); // process acknowledgement @@ -533,64 +622,88 @@ // remove the header total_length -= TCP_HEADER_LENGTH(header); - if(ERROR_OCCURRED(packet_trim(packet, TCP_HEADER_LENGTH(header), 0))){ + if (ERROR_OCCURRED(packet_trim(packet, + TCP_HEADER_LENGTH(header), 0))) return tcp_release_and_return(packet, ERROR_CODE); - } - - if(total_length){ - ERROR_PROPAGATE(tcp_queue_received_packet(socket, socket_data, packet, fragments, total_length)); - }else{ + + if (total_length) { + ERROR_PROPAGATE(tcp_queue_received_packet(socket, + socket_data, packet, fragments, total_length)); + } else { total_length = 1; } + socket_data->next_incoming = old_incoming + total_length; packet = socket_data->incoming; - while(packet){ - if(ERROR_OCCURRED(pq_get_order(socket_data->incoming, &order, NULL))){ + while (packet) { + + if (ERROR_OCCURRED(pq_get_order(socket_data->incoming, + &order, NULL))) { // remove the corrupted packet next_packet = pq_detach(packet); - if(packet == socket_data->incoming){ + if (packet == socket_data->incoming) socket_data->incoming = next_packet; - } - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); + pq_release_remote(tcp_globals.net_phone, + packet_get_id(packet)); packet = next_packet; continue; } + sequence_number = (uint32_t) order; - if(IS_IN_INTERVAL_OVERFLOW(sequence_number, old_incoming, socket_data->next_incoming)){ + if (IS_IN_INTERVAL_OVERFLOW(sequence_number, + old_incoming, socket_data->next_incoming)) { // move to the next packet = pq_next(packet); - // coninual data? - }else if(IS_IN_INTERVAL_OVERFLOW(old_incoming, sequence_number, socket_data->next_incoming)){ + // coninual data? + } else if (IS_IN_INTERVAL_OVERFLOW(old_incoming, + sequence_number, socket_data->next_incoming)) { // detach the packet next_packet = pq_detach(packet); - if(packet == socket_data->incoming){ + if (packet == socket_data->incoming) socket_data->incoming = next_packet; - } // get data length length = packet_get_data_length(packet); new_sequence_number = sequence_number + length; - if(length <= 0){ + if (length <= 0) { // remove the empty packet - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); + pq_release_remote(tcp_globals.net_phone, + packet_get_id(packet)); packet = next_packet; continue; } // exactly following - if(sequence_number == socket_data->next_incoming){ + if (sequence_number == + socket_data->next_incoming) { // queue received data - ERROR_PROPAGATE(tcp_queue_received_packet(socket, socket_data, packet, 1, packet_get_data_length(packet))); - socket_data->next_incoming = new_sequence_number; + ERROR_PROPAGATE( + tcp_queue_received_packet(socket, + socket_data, packet, 1, + packet_get_data_length(packet))); + socket_data->next_incoming = + new_sequence_number; packet = next_packet; continue; - // at least partly following data? - }else if(IS_IN_INTERVAL_OVERFLOW(sequence_number, socket_data->next_incoming, new_sequence_number)){ - if(socket_data->next_incoming < new_sequence_number){ - length = new_sequence_number - socket_data->next_incoming; - }else{ - length = socket_data->next_incoming - new_sequence_number; + // at least partly following data? + } else if (IS_IN_INTERVAL_OVERFLOW( + sequence_number, socket_data->next_incoming, + new_sequence_number)) { + if (socket_data->next_incoming < + new_sequence_number) { + length = new_sequence_number - + socket_data->next_incoming; + } else { + length = + socket_data->next_incoming - + new_sequence_number; } - if(! ERROR_OCCURRED(packet_trim(packet, length, 0))){ + if (ERROR_NONE(packet_trim(packet, + length, 0))) { // queue received data - ERROR_PROPAGATE(tcp_queue_received_packet(socket, socket_data, packet, 1, packet_get_data_length(packet))); - socket_data->next_incoming = new_sequence_number; + ERROR_PROPAGATE( + tcp_queue_received_packet( + socket, socket_data, packet, + 1, packet_get_data_length( + packet))); + socket_data->next_incoming = + new_sequence_number; packet = next_packet; continue; @@ -598,12 +711,15 @@ } // remove the duplicit or corrupted packet - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); + pq_release_remote(tcp_globals.net_phone, + packet_get_id(packet)); packet = next_packet; continue; - }else{ + } else { break; } } - }else if(IS_IN_INTERVAL(socket_data->next_incoming, new_sequence_number, socket_data->next_incoming + socket_data->window)){ + } else if (IS_IN_INTERVAL(socket_data->next_incoming, + new_sequence_number, + socket_data->next_incoming + socket_data->window)) { printf("in window\n"); // process acknowledgement @@ -612,27 +728,33 @@ // remove the header total_length -= TCP_HEADER_LENGTH(header); - if(ERROR_OCCURRED(packet_trim(packet, TCP_HEADER_LENGTH(header), 0))){ + if (ERROR_OCCURRED(packet_trim(packet, + TCP_HEADER_LENGTH(header), 0))) return tcp_release_and_return(packet, ERROR_CODE); - } next_packet = pq_detach(packet); length = packet_get_data_length(packet); - if(ERROR_OCCURRED(pq_add(&socket_data->incoming, packet, new_sequence_number, length))){ + if (ERROR_OCCURRED(pq_add(&socket_data->incoming, packet, + new_sequence_number, length))) { // remove the corrupted packets - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); - pq_release_remote(tcp_globals.net_phone, packet_get_id(next_packet)); - }else{ - while(next_packet){ + pq_release_remote(tcp_globals.net_phone, + packet_get_id(packet)); + pq_release_remote(tcp_globals.net_phone, + packet_get_id(next_packet)); + } else { + while (next_packet) { new_sequence_number += length; tmp_packet = pq_detach(next_packet); length = packet_get_data_length(next_packet); - if(ERROR_OCCURRED(pq_set_order(next_packet, new_sequence_number, length)) - || ERROR_OCCURRED(pq_insert_after(packet, next_packet))){ - pq_release_remote(tcp_globals.net_phone, packet_get_id(next_packet)); + if (ERROR_OCCURRED(pq_set_order(next_packet, + new_sequence_number, length)) || + ERROR_OCCURRED(pq_insert_after(packet, + next_packet))) { + pq_release_remote(tcp_globals.net_phone, + packet_get_id(next_packet)); } next_packet = tmp_packet; } } - }else{ + } else { printf("unexpected\n"); // release duplicite or restricted @@ -641,32 +763,43 @@ // change state according to the acknowledging incoming fin - if(IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming, socket_data->next_incoming)){ - switch(socket_data->state){ - case TCP_SOCKET_FIN_WAIT_1: - case TCP_SOCKET_FIN_WAIT_2: - case TCP_SOCKET_CLOSING: - socket_data->state = TCP_SOCKET_CLOSING; - break; + if (IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming, + socket_data->next_incoming)) { + switch (socket_data->state) { + case TCP_SOCKET_FIN_WAIT_1: + case TCP_SOCKET_FIN_WAIT_2: + case TCP_SOCKET_CLOSING: + socket_data->state = TCP_SOCKET_CLOSING; + break; //case TCP_ESTABLISHED: - default: - socket_data->state = TCP_SOCKET_CLOSE_WAIT; - break; + default: + socket_data->state = TCP_SOCKET_CLOSE_WAIT; + break; } } packet = tcp_get_packets_to_send(socket, socket_data); - if(! packet){ + if (!packet) { // create the notification packet - ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, socket_data, 0, 0)); - ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet, 1)); - packet = tcp_send_prepare_packet(socket, socket_data, packet, 1, socket_data->last_outgoing + 1); - } + ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, + socket_data, 0, 0)); + ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, + packet, 1)); + packet = tcp_send_prepare_packet(socket, socket_data, packet, 1, + socket_data->last_outgoing + 1); + } + fibril_rwlock_write_unlock(socket_data->local_lock); + // send the packet tcp_send_packets(socket_data->device_id, packet); + return EOK; } -int tcp_queue_received_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length){ +int +tcp_queue_received_packet(socket_core_ref socket, + tcp_socket_data_ref socket_data, packet_t packet, int fragments, + size_t total_length) +{ ERROR_DECLARE; @@ -681,6 +814,9 @@ // queue the received packet - if(ERROR_OCCURRED(dyn_fifo_push(&socket->received, packet_get_id(packet), SOCKET_MAX_RECEIVED_SIZE)) - || ERROR_OCCURRED(tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, socket_data->device_id, &packet_dimension))){ + if (ERROR_OCCURRED(dyn_fifo_push(&socket->received, + packet_get_id(packet), SOCKET_MAX_RECEIVED_SIZE)) || + ERROR_OCCURRED(tl_get_ip_packet_dimension(tcp_globals.ip_phone, + &tcp_globals.dimensions, socket_data->device_id, + &packet_dimension))) { return tcp_release_and_return(packet, ERROR_CODE); } @@ -690,9 +826,17 @@ // notify the destination socket - async_msg_5(socket->phone, NET_SOCKET_RECEIVED, (ipcarg_t) socket->socket_id, ((packet_dimension->content < socket_data->data_fragment_size) ? packet_dimension->content : socket_data->data_fragment_size), 0, 0, (ipcarg_t) fragments); + async_msg_5(socket->phone, NET_SOCKET_RECEIVED, + (ipcarg_t) socket->socket_id, + ((packet_dimension->content < socket_data->data_fragment_size) ? + packet_dimension->content : socket_data->data_fragment_size), 0, 0, + (ipcarg_t) fragments); + return EOK; } -int tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet){ +int +tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref socket_data, + tcp_header_ref header, packet_t packet) +{ ERROR_DECLARE; @@ -705,41 +849,50 @@ assert(packet); - if(header->synchronize){ - // process acknowledgement - tcp_process_acknowledgement(socket, socket_data, header); - - socket_data->next_incoming = ntohl(header->sequence_number) + 1; - // release additional packets - next_packet = pq_detach(packet); - if(next_packet){ - pq_release_remote(tcp_globals.net_phone, packet_get_id(next_packet)); - } - // trim if longer than the header - if((packet_get_data_length(packet) > sizeof(*header)) - && ERROR_OCCURRED(packet_trim(packet, 0, packet_get_data_length(packet) - sizeof(*header)))){ - return tcp_release_and_return(packet, ERROR_CODE); - } - tcp_prepare_operation_header(socket, socket_data, header, 0, 0); - fibril_mutex_lock(&socket_data->operation.mutex); - socket_data->operation.result = tcp_queue_packet(socket, socket_data, packet, 1); - if(socket_data->operation.result == EOK){ - socket_data->state = TCP_SOCKET_ESTABLISHED; - packet = tcp_get_packets_to_send(socket, socket_data); - if(packet){ - fibril_rwlock_write_unlock(socket_data->local_lock); - // send the packet - tcp_send_packets(socket_data->device_id, packet); - // signal the result - fibril_condvar_signal(&socket_data->operation.condvar); - fibril_mutex_unlock(&socket_data->operation.mutex); - return EOK; - } - } - fibril_mutex_unlock(&socket_data->operation.mutex); - } + if (!header->synchronize) + return tcp_release_and_return(packet, EINVAL); + + // process acknowledgement + tcp_process_acknowledgement(socket, socket_data, header); + + socket_data->next_incoming = ntohl(header->sequence_number) + 1; + // release additional packets + next_packet = pq_detach(packet); + if (next_packet) { + pq_release_remote(tcp_globals.net_phone, + packet_get_id(next_packet)); + } + // trim if longer than the header + if ((packet_get_data_length(packet) > sizeof(*header)) && + ERROR_OCCURRED(packet_trim(packet, 0, + packet_get_data_length(packet) - sizeof(*header)))) { + return tcp_release_and_return(packet, ERROR_CODE); + } + tcp_prepare_operation_header(socket, socket_data, header, 0, 0); + fibril_mutex_lock(&socket_data->operation.mutex); + socket_data->operation.result = tcp_queue_packet(socket, socket_data, + packet, 1); + if (socket_data->operation.result == EOK) { + socket_data->state = TCP_SOCKET_ESTABLISHED; + packet = tcp_get_packets_to_send(socket, socket_data); + if (packet) { + fibril_rwlock_write_unlock( socket_data->local_lock); + // send the packet + tcp_send_packets(socket_data->device_id, packet); + // signal the result + fibril_condvar_signal( &socket_data->operation.condvar); + fibril_mutex_unlock( &socket_data->operation.mutex); + return EOK; + } + } + fibril_mutex_unlock(&socket_data->operation.mutex); return tcp_release_and_return(packet, EINVAL); } -int tcp_process_listen(socket_core_ref listening_socket, tcp_socket_data_ref listening_socket_data, tcp_header_ref header, packet_t packet, struct sockaddr * src, struct sockaddr * dest, size_t addrlen){ +int +tcp_process_listen(socket_core_ref listening_socket, + tcp_socket_data_ref listening_socket_data, tcp_header_ref header, + packet_t packet, struct sockaddr *src, struct sockaddr *dest, + size_t addrlen) +{ ERROR_DECLARE; @@ -757,128 +910,144 @@ assert(packet); -// printf("syn %d\n", header->synchronize); - if(header->synchronize){ - socket_data = (tcp_socket_data_ref) malloc(sizeof(*socket_data)); - if(! socket_data){ - return tcp_release_and_return(packet, ENOMEM); - }else{ - tcp_initialize_socket_data(socket_data); - socket_data->local_lock = listening_socket_data->local_lock; - socket_data->local_sockets = listening_socket_data->local_sockets; - socket_data->listening_socket_id = listening_socket->socket_id; - - socket_data->next_incoming = ntohl(header->sequence_number); - socket_data->treshold = socket_data->next_incoming + ntohs(header->window); - - socket_data->addrlen = addrlen; - socket_data->addr = malloc(socket_data->addrlen); - if(! socket_data->addr){ - free(socket_data); - return tcp_release_and_return(packet, ENOMEM); - } - memcpy(socket_data->addr, src, socket_data->addrlen); - - socket_data->dest_port = ntohs(header->source_port); - if(ERROR_OCCURRED(tl_set_address_port(socket_data->addr, socket_data->addrlen, socket_data->dest_port))){ - free(socket_data->addr); - free(socket_data); - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); - return ERROR_CODE; - } - -// printf("addr %p\n", socket_data->addr, socket_data->addrlen); - // create a socket - socket_id = -1; - if(ERROR_OCCURRED(socket_create(socket_data->local_sockets, listening_socket->phone, socket_data, &socket_id))){ - free(socket_data->addr); - free(socket_data); - return tcp_release_and_return(packet, ERROR_CODE); - } - - printf("new_sock %d\n", socket_id); - socket_data->pseudo_header = listening_socket_data->pseudo_header; - socket_data->headerlen = listening_socket_data->headerlen; - listening_socket_data->pseudo_header = NULL; - listening_socket_data->headerlen = 0; - - fibril_rwlock_write_unlock(socket_data->local_lock); -// printf("list lg\n"); - fibril_rwlock_write_lock(&tcp_globals.lock); -// printf("list locked\n"); - // find the destination socket - listening_socket = socket_port_find(&tcp_globals.sockets, listening_port, SOCKET_MAP_KEY_LISTENING, 0); - if((! listening_socket) || (listening_socket->socket_id != listening_socket_id)){ - fibril_rwlock_write_unlock(&tcp_globals.lock); - // a shadow may remain until app hangs up - return tcp_release_and_return(packet, EOK/*ENOTSOCK*/); - } -// printf("port %d\n", listening_socket->port); - listening_socket_data = (tcp_socket_data_ref) listening_socket->specific_data; - assert(listening_socket_data); - -// printf("list ll\n"); - fibril_rwlock_write_lock(listening_socket_data->local_lock); -// printf("list locked\n"); - - socket = socket_cores_find(listening_socket_data->local_sockets, socket_id); - if(! socket){ - // where is the socket?!? - fibril_rwlock_write_unlock(&tcp_globals.lock); - return ENOTSOCK; - } - socket_data = (tcp_socket_data_ref) socket->specific_data; - assert(socket_data); - -// uint8_t * data = socket_data->addr; -// printf("addr %d of %x %x %x %x-%x %x %x %x-%x %x %x %x-%x %x %x %x\n", socket_data->addrlen, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11], data[12], data[13], data[14], data[15]); - - ERROR_CODE = socket_port_add(&tcp_globals.sockets, listening_port, socket, (const char *) socket_data->addr, socket_data->addrlen); - assert(socket == socket_port_find(&tcp_globals.sockets, listening_port, (const char *) socket_data->addr, socket_data->addrlen)); - //ERROR_CODE = socket_bind_free_port(&tcp_globals.sockets, socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, tcp_globals.last_used_port); - //tcp_globals.last_used_port = socket->port; -// printf("bound %d\n", socket->port); - fibril_rwlock_write_unlock(&tcp_globals.lock); - if(ERROR_CODE != EOK){ - socket_destroy(tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, &tcp_globals.sockets, tcp_free_socket_data); - return tcp_release_and_return(packet, ERROR_CODE); - } - - socket_data->state = TCP_SOCKET_LISTEN; - socket_data->next_incoming = ntohl(header->sequence_number) + 1; - // release additional packets - next_packet = pq_detach(packet); - if(next_packet){ - pq_release_remote(tcp_globals.net_phone, packet_get_id(next_packet)); - } - // trim if longer than the header - if((packet_get_data_length(packet) > sizeof(*header)) - && ERROR_OCCURRED(packet_trim(packet, 0, packet_get_data_length(packet) - sizeof(*header)))){ - socket_destroy(tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, &tcp_globals.sockets, tcp_free_socket_data); - return tcp_release_and_return(packet, ERROR_CODE); - } - tcp_prepare_operation_header(socket, socket_data, header, 1, 0); - if(ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1))){ - socket_destroy(tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, &tcp_globals.sockets, tcp_free_socket_data); - return ERROR_CODE; - } - packet = tcp_get_packets_to_send(socket, socket_data); -// printf("send %d\n", packet_get_id(packet)); - if(! packet){ - socket_destroy(tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, &tcp_globals.sockets, tcp_free_socket_data); - return EINVAL; - }else{ - socket_data->state = TCP_SOCKET_SYN_RECEIVED; -// printf("unlock\n"); - fibril_rwlock_write_unlock(socket_data->local_lock); - // send the packet - tcp_send_packets(socket_data->device_id, packet); - return EOK; - } - } - } - return tcp_release_and_return(packet, EINVAL); -} - -int tcp_process_syn_received(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet){ + if (!header->synchronize) + return tcp_release_and_return(packet, EINVAL); + + socket_data = (tcp_socket_data_ref) malloc(sizeof(*socket_data)); + if (!socket_data) + return tcp_release_and_return(packet, ENOMEM); + + tcp_initialize_socket_data(socket_data); + socket_data->local_lock = listening_socket_data->local_lock; + socket_data->local_sockets = listening_socket_data->local_sockets; + socket_data->listening_socket_id = listening_socket->socket_id; + socket_data->next_incoming = ntohl(header->sequence_number); + socket_data->treshold = socket_data->next_incoming + + ntohs(header->window); + socket_data->addrlen = addrlen; + socket_data->addr = malloc(socket_data->addrlen); + if (!socket_data->addr) { + free(socket_data); + return tcp_release_and_return(packet, ENOMEM); + } + memcpy(socket_data->addr, src, socket_data->addrlen); + socket_data->dest_port = ntohs(header->source_port); + if (ERROR_OCCURRED(tl_set_address_port(socket_data->addr, + socket_data->addrlen, socket_data->dest_port))) { + free(socket_data->addr); + free(socket_data); + pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); + return ERROR_CODE; + } + + // create a socket + socket_id = -1; + if (ERROR_OCCURRED(socket_create(socket_data->local_sockets, + listening_socket->phone, socket_data, &socket_id))) { + free(socket_data->addr); + free(socket_data); + return tcp_release_and_return(packet, ERROR_CODE); + } + + printf("new_sock %d\n", socket_id); + socket_data->pseudo_header = listening_socket_data->pseudo_header; + socket_data->headerlen = listening_socket_data->headerlen; + listening_socket_data->pseudo_header = NULL; + listening_socket_data->headerlen = 0; + + fibril_rwlock_write_unlock(socket_data->local_lock); + fibril_rwlock_write_lock(&tcp_globals.lock); + + // find the destination socket + listening_socket = socket_port_find(&tcp_globals.sockets, + listening_port, SOCKET_MAP_KEY_LISTENING, 0); + if ((!listening_socket) || + (listening_socket->socket_id != listening_socket_id)) { + fibril_rwlock_write_unlock(&tcp_globals.lock); + // a shadow may remain until app hangs up + return tcp_release_and_return(packet, EOK /*ENOTSOCK*/); + } + listening_socket_data = + (tcp_socket_data_ref) listening_socket->specific_data; + assert(listening_socket_data); + + fibril_rwlock_write_lock(listening_socket_data->local_lock); + + socket = socket_cores_find(listening_socket_data->local_sockets, + socket_id); + if (!socket) { + // where is the socket?!? + fibril_rwlock_write_unlock(&tcp_globals.lock); + return ENOTSOCK; + } + socket_data = (tcp_socket_data_ref) socket->specific_data; + assert(socket_data); + + ERROR_CODE = socket_port_add(&tcp_globals.sockets, listening_port, + socket, (const char *) socket_data->addr, socket_data->addrlen); + assert(socket == socket_port_find(&tcp_globals.sockets, listening_port, + (const char *) socket_data->addr, socket_data->addrlen)); + +// ERROR_CODE = socket_bind_free_port(&tcp_globals.sockets, socket, +// TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, +// tcp_globals.last_used_port); +// tcp_globals.last_used_port = socket->port; + fibril_rwlock_write_unlock(&tcp_globals.lock); + if (ERROR_CODE != EOK) { + socket_destroy(tcp_globals.net_phone, socket->socket_id, + socket_data->local_sockets, &tcp_globals.sockets, + tcp_free_socket_data); + return tcp_release_and_return(packet, ERROR_CODE); + } + + socket_data->state = TCP_SOCKET_LISTEN; + socket_data->next_incoming = ntohl(header->sequence_number) + 1; + + // release additional packets + next_packet = pq_detach(packet); + if (next_packet) { + pq_release_remote(tcp_globals.net_phone, + packet_get_id(next_packet)); + } + + // trim if longer than the header + if ((packet_get_data_length(packet) > sizeof(*header)) && + ERROR_OCCURRED(packet_trim(packet, 0, + packet_get_data_length(packet) - sizeof(*header)))) { + socket_destroy(tcp_globals.net_phone, socket->socket_id, + socket_data->local_sockets, &tcp_globals.sockets, + tcp_free_socket_data); + return tcp_release_and_return(packet, ERROR_CODE); + } + + tcp_prepare_operation_header(socket, socket_data, header, 1, 0); + + if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1))) { + socket_destroy(tcp_globals.net_phone, socket->socket_id, + socket_data->local_sockets, &tcp_globals.sockets, + tcp_free_socket_data); + return ERROR_CODE; + } + + packet = tcp_get_packets_to_send(socket, socket_data); + if (!packet) { + socket_destroy(tcp_globals.net_phone, socket->socket_id, + socket_data->local_sockets, &tcp_globals.sockets, + tcp_free_socket_data); + return EINVAL; + } + + socket_data->state = TCP_SOCKET_SYN_RECEIVED; + fibril_rwlock_write_unlock(socket_data->local_lock); + + // send the packet + tcp_send_packets(socket_data->device_id, packet); + + return EOK; +} + +int +tcp_process_syn_received(socket_core_ref socket, + tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet) +{ ERROR_DECLARE; @@ -892,49 +1061,60 @@ assert(packet); - printf("syn_rec\n"); - if(header->acknowledge){ - // process acknowledgement - tcp_process_acknowledgement(socket, socket_data, header); - - socket_data->next_incoming = ntohl(header->sequence_number);// + 1; - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); - socket_data->state = TCP_SOCKET_ESTABLISHED; - listening_socket = socket_cores_find(socket_data->local_sockets, socket_data->listening_socket_id); - if(listening_socket){ - listening_socket_data = (tcp_socket_data_ref) listening_socket->specific_data; - assert(listening_socket_data); - - // queue the received packet - if(! ERROR_OCCURRED(dyn_fifo_push(&listening_socket->accepted, (-1 * socket->socket_id), listening_socket_data->backlog))){ - // notify the destination socket - async_msg_5(socket->phone, NET_SOCKET_ACCEPTED, (ipcarg_t) listening_socket->socket_id, socket_data->data_fragment_size, TCP_HEADER_SIZE, 0, (ipcarg_t) socket->socket_id); - fibril_rwlock_write_unlock(socket_data->local_lock); - return EOK; - } - } - // send FIN - socket_data->state = TCP_SOCKET_FIN_WAIT_1; - - // create the notification packet - ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, socket_data, 0, 1)); - + if (!header->acknowledge) + return tcp_release_and_return(packet, EINVAL); + + // process acknowledgement + tcp_process_acknowledgement(socket, socket_data, header); + + socket_data->next_incoming = ntohl(header->sequence_number); // + 1; + pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); + socket_data->state = TCP_SOCKET_ESTABLISHED; + listening_socket = socket_cores_find(socket_data->local_sockets, + socket_data->listening_socket_id); + if (listening_socket) { + listening_socket_data = + (tcp_socket_data_ref) listening_socket->specific_data; + assert(listening_socket_data); + + // queue the received packet + if (ERROR_NONE(dyn_fifo_push(&listening_socket->accepted, + (-1 * socket->socket_id), + listening_socket_data->backlog))) { + + // notify the destination socket + async_msg_5(socket->phone, NET_SOCKET_ACCEPTED, + (ipcarg_t) listening_socket->socket_id, + socket_data->data_fragment_size, TCP_HEADER_SIZE, + 0, (ipcarg_t) socket->socket_id); + + fibril_rwlock_write_unlock(socket_data->local_lock); + return EOK; + } + } + // send FIN + socket_data->state = TCP_SOCKET_FIN_WAIT_1; + + // create the notification packet + ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, + socket_data, 0, 1)); + + // send the packet + ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1)); + + // flush packets + packet = tcp_get_packets_to_send(socket, socket_data); + fibril_rwlock_write_unlock(socket_data->local_lock); + if (packet) { // send the packet - ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1)); - - // flush packets - packet = tcp_get_packets_to_send(socket, socket_data); - fibril_rwlock_write_unlock(socket_data->local_lock); - if(packet){ - // send the packet - tcp_send_packets(socket_data->device_id, packet); - } - return EOK; - }else{ - return tcp_release_and_return(packet, EINVAL); - } - return EINVAL; -} - -void tcp_process_acknowledgement(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header){ + tcp_send_packets(socket_data->device_id, packet); + } + + return EOK; +} + +void +tcp_process_acknowledgement(socket_core_ref socket, + tcp_socket_data_ref socket_data, tcp_header_ref header) +{ size_t number; size_t length; @@ -949,65 +1129,78 @@ assert(header); - if(header->acknowledge){ - number = ntohl(header->acknowledgement_number); - // if more data acknowledged - if(number != socket_data->expected){ - old = socket_data->expected; - if(IS_IN_INTERVAL_OVERFLOW(old, socket_data->fin_outgoing, number)){ - switch(socket_data->state){ - case TCP_SOCKET_FIN_WAIT_1: - socket_data->state = TCP_SOCKET_FIN_WAIT_2; - break; - case TCP_SOCKET_LAST_ACK: - case TCP_SOCKET_CLOSING: - // fin acknowledged - release the socket in another fibril - tcp_prepare_timeout(tcp_release_after_timeout, socket, socket_data, 0, TCP_SOCKET_TIME_WAIT, NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT, true); - break; - default: - break; - } + if (!header->acknowledge) + return; + + number = ntohl(header->acknowledgement_number); + // if more data acknowledged + if (number != socket_data->expected) { + old = socket_data->expected; + if (IS_IN_INTERVAL_OVERFLOW(old, socket_data->fin_outgoing, + number)) { + switch (socket_data->state) { + case TCP_SOCKET_FIN_WAIT_1: + socket_data->state = TCP_SOCKET_FIN_WAIT_2; + break; + case TCP_SOCKET_LAST_ACK: + case TCP_SOCKET_CLOSING: + // fin acknowledged - release the socket in + // another fibril + tcp_prepare_timeout(tcp_release_after_timeout, + socket, socket_data, 0, + TCP_SOCKET_TIME_WAIT, + NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT, true); + break; + default: + break; } - // update the treshold if higher than set - if(number + ntohs(header->window) > socket_data->expected + socket_data->treshold){ - socket_data->treshold = number + ntohs(header->window) - socket_data->expected; - } - // set new expected sequence number - socket_data->expected = number; + } + // update the treshold if higher than set + if (number + ntohs(header->window) > + socket_data->expected + socket_data->treshold) { + socket_data->treshold = number + ntohs(header->window) - + socket_data->expected; + } + // set new expected sequence number + socket_data->expected = number; + socket_data->expected_count = 1; + packet = socket_data->outgoing; + while (pq_get_order(packet, &number, &length) == EOK) { + if (IS_IN_INTERVAL_OVERFLOW((uint32_t) old, + (uint32_t) (number + length), + (uint32_t) socket_data->expected)) { + next = pq_detach(packet); + if (packet == socket_data->outgoing) + socket_data->outgoing = next; + + // add to acknowledged or release + if (pq_add(&acknowledged, packet, 0, 0) != EOK) + pq_release_remote(tcp_globals.net_phone, + packet_get_id(packet)); + packet = next; + } else if (old < socket_data->expected) + break; + } + // release acknowledged + if (acknowledged) { + pq_release_remote(tcp_globals.net_phone, + packet_get_id(acknowledged)); + } + return; + // if the same as the previous time + } + if (number == socket_data->expected) { + // increase the counter + ++socket_data->expected_count; + if (socket_data->expected_count == TCP_FAST_RETRANSMIT_COUNT) { socket_data->expected_count = 1; - packet = socket_data->outgoing; - while(pq_get_order(packet, &number, &length) == EOK){ - if(IS_IN_INTERVAL_OVERFLOW((uint32_t) old, (uint32_t)(number + length), (uint32_t) socket_data->expected)){ - next = pq_detach(packet); - if(packet == socket_data->outgoing){ - socket_data->outgoing = next; - } - // add to acknowledged or release - if(pq_add(&acknowledged, packet, 0, 0) != EOK){ - pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); - } - packet = next; - }else if(old < socket_data->expected){ - break; - } - } - // release acknowledged - if(acknowledged){ - pq_release_remote(tcp_globals.net_phone, packet_get_id(acknowledged)); - } - return; - // if the same as the previous time - }else if(number == socket_data->expected){ - // increase the counter - ++ socket_data->expected_count; - if(socket_data->expected_count == TCP_FAST_RETRANSMIT_COUNT){ - socket_data->expected_count = 1; - // TODO retransmit lock - //tcp_retransmit_packet(socket, socket_data, number); - } - } - } -} - -int tcp_message_standalone(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){ + // TODO retransmit lock + //tcp_retransmit_packet(socket, socket_data, number); + } + } +} + +int tcp_message_standalone(ipc_callid_t callid, ipc_call_t * call, + ipc_call_t * answer, int *answer_count) +{ ERROR_DECLARE; @@ -1019,19 +1212,24 @@ *answer_count = 0; - switch(IPC_GET_METHOD(*call)){ - case NET_TL_RECEIVED: - //fibril_rwlock_read_lock(&tcp_globals.lock); - if(! ERROR_OCCURRED(packet_translate_remote(tcp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){ - ERROR_CODE = tcp_received_msg(IPC_GET_DEVICE(call), packet, SERVICE_TCP, IPC_GET_ERROR(call)); - } - //fibril_rwlock_read_unlock(&tcp_globals.lock); - return ERROR_CODE; - case IPC_M_CONNECT_TO_ME: - return tcp_process_client_messages(callid, * call); - } + switch (IPC_GET_METHOD(*call)) { + case NET_TL_RECEIVED: + //fibril_rwlock_read_lock(&tcp_globals.lock); + if (ERROR_NONE(packet_translate_remote(tcp_globals.net_phone, + &packet, IPC_GET_PACKET(call)))) { + ERROR_CODE = tcp_received_msg(IPC_GET_DEVICE(call), + packet, SERVICE_TCP, IPC_GET_ERROR(call)); + } + //fibril_rwlock_read_unlock(&tcp_globals.lock); + return ERROR_CODE; + + case IPC_M_CONNECT_TO_ME: + return tcp_process_client_messages(callid, *call); + } + return ENOTSUP; } -void tcp_refresh_socket_data(tcp_socket_data_ref socket_data){ +void tcp_refresh_socket_data(tcp_socket_data_ref socket_data) +{ assert(socket_data); @@ -1048,5 +1246,6 @@ } -void tcp_initialize_socket_data(tcp_socket_data_ref socket_data){ +void tcp_initialize_socket_data(tcp_socket_data_ref socket_data) +{ assert(socket_data); @@ -1057,10 +1256,11 @@ } -int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call){ +int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call) +{ int res; bool keep_on_going = true; socket_cores_t local_sockets; int app_phone = IPC_GET_PHONE(&call); - struct sockaddr * addr; + struct sockaddr *addr; int socket_id; size_t addrlen; @@ -1083,168 +1283,208 @@ fibril_rwlock_initialize(&lock); - while(keep_on_going){ + while (keep_on_going) { // answer the call answer_call(callid, res, &answer, answer_count); - // refresh data refresh_answer(&answer, &answer_count); - // get the next call callid = async_get_call(&call); // process the call - switch(IPC_GET_METHOD(call)){ - case IPC_M_PHONE_HUNGUP: - keep_on_going = false; - res = EHANGUP; + switch (IPC_GET_METHOD(call)) { + case IPC_M_PHONE_HUNGUP: + keep_on_going = false; + res = EHANGUP; + break; + + case NET_SOCKET: + socket_data = + (tcp_socket_data_ref) malloc(sizeof(*socket_data)); + if (!socket_data) { + res = ENOMEM; break; - case NET_SOCKET: - socket_data = (tcp_socket_data_ref) malloc(sizeof(*socket_data)); - if(! socket_data){ - res = ENOMEM; - }else{ - tcp_initialize_socket_data(socket_data); - socket_data->local_lock = &lock; - socket_data->local_sockets = &local_sockets; - fibril_rwlock_write_lock(&lock); - socket_id = SOCKET_GET_SOCKET_ID(call); - res = socket_create(&local_sockets, app_phone, socket_data, &socket_id); - SOCKET_SET_SOCKET_ID(answer, socket_id); - fibril_rwlock_write_unlock(&lock); - if(res == EOK){ - if (tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, DEVICE_INVALID_ID, &packet_dimension) == EOK){ - SOCKET_SET_DATA_FRAGMENT_SIZE(answer, ((packet_dimension->content < socket_data->data_fragment_size) ? packet_dimension->content : socket_data->data_fragment_size)); - } -// SOCKET_SET_DATA_FRAGMENT_SIZE(answer, MAX_TCP_FRAGMENT_SIZE); - SOCKET_SET_HEADER_SIZE(answer, TCP_HEADER_SIZE); - answer_count = 3; - }else{ - free(socket_data); - } + } + + tcp_initialize_socket_data(socket_data); + socket_data->local_lock = &lock; + socket_data->local_sockets = &local_sockets; + fibril_rwlock_write_lock(&lock); + socket_id = SOCKET_GET_SOCKET_ID(call); + res = socket_create(&local_sockets, app_phone, + socket_data, &socket_id); + SOCKET_SET_SOCKET_ID(answer, socket_id); + fibril_rwlock_write_unlock(&lock); + if (res != EOK) { + free(socket_data); + break; + } + if (tl_get_ip_packet_dimension(tcp_globals.ip_phone, + &tcp_globals.dimensions, DEVICE_INVALID_ID, + &packet_dimension) == EOK) { + SOCKET_SET_DATA_FRAGMENT_SIZE(answer, + ((packet_dimension->content < + socket_data->data_fragment_size) ? + packet_dimension->content : + socket_data->data_fragment_size)); + } +// SOCKET_SET_DATA_FRAGMENT_SIZE(answer, MAX_TCP_FRAGMENT_SIZE); + SOCKET_SET_HEADER_SIZE(answer, TCP_HEADER_SIZE); + answer_count = 3; + break; + + case NET_SOCKET_BIND: + res = data_receive((void **) &addr, &addrlen); + if (res != EOK) + break; + fibril_rwlock_write_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = socket_bind(&local_sockets, &tcp_globals.sockets, + SOCKET_GET_SOCKET_ID(call), addr, addrlen, + TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, + tcp_globals.last_used_port); + if (res == EOK) { + socket = socket_cores_find(&local_sockets, + SOCKET_GET_SOCKET_ID(call)); + if (socket) { + socket_data = (tcp_socket_data_ref) + socket->specific_data; + assert(socket_data); + socket_data->state = TCP_SOCKET_LISTEN; } + } + fibril_rwlock_write_unlock(&lock); + fibril_rwlock_write_unlock(&tcp_globals.lock); + free(addr); + break; + + case NET_SOCKET_LISTEN: + fibril_rwlock_read_lock(&tcp_globals.lock); +// fibril_rwlock_write_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = tcp_listen_message(&local_sockets, + SOCKET_GET_SOCKET_ID(call), + SOCKET_GET_BACKLOG(call)); + fibril_rwlock_write_unlock(&lock); +// fibril_rwlock_write_unlock(&tcp_globals.lock); + fibril_rwlock_read_unlock(&tcp_globals.lock); + break; + + case NET_SOCKET_CONNECT: + res = data_receive((void **) &addr, &addrlen); + if (res != EOK) break; - case NET_SOCKET_BIND: - res = data_receive((void **) &addr, &addrlen); - if(res == EOK){ - fibril_rwlock_write_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = socket_bind(&local_sockets, &tcp_globals.sockets, SOCKET_GET_SOCKET_ID(call), addr, addrlen, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, tcp_globals.last_used_port); - if(res == EOK){ - socket = socket_cores_find(&local_sockets, SOCKET_GET_SOCKET_ID(call)); - if(socket){ - socket_data = (tcp_socket_data_ref) socket->specific_data; - assert(socket_data); - socket_data->state = TCP_SOCKET_LISTEN; - } - } - fibril_rwlock_write_unlock(&lock); - fibril_rwlock_write_unlock(&tcp_globals.lock); - free(addr); - } - break; - case NET_SOCKET_LISTEN: - fibril_rwlock_read_lock(&tcp_globals.lock); -// fibril_rwlock_write_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = tcp_listen_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_BACKLOG(call)); + // the global lock may be released in the + // tcp_connect_message() function + fibril_rwlock_write_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = tcp_connect_message(&local_sockets, + SOCKET_GET_SOCKET_ID(call), addr, addrlen); + if (res != EOK) { fibril_rwlock_write_unlock(&lock); -// fibril_rwlock_write_unlock(&tcp_globals.lock); - fibril_rwlock_read_unlock(&tcp_globals.lock); - break; - case NET_SOCKET_CONNECT: - res = data_receive((void **) &addr, &addrlen); - if(res == EOK){ - // the global lock may be released in the tcp_connect_message() function - fibril_rwlock_write_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = tcp_connect_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), addr, addrlen); - if(res != EOK){ - fibril_rwlock_write_unlock(&lock); - fibril_rwlock_write_unlock(&tcp_globals.lock); - free(addr); - } - } - break; - case NET_SOCKET_ACCEPT: - fibril_rwlock_read_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = tcp_accept_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_NEW_SOCKET_ID(call), &size, &addrlen); - SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size); + fibril_rwlock_write_unlock(&tcp_globals.lock); + free(addr); + } + break; + + case NET_SOCKET_ACCEPT: + fibril_rwlock_read_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = tcp_accept_message(&local_sockets, + SOCKET_GET_SOCKET_ID(call), + SOCKET_GET_NEW_SOCKET_ID(call), &size, &addrlen); + SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size); + fibril_rwlock_write_unlock(&lock); + fibril_rwlock_read_unlock(&tcp_globals.lock); + if (res > 0) { + SOCKET_SET_SOCKET_ID(answer, res); + SOCKET_SET_ADDRESS_LENGTH(answer, addrlen); + answer_count = 3; + } + break; + + case NET_SOCKET_SEND: + fibril_rwlock_read_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = tcp_send_message(&local_sockets, + SOCKET_GET_SOCKET_ID(call), + SOCKET_GET_DATA_FRAGMENTS(call), &size, + SOCKET_GET_FLAGS(call)); + SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size); + if (res != EOK) { fibril_rwlock_write_unlock(&lock); fibril_rwlock_read_unlock(&tcp_globals.lock); - if(res > 0){ - SOCKET_SET_SOCKET_ID(answer, res); - SOCKET_SET_ADDRESS_LENGTH(answer, addrlen); - answer_count = 3; - } + } else { + answer_count = 2; + } + break; + + case NET_SOCKET_SENDTO: + res = data_receive((void **) &addr, &addrlen); + if (res != EOK) break; - case NET_SOCKET_SEND: - fibril_rwlock_read_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = tcp_send_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_DATA_FRAGMENTS(call), &size, SOCKET_GET_FLAGS(call)); - SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size); - if(res != EOK){ - fibril_rwlock_write_unlock(&lock); - fibril_rwlock_read_unlock(&tcp_globals.lock); - }else{ - answer_count = 2; - } - break; - case NET_SOCKET_SENDTO: - res = data_receive((void **) &addr, &addrlen); - if(res == EOK){ - fibril_rwlock_read_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = tcp_send_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_DATA_FRAGMENTS(call), &size, SOCKET_GET_FLAGS(call)); - SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size); - if(res != EOK){ - fibril_rwlock_write_unlock(&lock); - fibril_rwlock_read_unlock(&tcp_globals.lock); - }else{ - answer_count = 2; - } - free(addr); - } - break; - case NET_SOCKET_RECV: - fibril_rwlock_read_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = tcp_recvfrom_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call), NULL); + fibril_rwlock_read_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = tcp_send_message(&local_sockets, + SOCKET_GET_SOCKET_ID(call), + SOCKET_GET_DATA_FRAGMENTS(call), &size, + SOCKET_GET_FLAGS(call)); + SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size); + if (res != EOK) { fibril_rwlock_write_unlock(&lock); fibril_rwlock_read_unlock(&tcp_globals.lock); - if(res > 0){ - SOCKET_SET_READ_DATA_LENGTH(answer, res); - answer_count = 1; - res = EOK; - } - break; - case NET_SOCKET_RECVFROM: - fibril_rwlock_read_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = tcp_recvfrom_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call), &addrlen); + } else { + answer_count = 2; + } + free(addr); + break; + + case NET_SOCKET_RECV: + fibril_rwlock_read_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = tcp_recvfrom_message(&local_sockets, + SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call), + NULL); + fibril_rwlock_write_unlock(&lock); + fibril_rwlock_read_unlock(&tcp_globals.lock); + if (res > 0) { + SOCKET_SET_READ_DATA_LENGTH(answer, res); + answer_count = 1; + res = EOK; + } + break; + + case NET_SOCKET_RECVFROM: + fibril_rwlock_read_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = tcp_recvfrom_message(&local_sockets, + SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call), + &addrlen); + fibril_rwlock_write_unlock(&lock); + fibril_rwlock_read_unlock(&tcp_globals.lock); + if (res > 0) { + SOCKET_SET_READ_DATA_LENGTH(answer, res); + SOCKET_SET_ADDRESS_LENGTH(answer, addrlen); + answer_count = 3; + res = EOK; + } + break; + + case NET_SOCKET_CLOSE: + fibril_rwlock_write_lock(&tcp_globals.lock); + fibril_rwlock_write_lock(&lock); + res = tcp_close_message(&local_sockets, + SOCKET_GET_SOCKET_ID(call)); + if (res != EOK) { fibril_rwlock_write_unlock(&lock); - fibril_rwlock_read_unlock(&tcp_globals.lock); - if(res > 0){ - SOCKET_SET_READ_DATA_LENGTH(answer, res); - SOCKET_SET_ADDRESS_LENGTH(answer, addrlen); - answer_count = 3; - res = EOK; - } - break; - case NET_SOCKET_CLOSE: - fibril_rwlock_write_lock(&tcp_globals.lock); - fibril_rwlock_write_lock(&lock); - res = tcp_close_message(&local_sockets, SOCKET_GET_SOCKET_ID(call)); - if(res != EOK){ - fibril_rwlock_write_unlock(&lock); - fibril_rwlock_write_unlock(&tcp_globals.lock); - } - break; - case NET_SOCKET_GETSOCKOPT: - case NET_SOCKET_SETSOCKOPT: - default: - res = ENOTSUP; - break; + fibril_rwlock_write_unlock(&tcp_globals.lock); + } + break; + + case NET_SOCKET_GETSOCKOPT: + case NET_SOCKET_SETSOCKOPT: + default: + res = ENOTSUP; + break; } } @@ -1255,10 +1495,12 @@ printf("release\n"); // release all local sockets - socket_cores_release(tcp_globals.net_phone, &local_sockets, &tcp_globals.sockets, tcp_free_socket_data); + socket_cores_release(tcp_globals.net_phone, &local_sockets, + &tcp_globals.sockets, tcp_free_socket_data); return EOK; } -int tcp_timeout(void * data){ +int tcp_timeout(void *data) +{ tcp_timeout_ref timeout = data; int keep_write_lock = false; @@ -1271,53 +1513,61 @@ async_usleep(timeout->timeout); // lock the globals - if(timeout->globals_read_only){ + if (timeout->globals_read_only) fibril_rwlock_read_lock(&tcp_globals.lock); - }else{ + else fibril_rwlock_write_lock(&tcp_globals.lock); - } + // find the pending operation socket - socket = socket_port_find(&tcp_globals.sockets, timeout->port, timeout->key, timeout->key_length); - if(socket && (socket->socket_id == timeout->socket_id)){ - socket_data = (tcp_socket_data_ref) socket->specific_data; - assert(socket_data); - if(socket_data->local_sockets == timeout->local_sockets){ - fibril_rwlock_write_lock(socket_data->local_lock); - if(timeout->sequence_number){ - // increase the timeout counter; - ++ socket_data->timeout_count; - if(socket_data->timeout_count == TCP_MAX_TIMEOUTS){ - // TODO release as connection lost - //tcp_refresh_socket_data(socket_data); - fibril_rwlock_write_unlock(socket_data->local_lock); - }else{ - // retransmit -// tcp_retransmit_packet(socket, socket_data, timeout->sequence_number); - fibril_rwlock_write_unlock(socket_data->local_lock); - } - }else{ - fibril_mutex_lock(&socket_data->operation.mutex); - // set the timeout operation result if state not changed - if(socket_data->state == timeout->state){ - socket_data->operation.result = ETIMEOUT; - // notify the main fibril - fibril_condvar_signal(&socket_data->operation.condvar); - // keep the global write lock - keep_write_lock = true; - }else{ - // operation is ok, do nothing - // unlocking from now on, so the unlock order does not matter... - fibril_rwlock_write_unlock(socket_data->local_lock); - } - fibril_mutex_unlock(&socket_data->operation.mutex); - } - } - } + socket = socket_port_find(&tcp_globals.sockets, timeout->port, + timeout->key, timeout->key_length); + if (!(socket && (socket->socket_id == timeout->socket_id))) + goto out; + + socket_data = (tcp_socket_data_ref) socket->specific_data; + assert(socket_data); + if (socket_data->local_sockets != timeout->local_sockets) + goto out; + + fibril_rwlock_write_lock(socket_data->local_lock); + if (timeout->sequence_number) { + // increase the timeout counter; + ++socket_data->timeout_count; + if (socket_data->timeout_count == TCP_MAX_TIMEOUTS) { + // TODO release as connection lost + //tcp_refresh_socket_data(socket_data); + fibril_rwlock_write_unlock(socket_data->local_lock); + } else { + // retransmit +// tcp_retransmit_packet(socket, +// socket_data, timeout->sequence_number); + fibril_rwlock_write_unlock(socket_data->local_lock); + } + } else { + fibril_mutex_lock(&socket_data->operation.mutex); + // set the timeout operation result if state not + // changed + if (socket_data->state == timeout->state) { + socket_data->operation.result = ETIMEOUT; + // notify the main fibril + fibril_condvar_signal(&socket_data->operation.condvar); + // keep the global write lock + keep_write_lock = true; + } else { + // operation is ok, do nothing + // unlocking from now on, so the unlocki + // order does not matter... + fibril_rwlock_write_unlock(socket_data->local_lock); + } + fibril_mutex_unlock(&socket_data->operation.mutex); + } + +out: // unlock only if no socket - if(timeout->globals_read_only){ + if (timeout->globals_read_only) fibril_rwlock_read_unlock(&tcp_globals.lock); - }else if(! keep_write_lock){ + else if (!keep_write_lock) // release if not desired fibril_rwlock_write_unlock(&tcp_globals.lock); - } + // release the timeout structure free(timeout); @@ -1325,9 +1575,10 @@ } -int tcp_release_after_timeout(void * data){ +int tcp_release_after_timeout(void *data) +{ tcp_timeout_ref timeout = data; socket_core_ref socket; tcp_socket_data_ref socket_data; - fibril_rwlock_t * local_lock; + fibril_rwlock_t *local_lock; assert(timeout); @@ -1338,12 +1589,15 @@ fibril_rwlock_write_lock(&tcp_globals.lock); // find the pending operation socket - socket = socket_port_find(&tcp_globals.sockets, timeout->port, timeout->key, timeout->key_length); - if(socket && (socket->socket_id == timeout->socket_id)){ + socket = socket_port_find(&tcp_globals.sockets, timeout->port, + timeout->key, timeout->key_length); + if (socket && (socket->socket_id == timeout->socket_id)) { socket_data = (tcp_socket_data_ref) socket->specific_data; assert(socket_data); - if(socket_data->local_sockets == timeout->local_sockets){ + if (socket_data->local_sockets == timeout->local_sockets) { local_lock = socket_data->local_lock; fibril_rwlock_write_lock(local_lock); - socket_destroy(tcp_globals.net_phone, timeout->socket_id, timeout->local_sockets, &tcp_globals.sockets, tcp_free_socket_data); + socket_destroy(tcp_globals.net_phone, + timeout->socket_id, timeout->local_sockets, + &tcp_globals.sockets, tcp_free_socket_data); fibril_rwlock_write_unlock(local_lock); } @@ -1356,5 +1610,8 @@ } -void tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number){ +void +tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, + size_t sequence_number) +{ packet_t packet; packet_t copy; @@ -1368,18 +1625,20 @@ packet = pq_find(socket_data->outgoing, sequence_number); printf("retransmit %d\n", packet_get_id(packet)); - if(packet){ + if (packet) { pq_get_order(packet, NULL, &data_length); - copy = tcp_prepare_copy(socket, socket_data, packet, data_length, sequence_number); + copy = tcp_prepare_copy(socket, socket_data, packet, + data_length, sequence_number); fibril_rwlock_write_unlock(socket_data->local_lock); -// printf("r send %d\n", packet_get_id(packet)); - if(copy){ +// printf("r send %d\n", packet_get_id(packet)); + if (copy) tcp_send_packets(socket_data->device_id, copy); - } - }else{ + } else { fibril_rwlock_write_unlock(socket_data->local_lock); } } -int tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog){ +int +tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog) +{ socket_core_ref socket; tcp_socket_data_ref socket_data; @@ -1387,12 +1646,12 @@ assert(local_sockets); - if(backlog < 0){ + if (backlog < 0) return EINVAL; - } + // find the socket socket = socket_cores_find(local_sockets, socket_id); - if(! socket){ + if (!socket) return ENOTSOCK; - } + // get the socket specific data socket_data = (tcp_socket_data_ref) socket->specific_data; @@ -1400,8 +1659,12 @@ // set the backlog socket_data->backlog = backlog; + return EOK; } -int tcp_connect_message(socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen){ +int +tcp_connect_message(socket_cores_ref local_sockets, int socket_id, + struct sockaddr *addr, socklen_t addrlen) +{ ERROR_DECLARE; @@ -1414,12 +1677,14 @@ // find the socket socket = socket_cores_find(local_sockets, socket_id); - if(! socket){ + if (!socket) return ENOTSOCK; - } - if(ERROR_OCCURRED(tcp_connect_core(socket, local_sockets, addr, addrlen))){ + + if (ERROR_OCCURRED(tcp_connect_core(socket, local_sockets, addr, + addrlen))) { tcp_free_socket_data(socket); // unbind if bound - if(socket->port > 0){ - socket_ports_exclude(&tcp_globals.sockets, socket->port); + if (socket->port > 0) { + socket_ports_exclude(&tcp_globals.sockets, + socket->port); socket->port = 0; } @@ -1428,5 +1693,8 @@ } -int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen){ +int +tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets, + struct sockaddr *addr, socklen_t addrlen) +{ ERROR_DECLARE; @@ -1442,20 +1710,28 @@ assert(socket_data); assert(socket->specific_data == socket_data); - if((socket_data->state != TCP_SOCKET_INITIAL) - && ((socket_data->state != TCP_SOCKET_LISTEN) || (socket->port <= 0))){ + if ((socket_data->state != TCP_SOCKET_INITIAL) && + ((socket_data->state != TCP_SOCKET_LISTEN) || + (socket->port <= 0))) return EINVAL; - } + // get the destination port - ERROR_PROPAGATE(tl_get_address_port(addr, addrlen, &socket_data->dest_port)); - if(socket->port <= 0){ + ERROR_PROPAGATE(tl_get_address_port(addr, addrlen, + &socket_data->dest_port)); + if (socket->port <= 0) { // try to find a free port - ERROR_PROPAGATE(socket_bind_free_port(&tcp_globals.sockets, socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, tcp_globals.last_used_port)); + ERROR_PROPAGATE(socket_bind_free_port(&tcp_globals.sockets, + socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, + tcp_globals.last_used_port)); // set the next port as the search starting port number tcp_globals.last_used_port = socket->port; } - ERROR_PROPAGATE(ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP, addr, addrlen, &socket_data->device_id, &socket_data->pseudo_header, &socket_data->headerlen)); + + ERROR_PROPAGATE(ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP, + addr, addrlen, &socket_data->device_id, + &socket_data->pseudo_header, &socket_data->headerlen)); // create the notification packet - ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, socket_data, 1, 0)); + ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, + socket_data, 1, 0)); // unlock the globals and wait for an operation @@ -1465,12 +1741,16 @@ socket_data->addrlen = addrlen; // send the packet - if(ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1)) - || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data, 0, TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false))){ + if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1)) || + ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data, + 0, TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false))) { + socket_data->addr = NULL; socket_data->addrlen = 0; fibril_rwlock_write_lock(&tcp_globals.lock); - }else{ + + } else { + packet = tcp_get_packets_to_send(socket, socket_data); - if(packet){ + if (packet) { fibril_mutex_lock(&socket_data->operation.mutex); fibril_rwlock_write_unlock(socket_data->local_lock); @@ -1478,12 +1758,14 @@ printf("connecting %d\n", packet_get_id(packet)); tcp_send_packets(socket_data->device_id, packet); + // wait for a reply - fibril_condvar_wait(&socket_data->operation.condvar, &socket_data->operation.mutex); + fibril_condvar_wait(&socket_data->operation.condvar, + &socket_data->operation.mutex); ERROR_CODE = socket_data->operation.result; - if(ERROR_CODE != EOK){ + if (ERROR_CODE != EOK) { socket_data->addr = NULL; socket_data->addrlen = 0; } - }else{ + } else { socket_data->addr = NULL; socket_data->addrlen = 0; @@ -1498,5 +1780,8 @@ } -int tcp_queue_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length){ +int +tcp_queue_prepare_packet(socket_core_ref socket, + tcp_socket_data_ref socket_data, packet_t packet, size_t data_length) +{ ERROR_DECLARE; @@ -1509,21 +1794,26 @@ // get tcp header header = (tcp_header_ref) packet_get_data(packet); - if(! header){ + if (!header) return NO_DATA; - } + header->destination_port = htons(socket_data->dest_port); header->source_port = htons(socket->port); header->sequence_number = htonl(socket_data->next_outgoing); - if(ERROR_OCCURRED(packet_set_addr(packet, NULL, (uint8_t *) socket_data->addr, socket_data->addrlen))){ + + if (ERROR_OCCURRED(packet_set_addr(packet, NULL, + (uint8_t *) socket_data->addr, socket_data->addrlen))) return tcp_release_and_return(packet, EINVAL); - } + // remember the outgoing FIN - if(header->finalize){ + if (header->finalize) socket_data->fin_outgoing = socket_data->next_outgoing; - } + return EOK; } -int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length){ +int +tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, + packet_t packet, size_t data_length) +{ ERROR_DECLARE; @@ -1532,14 +1822,18 @@ assert(socket->specific_data == socket_data); - ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet, data_length)); - - if(ERROR_OCCURRED(pq_add(&socket_data->outgoing, packet, socket_data->next_outgoing, data_length))){ + ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet, + data_length)); + + if (ERROR_OCCURRED(pq_add(&socket_data->outgoing, packet, + socket_data->next_outgoing, data_length))) return tcp_release_and_return(packet, ERROR_CODE); - } + socket_data->next_outgoing += data_length; return EOK; } -packet_t tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data){ +packet_t +tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data) +{ ERROR_DECLARE; @@ -1555,38 +1849,47 @@ packet = pq_find(socket_data->outgoing, socket_data->last_outgoing + 1); - while(packet){ + while (packet) { pq_get_order(packet, NULL, &data_length); + // send only if fits into the window // respecting the possible overflow - if(IS_IN_INTERVAL_OVERFLOW((uint32_t) socket_data->last_outgoing, (uint32_t)(socket_data->last_outgoing + data_length), (uint32_t)(socket_data->expected + socket_data->treshold))){ - copy = tcp_prepare_copy(socket, socket_data, packet, data_length, socket_data->last_outgoing + 1); - if(! copy){ - return sending; - } - if(! sending){ - sending = copy; - }else{ - if(ERROR_OCCURRED(pq_insert_after(previous, copy))){ - pq_release_remote(tcp_globals.net_phone, packet_get_id(copy)); - return sending; - } - } - previous = copy; - packet = pq_next(packet); - // overflow occurred ? - if((! packet) && (socket_data->last_outgoing > socket_data->next_outgoing)){ - printf("gpts overflow\n"); - // continue from the beginning - packet = socket_data->outgoing; - } - socket_data->last_outgoing += data_length; - }else{ + if (!IS_IN_INTERVAL_OVERFLOW( + (uint32_t) socket_data->last_outgoing, + (uint32_t) (socket_data->last_outgoing + data_length), + (uint32_t) (socket_data->expected + socket_data->treshold))) break; - } - } + + copy = tcp_prepare_copy(socket, socket_data, packet, + data_length, socket_data->last_outgoing + 1); + if (!copy) + return sending; + + if (!sending) { + sending = copy; + } else if (ERROR_OCCURRED(pq_insert_after(previous, copy))) { + pq_release_remote(tcp_globals.net_phone, + packet_get_id(copy)); + return sending; + } + + previous = copy; + packet = pq_next(packet); + // overflow occurred ? + if ((!packet) && + (socket_data->last_outgoing > socket_data->next_outgoing)) { + printf("gpts overflow\n"); + // continue from the beginning + packet = socket_data->outgoing; + } + socket_data->last_outgoing += data_length; + } + return sending; } -packet_t tcp_send_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number){ +packet_t +tcp_send_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, + packet_t packet, size_t data_length, size_t sequence_number) +{ ERROR_DECLARE; @@ -1599,5 +1902,7 @@ // adjust the pseudo header - if(ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(socket_data->pseudo_header, socket_data->headerlen, packet_get_data_length(packet)))){ + if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length( + socket_data->pseudo_header, socket_data->headerlen, + packet_get_data_length(packet)))) { pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); return NULL; @@ -1606,5 +1911,5 @@ // get the header header = (tcp_header_ref) packet_get_data(packet); - if(! header){ + if (!header) { pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); return NULL; @@ -1613,6 +1918,7 @@ // adjust the header - if(socket_data->next_incoming){ - header->acknowledgement_number = htonl(socket_data->next_incoming); + if (socket_data->next_incoming) { + header->acknowledgement_number = + htonl(socket_data->next_incoming); header->acknowledge = 1; } @@ -1621,18 +1927,26 @@ // checksum header->checksum = 0; - checksum = compute_checksum(0, socket_data->pseudo_header, socket_data->headerlen); - checksum = compute_checksum(checksum, (uint8_t *) packet_get_data(packet), packet_get_data_length(packet)); + checksum = compute_checksum(0, socket_data->pseudo_header, + socket_data->headerlen); + checksum = compute_checksum(checksum, (uint8_t *) packet_get_data(packet), + packet_get_data_length(packet)); header->checksum = htons(flip_checksum(compact_checksum(checksum))); + // prepare the packet - if(ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0)) - // prepare the timeout - || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data, sequence_number, socket_data->state, socket_data->timeout, true))){ + if (ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, + 0, 0)) || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, + socket_data, sequence_number, socket_data->state, + socket_data->timeout, true))) { pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); return NULL; } + return packet; } -packet_t tcp_prepare_copy(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number){ +packet_t +tcp_prepare_copy(socket_core_ref socket, tcp_socket_data_ref socket_data, + packet_t packet, size_t data_length, size_t sequence_number) +{ packet_t copy; @@ -1643,22 +1957,28 @@ // make a copy of the packet copy = packet_get_copy(tcp_globals.net_phone, packet); - if(! copy){ + if (!copy) return NULL; - } - - return tcp_send_prepare_packet(socket, socket_data, copy, data_length, sequence_number); -} - -void tcp_send_packets(device_id_t device_id, packet_t packet){ + + return tcp_send_prepare_packet(socket, socket_data, copy, data_length, + sequence_number); +} + +void tcp_send_packets(device_id_t device_id, packet_t packet) +{ packet_t next; - while(packet){ + while (packet) { next = pq_detach(packet); - ip_send_msg(tcp_globals.ip_phone, device_id, packet, SERVICE_TCP, 0); + ip_send_msg(tcp_globals.ip_phone, device_id, packet, + SERVICE_TCP, 0); packet = next; } } -void tcp_prepare_operation_header(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize){ +void +tcp_prepare_operation_header(socket_core_ref socket, + tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, + int finalize) +{ assert(socket); assert(socket_data); @@ -1674,5 +1994,10 @@ } -int tcp_prepare_timeout(int (*timeout_function)(void * tcp_timeout_t), socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout, int globals_read_only){ +int +tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t), + socket_core_ref socket, tcp_socket_data_ref socket_data, + size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout, + int globals_read_only) +{ tcp_timeout_ref operation_timeout; fid_t fibril; @@ -1683,8 +2008,9 @@ // prepare the timeout with key bundle structure - operation_timeout = malloc(sizeof(*operation_timeout) + socket->key_length + 1); - if(! operation_timeout){ + operation_timeout = malloc(sizeof(*operation_timeout) + + socket->key_length + 1); + if (!operation_timeout) return ENOMEM; - } + bzero(operation_timeout, sizeof(*operation_timeout)); operation_timeout->globals_read_only = globals_read_only; @@ -1697,5 +2023,6 @@ // copy the key - operation_timeout->key = ((char *) operation_timeout) + sizeof(*operation_timeout); + operation_timeout->key = ((char *) operation_timeout) + + sizeof(*operation_timeout); operation_timeout->key_length = socket->key_length; memcpy(operation_timeout->key, socket->key, socket->key_length); @@ -1704,9 +2031,9 @@ // prepare the timeouting thread fibril = fibril_create(timeout_function, operation_timeout); - if(! fibril){ + if (!fibril) { free(operation_timeout); return EPARTY; } -// fibril_mutex_lock(&socket_data->operation.mutex); +// fibril_mutex_lock(&socket_data->operation.mutex); // start the timeouting fibril fibril_add_ready(fibril); @@ -1715,5 +2042,8 @@ } -int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen){ +int +tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags, + size_t * addrlen) +{ ERROR_DECLARE; @@ -1728,21 +2058,22 @@ // find the socket socket = socket_cores_find(local_sockets, socket_id); - if(! socket){ + if (!socket) return ENOTSOCK; - } + // get the socket specific data - if(! socket->specific_data){ + if (!socket->specific_data) return NO_DATA; - } + socket_data = (tcp_socket_data_ref) socket->specific_data; // check state - if((socket_data->state != TCP_SOCKET_ESTABLISHED) && (socket_data->state != TCP_SOCKET_CLOSE_WAIT)){ + if ((socket_data->state != TCP_SOCKET_ESTABLISHED) && + (socket_data->state != TCP_SOCKET_CLOSE_WAIT)) return ENOTCONN; - } // send the source address if desired - if(addrlen){ - ERROR_PROPAGATE(data_reply(socket_data->addr, socket_data->addrlen)); + if (addrlen) { + ERROR_PROPAGATE(data_reply(socket_data->addr, + socket_data->addrlen)); *addrlen = socket_data->addrlen; } @@ -1750,8 +2081,9 @@ // get the next received packet packet_id = dyn_fifo_value(&socket->received); - if(packet_id < 0){ + if (packet_id < 0) return NO_DATA; - } - ERROR_PROPAGATE(packet_translate_remote(tcp_globals.net_phone, &packet, packet_id)); + + ERROR_PROPAGATE(packet_translate_remote(tcp_globals.net_phone, &packet, + packet_id)); // reply the packets @@ -1765,5 +2097,8 @@ } -int tcp_send_message(socket_cores_ref local_sockets, int socket_id, int fragments, size_t * data_fragment_size, int flags){ +int +tcp_send_message(socket_cores_ref local_sockets, int socket_id, int fragments, + size_t * data_fragment_size, int flags) +{ ERROR_DECLARE; @@ -1782,36 +2117,42 @@ // find the socket socket = socket_cores_find(local_sockets, socket_id); - if(! socket){ + if (!socket) return ENOTSOCK; - } + // get the socket specific data - if(! socket->specific_data){ + if (!socket->specific_data) return NO_DATA; - } + socket_data = (tcp_socket_data_ref) socket->specific_data; // check state - if((socket_data->state != TCP_SOCKET_ESTABLISHED) && (socket_data->state != TCP_SOCKET_CLOSE_WAIT)){ + if ((socket_data->state != TCP_SOCKET_ESTABLISHED) && + (socket_data->state != TCP_SOCKET_CLOSE_WAIT)) return ENOTCONN; - } - - ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, socket_data->device_id, &packet_dimension)); - - *data_fragment_size = ((packet_dimension->content < socket_data->data_fragment_size) ? packet_dimension->content : socket_data->data_fragment_size); - - for(index = 0; index < fragments; ++ index){ + + ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone, + &tcp_globals.dimensions, socket_data->device_id, &packet_dimension)); + + *data_fragment_size = + ((packet_dimension->content < socket_data->data_fragment_size) ? + packet_dimension->content : socket_data->data_fragment_size); + + for (index = 0; index < fragments; ++index) { // read the data fragment - result = tl_socket_read_packet_data(tcp_globals.net_phone, &packet, TCP_HEADER_SIZE, packet_dimension, socket_data->addr, socket_data->addrlen); - if(result < 0){ + result = tl_socket_read_packet_data(tcp_globals.net_phone, + &packet, TCP_HEADER_SIZE, packet_dimension, + socket_data->addr, socket_data->addrlen); + if (result < 0) return result; - } + total_length = (size_t) result; // prefix the tcp header header = PACKET_PREFIX(packet, tcp_header_t); - if(! header){ + if (!header) return tcp_release_and_return(packet, ENOMEM); - } + tcp_prepare_operation_header(socket, socket_data, header, 0, 0); - ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 0)); + ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, + 0)); } @@ -1820,5 +2161,6 @@ fibril_rwlock_write_unlock(socket_data->local_lock); fibril_rwlock_read_unlock(&tcp_globals.lock); - if(packet){ + + if (packet) { // send the packet tcp_send_packets(socket_data->device_id, packet); @@ -1828,5 +2170,7 @@ } -int tcp_close_message(socket_cores_ref local_sockets, int socket_id){ +int +tcp_close_message(socket_cores_ref local_sockets, int socket_id) +{ ERROR_DECLARE; @@ -1837,7 +2181,7 @@ // find the socket socket = socket_cores_find(local_sockets, socket_id); - if(! socket){ + if (!socket) return ENOTSOCK; - } + // get the socket specific data socket_data = (tcp_socket_data_ref) socket->specific_data; @@ -1845,25 +2189,32 @@ // check state - switch(socket_data->state){ - case TCP_SOCKET_ESTABLISHED: - socket_data->state = TCP_SOCKET_FIN_WAIT_1; - break; - case TCP_SOCKET_CLOSE_WAIT: - socket_data->state = TCP_SOCKET_LAST_ACK; - break; -// case TCP_SOCKET_LISTEN: - default: - // just destroy - if(! ERROR_OCCURRED(socket_destroy(tcp_globals.net_phone, socket_id, local_sockets, &tcp_globals.sockets, tcp_free_socket_data))){ - fibril_rwlock_write_unlock(socket_data->local_lock); - fibril_rwlock_write_unlock(&tcp_globals.lock); - } - return ERROR_CODE; - } + switch (socket_data->state) { + case TCP_SOCKET_ESTABLISHED: + socket_data->state = TCP_SOCKET_FIN_WAIT_1; + break; + + case TCP_SOCKET_CLOSE_WAIT: + socket_data->state = TCP_SOCKET_LAST_ACK; + break; + +// case TCP_SOCKET_LISTEN: + + default: + // just destroy + if (ERROR_NONE(socket_destroy(tcp_globals.net_phone, socket_id, + local_sockets, &tcp_globals.sockets, + tcp_free_socket_data))) { + fibril_rwlock_write_unlock(socket_data->local_lock); + fibril_rwlock_write_unlock(&tcp_globals.lock); + } + return ERROR_CODE; + } + // send FIN // TODO should I wait to complete? // create the notification packet - ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, socket_data, 0, 1)); + ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, + socket_data, 0, 1)); // send the packet @@ -1874,12 +2225,17 @@ fibril_rwlock_write_unlock(socket_data->local_lock); fibril_rwlock_write_unlock(&tcp_globals.lock); - if(packet){ + + if (packet) { // send the packet tcp_send_packets(socket_data->device_id, packet); } + return EOK; } -int tcp_create_notification_packet(packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize){ +int +tcp_create_notification_packet(packet_t * packet, socket_core_ref socket, + tcp_socket_data_ref socket_data, int synchronize, int finalize) +{ ERROR_DECLARE; @@ -1890,21 +2246,31 @@ // get the device packet dimension - ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, socket_data->device_id, &packet_dimension)); + ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone, + &tcp_globals.dimensions, socket_data->device_id, + &packet_dimension)); + // get a new packet - *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE, packet_dimension->addr_len, packet_dimension->prefix, packet_dimension->suffix); - if(! * packet){ + *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE, + packet_dimension->addr_len, packet_dimension->prefix, + packet_dimension->suffix); + + if (!*packet) return ENOMEM; - } + // allocate space in the packet header = PACKET_SUFFIX(*packet, tcp_header_t); - if(! header){ + if (!header) tcp_release_and_return(*packet, ENOMEM); - } - - tcp_prepare_operation_header(socket, socket_data, header, synchronize, finalize); + + tcp_prepare_operation_header(socket, socket_data, header, synchronize, + finalize); + return EOK; } -int tcp_accept_message(socket_cores_ref local_sockets, int socket_id, int new_socket_id, size_t * data_fragment_size, size_t * addrlen){ +int +tcp_accept_message(socket_cores_ref local_sockets, int socket_id, + int new_socket_id, size_t * data_fragment_size, size_t * addrlen) +{ ERROR_DECLARE; @@ -1920,7 +2286,7 @@ // find the socket socket = socket_cores_find(local_sockets, socket_id); - if(! socket){ + if (!socket) return ENOTSOCK; - } + // get the socket specific data socket_data = (tcp_socket_data_ref) socket->specific_data; @@ -1928,40 +2294,52 @@ // check state - if(socket_data->state != TCP_SOCKET_LISTEN){ + if (socket_data->state != TCP_SOCKET_LISTEN) return EINVAL; - } - - do{ + + do { socket_id = dyn_fifo_value(&socket->accepted); - if(socket_id < 0){ + if (socket_id < 0) return ENOTSOCK; - } socket_id *= -1; accepted = socket_cores_find(local_sockets, socket_id); - if(! accepted){ + if (!accepted) return ENOTSOCK; - } + // get the socket specific data socket_data = (tcp_socket_data_ref) accepted->specific_data; assert(socket_data); // TODO can it be in another state? - if(socket_data->state == TCP_SOCKET_ESTABLISHED){ - ERROR_PROPAGATE(data_reply(socket_data->addr, socket_data->addrlen)); - ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, socket_data->device_id, &packet_dimension)); + if (socket_data->state == TCP_SOCKET_ESTABLISHED) { + ERROR_PROPAGATE(data_reply(socket_data->addr, + socket_data->addrlen)); + ERROR_PROPAGATE(tl_get_ip_packet_dimension( + tcp_globals.ip_phone, &tcp_globals.dimensions, + socket_data->device_id, &packet_dimension)); *addrlen = socket_data->addrlen; - *data_fragment_size = ((packet_dimension->content < socket_data->data_fragment_size) ? packet_dimension->content : socket_data->data_fragment_size); - if(new_socket_id > 0){ - ERROR_PROPAGATE(socket_cores_update(local_sockets, accepted->socket_id, new_socket_id)); + + *data_fragment_size = + ((packet_dimension->content < + socket_data->data_fragment_size) ? + packet_dimension->content : + socket_data->data_fragment_size); + + if (new_socket_id > 0) { + ERROR_PROPAGATE(socket_cores_update( + local_sockets, accepted->socket_id, + new_socket_id)); accepted->socket_id = new_socket_id; } } dyn_fifo_pop(&socket->accepted); - }while(socket_data->state != TCP_SOCKET_ESTABLISHED); + } while (socket_data->state != TCP_SOCKET_ESTABLISHED); + printf("ret accept %d\n", accepted->socket_id); return accepted->socket_id; } -void tcp_free_socket_data(socket_core_ref socket){ +void +tcp_free_socket_data(socket_core_ref socket) +{ tcp_socket_data_ref socket_data; @@ -1974,6 +2352,6 @@ assert(socket_data); //free the pseudo header - if(socket_data->pseudo_header){ - if(socket_data->headerlen){ + if (socket_data->pseudo_header) { + if (socket_data->headerlen) { printf("d pseudo\n"); free(socket_data->pseudo_header); @@ -1984,6 +2362,6 @@ socket_data->headerlen = 0; // free the address - if(socket_data->addr){ - if(socket_data->addrlen){ + if (socket_data->addr) { + if (socket_data->addrlen) { printf("d addr\n"); free(socket_data->addr); @@ -1995,5 +2373,6 @@ } -int tcp_release_and_return(packet_t packet, int result){ +int tcp_release_and_return(packet_t packet, int result) +{ pq_release_remote(tcp_globals.net_phone, packet_get_id(packet)); return result; @@ -2013,25 +2392,36 @@ */ ipc_answer_0(iid, EOK); - - while(true) { + + while (true) { ipc_call_t answer; int answer_count; - - /* Clear the answer structure */ + + /* + Clear the answer structure + */ refresh_answer(&answer, &answer_count); - - /* Fetch the next message */ + + /* + Fetch the next message + */ ipc_call_t call; ipc_callid_t callid = async_get_call(&call); - - /* Process the message */ + + /* + Process the message + */ int res = tl_module_message_standalone(callid, &call, &answer, &answer_count); - - /* End if said to either by the message or the processing result */ - if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP)) + + /* + End if said to either by the message or the processing result + */ + if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || + (res == EHANGUP)) return; - - /* Answer the message */ + + /* + Answer the message + */ answer_call(callid, res, &answer, answer_count); } @@ -2047,12 +2437,15 @@ * */ -int main(int argc, char *argv[]) +int +main(int argc, char *argv[]) { ERROR_DECLARE; - - /* Start the module */ + + /* + Start the module + */ if (ERROR_OCCURRED(tl_module_start_standalone(tl_client_connection))) return ERROR_CODE; - + return EOK; }