Changes in / [8e189ef:982e3d8] in mainline


Ignore:
Files:
2 deleted
30 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/amd64/include/pm.h

    r8e189ef r982e3d8  
    8383
    8484#define TSS_BASIC_SIZE  104
    85 #define TSS_IOMAP_SIZE  (8 * 1024 + 1)  /* 8K for bitmap + 1 terminating byte for convenience */
     85#define TSS_IOMAP_SIZE  (16 * 1024 + 1)  /* 16K for bitmap + 1 terminating byte for convenience */
    8686
    8787#define IO_PORTS  (64 * 1024)

  • kernel/arch/amd64/src/ddi/ddi.c

    r8e189ef r982e3d8  
    126126                bitmap_initialize(&iomap, CPU->arch.tss->iomap,
    127127                    TSS_IOMAP_SIZE * 8);
    128                 bitmap_copy(&iomap, &TASK->arch.iomap, bits);
     128                bitmap_copy(&iomap, &TASK->arch.iomap, TASK->arch.iomap.bits);
    129129               
    130                 /*
    131                  * Set the trailing bits in the last byte of the map to disable
    132                  * I/O access.
    133                  */
    134                 bitmap_set_range(&iomap, bits, ALIGN_UP(bits, 8) - bits);
    135130                /*
    136131                 * It is safe to set the trailing eight bits because of the
    137132                 * extra convenience byte in TSS_IOMAP_SIZE.
    138133                 */
    139                 bitmap_set_range(&iomap, ALIGN_UP(bits, 8), 8);
     134                bitmap_set_range(&iomap, ALIGN_UP(TASK->arch.iomap.bits, 8), 8);
    140135        }
    141136        irq_spinlock_unlock(&TASK->lock, false);

  • kernel/arch/ia32/include/pm.h

    r8e189ef r982e3d8  
    7575
    7676#define TSS_BASIC_SIZE  104
    77 #define TSS_IOMAP_SIZE  (8 * 1024 + 1)  /* 8K for bitmap + 1 terminating byte for convenience */
     77#define TSS_IOMAP_SIZE  (16 * 1024 + 1)  /* 16K for bitmap + 1 terminating byte for convenience */
    7878
    7979#define IO_PORTS  (64 * 1024)

  • kernel/arch/ia32/src/ddi/ddi.c

    r8e189ef r982e3d8  
    127127                bitmap_initialize(&iomap, CPU->arch.tss->iomap,
    128128                    TSS_IOMAP_SIZE * 8);
    129                 bitmap_copy(&iomap, &TASK->arch.iomap, bits);
     129                bitmap_copy(&iomap, &TASK->arch.iomap, TASK->arch.iomap.bits);
    130130               
    131                 /*
    132                  * Set the trailing bits in the last byte of the map to disable
    133                  * I/O access.
    134                  */
    135                 bitmap_set_range(&iomap, bits, ALIGN_UP(bits, 8) - bits);
    136131                /*
    137132                 * It is safe to set the trailing eight bits because of the
    138133                 * extra convenience byte in TSS_IOMAP_SIZE.
    139134                 */
    140                 bitmap_set_range(&iomap, ALIGN_UP(bits, 8), 8);
     135                bitmap_set_range(&iomap, ALIGN_UP(TASK->arch.iomap.bits, 8), 8);
    141136        }
    142137        irq_spinlock_unlock(&TASK->lock, false);

  • kernel/generic/src/adt/bitmap.c

    r8e189ef r982e3d8  
    3232/**
    3333 * @file
    34  * @brief Implementation of bitmap ADT.
     34 * @brief       Implementation of bitmap ADT.
    3535 *
    3636 * This file implements bitmap ADT and provides functions for
    … …  
    5151 * No portion of the bitmap is set or cleared by this function.
    5252 *
    53  * @param bitmap        Bitmap structure.
    54  * @param map           Address of the memory used to hold the map.
    55  * @param bits          Number of bits stored in bitmap.
     53 * @param bitmap Bitmap structure.
     54 * @param map Address of the memory used to hold the map.
     55 * @param bits Number of bits stored in bitmap.
    5656 */
    5757void bitmap_initialize(bitmap_t *bitmap, uint8_t *map, size_t bits)
    … …  
    6363/** Set range of bits.
    6464 *
    65  * @param bitmap        Bitmap structure.
    66  * @param start         Starting bit.
    67  * @param bits          Number of bits to set.
     65 * @param bitmap Bitmap structure.
     66 * @param start Starting bit.
     67 * @param bits Number of bits to set.
    6868 */
    6969void bitmap_set_range(bitmap_t *bitmap, size_t start, size_t bits)
    … …  
    7171        size_t i = 0;
    7272        size_t aligned_start;
    73         size_t lub;     /* leading unaligned bits */
    74         size_t amb;     /* aligned middle bits */
    75         size_t tab;     /* trailing aligned bits */
     73        size_t lub;             /* leading unaligned bits */
     74        size_t amb;             /* aligned middle bits */
     75        size_t tab;             /* trailing aligned bits */
    7676       
    7777        ASSERT(start + bits <= bitmap->bits);
    … …  
    8282        tab = amb % 8;
    8383       
    84         if (!bits)
    85                 return;
    86 
    87         if (start + bits < aligned_start) {
    88                 /* Set bits in the middle of byte. */
    89                 bitmap->map[start / 8] |= ((1 << lub) - 1) << (start & 7);
    90                 return;
     84        if ( start + bits < aligned_start ) {
     85            /*
     86            * Set bits in the middle of byte
     87            */
     88            bitmap->map[start / 8] |= ((1 << lub)-1) << (start&7);
     89            return;
    9190        }
    9291       
    9392        if (lub) {
    94                 /* Make sure to set any leading unaligned bits. */
     93                /*
     94                 * Make sure to set any leading unaligned bits.
     95                 */
    9596                bitmap->map[start / 8] |= ~((1 << (8 - lub)) - 1);
    9697        }
    9798        for (i = 0; i < amb / 8; i++) {
    98                 /* The middle bits can be set byte by byte. */
     99                /*
     100                 * The middle bits can be set byte by byte.
     101                 */
    99102                bitmap->map[aligned_start / 8 + i] = ALL_ONES;
    100103        }
    101104        if (tab) {
    102                 /* Make sure to set any trailing aligned bits. */
     105                /*
     106                 * Make sure to set any trailing aligned bits.
     107                 */
    103108                bitmap->map[aligned_start / 8 + i] |= (1 << tab) - 1;
    104109        }
    … …  
    108113/** Clear range of bits.
    109114 *
    110  * @param bitmap        Bitmap structure.
    111  * @param start         Starting bit.
    112  * @param bits          Number of bits to clear.
     115 * @param bitmap Bitmap structure.
     116 * @param start Starting bit.
     117 * @param bits Number of bits to clear.
    113118 */
    114119void bitmap_clear_range(bitmap_t *bitmap, size_t start, size_t bits)
    … …  
    116121        size_t i = 0;
    117122        size_t aligned_start;
    118         size_t lub;     /* leading unaligned bits */
    119         size_t amb;     /* aligned middle bits */
    120         size_t tab;     /* trailing aligned bits */
     123        size_t lub;             /* leading unaligned bits */
     124        size_t amb;             /* aligned middle bits */
     125        size_t tab;             /* trailing aligned bits */
    121126       
    122127        ASSERT(start + bits <= bitmap->bits);
    … …  
    127132        tab = amb % 8;
    128133
    129         if (!bits)
    130                 return;
    131 
    132         if (start + bits < aligned_start) {
    133                 /* Set bits in the middle of byte */
    134                 bitmap->map[start / 8] &= ~(((1 << lub) - 1) << (start & 7));
    135                 return;
     134        if ( start + bits < aligned_start )
     135        {
     136            /*
     137            * Set bits in the middle of byte
     138            */
     139            bitmap->map[start / 8] &= ~(((1 << lub)-1) << (start&7));
     140            return;
    136141        }
    137142
     143
    138144        if (lub) {
    139                 /* Make sure to clear any leading unaligned bits. */
     145                /*
     146                 * Make sure to clear any leading unaligned bits.
     147                 */
    140148                bitmap->map[start / 8] &= (1 << (8 - lub)) - 1;
    141149        }
    142150        for (i = 0; i < amb / 8; i++) {
    143                 /* The middle bits can be cleared byte by byte. */
     151                /*
     152                 * The middle bits can be cleared byte by byte.
     153                 */
    144154                bitmap->map[aligned_start / 8 + i] = ALL_ZEROES;
    145155        }
    146156        if (tab) {
    147                 /* Make sure to clear any trailing aligned bits. */
     157                /*
     158                 * Make sure to clear any trailing aligned bits.
     159                 */
    148160                bitmap->map[aligned_start / 8 + i] &= ~((1 << tab) - 1);
    149161        }
    … …  
    153165/** Copy portion of one bitmap into another bitmap.
    154166 *
    155  * @param dst           Destination bitmap.
    156  * @param src           Source bitmap.
    157  * @param bits          Number of bits to copy.
     167 * @param dst Destination bitmap.
     168 * @param src Source bitmap.
     169 * @param bits Number of bits to copy.
    158170 */
    159171void bitmap_copy(bitmap_t *dst, bitmap_t *src, size_t bits)

  • tools/toolchain.sh

    r8e189ef r982e3d8  
    6262        echo " ia32       IA-32 (x86, i386)"
    6363        echo " ia64       IA-64 (Itanium)"
    64         echo " mips32     MIPS little-endian 32b"
    65         echo " mips32eb   MIPS big-endian 32b"
    66         echo " mips64     MIPS little-endian 64b"
     64        echo " mips32     MIPS little-endian"
     65        echo " mips32eb   MIPS big-endian"
    6766        echo " ppc32      32-bit PowerPC"
    6867        echo " ppc64      64-bit PowerPC"
    … …  
    304303                build_target "mips32eb" "mips-linux-gnu"
    305304                ;;
    306         "mips64")
    307                 build_target "mips64" "mips64el-linux-gnu"
    308                 ;;
    309305        "ppc32")
    310306                build_target "ppc32" "ppc-linux-gnu"
    … …  
    324320                build_target "mips32" "mipsel-linux-gnu"
    325321                build_target "mips32eb" "mips-linux-gnu"
    326                 build_target "mips64" "mips64el-linux-gnu"
    327322                build_target "ppc32" "ppc-linux-gnu"
    328323                build_target "ppc64" "ppc64-linux-gnu"

  • uspace/app/bdsh/cmds/modules/help/help.c

    r8e189ef r982e3d8  
    4545extern const char *progname;
    4646
    47 #define HELP_IS_COMMANDS        2
    48 #define HELP_IS_MODULE          1
    49 #define HELP_IS_BUILTIN         0
    50 #define HELP_IS_RUBBISH         -1
     47#define HELP_IS_MODULE   1
     48#define HELP_IS_BUILTIN  0
     49#define HELP_IS_RUBBISH  -1
    5150
    5251volatile int mod_switch = -1;
    … …  
    5655{
    5756        int rc = HELP_IS_RUBBISH;
    58 
    59         if (str_cmp(cmd, "commands") == 0)
    60                 return HELP_IS_COMMANDS;
    6157
    6258        rc = is_builtin(cmd);
    … …  
    9490}
    9591
    96 static void help_commands(void)
     92int cmd_help(char *argv[])
    9793{
     94        module_t *mod;
    9895        builtin_t *cmd;
    99         module_t *mod;
    100         unsigned int i;
     96        unsigned int i = 0;
     97        int rc = 0;
     98        int argc;
     99        int level = HELP_SHORT;
    101100
    102         printf("\n  Bdsh built-in commands:\n");
     101        argc = cli_count_args(argv);
     102
     103        if (argc > 3) {
     104                printf("\nToo many arguments to `%s', try:\n", cmdname);
     105                help_cmd_help(HELP_SHORT);
     106                return CMD_FAILURE;
     107        }
     108
     109        if (argc == 3) {
     110                if (!str_cmp("extended", argv[2]))
     111                        level = HELP_LONG;
     112                else
     113                        level = HELP_SHORT;
     114        }
     115
     116        if (argc > 1) {
     117                rc = is_mod_or_builtin(argv[1]);
     118                switch (rc) {
     119                case HELP_IS_RUBBISH:
     120                        printf("Invalid command %s\n", argv[1]);
     121                        return CMD_FAILURE;
     122                case HELP_IS_MODULE:
     123                        help_module(mod_switch, level);
     124                        return CMD_SUCCESS;
     125                case HELP_IS_BUILTIN:
     126                        help_builtin(mod_switch, level);
     127                        return CMD_SUCCESS;
     128                }
     129        }
     130
     131        printf("\n  Available commands are:\n");
    103132        printf("  ------------------------------------------------------------\n");
    104133
    … …  
    125154        printf("\n  Try %s %s for more information on how `%s' works.\n\n",
    126155                cmdname, cmdname, cmdname);
    127 }
    128 
    129 /** Display survival tips. ('help' without arguments) */
    130 static void help_survival(void)
    131 {
    132         printf("Don't panic!\n\n");
    133 
    134         printf("This is Bdsh, the Brain dead shell, currently "
    135             "the primary user interface to HelenOS. Bdsh allows you to enter "
    136             "commands and supports history (Up, Down arrow keys), "
    137             "line editing (Left Arrow, Right Arrow, Home, End, Backspace), "
    138             "selection (Shift + movement keys), copy and paste (Ctrl-C, "
    139             "Ctrl-V), similar to common desktop environments.\n\n");
    140 
    141         printf("The most basic filesystem commands are Bdsh builtins. Type "
    142             "'help commands' [Enter] to see the list of Bdsh builtin commands. "
    143             "Other commands are external executables located in the /app and "
    144             "/srv directories. Type 'ls /app' [Enter] and 'ls /srv' [Enter] "
    145             "to see their list. You can execute an external command simply "
    146             "by entering its name (e.g. type 'tetris' [Enter]).\n\n");
    147 
    148         printf("HelenOS has virtual consoles (VCs). You can switch between "
    149             "these using the F1-F11 keys.\n\n");
    150 
    151         printf("This is but a small glimpse of what you can do with HelenOS. "
    152             "To learn more please point your browser to the HelenOS User's "
    153             "Guide: http://trac.helenos.org/trac.fcgi/wiki/UsersGuide\n\n");
    154 }
    155 
    156 int cmd_help(char *argv[])
    157 {
    158         int rc = 0;
    159         int argc;
    160         int level = HELP_SHORT;
    161 
    162         argc = cli_count_args(argv);
    163 
    164         if (argc > 3) {
    165                 printf("\nToo many arguments to `%s', try:\n", cmdname);
    166                 help_cmd_help(HELP_SHORT);
    167                 return CMD_FAILURE;
    168         }
    169 
    170         if (argc == 3) {
    171                 if (!str_cmp("extended", argv[2]))
    172                         level = HELP_LONG;
    173                 else
    174                         level = HELP_SHORT;
    175         }
    176 
    177         if (argc > 1) {
    178                 rc = is_mod_or_builtin(argv[1]);
    179                 switch (rc) {
    180                 case HELP_IS_RUBBISH:
    181                         printf("Invalid topic %s\n", argv[1]);
    182                         return CMD_FAILURE;
    183                 case HELP_IS_COMMANDS:
    184                         help_commands();
    185                         return CMD_SUCCESS;
    186                 case HELP_IS_MODULE:
    187                         help_module(mod_switch, level);
    188                         return CMD_SUCCESS;
    189                 case HELP_IS_BUILTIN:
    190                         help_builtin(mod_switch, level);
    191                         return CMD_SUCCESS;
    192                 }
    193         }
    194 
    195         help_survival();
    196156
    197157        return CMD_SUCCESS;

  • uspace/app/bdsh/scli.c

    r8e189ef r982e3d8  
    8989                exit(EXIT_FAILURE);
    9090
     91        printf("Welcome to %s - %s\nType `help' at any time for usage information.\n",
     92                progname, PACKAGE_STRING);
     93
    9194        while (!cli_quit) {
    9295                get_input(&usr);

  • uspace/app/getterm/Makefile

    r8e189ef r982e3d8  
    3434SOURCES = \
    3535        getterm.c \
    36         version.c \
    37         welcome.c
     36        version.c
    3837
    3938include $(USPACE_PREFIX)/Makefile.common

  • uspace/app/getterm/getterm.c

    r8e189ef r982e3d8  
    4343#include <errno.h>
    4444#include "version.h"
    45 #include "welcome.h"
    4645
    4746#define APP_NAME  "getterm"
    … …  
    4948static void usage(void)
    5049{
    51         printf("Usage: %s <terminal> [-w] <command> [<arguments...>]\n", APP_NAME);
     50        printf("Usage: %s <terminal> <path>\n", APP_NAME);
    5251}
    5352
    … …  
    7473}
    7574
     75static task_id_t spawn(const char *fname)
     76{
     77        task_id_t id;
     78        int rc;
     79       
     80        rc = task_spawnl(&id, fname, fname, NULL);
     81        if (rc != EOK) {
     82                printf("%s: Error spawning %s (%s)\n", APP_NAME, fname,
     83                    str_error(rc));
     84                return 0;
     85        }
     86       
     87        return id;
     88}
     89
    7690int main(int argc, char *argv[])
    7791{
    78         int rc;
    79         task_exit_t texit;
    80         int retval;
    81         task_id_t id;
    82         char *fname, *term;
    83         char **cmd_args;
    84         bool print_wmsg;
    85 
    86         ++argv; --argc;
    87         if (argc < 1) {
     92        if (argc < 3) {
    8893                usage();
    8994                return -1;
    9095        }
    91 
    92         if (str_cmp(*argv, "-w") == 0) {
    93                 print_wmsg = true;
    94                 ++argv; --argc;
    95         } else {
    96                 print_wmsg = false;
    97         }
    98 
    99         if (argc < 2) {
    100                 usage();
    101                 return -1;
    102         }
    103 
    104         term = *argv++;
    105         fname = *argv;
    106         cmd_args = argv;
    10796       
    108         reopen(&stdin, 0, term, O_RDONLY, "r");
    109         reopen(&stdout, 1, term, O_WRONLY, "w");
    110         reopen(&stderr, 2, term, O_WRONLY, "w");
     97        reopen(&stdin, 0, argv[1], O_RDONLY, "r");
     98        reopen(&stdout, 1, argv[1], O_WRONLY, "w");
     99        reopen(&stderr, 2, argv[1], O_WRONLY, "w");
    111100       
    112101        /*
    … …  
    125114                return -4;
    126115       
    127         version_print(term);
    128         if (print_wmsg)
    129                 welcome_msg_print();
    130 
    131         rc = task_spawnv(&id, fname, (const char * const *) cmd_args);
    132         if (rc != EOK) {
    133                 printf("%s: Error spawning %s (%s)\n", APP_NAME, fname,
    134                     str_error(rc));
    135                 return -5;
     116        version_print(argv[1]);
     117        task_id_t id = spawn(argv[2]);
     118       
     119        if (id != 0) {
     120                task_exit_t texit;
     121                int retval;
     122                task_wait(id, &texit, &retval);
     123               
     124                return 0;
    136125        }
    137 
    138         rc = task_wait(id, &texit, &retval);
    139         if (rc != EOK) {
    140                 printf("%s: Error waiting for %s (%s)\n", APP_NAME, fname,
    141                     str_error(rc));
    142                 return -6;
    143         }
    144 
    145         return 0;
     126       
     127        return -5;
    146128}
    147129

  • uspace/app/getterm/version.c

    r8e189ef r982e3d8  
    6161        printf("HelenOS release %s (%s)%s%s\n", release, name, revision, timestamp);
    6262        printf("Running on %s (%s)\n", arch, term);
    63         printf("Copyright (c) 2001-2010 HelenOS project\n\n");
     63        printf("Copyright (c) 2001-2009 HelenOS project\n\n");
    6464}
    6565

  • uspace/app/init/init.c

    r8e189ef r982e3d8  
    200200}
    201201
    202 static void getterm(const char *dev, const char *app, bool wmsg)
     202static void getterm(const char *dev, const char *app)
    203203{
    204204        char term[DEVMAP_NAME_MAXLEN];
    … …  
    218218        }
    219219       
    220         if (wmsg) {
    221                 rc = task_spawnl(NULL, APP_GETTERM, APP_GETTERM, "-w", term,
    222                     app, NULL);
    223                 if (rc != EOK) {
    224                         printf("%s: Error spawning %s -w %s %s (%s)\n", NAME,
    225                             APP_GETTERM, term, app, str_error(rc));
    226                 }
    227         } else {
    228                 rc = task_spawnl(NULL, APP_GETTERM, APP_GETTERM, term, app,
    229                     NULL);
    230                 if (rc != EOK) {
    231                         printf("%s: Error spawning %s %s %s (%s)\n", NAME,
    232                             APP_GETTERM, term, app, str_error(rc));
    233                 }
     220        rc = task_spawnl(NULL, APP_GETTERM, APP_GETTERM, term, app, NULL);
     221        if (rc != EOK) {
     222                printf("%s: Error spawning %s %s %s (%s)\n", NAME,
     223                    APP_GETTERM, term, app, str_error(rc));
    234224        }
    235225}
    … …  
    305295#endif
    306296       
    307         getterm("term/vc0", "/app/bdsh", true);
    308         getterm("term/vc1", "/app/bdsh", false);
    309         getterm("term/vc2", "/app/bdsh", false);
    310         getterm("term/vc3", "/app/bdsh", false);
    311         getterm("term/vc4", "/app/bdsh", false);
    312         getterm("term/vc5", "/app/bdsh", false);
    313         getterm("term/vc6", "/app/klog", false);
     297        getterm("term/vc0", "/app/bdsh");
     298        getterm("term/vc1", "/app/bdsh");
     299        getterm("term/vc2", "/app/bdsh");
     300        getterm("term/vc3", "/app/bdsh");
     301        getterm("term/vc4", "/app/bdsh");
     302        getterm("term/vc5", "/app/bdsh");
     303        getterm("term/vc6", "/app/klog");
    314304       
    315305        return 0;

  • uspace/app/nettest1/nettest1.c

    r8e189ef r982e3d8  
    287287int main(int argc, char *argv[])
    288288{
    289         struct sockaddr_in address_in;
    290         struct sockaddr_in6 address_in6;
     289
     290        socklen_t max_length;
     291        uint8_t *address_data[sizeof(struct sockaddr_in6)];
     292        struct sockaddr_in *address_in;
     293        struct sockaddr_in6 *address_in6;
    291294        uint8_t *address_start;
    292295
    … …  
    297300
    298301        int rc;
     302
     303        max_length = sizeof(address_data);
     304        address = (struct sockaddr *) address_data;
     305        address_in = (struct sockaddr_in *) address;
     306        address_in6 = (struct sockaddr_in6 *) address;
    299307
    300308        sockets = 10;
    … …  
    326334
    327335        /* Prepare the address buffer */
     336        bzero(address_data, max_length);
    328337
    329338        switch (family) {
    330339        case PF_INET:
    331                 address_in.sin_family = AF_INET;
    332                 address_in.sin_port = htons(port);
    333                 address = (struct sockaddr *) &address_in;
    334                 addrlen = sizeof(address_in);
    335                 address_start = (uint8_t *) &address_in.sin_addr.s_addr;
     340                address_in->sin_family = AF_INET;
     341                address_in->sin_port = htons(port);
     342                address_start = (uint8_t *) &address_in->sin_addr.s_addr;
     343                addrlen = sizeof(struct sockaddr_in);
    336344                break;
    337345        case PF_INET6:
    338                 address_in6.sin6_family = AF_INET6;
    339                 address_in6.sin6_port = htons(port);
    340                 address = (struct sockaddr *) &address_in6;
    341                 addrlen = sizeof(address_in6);
    342                 address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
     346                address_in6->sin6_family = AF_INET6;
     347                address_in6->sin6_port = htons(port);
     348                address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     349                addrlen = sizeof(struct sockaddr_in6);
    343350                break;
    344351        default:

  • uspace/app/nettest2/nettest2.c

    r8e189ef r982e3d8  
    223223int main(int argc, char *argv[])
    224224{
     225        socklen_t max_length;
     226        uint8_t address_data[sizeof(struct sockaddr_in6)];
    225227        struct sockaddr *address;
    226         struct sockaddr_in address_in;
    227         struct sockaddr_in6 address_in6;
     228        struct sockaddr_in *address_in;
     229        struct sockaddr_in6 *address_in6;
    228230        socklen_t addrlen;
    229231        uint8_t *address_start;
    … …  
    245247        port = 7;
    246248
     249        max_length = sizeof(address_data);
     250        address = (struct sockaddr *) address_data;
     251        address_in = (struct sockaddr_in *) address;
     252        address_in6 = (struct sockaddr_in6 *) address;
     253
    247254        /*
    248255         * Parse the command line arguments.
    … …  
    272279
    273280        /* Prepare the address buffer */
     281        bzero(address_data, max_length);
    274282
    275283        switch (family) {
    276284        case PF_INET:
    277                 address_in.sin_family = AF_INET;
    278                 address_in.sin_port = htons(port);
    279                 address = (struct sockaddr *) &address_in;
    280                 addrlen = sizeof(address_in);
    281                 address_start = (uint8_t *) &address_in.sin_addr.s_addr;
     285                address_in->sin_family = AF_INET;
     286                address_in->sin_port = htons(port);
     287                address_start = (uint8_t *) &address_in->sin_addr.s_addr;
     288                addrlen = sizeof(struct sockaddr_in);
    282289                break;
    283290        case PF_INET6:
    284                 address_in6.sin6_family = AF_INET6;
    285                 address_in6.sin6_port = htons(port);
    286                 address = (struct sockaddr *) &address_in6;
    287                 addrlen = sizeof(address_in6);
    288                 address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
     291                address_in6->sin6_family = AF_INET6;
     292                address_in6->sin6_port = htons(port);
     293                address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     294                addrlen = sizeof(struct sockaddr_in6);
    289295                break;
    290296        default:

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

    r8e189ef r982e3d8  
    4646#define BUFSIZ  4096
    4747
    48 #define DEBUG(fmt, ...) \
     48#define DEBUG(fmt, ...)se\
    4949        { \
    5050                char _buf[256]; \

  • uspace/srv/hw/netif/dp8390/dp8390.h

    r8e189ef r982e3d8  
    4343/** Input/output size.
    4444 */
    45 #define DP8390_IO_SIZE  0x020
     45#define DP8390_IO_SIZE  0x01f
    4646
    4747/*

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

    r8e189ef r982e3d8  
    125125}
    126126
    127 static int arp_clear_address_req(int arp_phone, device_id_t device_id,
    128     services_t protocol, measured_string_ref address)
     127static int
     128arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol,
     129    measured_string_ref address)
    129130{
    130131        arp_device_ref device;
    … …  
    174175 * @returns             ENOMEM if there is not enough memory left.
    175176 */
    176 static int arp_proto_create(arp_proto_ref *proto, services_t service,
     177static int
     178arp_proto_create(arp_proto_ref *proto, services_t service,
    177179    measured_string_ref address)
    178180{
    … …  
    212214 *                      measured_strings_return() function.
    213215 */
    214 static int arp_device_message(device_id_t device_id, services_t service,
     216static int
     217arp_device_message(device_id_t device_id, services_t service,
    215218    services_t protocol, measured_string_ref address)
    216219{
    … …  
    222225
    223226        fibril_rwlock_write_lock(&arp_globals.lock);
    224 
    225         /* An existing device? */
     227        // an existing device?
    226228        device = arp_cache_find(&arp_globals.cache, device_id);
    227 
    228229        if (device) {
    229230                if (device->service != service) {
    … …  
    259260                        return ENOENT;
    260261               
    261                 /* Create a new device */
     262                // create a new device
    262263                device = (arp_device_ref) malloc(sizeof(arp_device_t));
    263264                if (!device) {
    … …  
    288289                device->service = service;
    289290               
    290                 /* Bind the new one */
     291                // bind the new one
    291292                device->phone = nil_bind_service(device->service,
    292293                    (ipcarg_t) device->device_id, SERVICE_ARP,
    … …  
    299300                }
    300301               
    301                 /* Get packet dimensions */
     302                // get packet dimensions
    302303                rc = nil_packet_size_req(device->phone, device_id,
    303304                    &device->packet_dimension);
    … …  
    309310                }
    310311               
    311                 /* Get hardware address */
     312                // get hardware address
    312313                rc = nil_get_addr_req(device->phone, device_id, &device->addr,
    313314                    &device->addr_data);
    … …  
    319320                }
    320321               
    321                 /* Get broadcast address */
     322                // get broadcast address
    322323                rc = nil_get_broadcast_addr_req(device->phone, device_id,
    323324                    &device->broadcast_addr, &device->broadcast_data);
    … …  
    454455        hw_source = arp_addr_find(&proto->addresses, (char *) src_proto,
    455456            CONVERT_SIZE(uint8_t, char, header->protocol_length));
    456         /* Exists? */
     457        // exists?
    457458        if (hw_source) {
    458459                if (hw_source->length != CONVERT_SIZE(uint8_t, char,
    … …  
    462463                memcpy(hw_source->value, src_hw, hw_source->length);
    463464        }
    464         /* Is my protocol address? */
     465        // is my protocol address?
    465466        if (proto->addr->length != CONVERT_SIZE(uint8_t, char,
    466467            header->protocol_length)) {
    … …  
    469470        if (!str_lcmp(proto->addr->value, (char *) des_proto,
    470471            proto->addr->length)) {
    471                 /* Not already updated? */
     472                // not already upadted?
    472473                if (!hw_source) {
    473474                        hw_source = measured_string_create_bulk((char *) src_hw,
    … …  
    549550                return addr;
    550551
    551         /* ARP packet content size = header + (address + translation) * 2 */
     552        // ARP packet content size = header + (address + translation) * 2
    552553        length = 8 + 2 * (CONVERT_SIZE(char, uint8_t, proto->addr->length) +
    553554            CONVERT_SIZE(char, uint8_t, device->addr->length));
    … …  
    673674       
    674675        case NET_IL_DEVICE_STATE:
    675                 /* Do nothing - keep the cache */
     676                // do nothing - keep the cache
    676677                return EOK;
    677678       

  • uspace/srv/net/il/arp/arp_module.c

    r8e189ef r982e3d8  
    5757extern arp_globals_t arp_globals;
    5858
    59 int il_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     59int
     60il_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    6061    ipc_call_t *answer, int *answer_count)
    6162{

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

    r8e189ef r982e3d8  
    275275        measured_strings_initialize(&net_globals.configuration);
    276276       
    277         /* TODO: dynamic configuration */
     277        // TODO: dynamic configuration
    278278        rc = read_configuration();
    279279        if (rc != EOK)
    … …  
    347347 *
    348348 * The network interface configuration is searched first.
    349  *
     349 &
    350350 * @param[in]  netif_conf    The network interface configuration setting.
    351351 * @param[out] configuration The found configured values.

  • uspace/srv/net/netif/lo/lo.c

    r8e189ef r982e3d8  
    6464netif_globals_t netif_globals;
    6565
    66 int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
     66int
     67netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
    6768    ipc_call_t *answer, int *answer_count)
    6869{
    … …  
    7475        if (!address)
    7576                return EBADMEM;
    76 
    7777        address->value = str_dup(DEFAULT_ADDR);
    7878        address->length = DEFAULT_ADDR_LEN;
    79 
    8079        return EOK;
    8180}
    … …  
    8887        if (!stats)
    8988                return EBADMEM;
    90 
    9189        rc = find_device(device_id, &device);
    9290        if (rc != EOK)
    9391                return rc;
    94 
    9592        memcpy(stats, (device_stats_ref) device->specific,
    9693            sizeof(device_stats_t));
    97 
    9894        return EOK;
    9995}
    … …  
    138134        if (!*device)
    139135                return ENOMEM;
    140 
    141136        (*device)->specific = (device_stats_t *) malloc(sizeof(device_stats_t));
    142137        if (!(*device)->specific) {
    … …  
    144139                return ENOMEM;
    145140        }
    146 
    147141        null_device_stats((device_stats_ref) (*device)->specific);
    148142        (*device)->device_id = device_id;
    … …  
    151145        index = netif_device_map_add(&netif_globals.device_map,
    152146            (*device)->device_id, *device);
    153 
    154147        if (index < 0) {
    155148                free(*device);
    … …  
    174167        int rc;
    175168
    176         /* Create a new device */
     169        // create a new device
    177170        rc = create(device_id, &device);
    178171        if (rc != EOK)
    179172                return rc;
    180 
    181         /* Print the settings */
     173        // print the settings
    182174        printf("%s: Device created (id: %d)\n", NAME, device->device_id);
    183 
    184175        return EOK;
    185176}
    … …  
    196187        if (rc != EOK)
    197188                return EOK;
    198 
    199189        if (device->state != NETIF_ACTIVE) {
    200190                netif_pq_release(packet_get_id(packet));
    201191                return EFORWARD;
    202192        }
    203 
    204193        next = packet;
    205194        do {
    … …  
    211200                next = pq_next(next);
    212201        } while(next);
    213 
    214202        phone = device->nil_phone;
    215203        fibril_rwlock_write_unlock(&netif_globals.lock);

  • uspace/srv/net/nil/eth/eth.c

    r8e189ef r982e3d8  
    204204        fibril_rwlock_write_lock(&eth_globals.protos_lock);
    205205        eth_globals.net_phone = net_phone;
    206 
    207206        eth_globals.broadcast_addr =
    208207            measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF",
    … …  
    212211                goto out;
    213212        }
    214 
    215213        rc = eth_devices_initialize(&eth_globals.devices);
    216214        if (rc != EOK) {
    … …  
    218216                goto out;
    219217        }
    220 
    221218        rc = eth_protos_initialize(&eth_globals.protos);
    222219        if (rc != EOK) {
    … …  
    283280 *                      netif_get_addr_req() function.
    284281 */
    285 static int eth_device_message(device_id_t device_id, services_t service,
    286     size_t mtu)
     282static int
     283eth_device_message(device_id_t device_id, services_t service, size_t mtu)
    287284{
    288285        eth_device_ref device;
    … …  
    305302
    306303        fibril_rwlock_write_lock(&eth_globals.devices_lock);
    307         /* An existing device? */
     304        // an existing device?
    308305        device = eth_devices_find(&eth_globals.devices, device_id);
    309306        if (device) {
    … …  
    314311                }
    315312               
    316                 /* Update mtu */
     313                // update mtu
    317314                if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
    318315                        device->mtu = mtu;
    … …  
    324321                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    325322               
    326                 /* Notify all upper layer modules */
     323                // notify all upper layer modules
    327324                fibril_rwlock_read_lock(&eth_globals.protos_lock);
    328325                for (index = 0; index < eth_protos_count(&eth_globals.protos);
    … …  
    336333                        }
    337334                }
    338 
    339335                fibril_rwlock_read_unlock(&eth_globals.protos_lock);
    340336                return EOK;
    341337        }
    342338       
    343         /* Create a new device */
     339        // create a new device
    344340        device = (eth_device_ref) malloc(sizeof(eth_device_t));
    345341        if (!device)
    … …  
    362358                return rc;
    363359        }
    364 
    365360        if (configuration) {
    366361                if (!str_lcmp(configuration[0].value, "DIX",
    … …  
    383378        }
    384379       
    385         /* Bind the device driver */
     380        // bind the device driver
    386381        device->phone = netif_bind_service(device->service, device->device_id,
    387382            SERVICE_ETHERNET, eth_receiver);
    … …  
    392387        }
    393388       
    394         /* Get hardware address */
     389        // get hardware address
    395390        rc = netif_get_addr_req(device->phone, device->device_id, &device->addr,
    396391            &device->addr_data);
    … …  
    401396        }
    402397       
    403         /* Add to the cache */
     398        // add to the cache
    404399        index = eth_devices_add(&eth_globals.devices, device->device_id,
    405400            device);
    … …  
    458453       
    459454        if (type >= ETH_MIN_PROTO) {
    460                 /* DIX Ethernet */
     455                // DIX Ethernet
    461456                prefix = sizeof(eth_header_t);
    462457                suffix = 0;
    … …  
    464459                length -= sizeof(eth_fcs_t);
    465460        } else if(type <= ETH_MAX_CONTENT) {
    466                 /* Translate "LSAP" values */
     461                // translate "LSAP" values
    467462                if ((header->lsap.dsap == ETH_LSAP_GLSAP) &&
    468463                    (header->lsap.ssap == ETH_LSAP_GLSAP)) {
    469                         /* Raw packet -- discard */
     464                        // raw packet
     465                        // discard
    470466                        return NULL;
    471467                } else if((header->lsap.dsap == ETH_LSAP_SNAP) &&
    472468                    (header->lsap.ssap == ETH_LSAP_SNAP)) {
    473                         /*
    474                          * IEEE 802.3 + 802.2 + LSAP + SNAP
    475                          * organization code not supported
    476                          */
     469                        // IEEE 802.3 + 802.2 + LSAP + SNAP
     470                        // organization code not supported
    477471                        type = ntohs(header->snap.ethertype);
    478472                        prefix = sizeof(eth_header_t) +
    … …  
    480474                            sizeof(eth_header_snap_t);
    481475                } else {
    482                         /* IEEE 802.3 + 802.2 LSAP */
     476                        // IEEE 802.3 + 802.2 LSAP
    483477                        type = lsap_map(header->lsap.dsap);
    484478                        prefix = sizeof(eth_header_t) +
    485479                            sizeof(eth_header_lsap_t);
    486480                }
    487 
    488481                suffix = (type < ETH_MIN_CONTENT) ? ETH_MIN_CONTENT - type : 0U;
    489482                fcs = (eth_fcs_ref) data + prefix + type + suffix;
    … …  
    491484                length = prefix + type + suffix;
    492485        } else {
    493                 /* Invalid length/type, should not occur */
     486                // invalid length/type, should not occurr
    494487                return NULL;
    495488        }
    … …  
    513506}
    514507
    515 int nil_received_msg_local(int nil_phone, device_id_t device_id,
    516     packet_t packet, services_t target)
     508int
     509nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet,
     510    services_t target)
    517511{
    518512        eth_proto_ref proto;
    … …  
    527521                return ENOENT;
    528522        }
    529 
    530523        flags = device->flags;
    531524        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    … …  
    545538                packet = next;
    546539        } while(packet);
    547 
    548540        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
     541       
    549542        return EOK;
    550543}
    … …  
    561554 * @returns             ENOENT if there is no such device.
    562555 */
    563 static int eth_packet_space_message(device_id_t device_id, size_t *addr_len,
     556static int
     557eth_packet_space_message(device_id_t device_id, size_t *addr_len,
    564558    size_t *prefix, size_t *content, size_t *suffix)
    565559{
    … …  
    575569                return ENOENT;
    576570        }
    577 
    578571        *content = device->mtu;
    579572        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    … …  
    582575        *prefix = ETH_PREFIX;
    583576        *suffix = ETH_MIN_CONTENT + ETH_SUFFIX;
    584 
    585577        return EOK;
    586578}
    … …  
    595587 * @returns             ENOENT if there no such device.
    596588 */
    597 static int eth_addr_message(device_id_t device_id, eth_addr_type_t type,
     589static int
     590eth_addr_message(device_id_t device_id, eth_addr_type_t type,
    598591    measured_string_ref *address)
    599592{
    … …  
    651644                        return ENOMEM;
    652645                }
    653 
    654646                proto->service = service;
    655647                proto->protocol = protocol;
    656648                proto->phone = phone;
    657 
    658649                index = eth_protos_add(&eth_globals.protos, protocol, proto);
    659650                if (index < 0) {
    … …  
    714705                if (!padding)
    715706                        return ENOMEM;
    716 
    717707                bzero(padding, ETH_MIN_TAGGED_CONTENT(flags) - length);
    718708        }
    … …  
    792782 * @returns             EINVAL if the service parameter is not known.
    793783 */
    794 static int eth_send_message(device_id_t device_id, packet_t packet,
    795     services_t sender)
     784static int
     785eth_send_message(device_id_t device_id, packet_t packet, services_t sender)
    796786{
    797787        eth_device_ref device;
    … …  
    814804        }
    815805       
    816         /* Process packet queue */
     806        // process packet queue
    817807        next = packet;
    818808        do {
    … …  
    820810                    (uint8_t *) device->addr->value, ethertype, device->mtu);
    821811                if (rc != EOK) {
    822                         /* Release invalid packet */
     812                        // release invalid packet
    823813                        tmp = pq_detach(next);
    824814                        if (next == packet)
    … …  
    832822        } while(next);
    833823       
    834         /* Send packet queue */
     824        // send packet queue
    835825        if (packet) {
    836826                netif_send_msg(device->phone, device_id, packet,
    837827                    SERVICE_ETHERNET);
    838828        }
    839 
    840829        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     830       
    841831        return EOK;
    842832}
    843833
    844 int nil_message_standalone(const char *name, ipc_callid_t callid,
    845     ipc_call_t *call, ipc_call_t *answer, int *answer_count)
     834int
     835nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call,
     836    ipc_call_t *answer, int *answer_count)
    846837{
    847838        measured_string_ref address;
    … …  
    903894 * @param[in] iid       The initial message identifier.
    904895 * @param[in] icall     The initial message call structure.
     896 *
    905897 */
    906898static void nil_client_connection(ipc_callid_t iid, ipc_call_t *icall)

  • uspace/srv/net/nil/eth/eth_module.c

    r8e189ef r982e3d8  
    7777}
    7878
    79 int nil_module_message_standalone(const char *name, ipc_callid_t callid,
     79int
     80nil_module_message_standalone(const char *name, ipc_callid_t callid,
    8081    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
    8182{

  • uspace/srv/net/nil/nildummy/nildummy.c

    r8e189ef r982e3d8  
    150150 *                      netif_get_addr_req() function.
    151151 */
    152 static int nildummy_device_message(device_id_t device_id, services_t service,
    153     size_t mtu)
     152static int
     153nildummy_device_message(device_id_t device_id, services_t service, size_t mtu)
    154154{
    155155        nildummy_device_ref device;
    … …  
    159159        fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
    160160
    161         /* An existing device? */
     161        // an existing device?
    162162        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
    163163        if (device) {
    … …  
    169169                }
    170170               
    171                 /* Update MTU */
     171                // update mtu
    172172                if (mtu > 0)
    173173                        device->mtu = mtu;
    … …  
    179179                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    180180               
    181                 /* Notify the upper layer module */
     181                // notify the upper layer module
    182182                fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    183183                if (nildummy_globals.proto.phone) {
    … …  
    191191        }
    192192       
    193         /* Create a new device */
     193        // create a new device
    194194        device = (nildummy_device_ref) malloc(sizeof(nildummy_device_t));
    195195        if (!device)
    … …  
    203203                device->mtu = NET_DEFAULT_MTU;
    204204
    205         /* Bind the device driver */
     205        // bind the device driver
    206206        device->phone = netif_bind_service(device->service, device->device_id,
    207207            SERVICE_ETHERNET, nildummy_receiver);
    … …  
    212212        }
    213213       
    214         /* Get hardware address */
     214        // get hardware address
    215215        rc = netif_get_addr_req(device->phone, device->device_id, &device->addr,
    216216            &device->addr_data);
    … …  
    221221        }
    222222       
    223         /* Add to the cache */
     223        // add to the cache
    224224        index = nildummy_devices_add(&nildummy_globals.devices,
    225225            device->device_id, device);
    … …  
    247247 *
    248248 */
    249 static int nildummy_addr_message(device_id_t device_id,
    250     measured_string_ref *address)
     249static int
     250nildummy_addr_message(device_id_t device_id, measured_string_ref *address)
    251251{
    252252        nildummy_device_ref device;
    … …  
    279279 *
    280280 */
    281 static int nildummy_packet_space_message(device_id_t device_id, size_t *addr_len,
     281static int
     282nildummy_packet_space_message(device_id_t device_id, size_t *addr_len,
    282283    size_t *prefix, size_t *content, size_t *suffix)
    283284{
    … …  
    293294                return ENOENT;
    294295        }
    295 
    296296        *content = device->mtu;
    297297        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    … …  
    303303}
    304304
    305 int nil_received_msg_local(int nil_phone, device_id_t device_id,
    306     packet_t packet, services_t target)
     305int
     306nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet,
     307    services_t target)
    307308{
    308309        packet_t next;
    … …  
    354355 * @return              EINVAL if the service parameter is not known.
    355356 */
    356 static int nildummy_send_message(device_id_t device_id, packet_t packet,
    357     services_t sender)
     357static int
     358nildummy_send_message(device_id_t device_id, packet_t packet, services_t sender)
    358359{
    359360        nildummy_device_ref device;
    … …  
    365366                return ENOENT;
    366367        }
    367 
    368         /* Send packet queue */
     368        // send packet queue
    369369        if (packet)
    370370                netif_send_msg(device->phone, device_id, packet,
    … …  
    374374}
    375375
    376 int nil_message_standalone(const char *name, ipc_callid_t callid,
    377     ipc_call_t *call, ipc_call_t *answer, int *answer_count)
     376int
     377nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call,
     378    ipc_call_t *answer, int *answer_count)
    378379{
    379380        measured_string_ref address;

  • uspace/srv/net/nil/nildummy/nildummy_module.c

    r8e189ef r982e3d8  
    7878}
    7979
    80 int nil_module_message_standalone(const char *name, ipc_callid_t callid,
     80int
     81nil_module_message_standalone(const char *name, ipc_callid_t callid,
    8182    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
    8283{

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

    r8e189ef r982e3d8  
    155155 * @returns             EPERM if the error message is not allowed.
    156156 */
    157 static int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t packet,
     157static int
     158icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t packet,
    158159    icmp_header_ref header, services_t error, ip_ttl_t ttl, ip_tos_t tos,
    159160    int dont_fragment)
    … …  
    161162        int rc;
    162163
    163         /* Do not send an error if disabled */
     164        // do not send an error if disabled
    164165        if (error && !icmp_globals.error_reporting)
    165166                return icmp_release_and_return(packet, EPERM);
    … …  
    203204                return NULL;
    204205
    205         /* Truncate if longer than 64 bits (without the IP header) */
     206        // truncate if longer than 64 bits (without the IP header)
    206207        if ((total_length > header_length + ICMP_KEEP_LENGTH) &&
    207208            (packet_trim(packet, 0,
    … …  
    243244 * @returns             EPARTY if there was an internal error.
    244245 */
    245 static int icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size,
     246static int
     247icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size,
    246248    mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment,
    247249    const struct sockaddr * addr, socklen_t addrlen)
    … …  
    260262
    261263        length = (size_t) addrlen;
    262         /* TODO do not ask all the time */
     264        // TODO do not ask all the time
    263265        rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
    264266            &icmp_globals.packet_dimension);
    … …  
    273275                return ENOMEM;
    274276
    275         /* Prepare the requesting packet, set the destination address. */
     277        // prepare the requesting packet
     278        // set the destination address
    276279        rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length);
    277280        if (rc != EOK)
    278281                return icmp_release_and_return(packet, rc);
    279282
    280         /* Allocate space in the packet */
     283        // allocate space in the packet
    281284        data = (uint8_t *) packet_suffix(packet, size);
    282285        if (!data)
    283286                return icmp_release_and_return(packet, ENOMEM);
    284287
    285         /* Fill the data */
     288        // fill the data
    286289        length = 0;
    287290        while (size > length + sizeof(ICMP_ECHO_TEXT)) {
    … …  
    291294        memcpy(data + length, ICMP_ECHO_TEXT, size - length);
    292295
    293         /* Prefix the header */
     296        // prefix the header
    294297        header = PACKET_PREFIX(packet, icmp_header_t);
    295298        if (!header)
    … …  
    300303        header->un.echo.sequence_number = sequence;
    301304
    302         /* Prepare the reply structure */
     305        // prepare the reply structure
    303306        reply = malloc(sizeof(*reply));
    304307        if (!reply)
    … …  
    316319        }
    317320
    318         /* Unlock the globals so that we can wait for the reply */
     321        // unlock the globals so that we can wait for the reply
    319322        fibril_rwlock_write_unlock(&icmp_globals.lock);
    320323
    321         /* Send the request */
     324        // send the request
    322325        icmp_send_packet(ICMP_ECHO, 0, packet, header, 0, ttl, tos,
    323326            dont_fragment);
    324327
    325         /* Wait for the reply. Timeout in microseconds. */
     328        // wait for the reply
     329        // timeout in microseconds
    326330        rc = fibril_condvar_wait_timeout(&reply->condvar, &reply->mutex,
    327331            timeout * 1000);
    … …  
    329333                rc = reply->result;
    330334
    331         /* Drop the reply mutex before locking the globals again */
     335        // drop the reply mutex before locking the globals again
    332336        fibril_mutex_unlock(&reply->mutex);
    333337        fibril_rwlock_write_lock(&icmp_globals.lock);
    334338
    335         /* Destroy the reply structure */
     339        // destroy the reply structure
    336340        icmp_replies_exclude_index(&icmp_globals.replies, index);
    337341
    … …  
    339343}
    340344
    341 static int icmp_destination_unreachable_msg_local(int icmp_phone,
    342     icmp_code_t code, icmp_param_t mtu, packet_t packet)
     345static int
     346icmp_destination_unreachable_msg_local(int icmp_phone, icmp_code_t code,
     347    icmp_param_t mtu, packet_t packet)
    343348{
    344349        icmp_header_ref header;
    … …  
    367372}
    368373
    369 static int icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code,
    370     packet_t packet)
     374static int
     375icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code, packet_t packet)
    371376{
    372377        icmp_header_ref header;
    … …  
    380385}
    381386
    382 static int icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code,
     387static int
     388icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code,
    383389    icmp_param_t pointer, packet_t packet)
    384390{
    … …  
    443449        icmp_globals.echo_replying = NET_DEFAULT_ICMP_ECHO_REPLYING;
    444450
    445         /* Get configuration */
     451        // get configuration
    446452        configuration = &names[0];
    447453        rc = net_get_conf_req(icmp_globals.net_phone, &configuration, count,
    … …  
    479485 * @param[in] code      The received reply message code.
    480486 */
    481 static void  icmp_process_echo_reply(packet_t packet, icmp_header_ref header,
     487static void
     488icmp_process_echo_reply(packet_t packet, icmp_header_ref header,
    482489    icmp_type_t type, icmp_code_t code)
    483490{
    … …  
    485492        icmp_reply_ref reply;
    486493
    487         /* Compute the reply key */
     494        // compute the reply key
    488495        reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier,
    489496            header->un.echo.sequence_number);
    490497        pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
    491498
    492         /* Find the pending reply */
    493499        fibril_rwlock_write_lock(&icmp_globals.lock);
     500        // find the pending reply
    494501        reply = icmp_replies_find(&icmp_globals.replies, reply_key);
    495502        if (reply) {
    … …  
    534541                break;
    535542        case SERVICE_ICMP:
    536                 /* Process error */
     543                // process error
    537544                result = icmp_client_process_packet(packet, &type, &code, NULL,
    538545                    NULL);
    … …  
    540547                        return result;
    541548                length = (size_t) result;
    542                 /* Remove the error header */
     549                // remove the error header
    543550                rc = packet_trim(packet, length, 0);
    544551                if (rc != EOK)
    … …  
    549556        }
    550557
    551         /* Get rid of the IP header */
     558        // get rid of the ip header
    552559        length = ip_client_header_length(packet);
    553560        rc = packet_trim(packet, length, 0);
    … …  
    566573                return EINVAL;
    567574
    568         /* Get ICMP header */
     575        // get icmp header
    569576        header = (icmp_header_ref) data;
    570577
    571578        if (header->checksum) {
    572579                while (ICMP_CHECKSUM(header, length) != IP_CHECKSUM_ZERO) {
    573                         /*
    574                          * Set the original message type on error notification.
    575                          * Type swap observed in Qemu.
    576                          */
     580                        // set the original message type on error notification
     581                        // type swap observed in Qemu
    577582                        if (error) {
    578583                                switch (header->type) {
    … …  
    601606                }
    602607               
    603                 /* Do not send a reply if disabled */
     608                // do not send a reply if disabled
    604609                if (icmp_globals.echo_replying) {
    605610                        addrlen = packet_get_addr(packet, &src, NULL);
    606611
    607                         /*
    608                          * Set both addresses to the source one (avoids the
    609                          * source address deletion before setting the
    610                          * destination one).
    611                          */
     612                        // set both addresses to the source one (avoids the
     613                        // source address deletion before setting the
     614                        // destination one)
    612615                        if ((addrlen > 0) && (packet_set_addr(packet, src, src,
    613616                            (size_t) addrlen) == EOK)) {
    614                                 /* Send the reply */
     617                                // send the reply
    615618                                icmp_send_packet(ICMP_ECHOREPLY, 0, packet,
    616619                                    header, 0, 0, 0, 0);
    … …  
    658661 *                      icmp_process_packet() function.
    659662 */
    660 static int icmp_received_msg_local(device_id_t device_id, packet_t packet,
     663static int
     664icmp_received_msg_local(device_id_t device_id, packet_t packet,
    661665    services_t receiver, services_t error)
    662666{
    … …  
    742746                return EBADMEM;
    743747
    744         /* From the last used one */
     748        // from the last used one
    745749        index = icmp_globals.last_used_id;
    746750        do {
    747751                index++;
    748                 /* til the range end */
     752                // til the range end
    749753                if (index >= ICMP_FREE_IDS_END) {
    750                         /* start from the range beginning */
     754                        // start from the range beginning
    751755                        index = ICMP_FREE_IDS_START - 1;
    752756                        do {
    753757                                index++;
    754                                 /* til the last used one */
     758                                // til the last used one
    755759                                if (index >= icmp_globals.last_used_id) {
    756                                         /* none found */
     760                                        // none found
    757761                                        return ENOTCONN;
    758762                                }
    … …  
    760764                            index) != NULL);
    761765
    762                         /* Found, break immediately */
     766                        // found, break immediately
    763767                        break;
    764768                }
    … …  
    804808                return ENOMEM;
    805809
    806         /* Assign a new identifier */
     810        // assign a new identifier
    807811        fibril_rwlock_write_lock(&icmp_globals.lock);
    808812        rc = icmp_bind_free_id(echo_data);
    … …  
    814818
    815819        while (keep_on_going) {
    816                 /* Answer the call */
     820                // answer the call
    817821                answer_call(callid, rc, &answer, answer_count);
    818822
    819                 /* Refresh data */
     823                // refresh data
    820824                refresh_answer(&answer, &answer_count);
    821825
    822                 /* Get the next call */
     826                // get the next call
    823827                callid = async_get_call(&call);
    824828
    825                 /* Process the call */
     829                // process the call
    826830                switch (IPC_GET_METHOD(call)) {
    827831                case IPC_M_PHONE_HUNGUP:
    … …  
    872876        }
    873877
    874         /* Release the identifier */
     878        // release the identifier
    875879        fibril_rwlock_write_lock(&icmp_globals.lock);
    876880        icmp_echo_data_exclude(&icmp_globals.echo_data, echo_data->identifier);
    … …  
    893897 * @see IS_NET_ICMP_MESSAGE()
    894898 */
    895 int icmp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     899int
     900icmp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    896901    ipc_call_t *answer, int *answer_count)
    897902{

  • uspace/srv/net/tl/icmp/icmp_module.c

    r8e189ef r982e3d8  
    8585}
    8686
    87 int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     87int
     88tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    8889    ipc_call_t *answer, int *answer_count)
    8990{

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

    r8e189ef r982e3d8  
    4444#include <fibril_synch.h>
    4545#include <malloc.h>
    46 /* TODO remove stdio */
     46//TODO remove stdio
    4747#include <stdio.h>
    4848#include <errno.h>
    … …  
    267267}
    268268
    269 int tcp_received_msg(device_id_t device_id, packet_t packet,
    270     services_t receiver, services_t error)
     269int
     270tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver,
     271    services_t error)
    271272{
    272273        int rc;
    … …  
    308309                break;
    309310        case SERVICE_ICMP:
    310                 /* Process error */
     311                // process error
    311312                result = icmp_client_process_packet(packet, &type, &code, NULL,
    312313                    NULL);
    … …  
    323324        }
    324325
    325         /* TODO process received ipopts? */
     326        // TODO process received ipopts?
    326327        result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL);
    327328        if (result < 0)
    … …  
    337338                return tcp_release_and_return(packet, NO_DATA);
    338339
    339         /* Trim all but TCP header */
     340        // trim all but TCP header
    340341        rc = packet_trim(packet, offset, 0);
    341342        if (rc != EOK)
    342343                return tcp_release_and_return(packet, rc);
    343344
    344         /* Get tcp header */
     345        // get tcp header
    345346        header = (tcp_header_ref) packet_get_data(packet);
    346347        if (!header)
    … …  
    360361                return tcp_release_and_return(packet, rc);
    361362       
    362         /* Find the destination socket */
     363        // find the destination socket
    363364        socket = socket_port_find(&tcp_globals.sockets,
    364365            ntohs(header->destination_port), (const char *) src, addrlen);
    365366        if (!socket) {
    366                 /* Find the listening destination socket */
     367                // find the listening destination socket
    367368                socket = socket_port_find(&tcp_globals.sockets,
    368369                    ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING,
    369370                    0);
    370371        }
    371 
    372372        if (!socket) {
    373373                if (tl_prepare_icmp_packet(tcp_globals.net_phone,
    … …  
    383383        assert(socket_data);
    384384
    385         /* Some data received, clear the timeout counter */
     385        // some data received, clear the timeout counter
    386386        socket_data->timeout_count = 0;
    387387
    388         /* Count the received packet fragments */
     388        // count the received packet fragments
    389389        next_packet = packet;
    390390        fragments = 0;
    … …  
    399399                total_length += length;
    400400
    401                 /* Add partial checksum if set */
     401                // add partial checksum if set
    402402                if (!error) {
    403403                        checksum = compute_checksum(checksum,
    … …  
    447447                    tcp_globals.icmp_phone, packet, error);
    448448                if (rc == EOK) {
    449                         /* Checksum error ICMP */
     449                        // checksum error ICMP
    450450                        icmp_parameter_problem_msg(tcp_globals.icmp_phone,
    451451                            ICMP_PARAM_POINTER,
    … …  
    460460        fibril_rwlock_read_unlock(&tcp_globals.lock);
    461461
    462         /* TODO error reporting/handling */
     462        // TODO error reporting/handling
    463463        switch (socket_data->state) {
    464464        case TCP_SOCKET_LISTEN:
    … …  
    474474                break;
    475475        case TCP_SOCKET_FIN_WAIT_1:
    476                 /* ack changing the state to FIN_WAIT_2 gets processed later */
     476                // ack changing the state to FIN_WAIT_2 gets processed later
    477477        case TCP_SOCKET_FIN_WAIT_2:
    478                 /* fin changing state to LAST_ACK gets processed later */
     478                // fin changing state to LAST_ACK gets processed later
    479479        case TCP_SOCKET_LAST_ACK:
    480                 /* ack releasing the socket get processed later */
     480                // ack releasing the socket get processed later
    481481        case TCP_SOCKET_CLOSING:
    482                 /* ack releasing the socket gets processed later */
     482                // ack releasing the socket gets processed later
    483483        case TCP_SOCKET_ESTABLISHED:
    484484                rc = tcp_process_established(socket, socket_data, header,
    … …  
    497497}
    498498
    499 int tcp_process_established(socket_core_ref socket, tcp_socket_data_ref
    500     socket_data, tcp_header_ref header, packet_t packet, int fragments,
    501     size_t total_length)
     499int
     500tcp_process_established(socket_core_ref socket, tcp_socket_data_ref socket_data,
     501    tcp_header_ref header, packet_t packet, int fragments, size_t total_length)
    502502{
    503503        packet_t next_packet;
    … …  
    523523                socket_data->fin_incoming = new_sequence_number;
    524524
    525         /* Trim begining if containing expected data */
     525        // trim begining if containing expected data
    526526        if (IS_IN_INTERVAL_OVERFLOW(new_sequence_number,
    527527            socket_data->next_incoming, new_sequence_number + total_length)) {
    528528
    529                 /* Get the acknowledged offset */
     529                // get the acknowledged offset
    530530                if (socket_data->next_incoming < new_sequence_number) {
    531531                        offset = new_sequence_number -
    … …  
    539539                total_length -= offset;
    540540                length = packet_get_data_length(packet);
    541 
    542                 /* Trim the acknowledged data */
     541                // trim the acknowledged data
    543542                while (length <= offset) {
    544                         /* Release the acknowledged packets */
     543                        // release the acknowledged packets
    545544                        next_packet = pq_next(packet);
    546545                        pq_release_remote(tcp_globals.net_phone,
    … …  
    560559        }
    561560
    562         /* Release if overflowing the window */
     561        // release if overflowing the window
    563562/*
    564563        if (IS_IN_INTERVAL_OVERFLOW(socket_data->next_incoming +
    … …  
    610609        }
    611610*/
    612         /* The expected one arrived? */
     611        // the expected one arrived?
    613612        if (new_sequence_number == socket_data->next_incoming) {
    614613                printf("expected\n");
    615                 /* Process acknowledgement */
     614                // process acknowledgement
    616615                tcp_process_acknowledgement(socket, socket_data, header);
    617616
    618                 /* Remove the header */
     617                // remove the header
    619618                total_length -= TCP_HEADER_LENGTH(header);
    620619                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
    … …  
    636635                        rc = pq_get_order(socket_data->incoming, &order, NULL);
    637636                        if (rc != EOK) {
    638                                 /* Remove the corrupted packet */
     637                                // remove the corrupted packet
    639638                                next_packet = pq_detach(packet);
    640639                                if (packet == socket_data->incoming)
    … …  
    649648                        if (IS_IN_INTERVAL_OVERFLOW(sequence_number,
    650649                            old_incoming, socket_data->next_incoming)) {
    651                                 /* Move to the next */
     650                                // move to the next
    652651                                packet = pq_next(packet);
    653                                 /* Coninual data? */
     652                                // coninual data?
    654653                        } else if (IS_IN_INTERVAL_OVERFLOW(old_incoming,
    655654                            sequence_number, socket_data->next_incoming)) {
    656                                 /* Detach the packet */
     655                                // detach the packet
    657656                                next_packet = pq_detach(packet);
    658657                                if (packet == socket_data->incoming)
    659658                                        socket_data->incoming = next_packet;
    660                                 /* Get data length */
     659                                // get data length
    661660                                length = packet_get_data_length(packet);
    662661                                new_sequence_number = sequence_number + length;
    663662                                if (length <= 0) {
    664                                         /* Remove the empty packet */
     663                                        // remove the empty packet
    665664                                        pq_release_remote(tcp_globals.net_phone,
    666665                                            packet_get_id(packet));
    … …  
    668667                                        continue;
    669668                                }
    670                                 /* Exactly following */
     669                                // exactly following
    671670                                if (sequence_number ==
    672671                                    socket_data->next_incoming) {
    673                                         /* Queue received data */
     672                                        // queue received data
    674673                                        rc = tcp_queue_received_packet(socket,
    675674                                            socket_data, packet, 1,
    … …  
    681680                                        packet = next_packet;
    682681                                        continue;
    683                                         /* At least partly following data? */
     682                                        // at least partly following data?
    684683                                }
    685684                                if (IS_IN_INTERVAL_OVERFLOW(sequence_number,
    … …  
    696695                                        rc = packet_trim(packet,length, 0);
    697696                                        if (rc == EOK) {
    698                                                 /* Queue received data */
     697                                                // queue received data
    699698                                                rc = tcp_queue_received_packet(
    700699                                                    socket, socket_data, packet,
    … …  
    709708                                        }
    710709                                }
    711                                 /* Remove the duplicit or corrupted packet */
     710                                // remove the duplicit or corrupted packet
    712711                                pq_release_remote(tcp_globals.net_phone,
    713712                                    packet_get_id(packet));
    … …  
    722721            socket_data->next_incoming + socket_data->window)) {
    723722                printf("in window\n");
    724                 /* Process acknowledgement */
     723                // process acknowledgement
    725724                tcp_process_acknowledgement(socket, socket_data, header);
    726725
    727                 /* Remove the header */
     726                // remove the header
    728727                total_length -= TCP_HEADER_LENGTH(header);
    729728                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
    … …  
    736735                    length);
    737736                if (rc != EOK) {
    738                         /* Remove the corrupted packets */
     737                        // remove the corrupted packets
    739738                        pq_release_remote(tcp_globals.net_phone,
    740739                            packet_get_id(packet));
    … …  
    763762        } else {
    764763                printf("unexpected\n");
    765                 /* Release duplicite or restricted */
     764                // release duplicite or restricted
    766765                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    767766        }
    768767
    769         /* Change state according to the acknowledging incoming fin */
     768        // change state according to the acknowledging incoming fin
    770769        if (IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming,
    771770            socket_data->next_incoming)) {
    … …  
    776775                        socket_data->state = TCP_SOCKET_CLOSING;
    777776                        break;
    778                 /*case TCP_ESTABLISHED:*/
     777                        //case TCP_ESTABLISHED:
    779778                default:
    780779                        socket_data->state = TCP_SOCKET_CLOSE_WAIT;
    … …  
    785784        packet = tcp_get_packets_to_send(socket, socket_data);
    786785        if (!packet) {
    787                 /* Create the notification packet */
     786                // create the notification packet
    788787                rc = tcp_create_notification_packet(&packet, socket,
    789788                    socket_data, 0, 0);
    … …  
    799798        fibril_rwlock_write_unlock(socket_data->local_lock);
    800799
    801         /* Send the packet */
     800        // send the packet
    802801        tcp_send_packets(socket_data->device_id, packet);
    803802
    … …  
    805804}
    806805
    807 int tcp_queue_received_packet(socket_core_ref socket,
     806int
     807tcp_queue_received_packet(socket_core_ref socket,
    808808    tcp_socket_data_ref socket_data, packet_t packet, int fragments,
    809809    size_t total_length)
    … …  
    819819        assert(socket_data->window > total_length);
    820820
    821         /* Queue the received packet */
     821        // queue the received packet
    822822        rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
    823823            SOCKET_MAX_RECEIVED_SIZE);
    … …  
    829829                return tcp_release_and_return(packet, rc);
    830830
    831         /* Decrease the window size */
     831        // decrease the window size
    832832        socket_data->window -= total_length;
    833833
    834         /* Notify the destination socket */
     834        // notify the destination socket
    835835        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    836836            (ipcarg_t) socket->socket_id,
    … …  
    842842}
    843843
    844 int tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref
    845     socket_data, tcp_header_ref header, packet_t packet)
     844int
     845tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref socket_data,
     846    tcp_header_ref header, packet_t packet)
    846847{
    847848        packet_t next_packet;
    … …  
    857858                return tcp_release_and_return(packet, EINVAL);
    858859       
    859         /* Process acknowledgement */
     860        // process acknowledgement
    860861        tcp_process_acknowledgement(socket, socket_data, header);
    861862
    862863        socket_data->next_incoming = ntohl(header->sequence_number) + 1;
    863 
    864         /* Release additional packets */
     864        // release additional packets
    865865        next_packet = pq_detach(packet);
    866866        if (next_packet) {
    … …  
    868868                    packet_get_id(next_packet));
    869869        }
    870 
    871         /* Trim if longer than the header */
     870        // trim if longer than the header
    872871        if (packet_get_data_length(packet) > sizeof(*header)) {
    873872                rc = packet_trim(packet, 0,
    … …  
    876875                        return tcp_release_and_return(packet, rc);
    877876        }
    878 
    879877        tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
    880878        fibril_mutex_lock(&socket_data->operation.mutex);
    881879        socket_data->operation.result = tcp_queue_packet(socket, socket_data,
    882880            packet, 1);
    883 
    884881        if (socket_data->operation.result == EOK) {
    885882                socket_data->state = TCP_SOCKET_ESTABLISHED;
    … …  
    887884                if (packet) {
    888885                        fibril_rwlock_write_unlock( socket_data->local_lock);
    889                         /* Send the packet */
     886                        // send the packet
    890887                        tcp_send_packets(socket_data->device_id, packet);
    891                         /* Signal the result */
     888                        // signal the result
    892889                        fibril_condvar_signal( &socket_data->operation.condvar);
    893890                        fibril_mutex_unlock( &socket_data->operation.mutex);
    … …  
    895892                }
    896893        }
    897 
    898894        fibril_mutex_unlock(&socket_data->operation.mutex);
    899895        return tcp_release_and_return(packet, EINVAL);
    900896}
    901897
    902 int tcp_process_listen(socket_core_ref listening_socket,
     898int
     899tcp_process_listen(socket_core_ref listening_socket,
    903900    tcp_socket_data_ref listening_socket_data, tcp_header_ref header,
    904901    packet_t packet, struct sockaddr *src, struct sockaddr *dest,
    … …  
    939936                return tcp_release_and_return(packet, ENOMEM);
    940937        }
    941 
    942938        memcpy(socket_data->addr, src, socket_data->addrlen);
    943939        socket_data->dest_port = ntohs(header->source_port);
    … …  
    950946        }
    951947
    952         /* Create a socket */
     948        // create a socket
    953949        socket_id = -1;
    954950        rc = socket_create(socket_data->local_sockets, listening_socket->phone,
    … …  
    969965        fibril_rwlock_write_lock(&tcp_globals.lock);
    970966
    971         /* Find the destination socket */
     967        // find the destination socket
    972968        listening_socket = socket_port_find(&tcp_globals.sockets,
    973969            listening_port, SOCKET_MAP_KEY_LISTENING, 0);
    … …  
    975971            (listening_socket->socket_id != listening_socket_id)) {
    976972                fibril_rwlock_write_unlock(&tcp_globals.lock);
    977                 /* A shadow may remain until app hangs up */
     973                // a shadow may remain until app hangs up
    978974                return tcp_release_and_return(packet, EOK /*ENOTSOCK*/);
    979975        }
    … …  
    987983            socket_id);
    988984        if (!socket) {
    989                 /* Where is the socket?!? */
     985                // where is the socket?!?
    990986                fibril_rwlock_write_unlock(&tcp_globals.lock);
    991987                return ENOTSOCK;
    … …  
    10141010        socket_data->next_incoming = ntohl(header->sequence_number) + 1;
    10151011
    1016         /* Release additional packets */
     1012        // release additional packets
    10171013        next_packet = pq_detach(packet);
    10181014        if (next_packet) {
    … …  
    10211017        }
    10221018
    1023         /* Trim if longer than the header */
     1019        // trim if longer than the header
    10241020        if (packet_get_data_length(packet) > sizeof(*header)) {
    10251021                rc = packet_trim(packet, 0,
    … …  
    10541050        fibril_rwlock_write_unlock(socket_data->local_lock);
    10551051
    1056         /* Send the packet */
     1052        // send the packet
    10571053        tcp_send_packets(socket_data->device_id, packet);
    10581054
    … …  
    10601056}
    10611057
    1062 int tcp_process_syn_received(socket_core_ref socket,
     1058int
     1059tcp_process_syn_received(socket_core_ref socket,
    10631060    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet)
    10641061{
    … …  
    10761073                return tcp_release_and_return(packet, EINVAL);
    10771074
    1078         /* Process acknowledgement */
     1075        // process acknowledgement
    10791076        tcp_process_acknowledgement(socket, socket_data, header);
    10801077
    … …  
    10891086                assert(listening_socket_data);
    10901087
    1091                 /* Queue the received packet */
     1088                // queue the received packet
    10921089                rc = dyn_fifo_push(&listening_socket->accepted,
    10931090                    (-1 * socket->socket_id), listening_socket_data->backlog);
    10941091                if (rc == EOK) {
    1095                         /* Notify the destination socket */
     1092                        // notify the destination socket
    10961093                        async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
    10971094                            (ipcarg_t) listening_socket->socket_id,
    … …  
    11031100                }
    11041101        }
    1105         /* Send FIN */
     1102        // send FIN
    11061103        socket_data->state = TCP_SOCKET_FIN_WAIT_1;
    11071104
    1108         /* Create the notification packet */
     1105        // create the notification packet
    11091106        rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
    11101107        if (rc != EOK)
    11111108                return rc;
    11121109
    1113         /* Send the packet */
     1110        // send the packet
    11141111        rc = tcp_queue_packet(socket, socket_data, packet, 1);
    11151112        if (rc != EOK)
    11161113                return rc;
    11171114
    1118         /* Flush packets */
     1115        // flush packets
    11191116        packet = tcp_get_packets_to_send(socket, socket_data);
    11201117        fibril_rwlock_write_unlock(socket_data->local_lock);
    11211118        if (packet) {
    1122                 /* Send the packet */
     1119                // send the packet
    11231120                tcp_send_packets(socket_data->device_id, packet);
    11241121        }
    … …  
    11271124}
    11281125
    1129 void tcp_process_acknowledgement(socket_core_ref socket,
     1126void
     1127tcp_process_acknowledgement(socket_core_ref socket,
    11301128    tcp_socket_data_ref socket_data, tcp_header_ref header)
    11311129{
    … …  
    11461144
    11471145        number = ntohl(header->acknowledgement_number);
    1148 
    1149         /* If more data acknowledged */
     1146        // if more data acknowledged
    11501147        if (number != socket_data->expected) {
    11511148                old = socket_data->expected;
    … …  
    11581155                        case TCP_SOCKET_LAST_ACK:
    11591156                        case TCP_SOCKET_CLOSING:
    1160                                 /*
    1161                                  * FIN acknowledged - release the socket in
    1162                                  * another fibril.
    1163                                  */
     1157                                // fin acknowledged - release the socket in
     1158                                // another fibril
    11641159                                tcp_prepare_timeout(tcp_release_after_timeout,
    11651160                                    socket, socket_data, 0,
    … …  
    11711166                        }
    11721167                }
    1173 
    1174                 /* Update the treshold if higher than set */
     1168                // update the treshold if higher than set
    11751169                if (number + ntohs(header->window) >
    11761170                    socket_data->expected + socket_data->treshold) {
    … …  
    11781172                            socket_data->expected;
    11791173                }
    1180 
    1181                 /* Set new expected sequence number */
     1174                // set new expected sequence number
    11821175                socket_data->expected = number;
    11831176                socket_data->expected_count = 1;
    … …  
    11911184                                        socket_data->outgoing = next;
    11921185
    1193                                 /* Add to acknowledged or release */
     1186                                // add to acknowledged or release
    11941187                                if (pq_add(&acknowledged, packet, 0, 0) != EOK)
    11951188                                        pq_release_remote(tcp_globals.net_phone,
    … …  
    11991192                                break;
    12001193                }
    1201 
    1202                 /* Release acknowledged */
     1194                // release acknowledged
    12031195                if (acknowledged) {
    12041196                        pq_release_remote(tcp_globals.net_phone,
    … …  
    12061198                }
    12071199                return;
    1208                 /* If the same as the previous time */
    1209         }
    1210 
     1200                // if the same as the previous time
     1201        }
    12111202        if (number == socket_data->expected) {
    1212                 /* Increase the counter */
     1203                // increase the counter
    12131204                socket_data->expected_count++;
    12141205                if (socket_data->expected_count == TCP_FAST_RETRANSMIT_COUNT) {
    12151206                        socket_data->expected_count = 1;
    1216                         /* TODO retransmit lock */
     1207                        // TODO retransmit lock
    12171208                        //tcp_retransmit_packet(socket, socket_data, number);
    12181209                }
    … …  
    13201311        while (keep_on_going) {
    13211312
    1322                 /* Answer the call */
     1313                // answer the call
    13231314                answer_call(callid, res, &answer, answer_count);
    1324                 /* Refresh data */
     1315                // refresh data
    13251316                refresh_answer(&answer, &answer_count);
    1326                 /* Get the next call */
     1317                // get the next call
    13271318                callid = async_get_call(&call);
    13281319
    1329                 /* Process the call */
     1320                // process the call
    13301321                switch (IPC_GET_METHOD(call)) {
    13311322                case IPC_M_PHONE_HUNGUP:
    … …  
    14101401                        if (res != EOK)
    14111402                                break;
    1412                         /*
    1413                          * The global lock may be released in the
    1414                          * tcp_connect_message() function.
    1415                          */
     1403                        // the global lock may be released in the
     1404                        // tcp_connect_message() function
    14161405                        fibril_rwlock_write_lock(&tcp_globals.lock);
    14171406                        fibril_rwlock_write_lock(&lock);
    … …  
    15271516        }
    15281517
    1529         /* Release the application phone */
     1518        // release the application phone
    15301519        ipc_hangup(app_phone);
    15311520
    15321521        printf("release\n");
    1533         /* Release all local sockets */
     1522        // release all local sockets
    15341523        socket_cores_release(tcp_globals.net_phone, &local_sockets,
    15351524            &tcp_globals.sockets, tcp_free_socket_data);
    … …  
    15471536        assert(timeout);
    15481537
    1549         /* Sleep the given timeout */
     1538        // sleep the given timeout
    15501539        async_usleep(timeout->timeout);
    1551         /* Lock the globals */
     1540        // lock the globals
    15521541        if (timeout->globals_read_only)
    15531542                fibril_rwlock_read_lock(&tcp_globals.lock);
    … …  
    15551544                fibril_rwlock_write_lock(&tcp_globals.lock);
    15561545
    1557         /* Find the pending operation socket */
     1546        // find the pending operation socket
    15581547        socket = socket_port_find(&tcp_globals.sockets, timeout->port,
    15591548            timeout->key, timeout->key_length);
    … …  
    15681557        fibril_rwlock_write_lock(socket_data->local_lock);
    15691558        if (timeout->sequence_number) {
    1570                 /* Increase the timeout counter */
     1559                // increase the timeout counter;
    15711560                socket_data->timeout_count++;
    15721561                if (socket_data->timeout_count == TCP_MAX_TIMEOUTS) {
    1573                         /* TODO release as connection lost */
     1562                        // TODO release as connection lost
    15741563                        //tcp_refresh_socket_data(socket_data);
    15751564                        fibril_rwlock_write_unlock(socket_data->local_lock);
    15761565                } else {
    1577                         /* Retransmit */
     1566                        // retransmit
    15781567//                      tcp_retransmit_packet(socket,
    15791568//                          socket_data, timeout->sequence_number);
    … …  
    15821571        } else {
    15831572                fibril_mutex_lock(&socket_data->operation.mutex);
    1584                 /* Set the timeout operation result if state not changed */
     1573                // set the timeout operation result if state not
     1574                // changed
    15851575                if (socket_data->state == timeout->state) {
    15861576                        socket_data->operation.result = ETIMEOUT;
    1587 
    1588                         /* Notify the main fibril */
     1577                        // notify the main fibril
    15891578                        fibril_condvar_signal(&socket_data->operation.condvar);
    1590 
    1591                         /* Keep the global write lock */
     1579                        // keep the global write lock
    15921580                        keep_write_lock = true;
    15931581                } else {
    1594                         /*
    1595                          * Operation is ok, do nothing.
    1596                          * Unlocking from now on, so the unlocking
    1597                          * order does not matter.
    1598                          */
     1582                        // operation is ok, do nothing
     1583                        // unlocking from now on, so the unlocki
     1584                        // order does not matter...
    15991585                        fibril_rwlock_write_unlock(socket_data->local_lock);
    16001586                }
    … …  
    16031589
    16041590out:
    1605         /* Unlock only if no socket */
     1591        // unlock only if no socket
    16061592        if (timeout->globals_read_only)
    16071593                fibril_rwlock_read_unlock(&tcp_globals.lock);
    16081594        else if (!keep_write_lock)
    1609                 /* Release if not desired */
     1595                // release if not desired
    16101596                fibril_rwlock_write_unlock(&tcp_globals.lock);
    16111597       
    1612         /* Release the timeout structure */
     1598        // release the timeout structure
    16131599        free(timeout);
    16141600        return EOK;
    … …  
    16241610        assert(timeout);
    16251611
    1626         /* Sleep the given timeout */
     1612        // sleep the given timeout
    16271613        async_usleep(timeout->timeout);
    1628 
    1629         /* Lock the globals */
     1614        // lock the globals
    16301615        fibril_rwlock_write_lock(&tcp_globals.lock);
    1631 
    1632         /* Find the pending operation socket */
     1616        // find the pending operation socket
    16331617        socket = socket_port_find(&tcp_globals.sockets, timeout->port,
    16341618            timeout->key, timeout->key_length);
    1635 
    16361619        if (socket && (socket->socket_id == timeout->socket_id)) {
    16371620                socket_data = (tcp_socket_data_ref) socket->specific_data;
    … …  
    16461629                }
    16471630        }
    1648 
    1649         /* Unlock the globals */
     1631        // unlock the globals
    16501632        fibril_rwlock_write_unlock(&tcp_globals.lock);
    1651 
    1652         /* Release the timeout structure */
     1633        // release the timeout structure
    16531634        free(timeout);
    1654 
    16551635        return EOK;
    16561636}
    16571637
    1658 void tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref
    1659     socket_data, size_t sequence_number)
     1638void
     1639tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
     1640    size_t sequence_number)
    16601641{
    16611642        packet_t packet;
    … …  
    16671648        assert(socket->specific_data == socket_data);
    16681649
    1669         /* Sent packet? */
     1650        // sent packet?
    16701651        packet = pq_find(socket_data->outgoing, sequence_number);
    16711652        printf("retransmit %d\n", packet_get_id(packet));
    … …  
    16831664}
    16841665
    1685 int tcp_listen_message(socket_cores_ref local_sockets, int socket_id,
    1686     int backlog)
     1666int
     1667tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog)
    16871668{
    16881669        socket_core_ref socket;
    … …  
    16941675                return EINVAL;
    16951676
    1696         /* Find the socket */
     1677        // find the socket
    16971678        socket = socket_cores_find(local_sockets, socket_id);
    16981679        if (!socket)
    16991680                return ENOTSOCK;
    17001681       
    1701         /* Get the socket specific data */
     1682        // get the socket specific data
    17021683        socket_data = (tcp_socket_data_ref) socket->specific_data;
    17031684        assert(socket_data);
    1704 
    1705         /* Set the backlog */
     1685        // set the backlog
    17061686        socket_data->backlog = backlog;
    17071687
    … …  
    17091689}
    17101690
    1711 int tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
     1691int
     1692tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
    17121693    struct sockaddr *addr, socklen_t addrlen)
    17131694{
    … …  
    17191700        assert(addrlen > 0);
    17201701
    1721         /* Find the socket */
     1702        // find the socket
    17221703        socket = socket_cores_find(local_sockets, socket_id);
    17231704        if (!socket)
    … …  
    17271708        if (rc != EOK) {
    17281709                tcp_free_socket_data(socket);
    1729                 /* Unbind if bound */
     1710                // unbind if bound
    17301711                if (socket->port > 0) {
    17311712                        socket_ports_exclude(&tcp_globals.sockets,
    … …  
    17371718}
    17381719
    1739 int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
     1720int
     1721tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
    17401722    struct sockaddr *addr, socklen_t addrlen)
    17411723{
    … …  
    17481730        assert(addrlen > 0);
    17491731
    1750         /* Get the socket specific data */
     1732        // get the socket specific data
    17511733        socket_data = (tcp_socket_data_ref) socket->specific_data;
    17521734        assert(socket_data);
    … …  
    17571739                return EINVAL;
    17581740
    1759         /* Get the destination port */
     1741        // get the destination port
    17601742        rc = tl_get_address_port(addr, addrlen, &socket_data->dest_port);
    17611743        if (rc != EOK)
    … …  
    17631745       
    17641746        if (socket->port <= 0) {
    1765                 /* Try to find a free port */
     1747                // try to find a free port
    17661748                rc = socket_bind_free_port(&tcp_globals.sockets, socket,
    17671749                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
    … …  
    17691751                if (rc != EOK)
    17701752                        return rc;
    1771                 /* Set the next port as the search starting port number */
     1753                // set the next port as the search starting port number
    17721754                tcp_globals.last_used_port = socket->port;
    17731755        }
    … …  
    17791761                return rc;
    17801762
    1781         /* Create the notification packet */
     1763        // create the notification packet
    17821764        rc = tcp_create_notification_packet(&packet, socket, socket_data, 1, 0);
    17831765        if (rc != EOK)
    17841766                return rc;
    17851767
    1786         /* Unlock the globals and wait for an operation */
     1768        // unlock the globals and wait for an operation
    17871769        fibril_rwlock_write_unlock(&tcp_globals.lock);
    17881770
    17891771        socket_data->addr = addr;
    17901772        socket_data->addrlen = addrlen;
    1791 
    1792         /* Send the packet */
     1773        // send the packet
    17931774
    17941775        if (((rc = tcp_queue_packet(socket, socket_data, packet, 1)) != EOK) ||
    … …  
    18041785                        fibril_mutex_lock(&socket_data->operation.mutex);
    18051786                        fibril_rwlock_write_unlock(socket_data->local_lock);
    1806 
    1807                         /* Send the packet */
     1787                        // send the packet
    18081788                        printf("connecting %d\n", packet_get_id(packet));
    18091789                        tcp_send_packets(socket_data->device_id, packet);
    18101790
    1811                         /* Wait for a reply */
     1791                        // wait for a reply
    18121792                        fibril_condvar_wait(&socket_data->operation.condvar,
    18131793                            &socket_data->operation.mutex);
    … …  
    18251805
    18261806        fibril_mutex_unlock(&socket_data->operation.mutex);
     1807
     1808        // return the result
    18271809        return rc;
    18281810}
    18291811
    1830 int tcp_queue_prepare_packet(socket_core_ref socket,
     1812int
     1813tcp_queue_prepare_packet(socket_core_ref socket,
    18311814    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length)
    18321815{
    … …  
    18381821        assert(socket->specific_data == socket_data);
    18391822
    1840         /* Get TCP header */
     1823        // get tcp header
    18411824        header = (tcp_header_ref) packet_get_data(packet);
    18421825        if (!header)
    … …  
    18521835                return tcp_release_and_return(packet, EINVAL);
    18531836
    1854         /* Remember the outgoing FIN */
     1837        // remember the outgoing FIN
    18551838        if (header->finalize)
    18561839                socket_data->fin_outgoing = socket_data->next_outgoing;
    … …  
    18591842}
    18601843
    1861 int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
     1844int
     1845tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
    18621846    packet_t packet, size_t data_length)
    18631847{
    … …  
    18811865}
    18821866
    1883 packet_t tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref
    1884     socket_data)
     1867packet_t
     1868tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data)
    18851869{
    18861870        packet_t packet;
    … …  
    18991883                pq_get_order(packet, NULL, &data_length);
    19001884
    1901                 /*
    1902                  * Send only if fits into the window, respecting the possible
    1903                  * overflow.
    1904                  */
     1885                // send only if fits into the window
     1886                // respecting the possible overflow
    19051887                if (!IS_IN_INTERVAL_OVERFLOW(
    19061888                    (uint32_t) socket_data->last_outgoing,
    … …  
    19271909                previous = copy;
    19281910                packet = pq_next(packet);
    1929 
    1930                 /* Overflow occurred? */
     1911                // overflow occurred ?
    19311912                if (!packet &&
    19321913                    (socket_data->last_outgoing > socket_data->next_outgoing)) {
    19331914                        printf("gpts overflow\n");
    1934                         /* Continue from the beginning */
     1915                        // continue from the beginning
    19351916                        packet = socket_data->outgoing;
    19361917                }
    … …  
    19411922}
    19421923
    1943 packet_t tcp_send_prepare_packet(socket_core_ref socket, tcp_socket_data_ref
    1944     socket_data, packet_t packet, size_t data_length, size_t sequence_number)
     1924packet_t
     1925tcp_send_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
     1926    packet_t packet, size_t data_length, size_t sequence_number)
    19451927{
    19461928        tcp_header_ref header;
    … …  
    19521934        assert(socket->specific_data == socket_data);
    19531935
    1954         /* Adjust the pseudo header */
     1936        // adjust the pseudo header
    19551937        rc = ip_client_set_pseudo_header_data_length(socket_data->pseudo_header,
    19561938            socket_data->headerlen, packet_get_data_length(packet));
    … …  
    19601942        }
    19611943
    1962         /* Get the header */
     1944        // get the header
    19631945        header = (tcp_header_ref) packet_get_data(packet);
    19641946        if (!header) {
    … …  
    19681950        assert(ntohl(header->sequence_number) == sequence_number);
    19691951
    1970         /* Adjust the header */
     1952        // adjust the header
    19711953        if (socket_data->next_incoming) {
    19721954                header->acknowledgement_number =
    … …  
    19761958        header->window = htons(socket_data->window);
    19771959
    1978         /* Checksum */
     1960        // checksum
    19791961        header->checksum = 0;
    19801962        checksum = compute_checksum(0, socket_data->pseudo_header,
    … …  
    19851967        header->checksum = htons(flip_checksum(compact_checksum(checksum)));
    19861968
    1987         /* Prepare the packet */
     1969        // prepare the packet
    19881970        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
    19891971        if (rc != EOK) {
    … …  
    19911973                return NULL;
    19921974        }
    1993 
    19941975        rc = tcp_prepare_timeout(tcp_timeout, socket, socket_data,
    19951976            sequence_number, socket_data->state, socket_data->timeout, true);
    … …  
    20021983}
    20031984
    2004 packet_t tcp_prepare_copy(socket_core_ref socket, tcp_socket_data_ref
    2005     socket_data, packet_t packet, size_t data_length, size_t sequence_number)
     1985packet_t
     1986tcp_prepare_copy(socket_core_ref socket, tcp_socket_data_ref socket_data,
     1987    packet_t packet, size_t data_length, size_t sequence_number)
    20061988{
    20071989        packet_t copy;
    … …  
    20111993        assert(socket->specific_data == socket_data);
    20121994
    2013         /* Make a copy of the packet */
     1995        // make a copy of the packet
    20141996        copy = packet_get_copy(tcp_globals.net_phone, packet);
    20151997        if (!copy)
    … …  
    20322014}
    20332015
    2034 void tcp_prepare_operation_header(socket_core_ref socket,
     2016void
     2017tcp_prepare_operation_header(socket_core_ref socket,
    20352018    tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize,
    20362019    int finalize)
    … …  
    20492032}
    20502033
    2051 int tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
     2034int
     2035tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
    20522036    socket_core_ref socket, tcp_socket_data_ref socket_data,
    20532037    size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout,
    … …  
    20612045        assert(socket->specific_data == socket_data);
    20622046
    2063         /* Prepare the timeout with key bundle structure */
     2047        // prepare the timeout with key bundle structure
    20642048        operation_timeout = malloc(sizeof(*operation_timeout) +
    20652049            socket->key_length + 1);
    … …  
    20762060        operation_timeout->state = state;
    20772061
    2078         /* Copy the key */
     2062        // copy the key
    20792063        operation_timeout->key = ((char *) operation_timeout) +
    20802064            sizeof(*operation_timeout);
    … …  
    20832067        operation_timeout->key[operation_timeout->key_length] = '\0';
    20842068
    2085         /* Prepare the timeouting thread */
     2069        // prepare the timeouting thread
    20862070        fibril = fibril_create(timeout_function, operation_timeout);
    20872071        if (!fibril) {
    … …  
    20902074        }
    20912075//      fibril_mutex_lock(&socket_data->operation.mutex);
    2092         /* Start the timeout fibril */
     2076        // start the timeouting fibril
    20932077        fibril_add_ready(fibril);
    20942078        //socket_data->state = state;
    … …  
    20962080}
    20972081
    2098 int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id,
    2099     int flags, size_t *addrlen)
     2082int
     2083tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags,
     2084    size_t *addrlen)
    21002085{
    21012086        socket_core_ref socket;
    … …  
    21082093        assert(local_sockets);
    21092094
    2110         /* Find the socket */
     2095        // find the socket
    21112096        socket = socket_cores_find(local_sockets, socket_id);
    21122097        if (!socket)
    21132098                return ENOTSOCK;
    21142099
    2115         /* Get the socket specific data */
     2100        // get the socket specific data
    21162101        if (!socket->specific_data)
    21172102                return NO_DATA;
    … …  
    21192104        socket_data = (tcp_socket_data_ref) socket->specific_data;
    21202105
    2121         /* Check state */
     2106        // check state
    21222107        if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
    21232108            (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
    21242109                return ENOTCONN;
    21252110
    2126         /* Send the source address if desired */
     2111        // send the source address if desired
    21272112        if (addrlen) {
    21282113                rc = data_reply(socket_data->addr, socket_data->addrlen);
    … …  
    21322117        }
    21332118
    2134         /* Get the next received packet */
     2119        // get the next received packet
    21352120        packet_id = dyn_fifo_value(&socket->received);
    21362121        if (packet_id < 0)
    … …  
    21412126                return rc;
    21422127
    2143         /* Reply the packets */
     2128        // reply the packets
    21442129        rc = socket_reply_packets(packet, &length);
    21452130        if (rc != EOK)
    21462131                return rc;
    21472132
    2148         /* Release the packet */
     2133        // release the packet
    21492134        dyn_fifo_pop(&socket->received);
    21502135        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    2151 
    2152         /* Return the total length */
     2136        // return the total length
    21532137        return (int) length;
    21542138}
    21552139
    2156 int tcp_send_message(socket_cores_ref local_sockets, int socket_id,
    2157     int fragments, size_t *data_fragment_size, int flags)
     2140int
     2141tcp_send_message(socket_cores_ref local_sockets, int socket_id, int fragments,
     2142    size_t *data_fragment_size, int flags)
    21582143{
    21592144        socket_core_ref socket;
    … …  
    21702155        assert(data_fragment_size);
    21712156
    2172         /* Find the socket */
     2157        // find the socket
    21732158        socket = socket_cores_find(local_sockets, socket_id);
    21742159        if (!socket)
    21752160                return ENOTSOCK;
    21762161
    2177         /* Get the socket specific data */
     2162        // get the socket specific data
    21782163        if (!socket->specific_data)
    21792164                return NO_DATA;
    … …  
    21812166        socket_data = (tcp_socket_data_ref) socket->specific_data;
    21822167
    2183         /* Check state */
     2168        // check state
    21842169        if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
    21852170            (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
    … …  
    21962181
    21972182        for (index = 0; index < fragments; index++) {
    2198                 /* Read the data fragment */
     2183                // read the data fragment
    21992184                result = tl_socket_read_packet_data(tcp_globals.net_phone,
    22002185                    &packet, TCP_HEADER_SIZE, packet_dimension,
    … …  
    22042189
    22052190                total_length = (size_t) result;
    2206 
    2207                 /* Prefix the TCP header */
     2191                // prefix the tcp header
    22082192                header = PACKET_PREFIX(packet, tcp_header_t);
    22092193                if (!header)
    … …  
    22162200        }
    22172201
    2218         /* Flush packets */
     2202        // flush packets
    22192203        packet = tcp_get_packets_to_send(socket, socket_data);
    22202204        fibril_rwlock_write_unlock(socket_data->local_lock);
    … …  
    22222206
    22232207        if (packet) {
    2224                 /* Send the packet */
     2208                // send the packet
    22252209                tcp_send_packets(socket_data->device_id, packet);
    22262210        }
    … …  
    22372221        int rc;
    22382222
    2239         /* Find the socket */
     2223        // find the socket
    22402224        socket = socket_cores_find(local_sockets, socket_id);
    22412225        if (!socket)
    22422226                return ENOTSOCK;
    22432227
    2244         /* Get the socket specific data */
     2228        // get the socket specific data
    22452229        socket_data = (tcp_socket_data_ref) socket->specific_data;
    22462230        assert(socket_data);
    22472231
    2248         /* Check state */
     2232        // check state
    22492233        switch (socket_data->state) {
    22502234        case TCP_SOCKET_ESTABLISHED:
    … …  
    22592243
    22602244        default:
    2261                 /* Just destroy */
     2245                // just destroy
    22622246                rc = socket_destroy(tcp_globals.net_phone, socket_id,
    22632247                    local_sockets, &tcp_globals.sockets,
    … …  
    22702254        }
    22712255
    2272         /*
    2273          * Send FIN.
    2274          * TODO should I wait to complete?
    2275          */
    2276 
    2277         /* Create the notification packet */
     2256        // send FIN
     2257        // TODO should I wait to complete?
     2258
     2259        // create the notification packet
    22782260        rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
    22792261        if (rc != EOK)
    22802262                return rc;
    22812263
    2282         /* Send the packet */
     2264        // send the packet
    22832265        rc = tcp_queue_packet(socket, socket_data, packet, 1);
    22842266        if (rc != EOK)
    22852267                return rc;
    22862268
    2287         /* Flush packets */
     2269        // flush packets
    22882270        packet = tcp_get_packets_to_send(socket, socket_data);
    22892271        fibril_rwlock_write_unlock(socket_data->local_lock);
    … …  
    22912273
    22922274        if (packet) {
    2293                 /* Send the packet */
     2275                // send the packet
    22942276                tcp_send_packets(socket_data->device_id, packet);
    22952277        }
    … …  
    22982280}
    22992281
    2300 int tcp_create_notification_packet(packet_t *packet, socket_core_ref socket,
     2282int
     2283tcp_create_notification_packet(packet_t *packet, socket_core_ref socket,
    23012284    tcp_socket_data_ref socket_data, int synchronize, int finalize)
    23022285{
    … …  
    23072290        assert(packet);
    23082291
    2309         /* Get the device packet dimension */
     2292        // get the device packet dimension
    23102293        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    23112294            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    … …  
    23132296                return rc;
    23142297
    2315         /* Get a new packet */
     2298        // get a new packet
    23162299        *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
    23172300            packet_dimension->addr_len, packet_dimension->prefix,
    … …  
    23212304                return ENOMEM;
    23222305
    2323         /* Allocate space in the packet */
     2306        // allocate space in the packet
    23242307        header = PACKET_SUFFIX(*packet, tcp_header_t);
    23252308        if (!header)
    … …  
    23322315}
    23332316
    2334 int tcp_accept_message(socket_cores_ref local_sockets, int socket_id,
     2317int
     2318tcp_accept_message(socket_cores_ref local_sockets, int socket_id,
    23352319    int new_socket_id, size_t *data_fragment_size, size_t *addrlen)
    23362320{
    … …  
    23452329        assert(addrlen);
    23462330
    2347         /* Find the socket */
     2331        // find the socket
    23482332        socket = socket_cores_find(local_sockets, socket_id);
    23492333        if (!socket)
    23502334                return ENOTSOCK;
    23512335
    2352         /* Get the socket specific data */
     2336        // get the socket specific data
    23532337        socket_data = (tcp_socket_data_ref) socket->specific_data;
    23542338        assert(socket_data);
    23552339
    2356         /* Check state */
     2340        // check state
    23572341        if (socket_data->state != TCP_SOCKET_LISTEN)
    23582342                return EINVAL;
    … …  
    23682352                        return ENOTSOCK;
    23692353
    2370                 /* Get the socket specific data */
     2354                // get the socket specific data
    23712355                socket_data = (tcp_socket_data_ref) accepted->specific_data;
    23722356                assert(socket_data);
    2373                 /* TODO can it be in another state? */
     2357                // TODO can it be in another state?
    23742358                if (socket_data->state == TCP_SOCKET_ESTABLISHED) {
    23752359                        rc = data_reply(socket_data->addr,
    … …  
    24052389}
    24062390
    2407 void tcp_free_socket_data(socket_core_ref socket)
     2391void
     2392tcp_free_socket_data(socket_core_ref socket)
    24082393{
    24092394        tcp_socket_data_ref socket_data;
    … …  
    24132398        printf("destroy_socket %d\n", socket->socket_id);
    24142399
    2415         /* Get the socket specific data */
     2400        // get the socket specific data
    24162401        socket_data = (tcp_socket_data_ref) socket->specific_data;
    24172402        assert(socket_data);
    2418 
    2419         /* Free the pseudo header */
     2403        //free the pseudo header
    24202404        if (socket_data->pseudo_header) {
    24212405                if (socket_data->headerlen) {
    … …  
    24262410                socket_data->pseudo_header = NULL;
    24272411        }
    2428 
    24292412        socket_data->headerlen = 0;
    2430 
    2431         /* Free the address */
     2413        // free the address
    24322414        if (socket_data->addr) {
    24332415                if (socket_data->addrlen) {
    … …  
    24912473
    24922474                /*
    2493                  * Answer the message
     2475                   Answer the message
    24942476                 */
    24952477                answer_call(callid, res, &answer, answer_count);

  • uspace/srv/net/tl/tcp/tcp_module.c

    r8e189ef r982e3d8  
    8686}
    8787
    88 int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     88int
     89tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    8990    ipc_call_t *answer, int *answer_count)
    9091{

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

    r8e189ef r982e3d8  
    130130        }
    131131
    132         /* Read default packet dimensions */
     132        // read default packet dimensions
    133133        rc = ip_packet_size_req(udp_globals.ip_phone, -1,
    134134            &udp_globals.packet_dimension);
    … …  
    158158        udp_globals.autobinding = NET_DEFAULT_UDP_AUTOBINDING;
    159159
    160         /* Get configuration */
     160        // get configuration
    161161        configuration = &names[0];
    162162        rc = net_get_conf_req(udp_globals.net_phone, &configuration, count,
    … …  
    217217 *                      ip_client_process_packet() function.
    218218 */
    219 static int udp_process_packet(device_id_t device_id, packet_t packet,
    220     services_t error)
     219static int
     220udp_process_packet(device_id_t device_id, packet_t packet, services_t error)
    221221{
    222222        size_t length;
    … …  
    242242                break;
    243243        case SERVICE_ICMP:
    244                 /* Ignore error */
     244                // ignore error
    245245                // length = icmp_client_header_length(packet);
    246 
    247                 /* Process error */
     246                // process error
    248247                result = icmp_client_process_packet(packet, &type,
    249248                    &code, NULL, NULL);
    … …  
    259258        }
    260259
    261         /* TODO process received ipopts? */
     260        // TODO process received ipopts?
    262261        result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL);
    263262        if (result < 0)
    … …  
    271270                return udp_release_and_return(packet, NO_DATA);
    272271
    273         /* Trim all but UDP header */
     272        // trim all but UDP header
    274273        rc = packet_trim(packet, offset, 0);
    275274        if (rc != EOK)
    276275                return udp_release_and_return(packet, rc);
    277276
    278         /* Get UDP header */
     277        // get udp header
    279278        header = (udp_header_ref) packet_get_data(packet);
    280279        if (!header)
    281280                return udp_release_and_return(packet, NO_DATA);
    282281
    283         /* Find the destination socket */
     282        // find the destination socket
    284283        socket = socket_port_find(&udp_globals.sockets,
    285284        ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING, 0);
    … …  
    293292        }
    294293
    295         /* Count the received packet fragments */
     294        // count the received packet fragments
    296295        next_packet = packet;
    297296        fragments = 0;
    298297        total_length = ntohs(header->total_length);
    299298
    300         /* Compute header checksum if set */
     299        // compute header checksum if set
    301300        if (header->checksum && !error) {
    302301                result = packet_get_addr(packet, (uint8_t **) &src,
    … …  
    311310                } else {
    312311                        checksum = compute_checksum(0, ip_header, length);
    313                         /*
    314                          * The udp header checksum will be added with the first
    315                          * fragment later.
    316                          */
     312                        // the udp header checksum will be added with the first
     313                        // fragment later
    317314                        free(ip_header);
    318315                }
    … …  
    333330                                return udp_release_and_return(packet, rc);
    334331
    335                         /* Add partial checksum if set */
     332                        // add partial checksum if set
    336333                        if (header->checksum) {
    337334                                checksum = compute_checksum(checksum,
    … …  
    340337                        }
    341338
    342                         /* Relese the rest of the packet fragments */
     339                        // relese the rest of the packet fragments
    343340                        tmp_packet = pq_next(next_packet);
    344341                        while (tmp_packet) {
    … …  
    349346                        }
    350347
    351                         /* Exit the loop */
     348                        // exit the loop
    352349                        break;
    353350                }
    354351                total_length -= length;
    355352
    356                 /* Add partial checksum if set */
     353                // add partial checksum if set
    357354                if (header->checksum) {
    358355                        checksum = compute_checksum(checksum,
    … …  
    363360        } while ((next_packet = pq_next(next_packet)) && (total_length > 0));
    364361
    365         /* Verify checksum */
     362        // check checksum
    366363        if (header->checksum) {
    367364                if (flip_checksum(compact_checksum(checksum)) !=
    … …  
    369366                        if (tl_prepare_icmp_packet(udp_globals.net_phone,
    370367                            udp_globals.icmp_phone, packet, error) == EOK) {
    371                                 /* Checksum error ICMP */
     368                                // checksum error ICMP
    372369                                icmp_parameter_problem_msg(
    373370                                    udp_globals.icmp_phone, ICMP_PARAM_POINTER,
    … …  
    379376        }
    380377
    381         /* Queue the received packet */
     378        // queue the received packet
    382379        rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
    383380            SOCKET_MAX_RECEIVED_SIZE);
    … …  
    390387                return udp_release_and_return(packet, rc);
    391388
    392         /* Notify the destination socket */
     389        // notify the destination socket
    393390        fibril_rwlock_write_unlock(&udp_globals.lock);
    394391        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    … …  
    413410 *                      udp_process_packet() function.
    414411 */
    415 static int udp_received_msg(device_id_t device_id, packet_t packet,
    416     services_t receiver, services_t error)
     412static int
     413udp_received_msg(device_id_t device_id, packet_t packet, services_t receiver,
     414    services_t error)
    417415{
    418416        int result;
    … …  
    453451 *                      function.
    454452 */
    455 static int udp_sendto_message(socket_cores_ref local_sockets, int socket_id,
     453static int
     454udp_sendto_message(socket_cores_ref local_sockets, int socket_id,
    456455    const struct sockaddr *addr, socklen_t addrlen, int fragments,
    457456    size_t *data_fragment_size, int flags)
    … …  
    481480
    482481        if ((socket->port <= 0) && udp_globals.autobinding) {
    483                 /* Bind the socket to a random free port if not bound */
     482                // bind the socket to a random free port if not bound
    484483                rc = socket_bind_free_port(&udp_globals.sockets, socket,
    485484                    UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
    … …  
    487486                if (rc != EOK)
    488487                        return rc;
    489                 /* Set the next port as the search starting port number */
     488                // set the next port as the search starting port number
    490489                udp_globals.last_used_port = socket->port;
    491490        }
    … …  
    496495                if (rc != EOK)
    497496                        return rc;
    498                 /* Get the device packet dimension */
     497                // get the device packet dimension
    499498//              rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
    500499//                  &udp_globals.dimensions, device_id, &packet_dimension);
    … …  
    503502        }
    504503//      } else {
    505                 /* Do not ask all the time */
     504                // do not ask all the time
    506505                rc = ip_packet_size_req(udp_globals.ip_phone, -1,
    507506                    &udp_globals.packet_dimension);
    … …  
    511510//      }
    512511
    513         /* Read the first packet fragment */
     512        // read the first packet fragment
    514513        result = tl_socket_read_packet_data(udp_globals.net_phone, &packet,
    515514            UDP_HEADER_SIZE, packet_dimension, addr, addrlen);
    … …  
    524523                checksum = 0;
    525524
    526         /* Prefix the UDP header */
     525        // prefix the udp header
    527526        header = PACKET_PREFIX(packet, udp_header_t);
    528527        if (!header)
    … …  
    530529
    531530        bzero(header, sizeof(*header));
    532 
    533         /* Read the rest of the packet fragments */
     531        // read the rest of the packet fragments
    534532        for (index = 1; index < fragments; index++) {
    535533                result = tl_socket_read_packet_data(udp_globals.net_phone,
    … …  
    550548        }
    551549
    552         /* Set the UDP header */
     550        // set the udp header
    553551        header->source_port = htons((socket->port > 0) ? socket->port : 0);
    554552        header->destination_port = htons(dest_port);
    555553        header->total_length = htons(total_length + sizeof(*header));
    556554        header->checksum = 0;
    557 
    558555        if (udp_globals.checksum_computing) {
    559                 /* Update the pseudo header */
     556                // update the pseudo header
    560557                rc = ip_client_set_pseudo_header_data_length(ip_header,
    561558                    headerlen, total_length + UDP_HEADER_SIZE);
    … …  
    565562                }
    566563
    567                 /* Finish the checksum computation */
     564                // finish the checksum computation
    568565                checksum = compute_checksum(checksum, ip_header, headerlen);
    569566                checksum = compute_checksum(checksum, (uint8_t *) header,
    … …  
    576573        }
    577574
    578         /* Prepare the first packet fragment */
     575        // prepare the first packet fragment
    579576        rc = ip_client_prepare_packet(packet, IPPROTO_UDP, 0, 0, 0, 0);
    580577        if (rc != EOK)
    … …  
    584581        fibril_rwlock_write_unlock(&udp_globals.lock);
    585582
    586         /* Send the packet */
     583        // send the packet
    587584        ip_send_msg(udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0);
    588585
    … …  
    609606 *                      function.
    610607 */
    611 static int udp_recvfrom_message(socket_cores_ref local_sockets, int socket_id,
    612     int flags, size_t *addrlen)
     608static int
     609udp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags,
     610    size_t *addrlen)
    613611{
    614612        socket_core_ref socket;
    … …  
    622620        int rc;
    623621
    624         /* Find the socket */
     622        // find the socket
    625623        socket = socket_cores_find(local_sockets, socket_id);
    626624        if (!socket)
    627625                return ENOTSOCK;
    628626
    629         /* Get the next received packet */
     627        // get the next received packet
    630628        packet_id = dyn_fifo_value(&socket->received);
    631629        if (packet_id < 0)
    … …  
    638636        }
    639637
    640         /* Get UDP header */
     638        // get udp header
    641639        data = packet_get_data(packet);
    642640        if (!data) {
    … …  
    646644        header = (udp_header_ref) data;
    647645
    648         /* Set the source address port */
     646        // set the source address port
    649647        result = packet_get_addr(packet, (uint8_t **) &addr, NULL);
    650648        rc = tl_set_address_port(addr, result, ntohs(header->source_port));
    … …  
    655653        *addrlen = (size_t) result;
    656654
    657         /* Send the source address */
     655        // send the source address
    658656        rc = data_reply(addr, *addrlen);
    659657        switch (rc) {
    … …  
    667665        }
    668666
    669         /* Trim the header */
     667        // trim the header
    670668        rc = packet_trim(packet, UDP_HEADER_SIZE, 0);
    671669        if (rc != EOK) {
    … …  
    674672        }
    675673
    676         /* Reply the packets */
     674        // reply the packets
    677675        rc = socket_reply_packets(packet, &length);
    678676        switch (rc) {
    … …  
    688686        (void) dyn_fifo_pop(&socket->received);
    689687
    690         /* Release the packet and return the total length */
     688        // release the packet and return the total length
    691689        return udp_release_and_return(packet, (int) length);
    692690}
    … …  
    723721        answer_count = 0;
    724722
    725         /*
    726          * The client connection is only in one fibril and therefore no
    727          * additional locks are needed.
    728          */
     723        // The client connection is only in one fibril and therefore no
     724        // additional locks are needed.
    729725
    730726        socket_cores_initialize(&local_sockets);
    … …  
    732728        while (keep_on_going) {
    733729
    734                 /* Answer the call */
     730                // answer the call
    735731                answer_call(callid, res, &answer, answer_count);
    736732
    737                 /* Refresh data */
     733                // refresh data
    738734                refresh_answer(&answer, &answer_count);
    739735
    740                 /* Get the next call */
     736                // get the next call
    741737                callid = async_get_call(&call);
    742738
    743                 /* Process the call */
     739                // process the call
    744740                switch (IPC_GET_METHOD(call)) {
    745741                case IPC_M_PHONE_HUNGUP:
    … …  
    835831        }
    836832
    837         /* Release the application phone */
     833        // release the application phone
    838834        ipc_hangup(app_phone);
    839835
    840         /* Release all local sockets */
     836        // release all local sockets
    841837        socket_cores_release(udp_globals.net_phone, &local_sockets,
    842838            &udp_globals.sockets, NULL);
    … …  
    858854 * @see IS_NET_UDP_MESSAGE()
    859855 */
    860 int udp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     856int
     857udp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    861858    ipc_call_t *answer, int *answer_count)
    862859{

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

    r8e189ef r982e3d8  
    8686}
    8787
    88 int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     88int
     89tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    8990    ipc_call_t *answer, int *answer_count)
    9091{
Note: See TracChangeset for help on using the changeset viewer.