Changeset b1213b0 in mainline


Ignore:
Timestamp:
2012-04-17T07:13:35Z (13 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
96c0b7b
Parents:
d76a329 (diff), 06a1d077 (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 internet stack rewrite (IP+ICMP, UDP, IP over Ethernet).

Files:
46 added
74 deleted
21 edited
46 moved

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    rd76a329 rb1213b0  
    106106        $(USPACE_PATH)/srv/fs/ext2fs/ext2fs \
    107107        $(USPACE_PATH)/srv/hid/remcons/remcons \
     108        $(USPACE_PATH)/srv/net/ethip/ethip \
     109        $(USPACE_PATH)/srv/net/inet/inet \
     110        $(USPACE_PATH)/srv/net/tcp/tcp \
     111        $(USPACE_PATH)/srv/net/udp/udp \
    108112        $(USPACE_PATH)/srv/taskmon/taskmon \
    109         $(USPACE_PATH)/srv/net/nil/eth/eth \
    110         $(USPACE_PATH)/srv/net/nil/nildummy/nildummy \
    111         $(USPACE_PATH)/srv/net/il/arp/arp \
    112         $(USPACE_PATH)/srv/net/il/ip/ip \
    113         $(USPACE_PATH)/srv/net/tl/icmp/icmp \
    114         $(USPACE_PATH)/srv/net/tl/udp/udp \
    115         $(USPACE_PATH)/srv/net/tl/tcp/tcp \
    116         $(USPACE_PATH)/srv/net/net/net \
    117113        $(USPACE_PATH)/srv/devman/devman
    118114
    … …  
    161157        $(USPACE_PATH)/app/edit/edit \
    162158        $(USPACE_PATH)/app/ext2info/ext2info \
     159        $(USPACE_PATH)/app/inetcfg/inetcfg \
    163160        $(USPACE_PATH)/app/kill/kill \
    164161        $(USPACE_PATH)/app/killall/killall \
    … …  
    203200endif
    204201
    205 ifneq ($(CONFIG_BAREBONE),y)
    206 NET_CFG = \
    207         $(USPACE_PATH)/srv/net/cfg/general \
    208         $(USPACE_PATH)/srv/net/cfg/lo.nic \
    209         $(USPACE_PATH)/srv/net/cfg/ne2k.nic \
    210         $(USPACE_PATH)/srv/net/cfg/e1k.nic
    211 endif
    212 
    213202COMPONENTS = \
    214203        $(KERNEL_PATH)/kernel.bin \

  • uspace/Makefile

    rd76a329 rb1213b0  
    4242        app/getterm \
    4343        app/init \
     44        app/inetcfg \
    4445        app/kill \
    4546        app/killall \
    … …  
    7475        srv/devman \
    7576        srv/loader \
     77        srv/net/ethip \
     78        srv/net/inet \
     79        srv/net/tcp \
     80        srv/net/udp \
    7681        srv/ns \
    7782        srv/taskmon \
    … …  
    96101        srv/hid/remcons \
    97102        srv/hw/char/s3c24xx_uart \
    98         srv/net/il/arp \
    99         srv/net/il/ip \
    100         srv/net/tl/icmp \
    101         srv/net/tl/udp \
    102         srv/net/tl/tcp \
    103         srv/net/nil/eth \
    104         srv/net/nil/nildummy \
    105         srv/net/net \
    106103        drv/infrastructure/root \
    107104        drv/infrastructure/rootvirt \

  • uspace/app/inetcfg/Makefile

    rd76a329 rb1213b0  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2012 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2827#
    2928
    30 USPACE_PREFIX = ../../../..
    31 LIBS = $(LIBNET_PREFIX)/libnet.a
    32 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    33 BINARY = ip
     29USPACE_PREFIX = ../..
     30BINARY = inetcfg
    3431
    3532SOURCES = \
    36         ip.c
     33        inetcfg.c
    3734
    3835include $(USPACE_PREFIX)/Makefile.common

  • uspace/app/init/init.c

    rd76a329 rb1213b0  
    305305        srv_start("/srv/s3c24ts");
    306306       
    307         spawn("/srv/net");
     307        spawn("/srv/ethip");
     308        spawn("/srv/inet");
     309        spawn("/srv/tcp");
     310        spawn("/srv/udp");
    308311       
    309312        spawn("/srv/fb");

  • uspace/app/netecho/netecho.c

    rd76a329 rb1213b0  
    373373                address_in.sin_family = AF_INET;
    374374                address_in.sin_port = htons(port);
     375                address_in.sin_addr.s_addr = INADDR_ANY;
    375376                address = (struct sockaddr *) &address_in;
    376377                addrlen = sizeof(address_in);

  • uspace/app/netecho/print_error.c

    rd76a329 rb1213b0  
    4040#include <errno.h>
    4141
    42 #include <net/icmp_codes.h>
    43 
    44 /** Prints the specific ICMP error description.
    45  *
    46  * @param[in] output The description output stream. May be NULL.
    47  * @param[in] error_code The ICMP error code.
    48  * @param[in] prefix The error description prefix. May be NULL.
    49  * @param[in] suffix The error description suffix. May be NULL.
    50  */
    51 void icmp_print_error(FILE *output, int error_code, const char *prefix, const char *suffix)
    52 {
    53         if (!output)
    54                 return;
    55        
    56         if (prefix)
    57                 fprintf(output, "%s", prefix);
    58                
    59         switch (error_code) {
    60         case ICMP_DEST_UNREACH:
    61                 fprintf(output, "ICMP Destination Unreachable (%d) error", error_code);
    62                 break;
    63         case ICMP_SOURCE_QUENCH:
    64                 fprintf(output, "ICMP Source Quench (%d) error", error_code);
    65                 break;
    66         case ICMP_REDIRECT:
    67                 fprintf(output, "ICMP Redirect (%d) error", error_code);
    68                 break;
    69         case ICMP_ALTERNATE_ADDR:
    70                 fprintf(output, "ICMP Alternate Host Address (%d) error", error_code);
    71                 break;
    72         case ICMP_ROUTER_ADV:
    73                 fprintf(output, "ICMP Router Advertisement (%d) error", error_code);
    74                 break;
    75         case ICMP_ROUTER_SOL:
    76                 fprintf(output, "ICMP Router Solicitation (%d) error", error_code);
    77                 break;
    78         case ICMP_TIME_EXCEEDED:
    79                 fprintf(output, "ICMP Time Exceeded (%d) error", error_code);
    80                 break;
    81         case ICMP_PARAMETERPROB:
    82                 fprintf(output, "ICMP Paramenter Problem (%d) error", error_code);
    83                 break;
    84         case ICMP_CONVERSION_ERROR:
    85                 fprintf(output, "ICMP Datagram Conversion Error (%d) error", error_code);
    86                 break;
    87         case ICMP_REDIRECT_MOBILE:
    88                 fprintf(output, "ICMP Mobile Host Redirect (%d) error", error_code);
    89                 break;
    90         case ICMP_SKIP:
    91                 fprintf(output, "ICMP SKIP (%d) error", error_code);
    92                 break;
    93         case ICMP_PHOTURIS:
    94                 fprintf(output, "ICMP Photuris (%d) error", error_code);
    95                 break;
    96         default:
    97                 fprintf(output, "Other (%d) error", error_code);
    98         }
    99 
    100         if (suffix)
    101                 fprintf(output, "%s", suffix);
    102 }
    103 
    10442/** Prints the error description.
    10543 *
    106  * Supports ICMP and socket error codes.
     44 * Supports socket error codes.
    10745 *
    10846 * @param[in] output The description output stream. May be NULL.
    … …  
    11351void print_error(FILE *output, int error_code, const char *prefix, const char *suffix)
    11452{
    115         if (IS_ICMP_ERROR(error_code))
    116                 icmp_print_error(output, error_code, prefix, suffix);
    117         else if(IS_SOCKET_ERROR(error_code))
     53        if(IS_SOCKET_ERROR(error_code))
    11854                socket_print_error(output, error_code, prefix, suffix);
    11955}

  • uspace/app/ping/Makefile

    rd76a329 rb1213b0  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2012 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2928
    3029USPACE_PREFIX = ../..
    31 LIBS =
    32 EXTRA_CFLAGS =
    3330BINARY = ping
    3431
    3532SOURCES = \
    36         ping.c \
    37         print_error.c
     33        ping.c
    3834
    3935include $(USPACE_PREFIX)/Makefile.common

  • uspace/app/ping/ping.c

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * Packet Internet Network Grouper.
     32/** @file ICMP echo utility.
    3533 */
    3634
    3735#include <async.h>
     36#include <bool.h>
     37#include <errno.h>
     38#include <fibril_synch.h>
     39#include <inet/inetping.h>
     40#include <io/console.h>
    3841#include <stdio.h>
    39 #include <str.h>
    40 #include <task.h>
    41 #include <time.h>
    42 #include <ipc/services.h>
    43 #include <str_error.h>
    44 #include <errno.h>
    45 #include <arg_parse.h>
    46 
    47 #include <net/icmp_api.h>
    48 #include <net/in.h>
    49 #include <net/in6.h>
    50 #include <net/inet.h>
    51 #include <net/socket_parse.h>
    52 #include <net/ip_codes.h>
    53 
    54 #include "print_error.h"
    55 
    56 #define NAME  "ping"
    57 
    58 #define CL_OK           0
    59 #define CL_USAGE        -1
    60 #define CL_MISSING      -2
    61 #define CL_INVALID      -3
    62 #define CL_UNSUPPORTED  -4
    63 #define CL_ERROR        -5
    64 
    65 /** Ping configuration
    66  *
    67  */
    68 typedef struct {
    69         bool verbose;               /**< Verbose printouts. */
    70         size_t size;                /**< Outgoing packet size. */
    71         unsigned int count;         /**< Number of packets to send. */
    72         suseconds_t timeout;        /**< Reply wait timeout. */
    73         int af;                     /**< Address family. */
    74         ip_tos_t tos;               /**< Type of service. */
    75         ip_ttl_t ttl;               /**< Time-to-live. */
    76         bool fragments;             /**< Fragmentation. */
    77        
    78         char *dest_addr;            /**< Destination address. */
    79         struct sockaddr_in dest;    /**< IPv4 destionation. */
    80         struct sockaddr_in6 dest6;  /**< IPv6 destionation. */
    81        
    82         struct sockaddr *dest_raw;  /**< Raw destination address. */
    83         socklen_t dest_len;         /**< Raw destination address length. */
    84        
    85         /** Converted address string. */
    86         char dest_str[INET6_ADDRSTRLEN];
    87 } ping_config_t;
    88 
    89 
    90 static void usage(void)
    91 {
    92         printf(
    93             "Usage: ping [-c count] [-s size] [-W timeout] [-f family] [-t ttl]\n" \
    94             "            [-Q tos] [--dont_fragment] destination\n" \
    95             "\n" \
    96             "Options:\n" \
    97             "\t-c count\n" \
    98             "\t--count=count\n" \
    99             "\t\tNumber of outgoing packets (default: 4)\n" \
    100             "\n" \
    101             "\t-s size\n" \
    102             "\t--size=bytes\n" \
    103             "\t\tOutgoing packet size (default: 56 bytes)\n" \
    104             "\n" \
    105             "\t-W timeout\n" \
    106             "\t--timeout=ms\n" \
    107             "\t\tReply wait timeout (default: 3000 ms)\n" \
    108             "\n" \
    109             "\t-f family\n" \
    110             "\t--family=family\n" \
    111             "\t\tDestination address family, AF_INET or AF_INET6 (default: AF_INET)\n" \
    112             "\n" \
    113             "\t-t ttl\n" \
    114             "\t--ttl=ttl\n" \
    115             "\t\tOutgoing packet time-to-live (default: 0)\n" \
    116             "\n" \
    117             "\t-Q tos\n" \
    118             "\t--tos=tos\n" \
    119             "\t\tOutgoing packet type of service (default: 0)\n" \
    120             "\n" \
    121             "\t--dont_fragment\n" \
    122             "\t\tDisable packet fragmentation (default: enabled)\n" \
    123             "\n" \
    124             "\t-v\n" \
    125             "\t--verbose\n" \
    126             "\t\tVerbose operation\n" \
    127             "\n" \
    128             "\t-h\n" \
    129             "\t--help\n" \
    130             "\t\tPrint this usage information\n"
    131         );
    132 }
    133 
    134 static int args_parse(int argc, char *argv[], ping_config_t *config)
    135 {
    136         if (argc < 2)
    137                 return CL_USAGE;
    138        
     42#include <stdlib.h>
     43#include <sys/types.h>
     44
     45#define NAME "ping"
     46
     47/** Delay between subsequent ping requests in microseconds */
     48#define PING_DELAY (1000 * 1000)
     49
     50/** Ping request timeout in microseconds */
     51#define PING_TIMEOUT (1000 * 1000)
     52
     53static int ping_ev_recv(inetping_sdu_t *);
     54
     55static bool done = false;
     56static FIBRIL_CONDVAR_INITIALIZE(done_cv);
     57static FIBRIL_MUTEX_INITIALIZE(done_lock);
     58
     59static inetping_ev_ops_t ev_ops = {
     60        .recv = ping_ev_recv
     61};
     62
     63static inet_addr_t src_addr;
     64static inet_addr_t dest_addr;
     65
     66static bool ping_repeat = false;
     67
     68static void print_syntax(void)
     69{
     70        printf("syntax: " NAME " [-r] <addr>\n");
     71}
     72
     73static int addr_parse(const char *text, inet_addr_t *addr)
     74{
     75        unsigned long a[4];
     76        char *cp = (char *)text;
    13977        int i;
    140         int ret;
    141        
    142         for (i = 1; i < argc; i++) {
    143                
    144                 /* Not an option */
    145                 if (argv[i][0] != '-')
     78
     79        for (i = 0; i < 3; i++) {
     80                a[i] = strtoul(cp, &cp, 10);
     81                if (*cp != '.')
     82                        return EINVAL;
     83                ++cp;
     84        }
     85
     86        a[3] = strtoul(cp, &cp, 10);
     87        if (*cp != '\0')
     88                return EINVAL;
     89
     90        addr->ipv4 = 0;
     91        for (i = 0; i < 4; i++) {
     92                if (a[i] > 255)
     93                        return EINVAL;
     94                addr->ipv4 = (addr->ipv4 << 8) | a[i];
     95        }
     96
     97        return EOK;
     98}
     99
     100static int addr_format(inet_addr_t *addr, char **bufp)
     101{
     102        int rc;
     103
     104        rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
     105            (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
     106            addr->ipv4 & 0xff);
     107
     108        if (rc < 0)
     109                return ENOMEM;
     110
     111        return EOK;
     112}
     113
     114static void ping_signal_done(void)
     115{
     116        fibril_mutex_lock(&done_lock);
     117        done = true;
     118        fibril_mutex_unlock(&done_lock);
     119        fibril_condvar_broadcast(&done_cv);
     120}
     121
     122static int ping_ev_recv(inetping_sdu_t *sdu)
     123{
     124        char *asrc, *adest;
     125        int rc;
     126
     127        rc = addr_format(&sdu->src, &asrc);
     128        if (rc != EOK)
     129                return ENOMEM;
     130
     131        rc = addr_format(&sdu->dest, &adest);
     132        if (rc != EOK) {
     133                free(asrc);
     134                return ENOMEM;
     135        }
     136        printf("Received ICMP echo reply: from %s to %s, seq. no %u, "
     137            "payload size %zu\n", asrc, adest, sdu->seq_no, sdu->size);
     138
     139        if (!ping_repeat) {
     140                ping_signal_done();
     141        }
     142
     143        free(asrc);
     144        free(adest);
     145        return EOK;
     146}
     147
     148static int ping_send(uint16_t seq_no)
     149{
     150        inetping_sdu_t sdu;
     151        int rc;
     152
     153        sdu.src = src_addr;
     154        sdu.dest = dest_addr;
     155        sdu.seq_no = seq_no;
     156        sdu.data = (void *) "foo";
     157        sdu.size = 3;
     158
     159        rc = inetping_send(&sdu);
     160        if (rc != EOK) {
     161                printf(NAME ": Failed sending echo request (%d).\n", rc);
     162                return rc;
     163        }
     164
     165        return EOK;
     166}
     167
     168static int transmit_fibril(void *arg)
     169{
     170        uint16_t seq_no = 0;
     171
     172        while (true) {
     173                fibril_mutex_lock(&done_lock);
     174                if (done) {
     175                        fibril_mutex_unlock(&done_lock);
     176                        return 0;
     177                }
     178                fibril_mutex_unlock(&done_lock);
     179
     180                (void) ping_send(++seq_no);
     181                async_usleep(PING_DELAY);
     182        }
     183
     184        return 0;
     185}
     186
     187static int input_fibril(void *arg)
     188{
     189        console_ctrl_t *con;
     190        kbd_event_t ev;
     191
     192        con = console_init(stdin, stdout);
     193        printf("[Press Ctrl-Q to quit]\n");
     194
     195        while (true) {
     196                if (!console_get_kbd_event(con, &ev))
    146197                        break;
    147                
    148                 /* Options terminator */
    149                 if (str_cmp(argv[i], "--") == 0) {
    150                         i++;
    151                         break;
    152                 }
    153                
    154                 int off;
    155                
    156                 /* Usage */
    157                 if ((off = arg_parse_short_long(argv[i], "-h", "--help")) != -1)
    158                         return CL_USAGE;
    159                
    160                 /* Verbose */
    161                 if ((off = arg_parse_short_long(argv[i], "-v", "--verbose")) != -1) {
    162                         config->verbose = true;
    163                         continue;
    164                 }
    165                
    166                 /* Don't fragment */
    167                 if (str_cmp(argv[i], "--dont_fragment") == 0) {
    168                         config->fragments = false;
    169                         continue;
    170                 }
    171                
    172                 /* Count */
    173                 if ((off = arg_parse_short_long(argv[i], "-c", "--count=")) != -1) {
    174                         int tmp;
    175                         ret = arg_parse_int(argc, argv, &i, &tmp, off);
    176                        
    177                         if ((ret != EOK) || (tmp < 0))
    178                                 return i;
    179                        
    180                         config->count = (unsigned int) tmp;
    181                         continue;
    182                 }
    183                
    184                 /* Outgoing packet size */
    185                 if ((off = arg_parse_short_long(argv[i], "-s", "--size=")) != -1) {
    186                         int tmp;
    187                         ret = arg_parse_int(argc, argv, &i, &tmp, off);
    188                        
    189                         if ((ret != EOK) || (tmp < 0))
    190                                 return i;
    191                        
    192                         config->size = (size_t) tmp;
    193                         continue;
    194                 }
    195                
    196                 /* Reply wait timeout */
    197                 if ((off = arg_parse_short_long(argv[i], "-W", "--timeout=")) != -1) {
    198                         int tmp;
    199                         ret = arg_parse_int(argc, argv, &i, &tmp, off);
    200                        
    201                         if ((ret != EOK) || (tmp < 0))
    202                                 return i;
    203                        
    204                         config->timeout = (suseconds_t) tmp;
    205                         continue;
    206                 }
    207                
    208                 /* Address family */
    209                 if ((off = arg_parse_short_long(argv[i], "-f", "--family=")) != -1) {
    210                         ret = arg_parse_name_int(argc, argv, &i, &config->af, off,
    211                             socket_parse_address_family);
    212                        
    213                         if (ret != EOK)
    214                                 return i;
    215                        
    216                         continue;
    217                 }
    218                
    219                 /* Type of service */
    220                 if ((off = arg_parse_short_long(argv[i], "-Q", "--tos=")) != -1) {
    221                         int tmp;
    222                         ret = arg_parse_name_int(argc, argv, &i, &tmp, off,
    223                             socket_parse_address_family);
    224                        
    225                         if ((ret != EOK) || (tmp < 0))
    226                                 return i;
    227                        
    228                         config->tos = (ip_tos_t) tmp;
    229                         continue;
    230                 }
    231                
    232                 /* Time to live */
    233                 if ((off = arg_parse_short_long(argv[i], "-t", "--ttl=")) != -1) {
    234                         int tmp;
    235                         ret = arg_parse_name_int(argc, argv, &i, &tmp, off,
    236                             socket_parse_address_family);
    237                        
    238                         if ((ret != EOK) || (tmp < 0))
    239                                 return i;
    240                        
    241                         config->ttl = (ip_ttl_t) tmp;
    242                         continue;
    243                 }
    244         }
    245        
    246         if (i >= argc)
    247                 return CL_MISSING;
    248        
    249         config->dest_addr = argv[i];
    250        
    251         /* Resolve destionation address */
    252         switch (config->af) {
    253         case AF_INET:
    254                 config->dest_raw = (struct sockaddr *) &config->dest;
    255                 config->dest_len = sizeof(config->dest);
    256                 config->dest.sin_family = config->af;
    257                 ret = inet_pton(config->af, config->dest_addr,
    258                     (uint8_t *) &config->dest.sin_addr.s_addr);
    259                 break;
    260         case AF_INET6:
    261                 config->dest_raw = (struct sockaddr *) &config->dest6;
    262                 config->dest_len = sizeof(config->dest6);
    263                 config->dest6.sin6_family = config->af;
    264                 ret = inet_pton(config->af, config->dest_addr,
    265                     (uint8_t *) &config->dest6.sin6_addr.s6_addr);
    266                 break;
    267         default:
    268                 return CL_UNSUPPORTED;
    269         }
    270        
    271         if (ret != EOK)
    272                 return CL_INVALID;
    273        
    274         /* Convert destination address back to string */
    275         switch (config->af) {
    276         case AF_INET:
    277                 ret = inet_ntop(config->af,
    278                     (uint8_t *) &config->dest.sin_addr.s_addr,
    279                     config->dest_str, sizeof(config->dest_str));
    280                 break;
    281         case AF_INET6:
    282                 ret = inet_ntop(config->af,
    283                     (uint8_t *) &config->dest6.sin6_addr.s6_addr,
    284                     config->dest_str, sizeof(config->dest_str));
    285                 break;
    286         default:
    287                 return CL_UNSUPPORTED;
    288         }
    289        
    290         if (ret != EOK)
    291                 return CL_ERROR;
    292        
    293         return CL_OK;
     198
     199                if (ev.type == KEY_PRESS && (ev.mods & (KM_ALT | KM_SHIFT)) ==
     200                    0 && (ev.mods & KM_CTRL) != 0) {
     201                        /* Ctrl+key */
     202                        if (ev.key == KC_Q) {
     203                                ping_signal_done();
     204                                return 0;
     205                        }
     206                }
     207        }
     208
     209        return 0;
    294210}
    295211
    296212int main(int argc, char *argv[])
    297213{
    298         ping_config_t config;
    299        
    300         /* Default configuration */
    301         config.verbose = false;
    302         config.size = 56;
    303         config.count = 4;
    304         config.timeout = 3000;
    305         config.af = AF_INET;
    306         config.tos = 0;
    307         config.ttl = 0;
    308         config.fragments = true;
    309        
    310         int ret = args_parse(argc, argv, &config);
    311        
    312         switch (ret) {
    313         case CL_OK:
    314                 break;
    315         case CL_USAGE:
    316                 usage();
    317                 return 0;
    318         case CL_MISSING:
    319                 fprintf(stderr, "%s: Destination address missing\n", NAME);
    320                 return 1;
    321         case CL_INVALID:
    322                 fprintf(stderr, "%s: Destination address '%s' invalid or malformed\n",
    323                     NAME, config.dest_addr);
    324                 return 2;
    325         case CL_UNSUPPORTED:
    326                 fprintf(stderr, "%s: Destination address '%s' unsupported\n",
    327                     NAME, config.dest_addr);
    328                 return 3;
    329         case CL_ERROR:
    330                 fprintf(stderr, "%s: Destination address '%s' error\n",
    331                     NAME, config.dest_addr);
    332                 return 4;
    333         default:
    334                 fprintf(stderr, "%s: Unknown or invalid option '%s'\n", NAME,
    335                     argv[ret]);
    336                 return 5;
    337         }
    338        
    339         printf("PING %s (%s) %zu(%zu) bytes of data\n", config.dest_addr,
    340             config.dest_str, config.size, config.size);
    341        
    342         async_sess_t *sess = icmp_connect_module();
    343         if (!sess) {
    344                 fprintf(stderr, "%s: Unable to connect to ICMP service (%s)\n", NAME,
    345                     str_error(errno));
    346                 return errno;
    347         }
    348        
    349         unsigned int seq;
    350         for (seq = 0; seq < config.count; seq++) {
    351                 struct timeval t0;
    352                 ret = gettimeofday(&t0, NULL);
    353                 if (ret != EOK) {
    354                         fprintf(stderr, "%s: gettimeofday failed (%s)\n", NAME,
    355                             str_error(ret));
    356                        
    357                         async_hangup(sess);
    358                         return ret;
    359                 }
    360                
    361                 /* Ping! */
    362                 int result = icmp_echo_msg(sess, config.size, config.timeout,
    363                     config.ttl, config.tos, !config.fragments, config.dest_raw,
    364                     config.dest_len);
    365                
    366                 struct timeval t1;
    367                 ret = gettimeofday(&t1, NULL);
    368                 if (ret != EOK) {
    369                         fprintf(stderr, "%s: gettimeofday failed (%s)\n", NAME,
    370                             str_error(ret));
    371                        
    372                         async_hangup(sess);
    373                         return ret;
    374                 }
    375                
    376                 suseconds_t elapsed = tv_sub(&t1, &t0);
    377                
    378                 switch (result) {
    379                 case ICMP_ECHO:
    380                         printf("%zu bytes from ? (?): icmp_seq=%u ttl=? time=%ld.%04ld\n",
    381                                 config.size, seq, elapsed / 1000, elapsed % 1000);
    382                         break;
    383                 case ETIMEOUT:
    384                         printf("%zu bytes from ? (?): icmp_seq=%u Timed out\n",
    385                                 config.size, seq);
    386                         break;
    387                 default:
    388                         print_error(stdout, result, NULL, "\n");
    389                 }
    390         }
    391        
    392         async_hangup(sess);
    393        
     214        int rc;
     215        int argi;
     216
     217        rc = inetping_init(&ev_ops);
     218        if (rc != EOK) {
     219                printf(NAME ": Failed connecting to internet ping service "
     220                    "(%d).\n", rc);
     221                return 1;
     222        }
     223
     224        argi = 1;
     225        if (argi < argc && str_cmp(argv[argi], "-r") == 0) {
     226                ping_repeat = true;
     227                ++argi;
     228        } else {
     229                ping_repeat = false;
     230        }
     231
     232        if (argc - argi != 1) {
     233                print_syntax();
     234                return 1;
     235        }
     236
     237        /* Parse destination address */
     238        rc = addr_parse(argv[argi], &dest_addr);
     239        if (rc != EOK) {
     240                printf(NAME ": Invalid address format.\n");
     241                print_syntax();
     242                return 1;
     243        }
     244
     245        /* Determine source address */
     246        rc = inetping_get_srcaddr(&dest_addr, &src_addr);
     247        if (rc != EOK) {
     248                printf(NAME ": Failed determining source address.\n");
     249                return 1;
     250        }
     251
     252        fid_t fid;
     253
     254        if (ping_repeat) {
     255                fid = fibril_create(transmit_fibril, NULL);
     256                if (fid == 0) {
     257                        printf(NAME ": Failed creating transmit fibril.\n");
     258                        return 1;
     259                }
     260
     261                fibril_add_ready(fid);
     262
     263                fid = fibril_create(input_fibril, NULL);
     264                if (fid == 0) {
     265                        printf(NAME ": Failed creating input fibril.\n");
     266                        return 1;
     267                }
     268
     269                fibril_add_ready(fid);
     270        } else {
     271                ping_send(1);
     272        }
     273
     274        fibril_mutex_lock(&done_lock);
     275        rc = EOK;
     276        while (!done && rc != ETIMEOUT) {
     277                rc = fibril_condvar_wait_timeout(&done_cv, &done_lock,
     278                        ping_repeat ? 0 : PING_TIMEOUT);
     279        }
     280        fibril_mutex_unlock(&done_lock);
     281
     282        if (rc == ETIMEOUT) {
     283                printf(NAME ": Echo request timed out.\n");
     284                return 1;
     285        }
     286
    394287        return 0;
    395288}

  • uspace/drv/nic/e1k/Makefile

    rd76a329 rb1213b0  
    2828
    2929USPACE_PREFIX = ../../..
    30 LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNET_PREFIX)/libnet.a $(LIBNIC_PREFIX)/libnic.a
    31 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNET_PREFIX)/include -I$(LIBNIC_PREFIX)/include
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNIC_PREFIX)/libnic.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNIC_PREFIX)/include
    3232BINARY = e1k
    3333

  • uspace/drv/nic/e1k/e1k.c

    rd76a329 rb1213b0  
    4949#include <device/pci.h>
    5050#include <nic.h>
    51 #include <nil_remote.h>
    5251#include <ops/nic.h>
    5352#include "e1k.h"

  • uspace/drv/nic/lo/Makefile

    rd76a329 rb1213b0  
    2828
    2929USPACE_PREFIX = ../../..
    30 LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNET_PREFIX)/libnet.a $(LIBNIC_PREFIX)/libnic.a
    31 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNET_PREFIX)/include -I$(LIBNIC_PREFIX)/include
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNIC_PREFIX)/libnic.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNIC_PREFIX)/include
    3232BINARY = lo
    3333

  • uspace/drv/nic/ne2k/Makefile

    rd76a329 rb1213b0  
    2828
    2929USPACE_PREFIX = ../../..
    30 LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNET_PREFIX)/libnet.a $(LIBNIC_PREFIX)/libnic.a
    31 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNET_PREFIX)/include -I$(LIBNIC_PREFIX)/include
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNIC_PREFIX)/libnic.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNIC_PREFIX)/include
    3232BINARY = ne2k
    3333

  • uspace/drv/nic/rtl8139/Makefile

    rd76a329 rb1213b0  
    2828
    2929USPACE_PREFIX = ../../..
    30 LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNET_PREFIX)/libnet.a $(LIBNIC_PREFIX)/libnic.a
    31 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNET_PREFIX)/include -I$(LIBNIC_PREFIX)/include
     30LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBNIC_PREFIX)/libnic.a
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBNIC_PREFIX)/include
    3232BINARY = rtl8139
    3333

  • uspace/drv/nic/rtl8139/driver.c

    rd76a329 rb1213b0  
    4444#include <sysinfo.h>
    4545#include <ipc/ns.h>
    46 
    47 #include <net_checksum.h>
    4846
    4947#include <str.h>

  • uspace/lib/c/Makefile

    rd76a329 rb1213b0  
    8787        generic/task.c \
    8888        generic/futex.c \
     89        generic/inet.c \
     90        generic/inetcfg.c \
     91        generic/inetping.c \
    8992        generic/io/asprintf.c \
    9093        generic/io/io.c \
    … …  
    97100        generic/io/printf_core.c \
    98101        generic/io/console.c \
     102        generic/iplink.c \
     103        generic/iplink_srv.c \
    99104        generic/malloc.c \
    100105        generic/sysinfo.c \
    … …  
    108113        generic/adt/hash_set.c \
    109114        generic/adt/dynamic_fifo.c \
    110         generic/adt/measured_strings.c \
    111115        generic/adt/char_map.c \
    112116        generic/adt/prodcons.c \
    … …  
    118122        generic/vfs/canonify.c \
    119123        generic/net/inet.c \
    120         generic/net/icmp_common.c \
    121         generic/net/icmp_api.c \
    122124        generic/net/modules.c \
    123         generic/net/packet.c \
    124125        generic/net/socket_client.c \
    125126        generic/net/socket_parse.c \

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup libc
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * Hardware types according to the on-line IANA - Address Resolution Protocol
    35  * (ARP) Parameters
    36  * http://www.iana.org/assignments/arp-parameters/arp-parameters.xml,
    37  * cited January 14 2009.
    3833 */
    3934
    40 #ifndef LIBNET_NET_HARDWARE_H_
    41 #define LIBNET_NET_HARDWARE_H_
     35#ifndef LIBC_INET_INET_H_
     36#define LIBC_INET_INET_H_
    4237
    4338#include <sys/types.h>
    4439
    45 /** Network interface layer type type definition. */
    46 typedef uint8_t hw_type_t;
     40#define INET_TTL_MAX 255
    4741
    48 /** @name Network interface layer types definitions */
    49 /*@{*/
     42typedef struct {
     43        uint32_t ipv4;
     44} inet_addr_t;
    5045
    51 /** Ethernet (10Mb) hardware type. */
    52 #define HW_ETHER                1
     46typedef struct {
     47        inet_addr_t src;
     48        inet_addr_t dest;
     49        uint8_t tos;
     50        void *data;
     51        size_t size;
     52} inet_dgram_t;
    5353
    54 /*@}*/
     54typedef struct {
     55        int (*recv)(inet_dgram_t *);
     56} inet_ev_ops_t;
     57
     58typedef enum {
     59        INET_DF = 1
     60} inet_df_t;
     61
     62extern int inet_init(uint8_t, inet_ev_ops_t *);
     63extern int inet_send(inet_dgram_t *, uint8_t, inet_df_t);
     64extern int inet_get_srcaddr(inet_addr_t *, uint8_t, inet_addr_t *);
    5565
    5666#endif
    … …  
    5868/** @}
    5969 */
    60 

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup libc
    30  *  @{
     30 * @{
     31 */
     32/** @file
    3133 */
    3234
    33 /** @file
    34  * ICMP common interface implementation.
    35  * @see icmp_common.h
    36  */
     35#ifndef LIBC_INET_INETPING_H_
     36#define LIBC_INET_INETPING_H_
    3737
    38 #include <net/modules.h>
    39 #include <net/icmp_common.h>
    40 #include <ipc/services.h>
    41 #include <ipc/icmp.h>
    42 #include <sys/time.h>
    43 #include <async.h>
     38#include <inet/inet.h>
     39#include <sys/types.h>
    4440
    45 /** Connect to the ICMP module.
    46  *
    47  * @return ICMP module session.
    48  *
    49  */
    50 async_sess_t *icmp_connect_module(void)
    51 {
    52         return connect_to_service(SERVICE_ICMP);
    53 }
     41typedef struct {
     42        inet_addr_t src;
     43        inet_addr_t dest;
     44        uint16_t seq_no;
     45        void *data;
     46        size_t size;
     47} inetping_sdu_t;
     48
     49typedef struct inetping_ev_ops {
     50        int (*recv)(inetping_sdu_t *);
     51} inetping_ev_ops_t;
     52
     53extern int inetping_init(inetping_ev_ops_t *);
     54extern int inetping_send(inetping_sdu_t *);
     55extern int inetping_get_srcaddr(inet_addr_t *, inet_addr_t *);
     56
     57
     58#endif
    5459
    5560/** @}

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
    30  *  @{
     29/** @addtogroup libc
     30 * @{
     31 */
     32/** @file
    3133 */
    3234
    33 #ifndef LIBNET_ICMP_REMOTE_H_
    34 #define LIBNET_ICMP_REMOTE_H_
     35#ifndef LIBC_INET_IPLINK_H_
     36#define LIBC_INET_IPLINK_H_
    3537
    36 #include <net/socket_codes.h>
     38#include <async.h>
    3739#include <sys/types.h>
    38 #include <net/device.h>
    39 #include <adt/measured_strings.h>
    40 #include <net/packet.h>
    41 #include <net/inet.h>
    42 #include <net/ip_codes.h>
    43 #include <net/icmp_codes.h>
    44 #include <net/icmp_common.h>
    45 #include <async.h>
    4640
    47 /** @name ICMP module interface
    48  * This interface is used by other modules.
    49  */
    50 /*@{*/
     41struct iplink_ev_ops;
    5142
    52 extern int icmp_destination_unreachable_msg(async_sess_t *, icmp_code_t,
    53     icmp_param_t, packet_t *);
    54 extern int icmp_source_quench_msg(async_sess_t *, packet_t *);
    55 extern int icmp_time_exceeded_msg(async_sess_t *, icmp_code_t, packet_t *);
    56 extern int icmp_parameter_problem_msg(async_sess_t *, icmp_code_t, icmp_param_t,
    57     packet_t *);
     43typedef struct {
     44        async_sess_t *sess;
     45        struct iplink_ev_ops *ev_ops;
     46} iplink_t;
    5847
    59 /*@}*/
     48typedef struct {
     49        uint32_t ipv4;
     50} iplink_addr_t;
     51
     52/** IP link Service Data Unit */
     53typedef struct {
     54        /** Local source address */
     55        iplink_addr_t lsrc;
     56        /** Local destination address */
     57        iplink_addr_t ldest;
     58        /** Serialized IP packet */
     59        void *data;
     60        /** Size of @c data in bytes */
     61        size_t size;
     62} iplink_sdu_t;
     63
     64typedef struct iplink_ev_ops {
     65        int (*recv)(iplink_t *, iplink_sdu_t *);
     66} iplink_ev_ops_t;
     67
     68extern int iplink_open(async_sess_t *, iplink_ev_ops_t *, iplink_t **);
     69extern void iplink_close(iplink_t *);
     70extern int iplink_send(iplink_t *, iplink_sdu_t *);
     71extern int iplink_addr_add(iplink_t *, iplink_addr_t *);
     72extern int iplink_addr_remove(iplink_t *, iplink_addr_t *);
     73extern int iplink_get_mtu(iplink_t *, size_t *);
    6074
    6175#endif

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2828
    2929/** @addtogroup libc
    30  *  @{
     30 * @{
     31 */
     32/** @file
    3133 */
    3234
    33 /** @file
    34  * Character string with measured length.
    35  * The structure has been designed for serialization of character strings
    36  * between modules.
    37  */
     35#ifndef LIBC_INET_IPLINK_SRV_H_
     36#define LIBC_INET_IPLINK_SRV_H_
    3837
    39 #ifndef LIBC_MEASURED_STRINGS_H_
    40 #define LIBC_MEASURED_STRINGS_H_
     38#include <async.h>
     39#include <fibril_synch.h>
     40#include <bool.h>
     41#include <sys/types.h>
    4142
    42 #include <sys/types.h>
    43 #include <async.h>
     43struct iplink_ops;
    4444
    45 /** Type definition of the character string with measured length.
    46  * @see measured_string
    47  */
    48 typedef struct measured_string measured_string_t;
     45typedef struct {
     46        fibril_mutex_t lock;
     47        bool connected;
     48        struct iplink_ops *ops;
     49        void *arg;
     50        async_sess_t *client_sess;
     51} iplink_srv_t;
    4952
    50 /** Character string with measured length.
    51  *
    52  * This structure has been designed for serialization of character strings
    53  * between modules.
    54  */
    55 struct measured_string {
    56         /** Character string data. */
    57         uint8_t *value;
    58         /** Character string length. */
    59         size_t length;
    60 };
     53typedef struct {
     54        uint32_t ipv4;
     55} iplink_srv_addr_t;
    6156
    62 extern measured_string_t *measured_string_create_bulk(const uint8_t *, size_t);
    63 extern measured_string_t *measured_string_copy(measured_string_t *);
     57/** IP link Service Data Unit */
     58typedef struct {
     59        /** Local source address */
     60        iplink_srv_addr_t lsrc;
     61        /** Local destination address */
     62        iplink_srv_addr_t ldest;
     63        /** Serialized IP packet */
     64        void *data;
     65        /** Size of @c data in bytes */
     66        size_t size;
     67} iplink_srv_sdu_t;
    6468
    65 extern int measured_strings_receive(measured_string_t **, uint8_t **, size_t);
    66 extern int measured_strings_reply(const measured_string_t *, size_t);
     69typedef struct iplink_ops {
     70        int (*open)(iplink_srv_t *);
     71        int (*close)(iplink_srv_t *);
     72        int (*send)(iplink_srv_t *, iplink_srv_sdu_t *);
     73        int (*get_mtu)(iplink_srv_t *, size_t *);
     74        int (*addr_add)(iplink_srv_t *, iplink_srv_addr_t *);
     75        int (*addr_remove)(iplink_srv_t *, iplink_srv_addr_t *);
     76} iplink_ops_t;
    6777
    68 extern int measured_strings_return(async_exch_t *, measured_string_t **,
    69     uint8_t **, size_t);
    70 extern int measured_strings_send(async_exch_t *, const measured_string_t *,
    71     size_t);
     78extern void iplink_srv_init(iplink_srv_t *);
     79
     80extern int iplink_conn(ipc_callid_t, ipc_call_t *, void *);
     81extern int iplink_ev_recv(iplink_srv_t *, iplink_srv_sdu_t *);
    7282
    7383#endif

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
    3  * Copyright (c) 2011 Radim Vansa
     2 * Copyright (c) 2012 Jiri Svoboda
    43 * All rights reserved.
    54 *
    … …  
    2827 */
    2928
    30 /** @addtogroup libpacket
     29/** @addtogroup libcipc
    3130 * @{
    3231 */
    33 
    3432/** @file
    35  * Packet server.
    36  * The hosting module has to be compiled with both the packet.c and the
    37  * packet_server.c source files. To function correctly, initialization of the
    38  * packet map by the pm_init() function has to happen at the first place. Then
    39  * the packet messages have to be processed by the packet_server_message()
    40  * function. The packet map should be released by the pm_destroy() function
    41  * during the module termination.
    42  * @see IS_NET_PACKET_MESSAGE()
    4333 */
    4434
    45 #ifndef NET_PACKET_SERVER_H_
    46 #define NET_PACKET_SERVER_H_
     35#ifndef LIBC_IPC_INET_H_
     36#define LIBC_IPC_INET_H_
    4737
    4838#include <ipc/common.h>
    4939
    50 extern int packet_server_init(void);
    51 extern int packet_server_message(ipc_callid_t, ipc_call_t *, ipc_call_t *,
    52     size_t *);
     40/** Inet ports */
     41typedef enum {
     42        /** Default port */
     43        INET_PORT_DEFAULT = 1,
     44        /** Configuration port */
     45        INET_PORT_CFG,
     46        /** Ping service port */
     47        INET_PORT_PING
     48} inet_port_t;
     49
     50/** Requests on Inet default port */
     51typedef enum {
     52        INET_CALLBACK_CREATE = IPC_FIRST_USER_METHOD,
     53        INET_GET_SRCADDR,
     54        INET_SEND,
     55        INET_SET_PROTO
     56} inet_request_t;
     57
     58/** Events on Inet default port */
     59typedef enum {
     60        INET_EV_RECV = IPC_FIRST_USER_METHOD
     61} inet_event_t;
     62
     63/** Requests on Inet configuration port */
     64typedef enum {
     65        INETCFG_ADDR_CREATE_STATIC = IPC_FIRST_USER_METHOD,
     66        INETCFG_ADDR_DELETE,
     67        INETCFG_ADDR_GET,
     68        INETCFG_ADDR_GET_ID,
     69        INETCFG_GET_ADDR_LIST,
     70        INETCFG_GET_LINK_LIST,
     71        INETCFG_GET_SROUTE_LIST,
     72        INETCFG_LINK_GET,
     73        INETCFG_SROUTE_CREATE,
     74        INETCFG_SROUTE_DELETE,
     75        INETCFG_SROUTE_GET,
     76        INETCFG_SROUTE_GET_ID
     77} inetcfg_request_t;
     78
     79/** Events on Inet ping port */
     80typedef enum {
     81        INETPING_EV_RECV = IPC_FIRST_USER_METHOD
     82} inetping_event_t;
     83
     84/** Requests on Inet ping port */
     85typedef enum {
     86        INETPING_SEND = IPC_FIRST_USER_METHOD,
     87        INETPING_GET_SRCADDR
     88} inetping_request_t;
    5389
    5490#endif
    5591
    56 /** @}
     92/**
     93 * @}
    5794 */

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
     29/** @addtogroup libcipc
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * Transport layer modules messages.
    35  * @see tl_interface.h
    3633 */
    3734
    38 #ifndef LIBC_TL_MESSAGES_H_
    39 #define LIBC_TL_MESSAGES_H_
     35#ifndef LIBC_IPC_IPLINK_H_
     36#define LIBC_IPC_IPLINK_H_
    4037
    41 #include <ipc/net.h>
     38#include <ipc/common.h>
    4239
    43 /** Transport layer modules messages. */
    4440typedef enum {
    45         /** Packet received message.
    46          * @see tl_received_msg()
    47          */
    48         NET_TL_RECEIVED = NET_TL_FIRST
    49 } tl_messages;
     41        IPLINK_GET_MTU = IPC_FIRST_USER_METHOD,
     42        IPLINK_SEND,
     43        IPLINK_ADDR_ADD,
     44        IPLINK_ADDR_REMOVE
     45} iplink_request_t;
     46
     47typedef enum {
     48        IPLINK_EV_RECV = IPC_FIRST_USER_METHOD
     49} iplink_event_t;
    5050
    5151#endif
    5252
    53 /** @}
     53/**
     54 * @}
    5455 */

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

    rd76a329 rb1213b0  
    4848        SERVICE_IRC        = FOURCC('i', 'r', 'c', ' '),
    4949        SERVICE_CLIPBOARD  = FOURCC('c', 'l', 'i', 'p'),
    50         SERVICE_NETWORKING = FOURCC('n', 'e', 't', ' '),
    51         SERVICE_ETHERNET   = FOURCC('e', 't', 'h', ' '),
    52         SERVICE_NILDUMMY   = FOURCC('n', 'i', 'l', 'd'),
    53         SERVICE_IP         = FOURCC('i', 'p', 'v', '4'),
    54         SERVICE_ARP        = FOURCC('a', 'r', 'p', ' '),
    55         SERVICE_ICMP       = FOURCC('i', 'c', 'm', 'p'),
    5650        SERVICE_UDP        = FOURCC('u', 'd', 'p', ' '),
    5751        SERVICE_TCP        = FOURCC('t', 'c', 'p', ' ')
    5852} services_t;
     53
     54#define SERVICE_NAME_INET     "net/inet"
     55#define SERVICE_NAME_INETCFG  "net/inetcfg"
     56#define SERVICE_NAME_INETPING "net/inetping"
    5957
    6058#endif

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

    rd76a329 rb1213b0  
    3838#define LIBC_SOCKET_MESSAGES_H_
    3939
    40 #include <ipc/net.h>
    41 
    4240/** Socket client messages. */
    4341typedef enum {
    4442        /** Creates a new socket. @see socket() */
    45         NET_SOCKET = NET_SOCKET_FIRST,
     43        NET_SOCKET = IPC_FIRST_USER_METHOD,
    4644        /** Binds the socket. @see bind() */
    4745        NET_SOCKET_BIND,

  • uspace/lib/c/include/net/in.h

    rd76a329 rb1213b0  
    4545#define INET_ADDRSTRLEN  (4 * 3 + 3 + 1)
    4646
     47#define INADDR_ANY 0
     48
    4749/** Type definition of the INET address.
    4850 * @see in_addr

  • uspace/lib/net/Makefile

    rd76a329 rb1213b0  
    3333
    3434SOURCES = \
    35         generic/generic.c \
    36         generic/net_remote.c \
    37         generic/net_checksum.c \
    38         generic/packet_client.c \
    39         generic/packet_remote.c \
    40         generic/protocol_map.c \
    41         adt/module_map.c \
    42         nil/nil_remote.c \
    43         nil/nil_skel.c \
    44         il/il_remote.c \
    45         il/il_skel.c \
    46         il/ip_remote.c \
    47         il/ip_client.c \
    48         il/arp_remote.c \
    49         tl/icmp_remote.c \
    50         tl/icmp_client.c \
    51         tl/socket_core.c \
    52         tl/tl_common.c \
    53         tl/tl_remote.c \
    54         tl/tl_skel.c
     35        tl/socket_core.c
    5536
    5637include $(USPACE_PREFIX)/Makefile.common

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

    rd76a329 rb1213b0  
    4444#include <net/in.h>
    4545#include <net/device.h>
    46 #include <net/packet.h>
    4746#include <async.h>
    4847
    … …  
    8079        /** Bound port. */
    8180        int port;
    82         /** Received packets queue. */
    83         dyn_fifo_t received;
    8481        /** Sockets for acceptance queue. */
    8582        dyn_fifo_t accepted;
    … …  
    118115extern int socket_destroy(async_sess_t *, int, socket_cores_t *,
    119116    socket_ports_t *, void (*)(socket_core_t *));
    120 extern int socket_reply_packets(packet_t *, size_t *);
    121117extern socket_core_t *socket_port_find(socket_ports_t *, int, const uint8_t *,
    122118    size_t);

  • uspace/lib/net/tl/socket_core.c

    rd76a329 rb1213b0  
    3636
    3737#include <socket_core.h>
    38 #include <packet_client.h>
    39 #include <packet_remote.h>
    4038#include <net/socket_codes.h>
    4139#include <net/in.h>
    4240#include <net/inet.h>
    43 #include <net/packet.h>
    4441#include <net/modules.h>
    4542#include <stdint.h>
    … …  
    9289        }
    9390       
    94         /* Release all received packets */
    95         int packet_id;
    96         while ((packet_id = dyn_fifo_pop(&socket->received)) >= 0)
    97                 pq_release_remote(sess, packet_id);
    98        
    99         dyn_fifo_destroy(&socket->received);
    10091        dyn_fifo_destroy(&socket->accepted);
    10192       
    … …  
    448439        socket->key_length = 0;
    449440        socket->specific_data = specific_data;
    450         rc = dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
     441       
     442        rc = dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
    451443        if (rc != EOK) {
    452444                free(socket);
    453445                return rc;
    454446        }
    455        
    456         rc = dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
    457         if (rc != EOK) {
    458                 dyn_fifo_destroy(&socket->received);
    459                 free(socket);
    460                 return rc;
    461         }
    462447        socket->socket_id = *socket_id;
    463448        rc = socket_cores_add(local_sockets, socket->socket_id, socket);
    464449        if (rc < 0) {
    465                 dyn_fifo_destroy(&socket->received);
    466450                dyn_fifo_destroy(&socket->accepted);
    467451                free(socket);
    … …  
    506490        socket_destroy_core(sess, socket, local_sockets, global_sockets,
    507491            socket_release);
    508        
    509         return EOK;
    510 }
    511 
    512 /** Replies the packet or the packet queue data to the application via the
    513  * socket.
    514  *
    515  * Uses the current message processing fibril.
    516  *
    517  * @param[in] packet    The packet to be transfered.
    518  * @param[out] length   The total data length.
    519  * @return              EOK on success.
    520  * @return              EBADMEM if the length parameter is NULL.
    521  * @return              ENOMEM if there is not enough memory left.
    522  * @return              Other error codes as defined for the data_reply()
    523  *                      function.
    524  */
    525 int socket_reply_packets(packet_t *packet, size_t *length)
    526 {
    527         packet_t *next_packet;
    528         size_t fragments;
    529         size_t *lengths;
    530         size_t index;
    531         int rc;
    532 
    533         if (!length)
    534                 return EBADMEM;
    535 
    536         next_packet = pq_next(packet);
    537         if (!next_packet) {
    538                 /* Write all if only one fragment */
    539                 rc = data_reply(packet_get_data(packet),
    540                     packet_get_data_length(packet));
    541                 if (rc != EOK)
    542                         return rc;
    543                 /* Store the total length */
    544                 *length = packet_get_data_length(packet);
    545         } else {
    546                 /* Count the packet fragments */
    547                 fragments = 1;
    548                 next_packet = pq_next(packet);
    549                 while ((next_packet = pq_next(next_packet)))
    550                         ++fragments;
    551                
    552                 /* Compute and store the fragment lengths */
    553                 lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    554                     sizeof(size_t));
    555                 if (!lengths)
    556                         return ENOMEM;
    557                
    558                 lengths[0] = packet_get_data_length(packet);
    559                 lengths[fragments] = lengths[0];
    560                 next_packet = pq_next(packet);
    561                
    562                 for (index = 1; index < fragments; ++index) {
    563                         lengths[index] = packet_get_data_length(next_packet);
    564                         lengths[fragments] += lengths[index];
    565                         next_packet = pq_next(packet);
    566                 }
    567                
    568                 /* Write the fragment lengths */
    569                 rc = data_reply(lengths, sizeof(int) * (fragments + 1));
    570                 if (rc != EOK) {
    571                         free(lengths);
    572                         return rc;
    573                 }
    574                 next_packet = packet;
    575                
    576                 /* Write the fragments */
    577                 for (index = 0; index < fragments; ++index) {
    578                         rc = data_reply(packet_get_data(next_packet),
    579                             lengths[index]);
    580                         if (rc != EOK) {
    581                                 free(lengths);
    582                                 return rc;
    583                         }
    584                         next_packet = pq_next(next_packet);
    585                 }
    586                
    587                 /* Store the total length */
    588                 *length = lengths[fragments];
    589                 free(lengths);
    590         }
    591492       
    592493        return EOK;

  • uspace/srv/loc/loc.c

    rd76a329 rb1213b0  
    12961296        categ_dir_add_cat(&cdir, cat);
    12971297
     1298        cat = category_new("iplink");
     1299        categ_dir_add_cat(&cdir, cat);
     1300
    12981301        cat = category_new("keyboard");
    12991302        categ_dir_add_cat(&cdir, cat);

  • uspace/srv/net/ethip/Makefile

    rd76a329 rb1213b0  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2012 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2827#
    2928
    30 USPACE_PREFIX = ../../../..
    31 LIBS = $(LIBNET_PREFIX)/libnet.a
    32 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    33 BINARY = arp
     29USPACE_PREFIX = ../../..
     30BINARY = ethip
    3431
    3532SOURCES = \
    36         arp.c
     33        arp.c \
     34        atrans.c \
     35        ethip.c \
     36        ethip_nic.c \
     37        pdu.c
    3738
    3839include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/net/ethip/pdu.h

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup inet
    3030 * @{
    3131 */
     32/**
     33 * @file
     34 * @brief
     35 */
    3236
    33 #ifndef LIBNET_PACKET_REMOTE_H_
    34 #define LIBNET_PACKET_REMOTE_H_
     37#ifndef ETH_PDU_H_
     38#define ETH_PDU_H_
    3539
    36 #include <net/packet.h>
    37 #include <sys/types.h>
    38 #include <async.h>
     40#include "ethip.h"
    3941
    40 extern int packet_translate_remote(async_sess_t *, packet_t **, packet_id_t);
    41 extern packet_t *packet_get_4_remote(async_sess_t *, size_t, size_t, size_t,
    42     size_t);
    43 extern packet_t *packet_get_1_remote(async_sess_t *, size_t);
    44 extern void pq_release_remote(async_sess_t *, packet_id_t);
     42extern int eth_pdu_encode(eth_frame_t *, void **, size_t *);
     43extern int eth_pdu_decode(void *, size_t, eth_frame_t *);
     44extern void mac48_encode(mac48_addr_t *, void *);
     45extern void mac48_decode(void *, mac48_addr_t *);
     46extern int arp_pdu_encode(arp_eth_packet_t *, void **, size_t *);
     47extern int arp_pdu_decode(void *, size_t, arp_eth_packet_t *);
     48
    4549
    4650#endif

  • uspace/srv/net/ethip/std.h

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup ethip
    3030 * @{
    3131 */
    32 /** @file
    33  * General CRC and checksum computation.
     32/**
     33 * @file Ethernet, IP/Ethernet standard definitions
     34 *
    3435 */
    3536
    36 #ifndef LIBNET_CHECKSUM_H_
    37 #define LIBNET_CHECKSUM_H_
     37#ifndef ETHIP_STD_H_
     38#define ETHIP_STD_H_
    3839
    39 #include <byteorder.h>
    4040#include <sys/types.h>
    4141
    42 /** IP checksum value for computed zero checksum.
    43  *
    44  * Zero is returned as 0xFFFF (not flipped)
    45  *
    46  */
    47 #define IP_CHECKSUM_ZERO  0xffffU
     42#define ETH_ADDR_SIZE 6
     43#define IPV4_ADDR_SIZE 4
     44#define ETH_FRAME_MIN_SIZE 60
    4845
    49 #ifdef __BE__
     46/** Ethernet frame header */
     47typedef struct {
     48        /** Destination Address */
     49        uint8_t dest[ETH_ADDR_SIZE];
     50        /** Source Address */
     51        uint8_t src[ETH_ADDR_SIZE];
     52        /** Ethertype or Length */
     53        uint16_t etype_len;
     54} eth_header_t;
    5055
    51 #define compute_crc32(seed, data, length) \
    52         compute_crc32_be(seed, (uint8_t *) data, length)
     56/** ARP packet format (for 48-bit MAC addresses and IPv4) */
     57typedef struct {
     58        /** Hardware address space */
     59        uint16_t hw_addr_space;
     60        /** Protocol address space */
     61        uint16_t proto_addr_space;
     62        /** Hardware address size */
     63        uint8_t hw_addr_size;
     64        /** Protocol address size */
     65        uint8_t proto_addr_size;
     66        /** Opcode */
     67        uint16_t opcode;
     68        /** Sender hardware address */
     69        uint8_t sender_hw_addr[ETH_ADDR_SIZE];
     70        /** Sender protocol address */
     71        uint32_t sender_proto_addr;
     72        /** Target hardware address */
     73        uint8_t target_hw_addr[ETH_ADDR_SIZE];
     74        /** Target protocol address */
     75        uint32_t target_proto_addr;
     76} __attribute__((packed)) arp_eth_packet_fmt_t;
    5377
    54 #endif
     78enum arp_opcode_fmt {
     79        AOP_REQUEST = 1,
     80        AOP_REPLY   = 2
     81};
    5582
    56 #ifdef __LE__
     83enum arp_hw_addr_space {
     84        AHRD_ETHERNET = 1
     85};
    5786
    58 #define compute_crc32(seed, data, length) \
    59         compute_crc32_le(seed, (uint8_t *) data, length)
     87/** IP Ethertype */
     88enum ether_type {
     89        ETYPE_ARP = 0x0806,
     90        ETYPE_IP  = 0x0800
     91};
    6092
    61 #endif
    62 
    63 extern uint32_t compute_crc32_le(uint32_t, uint8_t *, size_t);
    64 extern uint32_t compute_crc32_be(uint32_t, uint8_t *, size_t);
    65 extern uint32_t compute_checksum(uint32_t, uint8_t *, size_t);
    66 extern uint16_t compact_checksum(uint32_t);
    67 extern uint16_t flip_checksum(uint16_t);
    68 extern uint16_t ip_checksum(uint8_t *, size_t);
    6993
    7094#endif

  • uspace/srv/net/inet/Makefile

    rd76a329 rb1213b0  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2012 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2827#
    2928
    30 USPACE_PREFIX = ../../../..
    31 LIBS = $(LIBNET_PREFIX)/libnet.a
    32 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    33 BINARY = icmp
    34 STATIC_ONLY = y
     29USPACE_PREFIX = ../../..
     30BINARY = inet
    3531
    3632SOURCES = \
    37         icmp.c
     33        addrobj.c \
     34        icmp.c \
     35        inet.c \
     36        inet_link.c \
     37        inet_util.c \
     38        inetcfg.c \
     39        inetping.c \
     40        pdu.c \
     41        reass.c \
     42        sroute.c
    3843
    3944include $(USPACE_PREFIX)/Makefile.common

  • uspace/srv/net/inet/addrobj.h

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup inet
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * Internetwork layer module interface for the underlying network interface
    35  * layer. This interface is always called by the remote modules.
     32/**
     33 * @file
     34 * @brief
    3635 */
    3736
    38 #ifndef LIBNET_IL_REMOTE_H_
    39 #define LIBNET_IL_REMOTE_H_
     37#ifndef INET_ADDROBJ_H_
     38#define INET_ADDROBJ_H_
    4039
    41 #include <ipc/services.h>
    4240#include <sys/types.h>
    43 #include <net/device.h>
    44 #include <net/packet.h>
    45 #include <async.h>
     41#include "inet.h"
    4642
    47 /** @name Internetwork layer module interface
    48  * This interface is used by other modules.
    49  */
    50 /*@{*/
     43typedef enum {
     44        /* Find matching network address (using mask) */
     45        iaf_net,
     46        /* Find exact local address (not using mask) */
     47        iaf_addr
     48} inet_addrobj_find_t;
    5149
    52 extern int il_device_state_msg(async_sess_t *, nic_device_id_t,
    53     nic_device_state_t, services_t);
    54 extern int il_received_msg(async_sess_t *, nic_device_id_t, packet_t *,
    55     services_t);
    56 extern int il_mtu_changed_msg(async_sess_t *, nic_device_id_t, size_t,
    57     services_t);
    58 extern int il_addr_changed_msg(async_sess_t *, nic_device_id_t, size_t,
    59     const uint8_t *);
     50extern inet_addrobj_t *inet_addrobj_new(void);
     51extern void inet_addrobj_delete(inet_addrobj_t *);
     52extern void inet_addrobj_add(inet_addrobj_t *);
     53extern void inet_addrobj_remove(inet_addrobj_t *);
     54extern inet_addrobj_t *inet_addrobj_find(inet_addr_t *, inet_addrobj_find_t);
     55extern inet_addrobj_t *inet_addrobj_find_by_name(const char *, inet_link_t *);
     56extern inet_addrobj_t *inet_addrobj_get_by_id(sysarg_t);
     57extern int inet_addrobj_send_dgram(inet_addrobj_t *, inet_addr_t *,
     58    inet_dgram_t *, uint8_t, uint8_t, int);
     59extern int inet_addrobj_get_id_list(sysarg_t **, size_t *);
    6060
    61 /*@}*/
    6261
    6362#endif

  • uspace/srv/net/inet/icmp_std.h

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup udp
     29/** @addtogroup inet
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * UDP header definition.
    35  * Based on the RFC 768.
     32/**
     33 * @file ICMP standard definitions
     34 *
    3635 */
    3736
    38 #ifndef NET_UDP_HEADER_H_
    39 #define NET_UDP_HEADER_H_
     37#ifndef ICMP_STD_H_
     38#define ICMP_STD_H_
    4039
    4140#include <sys/types.h>
    4241
    43 /** UDP header size in bytes. */
    44 #define UDP_HEADER_SIZE         sizeof(udp_header_t)
     42#define IP_PROTO_ICMP 1
    4543
    46 /** Type definition of the user datagram header.
    47  * @see udp_header
    48  */
    49 typedef struct udp_header udp_header_t;
     44/** Type of service used for ICMP */
     45#define ICMP_TOS        0
    5046
    51 /** User datagram header. */
    52 struct udp_header {
    53         uint16_t source_port;
    54         uint16_t destination_port;
    55         uint16_t total_length;
     47/** ICMP message type */
     48enum icmp_type {
     49        ICMP_ECHO_REPLY   = 0,
     50        ICMP_ECHO_REQUEST = 8
     51};
     52
     53/** ICMP Echo Request or Reply message header */
     54typedef struct {
     55        /** ICMP message type */
     56        uint8_t type;
     57        /** Code (0) */
     58        uint8_t code;
     59        /** Internet checksum of the ICMP message */
    5660        uint16_t checksum;
    57 } __attribute__ ((packed));
     61        /** Indentifier */
     62        uint16_t ident;
     63        /** Sequence number */
     64        uint16_t seq_no;
     65} icmp_echo_t;
    5866
    5967#endif

  • uspace/srv/net/inet/inet_std.h

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
     29/** @addtogroup inet
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * ARP module messages.
    35  * @see arp_interface.h
     32/**
     33 * @file IP header definitions
     34 *
    3635 */
    3736
    38 #ifndef LIBC_ARP_MESSAGES_
    39 #define LIBC_ARP_MESSAGES_
     37#ifndef INET_STD_H_
     38#define INET_STD_H_
    4039
    41 #include <ipc/net.h>
     40#include <sys/types.h>
    4241
    43 /** ARP module messages. */
    44 typedef enum {
    45         /** Clean cache message.
    46          * @see arp_clean_cache()
    47         */
    48         NET_ARP_CLEAN_CACHE = NET_ARP_FIRST,
    49         /** Clear address cache message.
    50          * @see arp_clear_address_msg()
    51         */
    52         NET_ARP_CLEAR_ADDRESS,
    53         /** Clear device cache message.
    54          * @see arp_clear_device_req()
    55         */
    56         NET_ARP_CLEAR_DEVICE,
    57         /** New device message.
    58          * @see arp_device_req()
    59         */
    60         NET_ARP_DEVICE,
    61         /** Address translation message.
    62          * @see arp_translate_req()
    63         */
    64         NET_ARP_TRANSLATE
    65 } arp_messages;
     42/** Internet Datagram header (fixed part) */
     43typedef struct {
     44        /** Version, Internet Header Length */
     45        uint8_t ver_ihl;
     46        /* Type of Service */
     47        uint8_t tos;
     48        /** Total Length */
     49        uint16_t tot_len;
     50        /** Identification */
     51        uint16_t id;
     52        /** Flags, Fragment Offset */
     53        uint16_t flags_foff;
     54        /** Time to Live */
     55        uint8_t ttl;
     56        /** Protocol */
     57        uint8_t proto;
     58        /** Header Checksum */
     59        uint16_t chksum;
     60        /** Source Address */
     61        uint32_t src_addr;
     62        /** Destination Address */
     63        uint32_t dest_addr;
     64} ip_header_t;
    6665
    67 /** @name ARP specific message parameters definitions */
    68 /*@{*/
     66/** Bits in ip_header_t.ver_ihl */
     67enum ver_ihl_bits {
     68        /** Version, highest bit */
     69        VI_VERSION_h = 7,
     70        /** Version, lowest bit */
     71        VI_VERSION_l = 4,
     72        /** Internet Header Length, highest bit */
     73        VI_IHL_h     = 3,
     74        /** Internet Header Length, lowest bit */
     75        VI_IHL_l     = 0
     76};
    6977
    70 /** Return the protocol service message parameter.
    71  *
    72  * @param[in] call Message call structure.
    73  *
    74  */
    75 #define ARP_GET_NETIF(call) ((services_t) IPC_GET_ARG2(call))
     78/** Bits in ip_header_t.flags_foff */
     79enum flags_foff_bits {
     80        /** Reserved, must be zero */
     81        FF_FLAG_RSVD = 15,
     82        /** Don't Fragment */
     83        FF_FLAG_DF = 14,
     84        /** More Fragments */
     85        FF_FLAG_MF = 13,
     86        /** Fragment Offset, highest bit */
     87        FF_FRAGOFF_h = 12,
     88        /** Fragment Offset, lowest bit */
     89        FF_FRAGOFF_l = 0
     90};
    7691
    77 /*@}*/
     92/** Fragment offset is expressed in units of 8 bytes */
     93#define FRAG_OFFS_UNIT 8
    7894
    7995#endif

  • uspace/srv/net/tcp/Makefile

    rd76a329 rb1213b0  
    2727#
    2828
    29 USPACE_PREFIX = ../../../..
     29USPACE_PREFIX = ../../..
    3030LIBS = $(LIBNET_PREFIX)/libnet.a
    3131EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include

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

    rd76a329 rb1213b0  
    309309}
    310310
    311 /** Compare two sockets.
    312  *
    313  * Two sockets are equal if the address is equal and the port number
    314  * is equal.
    315  */
     311/** Match socket with pattern. */
    316312static bool tcp_socket_match(tcp_sock_t *sock, tcp_sock_t *patt)
    317313{
    … …  
    332328}
    333329
    334 /** Match socket with pattern. */
     330/** Match socket pair with pattern. */
    335331static bool tcp_sockpair_match(tcp_sockpair_t *sp, tcp_sockpair_t *pattern)
    336332{
    … …  
    357353tcp_conn_t *tcp_conn_find_ref(tcp_sockpair_t *sp)
    358354{
    359         log_msg(LVL_DEBUG, "tcp_conn_find(%p)", sp);
     355        log_msg(LVL_DEBUG, "tcp_conn_find_ref(%p)", sp);
    360356
    361357        fibril_mutex_lock(&conn_list_lock);

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

    rd76a329 rb1213b0  
    255255}
    256256
    257 /** Encode outgoing PDU */
     257/** Decode incoming PDU */
    258258int tcp_pdu_decode(tcp_pdu_t *pdu, tcp_sockpair_t *sp, tcp_segment_t **seg)
    259259{
    … …  
    279279}
    280280
    281 /** Decode incoming PDU */
     281/** Encode outgoing PDU */
    282282int tcp_pdu_encode(tcp_sockpair_t *sp, tcp_segment_t *seg, tcp_pdu_t **pdu)
    283283{

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

    rd76a329 rb1213b0  
    3838#include <async.h>
    3939#include <errno.h>
     40#include <inet/inet.h>
    4041#include <io/log.h>
    41 #include <ip_client.h>
     42#include <ipc/services.h>
    4243#include <ipc/socket.h>
    4344#include <net/modules.h>
    4445#include <net/socket.h>
     46#include <ns.h>
    4547
    4648#include "sock.h"
    … …  
    6365static socket_ports_t gsock;
    6466
     67static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg);
    6568static void tcp_sock_cstate_cb(tcp_conn_t *conn, void *arg);
    6669
    67 void tcp_sock_init(void)
    68 {
     70int tcp_sock_init(void)
     71{
     72        int rc;
     73
    6974        socket_ports_initialize(&gsock);
     75
     76        async_set_client_connection(tcp_sock_connection);
     77
     78        rc = service_register(SERVICE_TCP);
     79        if (rc != EOK)
     80                return EEXIST;
     81
     82        return EOK;
    7083}
    7184
    … …  
    273286        tcp_sock_t lsocket;
    274287        tcp_sock_t fsocket;
    275         nic_device_id_t dev_id;
    276         tcp_phdr_t *phdr;
    277         size_t phdr_len;
    278288
    279289        log_msg(LVL_DEBUG, "tcp_sock_connect()");
    … …  
    309319
    310320        if (socket->laddr.ipv4 == TCP_IPV4_ANY) {
    311                 /* Find route to determine local IP address. */
    312                 rc = ip_get_route_req(ip_sess, IPPROTO_TCP,
    313                     (struct sockaddr *)addr, sizeof(*addr), &dev_id,
    314                     (void **)&phdr, &phdr_len);
     321                /* Determine local IP address */
     322                inet_addr_t loc_addr, rem_addr;
     323
     324                rem_addr.ipv4 = uint32_t_be2host(addr->sin_addr.s_addr);
     325                rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
    315326                if (rc != EOK) {
    316327                        fibril_mutex_unlock(&socket->lock);
    317328                        async_answer_0(callid, rc);
    318                         log_msg(LVL_DEBUG, "tcp_transmit_connect: Failed to find route.");
    319                         return;
    320                 }
    321 
    322                 socket->laddr.ipv4 = uint32_t_be2host(phdr->src_addr);
     329                        log_msg(LVL_DEBUG, "tcp_sock_connect: Failed to "
     330                            "determine local address.");
     331                        return;
     332                }
     333
     334                socket->laddr.ipv4 = loc_addr.ipv4;
    323335                log_msg(LVL_DEBUG, "Local IP address is %x", socket->laddr.ipv4);
    324                 free(phdr);
    325336        }
    326337
    … …  
    713724        }
    714725
    715         rc = socket_destroy(net_sess, socket_id, &client->sockets, &gsock,
     726        rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
    716727            tcp_free_sock_data);
    717728        if (rc != EOK) {
    … …  
    764775}
    765776
    766 int tcp_sock_connection(async_sess_t *sess, ipc_callid_t iid, ipc_call_t icall)
     777static void tcp_sock_connection(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    767778{
    768779        ipc_callid_t callid;
    … …  
    773784        async_answer_0(iid, EOK);
    774785
    775         client.sess = sess;
     786        client.sess = async_callback_receive(EXCHANGE_SERIALIZE);
    776787        socket_cores_initialize(&client.sockets);
    777788
    … …  
    824835                }
    825836        }
    826 
    827         return EOK;
    828837}
    829838

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

    rd76a329 rb1213b0  
    3838#include <async.h>
    3939
    40 extern void tcp_sock_init(void);
    41 extern int tcp_sock_connection(async_sess_t *, ipc_callid_t, ipc_call_t);
     40extern int tcp_sock_init(void);
    4241
    4342#endif

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

    rd76a329 rb1213b0  
    3737
    3838#include <async.h>
    39 #include <packet_remote.h>
    4039#include "tcp_type.h"
    4140
    42 extern async_sess_t *net_sess;
    43 extern async_sess_t *ip_sess;
    4441extern void tcp_transmit_pdu(tcp_pdu_t *);
    4542

  • uspace/srv/net/udp/Makefile

    rd76a329 rb1213b0  
    11#
    2 # Copyright (c) 2005 Martin Decky
    3 # Copyright (c) 2007 Jakub Jermar
     2# Copyright (c) 2012 Jiri Svoboda
    43# All rights reserved.
    54#
    … …  
    2827#
    2928
    30 USPACE_PREFIX = ../../../..
     29USPACE_PREFIX = ../../..
    3130LIBS = $(LIBNET_PREFIX)/libnet.a
    3231EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
    … …  
    3433
    3534SOURCES = \
    36         udp.c
     35        assoc.c \
     36        msg.c \
     37        sock.c \
     38        pdu.c \
     39        ucall.c \
     40        udp.c \
     41        udp_inet.c
    3742
    3843include $(USPACE_PREFIX)/Makefile.common

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup udp
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * Ethernet protocol numbers according to the on-line IANA - Ethernet numbers
    35  * http://www.iana.org/assignments/ethernet-numbers
    36  * cited January 17 2009.
     32/** @file UDP associations
    3733 */
    3834
    39 #ifndef LIBNET_ETHERNET_PROTOCOLS_H_
    40 #define LIBNET_ETHERNET_PROTOCOLS_H_
     35#ifndef ASSOC_H
     36#define ASSOC_H
    4137
    4238#include <sys/types.h>
     39#include "udp_type.h"
    4340
    44 /** Ethernet protocol type definition. */
    45 typedef uint16_t eth_type_t;
     41extern udp_assoc_t *udp_assoc_new(udp_sock_t *, udp_sock_t *);
     42extern void udp_assoc_delete(udp_assoc_t *);
     43extern void udp_assoc_add(udp_assoc_t *);
     44extern void udp_assoc_remove(udp_assoc_t *);
     45extern void udp_assoc_addref(udp_assoc_t *);
     46extern void udp_assoc_delref(udp_assoc_t *);
     47extern void udp_assoc_set_foreign(udp_assoc_t *, udp_sock_t *);
     48extern void udp_assoc_set_local(udp_assoc_t *, udp_sock_t *);
     49extern int udp_assoc_send(udp_assoc_t *, udp_sock_t *, udp_msg_t *);
     50extern int udp_assoc_recv(udp_assoc_t *, udp_msg_t **, udp_sock_t *);
     51extern void udp_assoc_received(udp_sockpair_t *, udp_msg_t *);
    4652
    47 /** @name Ethernet protocols definitions */
    48 /*@{*/
    49 
    50 /** Ethernet minimal protocol number.
    51  * According to the IEEE 802.3 specification.
    52  */
    53 #define ETH_MIN_PROTO           0x0600 /* 1536 */
    54 
    55 /** Internet IP (IPv4) ethernet protocol type. */
    56 #define ETH_P_IP                0x0800
    57 
    58 /** ARP ethernet protocol type. */
    59 #define ETH_P_ARP               0x0806
    60 
    61 /*@}*/
    6253
    6354#endif

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
    30  *  @{
     29/** @addtogroup udp
     30 * @{
     31 */
     32/** @file Socket provider
    3133 */
    3234
    33 /** @file
    34  * ICMP module common interface.
    35  */
     35#ifndef SOCK_H
     36#define SOCK_H
    3637
    37 #ifndef LIBC_ICMP_COMMON_H_
    38 #define LIBC_ICMP_COMMON_H_
    39 
    40 #include <ipc/services.h>
    41 #include <sys/time.h>
    4238#include <async.h>
    4339
    44 extern async_sess_t *icmp_connect_module(void);
     40extern int udp_sock_init(void);
    4541
    4642#endif

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libc
     29/** @addtogroup udp
    3030 * @{
    3131 */
    32 
    33 /** @file
    34  * ICMP module application interface.
     32/** @file UDP user calls
    3533 */
    3634
    37 #ifndef LIBC_ICMP_API_H_
    38 #define LIBC_ICMP_API_H_
     35#ifndef UCALL_H
     36#define UCALL_H
    3937
    40 #include <net/socket_codes.h>
    41 #include <net/inet.h>
    4238#include <sys/types.h>
    43 #include <sys/time.h>
    44 #include <adt/measured_strings.h>
    45 #include <net/ip_codes.h>
    46 #include <net/icmp_codes.h>
    47 #include <net/icmp_common.h>
    48 #include <async.h>
     39#include "udp_type.h"
    4940
    50 /** @name ICMP module application interface
    51  * This interface is used by other application modules.
    52  */
    53 /*@{*/
    54 
    55 extern int icmp_echo_msg(async_sess_t *, size_t, mseconds_t, ip_ttl_t, ip_tos_t,
    56     int, const struct sockaddr *, socklen_t);
    57 
    58 /*@}*/
     41extern udp_error_t udp_uc_create(udp_assoc_t **);
     42extern udp_error_t udp_uc_set_foreign(udp_assoc_t *, udp_sock_t *);
     43extern udp_error_t udp_uc_set_local(udp_assoc_t *, udp_sock_t *);
     44extern udp_error_t udp_uc_send(udp_assoc_t *, udp_sock_t *, void *, size_t,
     45    xflags_t);
     46extern udp_error_t udp_uc_receive(udp_assoc_t *, void *, size_t, size_t *,
     47    xflags_t *, udp_sock_t *);
     48extern void udp_uc_status(udp_assoc_t *, udp_assoc_status_t *);
     49extern void udp_uc_destroy(udp_assoc_t *);
    5950
    6051#endif

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2008 Lukas Mejdrech
     2 * Copyright (c) 2012 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3131 */
    3232
    33 /** @file
    34  * UDP module.
     33/**
     34 * @file UDP (User Datagram Protocol) service
    3535 */
    3636
    37 #ifndef NET_UDP_H_
    38 #define NET_UDP_H_
     37#include <async.h>
     38#include <errno.h>
     39#include <io/log.h>
     40#include <stdio.h>
     41#include <task.h>
    3942
    40 #include <async.h>
    41 #include <fibril_synch.h>
    42 #include <socket_core.h>
    43 #include <tl_common.h>
     43#include "udp_inet.h"
     44#include "sock.h"
    4445
    45 /** Type definition of the UDP global data.
    46  * @see udp_globals
     46#define NAME       "udp"
     47
     48static int udp_init(void)
     49{
     50        int rc;
     51
     52        log_msg(LVL_DEBUG, "udp_init()");
     53
     54        rc = udp_inet_init();
     55        if (rc != EOK) {
     56                log_msg(LVL_ERROR, "Failed connecting to internet service.");
     57                return ENOENT;
     58        }
     59
     60        rc = udp_sock_init();
     61        if (rc != EOK) {
     62                log_msg(LVL_ERROR, "Failed initializing socket service.");
     63                return ENOENT;
     64        }
     65
     66        return EOK;
     67}
     68
     69int main(int argc, char **argv)
     70{
     71        int rc;
     72
     73        printf(NAME ": UDP (User Datagram Protocol) service\n");
     74
     75        rc = log_init(NAME, LVL_WARN);
     76        if (rc != EOK) {
     77                printf(NAME ": Failed to initialize log.\n");
     78                return 1;
     79        }
     80
     81        rc = udp_init();
     82        if (rc != EOK)
     83                return 1;
     84
     85        printf(NAME ": Accepting connections.\n");
     86        task_retval(0);
     87        async_manager();
     88
     89        /* Not reached */
     90        return 0;
     91}
     92
     93/**
     94 * @}
    4795 */
    48 typedef struct udp_globals udp_globals_t;
    49 
    50 /** UDP global data. */
    51 struct udp_globals {
    52         /** Networking module session. */
    53         async_sess_t *net_sess;
    54         /** IP module session. */
    55         async_sess_t *ip_sess;
    56         /** ICMP module session. */
    57         async_sess_t *icmp_sess;
    58         /** Packet dimension. */
    59         packet_dimension_t packet_dimension;
    60         /** Indicates whether UDP checksum computing is enabled. */
    61         int checksum_computing;
    62         /** Indicates whether UDP autobnding on send is enabled. */
    63         int autobinding;
    64         /** Last used free port. */
    65         int last_used_port;
    66         /** Active sockets. */
    67         socket_ports_t sockets;
    68         /** Device packet dimensions. */
    69         packet_dimensions_t dimensions;
    70         /** Safety lock. */
    71         fibril_rwlock_t lock;
    72 };
    73 
    74 #endif
    75 
    76 /** @}
    77  */

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

    rd76a329 rb1213b0  
    11/*
    2  * Copyright (c) 2009 Lukas Mejdrech
     2 * Copyright (c) 2011 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup libnet
     29/** @addtogroup udp
    3030 * @{
    3131 */
    32 
    3332/** @file
    34  * ICMP client interface.
    3533 */
    3634
    37 #ifndef LIBNET_ICMP_CLIENT_H_
    38 #define LIBNET_ICMP_CLIENT_H_
     35#ifndef UDP_INET_H
     36#define UDP_INET_H
    3937
    40 #include <net/icmp_codes.h>
    41 #include <net/packet.h>
     38#include "udp_type.h"
    4239
    43 extern int icmp_client_process_packet(packet_t *, icmp_type_t *, icmp_code_t *,
    44     icmp_param_t *, icmp_param_t *);
    45 extern size_t icmp_client_header_length(packet_t *);
     40extern int udp_inet_init(void);
     41extern int udp_transmit_pdu(udp_pdu_t *);
    4642
    4743#endif
Note: See TracChangeset for help on using the changeset viewer.