Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rf4a27304 rdb81577  
    8888static void udp_sock_notify_data(socket_core_t *sock_core)
    8989{
    90         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id);
     90        log_msg(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(LOG_DEFAULT, LVL_DEBUG, "udp_sock_socket()");
     105        log_msg(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         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);
     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);
    167175        if (rc != EOK) {
    168176                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);
    175177                goto out;
    176178        }
    177        
    178         struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
    179        
    180         log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    181        
     179
     180        log_msg(LVL_DEBUG, " - call socket_bind");
    182181        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    183             addr6, addr_len, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
     182            addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
    184183            last_used_port);
    185184        if (rc != EOK) {
    … …  
    187186                goto out;
    188187        }
    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));
     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));
    194196        if (sock_core == NULL) {
    195197                async_answer_0(callid, ENOENT);
    196198                goto out;
    197199        }
    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        
     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
    220207        switch (urc) {
    221208        case UDP_EOK:
    … …  
    234221                assert(false);
    235222        }
    236        
    237         log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
     223
     224        log_msg(LVL_DEBUG, " - success");
    238225        async_answer_0(callid, rc);
    239        
    240226out:
    241         if (addr6 != NULL)
    242                 free(addr6);
     227        if (addr != NULL)
     228                free(addr);
    243229}
    244230
    245231static void udp_sock_listen(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    246232{
    247         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_listen()");
     233        log_msg(LVL_DEBUG, "udp_sock_listen()");
    248234        async_answer_0(callid, ENOTSUP);
    249235}
    … …  
    251237static void udp_sock_connect(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    252238{
    253         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connect()");
     239        log_msg(LVL_DEBUG, "udp_sock_connect()");
    254240        async_answer_0(callid, ENOTSUP);
    255241}
    … …  
    257243static void udp_sock_accept(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    258244{
    259         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_accept()");
     245        log_msg(LVL_DEBUG, "udp_sock_accept()");
    260246        async_answer_0(callid, ENOTSUP);
    261247}
    … …  
    263249static void udp_sock_sendto(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    264250{
    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;
     251        int socket_id;
     252        int fragments;
     253        int index;
    274254        struct sockaddr_in *addr;
    275         udp_sock_t fsocket;
    276         udp_sock_t *fsocket_ptr;
    277        
     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
    278270        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
    279                 size_t addr_len;
    280                 int rc = async_data_write_accept((void **) &addr6, false,
    281                     0, 0, 0, &addr_len);
     271                rc = async_data_write_accept((void **) &addr, false,
     272                    0, 0, 0, &addr_size);
    282273                if (rc != EOK) {
    283274                        async_answer_0(callid, rc);
    284275                        goto out;
    285276                }
    286                
    287                 if ((addr_len != sizeof(struct sockaddr_in)) &&
    288                     (addr_len != sizeof(struct sockaddr_in6))) {
     277
     278                if (addr_size != sizeof(struct sockaddr_in)) {
    289279                        async_answer_0(callid, EINVAL);
    290280                        goto out;
    291281                }
    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        
     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);
    314292        SOCKET_GET_FLAGS(call);
    315        
    316         socket_core_t *sock_core =
    317             socket_cores_find(&client->sockets, socket_id);
     293
     294        sock_core = socket_cores_find(&client->sockets, socket_id);
    318295        if (sock_core == NULL) {
    319296                async_answer_0(callid, ENOTSOCK);
    320297                goto out;
    321298        }
    322        
    323         udp_sockdata_t *socket =
    324             (udp_sockdata_t *) sock_core->specific_data;
    325        
    326         if (sock_core->port <= 0) {
     299
     300        if (sock_core->port == 0) {
    327301                /* Implicitly bind socket to port */
    328                 int rc = socket_bind_free_port(&gsock, sock_core,
    329                     UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, last_used_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);
    330305                if (rc != EOK) {
    331306                        async_answer_0(callid, rc);
    332307                        goto out;
    333308                }
    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        
     309        }
     310
     311        socket = (udp_sockdata_t *)sock_core->specific_data;
    349312        fibril_mutex_lock(&socket->lock);
    350        
    351         if (inet_addr_is_any(&socket->assoc->ident.local.addr)) {
     313
     314        if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
    352315                /* Determine local IP address */
    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);
     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);
    360322                if (rc != EOK) {
    361323                        fibril_mutex_unlock(&socket->lock);
    362324                        async_answer_0(callid, rc);
    363                         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_sendto: Failed to "
     325                        log_msg(LVL_DEBUG, "udp_sock_sendto: Failed to "
    364326                            "determine local address.");
    365                         goto out;
    366                 }
    367                
    368                 socket->assoc->ident.local.addr = loc_addr;
    369         }
    370        
     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
    371336        assert(socket->assoc != NULL);
    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                
     337
     338        for (index = 0; index < fragments; index++) {
    378339                if (!async_data_write_receive(&wcallid, &length)) {
    379340                        fibril_mutex_unlock(&socket->lock);
    … …  
    381342                        goto out;
    382343                }
    383                
     344
    384345                if (length > UDP_FRAGMENT_SIZE)
    385346                        length = UDP_FRAGMENT_SIZE;
    386                
    387                 int rc = async_data_write_finalize(wcallid, buffer, length);
     347
     348                rc = async_data_write_finalize(wcallid, buffer, length);
    388349                if (rc != EOK) {
    389350                        fibril_mutex_unlock(&socket->lock);
    … …  
    391352                        goto out;
    392353                }
    393                
    394                 udp_error_t urc =
    395                     udp_uc_send(socket->assoc, fsocket_ptr, buffer, length, 0);
    396                
     354
     355                urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
     356
    397357                switch (urc) {
    398358                case UDP_EOK:
    399359                        rc = EOK;
    400360                        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;
     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;*/
    410370                default:
    411371                        assert(false);
    412372                }
    413                
     373
    414374                if (rc != EOK) {
    415375                        fibril_mutex_unlock(&socket->lock);
    … …  
    418378                }
    419379        }
    420        
    421         ipc_call_t answer;
    422380       
    423381        IPC_SET_ARG1(answer, 0);
    … …  
    428386       
    429387out:
    430         if (addr6 != NULL)
    431                 free(addr6);
    432        
    433         free(buffer);
     388        if (addr != NULL)
     389                free(addr);
    434390}
    435391
    436392static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    437393{
    438         log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
    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);
     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);
    444413        if (sock_core == NULL) {
    445414                async_answer_0(callid, ENOTSOCK);
    446415                return;
    447416        }
    448        
    449         udp_sockdata_t *socket =
    450             (udp_sockdata_t *) sock_core->specific_data;
    451        
     417
     418        socket = (udp_sockdata_t *)sock_core->specific_data;
    452419        fibril_mutex_lock(&socket->lock);
    453        
     420
    454421        if (socket->assoc == NULL) {
    455422                fibril_mutex_unlock(&socket->lock);
    … …  
    457424                return;
    458425        }
    459        
    460         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
    461        
     426
     427        (void)flags;
     428
     429        log_msg(LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
    462430        fibril_mutex_lock(&socket->recv_buffer_lock);
    463        
    464         while ((socket->recv_buffer_used == 0) &&
    465             (socket->recv_error == UDP_EOK)) {
    466                 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
     431        while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
     432                log_msg(LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
    467433                fibril_condvar_wait(&socket->recv_buffer_cv,
    468434                    &socket->recv_buffer_lock);
    469435        }
    470        
    471         log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
    472        
    473         size_t data_len = socket->recv_buffer_used;
    474         udp_error_t urc = socket->recv_error;
    475        
    476         log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len);
    477        
    478         int rc;
    479        
     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
    480445        switch (urc) {
    481446        case UDP_EOK:
    … …  
    492457                assert(false);
    493458        }
    494        
    495         log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
    496        
     459
     460        log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
    497461        if (rc != EOK) {
    498462                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    501465                return;
    502466        }
    503        
    504         ipc_callid_t rcallid;
    505         size_t addr_size = 0;
    506        
     467
    507468        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    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:
     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)) {
    571476                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    572477                        fibril_mutex_unlock(&socket->lock);
    … …  
    574479                        return;
    575480                }
    576         }
    577        
    578         log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
    579        
    580         size_t length;
     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");
    581496        if (!async_data_read_receive(&rcallid, &length)) {
    582497                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    585500                return;
    586501        }
    587        
     502
    588503        if (length > data_len)
    589504                length = data_len;
    590        
    591         log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
    592        
     505
     506        log_msg(LVL_DEBUG, "data read finalize");
    593507        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    594        
    595         if ((length < data_len) && (rc == EOK))
     508
     509        if (length < data_len && rc == EOK)
    596510                rc = EOVERFLOW;
    597        
    598         log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
    599        
    600         ipc_call_t answer;
    601        
     511
     512        log_msg(LVL_DEBUG, "read_data_length <- %zu", length);
    602513        IPC_SET_ARG2(answer, 0);
    603514        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    604         SOCKET_SET_ADDRESS_LENGTH(answer, addr_size);
     515        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
    605516        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    606517            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    607        
     518
    608519        socket->recv_buffer_used = 0;
    609        
     520
    610521        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    611522        fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    615526static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    616527{
    617         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close()");
    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);
     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);
    623537        if (sock_core == NULL) {
    624         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_close() - core not found");
    625538                async_answer_0(callid, ENOTSOCK);
    626539                return;
    627540        }
    628541
    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");
     542        socket = (udp_sockdata_t *)sock_core->specific_data;
    633543        fibril_mutex_lock(&socket->lock);
    634544
    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,
     545        rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    644546            udp_free_sock_data);
    645547        if (rc != EOK) {
    646                 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - socket_destroy failed");
    647548                fibril_mutex_unlock(&socket->lock);
    648549                async_answer_0(callid, rc);
    … …  
    650551        }
    651552
    652         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_close - broadcast recv_buffer_cv");
    653         fibril_condvar_broadcast(&socket->recv_buffer_cv);
    654 
    655553        fibril_mutex_unlock(&socket->lock);
    656554        async_answer_0(callid, EOK);
    … …  
    659557static void udp_sock_getsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    660558{
    661         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_getsockopt()");
     559        log_msg(LVL_DEBUG, "udp_sock_getsockopt()");
    662560        async_answer_0(callid, ENOTSUP);
    663561}
    … …  
    665563static void udp_sock_setsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    666564{
    667         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_setsockopt()");
     565        log_msg(LVL_DEBUG, "udp_sock_setsockopt()");
    668566        async_answer_0(callid, ENOTSUP);
    669567}
    … …  
    676574        size_t rcvd;
    677575
    678         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril()");
    679 
    680         fibril_mutex_lock(&sock->recv_buffer_lock);
     576        log_msg(LVL_DEBUG, "udp_sock_recv_fibril()");
    681577
    682578        while (true) {
    683                 log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()");
    684                 while ((sock->recv_buffer_used != 0) && (sock->sock_core != NULL)) {
     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) {
    685582                        fibril_condvar_wait(&sock->recv_buffer_cv,
    686583                            &sock->recv_buffer_lock);
    687584                }
    688585
    689                 fibril_mutex_unlock(&sock->recv_buffer_lock);
    690 
    691                 log_msg(LOG_DEFAULT, LVL_DEBUG, "[] call udp_uc_receive()");
     586                log_msg(LVL_DEBUG, "[] call udp_uc_receive()");
    692587                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
    693588                    UDP_FRAGMENT_SIZE, &rcvd, &xflags, &sock->recv_fsock);
    694                 fibril_mutex_lock(&sock->recv_buffer_lock);
    695589                sock->recv_error = urc;
    696590
    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);
     591                udp_sock_notify_data(sock->sock_core);
    701592
    702593                if (urc != UDP_EOK) {
    703                         log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
    704594                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
    705595                        fibril_mutex_unlock(&sock->recv_buffer_lock);
    … …  
    707597                }
    708598
    709                 log_msg(LOG_DEFAULT, LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
     599                log_msg(LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
    710600
    711601                sock->recv_buffer_used = rcvd;
     602                fibril_mutex_unlock(&sock->recv_buffer_lock);
    712603                fibril_condvar_broadcast(&sock->recv_buffer_cv);
    713604        }
    714605
    715         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril() exited loop");
    716         fibril_mutex_unlock(&sock->recv_buffer_lock);
    717606        udp_uc_destroy(sock->assoc);
    718 
    719         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recv_fibril() terminated");
    720607
    721608        return 0;
    … …  
    735622
    736623        while (true) {
    737                 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: wait");
     624                log_msg(LVL_DEBUG, "udp_sock_connection: wait");
    738625                callid = async_get_call(&call);
    739626                if (!IPC_GET_IMETHOD(call))
    740627                        break;
    741628
    742                 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: METHOD=%d",
     629                log_msg(LVL_DEBUG, "udp_sock_connection: METHOD=%d",
    743630                    (int)IPC_GET_IMETHOD(call));
    744631
    … …  
    783670
    784671        /* Clean up */
    785         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_connection: Clean up");
     672        log_msg(LVL_DEBUG, "udp_sock_connection: Clean up");
    786673        async_hangup(client.sess);
    787674        socket_cores_release(NULL, &client.sockets, &gsock, udp_free_sock_data);
Note: See TracChangeset for help on using the changeset viewer.