Changeset 25eec4ef in mainline for uspace/srv/net


Ignore:
Timestamp:
2013-04-19T18:38:18Z (13 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6d717a4
Parents:
a1e2df13 (diff), 289cb7dd (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 chages.

Location:
uspace/srv/net
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/dnsres/dns_msg.h

    ra1e2df13 r25eec4ef  
    3838
    3939#include <adt/list.h>
    40 #include <bool.h>
     40#include <stdbool.h>
    4141#include <stdint.h>
    4242#include "dns_std.h"

  • uspace/srv/net/dnsres/dns_type.h

    ra1e2df13 r25eec4ef  
    3838
    3939#include <adt/list.h>
    40 #include <bool.h>
     40#include <stdbool.h>
    4141#include <stdint.h>
    4242#include "dns_std.h"

  • uspace/srv/net/dnsres/transport.c

    ra1e2df13 r25eec4ef  
    5757        addr.sin_family = AF_INET;
    5858        addr.sin_port = htons(53);
    59         addr.sin_addr.s_addr = htonl((10 << 24) | (0 << 16) | (0 << 8) | 1);
     59        addr.sin_addr.s_addr = htonl((10 << 24) | (0 << 16) | (0 << 8) | 138);
    6060
    6161        laddr.sin_family = AF_INET;

  • uspace/srv/net/ethip/ethip.c

    ra1e2df13 r25eec4ef  
    221221        case ETYPE_IP:
    222222                log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU");
    223                 sdu.lsrc.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 1;
    224                 sdu.ldest.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 4;
     223                sdu.lsrc.ipv4 = 0;
     224                sdu.ldest.ipv4 = 0;
    225225                sdu.data = frame.data;
    226226                sdu.size = frame.size;

  • uspace/srv/net/ethip/ethip_nic.c

    ra1e2df13 r25eec4ef  
    3737#include <adt/list.h>
    3838#include <async.h>
    39 #include <bool.h>
     39#include <stdbool.h>
    4040#include <errno.h>
    4141#include <fibril_synch.h>

  • uspace/srv/net/inetsrv/inet_link.c

    ra1e2df13 r25eec4ef  
    3535 */
    3636
    37 #include <bool.h>
     37#include <stdbool.h>
    3838#include <errno.h>
    3939#include <fibril_synch.h>
    … …  
    202202                first = 0;
    203203        } else {
    204                 addr->naddr.ipv4 = (10 << 24) + (0 << 16) + (0 << 8) + 2;
     204                addr->naddr.ipv4 = (192 << 24) + (168 << 16) + (0 << 8) + 4;
    205205        }
    206206        addr->naddr.bits = 24;

  • uspace/srv/net/inetsrv/inetsrv.c

    ra1e2df13 r25eec4ef  
    9898        }
    9999       
    100         rc = inet_link_discovery_start();
     100        inet_sroute_t *sroute = inet_sroute_new();
     101        if (sroute == NULL) {
     102                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed creating default route (%d).", rc);
     103                return ENOMEM;
     104        }
     105
     106        sroute->dest.ipv4 = 0;
     107        sroute->dest.bits = 0;
     108        sroute->router.ipv4 = (192 << 24) | (168 << 16) | (0 << 8) | 1;
     109        sroute->name = str_dup("default");
     110        inet_sroute_add(sroute);
     111
     112        rc = inet_link_discovery_start();
    101113        if (rc != EOK)
    102114                return EEXIST;

  • uspace/srv/net/inetsrv/inetsrv.h

    ra1e2df13 r25eec4ef  
    3939
    4040#include <adt/list.h>
    41 #include <bool.h>
     41#include <stdbool.h>
    4242#include <inet/iplink.h>
    4343#include <ipc/loc.h>

  • uspace/srv/net/tcp/conn.c

    ra1e2df13 r25eec4ef  
    3636
    3737#include <adt/list.h>
    38 #include <bool.h>
     38#include <stdbool.h>
    3939#include <errno.h>
    4040#include <io/log.h>
    … …  
    354354{
    355355        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
    356 
     356       
     357        log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare conn (f:(%x,%u), l:(%x,%u))",
     358            sp->foreign.addr.ipv4, sp->foreign.port,
     359            sp->local.addr.ipv4, sp->local.port);
     360       
    357361        fibril_mutex_lock(&conn_list_lock);
    358 
     362       
    359363        list_foreach(conn_list, link) {
    360364                tcp_conn_t *conn = list_get_instance(link, tcp_conn_t, link);
    361365                tcp_sockpair_t *csp = &conn->ident;
    362                 log_msg(LOG_DEFAULT, LVL_DEBUG2, "compare with conn (f:(%x,%u), l:(%x,%u))",
     366               
     367                log_msg(LOG_DEFAULT, LVL_DEBUG2, " - with (f:(%x,%u), l:(%x,%u))",
    363368                    csp->foreign.addr.ipv4, csp->foreign.port,
    364369                    csp->local.addr.ipv4, csp->local.port);
     370               
    365371                if (tcp_sockpair_match(sp, csp)) {
    366372                        tcp_conn_addref(conn);
    … …  
    369375                }
    370376        }
    371 
     377       
    372378        fibril_mutex_unlock(&conn_list_lock);
    373379        return NULL;

  • uspace/srv/net/tcp/conn.h

    ra1e2df13 r25eec4ef  
    3636#define CONN_H
    3737
    38 #include <bool.h>
     38#include <stdbool.h>
    3939#include "tcp_type.h"
    4040

  • uspace/srv/net/tcp/seq_no.c

    ra1e2df13 r25eec4ef  
    3636
    3737#include <assert.h>
    38 #include <bool.h>
     38#include <stdbool.h>
    3939#include <sys/types.h>
    4040#include "seq_no.h"

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

    ra1e2df13 r25eec4ef  
    203203{
    204204        int rc;
    205         struct sockaddr *addr;
    206         size_t addr_len;
     205        struct sockaddr_in *addr;
     206        size_t addr_size;
    207207        socket_core_t *sock_core;
    208208        tcp_sockdata_t *socket;
    209 
     209       
    210210        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_bind()");
    211211        log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
    212         rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
     212       
     213        addr = NULL;
     214       
     215        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
    213216        if (rc != EOK) {
    214217                async_answer_0(callid, rc);
    215                 return;
    216         }
    217 
     218                goto out;
     219        }
     220       
     221        if (addr_size != sizeof(struct sockaddr_in)) {
     222                async_answer_0(callid, EINVAL);
     223                goto out;
     224        }
     225       
    218226        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    219227        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    220             addr, addr_len, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     228            addr, addr_size, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    221229            last_used_port);
    222230        if (rc != EOK) {
    223231                async_answer_0(callid, rc);
    224                 return;
    225         }
    226 
     232                goto out;
     233        }
     234       
    227235        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    228236        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
    229         if (sock_core != NULL) {
    230                 socket = (tcp_sockdata_t *)sock_core->specific_data;
    231                 /* XXX Anything to do? */
    232                 (void) socket;
    233         }
    234 
     237        if (sock_core == NULL) {
     238                async_answer_0(callid, ENOENT);
     239                goto out;
     240        }
     241       
     242        socket = (tcp_sockdata_t *)sock_core->specific_data;
     243        /* XXX Anything to do? */
     244        (void) socket;
     245       
    235246        log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
    236247        async_answer_0(callid, EOK);
     248       
     249out:
     250        if (addr != NULL)
     251                free(addr);
    237252}
    238253
    … …  
    249264        tcp_sock_lconn_t *lconn;
    250265        int i;
     266        int rc;
    251267
    252268        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_listen()");
    … …  
    268284                return;
    269285        }
    270 
    271         socket = (tcp_sockdata_t *)sock_core->specific_data;
    272 
     286       
     287        if (sock_core->port <= 0) {
     288                rc = socket_bind_free_port(&gsock, sock_core,
     289                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     290                    last_used_port);
     291                if (rc != EOK) {
     292                        async_answer_0(callid, rc);
     293                        return;
     294                }
     295               
     296                last_used_port = sock_core->port;
     297        }
     298       
     299        socket = (tcp_sockdata_t *) sock_core->specific_data;
     300       
    273301        /*
    274302         * Prepare @c backlog listening connections.
    275303         */
    276304        fibril_mutex_lock(&socket->lock);
    277 
     305       
    278306        socket->backlog = backlog;
    279307        socket->lconn = calloc(backlog, sizeof(tcp_conn_t *));
    … …  
    283311                return;
    284312        }
    285 
     313       
    286314        log_msg(LOG_DEFAULT, LVL_DEBUG, " - open connections");
    287 
     315       
    288316        lsocket.addr.ipv4 = TCP_IPV4_ANY;
    289317        lsocket.port = sock_core->port;
    290318        fsocket.addr.ipv4 = TCP_IPV4_ANY;
    291319        fsocket.port = TCP_PORT_ANY;
    292 
     320       
    293321        for (i = 0; i < backlog; i++) {
    294322
    … …  
    362390                        return;
    363391                }
    364 
     392               
    365393                last_used_port = sock_core->port;
    366394        }
    … …  
    441469                return;
    442470        }
     471       
     472        if (sock_core->port <= 0) {
     473                rc = socket_bind_free_port(&gsock, sock_core,
     474                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     475                    last_used_port);
     476                if (rc != EOK) {
     477                        async_answer_0(callid, rc);
     478                        return;
     479                }
     480               
     481                last_used_port = sock_core->port;
     482        }
    443483
    444484        socket = (tcp_sockdata_t *)sock_core->specific_data;

  • uspace/srv/net/tcp/tcp_type.h

    ra1e2df13 r25eec4ef  
    3838#include <adt/list.h>
    3939#include <async.h>
    40 #include <bool.h>
     40#include <stdbool.h>
    4141#include <fibril.h>
    4242#include <fibril_synch.h>

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

    ra1e2df13 r25eec4ef  
    3636
    3737#include <adt/list.h>
    38 #include <bool.h>
     38#include <stdbool.h>
    3939#include <fibril_synch.h>
    4040#include <io/log.h>
    … …  
    200200/** Set local socket in association.
    201201 *
    202  * @param assoc         Association
    203  * @param fsock         Foreign socket (deeply copied)
     202 * @param assoc Association
     203 * @param lsock Local socket (deeply copied)
     204 *
    204205 */
    205206void udp_assoc_set_local(udp_assoc_t *assoc, udp_sock_t *lsock)
    … …  
    208209        fibril_mutex_lock(&assoc->lock);
    209210        assoc->ident.local = *lsock;
     211        fibril_mutex_unlock(&assoc->lock);
     212}
     213
     214/** Set local port in association.
     215 *
     216 * @param assoc Association
     217 * @param lport Local port
     218 *
     219 */
     220void udp_assoc_set_local_port(udp_assoc_t *assoc, uint16_t lport)
     221{
     222        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_assoc_set_local(%p, %" PRIu16 ")", assoc, lport);
     223        fibril_mutex_lock(&assoc->lock);
     224        assoc->ident.local.port = lport;
    210225        fibril_mutex_unlock(&assoc->lock);
    211226}
    … …  
    425440}
    426441
    427 
    428442/**
    429443 * @}

  • uspace/srv/net/udp/assoc.h

    ra1e2df13 r25eec4ef  
    4747extern void udp_assoc_set_foreign(udp_assoc_t *, udp_sock_t *);
    4848extern void udp_assoc_set_local(udp_assoc_t *, udp_sock_t *);
     49extern void udp_assoc_set_local_port(udp_assoc_t *, uint16_t);
    4950extern int udp_assoc_send(udp_assoc_t *, udp_sock_t *, udp_msg_t *);
    5051extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, udp_sock_t *);

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

    ra1e2df13 r25eec4ef  
    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);
    … …  
    177177                goto out;
    178178        }
    179 
     179       
     180        if (addr_size != sizeof(struct sockaddr_in)) {
     181                async_answer_0(callid, EINVAL);
     182                goto out;
     183        }
     184       
    180185        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
    181186        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
    … …  
    186191                goto out;
    187192        }
    188 
    189         if (addr_size != sizeof(struct sockaddr_in)) {
    190                 async_answer_0(callid, EINVAL);
    191                 goto out;
    192         }
    193 
     193       
    194194        log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
    195195        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
    … …  
    249249static void udp_sock_sendto(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    250250{
    251         int socket_id;
    252         int fragments;
    253         int index;
    254         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 
    266251        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()");
    267 
    268         addr = NULL;
    269 
     252       
     253        struct sockaddr_in *addr = NULL;
     254        udp_sock_t fsock;
     255        udp_sock_t *fsock_ptr;
     256       
    270257        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
    271                 rc = async_data_write_accept((void **) &addr, false,
     258                size_t addr_size;
     259                int rc = async_data_write_accept((void **) &addr, false,
    272260                    0, 0, 0, &addr_size);
    273261                if (rc != EOK) {
    … …  
    275263                        goto out;
    276264                }
    277 
     265               
    278266                if (addr_size != sizeof(struct sockaddr_in)) {
    279267                        async_answer_0(callid, EINVAL);
    280268                        goto out;
    281269                }
    282 
     270               
    283271                fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
    284272                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);
     273                fsock_ptr = &fsock;
     274        } else
     275                fsock_ptr = NULL;
     276       
     277        int socket_id = SOCKET_GET_SOCKET_ID(call);
     278       
    292279        SOCKET_GET_FLAGS(call);
    293 
    294         sock_core = socket_cores_find(&client->sockets, socket_id);
     280       
     281        socket_core_t *sock_core =
     282            socket_cores_find(&client->sockets, socket_id);
    295283        if (sock_core == NULL) {
    296284                async_answer_0(callid, ENOTSOCK);
    297285                goto out;
    298286        }
    299 
    300         if (sock_core->port == 0) {
     287       
     288        udp_sockdata_t *socket =
     289            (udp_sockdata_t *) sock_core->specific_data;
     290       
     291        if (sock_core->port <= 0) {
    301292                /* 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);
     293                int rc = socket_bind_free_port(&gsock, sock_core,
     294                    UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, last_used_port);
    305295                if (rc != EOK) {
    306296                        async_answer_0(callid, rc);
    307297                        goto out;
    308298                }
    309         }
    310 
    311         socket = (udp_sockdata_t *)sock_core->specific_data;
     299               
     300                assert(sock_core->port > 0);
     301               
     302                udp_error_t urc = udp_uc_set_local_port(socket->assoc,
     303                    sock_core->port);
     304               
     305                if (urc != UDP_EOK) {
     306                        // TODO: better error handling
     307                        async_answer_0(callid, EINTR);
     308                        goto out;
     309                }
     310               
     311                last_used_port = sock_core->port;
     312        }
     313       
    312314        fibril_mutex_lock(&socket->lock);
    313 
     315       
    314316        if (socket->assoc->ident.local.addr.ipv4 == UDP_IPV4_ANY) {
    315317                /* Determine local IP address */
    316318                inet_addr_t loc_addr, rem_addr;
    317 
    318                 rem_addr.ipv4 = fsockp ? fsock.addr.ipv4 :
     319               
     320                rem_addr.ipv4 = fsock_ptr ? fsock.addr.ipv4 :
    319321                    socket->assoc->ident.foreign.addr.ipv4;
    320 
    321                 rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
     322               
     323                int rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    322324                if (rc != EOK) {
    323325                        fibril_mutex_unlock(&socket->lock);
    … …  
    327329                        return;
    328330                }
    329 
     331               
    330332                socket->assoc->ident.local.addr.ipv4 = loc_addr.ipv4;
    331333                log_msg(LOG_DEFAULT, LVL_DEBUG, "Local IP address is %x",
    332334                    socket->assoc->ident.local.addr.ipv4);
    333335        }
    334 
    335 
     336       
    336337        assert(socket->assoc != NULL);
    337 
    338         for (index = 0; index < fragments; index++) {
     338       
     339        int fragments = SOCKET_GET_DATA_FRAGMENTS(call);
     340        for (int index = 0; index < fragments; index++) {
     341                ipc_callid_t wcallid;
     342                size_t length;
     343               
    339344                if (!async_data_write_receive(&wcallid, &length)) {
    340345                        fibril_mutex_unlock(&socket->lock);
    … …  
    342347                        goto out;
    343348                }
    344 
     349               
    345350                if (length > UDP_FRAGMENT_SIZE)
    346351                        length = UDP_FRAGMENT_SIZE;
    347 
    348                 rc = async_data_write_finalize(wcallid, buffer, length);
     352               
     353                uint8_t buffer[UDP_FRAGMENT_SIZE];
     354                int rc = async_data_write_finalize(wcallid, buffer, length);
    349355                if (rc != EOK) {
    350356                        fibril_mutex_unlock(&socket->lock);
    … …  
    352358                        goto out;
    353359                }
    354 
    355                 urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
    356 
     360               
     361                udp_error_t urc =
     362                    udp_uc_send(socket->assoc, fsock_ptr, buffer, length, 0);
     363               
    357364                switch (urc) {
    358365                case UDP_EOK:
    … …  
    360367                        break;
    361368                case UDP_ENORES:
    362                         rc = ENOTCONN;
     369                        rc = ENOMEM;
    363370                        break;
    364371                case UDP_EUNSPEC:
    … …  
    371378                        assert(false);
    372379                }
    373 
     380               
    374381                if (rc != EOK) {
    375382                        fibril_mutex_unlock(&socket->lock);
    … …  
    378385                }
    379386        }
     387       
     388        ipc_call_t answer;
    380389       
    381390        IPC_SET_ARG1(answer, 0);
    … …  
    526535static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
    527536{
    528         int socket_id;
    529         socket_core_t *sock_core;
    530         udp_sockdata_t *socket;
    531         int rc;
    532 
    533537        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);
     538        int socket_id = SOCKET_GET_SOCKET_ID(call);
     539
     540        socket_core_t *sock_core =
     541            socket_cores_find(&client->sockets, socket_id);
    537542        if (sock_core == NULL) {
    538543                async_answer_0(callid, ENOTSOCK);
    … …  
    540545        }
    541546
    542         socket = (udp_sockdata_t *)sock_core->specific_data;
     547        udp_sockdata_t *socket =
     548            (udp_sockdata_t *) sock_core->specific_data;
    543549        fibril_mutex_lock(&socket->lock);
    544550
    … …  
    550556        udp_uc_reset(socket->assoc);
    551557
    552         rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
     558        int rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    553559            udp_free_sock_data);
    554560        if (rc != EOK) {
    … …  
    595601                            &sock->recv_buffer_lock);
    596602                }
    597 
     603               
    598604                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] call udp_uc_receive()");
    599605                urc = udp_uc_receive(sock->assoc, sock->recv_buffer,
    … …  
    606612                        udp_sock_notify_data(sock->sock_core);
    607613
     614               
     615                udp_sock_notify_data(sock->sock_core);
     616               
    608617                if (urc != UDP_EOK) {
    609618                        log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
    … …  
    611620                        break;
    612621                }
    613 
     622               
    614623                log_msg(LOG_DEFAULT, LVL_DEBUG, "[] got data - broadcast recv_buffer_cv");
    615 
     624               
    616625                sock->recv_buffer_used = rcvd;
    617626                fibril_condvar_broadcast(&sock->recv_buffer_cv);

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

    ra1e2df13 r25eec4ef  
    6868{
    6969        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_local(%p, %p)", assoc, lsock);
     70       
     71        udp_assoc_set_local(assoc, lsock);
     72        return UDP_EOK;
     73}
    7074
    71         udp_assoc_set_local(assoc, lsock);
     75udp_error_t udp_uc_set_local_port(udp_assoc_t *assoc, uint16_t lport)
     76{
     77        log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_uc_set_local(%p, %" PRIu16 ")", assoc, lport);
     78       
     79        udp_assoc_set_local_port(assoc, lport);
    7280        return UDP_EOK;
    7381}

  • uspace/srv/net/udp/ucall.h

    ra1e2df13 r25eec4ef  
    4242extern udp_error_t udp_uc_set_foreign(udp_assoc_t *, udp_sock_t *);
    4343extern udp_error_t udp_uc_set_local(udp_assoc_t *, udp_sock_t *);
     44extern udp_error_t udp_uc_set_local_port(udp_assoc_t *, uint16_t);
    4445extern udp_error_t udp_uc_send(udp_assoc_t *, udp_sock_t *, void *, size_t,
    4546    xflags_t);

  • uspace/srv/net/udp/udp_type.h

    ra1e2df13 r25eec4ef  
    6868};
    6969
    70 enum tcp_port {
     70enum udp_port {
    7171        UDP_PORT_ANY = 0
    7272};
Note: See TracChangeset for help on using the changeset viewer.