Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r02a09ed rccb5165  
    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
    161169        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_bind()");
    162170        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);
     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))) {
     177                goto out;
     178        }
     179       
     180        if (addr_size != sizeof(struct sockaddr_in)) {
    174181                async_answer_0(callid, EINVAL);
    175182                goto out;
    176183        }
    177184       
    178         struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
    179        
    180185        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    181        
    182186        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    183             addr6, addr_len, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
     187            addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
    184188            last_used_port);
    185189        if (rc != EOK) {
    … …  
    189193       
    190194        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));
     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        
     223
    237224        log_msg(LOG_DEFAULT, 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
    … …  
    265251        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()");
    266252       
    267         struct sockaddr_in6 *addr6 = NULL;
    268         struct sockaddr_in *addr;
    269         udp_sock_t fsocket;
    270         udp_sock_t *fsocket_ptr;
     253        struct sockaddr_in *addr = NULL;
     254        udp_sock_t fsock;
     255        udp_sock_t *fsock_ptr;
    271256       
    272257        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
    273                 size_t addr_len;
    274                 int rc = async_data_write_accept((void **) &addr6, false,
    275                     0, 0, 0, &addr_len);
     258                size_t addr_size;
     259                int rc = async_data_write_accept((void **) &addr, false,
     260                    0, 0, 0, &addr_size);
    276261                if (rc != EOK) {
    277262                        async_answer_0(callid, rc);
    278                         return;
    279                 }
    280                
    281                 if ((addr_len != sizeof(struct sockaddr_in)) &&
    282                     (addr_len != sizeof(struct sockaddr_in6))) {
     263                        goto out;
     264                }
     265               
     266                if (addr_size != sizeof(struct sockaddr_in)) {
    283267                        async_answer_0(callid, EINVAL);
    284268                        goto out;
    285269                }
    286270               
    287                 addr = (struct sockaddr_in *) addr6;
    288                
    289                 switch (addr->sin_family) {
    290                 case AF_INET:
    291                         inet_sockaddr_in_addr(addr, &fsocket.addr);
    292                         break;
    293                 case AF_INET6:
    294                         inet_sockaddr_in6_addr(addr6, &fsocket.addr);
    295                         break;
    296                 default:
    297                         async_answer_0(callid, EINVAL);
    298                         goto out;
    299                 }
    300                
    301                 fsocket.port = uint16_t_be2host(addr->sin_port);
    302                 fsocket_ptr = &fsocket;
     271                fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     272                fsock.port = uint16_t_be2host(addr->sin_port);
     273                fsock_ptr = &fsock;
    303274        } else
    304                 fsocket_ptr = NULL;
     275                fsock_ptr = NULL;
    305276       
    306277        int socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    343314        fibril_mutex_lock(&socket->lock);
    344315       
    345         if (inet_addr_is_any(&socket->assoc->ident.local.addr)) {
     316        if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
    346317                /* Determine local IP address */
    347                 inet_addr_t loc_addr;
    348                 inet_addr_t rem_addr;
    349                
    350                 rem_addr = fsocket_ptr ? fsocket.addr :
    351                     socket->assoc->ident.foreign.addr;
     318                inet_addr_t loc_addr, rem_addr;
     319               
     320                rem_addr.ipv4 = fsock_ptr ? fsock.addr.ipv4 :
     321                    socket->assoc->ident.foreign.addr.ipv4;
    352322               
    353323                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    … …  
    360330                }
    361331               
    362                 socket->assoc->ident.local.addr = loc_addr;
     332                socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
     333                log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x",
     334                    socket->assoc->ident.local.addr.ipv4);
    363335        }
    364336       
    … …  
    388360               
    389361                udp_error_t urc =
    390                     udp_uc_send(socket->assoc, fsocket_ptr, buffer, length, 0);
     362                    udp_uc_send(socket->assoc, fsock_ptr, buffer, length, 0);
    391363               
    392364                switch (urc) {
    … …  
    423395       
    424396out:
    425         if (addr6 != NULL)
    426                 free(addr6);
     397        if (addr != NULL)
     398                free(addr);
    427399}
    428400
    429401static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    430402{
     403        int socket_id;
     404        int flags;
     405        size_t addr_length, length;
     406        socket_core_t *sock_core;
     407        udp_sockdata_t *socket;
     408        ipc_call_t answer;
     409        ipc_callid_t rcallid;
     410        size_t data_len;
     411        udp_error_t urc;
     412        udp_sock_t rsock;
     413        struct sockaddr_in addr;
     414        int rc;
     415
    431416        log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
    432        
    433         int socket_id = SOCKET_GET_SOCKET_ID(call);
    434        
    435         socket_core_t *sock_core =
    436             socket_cores_find(&client->sockets, socket_id);
     417
     418        socket_id = SOCKET_GET_SOCKET_ID(call);
     419        flags = SOCKET_GET_FLAGS(call);
     420
     421        sock_core = socket_cores_find(&client->sockets, socket_id);
    437422        if (sock_core == NULL) {
    438423                async_answer_0(callid, ENOTSOCK);
    439424                return;
    440425        }
    441        
    442         udp_sockdata_t *socket =
    443             (udp_sockdata_t *) sock_core->specific_data;
    444        
     426
     427        socket = (udp_sockdata_t *)sock_core->specific_data;
    445428        fibril_mutex_lock(&socket->lock);
    446        
     429
    447430        if (socket->assoc == NULL) {
    448431                fibril_mutex_unlock(&socket->lock);
    … …  
    450433                return;
    451434        }
    452        
     435
     436        (void)flags;
     437
    453438        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
    454        
    455439        fibril_mutex_lock(&socket->recv_buffer_lock);
    456        
    457         while ((socket->recv_buffer_used == 0) &&
    458             (socket->recv_error == UDP_EOK)) {
     440        while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
    459441                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
    460442                fibril_condvar_wait(&socket->recv_buffer_cv,
    461443                    &socket->recv_buffer_lock);
    462444        }
    463        
     445
    464446        log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
    465        
    466         size_t data_len = socket->recv_buffer_used;
    467         udp_error_t urc = socket->recv_error;
    468        
     447
     448        rsock = socket->recv_fsock;
     449        data_len = socket->recv_buffer_used;
     450        urc = socket->recv_error;
     451
    469452        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len);
    470        
    471         int rc;
    472        
     453
    473454        switch (urc) {
    474455        case UDP_EOK:
    … …  
    485466                assert(false);
    486467        }
    487        
     468
    488469        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
    489        
    490470        if (rc != EOK) {
    491471                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    494474                return;
    495475        }
    496        
    497         ipc_callid_t rcallid;
    498         size_t addr_size = 0;
    499        
     476
    500477        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
    501                 /* Fill address */
    502                 udp_sock_t *rsock = &socket->recv_fsock;
    503                 struct sockaddr_in addr;
    504                 struct sockaddr_in6 addr6;
    505                 size_t addr_length;
    506                
    507                 uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
    508                     &addr6);
    509                
    510                 switch (addr_af) {
    511                 case AF_INET:
    512                         addr.sin_port = host2uint16_t_be(rsock->port);
    513                        
    514                         log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
    515                         if (!async_data_read_receive(&rcallid, &addr_length)) {
    516                                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    517                                 fibril_mutex_unlock(&socket->lock);
    518                                 async_answer_0(callid, EINVAL);
    519                                 return;
    520                         }
    521                        
    522                         if (addr_length > sizeof(addr))
    523                                 addr_length = sizeof(addr);
    524                        
    525                         addr_size = sizeof(addr);
    526                        
    527                         log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
    528                         rc = async_data_read_finalize(rcallid, &addr, addr_length);
    529                         if (rc != EOK) {
    530                                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    531                                 fibril_mutex_unlock(&socket->lock);
    532                                 async_answer_0(callid, EINVAL);
    533                                 return;
    534                         }
    535                        
    536                         break;
    537                 case AF_INET6:
    538                         addr6.sin6_port = host2uint16_t_be(rsock->port);
    539                        
    540                         log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
    541                         if (!async_data_read_receive(&rcallid, &addr_length)) {
    542                                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    543                                 fibril_mutex_unlock(&socket->lock);
    544                                 async_answer_0(callid, EINVAL);
    545                                 return;
    546                         }
    547                        
    548                         if (addr_length > sizeof(addr6))
    549                                 addr_length = sizeof(addr6);
    550                        
    551                         addr_size = sizeof(addr6);
    552                        
    553                         log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
    554                         rc = async_data_read_finalize(rcallid, &addr6, addr_length);
    555                         if (rc != EOK) {
    556                                 fibril_mutex_unlock(&socket->recv_buffer_lock);
    557                                 fibril_mutex_unlock(&socket->lock);
    558                                 async_answer_0(callid, EINVAL);
    559                                 return;
    560                         }
    561                        
    562                         break;
    563                 default:
     478                /* Fill addr */
     479                addr.sin_family = AF_INET;
     480                addr.sin_addr.s_addr = host2uint32_t_be(rsock.addr.ipv4);
     481                addr.sin_port = host2uint16_t_be(rsock.port);
     482
     483                log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
     484                if (!async_data_read_receive(&rcallid, &addr_length)) {
    564485                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    565486                        fibril_mutex_unlock(&socket->lock);
    … …  
    567488                        return;
    568489                }
    569         }
    570        
     490
     491                if (addr_length > sizeof(addr))
     492                        addr_length = sizeof(addr);
     493
     494                log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
     495                rc = async_data_read_finalize(rcallid, &addr, addr_length);
     496                if (rc != EOK) {
     497                        fibril_mutex_unlock(&socket->recv_buffer_lock);
     498                        fibril_mutex_unlock(&socket->lock);
     499                        async_answer_0(callid, EINVAL);
     500                        return;
     501                }
     502        }
     503
    571504        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
    572        
    573         size_t length;
    574505        if (!async_data_read_receive(&rcallid, &length)) {
    575506                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    578509                return;
    579510        }
    580        
     511
    581512        if (length > data_len)
    582513                length = data_len;
    583        
     514
    584515        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
    585        
    586516        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    587        
    588         if ((length < data_len) && (rc == EOK))
     517
     518        if (length < data_len && rc == EOK)
    589519                rc = EOVERFLOW;
    590        
     520
    591521        log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
    592        
    593         ipc_call_t answer;
    594        
    595522        IPC_SET_ARG2(answer, 0);
    596523        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    597         SOCKET_SET_ADDRESS_LENGTH(answer, addr_size);
     524        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
    598525        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    599526            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    600        
     527
    601528        socket->recv_buffer_used = 0;
    602        
     529
    603530        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    604531        fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    675602        while (true) {
    676603                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()");
    677                 while ((sock->recv_buffer_used != 0) && (sock->sock_core != NULL)) {
     604                while (sock->recv_buffer_used != 0 && sock->sock_core != NULL) {
    678605                        fibril_condvar_wait(&sock->recv_buffer_cv,
    679606                            &sock->recv_buffer_lock);
    … …  
    696623                        log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
    697624                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
    698                         fibril_mutex_unlock(&sock->recv_buffer_lock);
    699625                        break;
    700626                }
Note: See TracChangeset for help on using the changeset viewer.