Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset e33bceb in mainline


Ignore:
Timestamp:
2012-04-03T07:17:08Z (10 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
4794417
Parents:
66a272f8
Message:

Implement socket provider interface in UDP to UDP user calls.

Location:
uspace/srv/udp
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/udp/Makefile

    r66a272f8 re33bceb  
    3636        sock.c \
    3737        pdu.c \
     38        ucall.c \
    3839        udp.c \
    3940        udp_inet.c
  • uspace/srv/udp/sock.c

    r66a272f8 re33bceb  
    11/*
     2 * Copyright (c) 2008 Lukas Mejdrech
    23 * Copyright (c) 2012 Jiri Svoboda
    34 * All rights reserved.
     
    3536 */
    3637
     38#include <async.h>
     39#include <byteorder.h>
    3740#include <errno.h>
     41#include <inet/inet.h>
     42#include <io/log.h>
     43#include <ipc/services.h>
     44#include <ipc/socket.h>
     45#include <net/modules.h>
     46#include <net/socket.h>
     47#include <ns.h>
    3848
    3949#include "sock.h"
     50#include "std.h"
     51#include "udp_type.h"
     52#include "ucall.h"
     53
     54#define FRAGMENT_SIZE 1024
     55
     56/** Free ports pool start. */
     57#define UDP_FREE_PORTS_START            1025
     58
     59/** Free ports pool end. */
     60#define UDP_FREE_PORTS_END              65535
     61
     62static int last_used_port = UDP_FREE_PORTS_START - 1;
     63static socket_ports_t gsock;
     64
     65static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    4066
    4167int udp_sock_init(void)
    4268{
     69        int rc;
     70
     71        socket_ports_initialize(&gsock);
     72
     73        async_set_client_connection(udp_sock_connection);
     74
     75        rc = service_register(SERVICE_UDP);
     76        if (rc != EOK)
     77                return EEXIST;
     78
    4379        return EOK;
     80}
     81
     82static void udp_free_sock_data(socket_core_t *sock_core)
     83{
     84        udp_sockdata_t *socket;
     85
     86        socket = (udp_sockdata_t *)sock_core->specific_data;
     87        (void)socket;
     88}
     89
     90static void udp_sock_notify_data(socket_core_t *sock_core)
     91{
     92        log_msg(LVL_DEBUG, "udp_sock_notify_data(%d)", sock_core->socket_id);
     93        async_exch_t *exch = async_exchange_begin(sock_core->sess);
     94        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t)sock_core->socket_id,
     95            FRAGMENT_SIZE, 0, 0, 1);
     96        async_exchange_end(exch);
     97}
     98
     99static void udp_sock_socket(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     100{
     101        udp_sockdata_t *sock;
     102        socket_core_t *sock_core;
     103        int sock_id;
     104        int rc;
     105        ipc_call_t answer;
     106
     107        log_msg(LVL_DEBUG, "udp_sock_socket()");
     108        sock = calloc(sizeof(udp_sockdata_t), 1);
     109        if (sock == NULL) {
     110                async_answer_0(callid, ENOMEM);
     111                return;
     112        }
     113
     114        fibril_mutex_initialize(&sock->lock);
     115        sock->client = client;
     116        sock->laddr.ipv4 = UDP_IPV4_ANY;
     117
     118        rc = udp_uc_create(&sock->assoc);
     119        if (rc != EOK) {
     120                udp_uc_destroy(sock->assoc);
     121                free(sock);
     122                async_answer_0(callid, rc);
     123                return;
     124        }
     125
     126        sock_id = SOCKET_GET_SOCKET_ID(call);
     127        rc = socket_create(&client->sockets, client->sess, sock, &sock_id);
     128        if (rc != EOK) {
     129                async_answer_0(callid, rc);
     130                return;
     131        }
     132
     133        sock_core = socket_cores_find(&client->sockets, sock_id);
     134        assert(sock_core != NULL);
     135        sock->sock_core = sock_core;
     136
     137
     138        refresh_answer(&answer, NULL);
     139        SOCKET_SET_SOCKET_ID(answer, sock_id);
     140
     141        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     142        SOCKET_SET_HEADER_SIZE(answer, sizeof(udp_header_t));
     143        answer_call(callid, EOK, &answer, 3);
     144}
     145
     146static void udp_sock_bind(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     147{
     148        int rc;
     149        struct sockaddr_in *addr;
     150        size_t addr_size;
     151        socket_core_t *sock_core;
     152        udp_sockdata_t *socket;
     153        udp_sock_t fsock;
     154        udp_error_t urc;
     155
     156        log_msg(LVL_DEBUG, "udp_sock_bind()");
     157        log_msg(LVL_DEBUG, " - async_data_write_accept");
     158
     159        addr = NULL;
     160
     161        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
     162        if (rc != EOK) {
     163                async_answer_0(callid, rc);
     164                goto out;
     165        }
     166
     167        log_msg(LVL_DEBUG, " - call socket_bind");
     168        rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
     169            addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
     170            last_used_port);
     171        if (rc != EOK) {
     172                async_answer_0(callid, rc);
     173                goto out;
     174        }
     175
     176        if (addr_size != sizeof(struct sockaddr_in)) {
     177                async_answer_0(callid, EINVAL);
     178                goto out;
     179        }
     180
     181        log_msg(LVL_DEBUG, " - call socket_cores_find");
     182        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
     183        if (sock_core == NULL) {
     184                async_answer_0(callid, ENOENT);
     185                goto out;
     186        }
     187
     188        socket = (udp_sockdata_t *)sock_core->specific_data;
     189
     190        fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     191        fsock.port = uint16_t_be2host(sock_core->port);
     192        urc = udp_uc_set_local(socket->assoc, &fsock);
     193
     194        switch (urc) {
     195        case UDP_EOK:
     196                rc = EOK;
     197                break;
     198/*      case TCP_ENOTEXIST:
     199                rc = ENOTCONN;
     200                break;
     201        case TCP_ECLOSING:
     202                rc = ENOTCONN;
     203                break;
     204        case TCP_ERESET:
     205                rc = ECONNABORTED;
     206                break;*/
     207        default:
     208                assert(false);
     209        }
     210
     211        log_msg(LVL_DEBUG, " - success");
     212        async_answer_0(callid, rc);
     213out:
     214        if (addr != NULL)
     215                free(addr);
     216}
     217
     218static void udp_sock_listen(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     219{
     220        log_msg(LVL_DEBUG, "udp_sock_listen()");
     221        async_answer_0(callid, ENOTSUP);
     222}
     223
     224static void udp_sock_connect(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     225{
     226        log_msg(LVL_DEBUG, "udp_sock_connect()");
     227        async_answer_0(callid, ENOTSUP);
     228}
     229
     230static void udp_sock_accept(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     231{
     232        log_msg(LVL_DEBUG, "udp_sock_accept()");
     233        async_answer_0(callid, ENOTSUP);
     234}
     235
     236static void udp_sock_sendto(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     237{
     238        int socket_id;
     239        int fragments;
     240        int index;
     241        struct sockaddr_in *addr;
     242        size_t addr_size;
     243        socket_core_t *sock_core;
     244        udp_sockdata_t *socket;
     245        udp_sock_t fsock, *fsockp;
     246        ipc_call_t answer;
     247        ipc_callid_t wcallid;
     248        size_t length;
     249        uint8_t buffer[FRAGMENT_SIZE];
     250        udp_error_t urc;
     251        int rc;
     252
     253        log_msg(LVL_DEBUG, "udp_sock_send()");
     254
     255        addr = NULL;
     256
     257        if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
     258                rc = async_data_write_accept((void **) &addr, false,
     259                    0, 0, 0, &addr_size);
     260                if (rc != EOK) {
     261                        async_answer_0(callid, rc);
     262                        goto out;
     263                }
     264
     265                if (addr_size != sizeof(struct sockaddr_in)) {
     266                        async_answer_0(callid, EINVAL);
     267                        goto out;
     268                }
     269
     270                fsock.addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     271                fsock.port = uint16_t_be2host(addr->sin_port);
     272                fsockp = &fsock;
     273        } else {
     274                fsockp = NULL;
     275        }
     276
     277        socket_id = SOCKET_GET_SOCKET_ID(call);
     278        fragments = SOCKET_GET_DATA_FRAGMENTS(call);
     279        SOCKET_GET_FLAGS(call);
     280
     281        sock_core = socket_cores_find(&client->sockets, socket_id);
     282        if (sock_core == NULL) {
     283                async_answer_0(callid, ENOTSOCK);
     284                goto out;
     285        }
     286
     287        if (sock_core->port == 0) {
     288                /* Implicitly bind socket */
     289                rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
     290                    addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
     291                    last_used_port);
     292                if (rc != EOK) {
     293                        async_answer_0(callid, rc);
     294                        goto out;
     295                }
     296        }
     297
     298        socket = (udp_sockdata_t *)sock_core->specific_data;
     299        fibril_mutex_lock(&socket->lock);
     300
     301        assert(socket->assoc != NULL);
     302
     303        for (index = 0; index < fragments; index++) {
     304                if (!async_data_write_receive(&wcallid, &length)) {
     305                        fibril_mutex_unlock(&socket->lock);
     306                        async_answer_0(callid, EINVAL);
     307                        goto out;
     308                }
     309
     310                if (length > FRAGMENT_SIZE)
     311                        length = FRAGMENT_SIZE;
     312
     313                rc = async_data_write_finalize(wcallid, buffer, length);
     314                if (rc != EOK) {
     315                        fibril_mutex_unlock(&socket->lock);
     316                        async_answer_0(callid, rc);
     317                        goto out;
     318                }
     319
     320                urc = udp_uc_send(socket->assoc, fsockp, buffer, length, 0);
     321
     322                switch (urc) {
     323                case UDP_EOK:
     324                        rc = EOK;
     325                        break;
     326/*              case TCP_ENOTEXIST:
     327                        rc = ENOTCONN;
     328                        break;
     329                case TCP_ECLOSING:
     330                        rc = ENOTCONN;
     331                        break;
     332                case TCP_ERESET:
     333                        rc = ECONNABORTED;
     334                        break;*/
     335                default:
     336                        assert(false);
     337                }
     338
     339                if (rc != EOK) {
     340                        fibril_mutex_unlock(&socket->lock);
     341                        async_answer_0(callid, rc);
     342                        goto out;
     343                }
     344        }
     345
     346        refresh_answer(&answer, NULL);
     347        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, FRAGMENT_SIZE);
     348        answer_call(callid, EOK, &answer, 2);
     349        fibril_mutex_unlock(&socket->lock);
     350out:
     351        if (addr != NULL)
     352                free(addr);
     353}
     354
     355static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     356{
     357        int socket_id;
     358        int flags;
     359        size_t addr_length, length;
     360        socket_core_t *sock_core;
     361        udp_sockdata_t *socket;
     362        ipc_call_t answer;
     363        ipc_callid_t rcallid;
     364        uint8_t buffer[FRAGMENT_SIZE];
     365        size_t data_len;
     366        xflags_t xflags;
     367        udp_error_t urc;
     368        struct sockaddr_in addr;
     369        udp_sock_t rsock;
     370        int rc;
     371
     372        log_msg(LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
     373
     374        socket_id = SOCKET_GET_SOCKET_ID(call);
     375        flags = SOCKET_GET_FLAGS(call);
     376
     377        sock_core = socket_cores_find(&client->sockets, socket_id);
     378        if (sock_core == NULL) {
     379                async_answer_0(callid, ENOTSOCK);
     380                return;
     381        }
     382
     383        socket = (udp_sockdata_t *)sock_core->specific_data;
     384        fibril_mutex_lock(&socket->lock);
     385
     386        if (socket->assoc == NULL) {
     387                fibril_mutex_unlock(&socket->lock);
     388                async_answer_0(callid, ENOTCONN);
     389                return;
     390        }
     391
     392        (void)flags;
     393
     394        urc = udp_uc_receive(socket->assoc, buffer, FRAGMENT_SIZE, &data_len,
     395            &xflags, &rsock);
     396        log_msg(LVL_DEBUG, "**** udp_uc_receive done");
     397
     398        switch (urc) {
     399        case UDP_EOK:
     400                rc = EOK;
     401                break;
     402/*      case TCP_ENOTEXIST:
     403        case TCP_ECLOSING:
     404                rc = ENOTCONN;
     405                break;
     406        case TCP_ERESET:
     407                rc = ECONNABORTED;
     408                break;*/
     409        default:
     410                assert(false);
     411        }
     412
     413        log_msg(LVL_DEBUG, "**** udp_uc_receive -> %d", rc);
     414        if (rc != EOK) {
     415                fibril_mutex_unlock(&socket->lock);
     416                async_answer_0(callid, rc);
     417                return;
     418        }
     419
     420        if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
     421                /* Fill addr */
     422                addr.sin_family = AF_INET;
     423                addr.sin_addr.s_addr = host2uint32_t_be(rsock.addr.ipv4);
     424                addr.sin_port = host2uint16_t_be(rsock.port);
     425
     426                log_msg(LVL_DEBUG, "addr read receive");
     427                if (!async_data_read_receive(&rcallid, &addr_length)) {
     428                        fibril_mutex_unlock(&socket->lock);
     429                        async_answer_0(callid, EINVAL);
     430                        return;
     431                }
     432
     433                if (addr_length > sizeof(addr))
     434                        addr_length = sizeof(addr);
     435
     436                log_msg(LVL_DEBUG, "addr read finalize");
     437                rc = async_data_read_finalize(rcallid, &addr, addr_length);
     438                if (rc != EOK) {
     439                        fibril_mutex_unlock(&socket->lock);
     440                        async_answer_0(callid, EINVAL);
     441                        return;
     442                }
     443        }
     444
     445        log_msg(LVL_DEBUG, "data read receive");
     446        if (!async_data_read_receive(&rcallid, &length)) {
     447                fibril_mutex_unlock(&socket->lock);
     448                async_answer_0(callid, EINVAL);
     449                return;
     450        }
     451
     452        if (length > data_len)
     453                length = data_len;
     454
     455        log_msg(LVL_DEBUG, "data read finalize");
     456        rc = async_data_read_finalize(rcallid, buffer, length);
     457
     458        if (length < data_len && rc == EOK)
     459                rc = EOVERFLOW;
     460
     461        SOCKET_SET_READ_DATA_LENGTH(answer, length);
     462        answer_call(callid, EOK, &answer, 1);
     463
     464        /* Push one fragment notification to client's queue */
     465        udp_sock_notify_data(sock_core);
     466        fibril_mutex_unlock(&socket->lock);
     467}
     468
     469static void udp_sock_close(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     470{
     471        int socket_id;
     472        socket_core_t *sock_core;
     473        udp_sockdata_t *socket;
     474        int rc;
     475
     476        log_msg(LVL_DEBUG, "tcp_sock_close()");
     477        socket_id = SOCKET_GET_SOCKET_ID(call);
     478
     479        sock_core = socket_cores_find(&client->sockets, socket_id);
     480        if (sock_core == NULL) {
     481                async_answer_0(callid, ENOTSOCK);
     482                return;
     483        }
     484
     485        socket = (udp_sockdata_t *)sock_core->specific_data;
     486        fibril_mutex_lock(&socket->lock);
     487
     488        assert(socket->assoc != NULL);
     489        udp_uc_destroy(socket->assoc);
     490
     491        rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
     492            udp_free_sock_data);
     493        if (rc != EOK) {
     494                fibril_mutex_unlock(&socket->lock);
     495                async_answer_0(callid, rc);
     496                return;
     497        }
     498
     499        fibril_mutex_unlock(&socket->lock);
     500        async_answer_0(callid, EOK);
     501}
     502
     503static void udp_sock_getsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     504{
     505        log_msg(LVL_DEBUG, "udp_sock_getsockopt()");
     506        async_answer_0(callid, ENOTSUP);
     507}
     508
     509static void udp_sock_setsockopt(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
     510{
     511        log_msg(LVL_DEBUG, "udp_sock_setsockopt()");
     512        async_answer_0(callid, ENOTSUP);
     513}
     514
     515static void udp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     516{
     517        ipc_callid_t callid;
     518        ipc_call_t call;
     519        udp_client_t client;
     520
     521        /* Accept the connection */
     522        async_answer_0(iid, EOK);
     523
     524        client.sess = async_callback_receive(EXCHANGE_SERIALIZE);
     525        socket_cores_initialize(&client.sockets);
     526
     527        while (true) {
     528                callid = async_get_call(&call);
     529                if (!IPC_GET_IMETHOD(call))
     530                        break;
     531
     532                log_msg(LVL_DEBUG, "udp_sock_connection: METHOD=%d\n",
     533                    (int)IPC_GET_IMETHOD(call));
     534
     535                switch (IPC_GET_IMETHOD(call)) {
     536                case NET_SOCKET:
     537                        udp_sock_socket(&client, callid, call);
     538                        break;
     539                case NET_SOCKET_BIND:
     540                        udp_sock_bind(&client, callid, call);
     541                        break;
     542                case NET_SOCKET_LISTEN:
     543                        udp_sock_listen(&client, callid, call);
     544                        break;
     545                case NET_SOCKET_CONNECT:
     546                        udp_sock_connect(&client, callid, call);
     547                        break;
     548                case NET_SOCKET_ACCEPT:
     549                        udp_sock_accept(&client, callid, call);
     550                        break;
     551                case NET_SOCKET_SEND:
     552                case NET_SOCKET_SENDTO:
     553                        udp_sock_sendto(&client, callid, call);
     554                        break;
     555                case NET_SOCKET_RECV:
     556                case NET_SOCKET_RECVFROM:
     557                        udp_sock_recvfrom(&client, callid, call);
     558                        break;
     559                case NET_SOCKET_CLOSE:
     560                        udp_sock_close(&client, callid, call);
     561                        break;
     562                case NET_SOCKET_GETSOCKOPT:
     563                        udp_sock_getsockopt(&client, callid, call);
     564                        break;
     565                case NET_SOCKET_SETSOCKOPT:
     566                        udp_sock_setsockopt(&client, callid, call);
     567                        break;
     568                default:
     569                        async_answer_0(callid, ENOTSUP);
     570                        break;
     571                }
     572        }
    44573}
    45574
  • uspace/srv/udp/udp_type.h

    r66a272f8 re33bceb  
    3636#define UDP_TYPE_H
    3737
     38#include <fibril_synch.h>
    3839#include <socket_core.h>
    3940#include <sys/types.h>
     41
     42typedef enum {
     43        UDP_EOK
     44} udp_error_t;
     45
     46typedef enum {
     47        XF_DUMMY        = 0x1
     48} xflags_t;
    4049
    4150typedef struct {
    4251        uint32_t ipv4;
    4352} netaddr_t;
     53
     54enum netaddr {
     55        UDP_IPV4_ANY = 0
     56};
    4457
    4558typedef struct {
     
    7487} udp_pdu_t;
    7588
     89typedef struct {
     90        async_sess_t *sess;
     91        socket_cores_t sockets;
     92} udp_client_t;
     93
     94typedef struct {
     95        char *name;
     96        udp_sockpair_t ident;
     97} udp_assoc_t;
     98
     99typedef struct {
     100} udp_assoc_status_t;
     101
     102typedef struct udp_sockdata {
     103        /** Lock */
     104        fibril_mutex_t lock;
     105        /** Socket core */
     106        socket_core_t *sock_core;
     107        /** Client */
     108        udp_client_t *client;
     109        /** Connection */
     110        udp_assoc_t *assoc;
     111        /** Local address */
     112        netaddr_t laddr;
     113} udp_sockdata_t;
     114
    76115#endif
    77116
Note: See TracChangeset for help on using the changeset viewer.