Changeset c42f50d in mainline


Ignore:
Timestamp:
2013-10-05T11:53:43Z (11 years ago)
Author:
Martin Sucha <sucha14@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
cbfc8b7
Parents:
408424e (diff), 3e896e1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

Files:
12 added
4 deleted
69 edited
4 moved

Legend:

Unmodified
Added
Removed

  • .bzrignore

    r408424e rc42f50d  
    269269uspace/dist/srv/dhcp
    270270uspace/srv/net/dhcp/dhcp
     271uspace/dist/srv/nconfsrv
     272uspace/srv/net/nconfsrv/nconfsrv
    271273uspace/app/netspeed/netspeed
    272274uspace/dist/app/netspeed

  • abi/include/abi/ipc/ipc.h

    r408424e rc42f50d  
    5959/** Interrupt notification */
    6060#define IPC_CALL_NOTIF  (1 << 3)
     61
     62/**
     63 * Maximum buffer size allowed for IPC_M_DATA_WRITE and
     64 * IPC_M_DATA_READ requests.
     65 */
     66#define DATA_XFER_LIMIT  (64 * 1024)
    6167
    6268

  • boot/Makefile.common

    r408424e rc42f50d  
    118118        $(USPACE_PATH)/srv/net/inetsrv/inetsrv \
    119119        $(USPACE_PATH)/srv/net/loopip/loopip \
     120        $(USPACE_PATH)/srv/net/nconfsrv/nconfsrv \
    120121        $(USPACE_PATH)/srv/net/slip/slip \
    121122        $(USPACE_PATH)/srv/net/tcp/tcp \
    … …  
    201202        $(USPACE_PATH)/app/nterm/nterm \
    202203        $(USPACE_PATH)/app/ping/ping \
    203         $(USPACE_PATH)/app/ping6/ping6 \
    204204        $(USPACE_PATH)/app/stats/stats \
    205205        $(USPACE_PATH)/app/sysinfo/sysinfo \
    … …  
    211211        $(USPACE_PATH)/app/date/date \
    212212        $(USPACE_PATH)/app/vdemo/vdemo \
     213        $(USPACE_PATH)/app/viewer/viewer \
    213214        $(USPACE_PATH)/app/df/df
    214215

  • kernel/generic/include/config.h

    r408424e rc42f50d  
    4747#define CONFIG_TASK_NAME_BUFLEN  32
    4848#define CONFIG_TASK_ARGUMENTS_BUFLEN 64
    49 
    50 /**
    51  * Maximum buffer size allowed for IPC_M_DATA_WRITE and IPC_M_DATA_READ
    52  * requests.
    53  */
    54 #define DATA_XFER_LIMIT  (64 * 1024)
    5549
    5650#ifndef __ASM__

  • tools/toolchain.sh

    r408424e rc42f50d  
    3636        GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
    3737
    38 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,2)
     38#if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4, 3, 2)
    3939        choke me
    4040#endif
    … …  
    5656BINUTILS_RELEASE=""
    5757GCC_VERSION="4.8.1"
    58 GDB_VERSION="7.6"
     58GDB_VERSION="7.6.1"
    5959
    6060BASEDIR="`pwd`"
    … …  
    303303        download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "33adb18c3048d057ac58d07a3f1adb38"
    304304        download_fetch "${GCC_SOURCE}" "${GCC}" "3b2386c114cd74185aa3754b58a79304"
    305         download_fetch "${GDB_SOURCE}" "${GDB}" "fda57170e4d11cdde74259ca575412a8"
     305        download_fetch "${GDB_SOURCE}" "${GDB}" "fbc4dab4181e6e9937075b43a4ce2732"
    306306}
    307307

  • uspace/Makefile

    r408424e rc42f50d  
    7676        app/nettest3 \
    7777        app/ping \
    78         app/ping6 \
    7978        app/sysinfo \
    8079        app/mkbd \
    8180        app/date \
    8281        app/vdemo \
     82        app/viewer \
    8383        app/vlaunch \
    8484        app/vterm \
    … …  
    9797        srv/net/inetsrv \
    9898        srv/net/loopip \
     99        srv/net/nconfsrv \
    99100        srv/net/slip \
    100101        srv/net/tcp \

  • uspace/app/dnsres/dnsres.c

    r408424e rc42f50d  
    3636#include <inet/addr.h>
    3737#include <inet/dnsr.h>
    38 #include <net/socket_codes.h>
    3938#include <stdio.h>
    4039#include <stdlib.h>
    … …  
    5453        }
    5554       
    56         uint16_t af;
     55        uint16_t ver;
    5756        char *hname;
    5857       
    … …  
    6362                }
    6463               
    65                 af = AF_INET;
     64                ver = ip_v4;
    6665                hname = argv[2];
    6766        } else if (str_cmp(argv[1], "-6") == 0) {
    … …  
    7170                }
    7271               
    73                 af = AF_INET6;
     72                ver = ip_v6;
    7473                hname = argv[2];
    7574        } else {
    76                 af = 0;
     75                ver = ip_any;
    7776                hname = argv[1];
    7877        }
    7978       
    8079        dnsr_hostinfo_t *hinfo;
    81         int rc = dnsr_name2host(hname, &hinfo, af);
     80        int rc = dnsr_name2host(hname, &hinfo, ver);
    8281        if (rc != EOK) {
    8382                printf("%s: Error resolving '%s'.\n", NAME, hname);

  • uspace/app/getterm/getterm.c

    r408424e rc42f50d  
    112112        reopen(&stderr, 2, term, O_WRONLY, "w");
    113113       
    114         /*
    115          * FIXME: fdopen() should actually detect that we are opening a console
    116          * and it should set line-buffering mode automatically.
    117          */
    118         setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
    119        
    120114        if (stdin == NULL)
    121115                return -2;
    … …  
    126120        if (stderr == NULL)
    127121                return -4;
     122       
     123        /*
     124         * FIXME: fdopen() should actually detect that we are opening a console
     125         * and it should set line-buffering mode automatically.
     126         */
     127        setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
    128128       
    129129        version_print(term);

  • uspace/app/init/init.c

    r408424e rc42f50d  
    360360        srv_start("/srv/udp");
    361361        srv_start("/srv/dnsrsrv");
     362        srv_start("/srv/dhcp");
     363        srv_start("/srv/nconfsrv");
    362364       
    363365        srv_start("/srv/clipboard");

  • uspace/app/netspeed/netspeed.c

    r408424e rc42f50d  
    3636 */
    3737
     38#include <assert.h>
     39#include <inet/dnsr.h>
     40#include <net/in.h>
     41#include <net/inet.h>
     42#include <net/socket.h>
    3843#include <stdio.h>
    3944#include <stdlib.h>
    … …  
    4146#include <str_error.h>
    4247#include <task.h>
    43 
    44 #include <net/in.h>
    45 #include <net/inet.h>
    46 #include <net/socket.h>
    4748
    4849#define NAME "netspeed"
    … …  
    114115}
    115116
    116 static int client(sock_type_t sock_type, const char *address, unsigned port,
     117static int client(sock_type_t sock_type, const char *host, unsigned port,
    117118    unsigned long count, char *buf, size_t bufsize)
    118119{
    119         struct sockaddr_in addr;
    120        
    121         addr.sin_family = AF_INET;
    122         addr.sin_port = htons(port);
    123        
    124         int rc = inet_pton(AF_INET, address, (void *) &addr.sin_addr.s_addr);
    125         if (rc != EOK) {
    126                 fprintf(stderr, "inet_pton failed: %s\n", str_error(rc));
    127                 return rc;
    128         }
    129        
    130         int conn_sd = socket(PF_INET, sock_type, 0);
     120        inet_addr_t iaddr;
     121        struct sockaddr *saddr;
     122        socklen_t saddrlen;
     123       
     124        int rc = inet_addr_parse(host, &iaddr);
     125        if (rc != EOK) {
     126                dnsr_hostinfo_t *hinfo = NULL;
     127                rc = dnsr_name2host(host, &hinfo, ip_any);
     128                if (rc != EOK) {
     129                        fprintf(stderr, "Error resolving host '%s'.\n", host);
     130                        return ENOENT;
     131                }
     132               
     133                iaddr = hinfo->addr;
     134        }
     135       
     136        rc = inet_addr_sockaddr(&iaddr, port, &saddr, &saddrlen);
     137        if (rc != EOK) {
     138                assert(rc == ENOMEM);
     139                fprintf(stderr, "Out of memory.\n");
     140                return ENOMEM;
     141        }
     142       
     143        int conn_sd = socket(saddr->sa_family, sock_type, 0);
    131144        if (conn_sd < 0) {
    132145                fprintf(stderr, "socket failed: %s\n", str_error(rc));
    … …  
    135148       
    136149        if (sock_type == SOCK_STREAM) {
    137                 rc = connect(conn_sd, (struct sockaddr *) &addr, sizeof(addr));
     150                rc = connect(conn_sd, saddr, saddrlen);
    138151                if (rc != EOK) {
    139152                        fprintf(stderr, "connect failed: %s\n", str_error(rc));
    … …  
    151164                        rc = send(conn_sd, buf, bufsize, 0);
    152165                } else {
    153                         rc = sendto(conn_sd, buf, bufsize, 0,
    154                             (struct sockaddr *) &addr, sizeof(addr));
     166                        rc = sendto(conn_sd, buf, bufsize, 0, saddr, saddrlen);
    155167                }
    156168                if (rc != EOK) {
    … …  
    161173       
    162174        closesocket(conn_sd);
     175        free(saddr);
    163176        return rc;
    164177}
    … …  
    167180{
    168181        fprintf(stderr, "Usage: netspeed <tcp|udp> server [port] <buffer size>\n");
    169         fprintf(stderr, "       netspeed <tcp|udp> client <ip> <port> <count> <buffer size>\n");
     182        fprintf(stderr, "       netspeed <tcp|udp> client <host> <port> <count> <buffer size>\n");
    170183}
    171184

  • uspace/app/nettest1/nettest1.c

    r408424e rc42f50d  
    3838#include "print_error.h"
    3939
     40#include <assert.h>
    4041#include <malloc.h>
    4142#include <stdio.h>
    … …  
    5960#define NETTEST1_TEXT  "Networking test 1 - sockets"
    6061
    61 static uint16_t family = AF_INET;
     62static uint16_t family = AF_NONE;
    6263static sock_type_t type = SOCK_DGRAM;
    6364static size_t size = 27;
    … …  
    326327        }
    327328       
    328         char *addr_s = argv[argc - 1];
     329        char *host = argv[argc - 1];
    329330       
    330331        /* Interpret as address */
    331         inet_addr_t addr_addr;
    332         rc = inet_addr_parse(addr_s, &addr_addr);
     332        inet_addr_t iaddr;
     333        rc = inet_addr_parse(host, &iaddr);
    333334       
    334335        if (rc != EOK) {
    335336                /* Interpret as a host name */
    336337                dnsr_hostinfo_t *hinfo = NULL;
    337                 rc = dnsr_name2host(addr_s, &hinfo, family);
     338                rc = dnsr_name2host(host, &hinfo, ipver_from_af(family));
    338339               
    339340                if (rc != EOK) {
    340                         printf("Error resolving host '%s'.\n", addr_s);
     341                        printf("Error resolving host '%s'.\n", host);
    341342                        return EINVAL;
    342343                }
    343344               
    344                 addr_addr = hinfo->addr;
    345         }
    346        
    347         struct sockaddr_in addr;
    348         struct sockaddr_in6 addr6;
    349         uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
    350        
    351         if (af != family) {
     345                iaddr = hinfo->addr;
     346        }
     347       
     348        rc = inet_addr_sockaddr(&iaddr, port, &address, &addrlen);
     349        if (rc != EOK) {
     350                assert(rc == ENOMEM);
     351                printf("Out of memory.\n");
     352                return ENOMEM;
     353        }
     354       
     355        if (family == AF_NONE)
     356                family = address->sa_family;
     357       
     358        if (address->sa_family != family) {
    352359                printf("Address family does not match explicitly set family.\n");
    353360                return EINVAL;
    354         }
    355        
    356         /* Prepare the address buffer */
    357        
    358         switch (af) {
    359         case AF_INET:
    360                 addr.sin_port = htons(port);
    361                 address = (struct sockaddr *) &addr;
    362                 addrlen = sizeof(addr);
    363                 break;
    364         case AF_INET6:
    365                 addr6.sin6_port = htons(port);
    366                 address = (struct sockaddr *) &addr6;
    367                 addrlen = sizeof(addr6);
    368                 break;
    369         default:
    370                 fprintf(stderr, "Address family is not supported\n");
    371                 return EAFNOSUPPORT;
    372361        }
    373362       
    … …  
    434423            &time_before));
    435424       
     425        free(address);
     426       
    436427        if (verbose)
    437428                printf("Exiting\n");

  • uspace/app/nettest2/nettest2.c

    r408424e rc42f50d  
    3838#include "print_error.h"
    3939
     40#include <assert.h>
    4041#include <malloc.h>
    4142#include <stdio.h>
    … …  
    6061#define NETTEST2_TEXT  "Networking test 2 - transfer"
    6162
    62 static uint16_t family = PF_INET;
     63static uint16_t family = AF_NONE;
    6364static size_t size = 28;
    6465static bool verbose = false;
    … …  
    271272                /* Interpret as a host name */
    272273                dnsr_hostinfo_t *hinfo = NULL;
    273                 rc = dnsr_name2host(addr_s, &hinfo, family);
     274                rc = dnsr_name2host(addr_s, &hinfo, ipver_from_af(family));
    274275               
    275276                if (rc != EOK) {
    … …  
    281282        }
    282283       
    283         struct sockaddr_in addr;
    284         struct sockaddr_in6 addr6;
    285         uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
    286        
    287         if (af != family) {
     284        struct sockaddr *address;
     285        socklen_t addrlen;
     286        rc = inet_addr_sockaddr(&addr_addr, port, &address, &addrlen);
     287        if (rc != EOK) {
     288                assert(rc == ENOMEM);
     289                printf("Out of memory.\n");
     290                return ENOMEM;
     291        }
     292       
     293        if (family == AF_NONE)
     294                family = address->sa_family;
     295       
     296        if (address->sa_family != family) {
    288297                printf("Address family does not match explicitly set family.\n");
    289298                return EINVAL;
    290         }
    291        
    292         /* Prepare the address buffer */
    293        
    294         struct sockaddr *address;
    295         socklen_t addrlen;
    296        
    297         switch (af) {
    298         case AF_INET:
    299                 addr.sin_port = htons(port);
    300                 address = (struct sockaddr *) &addr;
    301                 addrlen = sizeof(addr);
    302                 break;
    303         case AF_INET6:
    304                 addr6.sin6_port = htons(port);
    305                 address = (struct sockaddr *) &addr6;
    306                 addrlen = sizeof(addr6);
    307                 break;
    308         default:
    309                 fprintf(stderr, "Address family is not supported\n");
    310                 return EAFNOSUPPORT;
    311299        }
    312300       
    … …  
    424412                return rc;
    425413       
     414        free(address);
     415       
    426416        if (verbose)
    427417                printf("\nExiting\n");

  • uspace/app/nettest3/nettest3.c

    r408424e rc42f50d  
    3737#include <async.h>
    3838#include <stdio.h>
     39#include <stdlib.h>
    3940#include <str.h>
    4041
    … …  
    5253static char buf[BUF_SIZE];
    5354
    54 static struct sockaddr_in addr;
     55static struct sockaddr *address;
     56static socklen_t addrlen;
    5557
    5658static uint16_t port;
    … …  
    6264        char *endptr;
    6365        dnsr_hostinfo_t *hinfo;
     66        inet_addr_t addr;
     67        char *addr_s;
    6468
    6569        port = 7;
    … …  
    6973
    7074        /* Connect to local IP address by default */
    71         addr.sin_family = AF_INET;
    72         addr.sin_port = htons(port);
    73         addr.sin_addr.s_addr = htonl(0x7f000001);
     75        inet_addr(&addr, 127, 0, 0, 1);
    7476
    7577        if (argc >= 2) {
    7678                printf("parsing address '%s'\n", argv[1]);
    77                 rc = inet_pton(AF_INET, argv[1], (uint8_t *)&addr.sin_addr.s_addr);
     79                rc = inet_addr_parse(argv[1], &addr);
    7880                if (rc != EOK) {
    7981                        /* Try interpreting as a host name */
    80                         rc = dnsr_name2host(argv[1], &hinfo, AF_INET);
     82                        rc = dnsr_name2host(argv[1], &hinfo, ip_v4);
    8183                        if (rc != EOK) {
    8284                                printf("Error resolving host '%s'.\n", argv[1]);
    8385                                return rc;
    8486                        }
    85                        
    86                         uint16_t af = inet_addr_sockaddr_in(&hinfo->addr, &addr, NULL);
    87                         if (af != AF_INET) {
    88                                 printf("Host '%s' not resolved as IPv4 address.\n", argv[1]);
    89                                 return rc;
    90                         }
     87
     88                        addr = hinfo->addr;
    9189                }
    92                 printf("result: rc=%d, family=%d, addr=%x\n", rc,
    93                     addr.sin_family, addr.sin_addr.s_addr);
     90                rc = inet_addr_format(&addr, &addr_s);
     91                if (rc != EOK) {
     92                        assert(rc == ENOMEM);
     93                        printf("Out of memory.\n");
     94                        return rc;
     95                }
     96                printf("result: rc=%d, ver=%d, addr=%s\n", rc,
     97                    addr.version, addr_s);
     98                free(addr_s);
    9499        }
    95100
    96101        if (argc >= 3) {
    97102                printf("parsing port '%s'\n", argv[2]);
    98                 addr.sin_port = htons(strtoul(argv[2], &endptr, 10));
     103                port = htons(strtoul(argv[2], &endptr, 10));
    99104                if (*endptr != '\0') {
    100105                        fprintf(stderr, "Error parsing port\n");
    … …  
    103108        }
    104109
     110        rc = inet_addr_sockaddr(&hinfo->addr, port, &address, &addrlen);
     111        if (rc != EOK) {
     112                printf("Out of memory.\n");
     113                return rc;
     114        }
     115
    105116        printf("socket()\n");
    106         fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
     117        fd = socket(address->sa_family, SOCK_STREAM, IPPROTO_TCP);
    107118        printf(" -> %d\n", fd);
    108119        if (fd < 0)
    … …  
    110121
    111122        printf("connect()\n");
    112         rc = connect(fd, (struct sockaddr *) &addr, sizeof(addr));
     123        rc = connect(fd, address, addrlen);
    113124        printf(" -> %d\n", rc);
    114125        if (rc != 0)
    … …  
    133144        printf(" -> %d\n", rc);
    134145
     146        free(address);
     147
    135148        return 0;
    136149}

  • uspace/app/nterm/conn.c

    r408424e rc42f50d  
    3838#include <fibril.h>
    3939#include <inet/dnsr.h>
     40#include <net/inet.h>
    4041#include <net/socket.h>
    4142#include <stdio.h>
     43#include <stdlib.h>
    4244#include <str_error.h>
    4345#include <sys/types.h>
    … …  
    7375}
    7476
    75 int conn_open(const char *addr_s, const char *port_s)
     77int conn_open(const char *host, const char *port_s)
    7678{
    7779        int conn_fd = -1;
     80        struct sockaddr *saddr = NULL;
     81        socklen_t saddrlen;
    7882       
    7983        /* Interpret as address */
    80         inet_addr_t addr_addr;
    81         int rc = inet_addr_parse(addr_s, &addr_addr);
     84        inet_addr_t iaddr;
     85        int rc = inet_addr_parse(host, &iaddr);
    8286       
    8387        if (rc != EOK) {
    8488                /* Interpret as a host name */
    8589                dnsr_hostinfo_t *hinfo = NULL;
    86                 rc = dnsr_name2host(addr_s, &hinfo, 0);
     90                rc = dnsr_name2host(host, &hinfo, ip_any);
    8791               
    8892                if (rc != EOK) {
    89                         printf("Error resolving host '%s'.\n", addr_s);
     93                        printf("Error resolving host '%s'.\n", host);
    9094                        goto error;
    9195                }
    9296               
    93                 addr_addr = hinfo->addr;
     97                iaddr = hinfo->addr;
    9498        }
    95        
    96         struct sockaddr_in addr;
    97         struct sockaddr_in6 addr6;
    98         uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
    9999       
    100100        char *endptr;
    … …  
    105105        }
    106106       
    107         printf("Connecting to host %s port %u\n", addr_s, port);
     107        rc = inet_addr_sockaddr(&iaddr, port, &saddr, &saddrlen);
     108        if (rc != EOK) {
     109                assert(rc == ENOMEM);
     110                printf("Out of memory.\n");
     111                return ENOMEM;
     112        }
    108113       
    109         conn_fd = socket(PF_INET, SOCK_STREAM, 0);
     114        printf("Connecting to host %s port %u\n", host, port);
     115       
     116        conn_fd = socket(saddr->sa_family, SOCK_STREAM, 0);
    110117        if (conn_fd < 0)
    111118                goto error;
    112119       
    113         switch (af) {
    114         case AF_INET:
    115                 addr.sin_port = htons(port);
    116                 rc = connect(conn_fd, (struct sockaddr *) &addr, sizeof(addr));
    117                 break;
    118         case AF_INET6:
    119                 addr6.sin6_port = htons(port);
    120                 rc = connect(conn_fd, (struct sockaddr *) &addr6, sizeof(addr6));
    121                 break;
    122         default:
    123                 printf("Unknown address family.\n");
    124                 goto error;
    125         }
    126        
     120        rc = connect(conn_fd, saddr, saddrlen);
    127121        if (rc != EOK)
    128122                goto error;
    … …  
    134128        fibril_add_ready(rcv_fid);
    135129       
     130        free(saddr);
    136131        return EOK;
    137        
    138132error:
    139133        if (conn_fd >= 0) {
    … …  
    141135                conn_fd = -1;
    142136        }
     137        free(saddr);
    143138       
    144139        return EIO;

  • uspace/app/ping/ping.c

    r408424e rc42f50d  
    3737#include <errno.h>
    3838#include <fibril_synch.h>
    39 #include <net/socket_codes.h>
    4039#include <inet/dnsr.h>
    4140#include <inet/addr.h>
    … …  
    7776};
    7877
    79 static addr32_t src;
    80 static addr32_t dest;
     78static inet_addr_t src_addr;
     79static inet_addr_t dest_addr;
    8180
    8281static bool repeat_forever = false;
    8382static size_t repeat_count = 1;
    8483
    85 static const char *short_options = "rn:";
     84static const char *short_options = "46rn:";
    8685
    8786static void print_syntax(void)
    8887{
    89         printf("Syntax: %s [-n <count>|-r] <host>\n", NAME);
     88        printf("Syntax: %s [<options>] <host>\n", NAME);
     89        printf("\t-n <count> Repeat the specified number of times\n");
     90        printf("\t-r         Repeat forever\n");
     91        printf("\t-4|-6      Use IPv4 or IPv6 destination host address\n");
    9092}
    9193
    … …  
    108110static int ping_ev_recv(inetping_sdu_t *sdu)
    109111{
    110         inet_addr_t src_addr;
    111         inet_addr_set(sdu->src, &src_addr);
    112        
    113         inet_addr_t dest_addr;
    114         inet_addr_set(sdu->dest, &dest_addr);
    115        
    116112        char *asrc;
    117113        int rc = inet_addr_format(&src_addr, &asrc);
    … …  
    140136        inetping_sdu_t sdu;
    141137       
    142         sdu.src = src;
    143         sdu.dest = dest;
     138        sdu.src = src_addr;
     139        sdu.dest = dest_addr;
    144140        sdu.seq_no = seq_no;
    145141        sdu.data = (void *) "foo";
    … …  
    222218        char *adest = NULL;
    223219        char *sdest = NULL;
     220        ip_ver_t ip_ver = ip_any;
    224221       
    225222        int rc = inetping_init(&ev_ops);
    … …  
    244241                        }
    245242                        break;
     243                case '4':
     244                        ip_ver = ip_v4;
     245                        break;
     246                case '6':
     247                        ip_ver = ip_v6;
     248                        break;
    246249                default:
    247250                        printf("Unknown option passed.\n");
    … …  
    258261       
    259262        /* Parse destination address */
    260         inet_addr_t dest_addr;
    261263        rc = inet_addr_parse(argv[optind], &dest_addr);
    262264        if (rc != EOK) {
    263265                /* Try interpreting as a host name */
    264                 rc = dnsr_name2host(argv[optind], &hinfo, AF_INET);
     266                rc = dnsr_name2host(argv[optind], &hinfo, ip_ver);
    265267                if (rc != EOK) {
    266268                        printf("Error resolving host '%s'.\n", argv[optind]);
    … …  
    271273        }
    272274       
    273         uint16_t af = inet_addr_get(&dest_addr, &dest, NULL);
    274         if (af != AF_INET) {
    275                 printf("Destination '%s' is not an IPv4 address.\n",
    276                     argv[optind]);
    277                 goto error;
    278         }
    279        
    280275        /* Determine source address */
    281         rc = inetping_get_srcaddr(dest, &src);
     276        rc = inetping_get_srcaddr(&dest_addr, &src_addr);
    282277        if (rc != EOK) {
    283278                printf("Failed determining source address.\n");
    284279                goto error;
    285280        }
    286        
    287         inet_addr_t src_addr;
    288         inet_addr_set(src, &src_addr);
    289281       
    290282        rc = inet_addr_format(&src_addr, &asrc);

  • uspace/lib/c/Makefile

    r408424e rc42f50d  
    7777        generic/device/pci.c \
    7878        generic/device/ahci.c \
     79        generic/dhcp.c \
    7980        generic/dnsr.c \
    8081        generic/dlfcn.c \
    … …  
    99100        generic/inetcfg.c \
    100101        generic/inetping.c \
    101         generic/inetping6.c \
    102102        generic/io/asprintf.c \
    103103        generic/io/input.c \

  • uspace/lib/c/generic/dnsr.c

    r408424e rc42f50d  
    6767}
    6868
    69 int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo, uint16_t af)
     69int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo, ip_ver_t ver)
    7070{
    7171        dnsr_hostinfo_t *info = calloc(1, sizeof(dnsr_hostinfo_t));
    … …  
    7676       
    7777        ipc_call_t answer;
    78         aid_t req = async_send_1(exch, DNSR_NAME2HOST, (sysarg_t) af,
     78        aid_t req = async_send_1(exch, DNSR_NAME2HOST, (sysarg_t) ver,
    7979            &answer);
    8080       

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

    r408424e rc42f50d  
    3030#include <assert.h>
    3131#include <errno.h>
    32 #include <net/socket_codes.h>
    3332#include <inet/inet.h>
    3433#include <ipc/inet.h>

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

    r408424e rc42f50d  
    3333 */
    3434
     35#include <assert.h>
    3536#include <errno.h>
    3637#include <unistd.h>
    … …  
    5960
    6061static const inet_addr_t inet_addr_any_addr = {
    61         .family = AF_INET,
     62        .version = ip_v4,
    6263        .addr = 0
    6364};
    6465
    6566static const inet_addr_t inet_addr_any_addr6 = {
    66         .family = AF_INET6,
     67        .version = ip_v6,
    6768        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    6869};
    … …  
    7879}
    7980
     81/** Compare addr48.
     82  *
     83  * @return Non-zero if equal, zero if not equal.
     84  */
    8085int addr48_compare(const addr48_t a, const addr48_t b)
    8186{
    82         return memcmp(a, b, 6);
    83 }
    84 
     87        return memcmp(a, b, 6) == 0;
     88}
     89
     90/** Compare addr128.
     91  *
     92  * @return Non-zero if equal, zero if not equal.
     93  */
    8594int addr128_compare(const addr128_t a, const addr128_t b)
    8695{
    87         return memcmp(a, b, 16);
     96        return memcmp(a, b, 16) == 0;
    8897}
    8998
    … …  
    102111void host2addr128_t_be(const addr128_t host, addr128_t be)
    103112{
    104 #ifdef __BE__
    105113        memcpy(be, host, 16);
    106 #else
    107         be[0] = host[15];
    108         be[1] = host[14];
    109         be[2] = host[13];
    110         be[3] = host[12];
    111         be[4] = host[11];
    112         be[5] = host[10];
    113         be[6] = host[9];
    114         be[7] = host[8];
    115         be[8] = host[7];
    116         be[9] = host[6];
    117         be[10] = host[5];
    118         be[11] = host[4];
    119         be[12] = host[3];
    120         be[13] = host[2];
    121         be[14] = host[1];
    122         be[15] = host[0];
    123 #endif
    124114}
    125115
    126116void addr128_t_be2host(const addr128_t be, addr128_t host)
    127117{
    128 #ifdef __BE__
    129118        memcpy(host, be, 16);
    130 #else
    131         host[0] = be[15];
    132         host[1] = be[14];
    133         host[2] = be[13];
    134         host[3] = be[12];
    135         host[4] = be[11];
    136         host[5] = be[10];
    137         host[6] = be[9];
    138         host[7] = be[8];
    139         host[8] = be[7];
    140         host[9] = be[6];
    141         host[10] = be[5];
    142         host[11] = be[4];
    143         host[12] = be[3];
    144         host[13] = be[2];
    145         host[14] = be[1];
    146         host[15] = be[0];
    147 #endif
    148119}
    149120
    150121void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
    151122{
    152         addr->family = AF_INET;
     123        addr->version = ip_v4;
    153124        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    154125            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    158129    uint8_t prefix)
    159130{
    160         naddr->family = AF_INET;
     131        naddr->version = ip_v4;
    161132        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
    162133            ((addr32_t) c << 8) | ((addr32_t) d);
    … …  
    167138    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
    168139{
    169         addr->family = AF_INET6;
     140        addr->version = ip_v6;
    170141        addr->addr6[0] = (a >> 8) & 0xff;
    171142        addr->addr6[1] = a & 0xff;
    … …  
    189160    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
    190161{
    191         naddr->family = AF_INET6;
     162        naddr->version = ip_v6;
    192163        naddr->addr6[0] = (a >> 8) & 0xff;
    193164        naddr->addr6[1] = a & 0xff;
    … …  
    209180}
    210181
    211 /** Parse network address family.
    212  *
    213  * @param text Network address in common notation.
    214  * @param af   Place to store network address family.
     182/** Determine address version.
     183 *
     184 * @param text Address in common notation.
     185 * @param af   Place to store address version.
    215186 *
    216187 * @return EOK on success, EINVAL if input is not in valid format.
    217188 *
    218189 */
    219 int inet_addr_family(const char *text, uint16_t *af)
     190static int inet_addr_version(const char *text, ip_ver_t *ver)
    220191{
    221192        char *dot = str_chr(text, '.');
    222193        if (dot != NULL) {
    223                 *af = AF_INET;
     194                *ver = ip_v4;
    224195                return EOK;
    225196        }
    226        
     197
    227198        char *collon = str_chr(text, ':');
    228199        if (collon != NULL) {
    229                 *af = AF_INET6;
     200                *ver = ip_v6;
    230201                return EOK;
    231202        }
    232        
     203
    233204        return EINVAL;
    234205}
    235206
     207static 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
     222ip_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
    236237void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
    237238{
    238         addr->family = naddr->family;
     239        addr->version = naddr->version;
    239240        memcpy(addr->addr6, naddr->addr6, 16);
    240241}
    … …  
    243244    inet_naddr_t *naddr)
    244245{
    245         naddr->family = addr->family;
     246        naddr->version = addr->version;
    246247        memcpy(naddr->addr6, addr->addr6, 16);
    247248        naddr->prefix = prefix;
    … …  
    250251void inet_addr_any(inet_addr_t *addr)
    251252{
    252         addr->family = AF_NONE;
     253        addr->version = ip_any;
    253254        memset(addr->addr6, 0, 16);
    254255}
    … …  
    256257void inet_naddr_any(inet_naddr_t *naddr)
    257258{
    258         naddr->family = AF_NONE;
     259        naddr->version = ip_any;
    259260        memset(naddr->addr6, 0, 16);
    260261        naddr->prefix = 0;
    … …  
    263264int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
    264265{
    265         if (a->family != b->family)
     266        if (a->version != b->version)
    266267                return 0;
    267        
    268         switch (a->family) {
    269         case AF_INET:
     268
     269        switch (a->version) {
     270        case ip_v4:
    270271                return (a->addr == b->addr);
    271         case AF_INET6:
     272        case ip_v6:
    272273                return addr128_compare(a->addr6, b->addr6);
    273274        default:
    … …  
    278279int inet_addr_is_any(const inet_addr_t *addr)
    279280{
    280         return ((addr->family == 0) ||
     281        return ((addr->version == ip_any) ||
    281282            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
    282283            (inet_addr_compare(addr, &inet_addr_any_addr6)));
    … …  
    285286int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
    286287{
    287         if (naddr->family != addr->family)
     288        if (naddr->version != addr->version)
    288289                return 0;
    289290       
    290         switch (naddr->family) {
    291         case AF_INET:
     291        switch (naddr->version) {
     292        case ip_v4:
    292293                return (naddr->addr == addr->addr);
    293         case AF_INET6:
     294        case ip_v6:
    294295                return addr128_compare(naddr->addr6, addr->addr6);
    295296        default:
    … …  
    300301int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
    301302{
    302         if (naddr->family != addr->family)
     303        if (naddr->version != addr->version)
    303304                return 0;
    304        
    305         switch (naddr->family) {
    306         case AF_INET:
     305
     306        switch (naddr->version) {
     307        case ip_v4:
    307308                if (naddr->prefix > 32)
    308309                        return 0;
    309                
     310
    310311                addr32_t mask =
    311312                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
    312313                return ((naddr->addr & mask) == (addr->addr & mask));
    313         case AF_INET6:
     314        case ip_v6:
    314315                if (naddr->prefix > 128)
    315316                        return 0;
    … …  
    352353int inet_addr_parse(const char *text, inet_addr_t *addr)
    353354{
    354         int rc = inet_addr_family(text, &addr->family);
     355        int rc = inet_addr_version(text, &addr->version);
    355356        if (rc != EOK)
    356357                return rc;
    357358       
    358359        uint8_t buf[16];
    359         rc = inet_pton(addr->family, text, buf);
     360        rc = inet_pton(ipver_af(addr->version), text, buf);
    360361        if (rc != EOK)
    361362                return rc;
    362363       
    363         switch (addr->family) {
    364         case AF_INET:
     364        switch (addr->version) {
     365        case ip_v4:
    365366                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
    366367                    buf[3];
    367368                break;
    368         case AF_INET6:
     369        case ip_v6:
    369370                memcpy(addr->addr6, buf, 16);
    370371                break;
    … …  
    392393        *slash = 0;
    393394       
    394         int rc = inet_addr_family(text, &naddr->family);
     395        int rc = inet_addr_version(text, &naddr->version);
    395396        if (rc != EOK)
    396397                return rc;
    397398       
    398399        uint8_t buf[16];
    399         rc = inet_pton(naddr->family, text, buf);
     400        rc = inet_pton(ipver_af(naddr->version), text, buf);
    400401        *slash = '/';
    401402       
    … …  
    406407        uint8_t prefix;
    407408       
    408         switch (naddr->family) {
    409         case AF_INET:
     409        switch (naddr->version) {
     410        case ip_v4:
    410411                prefix = strtoul(slash, &slash, 10);
    411412                if (prefix > 32)
    … …  
    417418               
    418419                break;
    419         case AF_INET6:
     420        case ip_v6:
    420421                prefix = strtoul(slash, &slash, 10);
    421422                if (prefix > 128)
    … …  
    447448        int rc = 0;
    448449       
    449         switch (addr->family) {
    450         case AF_NONE:
     450        switch (addr->version) {
     451        case ip_any:
    451452                rc = asprintf(bufp, "none");
    452453                break;
    453         case AF_INET:
     454        case ip_v4:
    454455                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
    455456                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
    456457                    addr->addr & 0xff);
    457458                break;
    458         case AF_INET6:
     459        case ip_v6:
    459460                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
    460461                if (*bufp == NULL)
    … …  
    487488        char prefix[INET_PREFIXSTRSIZE];
    488489       
    489         switch (naddr->family) {
    490         case AF_NONE:
     490        switch (naddr->version) {
     491        case ip_any:
    491492                rc = asprintf(bufp, "none");
    492493                break;
    493         case AF_INET:
     494        case ip_v4:
    494495                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
    495496                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
    … …  
    497498                    naddr->addr & 0xff, naddr->prefix);
    498499                break;
    499         case AF_INET6:
     500        case ip_v6:
    500501                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
    501502                if (*bufp == NULL)
    … …  
    529530}
    530531
    531 uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
    532 {
    533         switch (addr->family) {
    534         case AF_INET:
     532ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
     533{
     534        switch (addr->version) {
     535        case ip_v4:
    535536                if (v4 != NULL)
    536537                        *v4 = addr->addr;
    537                
    538                 break;
    539         case AF_INET6:
     538                break;
     539        case ip_v6:
    540540                if (v6 != NULL)
    541541                        memcpy(*v6, addr->addr6, 16);
    542                
    543                 break;
    544         }
    545        
    546         return addr->family;
    547 }
    548 
    549 uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
     542                break;
     543        default:
     544                assert(false);
     545                break;
     546        }
     547
     548        return addr->version;
     549}
     550
     551ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
    550552    uint8_t *prefix)
    551553{
    552         switch (naddr->family) {
    553         case AF_INET:
     554        switch (naddr->version) {
     555        case ip_v4:
    554556                if (v4 != NULL)
    555557                        *v4 = naddr->addr;
    556                
    557558                if (prefix != NULL)
    558559                        *prefix = naddr->prefix;
    559                
    560                 break;
    561         case AF_INET6:
     560                break;
     561        case ip_v6:
    562562                if (v6 != NULL)
    563563                        memcpy(*v6, naddr->addr6, 16);
    564                
    565564                if (prefix != NULL)
    566565                        *prefix = naddr->prefix;
    567                
    568                 break;
    569         }
    570        
    571         return naddr->family;
     566                break;
     567        default:
     568                assert(false);
     569                break;
     570        }
     571
     572        return naddr->version;
    572573}
    573574
    574575void inet_addr_set(addr32_t v4, inet_addr_t *addr)
    575576{
    576         addr->family = AF_INET;
     577        addr->version = ip_v4;
    577578        addr->addr = v4;
    578579}
    … …  
    580581void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
    581582{
    582         naddr->family = AF_INET;
     583        naddr->version = ip_v4;
    583584        naddr->addr = v4;
    584585        naddr->prefix = prefix;
    … …  
    587588void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
    588589{
    589         addr->family = AF_INET;
     590        addr->version = ip_v4;
    590591        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
    591592}
    … …  
    593594void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
    594595{
    595         addr->family = AF_INET6;
     596        addr->version = ip_v6;
    596597        memcpy(addr->addr6, v6, 16);
    597598}
    … …  
    599600void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
    600601{
    601         naddr->family = AF_INET6;
     602        naddr->version = ip_v6;
    602603        memcpy(naddr->addr6, v6, 16);
    603604        naddr->prefix = prefix;
    … …  
    607608    inet_addr_t *addr)
    608609{
    609         addr->family = AF_INET6;
     610        addr->version = ip_v6;
    610611        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
    611612}
    … …  
    614615    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
    615616{
    616         switch (addr->family) {
    617         case AF_INET:
     617        switch (addr->version) {
     618        case ip_v4:
    618619                if (sockaddr_in != NULL) {
    619620                        sockaddr_in->sin_family = AF_INET;
    620621                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
    621622                }
    622                
    623                 break;
    624         case AF_INET6:
     623                break;
     624        case ip_v6:
    625625                if (sockaddr_in6 != NULL) {
    626626                        sockaddr_in6->sin6_family = AF_INET6;
    627627                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
    628628                }
    629                
    630                 break;
    631         }
    632        
    633         return addr->family;
     629                break;
     630        default:
     631                assert(false);
     632                break;
     633        }
     634
     635        return ipver_af(addr->version);
     636}
     637
     638int 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;
    634677}
    635678

  • uspace/lib/c/generic/inetcfg.c

    r408424e rc42f50d  
    267267}
    268268
     269int inetcfg_link_add(sysarg_t link_id)
     270{
     271        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     272
     273        int rc = async_req_1_0(exch, INETCFG_LINK_ADD, link_id);
     274        async_exchange_end(exch);
     275
     276        return rc;
     277}
     278
    269279int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    270280{
    … …  
    305315}
    306316
     317int inetcfg_link_remove(sysarg_t link_id)
     318{
     319        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
     320
     321        int rc = async_req_1_0(exch, INETCFG_LINK_REMOVE, link_id);
     322        async_exchange_end(exch);
     323
     324        return rc;
     325}
     326
    307327int inetcfg_sroute_create(const char *name, inet_naddr_t *dest,
    308328    inet_addr_t *router, sysarg_t *sroute_id)

  • uspace/lib/c/generic/inetping.c

    r408424e rc42f50d  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
     3 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    4950
    5051        assert(inetping_sess == NULL);
    51        
     52
    5253        inetping_ev_ops = ev_ops;
    53        
     54
    5455        rc = loc_service_get_id(SERVICE_NAME_INETPING, &inetping_svc,
    5556            IPC_FLAG_BLOCKING);
    5657        if (rc != EOK)
    5758                return ENOENT;
    58        
     59
    5960        inetping_sess = loc_service_connect(EXCHANGE_SERIALIZE, inetping_svc,
    6061            IPC_FLAG_BLOCKING);
    6162        if (inetping_sess == NULL)
    6263                return ENOENT;
    63        
     64
    6465        async_exch_t *exch = async_exchange_begin(inetping_sess);
    6566
    6667        rc = async_connect_to_me(exch, 0, 0, 0, inetping_cb_conn, NULL);
    6768        async_exchange_end(exch);
    68        
     69
    6970        if (rc != EOK) {
    7071                async_hangup(inetping_sess);
    … …  
    7273                return rc;
    7374        }
    74        
     75
    7576        return EOK;
    7677}
    … …  
    7980{
    8081        async_exch_t *exch = async_exchange_begin(inetping_sess);
    81        
     82
    8283        ipc_call_t answer;
    83         aid_t req = async_send_3(exch, INETPING_SEND, (sysarg_t) sdu->src,
    84             (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    85         sysarg_t retval = async_data_write_start(exch, sdu->data, sdu->size);
    86        
     84        aid_t req = async_send_1(exch, INETPING_SEND, sdu->seq_no, &answer);
     85
     86        int rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
     87        if (rc != EOK) {
     88                async_exchange_end(exch);
     89                async_forget(req);
     90                return rc;
     91        }
     92
     93        rc = async_data_write_start(exch, &sdu->dest, sizeof(sdu->dest));
     94        if (rc != EOK) {
     95                async_exchange_end(exch);
     96                async_forget(req);
     97                return rc;
     98        }
     99
     100        rc = async_data_write_start(exch, sdu->data, sdu->size);
     101
    87102        async_exchange_end(exch);
    88        
    89         if (retval != EOK) {
    90                 async_forget(req);
    91                 return retval;
    92         }
    93        
     103
     104        if (rc != EOK) {
     105                async_forget(req);
     106                return rc;
     107        }
     108
     109        sysarg_t retval;
    94110        async_wait_for(req, &retval);
    95         return retval;
    96 }
    97 
    98 int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
     111
     112        return (int) retval;
     113}
     114
     115int inetping_get_srcaddr(const inet_addr_t *remote, inet_addr_t *local)
    99116{
    100117        async_exch_t *exch = async_exchange_begin(inetping_sess);
    101        
    102         sysarg_t local_addr;
    103         int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
    104             &local_addr);
    105        
     118
     119        ipc_call_t answer;
     120        aid_t req = async_send_0(exch, INETPING_GET_SRCADDR, &answer);
     121
     122        int rc = async_data_write_start(exch, remote, sizeof(*remote));
     123        if (rc != EOK) {
     124                async_exchange_end(exch);
     125                async_forget(req);
     126                return rc;
     127        }
     128
     129        ipc_call_t answer_local;
     130        aid_t req_local = async_data_read(exch, local, sizeof(*local),
     131            &answer_local);
     132
    106133        async_exchange_end(exch);
    107        
    108         if (rc != EOK)
    109                 return rc;
    110        
    111         *local = (uint32_t) local_addr;
    112         return EOK;
    113 }
    114 
    115 static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
     134
     135        sysarg_t retval_local;
     136        async_wait_for(req_local, &retval_local);
     137
     138        if (retval_local != EOK) {
     139                async_forget(req);
     140                return (int) retval_local;
     141        }
     142
     143        sysarg_t retval;
     144        async_wait_for(req, &retval);
     145
     146        return (int) retval;
     147}
     148
     149static void inetping_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
    116150{
    117151        inetping_sdu_t sdu;
    118        
    119         sdu.src = IPC_GET_ARG1(*call);
    120         sdu.dest = IPC_GET_ARG2(*call);
    121         sdu.seq_no = IPC_GET_ARG3(*call);
    122        
    123         int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     152
     153        sdu.seq_no = IPC_GET_ARG1(*icall);
     154
     155        ipc_callid_t callid;
     156        size_t size;
     157        if (!async_data_write_receive(&callid, &size)) {
     158                async_answer_0(callid, EREFUSED);
     159                async_answer_0(iid, EREFUSED);
     160                return;
     161        }
     162
     163        if (size != sizeof(sdu.src)) {
     164                async_answer_0(callid, EINVAL);
     165                async_answer_0(iid, EINVAL);
     166                return;
     167        }
     168
     169        int rc = async_data_write_finalize(callid, &sdu.src, size);
    124170        if (rc != EOK) {
    125171                async_answer_0(callid, rc);
    126                 return;
    127         }
    128        
     172                async_answer_0(iid, rc);
     173                return;
     174        }
     175
     176        if (!async_data_write_receive(&callid, &size)) {
     177                async_answer_0(callid, EREFUSED);
     178                async_answer_0(iid, EREFUSED);
     179                return;
     180        }
     181
     182        if (size != sizeof(sdu.dest)) {
     183                async_answer_0(callid, EINVAL);
     184                async_answer_0(iid, EINVAL);
     185                return;
     186        }
     187
     188        rc = async_data_write_finalize(callid, &sdu.dest, size);
     189        if (rc != EOK) {
     190                async_answer_0(callid, rc);
     191                async_answer_0(iid, rc);
     192                return;
     193        }
     194
     195        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
     196        if (rc != EOK) {
     197                async_answer_0(iid, rc);
     198                return;
     199        }
     200
    129201        rc = inetping_ev_ops->recv(&sdu);
    130202        free(sdu.data);
    131         async_answer_0(callid, rc);
     203        async_answer_0(iid, rc);
    132204}
    133205

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

    r408424e rc42f50d  
    218218        iplink_recv_sdu_t sdu;
    219219       
    220         uint16_t af = IPC_GET_ARG1(*icall);
     220        ip_ver_t ver = IPC_GET_ARG1(*icall);
    221221       
    222222        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
    … …  
    227227        }
    228228       
    229         rc = iplink->ev_ops->recv(iplink, &sdu, af);
     229        rc = iplink->ev_ops->recv(iplink, &sdu, ver);
    230230        free(sdu.data);
    231231        async_answer_0(iid, rc);

  • uspace/lib/c/generic/iplink_srv.c

    r408424e rc42f50d  
    272272}
    273273
    274 int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, uint16_t af)
     274/* XXX Version should be part of @a sdu */
     275int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, ip_ver_t ver)
    275276{
    276277        if (srv->client_sess == NULL)
    … …  
    280281       
    281282        ipc_call_t answer;
    282         aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t) af,
     283        aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t)ver,
    283284            &answer);
    284285       

  • uspace/lib/c/generic/vfs/vfs.c

    r408424e rc42f50d  
    342342}
    343343
    344 ssize_t read(int fildes, void *buf, size_t nbyte) 
     344ssize_t read(int fildes, void *buf, size_t nbyte)
    345345{
    346346        sysarg_t rc;
    … …  
    348348        aid_t req;
    349349       
     350        if (nbyte > DATA_XFER_LIMIT)
     351                nbyte = DATA_XFER_LIMIT;
     352       
    350353        async_exch_t *exch = vfs_exchange_begin();
    351354       
    352355        req = async_send_1(exch, VFS_IN_READ, fildes, &answer);
    353         rc = async_data_read_start(exch, (void *)buf, nbyte);
     356        rc = async_data_read_start(exch, (void *) buf, nbyte);
    354357        if (rc != EOK) {
    355358                vfs_exchange_end(exch);
    … …  
    377380        aid_t req;
    378381       
     382        if (nbyte > DATA_XFER_LIMIT)
     383                nbyte = DATA_XFER_LIMIT;
     384       
    379385        async_exch_t *exch = vfs_exchange_begin();
    380386       
    381387        req = async_send_1(exch, VFS_IN_WRITE, fildes, &answer);
    382         rc = async_data_write_start(exch, (void *)buf, nbyte);
     388        rc = async_data_write_start(exch, (void *) buf, nbyte);
    383389        if (rc != EOK) {
    384390                vfs_exchange_end(exch);

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

    r408424e rc42f50d  
    3939#include <net/in.h>
    4040#include <net/in6.h>
     41#include <net/socket.h>
    4142
    4243typedef uint32_t addr32_t;
    … …  
    4445typedef uint8_t addr128_t[16];
    4546
     47typedef enum {
     48        /** Any IP protocol version */
     49        ip_any,
     50        /** IPv4 */
     51        ip_v4,
     52        /** IPv6 */
     53        ip_v6
     54} ip_ver_t;
     55
    4656/** Node address */
    4757typedef struct {
    48         uint16_t family;
     58        /** IP version */
     59        ip_ver_t version;
    4960        union {
    5061                addr32_t addr;
    … …  
    5566/** Network address */
    5667typedef struct {
    57         /** Address family */
    58         uint16_t family;
     68        /** IP version */
     69        ip_ver_t version;
    5970       
    6071        /** Address */
    … …  
    91102    uint16_t, uint16_t, uint16_t, uint16_t, uint8_t);
    92103
    93 extern int inet_addr_family(const char *, uint16_t *);
    94104extern void inet_naddr_addr(const inet_naddr_t *, inet_addr_t *);
    95105extern void inet_addr_naddr(const inet_addr_t *, uint8_t, inet_naddr_t *);
    … …  
    110120extern int inet_naddr_format(const inet_naddr_t *, char **);
    111121
    112 extern uint16_t inet_addr_get(const inet_addr_t *, addr32_t *, addr128_t *);
    113 extern uint16_t inet_naddr_get(const inet_naddr_t *, addr32_t *, addr128_t *,
     122extern ip_ver_t inet_addr_get(const inet_addr_t *, addr32_t *, addr128_t *);
     123extern ip_ver_t inet_naddr_get(const inet_naddr_t *, addr32_t *, addr128_t *,
    114124    uint8_t *);
    115125
    … …  
    125135    sockaddr_in6_t *);
    126136
     137extern ip_ver_t ipver_from_af(int af);
     138extern int inet_addr_sockaddr(const inet_addr_t *, uint16_t, sockaddr_t **,
     139    socklen_t *);
     140
    127141#endif
    128142

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

    r408424e rc42f50d  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * Network device.
    3533 */
    3634
    37 #ifndef LIBC_NET_DEVICE_H_
    38 #define LIBC_NET_DEVICE_H_
     35#ifndef LIBC_INET_DHCP_H_
     36#define LIBC_INET_DHCP_H_
    3937
    40 #include <adt/int_map.h>
    41 #include <nic/nic.h>
     38#include <sys/types.h>
    4239
    43 /** Device identifier to generic type map declaration. */
    44 #define DEVICE_MAP_DECLARE  INT_MAP_DECLARE
    45 
    46 /** Device identifier to generic type map implementation. */
    47 #define DEVICE_MAP_IMPLEMENT  INT_MAP_IMPLEMENT
    48 
    49 /** Device identifier type. */
    50 typedef int nic_device_id_t;
    51 
    52 /** Invalid device identifier. */
    53 #define NIC_DEVICE_INVALID_ID  (-1)
     40extern int dhcp_init(void);
     41extern int dhcp_link_add(sysarg_t);
     42extern int dhcp_link_remove(sysarg_t);
    5443
    5544#endif

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

    r408424e rc42f50d  
    5151
    5252extern int dnsr_init(void);
    53 extern int dnsr_name2host(const char *, dnsr_hostinfo_t **, uint16_t);
     53extern int dnsr_name2host(const char *, dnsr_hostinfo_t **, ip_ver_t);
    5454extern void dnsr_hostinfo_destroy(dnsr_hostinfo_t *);
    5555extern int dnsr_get_srvaddr(inet_addr_t *);

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

    r408424e rc42f50d  
    4848extern int inetcfg_get_link_list(sysarg_t **, size_t *);
    4949extern int inetcfg_get_sroute_list(sysarg_t **, size_t *);
     50extern int inetcfg_link_add(sysarg_t);
    5051extern int inetcfg_link_get(sysarg_t, inet_link_info_t *);
     52extern int inetcfg_link_remove(sysarg_t);
    5153extern int inetcfg_sroute_get(sysarg_t, inet_sroute_info_t *);
    5254extern int inetcfg_sroute_get_id(const char *, sysarg_t *);

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

    r408424e rc42f50d  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3838#include <inet/inet.h>
    3939#include <sys/types.h>
    40 
    41 typedef struct {
    42         uint32_t src;
    43         uint32_t dest;
    44         uint16_t seq_no;
    45         void *data;
    46         size_t size;
    47 } inetping_sdu_t;
     40#include <types/inetping.h>
    4841
    4942typedef struct inetping_ev_ops {
    … …  
    5346extern int inetping_init(inetping_ev_ops_t *);
    5447extern int inetping_send(inetping_sdu_t *);
    55 extern int inetping_get_srcaddr(uint32_t, uint32_t *);
     48extern int inetping_get_srcaddr(const inet_addr_t *, inet_addr_t *);
    5649
    5750#endif

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

    r408424e rc42f50d  
    3737
    3838#include <async.h>
    39 #include <sys/types.h>
    4039#include <inet/addr.h>
    4140
    … …  
    7877
    7978typedef struct iplink_ev_ops {
    80         int (*recv)(iplink_t *, iplink_recv_sdu_t *, uint16_t);
     79        int (*recv)(iplink_t *, iplink_recv_sdu_t *, ip_ver_t);
    8180} iplink_ev_ops_t;
    8281

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

    r408424e rc42f50d  
    3939#include <fibril_synch.h>
    4040#include <stdbool.h>
    41 #include <sys/types.h>
    4241#include <inet/addr.h>
    4342#include <inet/iplink.h>
    … …  
    6766
    6867extern int iplink_conn(ipc_callid_t, ipc_call_t *, void *);
    69 extern int iplink_ev_recv(iplink_srv_t *, iplink_recv_sdu_t *, uint16_t);
     68extern int iplink_ev_recv(iplink_srv_t *, iplink_recv_sdu_t *, ip_ver_t);
    7069
    7170#endif

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

    r408424e rc42f50d  
    7272        INETCFG_GET_LINK_LIST,
    7373        INETCFG_GET_SROUTE_LIST,
     74        INETCFG_LINK_ADD,
    7475        INETCFG_LINK_GET,
     76        INETCFG_LINK_REMOVE,
    7577        INETCFG_SROUTE_CREATE,
    7678        INETCFG_SROUTE_DELETE,
    … …  
    9092} inetping_request_t;
    9193
    92 /** Events on Inet ping6 port */
    93 typedef enum {
    94         INETPING6_EV_RECV = IPC_FIRST_USER_METHOD
    95 } inetping6_event_t;
    96 
    97 /** Requests on Inet ping6 port */
    98 typedef enum {
    99         INETPING6_SEND = IPC_FIRST_USER_METHOD,
    100         INETPING6_GET_SRCADDR
    101 } inetping6_request_t;
    102 
    10394#endif
    10495

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

    r408424e rc42f50d  
    5454
    5555#define SERVICE_NAME_CORECFG    "corecfg"
     56#define SERVICE_NAME_DHCP       "net/dhcp"
    5657#define SERVICE_NAME_DNSR       "net/dnsr"
    5758#define SERVICE_NAME_INET       "net/inet"
    … …  
    5960#define SERVICE_NAME_INETPING   "net/inetping"
    6061#define SERVICE_NAME_INETPING6  "net/inetping6"
     62#define SERVICE_NAME_NETCONF    "net/netconf"
    6163
    6264#endif

  • uspace/lib/c/include/types/inetping.h

    r408424e rc42f50d  
    11/*
    2  * Copyright (c) 2013 Martin Decky
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3030 * @{
    3131 */
    32 /** @file
     32/**
     33 * @file
     34 * @brief
    3335 */
    3436
    35 #ifndef LIBC_INET_INETPING6_H_
    36 #define LIBC_INET_INETPING6_H_
     37#ifndef LIBC_TYPES_INETPING_H_
     38#define LIBC_TYPES_INETPING_H_
    3739
    38 #include <inet/inet.h>
     40#include <inet/addr.h>
    3941#include <sys/types.h>
    4042
    4143typedef struct {
    42         addr128_t src;
    43         addr128_t dest;
     44        inet_addr_t src;
     45        inet_addr_t dest;
    4446        uint16_t seq_no;
    4547        void *data;
    4648        size_t size;
    47 } inetping6_sdu_t;
    48 
    49 typedef struct inetping6_ev_ops {
    50         int (*recv)(inetping6_sdu_t *);
    51 } inetping6_ev_ops_t;
    52 
    53 extern int inetping6_init(inetping6_ev_ops_t *);
    54 extern int inetping6_send(inetping6_sdu_t *);
    55 extern int inetping6_get_srcaddr(addr128_t, addr128_t);
     49} inetping_sdu_t;
    5650
    5751#endif

  • uspace/lib/gui/canvas.c

    r408424e rc42f50d  
    105105static void canvas_handle_keyboard_event(widget_t *widget, kbd_event_t event)
    106106{
    107         /* No-op */
     107        canvas_t *canvas = (canvas_t *) widget;
     108       
     109        sig_send(&canvas->keyboard_event, &event);
    108110}
    109111
    … …  
    142144}
    143145
     146bool update_canvas(canvas_t *canvas, surface_t *surface)
     147{
     148        if (surface != NULL)
     149                canvas->surface = surface;
     150       
     151        canvas_repaint(&canvas->widget);
     152        return true;
     153}
     154
    144155canvas_t *create_canvas(widget_t *parent, sysarg_t width, sysarg_t height,
    145156    surface_t *surface)

  • uspace/lib/gui/canvas.h

    r408424e rc42f50d  
    4242#include <surface.h>
    4343#include "widget.h"
     44#include "connection.h"
    4445
    4546typedef struct {
    … …  
    4849        sysarg_t height;
    4950        surface_t *surface;
     51        signal_t keyboard_event;
    5052} canvas_t;
    5153
    … …  
    5355    surface_t *);
    5456extern canvas_t *create_canvas(widget_t *, sysarg_t, sysarg_t, surface_t *);
     57extern bool update_canvas(canvas_t *, surface_t *);
    5558extern void deinit_canvas(canvas_t *);
    5659

  • uspace/lib/http/src/http.c

    r408424e rc42f50d  
    8686                /* Interpret as a host name */
    8787                dnsr_hostinfo_t *hinfo = NULL;
    88                 rc = dnsr_name2host(http->host, &hinfo, AF_NONE);
     88                rc = dnsr_name2host(http->host, &hinfo, ip_any);
    8989               
    9090                if (rc != EOK)
    … …  
    9595        }
    9696       
    97         struct sockaddr_in addr;
    98         struct sockaddr_in6 addr6;
    99         uint16_t af = inet_addr_sockaddr_in(&http->addr, &addr, &addr6);
     97        struct sockaddr *saddr;
     98        socklen_t saddrlen;
    10099       
    101         http->conn_sd = socket(PF_INET, SOCK_STREAM, 0);
     100        rc = inet_addr_sockaddr(&http->addr, http->port, &saddr, &saddrlen);
     101        if (rc != EOK) {
     102                assert(rc == ENOMEM);
     103                return ENOMEM;
     104        }
     105       
     106        http->conn_sd = socket(saddr->sa_family, SOCK_STREAM, 0);
    102107        if (http->conn_sd < 0)
    103108                return http->conn_sd;
    104109       
    105         switch (af) {
    106         case AF_INET:
    107                 addr.sin_port = htons(http->port);
    108                 rc = connect(http->conn_sd, (struct sockaddr *) &addr, sizeof(addr));
    109                 break;
    110         case AF_INET6:
    111                 addr6.sin6_port = htons(http->port);
    112                 rc = connect(http->conn_sd, (struct sockaddr *) &addr6, sizeof(addr6));
    113                 break;
    114         default:
    115                 return ENOTSUP;
    116         }
     110        rc = connect(http->conn_sd, saddr, saddrlen);
     111        free(saddr);
    117112       
    118113        return rc;

  • uspace/lib/net/include/socket_core.h

    r408424e rc42f50d  
    4343#include <adt/int_map.h>
    4444#include <net/in.h>
    45 #include <net/device.h>
    4645#include <async.h>
    4746

  • uspace/srv/net/dhcp/Makefile

    r408424e rc42f50d  
    3131
    3232SOURCES = \
    33         dhcp.c
     33        dhcp.c \
     34        main.c \
     35        transport.c
    3436
    3537include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/net/dhcp/dhcp.c

    r408424e rc42f50d  
    3535 */
    3636
     37#include <adt/list.h>
    3738#include <bitops.h>
     39#include <errno.h>
     40#include <fibril_synch.h>
    3841#include <inet/addr.h>
    3942#include <inet/dnsr.h>
    4043#include <inet/inetcfg.h>
     44#include <io/log.h>
    4145#include <loc.h>
    42 #include <net/in.h>
    43 #include <net/inet.h>
    44 #include <net/socket.h>
    4546#include <stdio.h>
    4647#include <stdlib.h>
    4748
     49#include "dhcp.h"
    4850#include "dhcp_std.h"
    49 
    50 #define NAME "dhcp"
     51#include "transport.h"
     52
     53enum {
     54        /** In microseconds */
     55        dhcp_discover_timeout_val = 5 * 1000 * 1000,
     56        /** In microseconds */
     57        dhcp_request_timeout_val = 1 * 1000 * 1000,
     58        dhcp_discover_retries = 5,
     59        dhcp_request_retries = 3
     60};
    5161
    5262#define MAX_MSG_SIZE 1024
    53 
    54 static int transport_fd = -1;
    55 static inet_link_info_t link_info;
    5663static uint8_t msgbuf[MAX_MSG_SIZE];
     64
     65/** List of registered links (of dhcp_link_t) */
     66static list_t dhcp_links;
     67
     68static void dhcpsrv_discover_timeout(void *);
     69static void dhcpsrv_request_timeout(void *);
     70
     71typedef enum {
     72        ds_bound,
     73        ds_fail,
     74        ds_init,
     75        ds_init_reboot,
     76        ds_rebinding,
     77        ds_renewing,
     78        ds_requesting,
     79        ds_selecting
     80} dhcp_state_t;
    5781
    5882typedef struct {
    … …  
    6993} dhcp_offer_t;
    7094
     95typedef struct {
     96        /** Link to dhcp_links list */
     97        link_t links;
     98        /** Link service ID */
     99        service_id_t link_id;
     100        /** Link info */
     101        inet_link_info_t link_info;
     102        /** Transport */
     103        dhcp_transport_t dt;
     104        /** Transport timeout */
     105        fibril_timer_t *timeout;
     106        /** Number of retries */
     107        int retries_left;
     108        /** Link state */
     109        dhcp_state_t state;
     110        /** Last received offer */
     111        dhcp_offer_t offer;
     112} dhcp_link_t;
     113
     114static void dhcpsrv_recv(void *, void *, size_t);
     115
    71116/** Decode subnet mask into subnet prefix length. */
    72117static int subnet_mask_decode(uint32_t mask, int *bits)
    … …  
    101146}
    102147
    103 static int dhcp_send(void *msg, size_t size)
    104 {
    105         struct sockaddr_in addr;
    106         int rc;
    107 
    108         addr.sin_family = AF_INET;
    109         addr.sin_port = htons(dhcp_server_port);
    110         addr.sin_addr.s_addr = htonl(addr32_broadcast_all_hosts);
    111 
    112         rc = sendto(transport_fd, msg, size, 0,
    113             (struct sockaddr *)&addr, sizeof(addr));
    114         if (rc != EOK) {
    115                 printf("Sending failed\n");
    116                 return rc;
    117         }
    118 
    119         return EOK;
    120 }
    121 
    122 static int dhcp_send_discover(void)
     148static int dhcp_send_discover(dhcp_link_t *dlink)
    123149{
    124150        dhcp_hdr_t *hdr = (dhcp_hdr_t *)msgbuf;
    … …  
    132158        hdr->flags = flag_broadcast;
    133159
    134         addr48(link_info.mac_addr, hdr->chaddr);
     160        addr48(dlink->link_info.mac_addr, hdr->chaddr);
    135161        hdr->opt_magic = host2uint32_t_be(dhcp_opt_magic);
    136162
    … …  
    140166        opt[3] = opt_end;
    141167
    142         return dhcp_send(msgbuf, sizeof(dhcp_hdr_t) + 4);
    143 }
    144 
    145 static int dhcp_recv_msg(void **rmsg, size_t *rsize)
    146 {
    147         struct sockaddr_in src_addr;
    148         socklen_t src_addr_size;
    149         size_t recv_size;
    150         int rc;
    151 
    152         src_addr_size = sizeof(src_addr);
    153         rc = recvfrom(transport_fd, msgbuf, MAX_MSG_SIZE, 0,
    154             (struct sockaddr *)&src_addr, &src_addr_size);
    155         if (rc < 0) {
    156                 printf("recvfrom failed (%d)\n", rc);
    157                 return rc;
    158         }
    159 
    160         recv_size = (size_t)rc;
    161         *rmsg = msgbuf;
    162         *rsize = recv_size;
    163 
    164         return EOK;
    165 }
    166 
    167 static int dhcp_send_request(dhcp_offer_t *offer)
     168        return dhcp_send(&dlink->dt, msgbuf, sizeof(dhcp_hdr_t) + 4);
     169}
     170
     171static int dhcp_send_request(dhcp_link_t *dlink, dhcp_offer_t *offer)
    168172{
    169173        dhcp_hdr_t *hdr = (dhcp_hdr_t *)msgbuf;
    … …  
    178182        hdr->flags = flag_broadcast;
    179183        hdr->ciaddr = host2uint32_t_be(offer->oaddr.addr);
    180         addr48(link_info.mac_addr, hdr->chaddr);
     184        addr48(dlink->link_info.mac_addr, hdr->chaddr);
    181185        hdr->opt_magic = host2uint32_t_be(dhcp_opt_magic);
    182186
    … …  
    203207        opt[i++] = opt_end;
    204208
    205         return dhcp_send(msgbuf, sizeof(dhcp_hdr_t) + i);
    206 }
    207 
    208 static int dhcp_recv_reply(void *msg, size_t size, dhcp_offer_t *offer)
     209        return dhcp_send(&dlink->dt, msgbuf, sizeof(dhcp_hdr_t) + i);
     210}
     211
     212static int dhcp_parse_reply(void *msg, size_t size, dhcp_offer_t *offer)
    209213{
    210214        dhcp_hdr_t *hdr = (dhcp_hdr_t *)msg;
    … …  
    222226        size_t i;
    223227
    224         printf("Receive reply\n");
     228        log_msg(LOG_DEFAULT, LVL_DEBUG, "Receive reply");
    225229        memset(offer, 0, sizeof(*offer));
    226230
    227         yiaddr.family = AF_INET;
    228         yiaddr.addr = uint32_t_be2host(hdr->yiaddr);
     231        inet_addr_set(uint32_t_be2host(hdr->yiaddr), &yiaddr);
    229232        rc = inet_addr_format(&yiaddr, &saddr);
    230233        if (rc != EOK)
    231234                return rc;
    232235
    233         printf("Your IP address: %s\n", saddr);
     236        log_msg(LOG_DEFAULT, LVL_DEBUG, "Your IP address: %s", saddr);
    234237        free(saddr);
    235238
    236         siaddr.family = AF_INET;
    237         siaddr.addr = uint32_t_be2host(hdr->siaddr);
     239        inet_addr_set(uint32_t_be2host(hdr->siaddr), &siaddr);
    238240        rc = inet_addr_format(&siaddr, &saddr);
    239241        if (rc != EOK)
    240242                return rc;
    241243
    242         printf("Next server IP address: %s\n", saddr);
     244        log_msg(LOG_DEFAULT, LVL_DEBUG, "Next server IP address: %s", saddr);
    243245        free(saddr);
    244246
    245         giaddr.family = AF_INET;
    246         giaddr.addr = uint32_t_be2host(hdr->giaddr);
     247        inet_addr_set(uint32_t_be2host(hdr->giaddr), &giaddr);
    247248        rc = inet_addr_format(&giaddr, &saddr);
    248249        if (rc != EOK)
    249250                return rc;
    250251
    251         printf("Relay agent IP address: %s\n", saddr);
     252        log_msg(LOG_DEFAULT, LVL_DEBUG, "Relay agent IP address: %s", saddr);
    252253        free(saddr);
    253254
    254         offer->oaddr.family = AF_INET;
    255         offer->oaddr.addr = yiaddr.addr;
     255        inet_naddr_set(yiaddr.addr, 0, &offer->oaddr);
    256256
    257257        msgb = (uint8_t *)msg;
    … …  
    293293                        if (opt_len != 4)
    294294                                return EINVAL;
    295                         offer->srv_addr.family = AF_INET;
    296                         offer->srv_addr.addr = dhcp_uint32_decode(&msgb[i]);
     295                        inet_addr_set(dhcp_uint32_decode(&msgb[i]),
     296                            &offer->srv_addr);
    297297                        have_server_id = true;
    298298                        break;
    … …  
    300300                        if (opt_len != 4)
    301301                                return EINVAL;
    302                         offer->router.family = AF_INET;
    303                         offer->router.addr = dhcp_uint32_decode(&msgb[i]);
     302                        inet_addr_set(dhcp_uint32_decode(&msgb[i]),
     303                            &offer->router);
    304304                        break;
    305305                case opt_dns_server:
    306306                        if (opt_len != 4)
    307307                                return EINVAL;
    308                         offer->dns_server.family = AF_INET;
    309                         offer->dns_server.addr = dhcp_uint32_decode(&msgb[i]);
     308                        inet_addr_set(dhcp_uint32_decode(&msgb[i]),
     309                            &offer->dns_server);
    310310                        break;
    311311                case opt_end:
    … …  
    320320
    321321        if (!have_server_id) {
    322                 printf("Missing server ID option.\n");
     322                log_msg(LOG_DEFAULT, LVL_ERROR, "Missing server ID option.");
    323323                return rc;
    324324        }
    325325
    326326        if (!have_subnet_mask) {
    327                 printf("Missing subnet mask option.\n");
     327                log_msg(LOG_DEFAULT, LVL_ERROR, "Missing subnet mask option.");
    328328                return rc;
    329329        }
    … …  
    333333                return rc;
    334334
    335         printf("Offered network address: %s\n", saddr);
     335        log_msg(LOG_DEFAULT, LVL_DEBUG, "Offered network address: %s", saddr);
    336336        free(saddr);
    337337
    … …  
    341341                        return rc;
    342342
    343                 printf("Router address: %s\n", saddr);
     343                log_msg(LOG_DEFAULT, LVL_DEBUG, "Router address: %s", saddr);
    344344                free(saddr);
    345345        }
    … …  
    350350                        return rc;
    351351
    352                 printf("DNS server: %s\n", saddr);
     352                log_msg(LOG_DEFAULT, LVL_DEBUG, "DNS server: %s", saddr);
    353353                free(saddr);
    354354        }
    … …  
    367367            &addr_id);
    368368        if (rc != EOK) {
    369                 printf("Error creating IP address %s (%d)\n", "dhcp4a", rc);
     369                log_msg(LOG_DEFAULT, LVL_ERROR,
     370                    "Error creating IP address %s (%d)", "dhcp4a", rc);
    370371                return rc;
    371372        }
    372373
    373374        if (offer->router.addr != 0) {
    374                 defr.family = AF_INET;
    375                 defr.addr = 0;
    376                 defr.prefix = 0;
     375                inet_naddr_set(0, 0, &defr);
    377376
    378377                rc = inetcfg_sroute_create("dhcpdef", &defr, &offer->router, &sroute_id);
    379378                if (rc != EOK) {
    380                         printf("Error creating default route %s (%d).\n", "dhcpdef",
    381                             rc);
     379                        log_msg(LOG_DEFAULT, LVL_ERROR, "Error creating "
     380                            "default route %s (%d).", "dhcpdef", rc);
    382381                        return rc;
    383382                }
    … …  
    387386                rc = dnsr_set_srvaddr(&offer->dns_server);
    388387                if (rc != EOK) {
    389                         printf("%s: Error setting nameserver address (%d))\n",
    390                             NAME, rc);
     388                        log_msg(LOG_DEFAULT, LVL_ERROR, "Error setting "
     389                            "nameserver address (%d))", rc);
    391390                        return rc;
    392391                }
    … …  
    396395}
    397396
    398 int main(int argc, char *argv[])
    399 {
    400         int fd;
    401         struct sockaddr_in laddr;
    402         void *msg;
    403         service_id_t iplink;
    404         size_t msg_size;
     397void dhcpsrv_links_init(void)
     398{
     399        list_initialize(&dhcp_links);
     400}
     401
     402static dhcp_link_t *dhcpsrv_link_find(service_id_t link_id)
     403{
     404        list_foreach(dhcp_links, links, dhcp_link_t, dlink) {
     405                if (dlink->link_id == link_id)
     406                        return dlink;
     407        }
     408
     409        return NULL;
     410}
     411
     412static void dhcp_link_set_failed(dhcp_link_t *dlink)
     413{
     414        log_msg(LOG_DEFAULT, LVL_NOTE, "Giving up on link %s",
     415            dlink->link_info.name);
     416        dlink->state = ds_fail;
     417}
     418
     419int dhcpsrv_link_add(service_id_t link_id)
     420{
     421        dhcp_link_t *dlink;
     422        int rc;
     423
     424        log_msg(LOG_DEFAULT, LVL_DEBUG, "dhcpsrv_link_add(%zu)", link_id);
     425
     426        if (dhcpsrv_link_find(link_id) != NULL) {
     427                log_msg(LOG_DEFAULT, LVL_NOTE, "Link %zu already added",
     428                    link_id);
     429                return EEXIST;
     430        }
     431
     432        dlink = calloc(1, sizeof(dhcp_link_t));
     433        if (dlink == NULL)
     434                return ENOMEM;
     435
     436        dlink->link_id = link_id;
     437        dlink->timeout = fibril_timer_create();
     438        if (dlink->timeout == NULL) {
     439                rc = ENOMEM;
     440                goto error;
     441        }
     442
     443        /* Get link hardware address */
     444        rc = inetcfg_link_get(link_id, &dlink->link_info);
     445        if (rc != EOK) {
     446                log_msg(LOG_DEFAULT, LVL_ERROR, "Error getting properties "
     447                    "for link %zu.", link_id);
     448                rc = EIO;
     449                goto error;
     450        }
     451
     452        rc = dhcp_transport_init(&dlink->dt, link_id, dhcpsrv_recv, dlink);
     453        if (rc != EOK) {
     454                log_msg(LOG_DEFAULT, LVL_ERROR, "Error initializing DHCP "
     455                    "transport for link %s.", dlink->link_info.name);
     456                rc = EIO;
     457                goto error;
     458        }
     459
     460        dlink->state = ds_selecting;
     461
     462        log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPDISCOVER");
     463        rc = dhcp_send_discover(dlink);
     464        if (rc != EOK) {
     465                log_msg(LOG_DEFAULT, LVL_ERROR, "Error sending DHCPDISCOVER.");
     466                dhcp_link_set_failed(dlink);
     467                rc = EIO;
     468                goto error;
     469        }
     470
     471        dlink->retries_left = dhcp_discover_retries;
     472        fibril_timer_set(dlink->timeout, dhcp_discover_timeout_val,
     473            dhcpsrv_discover_timeout, dlink);
     474
     475        list_append(&dlink->links, &dhcp_links);
     476
     477        return EOK;
     478error:
     479        if (dlink != NULL && dlink->timeout != NULL)
     480                fibril_timer_destroy(dlink->timeout);
     481        free(dlink);
     482        return rc;
     483}
     484
     485int dhcpsrv_link_remove(service_id_t link_id)
     486{
     487        return ENOTSUP;
     488}
     489
     490static void dhcpsrv_recv_offer(dhcp_link_t *dlink, dhcp_offer_t *offer)
     491{
     492        int rc;
     493
     494        if (dlink->state != ds_selecting) {
     495                log_msg(LOG_DEFAULT, LVL_DEBUG, "Received offer in state "
     496                    " %d, ignoring.", (int)dlink->state);
     497                return;
     498        }
     499
     500        fibril_timer_clear(dlink->timeout);
     501        dlink->offer = *offer;
     502        dlink->state = ds_requesting;
     503
     504        log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPREQUEST");
     505        rc = dhcp_send_request(dlink, offer);
     506        if (rc != EOK) {
     507                log_msg(LOG_DEFAULT, LVL_DEBUG, "Error sending request.");
     508                return;
     509        }
     510
     511        dlink->retries_left = dhcp_request_retries;
     512        fibril_timer_set(dlink->timeout, dhcp_request_timeout_val,
     513            dhcpsrv_request_timeout, dlink);
     514}
     515
     516static void dhcpsrv_recv_ack(dhcp_link_t *dlink, dhcp_offer_t *offer)
     517{
     518        int rc;
     519
     520        if (dlink->state != ds_requesting) {
     521                log_msg(LOG_DEFAULT, LVL_DEBUG, "Received ack in state "
     522                    " %d, ignoring.", (int)dlink->state);
     523                return;
     524        }
     525
     526        fibril_timer_clear(dlink->timeout);
     527        dlink->offer = *offer;
     528        dlink->state = ds_bound;
     529
     530        rc = dhcp_cfg_create(dlink->link_id, offer);
     531        if (rc != EOK) {
     532                log_msg(LOG_DEFAULT, LVL_DEBUG, "Error creating configuration.");
     533                return;
     534        }
     535
     536        log_msg(LOG_DEFAULT, LVL_NOTE, "%s: Successfully configured.",
     537            dlink->link_info.name);
     538}
     539
     540static void dhcpsrv_recv(void *arg, void *msg, size_t size)
     541{
     542        dhcp_link_t *dlink = (dhcp_link_t *)arg;
    405543        dhcp_offer_t offer;
    406544        int rc;
    407545
    408         if (argc < 2) {
    409                 printf("syntax: %s <ip-link>\n", NAME);
    410                 return 1;
    411         }
    412 
    413         rc = inetcfg_init();
    414         if (rc != EOK) {
    415                 printf("Error contacting inet configuration service.\n");
    416                 return 1;
    417         }
    418 
    419         rc = loc_service_get_id(argv[1], &iplink, 0);
    420         if (rc != EOK) {
    421                 printf("Error resolving service '%s'.\n", argv[1]);
    422                 return 1;
    423         }
    424 
    425         /* Get link hardware address */
    426         rc = inetcfg_link_get(iplink, &link_info);
    427         if (rc != EOK) {
    428                 printf("Error getting properties for link '%s'.\n", argv[1]);
    429                 return 1;
    430         }
    431 
    432         laddr.sin_family = AF_INET;
    433         laddr.sin_port = htons(dhcp_client_port);
    434         laddr.sin_addr.s_addr = INADDR_ANY;
    435 
    436         fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
    437         if (fd < 0)
    438                 return 1;
    439 
    440         printf("Bind socket.\n");
    441         rc = bind(fd, (struct sockaddr *)&laddr, sizeof(laddr));
    442         if (rc != EOK)
    443                 return 1;
    444 
    445         printf("Set socket options\n");
    446         rc = setsockopt(fd, SOL_SOCKET, SO_IPLINK, &iplink, sizeof(iplink));
    447         if (rc != EOK)
    448                 return 1;
    449 
    450         transport_fd = fd;
    451 
    452         printf("Send DHCPDISCOVER\n");
    453         rc = dhcp_send_discover();
    454         if (rc != EOK)
    455                 return 1;
    456 
    457         rc = dhcp_recv_msg(&msg, &msg_size);
    458         if (rc != EOK)
    459                 return 1;
    460 
    461         printf("Received %zu bytes\n", msg_size);
    462 
    463         rc = dhcp_recv_reply(msg, msg_size, &offer);
    464         if (rc != EOK)
    465                 return 1;
    466 
    467         rc = dhcp_send_request(&offer);
    468         if (rc != EOK)
    469                 return 1;
    470 
    471         rc = dhcp_recv_msg(&msg, &msg_size);
    472         if (rc != EOK)
    473                 return 1;
    474 
    475         printf("Received %zu bytes\n", msg_size);
    476 
    477         rc = dhcp_recv_reply(msg, msg_size, &offer);
    478         if (rc != EOK)
    479                 return 1;
    480 
    481         rc = dhcp_cfg_create(iplink, &offer);
    482         if (rc != EOK)
    483                 return 1;
    484 
    485         closesocket(fd);
    486         return 0;
     546        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: dhcpsrv_recv() %zu bytes",
     547            dlink->link_info.name, size);
     548
     549        rc = dhcp_parse_reply(msg, size, &offer);
     550        if (rc != EOK) {
     551                log_msg(LOG_DEFAULT, LVL_DEBUG, "Error parsing reply");
     552                return;
     553        }
     554
     555        switch (offer.msg_type) {
     556        case msg_dhcpoffer:
     557                dhcpsrv_recv_offer(dlink, &offer);
     558                break;
     559        case msg_dhcpack:
     560                dhcpsrv_recv_ack(dlink, &offer);
     561                break;
     562        default:
     563                log_msg(LOG_DEFAULT, LVL_DEBUG, "Received unexpected "
     564                    "message type. %d", (int)offer.msg_type);
     565                break;
     566        }
     567}
     568
     569static void dhcpsrv_discover_timeout(void *arg)
     570{
     571        dhcp_link_t *dlink = (dhcp_link_t *)arg;
     572        int rc;
     573
     574        assert(dlink->state == ds_selecting);
     575        log_msg(LOG_DEFAULT, LVL_NOTE, "%s: dcpsrv_discover_timeout",
     576            dlink->link_info.name);
     577
     578        if (dlink->retries_left == 0) {
     579                log_msg(LOG_DEFAULT, LVL_NOTE, "Retries exhausted");
     580                dhcp_link_set_failed(dlink);
     581                return;
     582        }
     583        --dlink->retries_left;
     584
     585        log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPDISCOVER");
     586        rc = dhcp_send_discover(dlink);
     587        if (rc != EOK) {
     588                log_msg(LOG_DEFAULT, LVL_ERROR, "Error sending DHCPDISCOVER");
     589                dhcp_link_set_failed(dlink);
     590                return;
     591        }
     592
     593        fibril_timer_set(dlink->timeout, dhcp_discover_timeout_val,
     594            dhcpsrv_discover_timeout, dlink);
     595}
     596
     597static void dhcpsrv_request_timeout(void *arg)
     598{
     599        dhcp_link_t *dlink = (dhcp_link_t *)arg;
     600        int rc;
     601
     602        assert(dlink->state == ds_requesting);
     603        log_msg(LOG_DEFAULT, LVL_NOTE, "%s: dcpsrv_request_timeout",
     604            dlink->link_info.name);
     605
     606        if (dlink->retries_left == 0) {
     607                log_msg(LOG_DEFAULT, LVL_NOTE, "Retries exhausted");
     608                dhcp_link_set_failed(dlink);
     609                return;
     610        }
     611        --dlink->retries_left;
     612
     613        log_msg(LOG_DEFAULT, LVL_DEBUG, "Send DHCPREQUEST");
     614        rc = dhcp_send_request(dlink, &dlink->offer);
     615        if (rc != EOK) {
     616                log_msg(LOG_DEFAULT, LVL_DEBUG, "Error sending request.");
     617                dhcp_link_set_failed(dlink);
     618                return;
     619        }
     620
     621        fibril_timer_set(dlink->timeout, dhcp_request_timeout_val,
     622            dhcpsrv_request_timeout, dlink);
    487623}
    488624

  • uspace/srv/net/dhcp/dhcp.h

    r408424e rc42f50d  
    11/*
    2  * Copyright (c) 2013 Martin Decky
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup inet
     29/** @addtogroup dhcp
    3030 * @{
    3131 */
    … …  
    3535 */
    3636
    37 #ifndef INETPING6_H_
    38 #define INETPING6_H_
     37#ifndef DHCP_H
     38#define DHCP_H
    3939
    40 #include "inetsrv.h"
     40#include <ipc/loc.h>
    4141
    42 extern void inetping6_conn(ipc_callid_t, ipc_call_t *, void *);
    43 extern int inetping6_recv(uint16_t, inetping6_sdu_t *);
     42extern void dhcpsrv_links_init(void);
     43extern int dhcpsrv_link_add(service_id_t);
     44extern int dhcpsrv_link_remove(service_id_t);
    4445
    4546#endif

  • uspace/srv/net/dnsrsrv/dnsrsrv.c

    r408424e rc42f50d  
    8989        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
    9090       
    91         uint16_t af = IPC_GET_ARG1(*icall);
     91        ip_ver_t ver = IPC_GET_ARG1(*icall);
    9292       
    9393        char *name;
    … …  
    100100       
    101101        dns_host_info_t *hinfo;
    102         rc = dns_name2host(name, &hinfo, af);
     102        rc = dns_name2host(name, &hinfo, ver);
    103103        if (rc != EOK) {
    104104                async_answer_0(iid, rc);

  • uspace/srv/net/dnsrsrv/query.c

    r408424e rc42f50d  
    3939#include <stdlib.h>
    4040#include <str.h>
    41 #include <net/socket_codes.h>
    4241#include "dns_msg.h"
    4342#include "dns_std.h"
    … …  
    190189}
    191190
    192 int dns_name2host(const char *name, dns_host_info_t **rinfo, uint16_t af)
     191int dns_name2host(const char *name, dns_host_info_t **rinfo, ip_ver_t ver)
    193192{
    194193        dns_host_info_t *info = calloc(1, sizeof(dns_host_info_t));
    … …  
    198197        int rc;
    199198       
    200         switch (af) {
    201         case AF_NONE:
     199        switch (ver) {
     200        case ip_any:
    202201                rc = dns_name_query(name, DTYPE_AAAA, info);
    203202               
    … …  
    206205               
    207206                break;
    208         case AF_INET:
     207        case ip_v4:
    209208                rc = dns_name_query(name, DTYPE_A, info);
    210209                break;
    211         case AF_INET6:
     210        case ip_v6:
    212211                rc = dns_name_query(name, DTYPE_AAAA, info);
    213212                break;

  • uspace/srv/net/dnsrsrv/query.h

    r408424e rc42f50d  
    3737#define QUERY_H
    3838
     39#include <inet/addr.h>
    3940#include "dns_type.h"
    4041
    41 extern int dns_name2host(const char *, dns_host_info_t **, uint16_t);
     42extern int dns_name2host(const char *, dns_host_info_t **, ip_ver_t);
    4243extern void dns_hostinfo_destroy(dns_host_info_t *);
    4344

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

    r408424e rc42f50d  
    182182{
    183183        trans_req_t *treq = NULL;
     184        struct sockaddr *saddr = NULL;
     185        socklen_t saddrlen;
    184186       
    185187        void *req_data;
    … …  
    189191                goto error;
    190192       
    191         struct sockaddr_in addr;
    192         struct sockaddr_in6 addr6;
    193         uint16_t af =
    194             inet_addr_sockaddr_in(&dns_server_addr, &addr, &addr6);
    195        
    196         struct sockaddr *address;
    197         socklen_t addrlen;
    198        
    199         switch (af) {
    200         case AF_INET:
    201                 addr.sin_port = htons(DNS_SERVER_PORT);
    202                 address = (struct sockaddr *) &addr;
    203                 addrlen = sizeof(addr);
    204                 break;
    205         case AF_INET6:
    206                 addr6.sin6_port = htons(DNS_SERVER_PORT);
    207                 address = (struct sockaddr *) &addr6;
    208                 addrlen = sizeof(addr6);
    209                 break;
    210         default:
    211                 rc = EAFNOSUPPORT;
     193        rc = inet_addr_sockaddr(&dns_server_addr, DNS_SERVER_PORT,
     194            &saddr, &saddrlen);
     195        if (rc != EOK) {
     196                assert(rc == ENOMEM);
    212197                goto error;
    213198        }
    … …  
    217202        while (ntry < REQ_RETRY_MAX) {
    218203                rc = sendto(transport_fd, req_data, req_size, 0,
    219                     (struct sockaddr *) address, addrlen);
     204                    saddr, saddrlen);
    220205                if (rc != EOK)
    221206                        goto error;
    … …  
    256241        treq_destroy(treq);
    257242        free(req_data);
     243        free(saddr);
    258244        return EOK;
    259245       
    … …  
    263249       
    264250        free(req_data);
     251        free(saddr);
    265252        return rc;
    266253}

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

    r408424e rc42f50d  
    4040#include <inet/addr.h>
    4141#include <stdlib.h>
    42 #include <net/socket_codes.h>
    4342#include "arp.h"
    4443#include "atrans.h"
    … …  
    7372       
    7473        addr32_t laddr_v4;
    75         uint16_t laddr_af = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
    76         if (laddr_af != AF_INET)
     74        ip_ver_t laddr_ver = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
     75        if (laddr_ver != ip_v4)
    7776                return;
    7877       

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

    r408424e rc42f50d  
    4444#include <stdio.h>
    4545#include <stdlib.h>
    46 #include <net/socket_codes.h>
    4746#include "arp.h"
    4847#include "ethip.h"
    … …  
    249248                sdu.size = frame.size;
    250249                log_msg(LOG_DEFAULT, LVL_DEBUG, " - call iplink_ev_recv");
    251                 rc = iplink_ev_recv(&nic->iplink, &sdu, AF_INET);
     250                rc = iplink_ev_recv(&nic->iplink, &sdu, ip_v4);
    252251                break;
    253252        case ETYPE_IPV6:
    … …  
    256255                sdu.size = frame.size;
    257256                log_msg(LOG_DEFAULT, LVL_DEBUG, " - call iplink_ev_recv");
    258                 rc = iplink_ev_recv(&nic->iplink, &sdu, AF_INET6);
     257                rc = iplink_ev_recv(&nic->iplink, &sdu, ip_v6);
    259258                break;
    260259        default:

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

    r408424e rc42f50d  
    4545#include <device/nic.h>
    4646#include <stdlib.h>
    47 #include <net/socket_codes.h>
    4847#include <mem.h>
    4948#include "ethip.h"
    … …  
    354353       
    355354        list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
    356                 uint16_t af = inet_addr_get(&laddr->addr, NULL, NULL);
    357                 if (af == AF_INET6)
     355                ip_ver_t ver = inet_addr_get(&laddr->addr, NULL, NULL);
     356                if (ver == ip_v6)
    358357                        count++;
    359358        }
    … …  
    373372        list_foreach(nic->addr_list, link, ethip_link_addr_t, laddr) {
    374373                addr128_t v6;
    375                 uint16_t af = inet_addr_get(&laddr->addr, NULL, &v6);
    376                 if (af != AF_INET6)
     374                ip_ver_t ver = inet_addr_get(&laddr->addr, NULL, &v6);
     375                if (ver != ip_v6)
    377376                        continue;
    378377               

  • uspace/srv/net/inetsrv/Makefile

    r408424e rc42f50d  
    3838        inetcfg.c \
    3939        inetping.c \
    40         inetping6.c \
    4140        ndp.c \
    4241        ntrans.c \

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

    r408424e rc42f50d  
    4242#include <stdlib.h>
    4343#include <str.h>
    44 #include <net/socket_codes.h>
    4544#include "addrobj.h"
    4645#include "inetsrv.h"
    … …  
    218217        inet_addr_t lsrc_addr;
    219218        inet_naddr_addr(&addr->naddr, &lsrc_addr);
    220        
     219
    221220        addr32_t lsrc_v4;
    222221        addr128_t lsrc_v6;
    223         uint16_t lsrc_af = inet_addr_get(&lsrc_addr, &lsrc_v4, &lsrc_v6);
    224        
     222        ip_ver_t lsrc_ver = inet_addr_get(&lsrc_addr, &lsrc_v4, &lsrc_v6);
     223
    225224        addr32_t ldest_v4;
    226225        addr128_t ldest_v6;
    227         uint16_t ldest_af = inet_addr_get(ldest, &ldest_v4, &ldest_v6);
    228        
    229         if (lsrc_af != ldest_af)
     226        ip_ver_t ldest_ver = inet_addr_get(ldest, &ldest_v4, &ldest_v6);
     227
     228        if (lsrc_ver != ldest_ver)
    230229                return EINVAL;
    231        
     230
    232231        int rc;
    233232        addr48_t ldest_mac;
    234        
    235         switch (ldest_af) {
    236         case AF_INET:
     233
     234        switch (ldest_ver) {
     235        case ip_v4:
    237236                return inet_link_send_dgram(addr->ilink, lsrc_v4, ldest_v4,
    238237                    dgram, proto, ttl, df);
    239         case AF_INET6:
     238        case ip_v6:
    240239                /*
    241240                 * Translate local destination IPv6 address.
    … …  
    244243                if (rc != EOK)
    245244                        return rc;
    246                
     245
    247246                return inet_link_send_dgram6(addr->ilink, ldest_mac, dgram,
    248247                    proto, ttl, df);
    249         }
    250        
     248        default:
     249                assert(false);
     250                break;
     251        }
     252
    251253        return ENOTSUP;
    252254}

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

    r408424e rc42f50d  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 #include <net/socket_codes.h>
     42#include <types/inetping.h>
    4343#include "icmp.h"
    4444#include "icmp_std.h"
    … …  
    122122{
    123123        log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()");
    124        
     124
    125125        if (dgram->size < sizeof(icmp_echo_t))
    126126                return EINVAL;
    127        
     127
    128128        icmp_echo_t *reply = (icmp_echo_t *) dgram->data;
    129        
     129
    130130        inetping_sdu_t sdu;
    131        
    132         uint16_t family = inet_addr_get(&dgram->src, &sdu.src, NULL);
    133         if (family != AF_INET)
    134                 return EINVAL;
    135        
    136         family = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
    137         if (family != AF_INET)
    138                 return EINVAL;
    139        
     131
     132        sdu.src = dgram->src;
     133        sdu.dest = dgram->dest;
    140134        sdu.seq_no = uint16_t_be2host(reply->seq_no);
    141135        sdu.data = reply + sizeof(icmp_echo_t);
    142136        sdu.size = dgram->size - sizeof(icmp_echo_t);
    143        
     137
    144138        uint16_t ident = uint16_t_be2host(reply->ident);
    145139
    … …  
    153147        if (rdata == NULL)
    154148                return ENOMEM;
    155        
     149
    156150        icmp_echo_t *request = (icmp_echo_t *) rdata;
    157        
     151
    158152        request->type = ICMP_ECHO_REQUEST;
    159153        request->code = 0;
    … …  
    161155        request->ident = host2uint16_t_be(ident);
    162156        request->seq_no = host2uint16_t_be(sdu->seq_no);
    163        
     157
    164158        memcpy(rdata + sizeof(icmp_echo_t), sdu->data, sdu->size);
    165        
     159
    166160        uint16_t checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
    167161        request->checksum = host2uint16_t_be(checksum);
    168        
     162
    169163        inet_dgram_t dgram;
    170        
    171         inet_addr_set(sdu->src, &dgram.src);
    172         inet_addr_set(sdu->dest, &dgram.dest);
    173        
     164
     165        dgram.src = sdu->src;
     166        dgram.dest = sdu->dest;
    174167        dgram.iplink = 0;
    175168        dgram.tos = ICMP_TOS;
    176169        dgram.data = rdata;
    177170        dgram.size = rsize;
    178        
     171
    179172        int rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
    180        
     173
    181174        free(rdata);
    182175        return rc;

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

    r408424e rc42f50d  
    3838#define ICMP_H_
    3939
     40#include <types/inetping.h>
    4041#include "inetsrv.h"
    4142

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

    r408424e rc42f50d  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 #include <net/socket_codes.h>
     42#include <types/inetping.h>
    4343#include "icmpv6.h"
    4444#include "icmpv6_std.h"
    4545#include "inetsrv.h"
    46 #include "inetping6.h"
     46#include "inetping.h"
    4747#include "pdu.h"
    4848
    … …  
    5858       
    5959        addr128_t src_v6;
    60         uint16_t src_af = inet_addr_get(&dgram->src, NULL, &src_v6);
     60        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &src_v6);
    6161       
    6262        addr128_t dest_v6;
    63         uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &dest_v6);
    64        
    65         if ((src_af != dest_af) || (src_af != AF_INET6))
     63        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
     64       
     65        if ((src_ver != dest_ver) || (src_ver != ip_v6))
    6666                return EINVAL;
    6767       
    … …  
    8080        inet_get_srcaddr(&dgram->src, 0, &rdgram.src);
    8181        rdgram.dest = dgram->src;
     82        rdgram.iplink = 0;
    8283        rdgram.tos = 0;
    8384        rdgram.data = reply;
    … …  
    115116                return EINVAL;
    116117       
    117         inetping6_sdu_t sdu;
    118        
    119         uint16_t src_af = inet_addr_get(&dgram->src, NULL, &sdu.src);
    120         uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &sdu.dest);
    121        
    122         if ((src_af != dest_af) || (src_af != AF_INET6))
    123                 return EINVAL;
     118        inetping_sdu_t sdu;
     119       
     120        sdu.src = dgram->src;
     121        sdu.dest = dgram->dest;
    124122       
    125123        icmpv6_message_t *reply = (icmpv6_message_t *) dgram->data;
    … …  
    131129        uint16_t ident = uint16_t_be2host(reply->un.echo.ident);
    132130       
    133         return inetping6_recv(ident, &sdu);
     131        return inetping_recv(ident, &sdu);
    134132}
    135133
    … …  
    159157}
    160158
    161 int icmpv6_ping_send(uint16_t ident, inetping6_sdu_t *sdu)
     159int icmpv6_ping_send(uint16_t ident, inetping_sdu_t *sdu)
    162160{
    163161        size_t rsize = sizeof(icmpv6_message_t) + sdu->size;
    … …  
    178176        inet_dgram_t dgram;
    179177       
    180         inet_addr_set6(sdu->src, &dgram.src);
    181         inet_addr_set6(sdu->dest, &dgram.dest);
     178        dgram.src = sdu->src;
     179        dgram.dest = sdu->dest;
     180        dgram.iplink = 0;
    182181        dgram.tos = 0;
    183182        dgram.data = rdata;
    … …  
    186185        icmpv6_phdr_t phdr;
    187186       
    188         host2addr128_t_be(sdu->src, phdr.src_addr);
    189         host2addr128_t_be(sdu->dest, phdr.dest_addr);
     187        assert(sdu->src.version == ip_v6);
     188        assert(sdu->dest.version == ip_v6);
     189       
     190        host2addr128_t_be(sdu->src.addr6, phdr.src_addr);
     191        host2addr128_t_be(sdu->dest.addr6, phdr.dest_addr);
    190192        phdr.length = host2uint32_t_be(dgram.size);
    191193        memset(phdr.zeroes, 0, 3);

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

    r408424e rc42f50d  
    3838#define ICMPV6_H_
    3939
     40#include <types/inetping.h>
    4041#include "inetsrv.h"
    4142
    4243extern int icmpv6_recv(inet_dgram_t *);
    43 extern int icmpv6_ping_send(uint16_t, inetping6_sdu_t *);
     44extern int icmpv6_ping_send(uint16_t, inetping_sdu_t *);
    4445
    4546#endif

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

    r408424e rc42f50d  
    4343#include <stdlib.h>
    4444#include <str.h>
    45 #include <net/socket_codes.h>
    4645#include "addrobj.h"
    4746#include "inetsrv.h"
    … …  
    5554static uint16_t ip_ident = 0;
    5655
    57 static int inet_link_open(service_id_t);
    58 static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, uint16_t);
     56static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, ip_ver_t);
     57static inet_link_t *inet_link_get_by_id_locked(sysarg_t);
    5958
    6059static iplink_ev_ops_t inet_iplink_ev_ops = {
    … …  
    6261};
    6362
    64 static LIST_INITIALIZE(inet_link_list);
    65 static FIBRIL_MUTEX_INITIALIZE(inet_discovery_lock);
     63static LIST_INITIALIZE(inet_links);
     64static FIBRIL_MUTEX_INITIALIZE(inet_links_lock);
    6665
    6766static addr128_t link_local_node_ip =
    … …  
    8180}
    8281
    83 static int inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, uint16_t af)
     82static int inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, ip_ver_t ver)
    8483{
    8584        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
    … …  
    8887        inet_packet_t packet;
    8988       
    90         switch (af) {
    91         case AF_INET:
     89        switch (ver) {
     90        case ip_v4:
    9291                rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
    9392                break;
    94         case AF_INET6:
     93        case ip_v6:
    9594                rc = inet_pdu_decode6(sdu->data, sdu->size, &packet);
    9695                break;
    9796        default:
    98                 log_msg(LOG_DEFAULT, LVL_DEBUG, "invalid address family");
     97                log_msg(LOG_DEFAULT, LVL_DEBUG, "invalid IP version");
    9998                return EINVAL;
    10099        }
    … …  
    113112}
    114113
    115 static int inet_link_check_new(void)
    116 {
    117         bool already_known;
    118         category_id_t iplink_cat;
    119         service_id_t *svcs;
    120         size_t count, i;
    121         int rc;
    122 
    123         fibril_mutex_lock(&inet_discovery_lock);
    124 
    125         rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING);
    126         if (rc != EOK) {
    127                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'iplink'.");
    128                 fibril_mutex_unlock(&inet_discovery_lock);
    129                 return ENOENT;
    130         }
    131 
    132         rc = loc_category_get_svcs(iplink_cat, &svcs, &count);
    133         if (rc != EOK) {
    134                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of IP links.");
    135                 fibril_mutex_unlock(&inet_discovery_lock);
    136                 return EIO;
    137         }
    138 
    139         for (i = 0; i < count; i++) {
    140                 already_known = false;
    141 
    142                 list_foreach(inet_link_list, link_list, inet_link_t, ilink) {
    143                         if (ilink->svc_id == svcs[i]) {
    144                                 already_known = true;
    145                                 break;
    146                         }
    147                 }
    148 
    149                 if (!already_known) {
    150                         log_msg(LOG_DEFAULT, LVL_DEBUG, "Found IP link '%lu'",
    151                             (unsigned long) svcs[i]);
    152                         rc = inet_link_open(svcs[i]);
    153                         if (rc != EOK)
    154                                 log_msg(LOG_DEFAULT, LVL_ERROR, "Could not open IP link.");
    155                 }
    156         }
    157 
    158         fibril_mutex_unlock(&inet_discovery_lock);
    159         return EOK;
    160 }
    161 
    162114static inet_link_t *inet_link_new(void)
    163115{
    … …  
    183135}
    184136
    185 static int inet_link_open(service_id_t sid)
     137int inet_link_open(service_id_t sid)
    186138{
    187139        inet_link_t *ilink;
    … …  
    231183
    232184        log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened IP link '%s'", ilink->svc_name);
    233         list_append(&ilink->link_list, &inet_link_list);
     185
     186        fibril_mutex_lock(&inet_links_lock);
     187
     188        if (inet_link_get_by_id_locked(sid) != NULL) {
     189                fibril_mutex_unlock(&inet_links_lock);
     190                log_msg(LOG_DEFAULT, LVL_DEBUG, "Link %zu already open",
     191                    sid);
     192                rc = EEXIST;
     193                goto error;
     194        }
     195
     196        list_append(&ilink->link_list, &inet_links);
     197        fibril_mutex_unlock(&inet_links_lock);
    234198
    235199        inet_addrobj_t *addr = NULL;
    … …  
    299263        }
    300264       
     265        log_msg(LOG_DEFAULT, LVL_DEBUG, "Configured link '%s'.", ilink->svc_name);
    301266        return EOK;
    302267       
    … …  
    307272        inet_link_delete(ilink);
    308273        return rc;
    309 }
    310 
    311 static void inet_link_cat_change_cb(void)
    312 {
    313         (void) inet_link_check_new();
    314 }
    315 
    316 int inet_link_discovery_start(void)
    317 {
    318         int rc;
    319 
    320         rc = loc_register_cat_change_cb(inet_link_cat_change_cb);
    321         if (rc != EOK) {
    322                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for IP link "
    323                     "discovery (%d).", rc);
    324                 return rc;
    325         }
    326 
    327         return inet_link_check_new();
    328274}
    329275
    … …  
    347293{
    348294        addr32_t src_v4;
    349         uint16_t src_af = inet_addr_get(&dgram->src, &src_v4, NULL);
    350         if (src_af != AF_INET)
     295        ip_ver_t src_ver = inet_addr_get(&dgram->src, &src_v4, NULL);
     296        if (src_ver != ip_v4)
    351297                return EINVAL;
    352298       
    353299        addr32_t dest_v4;
    354         uint16_t dest_af = inet_addr_get(&dgram->dest, &dest_v4, NULL);
    355         if (dest_af != AF_INET)
     300        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, &dest_v4, NULL);
     301        if (dest_ver != ip_v4)
    356302                return EINVAL;
    357303       
    … …  
    422368{
    423369        addr128_t src_v6;
    424         uint16_t src_af = inet_addr_get(&dgram->src, NULL, &src_v6);
    425         if (src_af != AF_INET6)
     370        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &src_v6);
     371        if (src_ver != ip_v6)
    426372                return EINVAL;
    427373       
    428374        addr128_t dest_v6;
    429         uint16_t dest_af = inet_addr_get(&dgram->dest, NULL, &dest_v6);
    430         if (dest_af != AF_INET6)
     375        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
     376        if (dest_ver != ip_v6)
    431377                return EINVAL;
    432378       
    … …  
    478424}
    479425
     426static inet_link_t *inet_link_get_by_id_locked(sysarg_t link_id)
     427{
     428        assert(fibril_mutex_is_locked(&inet_links_lock));
     429
     430        list_foreach(inet_links, link_list, inet_link_t, ilink) {
     431                if (ilink->svc_id == link_id)
     432                        return ilink;
     433        }
     434
     435        return NULL;
     436}
     437
    480438inet_link_t *inet_link_get_by_id(sysarg_t link_id)
    481439{
    482         fibril_mutex_lock(&inet_discovery_lock);
    483 
    484         list_foreach(inet_link_list, link_list, inet_link_t, ilink) {
    485                 if (ilink->svc_id == link_id) {
    486                         fibril_mutex_unlock(&inet_discovery_lock);
    487                         return ilink;
    488                 }
    489         }
    490 
    491         fibril_mutex_unlock(&inet_discovery_lock);
    492         return NULL;
     440        inet_link_t *ilink;
     441
     442        fibril_mutex_lock(&inet_links_lock);
     443        ilink = inet_link_get_by_id_locked(link_id);
     444        fibril_mutex_unlock(&inet_links_lock);
     445
     446        return ilink;
    493447}
    494448
    … …  
    499453        size_t count, i;
    500454
    501         fibril_mutex_lock(&inet_discovery_lock);
    502         count = list_count(&inet_link_list);
     455        fibril_mutex_lock(&inet_links_lock);
     456        count = list_count(&inet_links);
    503457
    504458        id_list = calloc(count, sizeof(sysarg_t));
    505459        if (id_list == NULL) {
    506                 fibril_mutex_unlock(&inet_discovery_lock);
     460                fibril_mutex_unlock(&inet_links_lock);
    507461                return ENOMEM;
    508462        }
    509463
    510464        i = 0;
    511         list_foreach(inet_link_list, link_list, inet_link_t, ilink) {
     465        list_foreach(inet_links, link_list, inet_link_t, ilink) {
    512466                id_list[i++] = ilink->svc_id;
    513467                log_msg(LOG_DEFAULT, LVL_NOTE, "add link to list");
    514468        }
    515469
    516         fibril_mutex_unlock(&inet_discovery_lock);
     470        fibril_mutex_unlock(&inet_links_lock);
    517471
    518472        log_msg(LOG_DEFAULT, LVL_NOTE, "return %zu links", count);

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

    r408424e rc42f50d  
    4141#include "inetsrv.h"
    4242
    43 extern int inet_link_discovery_start(void);
     43extern int inet_link_open(service_id_t);
    4444extern int inet_link_send_dgram(inet_link_t *, addr32_t,
    4545    addr32_t, inet_dgram_t *, uint8_t, uint8_t, int);

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

    r408424e rc42f50d  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    160160}
    161161
     162static int inetcfg_link_add(sysarg_t link_id)
     163{
     164        return inet_link_open(link_id);
     165}
     166
    162167static int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
    163168{
    … …  
    180185}
    181186
     187static int inetcfg_link_remove(sysarg_t link_id)
     188{
     189        return ENOTSUP;
     190}
     191
    182192static int inetcfg_sroute_create(char *name, inet_naddr_t *dest,
    183193    inet_addr_t *router, sysarg_t *sroute_id)
    … …  
    483493}
    484494
     495static void inetcfg_link_add_srv(ipc_callid_t callid, ipc_call_t *call)
     496{
     497        sysarg_t link_id;
     498        int rc;
     499
     500        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_add_srv()");
     501
     502        link_id = IPC_GET_ARG1(*call);
     503
     504        rc = inetcfg_link_add(link_id);
     505        async_answer_0(callid, rc);
     506}
     507
    485508static void inetcfg_link_get_srv(ipc_callid_t callid, ipc_call_t *call)
    486509{
    … …  
    536559}
    537560
     561static void inetcfg_link_remove_srv(ipc_callid_t callid, ipc_call_t *call)
     562{
     563        sysarg_t link_id;
     564        int rc;
     565
     566        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_link_remove_srv()");
     567
     568        link_id = IPC_GET_ARG1(*call);
     569
     570        rc = inetcfg_link_remove(link_id);
     571        async_answer_0(callid, rc);
     572}
     573
    538574static void inetcfg_sroute_create_srv(ipc_callid_t iid,
    539575    ipc_call_t *icall)
    … …  
    714750                sysarg_t method = IPC_GET_IMETHOD(call);
    715751
     752                log_msg(LOG_DEFAULT, LVL_DEBUG, "method %d", (int)method);
    716753                if (!method) {
    717754                        /* The other side has hung up */
    … …  
    742779                        inetcfg_get_sroute_list_srv(callid, &call);
    743780                        break;
     781                case INETCFG_LINK_ADD:
     782                        inetcfg_link_add_srv(callid, &call);
     783                        break;
    744784                case INETCFG_LINK_GET:
    745785                        inetcfg_link_get_srv(callid, &call);
     786                        break;
     787                case INETCFG_LINK_REMOVE:
     788                        inetcfg_link_remove_srv(callid, &call);
    746789                        break;
    747790                case INETCFG_SROUTE_CREATE:

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

    r408424e rc42f50d  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
     3 * Copyright (c) 2013 Martin Decky
    34 * All rights reserved.
    45 *
    … …  
    4344#include <stdlib.h>
    4445#include <sys/types.h>
    45 #include <net/socket_codes.h>
     46#include <types/inetping.h>
    4647#include "icmp.h"
     48#include "icmpv6.h"
    4749#include "icmp_std.h"
    4850#include "inetsrv.h"
    … …  
    5759static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
    5860{
    59         return icmp_ping_send(client->ident, sdu);
    60 }
    61 
    62 static int inetping_get_srcaddr(inetping_client_t *client, addr32_t remote,
    63     addr32_t *local)
    64 {
    65         inet_addr_t remote_addr;
    66         inet_addr_set(remote, &remote_addr);
    67        
    68         inet_addr_t local_addr;
    69         int rc = inet_get_srcaddr(&remote_addr, ICMP_TOS, &local_addr);
    70         if (rc != EOK)
    71                 return rc;
    72        
    73         uint16_t family = inet_addr_get(&local_addr, local, NULL);
    74         if (family != AF_INET)
     61        if (sdu->src.version != sdu->dest.version)
    7562                return EINVAL;
    76        
    77         return EOK;
     63
     64        switch (sdu->src.version) {
     65        case ip_v4:
     66                return icmp_ping_send(client->ident, sdu);
     67        case ip_v6:
     68                return icmpv6_ping_send(client->ident, sdu);
     69        default:
     70                return EINVAL;
     71        }
     72}
     73
     74static int inetping_get_srcaddr(inetping_client_t *client,
     75    inet_addr_t *remote, inet_addr_t *local)
     76{
     77        return inet_get_srcaddr(remote, ICMP_TOS, local);
    7878}
    7979
    … …  
    8181{
    8282        fibril_mutex_lock(&client_list_lock);
    83        
     83
    8484        list_foreach(client_list, client_list, inetping_client_t, client) {
    8585                if (client->ident == ident) {
    … …  
    8888                }
    8989        }
    90        
     90
    9191        fibril_mutex_unlock(&client_list_lock);
    9292        return NULL;
    … …  
    100100                return ENOENT;
    101101        }
    102        
     102
    103103        async_exch_t *exch = async_exchange_begin(client->sess);
    104        
     104
    105105        ipc_call_t answer;
    106         aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
    107             (sysarg_t) sdu->dest, sdu->seq_no, &answer);
    108         int rc = async_data_write_start(exch, sdu->data, sdu->size);
    109        
    110         async_exchange_end(exch);
    111        
    112         if (rc != EOK) {
     106        aid_t req = async_send_1(exch, INETPING_EV_RECV, sdu->seq_no, &answer);
     107
     108        int rc = async_data_write_start(exch, &sdu->src, sizeof(sdu->src));
     109        if (rc != EOK) {
     110                async_exchange_end(exch);
    113111                async_forget(req);
    114112                return rc;
    115113        }
    116        
     114
     115        rc = async_data_write_start(exch, &sdu->dest, sizeof(sdu->dest));
     116        if (rc != EOK) {
     117                async_exchange_end(exch);
     118                async_forget(req);
     119                return rc;
     120        }
     121
     122        rc = async_data_write_start(exch, sdu->data, sdu->size);
     123
     124        async_exchange_end(exch);
     125
     126        if (rc != EOK) {
     127                async_forget(req);
     128                return rc;
     129        }
     130
    117131        sysarg_t retval;
    118132        async_wait_for(req, &retval);
    119        
     133
    120134        return (int) retval;
    121135}
    122136
    123 static void inetping_send_srv(inetping_client_t *client, ipc_callid_t callid,
    124     ipc_call_t *call)
    125 {
     137static void inetping_send_srv(inetping_client_t *client, ipc_callid_t iid,
     138    ipc_call_t *icall)
     139{
     140        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()");
     141
    126142        inetping_sdu_t sdu;
    127143        int rc;
    128144
    129         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_send_srv()");
     145        sdu.seq_no = IPC_GET_ARG1(*icall);
     146
     147        ipc_callid_t callid;
     148        size_t size;
     149        if (!async_data_write_receive(&callid, &size)) {
     150                async_answer_0(callid, EREFUSED);
     151                async_answer_0(iid, EREFUSED);
     152                return;
     153        }
     154
     155        if (size != sizeof(sdu.src)) {
     156                async_answer_0(callid, EINVAL);
     157                async_answer_0(iid, EINVAL);
     158                return;
     159        }
     160
     161        rc = async_data_write_finalize(callid, &sdu.src, size);
     162        if (rc != EOK) {
     163                async_answer_0(callid, rc);
     164                async_answer_0(iid, rc);
     165                return;
     166        }
     167
     168        if (!async_data_write_receive(&callid, &size)) {
     169                async_answer_0(callid, EREFUSED);
     170                async_answer_0(iid, EREFUSED);
     171                return;
     172        }
     173
     174        if (size != sizeof(sdu.dest)) {
     175                async_answer_0(callid, EINVAL);
     176                async_answer_0(iid, EINVAL);
     177                return;
     178        }
     179
     180        rc = async_data_write_finalize(callid, &sdu.dest, size);
     181        if (rc != EOK) {
     182                async_answer_0(callid, rc);
     183                async_answer_0(iid, rc);
     184                return;
     185        }
    130186
    131187        rc = async_data_write_accept((void **) &sdu.data, false, 0, 0, 0,
    132188            &sdu.size);
    133189        if (rc != EOK) {
    134                 async_answer_0(callid, rc);
    135                 return;
    136         }
    137 
    138         sdu.src = IPC_GET_ARG1(*call);
    139         sdu.dest = IPC_GET_ARG2(*call);
    140         sdu.seq_no = IPC_GET_ARG3(*call);
     190                async_answer_0(iid, rc);
     191                return;
     192        }
    141193
    142194        rc = inetping_send(client, &sdu);
    143195        free(sdu.data);
    144196
    145         async_answer_0(callid, rc);
     197        async_answer_0(iid, rc);
    146198}
    147199
    148200static void inetping_get_srcaddr_srv(inetping_client_t *client,
    149     ipc_callid_t callid, ipc_call_t *call)
     201    ipc_callid_t iid, ipc_call_t *icall)
    150202{
    151203        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
    152        
    153         uint32_t remote = IPC_GET_ARG1(*call);
    154         uint32_t local = 0;
    155        
    156         int rc = inetping_get_srcaddr(client, remote, &local);
    157         async_answer_1(callid, rc, (sysarg_t) local);
     204
     205        ipc_callid_t callid;
     206        size_t size;
     207
     208        inet_addr_t local;
     209        inet_addr_t remote;
     210
     211        if (!async_data_write_receive(&callid, &size)) {
     212                async_answer_0(callid, EREFUSED);
     213                async_answer_0(iid, EREFUSED);
     214                return;
     215        }
     216
     217        if (size != sizeof(remote)) {
     218                async_answer_0(callid, EINVAL);
     219                async_answer_0(iid, EINVAL);
     220                return;
     221        }
     222
     223        int rc = async_data_write_finalize(callid, &remote, size);
     224        if (rc != EOK) {
     225                async_answer_0(callid, rc);
     226                async_answer_0(iid, rc);
     227                return;
     228        }
     229
     230        rc = inetping_get_srcaddr(client, &remote, &local);
     231        if (rc != EOK) {
     232                async_answer_0(iid, rc);
     233                return;
     234        }
     235
     236        if (!async_data_read_receive(&callid, &size)) {
     237                async_answer_0(callid, EREFUSED);
     238                async_answer_0(iid, EREFUSED);
     239                return;
     240        }
     241
     242        if (size != sizeof(local)) {
     243                async_answer_0(callid, EINVAL);
     244                async_answer_0(iid, EINVAL);
     245                return;
     246        }
     247
     248        rc = async_data_read_finalize(callid, &local, size);
     249        if (rc != EOK)
     250                async_answer_0(callid, rc);
     251
     252        async_answer_0(iid, rc);
    158253}
    159254
    … …  
    163258        if (sess == NULL)
    164259                return ENOMEM;
    165        
     260
    166261        client->sess = sess;
    167262        link_initialize(&client->client_list);
    168        
     263
    169264        fibril_mutex_lock(&client_list_lock);
    170265        client->ident = ++inetping_ident;
    171266        list_append(&client->client_list, &client_list);
    172267        fibril_mutex_unlock(&client_list_lock);
    173        
     268
    174269        return EOK;
    175270}
    … …  
    179274        async_hangup(client->sess);
    180275        client->sess = NULL;
    181        
     276
    182277        fibril_mutex_lock(&client_list_lock);
    183278        list_remove(&client->client_list);
    … …  
    188283{
    189284        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
    190        
     285
    191286        /* Accept the connection */
    192287        async_answer_0(iid, EOK);
    193        
     288
    194289        inetping_client_t client;
    195290        int rc = inetping_client_init(&client);
    196291        if (rc != EOK)
    197292                return;
    198        
     293
    199294        while (true) {
    200295                ipc_call_t call;
    201296                ipc_callid_t callid = async_get_call(&call);
    202297                sysarg_t method = IPC_GET_IMETHOD(call);
    203                
     298
    204299                if (!method) {
    205300                        /* The other side has hung up */
    … …  
    207302                        break;
    208303                }
    209                
     304
    210305                switch (method) {
    211306                case INETPING_SEND:
    … …  
    219314                }
    220315        }
    221        
     316
    222317        inetping_client_fini(&client);
    223318}

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

    r408424e rc42f50d  
    3838#define INETPING_H_
    3939
     40#include <types/inetping.h>
    4041#include "inetsrv.h"
    4142

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

    r408424e rc42f50d  
    4646#include <stdlib.h>
    4747#include <sys/types.h>
    48 #include <net/socket_codes.h>
    4948#include "addrobj.h"
    5049#include "icmp.h"
    … …  
    5554#include "inetcfg.h"
    5655#include "inetping.h"
    57 #include "inetping6.h"
    5856#include "inet_link.h"
    5957#include "reass.h"
    … …  
    6361
    6462static inet_naddr_t solicited_node_mask = {
    65         .family = AF_INET6,
     63        .version = ip_v6,
    6664        .addr6 = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, 0xff, 0, 0, 0},
    6765        .prefix = 104
    … …  
    6967
    7068static inet_addr_t broadcast4_all_hosts = {
    71         .family = AF_INET,
     69        .version = ip_v4,
    7270        .addr = 0xffffffff
    7371};
    7472
    7573static inet_addr_t multicast_all_nodes = {
    76         .family = AF_INET6,
     74        .version = ip_v6,
    7775        .addr6 = {0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}
    7876};
    … …  
    116114                return EEXIST;
    117115        }
    118        
    119         rc = loc_service_register_with_iface(SERVICE_NAME_INETPING6, &sid,
    120             INET_PORT_PING6);
    121         if (rc != EOK) {
    122                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service (%d).", rc);
    123                 return EEXIST;
    124         }
    125        
    126         rc = inet_link_discovery_start();
    127         if (rc != EOK)
    128                 return EEXIST;
    129116       
    130117        return EOK;
    … …  
    184171
    185172        if (dgram->iplink != 0) {
     173                /* XXX TODO - IPv6 */
    186174                log_msg(LOG_DEFAULT, LVL_DEBUG, "dgram directly to iplink %zu",
    187175                    dgram->iplink);
    … …  
    191179                        return ENOENT;
    192180
    193                 if (dgram->src.family != AF_INET ||
    194                         dgram->dest.family != AF_INET)
     181                if (dgram->src.version != ip_v4 ||
     182                        dgram->dest.version != ip_v4)
    195183                        return EINVAL;
    196184
    … …  
    229217
    230218        /* Take source address from the address object */
    231         if (remote->family == AF_INET && remote->addr == 0xffffffff) {
    232                 local->family = AF_INET;
     219        if (remote->version == ip_v4 && remote->addr == 0xffffffff) {
     220                /* XXX TODO - IPv6 */
     221                local->version = ip_v4;
    233222                local->addr = 0;
    234223                return EOK;
    235224        }
     225
    236226        inet_naddr_addr(&dir.aobj->naddr, local);
    237227        return EOK;
    … …  
    454444                inetping_conn(iid, icall, arg);
    455445                break;
    456         case INET_PORT_PING6:
    457                 inetping6_conn(iid, icall, arg);
    458                 break;
    459446        default:
    460447                async_answer_0(iid, ENOTSUP);

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

    r408424e rc42f50d  
    148148} inet_dir_t;
    149149
    150 typedef struct {
    151         uint32_t src;
    152         uint32_t dest;
    153         uint16_t seq_no;
    154         void *data;
    155         size_t size;
    156 } inetping_sdu_t;
    157 
    158 typedef struct {
    159         addr128_t src;
    160         addr128_t dest;
    161         uint16_t seq_no;
    162         void *data;
    163         size_t size;
    164 } inetping6_sdu_t;
    165 
    166150extern int inet_ev_recv(inet_client_t *, inet_dgram_t *);
    167151extern int inet_recv_packet(inet_packet_t *);

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

    r408424e rc42f50d  
    3939#include <malloc.h>
    4040#include <io/log.h>
    41 #include <net/socket_codes.h>
    4241#include "ntrans.h"
    4342#include "addrobj.h"

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

    r408424e rc42f50d  
    4444#include <mem.h>
    4545#include <stdlib.h>
    46 #include <net/socket_codes.h>
    4746#include "inetsrv.h"
    4847#include "inet_std.h"
    … …  
    533532int ndp_pdu_decode(inet_dgram_t *dgram, ndp_packet_t *ndp)
    534533{
    535         uint16_t src_af = inet_addr_get(&dgram->src, NULL,
     534        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL,
    536535            &ndp->sender_proto_addr);
    537         if (src_af != AF_INET6)
     536        if (src_ver != ip_v6)
    538537                return EINVAL;
    539538       

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

    r408424e rc42f50d  
    9595inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
    9696{
    97         uint16_t addr_af = inet_addr_get(addr, NULL, NULL);
     97        ip_ver_t addr_ver = inet_addr_get(addr, NULL, NULL);
    9898       
    9999        inet_sroute_t *best = NULL;
    … …  
    104104        list_foreach(sroute_list, sroute_list, inet_sroute_t, sroute) {
    105105                uint8_t dest_bits;
    106                 uint16_t dest_af = inet_naddr_get(&sroute->dest, NULL, NULL,
     106                ip_ver_t dest_ver = inet_naddr_get(&sroute->dest, NULL, NULL,
    107107                    &dest_bits);
    108108               
    109109                /* Skip comparison with different address family */
    110                 if (addr_af != dest_af)
     110                if (addr_ver != dest_ver)
    111111                        continue;
    112112               

  • uspace/srv/net/loopip/loopip.c

    r408424e rc42f50d  
    4040#include <inet/iplink_srv.h>
    4141#include <inet/addr.h>
    42 #include <net/socket_codes.h>
    4342#include <io/log.h>
    4443#include <loc.h>
    … …  
    7675        link_t link;
    7776       
    78         uint16_t af;
     77        /* XXX Version should be part of SDU */
     78        ip_ver_t ver;
    7979        iplink_recv_sdu_t sdu;
    8080} rqueue_entry_t;
    … …  
    8888                    list_get_instance(link, rqueue_entry_t, link);
    8989               
    90                 (void) iplink_ev_recv(&loopip_iplink, &rqe->sdu, rqe->af);
     90                (void) iplink_ev_recv(&loopip_iplink, &rqe->sdu, rqe->ver);
    9191               
    9292                free(rqe->sdu.data);
    … …  
    174174         * Clone SDU
    175175         */
    176         rqe->af = AF_INET;
     176        rqe->ver = ip_v4;
    177177        rqe->sdu.data = malloc(sdu->size);
    178178        if (rqe->sdu.data == NULL) {
    … …  
    203203         * Clone SDU
    204204         */
    205         rqe->af = AF_INET6;
     205        rqe->ver = ip_v6;
    206206        rqe->sdu.data = malloc(sdu->size);
    207207        if (rqe->sdu.data == NULL) {

  • uspace/srv/net/nconfsrv/Makefile

    r408424e rc42f50d  
    11#
    2 # Copyright (c) 2013 Antonin Steinhauser
     2# Copyright (c) 2013 Jiri Svoboda
    33# All rights reserved.
    44#
    … …  
    2727#
    2828
    29 USPACE_PREFIX = ../..
    30 BINARY = ping6
     29USPACE_PREFIX = ../../..
     30BINARY = nconfsrv
    3131
    3232SOURCES = \
    33         ping6.c
     33        iplink.c \
     34        nconfsrv.c
    3435
    3536include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/net/slip/slip.c

    r408424e rc42f50d  
    3838#include <stdint.h>
    3939#include <loc.h>
    40 #include <net/socket_codes.h>
    4140#include <inet/addr.h>
    4241#include <inet/iplink_srv.h>
    … …  
    277276
    278277pass:
    279                 rc = iplink_ev_recv(&slip_iplink, &sdu, AF_INET);
     278                rc = iplink_ev_recv(&slip_iplink, &sdu, ip_v4);
    280279                if (rc != EOK) {
    281280                        log_msg(LOG_DEFAULT, LVL_ERROR,

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

    r408424e rc42f50d  
    381381 * @param conn  Connection
    382382 */
    383 static void tcp_conn_reset(tcp_conn_t *conn)
     383void tcp_conn_reset(tcp_conn_t *conn)
    384384{
    385385        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_conn_reset()", conn->name);

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

    r408424e rc42f50d  
    4343extern void tcp_conn_add(tcp_conn_t *);
    4444extern void tcp_conn_remove(tcp_conn_t *);
     45extern void tcp_conn_reset(tcp_conn_t *conn);
    4546extern void tcp_conn_sync(tcp_conn_t *);
    4647extern void tcp_conn_fin_sent(tcp_conn_t *);

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

    r408424e rc42f50d  
    4040#include <mem.h>
    4141#include <stdlib.h>
    42 #include <net/socket_codes.h>
    4342#include "pdu.h"
    4443#include "segment.h"
    … …  
    145144}
    146145
    147 static uint16_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr,
     146static ip_ver_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr,
    148147    tcp_phdr6_t *phdr6)
    149148{
    150149        addr32_t src_v4;
    151150        addr128_t src_v6;
    152         uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
    153        
     151        uint16_t src_ver = inet_addr_get(&pdu->src, &src_v4, &src_v6);
     152
    154153        addr32_t dest_v4;
    155154        addr128_t dest_v6;
    156         uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
    157        
    158         assert(src_af == dest_af);
    159        
    160         switch (src_af) {
    161         case AF_INET:
     155        uint16_t dest_ver = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
     156
     157        assert(src_ver == dest_ver);
     158
     159        switch (src_ver) {
     160        case ip_v4:
    162161                phdr->src = host2uint32_t_be(src_v4);
    163162                phdr->dest = host2uint32_t_be(dest_v4);
    … …  
    167166                    host2uint16_t_be(pdu->header_size + pdu->text_size);
    168167                break;
    169         case AF_INET6:
     168        case ip_v6:
    170169                host2addr128_t_be(src_v6, phdr6->src);
    171170                host2addr128_t_be(dest_v6, phdr6->dest);
    … …  
    178177                assert(false);
    179178        }
    180        
    181         return src_af;
     179
     180        return src_ver;
    182181}
    183182
    … …  
    266265        tcp_phdr_t phdr;
    267266        tcp_phdr6_t phdr6;
    268        
    269         uint16_t af = tcp_phdr_setup(pdu, &phdr, &phdr6);
    270         switch (af) {
    271         case AF_INET:
     267
     268        ip_ver_t ver = tcp_phdr_setup(pdu, &phdr, &phdr6);
     269        switch (ver) {
     270        case ip_v4:
    272271                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr,
    273272                    sizeof(tcp_phdr_t));
    274273                break;
    275         case AF_INET6:
     274        case ip_v6:
    276275                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr6,
    277276                    sizeof(tcp_phdr6_t));
    … …  
    280279                assert(false);
    281280        }
    282        
     281
    283282        cs_headers = tcp_checksum_calc(cs_phdr, pdu->header, pdu->header_size);
    284283        return tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);

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

    r408424e rc42f50d  
    882882        tcp_sockdata_t *socket;
    883883        tcp_error_t trc;
     884        int i;
    884885        int rc;
    885886
    … …  
    897898
    898899        if (socket->conn != NULL) {
     900                /* Close connection */
    899901                trc = tcp_uc_close(socket->conn);
    900902                if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
    … …  
    905907        }
    906908
     909        if (socket->lconn != NULL) {
     910                /* Close listening connections */
     911                for (i = 0; i < socket->backlog; i++) {
     912                        tcp_uc_set_cstate_cb(socket->lconn[i]->conn, NULL, NULL);
     913                        trc = tcp_uc_close(socket->lconn[i]->conn);
     914                        if (trc != TCP_EOK && trc != TCP_ENOTEXIST) {
     915                                fibril_mutex_unlock(&socket->lock);
     916                                async_answer_0(callid, EBADF);
     917                                return;
     918                        }
     919
     920                        free(socket->lconn[i]);
     921                        socket->lconn[i] = NULL;
     922                }
     923        }
     924
    907925        /* Grab recv_buffer_lock because of CV wait in tcp_sock_recv_fibril() */
    908926        fibril_mutex_lock(&socket->recv_buffer_lock);

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

    r408424e rc42f50d  
    8383
    8484        if (oflags == tcp_open_nonblock) {
     85                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_open -> %p", nconn);
    8586                *conn = nconn;
    8687                return TCP_EOK;
    … …  
    234235tcp_error_t tcp_uc_close(tcp_conn_t *conn)
    235236{
    236         log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_close()", conn->name);
     237        log_msg(LOG_DEFAULT, LVL_DEBUG, "%s: tcp_uc_close(%p)", conn->name,
     238            conn);
    237239
    238240        fibril_mutex_lock(&conn->lock);
    239241
    240242        if (conn->cstate == st_closed) {
     243                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_close - ENOTEXIST");
    241244                fibril_mutex_unlock(&conn->lock);
    242245                return TCP_ENOTEXIST;
    243246        }
    244247
     248        if (conn->cstate == st_listen || conn->cstate == st_syn_sent) {
     249                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_close - listen/syn_sent");
     250                tcp_conn_reset(conn);
     251                tcp_conn_remove(conn);
     252                return TCP_EOK;
     253        }
     254
    245255        if (conn->snd_buf_fin) {
     256                log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_close - ECLOSING");
    246257                fibril_mutex_unlock(&conn->lock);
    247258                return TCP_ECLOSING;
    248259        }
    249260
     261        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_uc_close - set snd_buf_fin");
    250262        conn->snd_buf_fin = true;
    251263        tcp_tqueue_new_data(conn);

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

    r408424e rc42f50d  
    8585}
    8686
    87 static uint16_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr,
     87static ip_ver_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr,
    8888    udp_phdr6_t *phdr6)
    8989{
    9090        addr32_t src_v4;
    9191        addr128_t src_v6;
    92         uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
    93        
     92        ip_ver_t src_ver = inet_addr_get(&pdu->src, &src_v4, &src_v6);
     93
    9494        addr32_t dest_v4;
    9595        addr128_t dest_v6;
    96         uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
    97        
    98         assert(src_af == dest_af);
    99        
    100         switch (src_af) {
    101         case AF_INET:
     96        ip_ver_t dest_ver = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
     97
     98        assert(src_ver == dest_ver);
     99
     100        switch (src_ver) {
     101        case ip_v4:
    102102                phdr->src_addr = host2uint32_t_be(src_v4);
    103103                phdr->dest_addr = host2uint32_t_be(dest_v4);
    … …  
    106106                phdr->udp_length = host2uint16_t_be(pdu->data_size);
    107107                break;
    108         case AF_INET6:
     108        case ip_v6:
    109109                host2addr128_t_be(src_v6, phdr6->src_addr);
    110110                host2addr128_t_be(dest_v6, phdr6->dest_addr);
    … …  
    116116                assert(false);
    117117        }
    118        
    119         return src_af;
     118
     119        return src_ver;
    120120}
    121121
    … …  
    136136        udp_phdr_t phdr;
    137137        udp_phdr6_t phdr6;
    138        
    139         uint16_t af = udp_phdr_setup(pdu, &phdr, &phdr6);
    140         switch (af) {
    141         case AF_INET:
     138
     139        ip_ver_t ver = udp_phdr_setup(pdu, &phdr, &phdr6);
     140        switch (ver) {
     141        case ip_v4:
    142142                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr,
    143143                    sizeof(udp_phdr_t));
    144144                break;
    145         case AF_INET6:
     145        case ip_v6:
    146146                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr6,
    147147                    sizeof(udp_phdr6_t));
    … …  
    150150                assert(false);
    151151        }
    152        
     152
    153153        return udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
    154154}
Note: See TracChangeset for help on using the changeset viewer.