Changeset fab2746 in mainline for uspace/lib/c


Ignore:
Timestamp:
2015-04-08T21:25:30Z (10 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
99ea91b2
Parents:
ba0eac5
Message:

New transport layer API. Only UDP implemented.

Location:
uspace/lib/c
Files:
2 added
13 deleted
5 edited
6 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    rba0eac5 rfab2746  
    9797        generic/futex.c \
    9898        generic/inet/addr.c \
     99        generic/inet/endpoint.c \
     100        generic/inet/tcp.c \
     101        generic/inet/udp.c \
    99102        generic/inet.c \
    100103        generic/inetcfg.c \
    … …  
    137140        generic/adt/list.c \
    138141        generic/adt/hash_table.c \
    139         generic/adt/dynamic_fifo.c \
    140         generic/adt/char_map.c \
    141142        generic/adt/prodcons.c \
    142143        generic/time.c \
    … …  
    145146        generic/vfs/vfs.c \
    146147        generic/vfs/canonify.c \
    147         generic/net/inet.c \
    148         generic/net/socket_client.c \
    149         generic/net/socket_parse.c \
    150148        generic/setjmp.c \
    151149        generic/stack.c \

  • uspace/lib/c/generic/inet/addr.c

    rba0eac5 rfab2746  
    3636#include <errno.h>
    3737#include <unistd.h>
    38 #include <net/socket_codes.h>
    3938#include <inet/addr.h>
    40 #include <net/inet.h>
    4139#include <stdio.h>
    4240#include <malloc.h>
    … …  
    4442
    4543#define INET_PREFIXSTRSIZE  5
     44
     45#define INET6_ADDRSTRLEN (8 * 4 + 7 + 1)
    4646
    4747#if !(defined(__BE__) ^ defined(__LE__))
    … …  
    178178        naddr->addr6[15] = h & 0xff;
    179179        naddr->prefix = prefix;
    180 }
    181 
    182 /** Determine address version.
    183  *
    184  * @param text Address in common notation.
    185  * @param af   Place to store address version.
    186  *
    187  * @return EOK on success, EINVAL if input is not in valid format.
    188  *
    189  */
    190 static int inet_addr_version(const char *text, ip_ver_t *ver)
    191 {
    192         char *dot = str_chr(text, '.');
    193         if (dot != NULL) {
    194                 *ver = ip_v4;
    195                 return EOK;
    196         }
    197 
    198         char *collon = str_chr(text, ':');
    199         if (collon != NULL) {
    200                 *ver = ip_v6;
    201                 return EOK;
    202         }
    203 
    204         return EINVAL;
    205 }
    206 
    207 static int ipver_af(ip_ver_t ver)
    208 {
    209         switch (ver) {
    210         case ip_any:
    211                 return AF_NONE;
    212         case ip_v4:
    213                 return AF_INET;
    214         case ip_v6:
    215                 return AF_INET6;
    216         default:
    217                 assert(false);
    218                 return EINVAL;
    219         }
    220 }
    221 
    222 ip_ver_t ipver_from_af(int af)
    223 {
    224         switch (af) {
    225         case AF_NONE:
    226                 return ip_any;
    227         case AF_INET:
    228                 return ip_v4;
    229         case AF_INET6:
    230                 return ip_v6;
    231         default:
    232                 assert(false);
    233                 return EINVAL;
    234         }
    235180}
    236181
    … …  
    343288}
    344289
     290static int inet_addr_parse_v4(const char *str, inet_addr_t *raddr,
     291    int *prefix)
     292{
     293        uint32_t a = 0;
     294        uint8_t b;
     295        char *cur = (char *)str;
     296        size_t i = 0;
     297
     298        while (i < 4) {
     299                int rc = str_uint8_t(cur, (const char **)&cur, 10, false, &b);
     300                if (rc != EOK)
     301                        return rc;
     302
     303                a = (a << 8) + b;
     304
     305                i++;
     306
     307                if (*cur == 0)
     308                        break;
     309
     310                if (*cur != '.')
     311                        return EINVAL;
     312
     313                if (i < 4)
     314                        cur++;
     315        }
     316
     317        if (prefix != NULL) {
     318                *prefix = strtoul(cur, &cur, 10);
     319                if (*prefix > 32)
     320                        return EINVAL;
     321        }
     322
     323        if (i != 4 || (*cur != 0))
     324                return EINVAL;
     325
     326        raddr->version = ip_v4;
     327        raddr->addr = a;
     328
     329        return EOK;
     330}
     331
     332static int inet_addr_parse_v6(const char *str, inet_addr_t *raddr, int *prefix)
     333{
     334        /* XXX */
     335        return EINVAL;
     336}
     337
    345338/** Parse node address.
    346339 *
    … …  
    353346int inet_addr_parse(const char *text, inet_addr_t *addr)
    354347{
    355         int rc = inet_addr_version(text, &addr->version);
    356         if (rc != EOK)
    357                 return rc;
    358        
    359         uint8_t buf[16];
    360         rc = inet_pton(ipver_af(addr->version), text, buf);
    361         if (rc != EOK)
    362                 return rc;
    363        
    364         switch (addr->version) {
    365         case ip_v4:
    366                 addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    367                     buf[3];
    368                 break;
    369         case ip_v6:
    370                 memcpy(addr->addr6, buf, 16);
    371                 break;
    372         default:
    373                 return EINVAL;
    374         }
    375        
    376         return EOK;
     348        int rc;
     349
     350        rc = inet_addr_parse_v4(text, addr, NULL);
     351        if (rc == EOK)
     352                return EOK;
     353
     354        rc = inet_addr_parse_v6(text, addr, NULL);
     355        if (rc == EOK)
     356                return EOK;
     357
     358        return EINVAL;
    377359}
    378360
    … …  
    387369int inet_naddr_parse(const char *text, inet_naddr_t *naddr)
    388370{
    389         char *slash = str_chr(text, '/');
    390         if (slash == NULL)
    391                 return EINVAL;
    392        
    393         *slash = 0;
    394        
    395         int rc = inet_addr_version(text, &naddr->version);
    396         if (rc != EOK)
    397                 return rc;
    398        
    399         uint8_t buf[16];
    400         rc = inet_pton(ipver_af(naddr->version), text, buf);
    401         *slash = '/';
    402        
    403         if (rc != EOK)
    404                 return rc;
    405        
    406         slash++;
    407         uint8_t prefix;
    408        
    409         switch (naddr->version) {
    410         case ip_v4:
    411                 prefix = strtoul(slash, &slash, 10);
    412                 if (prefix > 32)
     371        int rc;
     372        inet_addr_t addr;
     373        int prefix;
     374
     375        rc = inet_addr_parse_v4(text, &addr, &prefix);
     376        if (rc == EOK) {
     377                inet_addr_naddr(&addr, prefix, naddr);
     378                return EOK;
     379        }
     380
     381        rc = inet_addr_parse_v6(text, &addr, &prefix);
     382        if (rc == EOK) {
     383                inet_addr_naddr(&addr, prefix, naddr);
     384                return EOK;
     385        }
     386
     387        return EINVAL;
     388}
     389
     390static int inet_ntop6(const uint8_t *data, char *address, size_t length)
     391{
     392        /* Check output buffer size */
     393        if (length < INET6_ADDRSTRLEN)
     394                return ENOMEM;
     395       
     396        /* Find the longest zero subsequence */
     397       
     398        uint16_t zeroes[8];
     399        uint16_t bioctets[8];
     400       
     401        for (size_t i = 8; i > 0; i--) {
     402                size_t j = i - 1;
     403               
     404                bioctets[j] = (data[j << 1] << 8) | data[(j << 1) + 1];
     405               
     406                if (bioctets[j] == 0) {
     407                        zeroes[j] = 1;
     408                        if (j < 7)
     409                                zeroes[j] += zeroes[j + 1];
     410                } else
     411                        zeroes[j] = 0;
     412        }
     413       
     414        size_t wildcard_pos = (size_t) -1;
     415        size_t wildcard_size = 0;
     416       
     417        for (size_t i = 0; i < 8; i++) {
     418                if (zeroes[i] > wildcard_size) {
     419                        wildcard_pos = i;
     420                        wildcard_size = zeroes[i];
     421                }
     422        }
     423       
     424        char *cur = address;
     425        size_t rest = length;
     426        bool tail_zero = false;
     427        int ret;
     428       
     429        for (size_t i = 0; i < 8; i++) {
     430                if ((i == wildcard_pos) && (wildcard_size > 1)) {
     431                        ret = snprintf(cur, rest, ":");
     432                        i += wildcard_size - 1;
     433                        tail_zero = true;
     434                } else if (i == 0) {
     435                        ret = snprintf(cur, rest, "%" PRIx16, bioctets[i]);
     436                        tail_zero = false;
     437                } else {
     438                        ret = snprintf(cur, rest, ":%" PRIx16, bioctets[i]);
     439                        tail_zero = false;
     440                }
     441               
     442                if (ret < 0)
    413443                        return EINVAL;
    414444               
    415                 naddr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    416                     buf[3];
    417                 naddr->prefix = prefix;
    418                
    419                 break;
    420         case ip_v6:
    421                 prefix = strtoul(slash, &slash, 10);
    422                 if (prefix > 128)
     445                cur += ret;
     446                rest -= ret;
     447        }
     448       
     449        if (tail_zero) {
     450                ret = snprintf(cur, rest, ":");
     451                if (ret < 0)
    423452                        return EINVAL;
    424                
    425                 memcpy(naddr->addr6, buf, 16);
    426                 naddr->prefix = prefix;
    427                
    428                 break;
    429         default:
    430                 return ENOTSUP;
    431453        }
    432454       
    433455        return EOK;
    434456}
     457
    435458
    436459/** Format node address.
    … …  
    462485                        return ENOMEM;
    463486               
    464                 return inet_ntop(AF_INET6, addr->addr6, *bufp, INET6_ADDRSTRLEN);
     487                return inet_ntop6(addr->addr6, *bufp, INET6_ADDRSTRLEN);
    465488        default:
     489                asprintf(bufp, "<ver=%d>", addr->version);
    466490                return ENOTSUP;
    467491        }
    … …  
    503527                        return ENOMEM;
    504528               
    505                 rc = inet_ntop(AF_INET6, naddr->addr6, *bufp,
     529                rc = inet_ntop6(naddr->addr6, *bufp,
    506530                    INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    507531                if (rc != EOK) {
    … …  
    586610}
    587611
    588 void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
    589 {
    590         addr->version = ip_v4;
    591         addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
    592 }
    593 
    594612void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    595613{
    … …  
    605623}
    606624
    607 void inet_sockaddr_in6_addr(const sockaddr_in6_t *sockaddr_in6,
    608     inet_addr_t *addr)
    609 {
    610         addr->version = ip_v6;
    611         addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
    612 }
    613 
    614 uint16_t inet_addr_sockaddr_in(const inet_addr_t *addr,
    615     sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
    616 {
    617         switch (addr->version) {
    618         case ip_v4:
    619                 if (sockaddr_in != NULL) {
    620                         sockaddr_in->sin_family = AF_INET;
    621                         sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    622                 }
    623                 break;
    624         case ip_v6:
    625                 if (sockaddr_in6 != NULL) {
    626                         sockaddr_in6->sin6_family = AF_INET6;
    627                         host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
    628                 }
    629                 break;
    630         default:
    631                 assert(false);
    632                 break;
    633         }
    634 
    635         return ipver_af(addr->version);
    636 }
    637 
    638 int inet_addr_sockaddr(const inet_addr_t *addr, uint16_t port,
    639     sockaddr_t **nsockaddr, socklen_t *naddrlen)
    640 {
    641         sockaddr_in_t *sa4;
    642         sockaddr_in6_t *sa6;
    643 
    644         switch (addr->version) {
    645         case ip_v4:
    646                 sa4 = calloc(1, sizeof(sockaddr_in_t));
    647                 if (sa4 == NULL)
    648                         return ENOMEM;
    649 
    650                 sa4->sin_family = AF_INET;
    651                 sa4->sin_port = host2uint16_t_be(port);
    652                 sa4->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    653                 if (nsockaddr != NULL)
    654                         *nsockaddr = (sockaddr_t *)sa4;
    655                 if (naddrlen != NULL)
    656                         *naddrlen = sizeof(*sa4);
    657                 break;
    658         case ip_v6:
    659                 sa6 = calloc(1, sizeof(sockaddr_in6_t));
    660                 if (sa6 == NULL)
    661                         return ENOMEM;
    662 
    663                 sa6->sin6_family = AF_INET6;
    664                 sa6->sin6_port = host2uint16_t_be(port);
    665                 host2addr128_t_be(addr->addr6, sa6->sin6_addr.s6_addr);
    666                 if (nsockaddr != NULL)
    667                         *nsockaddr = (sockaddr_t *)sa6;
    668                 if (naddrlen != NULL)
    669                         *naddrlen = sizeof(*sa6);
    670                 break;
    671         default:
    672                 assert(false);
    673                 break;
    674         }
    675 
    676         return EOK;
    677 }
    678 
    679625/** @}
    680626 */

  • uspace/lib/c/generic/inet/endpoint.c

    rba0eac5 rfab2746  
    11/*
    2  * Copyright (c) 2011 Jiri Svoboda
     2 * Copyright (c) 2015 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup tcp
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 /** @file Socket provider
     32/** @file Internet endpoint
    3333 */
    3434
    35 #ifndef SOCK_H
    36 #define SOCK_H
     35#include <inet/endpoint.h>
     36#include <mem.h>
    3737
    38 #include <async.h>
     38void inet_ep_init(inet_ep_t *ep)
     39{
     40        memset(ep, 0, sizeof(*ep));
     41}
    3942
    40 extern int tcp_sock_init(void);
    41 
    42 #endif
     43void inet_ep2_init(inet_ep2_t *ep2)
     44{
     45        memset(ep2, 0, sizeof(*ep2));
     46}
    4347
    4448/** @}

  • uspace/lib/c/generic/inet/tcp.c

    rba0eac5 rfab2746  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2015 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup libc
    30  *  @{
     30 * @{
     31 */
     32/** @file UDP API
    3133 */
    3234
    33 /** @file
    34  *  Socket application program interface (API).
    35  *  This is a part of the network application library.
    36  *  Based on the BSD socket interface.
    37  */
     35#include <errno.h>
     36#include <inet/endpoint.h>
     37#include <inet/tcp.h>
    3838
    39 #ifndef LIBC_SOCKET_H_
    40 #define LIBC_SOCKET_H_
     39int tcp_create(tcp_t **rtcp)
     40{
     41        return 0;
     42}
    4143
    42 #include <net/socket_codes.h>
    43 #include <net/in.h>
    44 #include <net/in6.h>
    45 #include <net/inet.h>
    46 #include <errno.h>
    47 #include <byteorder.h>
     44void tcp_destroy(tcp_t *tcp)
     45{
     46}
    4847
    49 /** @name Socket application programming interface
    50  */
    51 /*@{*/
     48int tcp_conn_create(tcp_t *tcp, inet_ep2_t *epp, tcp_cb_t *cb, void *arg,
     49    tcp_conn_t **rconn)
     50{
     51        return 0;
     52}
    5253
    53 extern int socket(int, int, int);
    54 extern int bind(int, const struct sockaddr *, socklen_t);
    55 extern int listen(int, int);
    56 extern int accept(int, struct sockaddr *, socklen_t *);
    57 extern int connect(int, const struct sockaddr *, socklen_t);
    58 extern int closesocket(int);
    59 extern int send(int, const void *, size_t, int);
    60 extern int sendto(int, const void *, size_t, int, const struct sockaddr *,
    61     socklen_t);
    62 extern ssize_t recv(int, void *, size_t, int);
    63 extern ssize_t recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *);
    64 extern int getsockopt(int, int, int, void *, size_t *);
    65 extern int setsockopt(int, int, int, const void *, size_t);
     54void tcp_conn_destroy(tcp_conn_t *conn)
     55{
     56}
    6657
    67 /*@}*/
     58void *tcp_conn_userptr(tcp_conn_t *conn)
     59{
     60        return NULL;
     61}
    6862
    69 #endif
     63int tcp_listener_create(tcp_t *tcp, inet_ep_t *ep, tcp_listen_cb_t *lcb,
     64    void *larg, tcp_cb_t *cb, void *arg, tcp_listener_t **rlst)
     65{
     66        return 0;
     67}
     68
     69void tcp_listener_destroy(tcp_listener_t *lst)
     70{
     71}
     72
     73void *tcp_listener_userptr(tcp_listener_t *lst)
     74{
     75        return NULL;
     76}
     77
     78
     79int tcp_conn_wait_connected(tcp_conn_t *conn)
     80{
     81        return 0;
     82}
     83
     84int tcp_conn_send(tcp_conn_t *conn, const void *data, size_t bytes)
     85{
     86        return 0;
     87}
     88
     89int tcp_conn_send_fin(tcp_conn_t *conn)
     90{
     91        return 0;
     92}
     93
     94int tcp_conn_push(tcp_conn_t *conn)
     95{
     96        return 0;
     97}
     98
     99void tcp_conn_reset(tcp_conn_t *conn)
     100{
     101}
     102
     103
     104int tcp_conn_recv(tcp_conn_t *conn, void *buf, size_t bsize, size_t *nrecv)
     105{
     106        return 0;
     107}
     108
     109int tcp_conn_recv_wait(tcp_conn_t *conn, void *buf, size_t bsize, size_t *nrecv)
     110{
     111        return 0;
     112}
     113
    70114
    71115/** @}

  • uspace/lib/c/include/errno.h

    rba0eac5 rfab2746  
    6868#define ENAK (-303)
    6969
    70 /** An API function is called while another blocking function is in progress. */
    71 #define EINPROGRESS  (-10036)
    72 
    73 /** The socket identifier is not valid. */
    74 #define ENOTSOCK  (-10038)
    75 
    76 /** The destination address required. */
    77 #define EDESTADDRREQ  (-10039)
    78 
    79 /** Protocol is not supported.  */
    80 #define EPROTONOSUPPORT  (-10043)
    81 
    82 /** Socket type is not supported. */
    83 #define ESOCKTNOSUPPORT  (-10044)
    84 
    85 /** Protocol family is not supported. */
    86 #define EPFNOSUPPORT  (-10046)
    87 
    88 /** Address family is not supported. */
    89 #define EAFNOSUPPORT  (-10047)
    90 
    91 /** Address is already in use. */
    92 #define EADDRINUSE  (-10048)
    93 
    94 /** The socket is not connected or bound. */
    95 #define ENOTCONN  (-10057)
    96 
    97 #define ECONNREFUSED  (-10058)
    98 
    99 #define ECONNABORTED  (-10059)
    100 
    10170/** The requested operation was not performed. Try again later. */
    10271#define EAGAIN  (-11002)
    103 
    104 /** No data. */
    105 #define NO_DATA (-11004)
    10672
    10773#endif

  • uspace/lib/c/include/inet/addr.h

    rba0eac5 rfab2746  
    3737
    3838#include <stdint.h>
    39 #include <net/in.h>
    40 #include <net/in6.h>
    41 #include <net/socket.h>
    4239
    4340typedef uint32_t addr32_t;
    … …  
    126123extern void inet_addr_set(addr32_t, inet_addr_t *);
    127124extern void inet_naddr_set(addr32_t, uint8_t, inet_naddr_t *);
    128 extern void inet_sockaddr_in_addr(const sockaddr_in_t *, inet_addr_t *);
    129125
    130126extern void inet_addr_set6(addr128_t, inet_addr_t *);
    131127extern void inet_naddr_set6(addr128_t, uint8_t, inet_naddr_t *);
    132 extern void inet_sockaddr_in6_addr(const sockaddr_in6_t *, inet_addr_t *);
    133 
    134 extern uint16_t inet_addr_sockaddr_in(const inet_addr_t *, sockaddr_in_t *,
    135     sockaddr_in6_t *);
    136 
    137 extern ip_ver_t ipver_from_af(int af);
    138 extern int inet_addr_sockaddr(const inet_addr_t *, uint16_t, sockaddr_t **,
    139     socklen_t *);
    140128
    141129#endif

  • uspace/lib/c/include/inet/endpoint.h

    rba0eac5 rfab2746  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2015 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup libc
    30  *  @{
     30 * @{
     31 */
     32/** @file
    3133 */
    3234
    33 /** @file
    34  * Internet protocol numbers according to the on-line IANA - Assigned Protocol
    35  * numbers:
    36  *
    37  * http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xml
    38  */
     35#ifndef LIBC_INET_ASSOC_H_
     36#define LIBC_INET_ASSOC_H_
    3937
    40 #ifndef LIBC_IP_PROTOCOLS_H_
    41 #define LIBC_IP_PROTOCOLS_H_
     38#include <stdint.h>
     39#include <inet/addr.h>
     40#include <loc.h>
    4241
    43 /** @name IP protocols definitions */
    44 /*@{*/
     42/** Internet endpoint (address-port pair), a.k.a. socket */
     43typedef struct {
     44        inet_addr_t addr;
     45        uint16_t port;
     46} inet_ep_t;
    4547
    46 #define IPPROTO_ICMP    1
    47 #define IPPROTO_TCP     6
    48 #define IPPROTO_UDP     17
    49 #define IPPROTO_ICMPV6  58
     48/** Internet endpoint pair */
     49typedef struct {
     50        service_id_t local_link;
     51        inet_ep_t local;
     52        inet_ep_t remote;
     53} inet_ep2_t;
    5054
    51 /*@}*/
     55extern void inet_ep_init(inet_ep_t *);
     56extern void inet_ep2_init(inet_ep2_t *);
    5257
    5358#endif

  • uspace/lib/c/include/inet/tcp.h

    rba0eac5 rfab2746  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2015 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup libc
    30  *  @{
     30 * @{
     31 */
     32/** @file
    3133 */
    3234
    33 /** @file
    34  *  Socket codes and definitions.
    35  *  This is a part of the network application library.
    36  */
     35#ifndef LIBC_INET_TCP_H_
     36#define LIBC_INET_TCP_H_
    3737
    38 #ifndef LIBC_SOCKET_CODES_H_
    39 #define LIBC_SOCKET_CODES_H_
     38#include <inet/addr.h>
     39#include <inet/endpoint.h>
     40#include <inet/inet.h>
    4041
    41 #include <sys/types.h>
     42typedef struct {
     43} tcp_conn_t;
    4244
    43 /** @name Address families definitions */
    44 /*@{*/
     45typedef struct {
     46} tcp_listener_t;
    4547
    46 enum {
    47         AF_NONE = 0,
    48         AF_INET,  /* IPv4 address */
    49         AF_INET6  /* IPv6 address */
    50 };
     48typedef struct {
     49        void (*connected)(tcp_conn_t *);
     50        void (*conn_failed)(tcp_conn_t *);
     51        void (*conn_reset)(tcp_conn_t *);
     52        void (*data_avail)(tcp_conn_t *);
     53        void (*urg_data)(tcp_conn_t *);
     54} tcp_cb_t;
    5155
    52 /*@}*/
     56typedef struct {
     57        void (*new_conn)(tcp_listener_t *, tcp_conn_t *);
     58} tcp_listen_cb_t;
    5359
    54 /** @name Protocol families definitions
    55  * Same as address families.
    56  */
    57 /*@{*/
     60typedef struct {
     61} tcp_t;
    5862
    59 #define PF_INET   AF_INET
    60 #define PF_INET6  AF_INET6
     63extern int tcp_create(tcp_t **);
     64extern void tcp_destroy(tcp_t *);
     65extern int tcp_conn_create(tcp_t *, inet_ep2_t *, tcp_cb_t *, void *,
     66    tcp_conn_t **);
     67extern void tcp_conn_destroy(tcp_conn_t *);
     68extern void *tcp_conn_userptr(tcp_conn_t *);
     69extern int tcp_listener_create(tcp_t *, inet_ep_t *, tcp_listen_cb_t *, void *,
     70    tcp_cb_t *, void *, tcp_listener_t **);
     71extern void tcp_listener_destroy(tcp_listener_t *);
     72extern void *tcp_listener_userptr(tcp_listener_t *);
    6173
    62 /*@}*/
     74extern int tcp_conn_wait_connected(tcp_conn_t *);
     75extern int tcp_conn_send(tcp_conn_t *, const void *, size_t);
     76extern int tcp_conn_send_fin(tcp_conn_t *);
     77extern int tcp_conn_push(tcp_conn_t *);
     78extern void tcp_conn_reset(tcp_conn_t *);
    6379
    64 /** Socket types. */
    65 typedef enum sock_type {
    66         /** Stream (connection oriented) socket. */
    67         SOCK_STREAM = 1,
    68         /** Datagram (connectionless oriented) socket. */
    69         SOCK_DGRAM = 2,
    70         /** Raw socket. */
    71         SOCK_RAW = 3
    72 } sock_type_t;
     80extern int tcp_conn_recv(tcp_conn_t *, void *, size_t, size_t *);
     81extern int tcp_conn_recv_wait(tcp_conn_t *, void *, size_t, size_t *);
    7382
    74 /** Type definition of the socket length. */
    75 typedef int32_t socklen_t;
    76 
    77 /* Socket options */
    78 
    79 enum {
    80         SOL_SOCKET = 1,
    81 
    82         /* IP link to transmit on */
    83         SO_IPLINK
    84 };
    8583
    8684#endif

  • uspace/lib/c/include/inet/udp.h

    rba0eac5 rfab2746  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2015 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup libc
    30  *  @{
     30 * @{
     31 */
     32/** @file
    3133 */
    3234
    33 /** @file
    34  *  Character string to integer map.
    35  */
     35#ifndef LIBC_INET_UDP_H_
     36#define LIBC_INET_UDP_H_
    3637
    37 #ifndef LIBC_CHAR_MAP_H_
    38 #define LIBC_CHAR_MAP_H_
     38#include <async.h>
     39#include <inet/addr.h>
     40#include <inet/endpoint.h>
     41#include <inet/inet.h>
    3942
    40 #include <libarch/types.h>
     43typedef enum {
     44        udp_ls_down,
     45        udp_ls_up
     46} udp_link_state_t;
    4147
    42 /** Invalid assigned value used also if an&nbsp;entry does not exist. */
    43 #define CHAR_MAP_NULL  (-1)
     48typedef struct {
     49        struct udp *udp;
     50        sysarg_t assoc_id;
     51        size_t size;
     52        inet_ep_t remote_ep;
     53} udp_rmsg_t;
    4454
    45 /** Type definition of the character string to integer map.
    46  *  @see char_map
    47  */
    48 typedef struct char_map char_map_t;
     55typedef struct {
     56} udp_rerr_t;
    4957
    50 /** Character string to integer map item.
    51  *
    52  * This structure recursivelly contains itself as a character by character tree.
    53  * The actually mapped character string consists of all the parent characters
    54  * and the actual one.
    55  */
    56 struct char_map {
    57         /** Actually mapped character. */
    58         uint8_t c;
    59         /** Stored integral value. */
    60         int value;
    61         /** Next character array size. */
    62         int size;
    63         /** First free position in the next character array. */
    64         int next;
    65         /** Next character array. */
    66         char_map_t **items;
    67         /** Consistency check magic value. */
    68         int magic;
    69 };
     58typedef struct {
     59        struct udp *udp;
     60        link_t ludp;
     61        sysarg_t id;
     62        struct udp_cb *cb;
     63        void *cb_arg;
     64} udp_assoc_t;
    7065
    71 extern int char_map_initialize(char_map_t *);
    72 extern void char_map_destroy(char_map_t *);
    73 extern int char_map_exclude(char_map_t *, const uint8_t *, size_t);
    74 extern int char_map_add(char_map_t *, const uint8_t *, size_t, const int);
    75 extern int char_map_find(const char_map_t *, const uint8_t *, size_t);
    76 extern int char_map_update(char_map_t *, const uint8_t *, size_t, const int);
     66typedef struct udp_cb {
     67        void (*recv_msg)(udp_assoc_t *, udp_rmsg_t *);
     68        void (*recv_err)(udp_assoc_t *, udp_rerr_t *);
     69        void (*link_state)(udp_assoc_t *, udp_link_state_t);
     70} udp_cb_t;
     71
     72typedef struct udp {
     73        /** UDP session */
     74        async_sess_t *sess;
     75        /** List of associations */
     76        list_t assoc; /* of udp_assoc_t */
     77} udp_t;
     78
     79extern int udp_create(udp_t **);
     80extern void udp_destroy(udp_t *);
     81extern int udp_assoc_create(udp_t *, inet_ep2_t *, udp_cb_t *, void *,
     82    udp_assoc_t **);
     83extern void udp_assoc_destroy(udp_assoc_t *);
     84extern int udp_assoc_send_msg(udp_assoc_t *, inet_ep_t *, void *, size_t);
     85extern void *udp_assoc_userptr(udp_assoc_t *);
     86extern size_t udp_rmsg_size(udp_rmsg_t *);
     87extern int udp_rmsg_read(udp_rmsg_t *, size_t, void *, size_t);
     88extern void udp_rmsg_remote_ep(udp_rmsg_t *, inet_ep_t *);
     89extern uint8_t udp_rerr_type(udp_rerr_t *);
     90extern uint8_t udp_rerr_code(udp_rerr_t *);
    7791
    7892#endif

  • uspace/lib/c/include/ipc/services.h

    rba0eac5 rfab2746  
    4949        SERVICE_IRC        = FOURCC('i', 'r', 'c', ' '),
    5050        SERVICE_CLIPBOARD  = FOURCC('c', 'l', 'i', 'p'),
    51         SERVICE_UDP        = FOURCC('u', 'd', 'p', ' '),
    52         SERVICE_TCP        = FOURCC('t', 'c', 'p', ' ')
    5351} services_t;
    5452
    … …  
    6159#define SERVICE_NAME_INETPING6  "net/inetping6"
    6260#define SERVICE_NAME_NETCONF    "net/netconf"
     61#define SERVICE_NAME_UDP        "net/udp"
     62#define SERVICE_NAME_TCP        "net/tcp"
    6363
    6464#endif

  • uspace/lib/c/include/ipc/udp.h

    rba0eac5 rfab2746  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2015 Jiri Svobda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup socket
     29/** @addtogroup libcipc
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * Command-line argument parsing functions related to networking.
    3533 */
    3634
    37 extern int socket_parse_address_family(const char *, int *);
    38 extern int socket_parse_protocol_family(const char *, int *);
    39 extern int socket_parse_socket_type(const char *, int *);
     35#ifndef LIBC_IPC_UDP_H_
     36#define LIBC_IPC_UDP_H_
     37
     38#include <ipc/common.h>
     39
     40typedef enum {
     41        UDP_CALLBACK_CREATE = IPC_FIRST_USER_METHOD,
     42        UDP_ASSOC_CREATE,
     43        UDP_ASSOC_DESTROY,
     44        UDP_ASSOC_SEND_MSG,
     45        UDP_RMSG_INFO,
     46        UDP_RMSG_READ,
     47        UDP_RMSG_DISCARD
     48} udp_request_t;
     49
     50typedef enum {
     51        UDP_EV_DATA = IPC_FIRST_USER_METHOD
     52} udp_event_t;
     53
     54#endif
    4055
    4156/** @}
Note: See TracChangeset for help on using the changeset viewer.