Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rdb81577 rb243da3  
    9191static void tcp_sock_notify_data(socket_core_t *sock_core)
    9292{
    93         log_msg(LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id);
     93        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_data(%d)", sock_core->socket_id);
    9494        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    9595        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
    … …  
    100100static void tcp_sock_notify_aconn(socket_core_t *lsock_core)
    101101{
    102         log_msg(LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id);
     102        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_notify_aconn(%d)", lsock_core->socket_id);
    103103        async_exch_t *exch = async_exchange_begin(lsock_core->sess);
    104104        async_msg_5(exch, NET_SOCKET_ACCEPTED, (sysarg_t)lsock_core->socket_id,
    … …  
    111111        tcp_sockdata_t *sock;
    112112
    113         log_msg(LVL_DEBUG, "tcp_sock_create()");
     113        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_create()");
    114114        *rsock = NULL;
    115115
    … …  
    133133static void tcp_sock_uncreate(tcp_sockdata_t *sock)
    134134{
    135         log_msg(LVL_DEBUG, "tcp_sock_uncreate()");
     135        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_uncreate()");
    136136        free(sock);
    137137}
    … …  
    142142        int rc;
    143143
    144         log_msg(LVL_DEBUG, "tcp_sock_finish_setup()");
     144        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_finish_setup()");
    145145
    146146        sock->recv_fibril = fibril_create(tcp_sock_recv_fibril, sock);
    … …  
    171171        ipc_call_t answer;
    172172
    173         log_msg(LVL_DEBUG, "tcp_sock_socket()");
     173        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_socket()");
    174174
    175175        rc = tcp_sock_create(client, &sock);
    … …  
    179179        }
    180180
    181         sock->laddr.ipv4 = TCP_IPV4_ANY;
     181        inet_addr_any(&sock->laddr);
    182182        sock->lconn = NULL;
    183183        sock->backlog = 0;
    … …  
    203203{
    204204        int rc;
    205         struct sockaddr *addr;
    206         size_t addr_len;
     205        struct sockaddr_in *addr;
     206        size_t addr_size;
    207207        socket_core_t *sock_core;
    208208        tcp_sockdata_t *socket;
    209 
    210         log_msg(LVL_DEBUG, "tcp_sock_bind()");
    211         log_msg(LVL_DEBUG, " - async_data_write_accept");
    212         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
     209       
     210        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_bind()");
     211        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
     212       
     213        addr = NULL;
     214       
     215        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
    213216        if (rc != EOK) {
    214217                async_answer_0(callid, rc);
    215                 return;
    216         }
    217 
    218         log_msg(LVL_DEBUG, " - call socket_bind");
     218                goto out;
     219        }
     220       
     221        if (addr_size != sizeof(struct sockaddr_in)) {
     222                async_answer_0(callid, EINVAL);
     223                goto out;
     224        }
     225       
     226        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    219227        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    220             addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     228            addr, addr_size, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    221229            last_used_port);
    222230        if (rc != EOK) {
    223231                async_answer_0(callid, rc);
    224                 return;
    225         }
    226 
    227         log_msg(LVL_DEBUG, " - call socket_cores_find");
     232                goto out;
     233        }
     234       
     235        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    228236        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
    229         if (sock_core != NULL) {
    230                 socket = (tcp_sockdata_t *)sock_core->specific_data;
    231                 /* XXX Anything to do? */
    232                 (void) socket;
    233         }
    234 
    235         log_msg(LVL_DEBUG, " - success");
     237        if (sock_core == NULL) {
     238                async_answer_0(callid, ENOENT);
     239                goto out;
     240        }
     241       
     242        socket = (tcp_sockdata_t *)sock_core->specific_data;
     243        /* XXX Anything to do? */
     244        (void) socket;
     245       
     246        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    236247        async_answer_0(callid, EOK);
     248       
     249out:
     250        if (addr != NULL)
     251                free(addr);
    237252}
    238253
    … …  
    249264        tcp_sock_lconn_t *lconn;
    250265        int i;
    251 
    252         log_msg(LVL_DEBUG, "tcp_sock_listen()");
     266        int rc;
     267
     268        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_listen()");
    253269
    254270        socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    268284                return;
    269285        }
    270 
    271         socket = (tcp_sockdata_t *)sock_core->specific_data;
    272 
     286       
     287        if (sock_core->port <= 0) {
     288                rc = socket_bind_free_port(&gsock, sock_core,
     289                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     290                    last_used_port);
     291                if (rc != EOK) {
     292                        async_answer_0(callid, rc);
     293                        return;
     294                }
     295               
     296                last_used_port = sock_core->port;
     297        }
     298       
     299        socket = (tcp_sockdata_t *) sock_core->specific_data;
     300       
    273301        /*
    274302         * Prepare @c backlog listening connections.
    275303         */
    276304        fibril_mutex_lock(&socket->lock);
    277 
     305       
    278306        socket->backlog = backlog;
    279307        socket->lconn = calloc(backlog, sizeof(tcp_conn_t *));
    … …  
    283311                return;
    284312        }
    285 
    286         log_msg(LVL_DEBUG, " - open connections");
    287 
    288         lsocket.addr.ipv4 = TCP_IPV4_ANY;
     313       
     314        log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
     315       
     316        inet_addr_any(&lsocket.addr);
    289317        lsocket.port = sock_core->port;
    290         fsocket.addr.ipv4 = TCP_IPV4_ANY;
     318       
     319        inet_addr_any(&fsocket.addr);
    291320        fsocket.port = TCP_PORT_ANY;
    292 
     321       
    293322        for (i = 0; i < backlog; i++) {
    294323
    … …  
    325354}
    326355
    327 static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    328 {
    329         int rc;
    330         struct sockaddr_in *addr;
    331         int socket_id;
     356static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid,
     357    ipc_call_t call)
     358{
     359        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()");
     360       
     361        struct sockaddr_in6 *addr6 = NULL;
    332362        size_t addr_len;
    333         socket_core_t *sock_core;
    334         tcp_sockdata_t *socket;
    335         tcp_error_t trc;
    336         tcp_sock_t lsocket;
    337         tcp_sock_t fsocket;
    338 
    339         log_msg(LVL_DEBUG, "tcp_sock_connect()");
    340 
    341         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
    342         if (rc != EOK || addr_len != sizeof(struct sockaddr_in)) {
     363        int rc = async_data_write_accept((void **) &addr6, false, 0, 0, 0, &addr_len);
     364        if (rc != EOK) {
    343365                async_answer_0(callid, rc);
    344366                return;
    345367        }
    346 
    347         socket_id = SOCKET_GET_SOCKET_ID(call);
    348 
    349         sock_core = socket_cores_find(&client->sockets, socket_id);
     368       
     369        if ((addr_len != sizeof(struct sockaddr_in)) &&
     370            (addr_len != sizeof(struct sockaddr_in6))) {
     371                async_answer_0(callid, EINVAL);
     372                goto out;
     373        }
     374       
     375        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
     376       
     377        int socket_id = SOCKET_GET_SOCKET_ID(call);
     378        socket_core_t *sock_core = socket_cores_find(&client->sockets,
     379            socket_id);
    350380        if (sock_core == NULL) {
    351381                async_answer_0(callid, ENOTSOCK);
    352                 return;
    353         }
    354 
    355         socket = (tcp_sockdata_t *)sock_core->specific_data;
     382                goto out;
     383        }
     384       
     385        tcp_sockdata_t *socket =
     386            (tcp_sockdata_t *) sock_core->specific_data;
     387       
    356388        if (sock_core->port <= 0) {
    357389                rc = socket_bind_free_port(&gsock, sock_core,
    … …  
    360392                if (rc != EOK) {
    361393                        async_answer_0(callid, rc);
    362                         return;
    363                 }
    364 
     394                        goto out;
     395                }
     396               
    365397                last_used_port = sock_core->port;
    366398        }
    367 
     399       
    368400        fibril_mutex_lock(&socket->lock);
    369 
    370         if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
     401       
     402        if (inet_addr_is_any(&socket->laddr)) {
    371403                /* Determine local IP address */
    372                 inet_addr_t loc_addr, rem_addr;
    373 
    374                 rem_addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     404                inet_addr_t loc_addr;
     405                inet_addr_t rem_addr;
     406               
     407                switch (addr->sin_family) {
     408                case AF_INET:
     409                        inet_sockaddr_in_addr(addr, &rem_addr);
     410                        break;
     411                case AF_INET6:
     412                        inet_sockaddr_in6_addr(addr6, &rem_addr);
     413                        break;
     414                default:
     415                        fibril_mutex_unlock(&socket->lock);
     416                        async_answer_0(callid, EINVAL);
     417                        goto out;
     418                }
     419               
    375420                rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    376421                if (rc != EOK) {
    377422                        fibril_mutex_unlock(&socket->lock);
    378423                        async_answer_0(callid, rc);
    379                         log_msg(LVL_DEBUG, "tcp_sock_connect: Failed to "
     424                        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect: Failed to "
    380425                            "determine local address.");
    381                         return;
    382                 }
    383 
    384                 socket->laddr.ipv4 = loc_addr.ipv4;
    385                 log_msg(LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
    386         }
    387 
    388         lsocket.addr.ipv4 = socket->laddr.ipv4;
     426                        goto out;
     427                }
     428               
     429                socket->laddr = loc_addr;
     430        }
     431       
     432        tcp_sock_t lsocket;
     433        tcp_sock_t fsocket;
     434       
     435        lsocket.addr = socket->laddr;
    389436        lsocket.port = sock_core->port;
    390         fsocket.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     437       
     438        switch (addr->sin_family) {
     439        case AF_INET:
     440                inet_sockaddr_in_addr(addr, &fsocket.addr);
     441                break;
     442        case AF_INET6:
     443                inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     444                break;
     445        default:
     446                fibril_mutex_unlock(&socket->lock);
     447                async_answer_0(callid, EINVAL);
     448                goto out;
     449        }
     450       
    391451        fsocket.port = uint16_t_be2host(addr->sin_port);
    392 
    393         trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
    394 
     452       
     453        tcp_error_t trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0,
     454            &socket->conn);
     455       
    395456        if (socket->conn != NULL)
    396                 socket->conn->name = (char *)"C";
    397 
     457                socket->conn->name = (char *) "C";
     458       
    398459        fibril_mutex_unlock(&socket->lock);
    399 
     460       
    400461        switch (trc) {
    401462        case TCP_EOK:
    … …  
    408469                assert(false);
    409470        }
    410 
     471       
    411472        if (rc == EOK)
    412473                fibril_add_ready(socket->recv_fibril);
    413 
     474       
    414475        async_answer_0(callid, rc);
     476       
     477out:
     478        if (addr6 != NULL)
     479                free(addr6);
    415480}
    416481
    … …  
    431496        int rc;
    432497
    433         log_msg(LVL_DEBUG, "tcp_sock_accept()");
     498        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept()");
    434499
    435500        socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    441506                return;
    442507        }
     508       
     509        if (sock_core->port <= 0) {
     510                rc = socket_bind_free_port(&gsock, sock_core,
     511                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     512                    last_used_port);
     513                if (rc != EOK) {
     514                        async_answer_0(callid, rc);
     515                        return;
     516                }
     517               
     518                last_used_port = sock_core->port;
     519        }
    443520
    444521        socket = (tcp_sockdata_t *)sock_core->specific_data;
    445522        fibril_mutex_lock(&socket->lock);
    446523
    447         log_msg(LVL_DEBUG, " - verify socket->conn");
     524        log_msg(LOG_DEFAULT, LVL_DEBUG, " - verify socket->conn");
    448525        if (socket->conn != NULL) {
    449526                fibril_mutex_unlock(&socket->lock);
    … …  
    467544        /* Replenish listening connection */
    468545
    469         lsocket.addr.ipv4 = TCP_IPV4_ANY;
     546        inet_addr_any(&lsocket.addr);
    470547        lsocket.port = sock_core->port;
    471         fsocket.addr.ipv4 = TCP_IPV4_ANY;
     548       
     549        inet_addr_any(&fsocket.addr);
    472550        fsocket.port = TCP_PORT_ANY;
    473551
    … …  
    498576
    499577        asocket->conn = conn;
    500         log_msg(LVL_DEBUG, "tcp_sock_accept():create asocket\n");
     578        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept():create asocket\n");
    501579
    502580        rc = tcp_sock_finish_setup(asocket, &asock_id);
    … …  
    510588        fibril_add_ready(asocket->recv_fibril);
    511589
    512         log_msg(LVL_DEBUG, "tcp_sock_accept(): find acore\n");
     590        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): find acore\n");
    513591
    514592        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, TCP_SOCK_FRAGMENT_SIZE);
    … …  
    521599       
    522600        /* Push one fragment notification to client's queue */
    523         log_msg(LVL_DEBUG, "tcp_sock_accept(): notify data\n");
     601        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_accept(): notify data\n");
    524602        fibril_mutex_unlock(&socket->lock);
    525603}
    … …  
    535613        ipc_callid_t wcallid;
    536614        size_t length;
    537         uint8_t buffer[TCP_SOCK_FRAGMENT_SIZE];
    538615        tcp_error_t trc;
    539616        int rc;
    540 
    541         log_msg(LVL_DEBUG, "tcp_sock_send()");
     617       
     618        uint8_t *buffer = calloc(TCP_SOCK_FRAGMENT_SIZE, 1);
     619        if (buffer == NULL) {
     620                async_answer_0(callid, ENOMEM);
     621                return;
     622        }
     623
     624        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_send()");
    542625        socket_id = SOCKET_GET_SOCKET_ID(call);
    543626        fragments = SOCKET_GET_DATA_FRAGMENTS(call);
    … …  
    547630        if (sock_core == NULL) {
    548631                async_answer_0(callid, ENOTSOCK);
    549                 return;
     632                goto out;
    550633        }
    551634
    … …  
    563646                        fibril_mutex_unlock(&socket->lock);
    564647                        async_answer_0(callid, EINVAL);
    565                         return;
     648                        goto out;
    566649                }
    567650
    … …  
    573656                        fibril_mutex_unlock(&socket->lock);
    574657                        async_answer_0(callid, rc);
    575                         return;
     658                        goto out;
    576659                }
    577660
    … …  
    598681                        fibril_mutex_unlock(&socket->lock);
    599682                        async_answer_0(callid, rc);
    600                         return;
     683                        goto out;
    601684                }
    602685        }
    … …  
    607690            IPC_GET_ARG2(answer));
    608691        fibril_mutex_unlock(&socket->lock);
     692       
     693out:
     694        free(buffer);
    609695}
    610696
    611697static void tcp_sock_sendto(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    612698{
    613         log_msg(LVL_DEBUG, "tcp_sock_sendto()");
     699        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_sendto()");
    614700        async_answer_0(callid, ENOTSUP);
    615701}
    … …  
    617703static void tcp_sock_recvfrom(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    618704{
    619         int socket_id;
    620         int flags;
    621         size_t addr_length, length;
    622         socket_core_t *sock_core;
    623         tcp_sockdata_t *socket;
    624         ipc_call_t answer;
    625         ipc_callid_t rcallid;
    626         size_t data_len;
    627         struct sockaddr_in addr;
    628         tcp_sock_t *rsock;
    629         int rc;
    630 
    631         log_msg(LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
    632 
    633         socket_id = SOCKET_GET_SOCKET_ID(call);
    634         flags = SOCKET_GET_FLAGS(call);
    635 
    636         sock_core = socket_cores_find(&client->sockets, socket_id);
     705        log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
     706       
     707        int socket_id = SOCKET_GET_SOCKET_ID(call);
     708       
     709        socket_core_t *sock_core =
     710            socket_cores_find(&client->sockets, socket_id);
    637711        if (sock_core == NULL) {
    638712                async_answer_0(callid, ENOTSOCK);
    639713                return;
    640714        }
    641 
    642         socket = (tcp_sockdata_t *)sock_core->specific_data;
     715       
     716        tcp_sockdata_t *socket =
     717            (tcp_sockdata_t *) sock_core->specific_data;
     718       
    643719        fibril_mutex_lock(&socket->lock);
    644 
     720       
    645721        if (socket->conn == NULL) {
    646722                fibril_mutex_unlock(&socket->lock);
    … …  
    648724                return;
    649725        }
    650 
    651         (void)flags;
    652 
    653         log_msg(LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
     726       
     727        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
     728       
    654729        fibril_mutex_lock(&socket->recv_buffer_lock);
    655         while (socket->recv_buffer_used == 0 && socket->recv_error == TCP_EOK) {
    656                 log_msg(LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
     730        while ((socket->recv_buffer_used == 0) &&
     731            (socket->recv_error == TCP_EOK)) {
     732                log_msg(LOG_DEFAULT, LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
    657733                fibril_condvar_wait(&socket->recv_buffer_cv,
    658734                    &socket->recv_buffer_lock);
    659735        }
    660 
    661         log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
    662 
    663         data_len = socket->recv_buffer_used;
    664         rc = socket->recv_error;
    665 
    666         switch (socket->recv_error) {
     736       
     737        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
     738       
     739        size_t data_len = socket->recv_buffer_used;
     740        tcp_error_t trc = socket->recv_error;
     741        int rc;
     742       
     743        switch (trc) {
    667744        case TCP_EOK:
    668745                rc = EOK;
    … …  
    678755                assert(false);
    679756        }
    680 
    681         log_msg(LVL_DEBUG, "**** recv result -> %d", rc);
     757       
     758        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv result -> %d", rc);
     759       
    682760        if (rc != EOK) {
    683761                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    686764                return;
    687765        }
    688 
     766       
     767        ipc_callid_t rcallid;
     768       
    689769        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    690                 /* Fill addr */
    691                 rsock = &socket->conn->ident.foreign;
    692                 addr.sin_family = AF_INET;
    693                 addr.sin_addr.s_addr = host2uint32_t_be(rsock->addr.ipv4);
    694                 addr.sin_port = host2uint16_t_be(rsock->port);
    695 
    696                 log_msg(LVL_DEBUG, "addr read receive");
    697                 if (!async_data_read_receive(&rcallid, &addr_length)) {
     770                /* Fill address */
     771                tcp_sock_t *rsock = &socket->conn->ident.foreign;
     772                struct sockaddr_in addr;
     773                struct sockaddr_in6 addr6;
     774                size_t addr_length;
     775               
     776                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
     777                    &addr6);
     778               
     779                switch (addr_af) {
     780                case AF_INET:
     781                        addr.sin_port = host2uint16_t_be(rsock->port);
     782                       
     783                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
     784                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     785                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     786                                fibril_mutex_unlock(&socket->lock);
     787                                async_answer_0(callid, EINVAL);
     788                                return;
     789                        }
     790                       
     791                        if (addr_length > sizeof(addr))
     792                                addr_length = sizeof(addr);
     793                       
     794                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
     795                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
     796                        if (rc != EOK) {
     797                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     798                                fibril_mutex_unlock(&socket->lock);
     799                                async_answer_0(callid, EINVAL);
     800                                return;
     801                        }
     802                       
     803                        break;
     804                case AF_INET6:
     805                        addr6.sin6_port = host2uint16_t_be(rsock->port);
     806                       
     807                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
     808                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     809                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     810                                fibril_mutex_unlock(&socket->lock);
     811                                async_answer_0(callid, EINVAL);
     812                                return;
     813                        }
     814                       
     815                        if (addr_length > sizeof(addr6))
     816                                addr_length = sizeof(addr6);
     817                       
     818                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
     819                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
     820                        if (rc != EOK) {
     821                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     822                                fibril_mutex_unlock(&socket->lock);
     823                                async_answer_0(callid, EINVAL);
     824                                return;
     825                        }
     826                       
     827                        break;
     828                default:
    698829                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    699830                        fibril_mutex_unlock(&socket->lock);
    … …  
    701832                        return;
    702833                }
    703 
    704                 if (addr_length > sizeof(addr))
    705                         addr_length = sizeof(addr);
    706 
    707                 log_msg(LVL_DEBUG, "addr read finalize");
    708                 rc = async_data_read_finalize(rcallid, &addr, addr_length);
    709                 if (rc != EOK) {
    710                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    711                         fibril_mutex_unlock(&socket->lock);
    712                         async_answer_0(callid, EINVAL);
    713                         return;
    714                 }
    715         }
    716 
    717         log_msg(LVL_DEBUG, "data read receive");
     834        }
     835       
     836        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
     837       
     838        size_t length;
    718839        if (!async_data_read_receive(&rcallid, &length)) {
    719840                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    722843                return;
    723844        }
    724 
     845       
    725846        if (length > data_len)
    726847                length = data_len;
    727 
    728         log_msg(LVL_DEBUG, "data read finalize");
     848       
     849        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
     850       
    729851        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    730 
     852       
    731853        socket->recv_buffer_used -= length;
    732         log_msg(LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
     854       
     855        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
    733856            socket->recv_buffer_used);
     857       
    734858        if (socket->recv_buffer_used > 0) {
    735859                memmove(socket->recv_buffer, socket->recv_buffer + length,
    … …  
    737861                tcp_sock_notify_data(socket->sock_core);
    738862        }
    739 
     863       
    740864        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    741 
    742         if (length < data_len && rc == EOK)
     865       
     866        if ((length < data_len) && (rc == EOK))
    743867                rc = EOVERFLOW;
    744 
     868       
     869        ipc_call_t answer;
     870       
    745871        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    746872        async_answer_1(callid, EOK, IPC_GET_ARG1(answer));
    747 
     873       
    748874        fibril_mutex_unlock(&socket->recv_buffer_lock);
    749875        fibril_mutex_unlock(&socket->lock);
    … …  
    756882        tcp_sockdata_t *socket;
    757883        tcp_error_t trc;
     884        int i;
    758885        int rc;
    759886
    760         log_msg(LVL_DEBUG, "tcp_sock_close()");
     887        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
    761888        socket_id = SOCKET_GET_SOCKET_ID(call);
    762889
    … …  
    771898
    772899        if (socket->conn != NULL) {
     900                /* Close connection */
    773901                trc = tcp_uc_close(socket->conn);
    774902                if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
    … …  
    779907        }
    780908
     909        if (socket->lconn != NULL) {
     910                /* Close listening connections */
     911                for (i = 0; i < socket->backlog; i++) {
     912                        tcp_uc_set_cstate_cb(socket->lconn[i]->conn, NULL, NULL);
     913                        trc = tcp_uc_close(socket->lconn[i]->conn);
     914                        if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
     915                                fibril_mutex_unlock(&socket->lock);
     916                                async_answer_0(callid, EBADF);
     917                                return;
     918                        }
     919
     920                        free(socket->lconn[i]);
     921                        socket->lconn[i] = NULL;
     922                }
     923        }
     924
    781925        /* Grab recv_buffer_lock because of CV wait in tcp_sock_recv_fibril() */
    782926        fibril_mutex_lock(&socket->recv_buffer_lock);
    … …  
    798942static void tcp_sock_getsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    799943{
    800         log_msg(LVL_DEBUG, "tcp_sock_getsockopt()");
     944        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_getsockopt()");
    801945        async_answer_0(callid, ENOTSUP);
    802946}
    … …  
    804948static void tcp_sock_setsockopt(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    805949{
    806         log_msg(LVL_DEBUG, "tcp_sock_setsockopt()");
     950        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_setsockopt()");
    807951        async_answer_0(callid, ENOTSUP);
    808952}
    … …  
    815959        tcp_sockdata_t *socket = lconn->socket;
    816960
    817         log_msg(LVL_DEBUG, "tcp_sock_cstate_cb()");
     961        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb()");
    818962        fibril_mutex_lock(&socket->lock);
    819963        assert(conn == lconn->conn);
    … …  
    828972        list_append(&lconn->ready_list, &socket->ready);
    829973
    830         log_msg(LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
     974        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_cstate_cb(): notify accept");
    831975
    832976        /* Push one accept notification to client's queue */
    … …  
    842986        tcp_error_t trc;
    843987
    844         log_msg(LVL_DEBUG, "tcp_sock_recv_fibril()");
     988        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recv_fibril()");
    845989
    846990        fibril_mutex_lock(&sock->recv_buffer_lock);
    847991
    848992        while (true) {
    849                 log_msg(LVL_DEBUG, "call tcp_uc_receive()");
     993                log_msg(LOG_DEFAULT, LVL_DEBUG, "call tcp_uc_receive()");
    850994                while (sock->recv_buffer_used != 0 && sock->sock_core != NULL)
    851995                        fibril_condvar_wait(&sock->recv_buffer_cv,
    … …  
    8631007                }
    8641008
    865                 log_msg(LVL_DEBUG, "got data - broadcast recv_buffer_cv");
     1009                log_msg(LOG_DEFAULT, LVL_DEBUG, "got data - broadcast recv_buffer_cv");
    8661010
    8671011                sock->recv_buffer_used = data_len;
    … …  
    8951039                        break;
    8961040
    897                 log_msg(LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n",
     1041                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: METHOD=%d\n",
    8981042                    (int)IPC_GET_IMETHOD(call));
    8991043
    … …  
    9401084
    9411085        /* Clean up */
    942         log_msg(LVL_DEBUG, "tcp_sock_connection: Clean up");
     1086        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connection: Clean up");
    9431087        async_hangup(client.sess);
    9441088        socket_cores_release(NULL, &client.sockets, &gsock, tcp_free_sock_data);
Note: See TracChangeset for help on using the changeset viewer.