Changeset db71e2a in mainline for uspace/srv/net/udp/sock.c


Ignore:
Timestamp:
2013-07-24T17:42:25Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/fix-logger-deadlock, topic/msim-upgrade, topic/simplify-dev-export
Children:
69b264a9
Parents:
52f1882 (diff), cffa14e6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge mainline changes.

usb hc macro changes from mainline were reverted, too many conflicts

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r52f1882 rdb71e2a  
    9090        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);
    … …  
    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 
    169161        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_bind()");
    170162        log_msg(LOG_DEFAULT, 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);
     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 
     177       
     178        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
     179       
    180180        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 
     189       
    194190        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    195         sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
     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 
     236       
    224237        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
    … …  
    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(LOG_DEFAULT, 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)) {
    315352                /* 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);
     353                inet_addr_t loc_addr;
     354                inet_addr_t rem_addr;
     355               
     356                rem_addr = fsocket_ptr ? fsocket.addr :
     357                    socket->assoc->ident.foreign.addr;
     358               
     359                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    322360                if (rc != EOK) {
    323361                        fibril_mutex_unlock(&socket->lock);
    … …  
    325363                        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_sendto: Failed to "
    326364                            "determine local address.");
    327                         return;
    328                 }
    329 
    330                 socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
    331                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x",
    332                     socket->assoc->ident.local.addr.ipv4);
    333         }
    334 
    335 
     365                        goto out;
     366                }
     367               
     368                socket->assoc->ident.local.addr = loc_addr;
     369        }
     370       
    336371        assert(socket->assoc != NULL);
    337 
    338         for (index = 0; index < fragments; index++) {
     372       
     373        int fragments = SOCKET_GET_DATA_FRAGMENTS(call);
     374        for (int index = 0; index < fragments; index++) {
     375                ipc_callid_t wcallid;
     376                size_t length;
     377               
    339378                if (!async_data_write_receive(&wcallid, &length)) {
    340379                        fibril_mutex_unlock(&socket->lock);
    … …  
    342381                        goto out;
    343382                }
    344 
     383               
    345384                if (length > UDP_FRAGMENT_SIZE)
    346385                        length = UDP_FRAGMENT_SIZE;
    347 
    348                 rc = async_data_write_finalize(wcallid, buffer, length);
     386               
     387                int rc = async_data_write_finalize(wcallid, buffer, length);
    349388                if (rc != EOK) {
    350389                        fibril_mutex_unlock(&socket->lock);
    … …  
    352391                        goto out;
    353392                }
    354 
    355                 urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
    356 
     393               
     394                udp_error_t urc =
     395                    udp_uc_send(socket->assoc, fsocket_ptr, buffer, length, 0);
     396               
    357397                switch (urc) {
    358398                case UDP_EOK:
    359399                        rc = EOK;
    360400                        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;*/
     401                case UDP_ENORES:
     402                        rc = ENOMEM;
     403                        break;
     404                case UDP_EUNSPEC:
     405                        rc = EINVAL;
     406                        break;
     407                case UDP_ENOROUTE:
     408                        rc = EIO;
     409                        break;
    370410                default:
    371411                        assert(false);
    372412                }
    373 
     413               
    374414                if (rc != EOK) {
    375415                        fibril_mutex_unlock(&socket->lock);
    … …  
    378418                }
    379419        }
     420       
     421        ipc_call_t answer;
    380422       
    381423        IPC_SET_ARG1(answer, 0);
    … …  
    386428       
    387429out:
    388         if (addr != NULL)
    389                 free(addr);
     430        if (addr6 != NULL)
     431                free(addr6);
     432       
     433        free(buffer);
    390434}
    391435
    392436static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    393437{
    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 
    407438        log_msg(LOG_DEFAULT, 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       
     440        int socket_id = SOCKET_GET_SOCKET_ID(call);
     441       
     442        socket_core_t *sock_core =
     443            socket_cores_find(&client->sockets, socket_id);
    413444        if (sock_core == NULL) {
    414445                async_answer_0(callid, ENOTSOCK);
    415446                return;
    416447        }
    417 
    418         socket = (udp_sockdata_t *)sock_core->specific_data;
     448       
     449        udp_sockdata_t *socket =
     450            (udp_sockdata_t *) sock_core->specific_data;
     451       
    419452        fibril_mutex_lock(&socket->lock);
    420 
     453       
    421454        if (socket->assoc == NULL) {
    422455                fibril_mutex_unlock(&socket->lock);
    … …  
    424457                return;
    425458        }
    426 
    427         (void)flags;
    428 
     459       
    429460        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
     461       
    430462        fibril_mutex_lock(&socket->recv_buffer_lock);
    431         while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
     463       
     464        while ((socket->recv_buffer_used == 0) &&
     465            (socket->recv_error == UDP_EOK)) {
    432466                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
    433467                fibril_condvar_wait(&socket->recv_buffer_cv,
    434468                    &socket->recv_buffer_lock);
    435469        }
    436 
     470       
    437471        log_msg(LOG_DEFAULT, 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 
     472       
     473        size_t data_len = socket->recv_buffer_used;
     474        udp_error_t urc = socket->recv_error;
     475       
    443476        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len);
    444 
     477       
     478        int rc;
     479       
    445480        switch (urc) {
    446481        case UDP_EOK:
    … …  
    457492                assert(false);
    458493        }
    459 
     494       
    460495        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
     496       
    461497        if (rc != EOK) {
    462498                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    465501                return;
    466502        }
    467 
     503       
     504        ipc_callid_t rcallid;
     505        size_t addr_size = 0;
     506       
    468507        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(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
    475                 if (!async_data_read_receive(&rcallid, &addr_length)) {
     508                /* Fill address */
     509                udp_sock_t *rsock = &socket->recv_fsock;
     510                struct sockaddr_in addr;
     511                struct sockaddr_in6 addr6;
     512                size_t addr_length;
     513               
     514                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
     515                    &addr6);
     516               
     517                switch (addr_af) {
     518                case AF_INET:
     519                        addr.sin_port = host2uint16_t_be(rsock->port);
     520                       
     521                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
     522                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     523                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     524                                fibril_mutex_unlock(&socket->lock);
     525                                async_answer_0(callid, EINVAL);
     526                                return;
     527                        }
     528                       
     529                        if (addr_length > sizeof(addr))
     530                                addr_length = sizeof(addr);
     531                       
     532                        addr_size = sizeof(addr);
     533                       
     534                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
     535                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
     536                        if (rc != EOK) {
     537                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     538                                fibril_mutex_unlock(&socket->lock);
     539                                async_answer_0(callid, EINVAL);
     540                                return;
     541                        }
     542                       
     543                        break;
     544                case AF_INET6:
     545                        addr6.sin6_port = host2uint16_t_be(rsock->port);
     546                       
     547                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
     548                        if (!async_data_read_receive(&rcallid, &addr_length)) {
     549                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     550                                fibril_mutex_unlock(&socket->lock);
     551                                async_answer_0(callid, EINVAL);
     552                                return;
     553                        }
     554                       
     555                        if (addr_length > sizeof(addr6))
     556                                addr_length = sizeof(addr6);
     557                       
     558                        addr_size = sizeof(addr6);
     559                       
     560                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
     561                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
     562                        if (rc != EOK) {
     563                                fibril_mutex_unlock(&socket->recv_buffer_lock);
     564                                fibril_mutex_unlock(&socket->lock);
     565                                async_answer_0(callid, EINVAL);
     566                                return;
     567                        }
     568                       
     569                        break;
     570                default:
    476571                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    477572                        fibril_mutex_unlock(&socket->lock);
    … …  
    479574                        return;
    480575                }
    481 
    482                 if (addr_length > sizeof(addr))
    483                         addr_length = sizeof(addr);
    484 
    485                 log_msg(LOG_DEFAULT, 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 
     576        }
     577       
    495578        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
     579       
     580        size_t length;
    496581        if (!async_data_read_receive(&rcallid, &length)) {
    497582                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    500585                return;
    501586        }
    502 
     587       
    503588        if (length > data_len)
    504589                length = data_len;
    505 
     590       
    506591        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
     592       
    507593        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    508 
    509         if (length < data_len && rc == EOK)
     594       
     595        if ((length < data_len) && (rc == EOK))
    510596                rc = EOVERFLOW;
    511 
     597       
    512598        log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
     599       
     600        ipc_call_t answer;
     601       
    513602        IPC_SET_ARG2(answer, 0);
    514603        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    515         SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
     604        SOCKET_SET_ADDRESS_LENGTH(answer, addr_size);
    516605        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    517606            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    518 
     607       
    519608        socket->recv_buffer_used = 0;
    520 
     609       
    521610        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    522611        fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    526615static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    527616{
    528         int socket_id;
    529         socket_core_t *sock_core;
    530         udp_sockdata_t *socket;
    531         int rc;
    532 
    533617        log_msg(LOG_DEFAULT, 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        int socket_id = SOCKET_GET_SOCKET_ID(call);
     619
     620        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - find core");
     621        socket_core_t *sock_core =
     622            socket_cores_find(&client->sockets, socket_id);
    537623        if (sock_core == NULL) {
     624        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - core not found");
    538625                async_answer_0(callid, ENOTSOCK);
    539626                return;
    540627        }
    541628
    542         socket = (udp_sockdata_t *)sock_core->specific_data;
     629        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - spec data");
     630        udp_sockdata_t *socket =
     631            (udp_sockdata_t *) sock_core->specific_data;
     632        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - lock socket");
    543633        fibril_mutex_lock(&socket->lock);
    544634
    545         rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
     635        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - lock socket buffer");
     636        fibril_mutex_lock(&socket->recv_buffer_lock);
     637        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - set socket->sock_core = NULL");
     638        socket->sock_core = NULL;
     639        fibril_mutex_unlock(&socket->recv_buffer_lock);
     640
     641        udp_uc_reset(socket->assoc);
     642
     643        int rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    546644            udp_free_sock_data);
    547645        if (rc != EOK) {
     646                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - socket_destroy failed");
    548647                fibril_mutex_unlock(&socket->lock);
    549648                async_answer_0(callid, rc);
    550649                return;
    551650        }
     651
     652        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - broadcast recv_buffer_cv");
     653        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    552654
    553655        fibril_mutex_unlock(&socket->lock);
    … …  
    576678        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril()");
    577679
     680        fibril_mutex_lock(&sock->recv_buffer_lock);
     681
    578682        while (true) {
    579683                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()");
    580                 fibril_mutex_lock(&sock->recv_buffer_lock);
    581                 while (sock->recv_buffer_used != 0) {
     684                while ((sock->recv_buffer_used != 0) && (sock->sock_core != NULL)) {
    582685                        fibril_condvar_wait(&sock->recv_buffer_cv,
    583686                            &sock->recv_buffer_lock);
    584687                }
     688
     689                fibril_mutex_unlock(&sock->recv_buffer_lock);
    585690
    586691                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] call udp_uc_receive()");
    587692                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
    588693                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
     694                fibril_mutex_lock(&sock->recv_buffer_lock);
    589695                sock->recv_error = urc;
    590696
    591                 udp_sock_notify_data(sock->sock_core);
     697                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] udp_uc_receive -> %d", urc);
     698
     699                if (sock->sock_core != NULL)
     700                        udp_sock_notify_data(sock->sock_core);
    592701
    593702                if (urc != UDP_EOK) {
     703                        log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
    594704                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
    595705                        fibril_mutex_unlock(&sock->recv_buffer_lock);
    … …  
    600710
    601711                sock->recv_buffer_used = rcvd;
    602                 fibril_mutex_unlock(&sock->recv_buffer_lock);
    603712                fibril_condvar_broadcast(&sock->recv_buffer_cv);
    604713        }
    605714
     715        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril() exited loop");
     716        fibril_mutex_unlock(&sock->recv_buffer_lock);
    606717        udp_uc_destroy(sock->assoc);
     718
     719        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril() terminated");
    607720
    608721        return 0;
Note: See TracChangeset for help on using the changeset viewer.