Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rdb81577 r695b6ff  
    11/*
    22 * Copyright (c) 2008 Lukas Mejdrech
    3  * Copyright (c) 2012 Jiri Svoboda
     3 * Copyright (c) 2013 Jiri Svoboda
    44 * All rights reserved.
    55 *
    … …  
    8888static void udp_sock_notify_data(socket_core_t *sock_core)
    8989{
    90         log_msg(LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id);
     90        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id);
    9191        async_exch_t *exch = async_exchange_begin(sock_core->sess);
    92         async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
     92        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) sock_core->socket_id,
    9393            UDP_FRAGMENT_SIZE, 0, 0, 1);
    9494        async_exchange_end(exch);
    … …  
    103103        ipc_call_t answer;
    104104
    105         log_msg(LVL_DEBUG, "udp_sock_socket()");
     105        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_socket()");
    106106        sock = calloc(1, sizeof(udp_sockdata_t));
    107107        if (sock == NULL) {
    … …  
    159159static void udp_sock_bind(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    160160{
    161         int rc;
    162         struct sockaddr_in *addr;
    163         size_t addr_size;
    164         socket_core_t *sock_core;
    165         udp_sockdata_t *socket;
    166         udp_sock_t fsock;
    167         udp_error_t urc;
    168 
    169         log_msg(LVL_DEBUG, "udp_sock_bind()");
    170         log_msg(LVL_DEBUG, " - async_data_write_accept");
    171 
    172         addr = NULL;
    173 
    174         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
     161        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_bind()");
     162        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
     163       
     164        struct sockaddr_in6 *addr6 = NULL;
     165        size_t addr_len;
     166        int rc = async_data_write_accept((void **) &addr6, false, 0, 0, 0, &addr_len);
    175167        if (rc != EOK) {
    176168                async_answer_0(callid, rc);
     169                return;
     170        }
     171       
     172        if ((addr_len != sizeof(struct sockaddr_in)) &&
     173            (addr_len != sizeof(struct sockaddr_in6))) {
     174                async_answer_0(callid, EINVAL);
    177175                goto out;
    178176        }
    179 
    180         log_msg(LVL_DEBUG, " - call socket_bind");
     177       
     178        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
     179       
     180        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
     181       
    181182        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    182             addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
     183            addr6, addr_len, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
    183184            last_used_port);
    184185        if (rc != EOK) {
    … …  
    186187                goto out;
    187188        }
    188 
    189         if (addr_size != sizeof(struct sockaddr_in)) {
    190                 async_answer_0(callid, EINVAL);
    191                 goto out;
    192         }
    193 
    194         log_msg(LVL_DEBUG, " - call socket_cores_find");
    195         sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
     189       
     190        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
     191       
     192        socket_core_t *sock_core = socket_cores_find(&client->sockets,
     193            SOCKET_GET_SOCKET_ID(call));
    196194        if (sock_core == NULL) {
    197195                async_answer_0(callid, ENOENT);
    198196                goto out;
    199197        }
    200 
    201         socket = (udp_sockdata_t *)sock_core->specific_data;
    202 
    203         fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    204         fsock.port = sock_core->port;
    205         urc = udp_uc_set_local(socket->assoc, &fsock);
    206 
     198       
     199        udp_sockdata_t *socket =
     200            (udp_sockdata_t *) sock_core->specific_data;
     201       
     202        udp_sock_t fsocket;
     203       
     204        fsocket.port = sock_core->port;
     205       
     206        switch (addr->sin_family) {
     207        case AF_INET:
     208                inet_sockaddr_in_addr(addr, &fsocket.addr);
     209                break;
     210        case AF_INET6:
     211                inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     212                break;
     213        default:
     214                async_answer_0(callid, EINVAL);
     215                goto out;
     216        }
     217       
     218        udp_error_t urc = udp_uc_set_local(socket->assoc, &fsocket);
     219       
    207220        switch (urc) {
    208221        case UDP_EOK:
    … …  
    221234                assert(false);
    222235        }
    223 
    224         log_msg(LVL_DEBUG, " - success");
     236       
     237        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    225238        async_answer_0(callid, rc);
     239       
    226240out:
    227         if (addr != NULL)
    228                 free(addr);
     241        if (addr6 != NULL)
     242                free(addr6);
    229243}
    230244
    231245static void udp_sock_listen(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    232246{
    233         log_msg(LVL_DEBUG, "udp_sock_listen()");
     247        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_listen()");
    234248        async_answer_0(callid, ENOTSUP);
    235249}
    … …  
    237251static void udp_sock_connect(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    238252{
    239         log_msg(LVL_DEBUG, "udp_sock_connect()");
     253        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connect()");
    240254        async_answer_0(callid, ENOTSUP);
    241255}
    … …  
    243257static void udp_sock_accept(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    244258{
    245         log_msg(LVL_DEBUG, "udp_sock_accept()");
     259        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_accept()");
    246260        async_answer_0(callid, ENOTSUP);
    247261}
    … …  
    249263static void udp_sock_sendto(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    250264{
    251         int socket_id;
    252         int fragments;
    253         int index;
     265        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()");
     266       
     267        uint8_t *buffer = calloc(UDP_FRAGMENT_SIZE, 1);
     268        if (buffer == NULL) {
     269                async_answer_0(callid, ENOMEM);
     270                return;
     271        }
     272       
     273        struct sockaddr_in6 *addr6 = NULL;
    254274        struct sockaddr_in *addr;
    255         size_t addr_size;
    256         socket_core_t *sock_core;
    257         udp_sockdata_t *socket;
    258         udp_sock_t fsock, *fsockp;
    259         ipc_call_t answer;
    260         ipc_callid_t wcallid;
    261         size_t length;
    262         uint8_t buffer[UDP_FRAGMENT_SIZE];
    263         udp_error_t urc;
    264         int rc;
    265 
    266         log_msg(LVL_DEBUG, "udp_sock_send()");
    267 
    268         addr = NULL;
    269 
     275        udp_sock_t fsocket;
     276        udp_sock_t *fsocket_ptr;
     277       
    270278        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
    271                 rc = async_data_write_accept((void **) &addr, false,
    272                     0, 0, 0, &addr_size);
     279                size_t addr_len;
     280                int rc = async_data_write_accept((void **) &addr6, false,
     281                    0, 0, 0, &addr_len);
    273282                if (rc != EOK) {
    274283                        async_answer_0(callid, rc);
    275284                        goto out;
    276285                }
    277 
    278                 if (addr_size != sizeof(struct sockaddr_in)) {
     286               
     287                if ((addr_len != sizeof(struct sockaddr_in)) &&
     288                    (addr_len != sizeof(struct sockaddr_in6))) {
    279289                        async_answer_0(callid, EINVAL);
    280290                        goto out;
    281291                }
    282 
    283                 fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    284                 fsock.port = uint16_t_be2host(addr->sin_port);
    285                 fsockp = &fsock;
    286         } else {
    287                 fsockp = NULL;
    288         }
    289 
    290         socket_id = SOCKET_GET_SOCKET_ID(call);
    291         fragments = SOCKET_GET_DATA_FRAGMENTS(call);
     292               
     293                addr = (struct sockaddr_in *) addr6;
     294               
     295                switch (addr->sin_family) {
     296                case AF_INET:
     297                        inet_sockaddr_in_addr(addr, &fsocket.addr);
     298                        break;
     299                case AF_INET6:
     300                        inet_sockaddr_in6_addr(addr6, &fsocket.addr);
     301                        break;
     302                default:
     303                        async_answer_0(callid, EINVAL);
     304                        goto out;
     305                }
     306               
     307                fsocket.port = uint16_t_be2host(addr->sin_port);
     308                fsocket_ptr = &fsocket;
     309        } else
     310                fsocket_ptr = NULL;
     311       
     312        int socket_id = SOCKET_GET_SOCKET_ID(call);
     313       
    292314        SOCKET_GET_FLAGS(call);
    293 
    294         sock_core = socket_cores_find(&client->sockets, socket_id);
     315       
     316        socket_core_t *sock_core =
     317            socket_cores_find(&client->sockets, socket_id);
    295318        if (sock_core == NULL) {
    296319                async_answer_0(callid, ENOTSOCK);
    297320                goto out;
    298321        }
    299 
    300         if (sock_core->port == 0) {
     322       
     323        udp_sockdata_t *socket =
     324            (udp_sockdata_t *) sock_core->specific_data;
     325       
     326        if (sock_core->port <= 0) {
    301327                /* Implicitly bind socket to port */
    302                 rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    303                     addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
    304                     last_used_port);
     328                int rc = socket_bind_free_port(&gsock, sock_core,
     329                    UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, last_used_port);
    305330                if (rc != EOK) {
    306331                        async_answer_0(callid, rc);
    307332                        goto out;
    308333                }
    309         }
    310 
    311         socket = (udp_sockdata_t *)sock_core->specific_data;
     334               
     335                assert(sock_core->port > 0);
     336               
     337                udp_error_t urc = udp_uc_set_local_port(socket->assoc,
     338                    sock_core->port);
     339               
     340                if (urc != UDP_EOK) {
     341                        // TODO: better error handling
     342                        async_answer_0(callid, EINTR);
     343                        goto out;
     344                }
     345               
     346                last_used_port = sock_core->port;
     347        }
     348       
    312349        fibril_mutex_lock(&socket->lock);
    313 
    314         if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
     350       
     351        if (inet_addr_is_any(&socket->assoc->ident.local.addr) &&
     352                socket->assoc->ident.iplink == 0) {
    315353                /* Determine local IP address */
    316                 inet_addr_t loc_addr, rem_addr;
    317 
    318                 rem_addr.ipv4 = fsockp ? fsock.addr.ipv4 :
    319                     socket->assoc->ident.foreign.addr.ipv4;
    320 
    321                 rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
     354                inet_addr_t loc_addr;
     355                inet_addr_t rem_addr;
     356               
     357                rem_addr = fsocket_ptr ? fsocket.addr :
     358                    socket->assoc->ident.foreign.addr;
     359               
     360                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    322361                if (rc != EOK) {
    323362                        fibril_mutex_unlock(&socket->lock);
    324363                        async_answer_0(callid, rc);
    325                         log_msg(LVL_DEBUG, "udp_sock_sendto: Failed to "
     364                        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_sendto: Failed to "
    326365                            "determine local address.");
    327                         return;
    328                 }
    329 
    330                 socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
    331                 log_msg(LVL_DEBUG, "Local IP address is %x",
    332                     socket->assoc->ident.local.addr.ipv4);
    333         }
    334 
    335 
     366                        goto out;
     367                }
     368               
     369                socket->assoc->ident.local.addr = loc_addr;
     370        }
     371       
    336372        assert(socket->assoc != NULL);
    337 
    338         for (index = 0; index < fragments; index++) {
     373       
     374        int fragments = SOCKET_GET_DATA_FRAGMENTS(call);
     375        for (int index = 0; index < fragments; index++) {
     376                ipc_callid_t wcallid;
     377                size_t length;
     378               
    339379                if (!async_data_write_receive(&wcallid, &length)) {
    340380                        fibril_mutex_unlock(&socket->lock);
    … …  
    342382                        goto out;
    343383                }
    344 
     384               
    345385                if (length > UDP_FRAGMENT_SIZE)
    346386                        length = UDP_FRAGMENT_SIZE;
    347 
    348                 rc = async_data_write_finalize(wcallid, buffer, length);
     387               
     388                int rc = async_data_write_finalize(wcallid, buffer, length);
    349389                if (rc != EOK) {
    350390                        fibril_mutex_unlock(&socket->lock);
    … …  
    352392                        goto out;
    353393                }
    354 
    355                 urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
    356 
     394               
     395                udp_error_t urc =
     396                    udp_uc_send(socket->assoc, fsocket_ptr, buffer, length, 0);
     397               
    357398                switch (urc) {
    358399                case UDP_EOK:
    359400                        rc = EOK;
    360401                        break;
    361 /*              case TCP_ENOTEXIST:
    362                         rc = ENOTCONN;
    363                         break;
    364                 case TCP_ECLOSING:
    365                         rc = ENOTCONN;
    366                         break;
    367                 case TCP_ERESET:
    368                         rc = ECONNABORTED;
    369                         break;*/
     402                case UDP_ENORES:
     403                        rc = ENOMEM;
     404                        break;
     405                case UDP_EUNSPEC:
     406                        rc = EINVAL;
     407                        break;
     408                case UDP_ENOROUTE:
     409                        rc = EIO;
     410                        break;
    370411                default:
    371412                        assert(false);
    372413                }
    373 
     414               
    374415                if (rc != EOK) {
    375416                        fibril_mutex_unlock(&socket->lock);
    … …  
    378419                }
    379420        }
     421       
     422        ipc_call_t answer;
    380423       
    381424        IPC_SET_ARG1(answer, 0);
    … …  
    386429       
    387430out:
    388         if (addr != NULL)
    389                 free(addr);
     431        if (addr6 != NULL)
     432                free(addr6);
     433       
     434        free(buffer);
    390435}
    391436
    392437static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    393438{
    394         int socket_id;
    395         int flags;
    396         size_t addr_length, length;
    397         socket_core_t *sock_core;
    398         udp_sockdata_t *socket;
    399         ipc_call_t answer;
    400         ipc_callid_t rcallid;
    401         size_t data_len;
    402         udp_error_t urc;
    403         udp_sock_t rsock;
    404         struct sockaddr_in addr;
    405         int rc;
    406 
    407         log_msg(LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
    408 
    409         socket_id = SOCKET_GET_SOCKET_ID(call);
    410         flags = SOCKET_GET_FLAGS(call);
    411 
    412         sock_core = socket_cores_find(&client->sockets, socket_id);
     439        log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
     440       
     441        int socket_id = SOCKET_GET_SOCKET_ID(call);
     442       
     443        socket_core_t *sock_core =
     444            socket_cores_find(&client->sockets, socket_id);
    413445        if (sock_core == NULL) {
    414446                async_answer_0(callid, ENOTSOCK);
    415447                return;
    416448        }
    417 
    418         socket = (udp_sockdata_t *)sock_core->specific_data;
     449       
     450        udp_sockdata_t *socket =
     451            (udp_sockdata_t *) sock_core->specific_data;
     452       
    419453        fibril_mutex_lock(&socket->lock);
    420 
     454       
    421455        if (socket->assoc == NULL) {
    422456                fibril_mutex_unlock(&socket->lock);
    … …  
    424458                return;
    425459        }
    426 
    427         (void)flags;
    428 
    429         log_msg(LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
     460       
     461        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
     462       
    430463        fibril_mutex_lock(&socket->recv_buffer_lock);
    431         while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
    432                 log_msg(LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
     464       
     465        while ((socket->recv_buffer_used == 0) &&
     466            (socket->recv_error == UDP_EOK)) {
     467                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
    433468                fibril_condvar_wait(&socket->recv_buffer_cv,
    434469                    &socket->recv_buffer_lock);
    435470        }
    436 
    437         log_msg(LVL_DEBUG, "Got data in sock recv_buffer");
    438 
    439         rsock = socket->recv_fsock;
    440         data_len = socket->recv_buffer_used;
    441         urc = socket->recv_error;
    442 
    443         log_msg(LVL_DEBUG, "**** recv data_len=%zu", data_len);
    444 
     471       
     472        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
     473       
     474        size_t data_len = socket->recv_buffer_used;
     475        udp_error_t urc = socket->recv_error;
     476       
     477        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len);
     478       
     479        int rc;
     480       
    445481        switch (urc) {
    446482        case UDP_EOK:
    … …  
    457493                assert(false);
    458494        }
    459 
    460         log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
     495       
     496        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
     497       
    461498        if (rc != EOK) {
    462499                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    465502                return;
    466503        }
    467 
     504       
     505        ipc_callid_t rcallid;
     506        size_t addr_size = 0;
     507       
    468508        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    469                 /* Fill addr */
    470                 addr.sin_family = AF_INET;
    471                 addr.sin_addr.s_addr = host2uint32_t_be(rsock.addr.ipv4);
    472                 addr.sin_port = host2uint16_t_be(rsock.port);
    473 
    474                 log_msg(LVL_DEBUG, "addr read receive");
    475                 if (!async_data_read_receive(&rcallid, &addr_length)) {
     509                /* Fill address */
     510                udp_sock_t *rsock = &socket->recv_fsock;
     511                struct sockaddr_in addr;
     512                struct sockaddr_in6 addr6;
     513                size_t addr_length;
     514               
     515                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
     516                    &addr6);
     517               
     518                switch (addr_af) {
     519                case AF_INET:
     520                        addr.sin_port = host2uint16_t_be(rsock->port);
     521                       
     522                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
     523                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     524                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     525                                fibril_mutex_unlock(&socket->lock);
     526                                async_answer_0(callid, EINVAL);
     527                                return;
     528                        }
     529                       
     530                        if (addr_length > sizeof(addr))
     531                                addr_length = sizeof(addr);
     532                       
     533                        addr_size = sizeof(addr);
     534                       
     535                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
     536                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
     537                        if (rc != EOK) {
     538                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     539                                fibril_mutex_unlock(&socket->lock);
     540                                async_answer_0(callid, EINVAL);
     541                                return;
     542                        }
     543                       
     544                        break;
     545                case AF_INET6:
     546                        addr6.sin6_port = host2uint16_t_be(rsock->port);
     547                       
     548                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
     549                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     550                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     551                                fibril_mutex_unlock(&socket->lock);
     552                                async_answer_0(callid, EINVAL);
     553                                return;
     554                        }
     555                       
     556                        if (addr_length > sizeof(addr6))
     557                                addr_length = sizeof(addr6);
     558                       
     559                        addr_size = sizeof(addr6);
     560                       
     561                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
     562                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
     563                        if (rc != EOK) {
     564                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     565                                fibril_mutex_unlock(&socket->lock);
     566                                async_answer_0(callid, EINVAL);
     567                                return;
     568                        }
     569                       
     570                        break;
     571                default:
    476572                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    477573                        fibril_mutex_unlock(&socket->lock);
    … …  
    479575                        return;
    480576                }
    481 
    482                 if (addr_length > sizeof(addr))
    483                         addr_length = sizeof(addr);
    484 
    485                 log_msg(LVL_DEBUG, "addr read finalize");
    486                 rc = async_data_read_finalize(rcallid, &addr, addr_length);
    487                 if (rc != EOK) {
    488                         fibril_mutex_unlock(&socket->recv_buffer_lock);
    489                         fibril_mutex_unlock(&socket->lock);
    490                         async_answer_0(callid, EINVAL);
    491                         return;
    492                 }
    493         }
    494 
    495         log_msg(LVL_DEBUG, "data read receive");
     577        }
     578       
     579        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
     580       
     581        size_t length;
    496582        if (!async_data_read_receive(&rcallid, &length)) {
    497583                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    500586                return;
    501587        }
    502 
     588       
    503589        if (length > data_len)
    504590                length = data_len;
    505 
    506         log_msg(LVL_DEBUG, "data read finalize");
     591       
     592        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
     593       
    507594        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    508 
    509         if (length < data_len && rc == EOK)
     595       
     596        if ((length < data_len) && (rc == EOK))
    510597                rc = EOVERFLOW;
    511 
    512         log_msg(LVL_DEBUG, "read_data_length <- %zu", length);
     598       
     599        log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
     600       
     601        ipc_call_t answer;
     602       
    513603        IPC_SET_ARG2(answer, 0);
    514604        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    515         SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
     605        SOCKET_SET_ADDRESS_LENGTH(answer, addr_size);
    516606        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    517607            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    518 
     608       
    519609        socket->recv_buffer_used = 0;
    520 
     610       
    521611        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    522612        fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    526616static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    527617{
    528         int socket_id;
    529         socket_core_t *sock_core;
    530         udp_sockdata_t *socket;
    531         int rc;
    532 
    533         log_msg(LVL_DEBUG, "tcp_sock_close()");
    534         socket_id = SOCKET_GET_SOCKET_ID(call);
    535 
    536         sock_core = socket_cores_find(&client->sockets, socket_id);
     618        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
     619        int socket_id = SOCKET_GET_SOCKET_ID(call);
     620
     621        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - find core");
     622        socket_core_t *sock_core =
     623            socket_cores_find(&client->sockets, socket_id);
    537624        if (sock_core == NULL) {
     625        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - core not found");
    538626                async_answer_0(callid, ENOTSOCK);
    539627                return;
    540628        }
    541629
    542         socket = (udp_sockdata_t *)sock_core->specific_data;
     630        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - spec data");
     631        udp_sockdata_t *socket =
     632            (udp_sockdata_t *) sock_core->specific_data;
     633        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - lock socket");
    543634        fibril_mutex_lock(&socket->lock);
    544635
    545         rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
     636        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - lock socket buffer");
     637        fibril_mutex_lock(&socket->recv_buffer_lock);
     638        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - set socket->sock_core = NULL");
     639        socket->sock_core = NULL;
     640        fibril_mutex_unlock(&socket->recv_buffer_lock);
     641
     642        udp_uc_reset(socket->assoc);
     643
     644        int rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    546645            udp_free_sock_data);
    547646        if (rc != EOK) {
     647                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - socket_destroy failed");
    548648                fibril_mutex_unlock(&socket->lock);
    549649                async_answer_0(callid, rc);
    … …  
    551651        }
    552652
     653        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - broadcast recv_buffer_cv");
     654        fibril_condvar_broadcast(&socket->recv_buffer_cv);
     655
    553656        fibril_mutex_unlock(&socket->lock);
    554657        async_answer_0(callid, EOK);
    … …  
    557660static void udp_sock_getsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    558661{
    559         log_msg(LVL_DEBUG, "udp_sock_getsockopt()");
     662        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_getsockopt()");
    560663        async_answer_0(callid, ENOTSUP);
    561664}
    … …  
    563666static void udp_sock_setsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    564667{
    565         log_msg(LVL_DEBUG, "udp_sock_setsockopt()");
    566         async_answer_0(callid, ENOTSUP);
    567 }
     668        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_setsockopt)");
     669        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
     670       
     671        void *data = NULL;
     672        size_t data_len;
     673        int rc = async_data_write_accept(&data, false, 0, 0, 0, &data_len);
     674        if (rc != EOK) {
     675                log_msg(LOG_DEFAULT, LVL_DEBUG, " - failed accepting data");
     676                async_answer_0(callid, rc);
     677                return;
     678        }
     679       
     680        sysarg_t opt_level = SOL_SOCKET;
     681        sysarg_t opt_name = SOCKET_GET_OPT_NAME(call);
     682       
     683        if (opt_level != SOL_SOCKET || opt_name != SO_IPLINK ||
     684            data_len != sizeof(service_id_t)) {
     685                log_msg(LOG_DEFAULT, LVL_DEBUG, " - failed opt_level/name/len");
     686                log_msg(LOG_DEFAULT, LVL_DEBUG, " - failed opt_level=%d, "
     687                    "opt_name=%d, data_len=%zu", (int)opt_level, (int)opt_name,
     688                    data_len);
     689                async_answer_0(callid, EINVAL);
     690                return;
     691        }
     692       
     693        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
     694       
     695        socket_core_t *sock_core = socket_cores_find(&client->sockets,
     696            SOCKET_GET_SOCKET_ID(call));
     697        if (sock_core == NULL) {
     698                log_msg(LOG_DEFAULT, LVL_DEBUG, " - failed getting sock_core");
     699                async_answer_0(callid, ENOENT);
     700                return;
     701        }
     702       
     703        udp_sockdata_t *socket =
     704            (udp_sockdata_t *) sock_core->specific_data;
     705       
     706        service_id_t iplink = *(service_id_t *)data;
     707        udp_uc_set_iplink(socket->assoc, iplink);
     708       
     709        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
     710        async_answer_0(callid, EOK);
     711}
     712
    568713
    569714static int udp_sock_recv_fibril(void *arg)
    … …  
    574719        size_t rcvd;
    575720
    576         log_msg(LVL_DEBUG, "udp_sock_recv_fibril()");
     721        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril()");
     722
     723        fibril_mutex_lock(&sock->recv_buffer_lock);
    577724
    578725        while (true) {
    579                 log_msg(LVL_DEBUG, "[] wait for rcv buffer empty()");
    580                 fibril_mutex_lock(&sock->recv_buffer_lock);
    581                 while (sock->recv_buffer_used != 0) {
     726                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()");
     727                while ((sock->recv_buffer_used != 0) && (sock->sock_core != NULL)) {
    582728                        fibril_condvar_wait(&sock->recv_buffer_cv,
    583729                            &sock->recv_buffer_lock);
    584730                }
    585731
    586                 log_msg(LVL_DEBUG, "[] call udp_uc_receive()");
     732                fibril_mutex_unlock(&sock->recv_buffer_lock);
     733
     734                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] call udp_uc_receive()");
    587735                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
    588736                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
     737                fibril_mutex_lock(&sock->recv_buffer_lock);
    589738                sock->recv_error = urc;
    590739
    591                 udp_sock_notify_data(sock->sock_core);
     740                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] udp_uc_receive -> %d", urc);
     741
     742                if (sock->sock_core != NULL)
     743                        udp_sock_notify_data(sock->sock_core);
    592744
    593745                if (urc != UDP_EOK) {
     746                        log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
    594747                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
    595748                        fibril_mutex_unlock(&sock->recv_buffer_lock);
    … …  
    597750                }
    598751
    599                 log_msg(LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
     752                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
    600753
    601754                sock->recv_buffer_used = rcvd;
    602                 fibril_mutex_unlock(&sock->recv_buffer_lock);
    603755                fibril_condvar_broadcast(&sock->recv_buffer_cv);
    604756        }
    605757
     758        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril() exited loop");
    606759        udp_uc_destroy(sock->assoc);
     760
     761        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril() terminated");
    607762
    608763        return 0;
    … …  
    618773        async_answer_0(iid, EOK);
    619774
     775        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: begin");
     776
    620777        client.sess = async_callback_receive(EXCHANGE_SERIALIZE);
    621778        socket_cores_initialize(&client.sockets);
    622779
    623780        while (true) {
    624                 log_msg(LVL_DEBUG, "udp_sock_connection: wait");
     781                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: wait");
    625782                callid = async_get_call(&call);
    626783                if (!IPC_GET_IMETHOD(call))
    627784                        break;
    628785
    629                 log_msg(LVL_DEBUG, "udp_sock_connection: METHOD=%d",
     786                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: METHOD=%d",
    630787                    (int)IPC_GET_IMETHOD(call));
    631788
    … …  
    670827
    671828        /* Clean up */
    672         log_msg(LVL_DEBUG, "udp_sock_connection: Clean up");
     829        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: Clean up");
    673830        async_hangup(client.sess);
    674831        socket_cores_release(NULL, &client.sockets, &gsock, udp_free_sock_data);
Note: See TracChangeset for help on using the changeset viewer.