Changeset ee1c2d9 in mainline for uspace/lib/c


Ignore:
Timestamp:
2015-06-13T18:30:18Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a157846
Parents:
0453261 (diff), 2f9a8e8 (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:

mainline changes

Location:
uspace/lib/c
Files:
5 added
15 deleted
10 edited
3 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/Makefile

    r0453261 ree1c2d9  
    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/fibril_synch.c

    r0453261 ree1c2d9  
    461461                        if (rc == ETIMEOUT && timer->state == fts_active) {
    462462                                timer->state = fts_fired;
    463                                 timer->handler_running = true;
     463                                timer->handler_fid = fibril_get_id();
    464464                                fibril_mutex_unlock(timer->lockp);
    465465                                timer->fun(timer->arg);
    466466                                fibril_mutex_lock(timer->lockp);
    467                                 timer->handler_running = false;
     467                                timer->handler_fid = 0;
    468468                        }
    469469                        break;
    … …  
    477477        /* Acknowledge timer fibril has finished cleanup. */
    478478        timer->state = fts_clean;
     479        fibril_condvar_broadcast(&timer->cv);
    479480        fibril_mutex_unlock(timer->lockp);
    480         free(timer);
    481481
    482482        return 0;
    … …  
    525525        timer->state = fts_cleanup;
    526526        fibril_condvar_broadcast(&timer->cv);
     527
     528        /* Wait for timer fibril to terminate */
     529        while (timer->state != fts_clean)
     530                fibril_condvar_wait(&timer->cv, timer->lockp);
    527531        fibril_mutex_unlock(timer->lockp);
     532
     533        free(timer);
    528534}
    529535
    … …  
    608614        assert(fibril_mutex_is_locked(timer->lockp));
    609615
    610         while (timer->handler_running)
     616        while (timer->handler_fid != 0) {
     617                if (timer->handler_fid == fibril_get_id()) {
     618                        printf("Deadlock detected.\n");
     619                        stacktrace_print();
     620                        printf("Fibril %zx is trying to clear timer %p from "
     621                            "inside its handler %p.\n",
     622                            fibril_get_id(), timer, timer->fun);
     623                        abort();
     624                }
     625
    611626                fibril_condvar_wait(&timer->cv, timer->lockp);
     627        }
    612628
    613629        old_state = timer->state;

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

    r0453261 ree1c2d9  
    177177       
    178178        dgram.tos = IPC_GET_ARG1(*icall);
     179        dgram.iplink = IPC_GET_ARG2(*icall);
    179180       
    180181        ipc_callid_t callid;

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

    r0453261 ree1c2d9  
    11/*
    22 * Copyright (c) 2013 Jiri Svoboda
     3 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    3637#include <errno.h>
    3738#include <unistd.h>
    38 #include <net/socket_codes.h>
    3939#include <inet/addr.h>
    40 #include <net/inet.h>
    4140#include <stdio.h>
    4241#include <malloc.h>
    … …  
    4443
    4544#define INET_PREFIXSTRSIZE  5
     45
     46#define INET6_ADDRSTRLEN (8 * 4 + 7 + 1)
    4647
    4748#if !(defined(__BE__) ^ defined(__LE__))
    … …  
    180181}
    181182
    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         }
    235 }
    236 
    237183void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
    238184{
    … …  
    288234        if (naddr->version != addr->version)
    289235                return 0;
    290        
     236
    291237        switch (naddr->version) {
    292238        case ip_v4:
    … …  
    315261                if (naddr->prefix > 128)
    316262                        return 0;
    317                
     263
    318264                size_t pos = 0;
    319265                for (size_t i = 0; i < 16; i++) {
    … …  
    321267                        if (naddr->prefix < pos)
    322268                                break;
    323                        
     269
    324270                        if (naddr->prefix - pos > 8) {
    325271                                /* Comparison without masking */
    … …  
    333279                                        return 0;
    334280                        }
    335                        
     281
    336282                        pos += 8;
    337283                }
    338                
     284
    339285                return 1;
    340286        default:
    … …  
    343289}
    344290
     291static int inet_addr_parse_v4(const char *str, inet_addr_t *raddr,
     292    int *prefix)
     293{
     294        uint32_t a = 0;
     295        uint8_t b;
     296        char *cur = (char *)str;
     297        size_t i = 0;
     298
     299        while (i < 4) {
     300                int rc = str_uint8_t(cur, (const char **)&cur, 10, false, &b);
     301                if (rc != EOK)
     302                        return rc;
     303
     304                a = (a << 8) + b;
     305
     306                i++;
     307
     308                if (*cur == '\0')
     309                        break;
     310
     311                if (*cur != '.')
     312                        return EINVAL;
     313
     314                if (i < 4)
     315                        cur++;
     316        }
     317
     318        if (prefix != NULL) {
     319                *prefix = strtoul(cur, &cur, 10);
     320                if (*prefix > 32)
     321                        return EINVAL;
     322        }
     323
     324        if (i != 4 || (*cur != '\0'))
     325                return EINVAL;
     326
     327        raddr->version = ip_v4;
     328        raddr->addr = a;
     329
     330        return EOK;
     331}
     332
     333static int inet_addr_parse_v6(const char *str, inet_addr_t *raddr, int *prefix)
     334{
     335        uint8_t data[16];
     336
     337        memset(data, 0, 16);
     338
     339        const char *cur = str;
     340        size_t i = 0;
     341        size_t wildcard_pos = (size_t) -1;
     342        size_t wildcard_size = 0;
     343
     344        /* Handle initial wildcard */
     345        if ((str[0] == ':') && (str[1] == ':')) {
     346                cur = str + 2;
     347                wildcard_pos = 0;
     348                wildcard_size = 16;
     349
     350                /* Handle the unspecified address */
     351                if (*cur == '\0')
     352                        goto success;
     353        }
     354
     355        while (i < 16) {
     356                uint16_t bioctet;
     357                int rc = str_uint16_t(cur, &cur, 16, false, &bioctet);
     358                if (rc != EOK)
     359                        return rc;
     360
     361                data[i] = (bioctet >> 8) & 0xff;
     362                data[i + 1] = bioctet & 0xff;
     363
     364                if (wildcard_pos != (size_t) -1) {
     365                        if (wildcard_size < 2)
     366                                return EINVAL;
     367
     368                        wildcard_size -= 2;
     369                }
     370
     371                i += 2;
     372
     373                if (*cur != ':')
     374                        break;
     375
     376                if (i < 16) {
     377                        cur++;
     378
     379                        /* Handle wildcard */
     380                        if (*cur == ':') {
     381                                if (wildcard_pos != (size_t) -1)
     382                                        return EINVAL;
     383
     384                                wildcard_pos = i;
     385                                wildcard_size = 16 - i;
     386                                cur++;
     387
     388                                if (*cur == '\0' || *cur == '/')
     389                                        break;
     390                        }
     391                }
     392        }
     393
     394        if (prefix != NULL) {
     395                if (*cur != '/')
     396                        return EINVAL;
     397                cur++;
     398
     399                *prefix = strtoul(cur, (char **)&cur, 10);
     400                if (*prefix > 128)
     401                        return EINVAL;
     402        }
     403
     404        if (*cur != '\0')
     405                return EINVAL;
     406
     407        /* Create wildcard positions */
     408        if ((wildcard_pos != (size_t) -1) && (wildcard_size > 0)) {
     409                size_t wildcard_shift = 16 - wildcard_size;
     410
     411                for (i = wildcard_pos + wildcard_shift; i > wildcard_pos; i--) {
     412                        size_t j = i - 1;
     413                        data[j + wildcard_size] = data[j];
     414                        data[j] = 0;
     415                }
     416        }
     417
     418success:
     419        raddr->version = ip_v6;
     420        memcpy(raddr->addr6, data, 16);
     421        return EOK;
     422}
     423
    345424/** Parse node address.
    346425 *
    … …  
    353432int inet_addr_parse(const char *text, inet_addr_t *addr)
    354433{
    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;
     434        int rc;
     435
     436        rc = inet_addr_parse_v4(text, addr, NULL);
     437        if (rc == EOK)
     438                return EOK;
     439
     440        rc = inet_addr_parse_v6(text, addr, NULL);
     441        if (rc == EOK)
     442                return EOK;
     443
     444        return EINVAL;
    377445}
    378446
    … …  
    387455int inet_naddr_parse(const char *text, inet_naddr_t *naddr)
    388456{
    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)
     457        int rc;
     458        inet_addr_t addr;
     459        int prefix;
     460
     461        rc = inet_addr_parse_v4(text, &addr, &prefix);
     462        if (rc == EOK) {
     463                inet_addr_naddr(&addr, prefix, naddr);
     464                return EOK;
     465        }
     466
     467        rc = inet_addr_parse_v6(text, &addr, &prefix);
     468        if (rc == EOK) {
     469                inet_addr_naddr(&addr, prefix, naddr);
     470                return EOK;
     471        }
     472
     473        return EINVAL;
     474}
     475
     476static int inet_addr_format_v4(addr32_t addr, char **bufp)
     477{
     478        int rc;
     479
     480        rc = asprintf(bufp, "%u.%u.%u.%u", (addr >> 24) & 0xff,
     481            (addr >> 16) & 0xff, (addr >> 8) & 0xff, addr & 0xff);
     482        if (rc < 0)
     483                return ENOMEM;
     484
     485        return EOK;
     486}
     487
     488static int inet_addr_format_v6(const addr128_t addr, char **bufp)
     489{
     490        *bufp = (char *) malloc(INET6_ADDRSTRLEN);
     491        if (*bufp == NULL)
     492                return ENOMEM;
     493
     494        /* Find the longest zero subsequence */
     495
     496        uint16_t zeroes[8];
     497        uint16_t bioctets[8];
     498
     499        for (size_t i = 8; i > 0; i--) {
     500                size_t j = i - 1;
     501
     502                bioctets[j] = (addr[j << 1] << 8) | addr[(j << 1) + 1];
     503
     504                if (bioctets[j] == 0) {
     505                        zeroes[j] = 1;
     506                        if (j < 7)
     507                                zeroes[j] += zeroes[j + 1];
     508                } else
     509                        zeroes[j] = 0;
     510        }
     511
     512        size_t wildcard_pos = (size_t) -1;
     513        size_t wildcard_size = 0;
     514
     515        for (size_t i = 0; i < 8; i++) {
     516                if (zeroes[i] > wildcard_size) {
     517                        wildcard_pos = i;
     518                        wildcard_size = zeroes[i];
     519                }
     520        }
     521
     522        char *cur = *bufp;
     523        size_t rest = INET6_ADDRSTRLEN;
     524        bool tail_zero = false;
     525        int ret;
     526
     527        for (size_t i = 0; i < 8; i++) {
     528                if ((i == wildcard_pos) && (wildcard_size > 1)) {
     529                        ret = snprintf(cur, rest, ":");
     530                        i += wildcard_size - 1;
     531                        tail_zero = true;
     532                } else if (i == 0) {
     533                        ret = snprintf(cur, rest, "%" PRIx16, bioctets[i]);
     534                        tail_zero = false;
     535                } else {
     536                        ret = snprintf(cur, rest, ":%" PRIx16, bioctets[i]);
     537                        tail_zero = false;
     538                }
     539
     540                if (ret < 0)
    413541                        return EINVAL;
    414                
    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)
    423                         return EINVAL;
    424                
    425                 memcpy(naddr->addr6, buf, 16);
    426                 naddr->prefix = prefix;
    427                
    428                 break;
    429         default:
    430                 return ENOTSUP;
    431         }
    432        
     542
     543                cur += ret;
     544                rest -= ret;
     545        }
     546
     547        if (tail_zero)
     548                (void) snprintf(cur, rest, ":");
     549
    433550        return EOK;
    434551}
    … …  
    446563int inet_addr_format(const inet_addr_t *addr, char **bufp)
    447564{
    448         int rc = 0;
    449        
     565        int rc;
     566
     567        rc = ENOTSUP;
     568
    450569        switch (addr->version) {
    451570        case ip_any:
    452571                rc = asprintf(bufp, "none");
     572                if (rc < 0)
     573                        return ENOMEM;
     574                rc = EOK;
    453575                break;
    454576        case ip_v4:
    455                 rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
    456                     (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
    457                     addr->addr & 0xff);
     577                rc = inet_addr_format_v4(addr->addr, bufp);
    458578                break;
    459579        case ip_v6:
    460                 *bufp = (char *) malloc(INET6_ADDRSTRLEN);
    461                 if (*bufp == NULL)
    462                         return ENOMEM;
    463                
    464                 return inet_ntop(AF_INET6, addr->addr6, *bufp, INET6_ADDRSTRLEN);
    465         default:
    466                 return ENOTSUP;
    467         }
    468        
    469         if (rc < 0)
    470                 return ENOMEM;
    471        
    472         return EOK;
     580                rc = inet_addr_format_v6(addr->addr6, bufp);
     581                break;
     582        }
     583
     584        return rc;
    473585}
    474586
    … …  
    485597int inet_naddr_format(const inet_naddr_t *naddr, char **bufp)
    486598{
    487         int rc = 0;
    488         char prefix[INET_PREFIXSTRSIZE];
    489        
     599        int rc;
     600        char *astr;
     601
     602        rc = ENOTSUP;
     603
    490604        switch (naddr->version) {
    491605        case ip_any:
    492606                rc = asprintf(bufp, "none");
     607                if (rc < 0)
     608                        return ENOMEM;
     609                rc = EOK;
    493610                break;
    494611        case ip_v4:
    495                 rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
    496                     "/%" PRIu8, (naddr->addr >> 24) & 0xff,
    497                     (naddr->addr >> 16) & 0xff, (naddr->addr >> 8) & 0xff,
    498                     naddr->addr & 0xff, naddr->prefix);
    499                 break;
    500         case ip_v6:
    501                 *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    502                 if (*bufp == NULL)
     612                rc = inet_addr_format_v4(naddr->addr, &astr);
     613                if (rc != EOK)
    503614                        return ENOMEM;
    504                
    505                 rc = inet_ntop(AF_INET6, naddr->addr6, *bufp,
    506                     INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    507                 if (rc != EOK) {
    508                         free(*bufp);
    509                         return rc;
    510                 }
    511                
    512                 rc = snprintf(prefix, INET_PREFIXSTRSIZE, "/%" PRIu8,
    513                     naddr->prefix);
     615
     616                rc = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
    514617                if (rc < 0) {
    515                         free(*bufp);
     618                        free(astr);
    516619                        return ENOMEM;
    517620                }
    518                
    519                 str_append(*bufp, INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE, prefix);
    520                
    521                 break;
    522         default:
    523                 return ENOTSUP;
    524         }
    525        
    526         if (rc < 0)
    527                 return ENOMEM;
    528        
    529         return EOK;
     621
     622                rc = EOK;
     623                break;
     624        case ip_v6:
     625                rc = inet_addr_format_v6(naddr->addr6, &astr);
     626                if (rc != EOK)
     627                        return ENOMEM;
     628
     629                rc = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
     630                if (rc < 0) {
     631                        free(astr);
     632                        return ENOMEM;
     633                }
     634
     635                rc = EOK;
     636                break;
     637        }
     638
     639        return rc;
    530640}
    531641
    … …  
    586696}
    587697
    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 
    594698void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    595699{
    … …  
    605709}
    606710
    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 
    679711/** @}
    680712 */

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

    r0453261 ree1c2d9  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2015 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup socket
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * Command-line argument parsing functions related to networking.
     32/** @file Internet endpoint
    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#include <inet/endpoint.h>
     36#include <mem.h>
     37
     38void inet_ep_init(inet_ep_t *ep)
     39{
     40        memset(ep, 0, sizeof(*ep));
     41}
     42
     43void inet_ep2_init(inet_ep2_t *ep2)
     44{
     45        memset(ep2, 0, sizeof(*ep2));
     46}
    4047
    4148/** @}

  • uspace/lib/c/generic/iplink.c

    r0453261 ree1c2d9  
    4747static void iplink_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    4848
    49 int iplink_open(async_sess_t *sess, iplink_ev_ops_t *ev_ops,
     49int iplink_open(async_sess_t *sess, iplink_ev_ops_t *ev_ops, void *arg,
    5050    iplink_t **riplink)
    5151{
    … …  
    5656        iplink->sess = sess;
    5757        iplink->ev_ops = ev_ops;
     58        iplink->arg = arg;
    5859       
    5960        async_exch_t *exch = async_exchange_begin(sess);
    … …  
    234235       
    235236        return (int) retval;
     237}
     238
     239void *iplink_get_userptr(iplink_t *iplink)
     240{
     241        return iplink->arg;
    236242}
    237243

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

    r0453261 ree1c2d9  
    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/fibril_synch.h

    r0453261 ree1c2d9  
    135135        fid_t fibril;
    136136        fibril_timer_state_t state;
    137         bool handler_running;
     137        /** FID of fibril executing handler or 0 if handler is not running */
     138        fid_t handler_fid;
    138139
    139140        suseconds_t delay;

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

    r0453261 ree1c2d9  
    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

    r0453261 ree1c2d9  
    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#ifndef LIBC_INET_ASSOC_H_
     36#define LIBC_INET_ASSOC_H_
     37
     38#include <stdint.h>
     39#include <inet/addr.h>
     40#include <loc.h>
     41
     42/** Internet port number ranges
     43 *
     44 * Port number ranges per RFC 6335 section 6 (Port Number Ranges.
     45 * Technically port zero is a system port. But since it is reserved,
     46 * we will use it as a special value denoting no port is specified
     47 * and we will exclude it from the system port range to disallow
     48 * ever assigning it.
    3549 */
    36 
    37 #ifndef LIBC_CHAR_MAP_H_
    38 #define LIBC_CHAR_MAP_H_
    39 
    40 #include <libarch/types.h>
    41 
    42 /** Invalid assigned value used also if an&nbsp;entry does not exist. */
    43 #define CHAR_MAP_NULL  (-1)
    44 
    45 /** Type definition of the character string to integer map.
    46  *  @see char_map
    47  */
    48 typedef struct char_map char_map_t;
    49 
    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;
     50enum inet_port_ranges {
     51        /** Special value meaning no specific port */
     52        inet_port_any = 0,
     53        /** Lowest system port (a.k.a. well known port) */
     54        inet_port_sys_lo = 1,
     55        /** Highest system port (a.k.a. well known port) */
     56        inet_port_sys_hi = 1023,
     57        /** Lowest user port (a.k.a. registered port) */
     58        inet_port_user_lo = 1024,
     59        /** Highest user port (a.k.a. registered port) */
     60        inet_port_user_hi = 49151,
     61        /** Lowest dynamic port (a.k.a. private or ephemeral port) */
     62        inet_port_dyn_lo = 49152,
     63        /** Highest dynamic port (a.k.a. private or ephemeral port) */
     64        inet_port_dyn_hi = 65535
    6965};
    7066
    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);
     67/** Internet endpoint (address-port pair), a.k.a. socket */
     68typedef struct {
     69        inet_addr_t addr;
     70        uint16_t port;
     71} inet_ep_t;
     72
     73/** Internet endpoint pair */
     74typedef struct {
     75        service_id_t local_link;
     76        inet_ep_t local;
     77        inet_ep_t remote;
     78} inet_ep2_t;
     79
     80extern void inet_ep_init(inet_ep_t *);
     81extern void inet_ep2_init(inet_ep2_t *);
    7782
    7883#endif

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

    r0453261 ree1c2d9  
    4444        async_sess_t *sess;
    4545        struct iplink_ev_ops *ev_ops;
     46        void *arg;
    4647} iplink_t;
    4748
    … …  
    8182} iplink_ev_ops_t;
    8283
    83 extern int iplink_open(async_sess_t *, iplink_ev_ops_t *, iplink_t **);
     84extern int iplink_open(async_sess_t *, iplink_ev_ops_t *, void *, iplink_t **);
    8485extern void iplink_close(iplink_t *);
    8586extern int iplink_send(iplink_t *, iplink_sdu_t *);
    … …  
    9091extern int iplink_get_mac48(iplink_t *, addr48_t *);
    9192extern int iplink_set_mac48(iplink_t *, addr48_t);
     93extern void *iplink_get_userptr(iplink_t *);
    9294
    9395#endif

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

    r0453261 ree1c2d9  
    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

    r0453261 ree1c2d9  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2015 Jiri Svobda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
    30  *  @{
     29/** @addtogroup libcipc
     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_IPC_UDP_H_
     36#define LIBC_IPC_UDP_H_
    3937
    40 #ifndef LIBC_IP_PROTOCOLS_H_
    41 #define LIBC_IP_PROTOCOLS_H_
     38#include <ipc/common.h>
    4239
    43 /** @name IP protocols definitions */
    44 /*@{*/
     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;
    4549
    46 #define IPPROTO_ICMP    1
    47 #define IPPROTO_TCP     6
    48 #define IPPROTO_UDP     17
    49 #define IPPROTO_ICMPV6  58
    50 
    51 /*@}*/
     50typedef enum {
     51        UDP_EV_DATA = IPC_FIRST_USER_METHOD
     52} udp_event_t;
    5253
    5354#endif
Note: See TracChangeset for help on using the changeset viewer.