Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rf4a27304 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         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;
    274         struct sockaddr_in *addr;
    275         udp_sock_t fsocket;
    276         udp_sock_t *fsocket_ptr;
     253        struct sockaddr_in *addr = NULL;
     254        udp_sock_t fsock;
     255        udp_sock_t *fsock_ptr;
    277256       
    278257        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);
     258                size_t addr_size;
     259                int rc = async_data_write_accept((void **) &addr, false,
     260                    0, 0, 0, &addr_size);
    282261                if (rc != EOK) {
    283262                        async_answer_0(callid, rc);
    … …  
    285264                }
    286265               
    287                 if ((addr_len != sizeof(struct sockaddr_in)) &&
    288                     (addr_len != sizeof(struct sockaddr_in6))) {
     266                if (addr_size != sizeof(struct sockaddr_in)) {
    289267                        async_answer_0(callid, EINVAL);
    290268                        goto out;
    291269                }
    292270               
    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;
     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;
    309274        } else
    310                 fsocket_ptr = NULL;
     275                fsock_ptr = NULL;
    311276       
    312277        int socket_id = SOCKET_GET_SOCKET_ID(call);
    … …  
    349314        fibril_mutex_lock(&socket->lock);
    350315       
    351         if (inet_addr_is_any(&socket->assoc->ident.local.addr)) {
     316        if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
    352317                /* 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;
     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;
    358322               
    359323                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    … …  
    363327                        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_sendto: Failed to "
    364328                            "determine local address.");
    365                         goto out;
    366                 }
    367                
    368                 socket->assoc->ident.local.addr = loc_addr;
     329                        return;
     330                }
     331               
     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);
    369335        }
    370336       
    … …  
    385351                        length = UDP_FRAGMENT_SIZE;
    386352               
     353                uint8_t buffer[UDP_FRAGMENT_SIZE];
    387354                int rc = async_data_write_finalize(wcallid, buffer, length);
    388355                if (rc != EOK) {
    … …  
    393360               
    394361                udp_error_t urc =
    395                     udp_uc_send(socket->assoc, fsocket_ptr, buffer, length, 0);
     362                    udp_uc_send(socket->assoc, fsock_ptr, buffer, length, 0);
    396363               
    397364                switch (urc) {
    … …  
    428395       
    429396out:
    430         if (addr6 != NULL)
    431                 free(addr6);
    432        
    433         free(buffer);
     397        if (addr != NULL)
     398                free(addr);
    434399}
    435400
    436401static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    437402{
     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
    438416        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);
     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);
    444422        if (sock_core == NULL) {
    445423                async_answer_0(callid, ENOTSOCK);
    446424                return;
    447425        }
    448        
    449         udp_sockdata_t *socket =
    450             (udp_sockdata_t *) sock_core->specific_data;
    451        
     426
     427        socket = (udp_sockdata_t *)sock_core->specific_data;
    452428        fibril_mutex_lock(&socket->lock);
    453        
     429
    454430        if (socket->assoc == NULL) {
    455431                fibril_mutex_unlock(&socket->lock);
    … …  
    457433                return;
    458434        }
    459        
     435
     436        (void)flags;
     437
    460438        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
    461        
    462439        fibril_mutex_lock(&socket->recv_buffer_lock);
    463        
    464         while ((socket->recv_buffer_used == 0) &&
    465             (socket->recv_error == UDP_EOK)) {
     440        while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
    466441                log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
    467442                fibril_condvar_wait(&socket->recv_buffer_cv,
    468443                    &socket->recv_buffer_lock);
    469444        }
    470        
     445
    471446        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        
     447
     448        rsock = socket->recv_fsock;
     449        data_len = socket->recv_buffer_used;
     450        urc = socket->recv_error;
     451
    476452        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len);
    477        
    478         int rc;
    479        
     453
    480454        switch (urc) {
    481455        case UDP_EOK:
    … …  
    492466                assert(false);
    493467        }
    494        
     468
    495469        log_msg(LOG_DEFAULT, LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
    496        
    497470        if (rc != EOK) {
    498471                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    501474                return;
    502475        }
    503        
    504         ipc_callid_t rcallid;
    505         size_t addr_size = 0;
    506        
     476
    507477        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:
     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)) {
    571485                        fibril_mutex_unlock(&socket->recv_buffer_lock);
    572486                        fibril_mutex_unlock(&socket->lock);
    … …  
    574488                        return;
    575489                }
    576         }
    577        
     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
    578504        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
    579        
    580         size_t length;
    581505        if (!async_data_read_receive(&rcallid, &length)) {
    582506                fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    585509                return;
    586510        }
    587        
     511
    588512        if (length > data_len)
    589513                length = data_len;
    590        
     514
    591515        log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
    592        
    593516        rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
    594        
    595         if ((length < data_len) && (rc == EOK))
     517
     518        if (length < data_len && rc == EOK)
    596519                rc = EOVERFLOW;
    597        
     520
    598521        log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
    599        
    600         ipc_call_t answer;
    601        
    602522        IPC_SET_ARG2(answer, 0);
    603523        SOCKET_SET_READ_DATA_LENGTH(answer, length);
    604         SOCKET_SET_ADDRESS_LENGTH(answer, addr_size);
     524        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
    605525        async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
    606526            IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
    607        
     527
    608528        socket->recv_buffer_used = 0;
    609        
     529
    610530        fibril_condvar_broadcast(&socket->recv_buffer_cv);
    611531        fibril_mutex_unlock(&socket->recv_buffer_lock);
    … …  
    682602        while (true) {
    683603                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] wait for rcv buffer empty()");
    684                 while ((sock->recv_buffer_used != 0) && (sock->sock_core != NULL)) {
     604                while (sock->recv_buffer_used != 0 && sock->sock_core != NULL) {
    685605                        fibril_condvar_wait(&sock->recv_buffer_cv,
    686606                            &sock->recv_buffer_lock);
    … …  
    703623                        log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
    704624                        fibril_condvar_broadcast(&sock->recv_buffer_cv);
    705                         fibril_mutex_unlock(&sock->recv_buffer_lock);
    706625                        break;
    707626                }
Note: See TracChangeset for help on using the changeset viewer.