Changeset db71e2a in mainline for uspace/app


Ignore:
Timestamp:
2013-07-24T17:42:25Z (12 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
69b264a9
Parents:
52f1882 (diff), cffa14e6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge mainline changes.

usb hc macro changes from mainline were reverted, too many conflicts

Location:
uspace/app
Files:
7 added
4 deleted
48 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/Makefile

    r52f1882 rdb71e2a  
    2929
    3030USPACE_PREFIX = ../..
    31 LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBCLUI_PREFIX)/libclui.a \
    32         $(LIBFMTUTIL_PREFIX)/libfmtutil.a
    33 EXTRA_CFLAGS = -I$(LIBBLOCK_PREFIX) -I$(LIBCLUI_PREFIX) \
    34         -I$(LIBFMTUTIL_PREFIX) -I. -Icmds/ -Icmds/builtins -Icmds/modules
     31LIBS = $(LIBCLUI_PREFIX)/libclui.a $(LIBFMTUTIL_PREFIX)/libfmtutil.a
     32EXTRA_CFLAGS = -I$(LIBCLUI_PREFIX) -I$(LIBFMTUTIL_PREFIX) \
     33        -I. -Icmds/ -Icmds/builtins -Icmds/modules
    3534BINARY = bdsh
    3635
    … …  
    4039        cmds/modules/mkfile/mkfile.c \
    4140        cmds/modules/rm/rm.c \
    42         cmds/modules/bdd/bdd.c \
    4341        cmds/modules/cat/cat.c \
    4442        cmds/modules/touch/touch.c \

  • uspace/app/bdsh/cmds/builtins/batch/batch.c

    r52f1882 rdb71e2a  
    2929#include <stdio.h>
    3030#include <stdlib.h>
     31#include <stdbool.h>
     32#include <errno.h>
    3133#include "config.h"
    3234#include "util.h"
    … …  
    4446        if (level == HELP_SHORT) {
    4547                printf(
    46                 "\n  batch [filename]\n"
     48                "\n  batch [filename] [-c]\n"
    4749                "  Issues commands stored in the file.\n"
    4850                "  Each command must correspond to the single line in the file.\n\n");
    … …  
    5456                "  separate groups of commands. There is no support for comments,\n"
    5557                "  variables, recursion or other programming constructs - the `batch'\n"
    56                 "  command is indeed very trivial.\n\n");
     58                "  command is indeed very trivial.\n"
     59                "  If the filename is followed by -c, execution continues even if some\n"
     60                "  of the commands failed.\n\n");
    5761        }
    5862
    … …  
    6569{
    6670        unsigned int argc;
     71        bool continue_despite_errors = false;
    6772
    6873        /* Count the arguments */
    … …  
    7277                printf("%s - no input file provided.\n", cmdname);
    7378                return CMD_FAILURE;
     79        }
     80
     81        if (argc > 2) {
     82                if (str_cmp(argv[2], "-c") == 0)
     83                        continue_despite_errors = true;
    7484        }
    7585
    … …  
    99109                                        rc = process_input(&fusr);
    100110                                        /* fusr->line was freed by process_input() */
     111                                        if ((rc != EOK) && continue_despite_errors) {
     112                                                /* Mute the error. */
     113                                                rc = EOK;
     114                                        }
    101115                                }
    102116                                if (rc == 0 && c != EOF) {

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

    r52f1882 rdb71e2a  
    6363static bool should_quit = false;
    6464static bool dash_represents_stdin = false;
     65static unsigned int lineno = 0;
     66static bool number = false;
     67static bool last_char_was_newline = false;
    6568
    6669static console_ctrl_t *console = NULL;
    … …  
    7578        { "hex", no_argument, 0, 'x' },
    7679        { "stdin", no_argument, 0, 's' },
     80        { "number", no_argument, 0, 'n' },
    7781        { 0, 0, 0, 0 }
    7882};
    … …  
    9599                "  -m, --more       Pause after each screen full\n"
    96100                "  -x, --hex        Print bytes as hex values\n"
    97                 "  -s  --stdin      Treat `-' in file list as standard input\n"
     101                "  -s, --stdin      Treat `-' in file list as standard input\n"
     102                "  -n, --number     Number all output lines\n"
    98103                "Currently, %s is under development, some options don't work.\n",
    99104                cmdname, cmdname);
    … …  
    117122static void waitkey()
    118123{
    119         kbd_event_t ev;
     124        cons_event_t ev;
     125        kbd_event_t *kev;
    120126       
    121127        while (true) {
    122                 if (!console_get_kbd_event(console, &ev)) {
     128                if (!console_get_event(console, &ev)) {
    123129                        return;
    124130                }
    125                 if (ev.type == KEY_PRESS) {
    126                         if (ev.key == KC_ESCAPE || ev.key == KC_Q) {
     131                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
     132                        kev = &ev.ev.key;
     133                       
     134                        if (kev->key == KC_ESCAPE || kev->key == KC_Q) {
    127135                                should_quit = true;
    128136                                return;
    129137                        }
    130                         if (ev.key == KC_C) {
     138                        if (kev->key == KC_C) {
    131139                                paging_enabled = false;
    132140                                return;
    133141                        }
    134                         if (ev.key == KC_ENTER || ev.key == KC_SPACE ||
    135                             ev.key == KC_PAGE_DOWN) {
     142                        if (kev->key == KC_ENTER || kev->key == KC_SPACE ||
     143                            kev->key == KC_PAGE_DOWN) {
    136144                                return;
    137145                        }
    … …  
    150158static void paged_char(wchar_t c)
    151159{
     160        if (last_char_was_newline && number) {
     161                lineno++;
     162                printf("%6u  ", lineno);
     163        }
    152164        putchar(c);
     165        last_char_was_newline = c == '\n';
    153166        if (paging_enabled) {
    154167                chars_remaining--;
    … …  
    303316        should_quit = false;
    304317        console = console_init(stdin, stdout);
     318        number = false;
     319        lineno = 0;
     320        /* This enables printing of the first number. */
     321        last_char_was_newline = true;
     322
    305323
    306324        argc = cli_count_args(argv);
    307325
    308326        for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
    309                 c = getopt_long(argc, argv, "xhvmH:t:b:s", long_options, &opt_ind);
     327                c = getopt_long(argc, argv, "xhvmH:t:b:s:n", long_options, &opt_ind);
    310328                switch (c) {
    311329                case 'h':
    … …  
    344362                        dash_represents_stdin = true;
    345363                        break;
     364                case 'n':
     365                        number = true;
     366                        break;
    346367                }
    347368        }

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

    r52f1882 rdb71e2a  
    107107
    108108                if (offset[0] != offset[1] ||
    109                     bcmp(buffer[0], buffer[1], offset[0])) {
     109                    memcmp(buffer[0], buffer[1], offset[0]) != 0) {
    110110                        rc = 1;
    111111                        goto end;

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

    r52f1882 rdb71e2a  
    152152
    153153        while (true) {
    154                 kbd_event_t ev;
     154                cons_event_t ev;
    155155                console_flush(con);
    156                 console_get_kbd_event(con, &ev);
    157                 if ((ev.type != KEY_PRESS)
    158                     || (ev.mods & (KM_CTRL | KM_ALT)) != 0) {
     156                console_get_event(con, &ev);
     157                if (ev.type != CEV_KEY || ev.ev.key.type != KEY_PRESS ||
     158                    (ev.ev.key.mods & (KM_CTRL | KM_ALT)) != 0) {
    159159                        continue;
    160160                }
    161161
    162                 switch(ev.key) {
     162                switch(ev.ev.key.key) {
    163163                case KC_Y:
    164164                        printf("y\n");

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

    r52f1882 rdb71e2a  
    9898        builtin_t *cmd;
    9999        module_t *mod;
    100         unsigned int i;
    101100
    102101        printf("\n  Bdsh built-in commands:\n");
    … …  
    104103
    105104        /* First, show a list of built in commands that are available in this mode */
    106         for (cmd = builtins; cmd->name != NULL; cmd++, i++) {
     105        for (cmd = builtins; cmd->name != NULL; cmd++) {
    107106                        if (is_builtin_alias(cmd->name))
    108107                                printf("   %-16s\tAlias for `%s'\n", cmd->name,
    … …  
    112111        }
    113112
    114         i = 0;
    115 
    116113        /* Now, show a list of module commands that are available in this mode */
    117         for (mod = modules; mod->name != NULL; mod++, i++) {
     114        for (mod = modules; mod->name != NULL; mod++) {
    118115                        if (is_module_alias(mod->name))
    119116                                printf("   %-16s\tAlias for `%s'\n", mod->name,

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

    r52f1882 rdb71e2a  
    315315{
    316316        if (stat(path, &de->s)) {
    317                 cli_error(CL_ENOENT, path);
     317                cli_error(CL_ENOENT, "%s", path);
    318318                return LS_BOGUS;
    319319        }

  • uspace/app/bdsh/cmds/modules/modules.h

    r52f1882 rdb71e2a  
    5050#include "mkfile/entry.h"
    5151#include "rm/entry.h"
    52 #include "bdd/entry.h"
    5352#include "cat/entry.h"
    5453#include "touch/entry.h"
    … …  
    7473#include "mkfile/mkfile_def.h"
    7574#include "rm/rm_def.h"
    76 #include "bdd/bdd_def.h"
    7775#include "cat/cat_def.h"
    7876#include "touch/touch_def.h"

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

    r52f1882 rdb71e2a  
    5555        }
    5656
    57         memset(buff, 0, sizeof(buff));
     57        memset(buff, 0, PATH_MAX);
    5858        getcwd(buff, PATH_MAX);
    5959

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

    r52f1882 rdb71e2a  
    9999        if (NULL == (rm->nwd = (char *) malloc(PATH_MAX)))
    100100                return 0;
    101         memset(rm->nwd, 0, sizeof(rm->nwd));
     101        memset(rm->nwd, 0, PATH_MAX);
    102102
    103103        if (NULL == (rm->owd = (char *) malloc(PATH_MAX)))
    104104                return 0;
    105         memset(rm->owd, 0, sizeof(rm->owd));
     105        memset(rm->owd, 0, PATH_MAX);
    106106
    107107        if (NULL == (rm->cwd = (char *) malloc(PATH_MAX)))
    108108                return 0;
    109         memset(rm->cwd, 0, sizeof(rm->cwd));
     109        memset(rm->cwd, 0, PATH_MAX);
    110110
    111111        chdir(".");
    … …  
    298298                        break;
    299299                }
    300                 memset(buff, 0, sizeof(buff));
     300                memset(buff, 0, len);
    301301                snprintf(buff, len, "%s", argv[i]);
    302302

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

    r52f1882 rdb71e2a  
    6767        uint64_t whole_seconds;
    6868        uint64_t frac_seconds;
    69         char *endptr;
     69        const char *endptr;
    7070
    7171        /* Check for whole seconds */
    … …  
    114114        int ret;
    115115        unsigned int argc;
    116         useconds_t duration;
     116        useconds_t duration = 0;
    117117
    118118        /* Count the arguments */

  • uspace/app/bdsh/exec.c

    r52f1882 rdb71e2a  
    8383        /* We now have n places to look for the command */
    8484        for (i = 0; search_dir[i] != NULL; i++) {
    85                 memset(found, 0, sizeof(found));
     85                memset(found, 0, PATH_MAX);
    8686                snprintf(found, PATH_MAX, "%s/%s", search_dir[i], cmd);
    8787                if (-1 != try_access(found)) {

  • uspace/app/binutils/intrusive.sh

    r52f1882 rdb71e2a  
    9696# libposix function name redefinitons in one of the arm-specific files.
    9797#
     98# Patch 9
     99# Libiberty does not trust our strncmp that is provided in libposix.
     100# That is because when cross-compiling, it cannot check how it behaves
     101# and assumes the worst. But then it clashes when linking (due to
     102# multiple definitions of ...) and this patch prevents compilation of
     103# liberty strncmp.
    98104
    99105case "$1" in
    … …  
    157163                # Patch libiberty configure script.
    158164                cat "$2/libiberty/configure.backup" | \
    159                 # See Patch 1.
    160                 sed 's/^cross_compiling=no/cross_compiling=yes/g' \
     165                # See Patch 1 and 9.
     166                sed -e 's/^cross_compiling=no/cross_compiling=yes/g' \
     167                        -e 's/ac_cv_func_strncmp_works=no/ac_cv_func_strncmp_works=yes/g' \
    161168                > "$2/libiberty/configure"
    162169

  • uspace/app/binutils/toolchain.sh

    r52f1882 rdb71e2a  
    7272                echo '  ld $LD_ARGS'
    7373                echo 'else'
    74                 CFLAGS="`echo " $3" | \
     74                CFLAGS="`echo " $3 " | \
    7575                        sed 's/ -O[^ ]*//g' | \
    7676                        sed 's/ -W[^ ]*//g' | \
    7777                        sed 's/ -pipe//g' | \
    78                         sed 's/ -g//g' | \
     78                        sed 's/ -g[^ ]*//g' | \
    7979                        sed 's/ [ ]*/ /g'`"
    8080                echo '  CONFTEST="`echo \"$*\" | grep '\' conftest \''`"'

  • uspace/app/blkdump/blkdump.c

    r52f1882 rdb71e2a  
    11/*
    22 * Copyright (c) 2011 Martin Sucha
    3  * Copyright (c) 2010 Jiri Svoboda
     3 * Copyright (c) 2013 Jiri Svoboda
    44 * All rights reserved.
    55 *
    … …  
    5252
    5353static void syntax_print(void);
     54static int print_blocks(aoff64_t block_offset, aoff64_t block_count, size_t block_size);
     55static int print_toc(void);
    5456static void print_hex_row(uint8_t *data, size_t length, size_t bytes_per_row);
     57
     58static bool relative = false;
     59static service_id_t service_id;
    5560
    5661int main(int argc, char **argv)
    … …  
    5964        int rc;
    6065        char *dev_path;
    61         service_id_t service_id;
    6266        size_t block_size;
    6367        char *endptr;
    … …  
    6569        aoff64_t block_count = 1;
    6670        aoff64_t dev_nblocks;
    67         uint8_t *data;
    68         size_t data_offset;
    69         aoff64_t current;
    70         aoff64_t limit;
    71         bool relative = false;
     71        bool toc = false;
    7272       
    7373        if (argc < 2) {
    … …  
    7979        --argc; ++argv;
    8080
     81        if (str_cmp(*argv, "--toc") == 0) {
     82                --argc; ++argv;
     83                toc = true;
     84                goto devname;
     85        }
     86
    8187        if (str_cmp(*argv, "--relative") == 0) {
    8288                --argc; ++argv;
    … …  
    120126        }
    121127
     128devname:
    122129        if (argc != 1) {
    123130                printf(NAME ": Error, unexpected argument.\n");
    … …  
    153160        printf("Device %s has %" PRIuOFF64 " blocks, %" PRIuOFF64 " bytes each\n", dev_path, dev_nblocks, (aoff64_t) block_size);
    154161
     162        if (toc)
     163                rc = print_toc();
     164        else
     165                rc = print_blocks(block_offset, block_count, block_size);
     166
     167        block_fini(service_id);
     168
     169        return rc;
     170}
     171
     172static int print_blocks(aoff64_t block_offset, aoff64_t block_count, size_t block_size)
     173{
     174        uint8_t *data;
     175        aoff64_t current;
     176        aoff64_t limit;
     177        size_t data_offset;
     178        int rc;
     179
    155180        data = malloc(block_size);
    156181        if (data == NULL) {
    157182                printf(NAME ": Error allocating data buffer of %" PRIuOFF64 " bytes", (aoff64_t) block_size);
    158                 block_fini(service_id);
    159183                return 3;
    160184        }
    161        
     185
    162186        limit = block_offset + block_count;
    163187        for (current = block_offset; current < limit; current++) {
    … …  
    168192                        return 3;
    169193                }
    170                
     194
    171195                printf("---- Block %" PRIuOFF64 " (at %" PRIuOFF64 ") ----\n", current, current*block_size);
    172                
     196
    173197                for (data_offset = 0; data_offset < block_size; data_offset += 16) {
    174198                        if (relative) {
    … …  
    183207                printf("\n");
    184208        }
    185        
     209
    186210        free(data);
    187 
    188         block_fini(service_id);
     211        return 0;
     212}
     213
     214static int print_toc(void)
     215{
     216        toc_block_t *toc;
     217
     218        toc = block_get_toc(service_id, 0);
     219        if (toc == NULL)
     220                return 1;
     221
     222        printf("TOC size: %" PRIu16 " bytes\n", toc->size);
     223        printf("First session: %" PRIu8 "\n", toc->first_session);
     224        printf("Last_session: %" PRIu8 "\n", toc->last_session);
    189225
    190226        return 0;

  • uspace/app/bnchmark/bnchmark.c

    r52f1882 rdb71e2a  
    142142{
    143143        int rc;
    144         umseconds_t milliseconds_taken;
     144        umseconds_t milliseconds_taken = 0;
    145145        char *path = NULL;
    146146        measure_func_t fn = NULL;

  • uspace/app/edit/edit.c

    r52f1882 rdb71e2a  
    8080        tag_t sel_start;
    8181
     82        /** Active keyboard modifiers */
     83        keymod_t keymod;
     84
    8285        /**
    8386         * Ideal column where the caret should try to get. This is used
    … …  
    119122static void cursor_setvis(bool visible);
    120123
     124static void key_handle_press(kbd_event_t *ev);
    121125static void key_handle_unmod(kbd_event_t const *ev);
    122126static void key_handle_ctrl(kbd_event_t const *ev);
    … …  
    124128static void key_handle_shift_ctrl(kbd_event_t const *ev);
    125129static void key_handle_movement(unsigned int key, bool shift);
     130
     131static void pos_handle(pos_event_t *ev);
    126132
    127133static int file_save(char const *fname);
    … …  
    182188int main(int argc, char *argv[])
    183189{
    184         kbd_event_t ev;
     190        cons_event_t ev;
    185191        bool new_file;
    186192        int rc;
    … …  
    245251
    246252        while (!done) {
    247                 console_get_kbd_event(con, &ev);
     253                console_get_event(con, &ev);
    248254                pane.rflags = 0;
    249255
    250                 if (ev.type == KEY_PRESS) {
    251                         /* Handle key press. */
    252                         if (((ev.mods & KM_ALT) == 0) &&
    253                             ((ev.mods & KM_SHIFT) == 0) &&
    254                              (ev.mods & KM_CTRL) != 0) {
    255                                 key_handle_ctrl(&ev);
    256                         } else if (((ev.mods & KM_ALT) == 0) &&
    257                             ((ev.mods & KM_CTRL) == 0) &&
    258                              (ev.mods & KM_SHIFT) != 0) {
    259                                 key_handle_shift(&ev);
    260                         } else if (((ev.mods & KM_ALT) == 0) &&
    261                             ((ev.mods & KM_CTRL) != 0) &&
    262                              (ev.mods & KM_SHIFT) != 0) {
    263                                 key_handle_shift_ctrl(&ev);
    264                         } else if ((ev.mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
    265                                 key_handle_unmod(&ev);
    266                         }
     256                switch (ev.type) {
     257                case CEV_KEY:
     258                        pane.keymod = ev.ev.key.mods;
     259                        if (ev.ev.key.type == KEY_PRESS)
     260                                key_handle_press(&ev.ev.key);
     261                        break;
     262                case CEV_POS:
     263                        pos_handle(&ev.ev.pos);
     264                        break;
    267265                }
    268266
    … …  
    286284
    287285        return 0;
     286}
     287
     288/* Handle key press. */
     289static void key_handle_press(kbd_event_t *ev)
     290{
     291        if (((ev->mods & KM_ALT) == 0) &&
     292            ((ev->mods & KM_SHIFT) == 0) &&
     293             (ev->mods & KM_CTRL) != 0) {
     294                key_handle_ctrl(ev);
     295        } else if (((ev->mods & KM_ALT) == 0) &&
     296            ((ev->mods & KM_CTRL) == 0) &&
     297             (ev->mods & KM_SHIFT) != 0) {
     298                key_handle_shift(ev);
     299        } else if (((ev->mods & KM_ALT) == 0) &&
     300            ((ev->mods & KM_CTRL) != 0) &&
     301             (ev->mods & KM_SHIFT) != 0) {
     302                key_handle_shift_ctrl(ev);
     303        } else if ((ev->mods & (KM_CTRL | KM_ALT | KM_SHIFT)) == 0) {
     304                key_handle_unmod(ev);
     305        }
    288306}
    289307
    … …  
    462480}
    463481
     482static void pos_handle(pos_event_t *ev)
     483{
     484        coord_t bc;
     485        spt_t pt;
     486        bool select;
     487
     488        if (ev->type == POS_PRESS && ev->vpos < (unsigned)pane.rows) {
     489                bc.row = pane.sh_row + ev->vpos;
     490                bc.column = pane.sh_column + ev->hpos;
     491                sheet_get_cell_pt(doc.sh, &bc, dir_before, &pt);
     492
     493                select = (pane.keymod & KM_SHIFT) != 0;
     494
     495                caret_move(pt, select, true);
     496        }
     497}
     498
    464499/** Move caret while preserving or resetting selection. */
    465500static void caret_move(spt_t new_caret_pt, bool select, bool update_ideal_column)
    … …  
    592627static char *prompt(char const *prompt, char const *init_value)
    593628{
    594         kbd_event_t ev;
     629        cons_event_t ev;
     630        kbd_event_t *kev;
    595631        char *str;
    596632        wchar_t buffer[INFNAME_MAX_LEN + 1];
    … …  
    612648
    613649        while (!done) {
    614                 console_get_kbd_event(con, &ev);
    615 
    616                 if (ev.type == KEY_PRESS) {
     650                console_get_event(con, &ev);
     651
     652                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
     653                        kev = &ev.ev.key;
     654
    617655                        /* Handle key press. */
    618                         if (((ev.mods & KM_ALT) == 0) &&
    619                              (ev.mods & KM_CTRL) != 0) {
     656                        if (((kev->mods & KM_ALT) == 0) &&
     657                             (kev->mods & KM_CTRL) != 0) {
    620658                                ;
    621                         } else if ((ev.mods & (KM_CTRL | KM_ALT)) == 0) {
    622                                 switch (ev.key) {
     659                        } else if ((kev->mods & (KM_CTRL | KM_ALT)) == 0) {
     660                                switch (kev->key) {
    623661                                case KC_ESCAPE:
    624662                                        return NULL;
    … …  
    634672                                        break;
    635673                                default:
    636                                         if (ev.c >= 32 && nc < max_len) {
    637                                                 putchar(ev.c);
     674                                        if (kev->c >= 32 && nc < max_len) {
     675                                                putchar(kev->c);
    638676                                                console_flush(con);
    639                                                 buffer[nc++] = ev.c;
     677                                                buffer[nc++] = kev->c;
    640678                                        }
    641679                                        break;

  • uspace/app/edit/search_impl.h

    r52f1882 rdb71e2a  
    4040
    4141/** Search state */
    42 typedef struct search {
     42struct search {
    4343        /* Note: This structure is opaque for the user. */
    4444
    … …  
    4949        void *client_data;
    5050        search_ops_t ops;
    51 } search_t;
     51};
    5252
    5353#endif

  • uspace/app/edit/sheet_impl.h

    r52f1882 rdb71e2a  
    4040
    4141/** Sheet */
    42 typedef struct sheet {
     42struct sheet {
    4343        /* Note: This structure is opaque for the user. */
    4444
    … …  
    4848
    4949        list_t tags;
    50 } sheet_t;
     50};
    5151
    5252#endif

  • uspace/app/inet/inet.c

    r52f1882 rdb71e2a  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3636
    3737#include <errno.h>
     38#include <inet/addr.h>
    3839#include <inet/inetcfg.h>
    3940#include <loc.h>
    … …  
    4344#include <sys/types.h>
    4445
    45 #define NAME "inet"
     46#define NAME  "inet"
    4647
    4748static void print_syntax(void)
    … …  
    5455}
    5556
    56 static int naddr_parse(const char *text, inet_naddr_t *naddr)
    57 {
    58         unsigned long a[4], bits;
    59         char *cp = (char *)text;
    60         int i;
    61 
    62         for (i = 0; i < 3; i++) {
    63                 a[i] = strtoul(cp, &cp, 10);
    64                 if (*cp != '.')
    65                         return EINVAL;
    66                 ++cp;
    67         }
    68 
    69         a[3] = strtoul(cp, &cp, 10);
    70         if (*cp != '/')
    71                 return EINVAL;
    72         ++cp;
    73 
    74         bits = strtoul(cp, &cp, 10);
    75         if (*cp != '\0')
    76                 return EINVAL;
    77 
    78         naddr->ipv4 = 0;
    79         for (i = 0; i < 4; i++) {
    80                 if (a[i] > 255)
    81                         return EINVAL;
    82                 naddr->ipv4 = (naddr->ipv4 << 8) | a[i];
    83         }
    84 
    85         if (bits > 31)
    86                 return EINVAL;
    87 
    88         naddr->bits = bits;
    89         return EOK;
    90 }
    91 
    92 static int addr_parse(const char *text, inet_addr_t *addr)
    93 {
    94         unsigned long a[4];
    95         char *cp = (char *)text;
    96         int i;
    97 
    98         for (i = 0; i < 3; i++) {
    99                 a[i] = strtoul(cp, &cp, 10);
    100                 if (*cp != '.')
    101                         return EINVAL;
    102                 ++cp;
    103         }
    104 
    105         a[3] = strtoul(cp, &cp, 10);
    106         if (*cp != '\0')
    107                 return EINVAL;
    108 
    109         addr->ipv4 = 0;
    110         for (i = 0; i < 4; i++) {
    111                 if (a[i] > 255)
    112                         return EINVAL;
    113                 addr->ipv4 = (addr->ipv4 << 8) | a[i];
    114         }
    115 
    116         return EOK;
    117 }
    118 
    119 static int naddr_format(inet_naddr_t *naddr, char **bufp)
    120 {
    121         int rc;
    122 
    123         rc = asprintf(bufp, "%d.%d.%d.%d/%d", naddr->ipv4 >> 24,
    124             (naddr->ipv4 >> 16) & 0xff, (naddr->ipv4 >> 8) & 0xff,
    125             naddr->ipv4 & 0xff, naddr->bits);
    126 
    127         if (rc < 0)
    128                 return ENOMEM;
    129 
    130         return EOK;
    131 }
    132 
    133 static int addr_format(inet_addr_t *addr, char **bufp)
    134 {
    135         int rc;
    136 
    137         rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
    138             (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
    139             addr->ipv4 & 0xff);
    140 
    141         if (rc < 0)
    142                 return ENOMEM;
    143 
    144         return EOK;
    145 }
    146 
    14757static int addr_create_static(int argc, char *argv[])
    14858{
    … …  
    17888        }
    17989
    180         rc = naddr_parse(addr_spec, &naddr);
     90        rc = inet_naddr_parse(addr_spec, &naddr);
    18191        if (rc != EOK) {
    18292                printf(NAME ": Invalid network address format '%s'.\n",
    … …  
    267177        route_name = argv[2];
    268178
    269         rc = naddr_parse(dest_str, &dest);
     179        rc = inet_naddr_parse(dest_str, &dest);
    270180        if (rc != EOK) {
    271181                printf(NAME ": Invalid network address format '%s'.\n",
    … …  
    274184        }
    275185
    276         rc = addr_parse(router_str, &router);
     186        rc = inet_addr_parse(router_str, &router);
    277187        if (rc != EOK) {
    278188                printf(NAME ": Invalid address format '%s'.\n", router_str);
    … …  
    347257        if (count > 0)
    348258                printf("    [Addr/Width] [Link-Name] [Addr-Name] [Def-MTU]\n");
    349         ainfo.name = linfo.name = astr = NULL;
     259        ainfo.name = NULL;
     260        linfo.name = NULL;
     261        astr = NULL;
    350262
    351263        for (i = 0; i < count; i++) {
    … …  
    366278                }
    367279
    368                 rc = naddr_format(&ainfo.naddr, &astr);
     280                rc = inet_naddr_format(&ainfo.naddr, &astr);
    369281                if (rc != EOK) {
    370282                        printf("Memory allocation failed.\n");
    … …  
    380292                free(astr);
    381293
    382                 ainfo.name = linfo.name = astr = NULL;
     294                ainfo.name = NULL;
     295                linfo.name = NULL;
     296                astr = NULL;
    383297        }
    384298
    … …  
    419333                printf("    [Dest/Width] [Router-Addr] [Route-Name]\n");
    420334
    421         srinfo.name = dest_str = router_str = NULL;
     335        srinfo.name = NULL;
     336        dest_str = NULL;
     337        router_str = NULL;
    422338
    423339        for (i = 0; i < count; i++) {
    … …  
    430346                }
    431347
    432                 rc = naddr_format(&srinfo.dest, &dest_str);
     348                rc = inet_naddr_format(&srinfo.dest, &dest_str);
    433349                if (rc != EOK) {
    434350                        printf("Memory allocation failed.\n");
    … …  
    437353                }
    438354
    439                 rc = addr_format(&srinfo.router, &router_str);
     355                rc = inet_addr_format(&srinfo.router, &router_str);
    440356                if (rc != EOK) {
    441357                        printf("Memory allocation failed.\n");
    … …  
    450366                free(router_str);
    451367
    452                 router_str = srinfo.name = dest_str = NULL;
     368                router_str = NULL;
     369                srinfo.name = NULL;
     370                dest_str = NULL;
    453371        }
    454372

  • uspace/app/init/init.c

    r52f1882 rdb71e2a  
    359359        srv_start("/srv/tcp");
    360360        srv_start("/srv/udp");
     361        srv_start("/srv/dnsrsrv");
    361362       
    362363        srv_start("/srv/clipboard");
    … …  
    369370#ifdef CONFIG_START_BD
    370371        srv_start("/srv/ata_bd");
    371         srv_start("/srv/gxe_bd");
    372372#endif
    373373       

  • uspace/app/mkbd/main.c

    r52f1882 rdb71e2a  
    177177
    178178        while (1) {
    179                 kbd_event_t ev;
    180                 bool ok = console_get_kbd_event(con, &ev);
     179                cons_event_t ev;
     180                bool ok = console_get_event(con, &ev);
    181181                if (!ok) {
    182182                        printf("Connection with console broken: %s.\n",
    … …  
    185185                }
    186186
    187                 if (ev.key == KC_ESCAPE) {
     187                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS &&
     188                    ev.ev.key.key == KC_ESCAPE) {
    188189                        break;
    189190                }

  • uspace/app/mkmfs/mkmfs.c

    r52f1882 rdb71e2a  
    649649                mark_bmap(ibmap_buf, i, FREE);
    650650
    651         for (i = sb->first_data_zone + 1; i < sb->n_zones; ++i)
     651        for (i = 2; i < sb->n_zones - sb->first_data_zone; ++i)
    652652                mark_bmap(zbmap_buf, i, FREE);
    653653

  • uspace/app/msim/arch_helenos/input.c

    r52f1882 rdb71e2a  
    9191bool stdin_poll(char *key)
    9292{
    93         kbd_event_t ev;
     93        cons_event_t ev;
    9494        suseconds_t timeout = 0;
    9595        errno = EOK;
    9696        console_flush(input_prompt->console);
    97         bool has_input = console_get_kbd_event_timeout(input_prompt->console, &ev, &timeout);
     97        bool has_input = console_get_event_timeout(input_prompt->console, &ev, &timeout);
    9898        if (!has_input) {
    9999                return false;
    100100        }
    101101
    102         if (ev.type != KEY_PRESS)
     102        if (ev.type != CEV_KEY || ev.ev.key.type != KEY_PRESS)
    103103                return false;
    104104
    105         *key = ev.c;
     105        *key = ev.ev.key.c;
    106106
    107107        return true;

  • uspace/app/netecho/netecho.c

    r52f1882 rdb71e2a  
    225225        uint8_t address_buf[sizeof(struct sockaddr_in6)];
    226226
    227         socklen_t addrlen;
     227        socklen_t addrlen = sizeof(struct sockaddr_in6);
    228228        int socket_id;
    229229        ssize_t rcv_size;
    … …  
    240240        if (type == SOCK_STREAM) {
    241241                /* Accept a socket if a stream socket is used */
    242                 addrlen = sizeof(address_buf);
    243242                if (verbose)
    244243                        printf("accept()\n");
    245                 socket_id = accept(listening_id, (void *) address_buf, &addrlen);
     244                socket_id = accept(listening_id, (void *) address_buf, &addrlen);
    246245                if (socket_id <= 0) {
    247246                        socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
    … …  
    280279                                case AF_INET6:
    281280                                        port = ntohs(address_in6->sin6_port);
    282                                         address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     281                                        address_start = (uint8_t *) address_in6->sin6_addr.s6_addr;
    283282                                        break;
    284283                                default:
    … …  
    312311                                rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
    313312                                if (rc != EOK)
    314                                         socket_print_error(stderr, rc, "Socket send: ", "\n");
     313                                        socket_print_error(stderr, rc, "Socket sendto: ", "\n");
    315314                        }
    316315                }
    … …  
    380379                address_in6.sin6_family = AF_INET6;
    381380                address_in6.sin6_port = htons(port);
     381                address_in6.sin6_addr = in6addr_any;
    382382                address = (struct sockaddr *) &address_in6;
    383383                addrlen = sizeof(address_in6);
    … …  
    394394                return listening_id;
    395395        }
    396 
     396       
     397        /* Bind the listening socket */
     398        rc = bind(listening_id, address, addrlen);
     399        if (rc != EOK) {
     400                socket_print_error(stderr, rc, "Socket bind: ", "\n");
     401                return rc;
     402        }
     403       
    397404        /* if the stream socket is used */
    398405        if (type == SOCK_STREAM) {
    … …  
    402409                        backlog = 3;
    403410                }
    404 
     411               
    405412                /* Set the backlog */
    406413                rc = listen(listening_id, backlog);
    … …  
    409416                        return rc;
    410417                }
    411         }
    412 
    413         /* Bind the listening socket */
    414         rc = bind(listening_id, address, addrlen);
    415         if (rc != EOK) {
    416                 socket_print_error(stderr, rc, "Socket bind: ", "\n");
    417                 return rc;
    418418        }
    419419

  • uspace/app/nettest1/nettest.c

    r52f1882 rdb71e2a  
    4141#include "print_error.h"
    4242
    43 
    4443/** Creates new sockets.
    4544 *
    … …  
    5251 * @return Other error codes as defined for the socket() function.
    5352 */
    54 int sockets_create(int verbose, int *socket_ids, int sockets, int family, sock_type_t type)
    55 {
    56         int index;
    57 
     53int sockets_create(int verbose, int *socket_ids, unsigned int sockets,
     54    uint16_t family, sock_type_t type)
     55{
    5856        if (verbose)
    5957                printf("Create\t");
    60                
    61         fflush(stdout);
    62        
    63         for (index = 0; index < sockets; index++) {
     58       
     59        fflush(stdout);
     60       
     61        for (unsigned int index = 0; index < sockets; index++) {
    6462                socket_ids[index] = socket(family, type, 0);
    6563                if (socket_ids[index] < 0) {
    66                         printf("Socket %d (%d) error:\n", index, socket_ids[index]);
     64                        printf("Socket %u (%d) error:\n", index, socket_ids[index]);
    6765                        socket_print_error(stderr, socket_ids[index], "Socket create: ", "\n");
    6866                        return socket_ids[index];
    6967                }
     68               
    7069                if (verbose)
    7170                        print_mark(index);
    … …  
    8382 * @return Other error codes as defined for the closesocket() function.
    8483 */
    85 int sockets_close(int verbose, int *socket_ids, int sockets)
    86 {
    87         int index;
    88         int rc;
    89 
     84int sockets_close(int verbose, int *socket_ids, unsigned int sockets)
     85{
    9086        if (verbose)
    9187                printf("\tClose\t");
    92 
    93         fflush(stdout);
    94        
    95         for (index = 0; index < sockets; index++) {
    96                 rc = closesocket(socket_ids[index]);
     88       
     89        fflush(stdout);
     90       
     91        for (unsigned int index = 0; index < sockets; index++) {
     92                int rc = closesocket(socket_ids[index]);
    9793                if (rc != EOK) {
    98                         printf("Socket %d (%d) error:\n", index, socket_ids[index]);
     94                        printf("Socket %u (%d) error:\n", index, socket_ids[index]);
    9995                        socket_print_error(stderr, rc, "Socket close: ", "\n");
    10096                        return rc;
    10197                }
     98               
    10299                if (verbose)
    103100                        print_mark(index);
    … …  
    117114 * @return Other error codes as defined for the connect() function.
    118115 */
    119 int sockets_connect(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t addrlen)
    120 {
    121         int index;
    122         int rc;
    123 
     116int sockets_connect(int verbose, int *socket_ids, unsigned int sockets,
     117    struct sockaddr *address, socklen_t addrlen)
     118{
    124119        if (verbose)
    125120                printf("\tConnect\t");
    … …  
    127122        fflush(stdout);
    128123       
    129         for (index = 0; index < sockets; index++) {
    130                 rc = connect(socket_ids[index], address, addrlen);
     124        for (unsigned int index = 0; index < sockets; index++) {
     125                int rc = connect(socket_ids[index], address, addrlen);
    131126                if (rc != EOK) {
    132127                        socket_print_error(stderr, rc, "Socket connect: ", "\n");
    133128                        return rc;
    134129                }
    135                 if (verbose)
    136                         print_mark(index);
    137         }
    138        
    139         return EOK;
    140 }
    141 
    142 /** Sends data via sockets.
    143  *
    144  * @param[in] verbose A value indicating whether to print out verbose information.
    145  * @param[in] socket_ids A field of stored socket identifiers.
    146  * @param[in] sockets The number of sockets in the field. Should be at most the size of the field.
    147  * @param[in] address The destination host address to send data to.
    148  * @param[in] addrlen The length of the destination address in bytes.
    149  * @param[in] data The data to be sent.
    150  * @param[in] size The data size in bytes.
    151  * @param[in] messages The number of datagrams per socket to be sent.
     130               
     131                if (verbose)
     132                        print_mark(index);
     133        }
     134       
     135        return EOK;
     136}
     137
     138/** Send data via sockets.
     139 *
     140 * @param[in] verbose    Print out verbose information.
     141 * @param[in] socket_ids Stored socket identifiers.
     142 * @param[in] sockets    Number of sockets.
     143 * @param[in] address    Destination host address to send data to.
     144 * @param[in] addrlen    Length of the destination address in bytes.
     145 * @param[in] data       Data to be sent.
     146 * @param[in] size       Size of the data in bytes.
     147 * @param[in] messages   Number of datagrams per socket to be sent.
     148 * @param[in] type       Socket type.
     149 *
    152150 * @return EOK on success.
    153151 * @return Other error codes as defined for the sendto() function.
    154  */
    155 int sockets_sendto(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t addrlen, char *data, int size, int messages)
    156 {
    157         int index;
    158         int message;
    159         int rc;
    160 
     152 *
     153 */
     154int sockets_sendto(int verbose, int *socket_ids, unsigned int sockets,
     155    struct sockaddr *address, socklen_t addrlen, char *data, size_t size,
     156    unsigned int messages, sock_type_t type)
     157{
    161158        if (verbose)
    162159                printf("\tSendto\t");
    163 
    164         fflush(stdout);
    165        
    166         for (index = 0; index < sockets; index++) {
    167                 for (message = 0; message < messages; message++) {
    168                         rc = sendto(socket_ids[index], data, size, 0, address, addrlen);
     160       
     161        fflush(stdout);
     162       
     163        for (unsigned int index = 0; index < sockets; index++) {
     164                for (unsigned int message = 0; message < messages; message++) {
     165                        int rc;
     166                       
     167                        switch (type) {
     168                        case SOCK_STREAM:
     169                                rc = send(socket_ids[index], data, size, 0);
     170                                break;
     171                        case SOCK_DGRAM:
     172                                rc = sendto(socket_ids[index], data, size, 0, address, addrlen);
     173                                break;
     174                        default:
     175                                rc = EINVAL;
     176                        }
     177                       
    169178                        if (rc != EOK) {
    170                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     179                                printf("Socket %u (%d), message %u error:\n",
     180                                    index, socket_ids[index], message);
    171181                                socket_print_error(stderr, rc, "Socket send: ", "\n");
    172182                                return rc;
    173183                        }
    174184                }
    175                 if (verbose)
    176                         print_mark(index);
    177         }
    178        
    179         return EOK;
    180 }
    181 
    182 /** Receives data via sockets.
    183  *
    184  * @param[in] verbose A value indicating whether to print out verbose information.
    185  * @param[in] socket_ids A field of stored socket identifiers.
    186  * @param[in] sockets The number of sockets in the field. Should be at most the size of the field.
    187  * @param[in] address The source host address of received datagrams.
    188  * @param[in,out] addrlen The maximum length of the source address in bytes. The actual size of the source address is set instead.
    189  * @param[out] data The received data.
    190  * @param[in] size The maximum data size in bytes.
    191  * @param[in] messages The number of datagrams per socket to be received.
     185               
     186                if (verbose)
     187                        print_mark(index);
     188        }
     189       
     190        return EOK;
     191}
     192
     193/** Receive data via sockets.
     194 *
     195 * @param[in]     verbose    Print out verbose information.
     196 * @param[in]     socket_ids Stored socket identifiers.
     197 * @param[in]     sockets    Number of sockets.
     198 * @param[in]     address    Source host address of received datagrams.
     199 * @param[in,out] addrlen    Maximum length of the source address in bytes.
     200 *                           The actual size of the source address is set.
     201 * @param[out]    data       Received data.
     202 * @param[in]     size       Maximum data size in bytes.
     203 * @param[in]     messages   Number of datagrams per socket to be received.
     204 *
    192205 * @return EOK on success.
    193206 * @return Other error codes as defined for the recvfrom() function.
    194  */
    195 int sockets_recvfrom(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t *addrlen, char *data, int size, int messages)
    196 {
    197         int value;
    198         int index;
    199         int message;
    200 
     207 *
     208 */
     209int sockets_recvfrom(int verbose, int *socket_ids, unsigned int sockets,
     210    struct sockaddr *address, socklen_t *addrlen, char *data, size_t size,
     211    unsigned int messages)
     212{
    201213        if (verbose)
    202214                printf("\tRecvfrom\t");
    … …  
    204216        fflush(stdout);
    205217       
    206         for (index = 0; index < sockets; index++) {
    207                 for (message = 0; message < messages; message++) {
    208                         value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
    209                         if (value < 0) {
    210                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
    211                                 socket_print_error(stderr, value, "Socket receive: ", "\n");
    212                                 return value;
    213                         }
    214                 }
    215                 if (verbose)
    216                         print_mark(index);
    217         }
    218         return EOK;
    219 }
    220 
    221 /** Sends and receives data via sockets.
     218        for (unsigned int index = 0; index < sockets; index++) {
     219                for (unsigned int message = 0; message < messages; message++) {
     220                        int rc = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
     221                        if (rc < 0) {
     222                                printf("Socket %u (%d), message %u error:\n",
     223                                    index, socket_ids[index], message);
     224                                socket_print_error(stderr, rc, "Socket receive: ", "\n");
     225                                return rc;
     226                        }
     227                }
     228               
     229                if (verbose)
     230                        print_mark(index);
     231        }
     232       
     233        return EOK;
     234}
     235
     236/** Send and receive data via sockets.
    222237 *
    223238 * Each datagram is sent and a reply read consequently.
    224239 * The next datagram is sent after the reply is received.
    225240 *
    226  * @param[in] verbose A value indicating whether to print out verbose information.
    227  * @param[in] socket_ids A field of stored socket identifiers.
    228  * @param[in] sockets The number of sockets in the field. Should be at most the size of the field.
    229  * @param[in,out] address The destination host address to send data to. The source host address of received datagrams is set instead.
    230  * @param[in] addrlen The length of the destination address in bytes.
    231  * @param[in,out] data The data to be sent. The received data are set instead.
    232  * @param[in] size The data size in bytes.
    233  * @param[in] messages The number of datagrams per socket to be received.
     241 * @param[in]     verbose    Print out verbose information.
     242 * @param[in]     socket_ids Stored socket identifiers.
     243 * @param[in]     sockets    Number of sockets.
     244 * @param[in,out] address    Destination host address to send data to.
     245 *                           The source host address of received datagrams is set.
     246 * @param[in]     addrlen    Length of the destination address in bytes.
     247 * @param[in,out] data       Data to be sent. The received data are set.
     248 * @param[in]     size       Size of the data in bytes.
     249 * @param[in]     messages   Number of datagrams per socket to be received.
     250 * @param[in]     type       Socket type.
     251 *
    234252 * @return EOK on success.
    235253 * @return Other error codes as defined for the recvfrom() function.
    236  */
    237 int sockets_sendto_recvfrom(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t *addrlen, char *data, int size, int messages)
    238 {
    239         int value;
    240         int index;
    241         int message;
    242         int rc;
    243 
     254 *
     255 */
     256int sockets_sendto_recvfrom(int verbose, int *socket_ids, unsigned int sockets,
     257    struct sockaddr *address, socklen_t *addrlen, char *data,
     258    size_t size, unsigned int messages, sock_type_t type)
     259{
    244260        if (verbose)
    245261                printf("\tSendto and recvfrom\t");
    246 
    247         fflush(stdout);
    248        
    249         for (index = 0; index < sockets; index++) {
    250                 for (message = 0; message < messages; message++) {
    251                         rc = sendto(socket_ids[index], data, size, 0, address, *addrlen);
     262       
     263        fflush(stdout);
     264       
     265        for (unsigned int index = 0; index < sockets; index++) {
     266                for (unsigned int message = 0; message < messages; message++) {
     267                        int rc;
     268                       
     269                        switch (type) {
     270                        case SOCK_STREAM:
     271                                rc = send(socket_ids[index], data, size, 0);
     272                                break;
     273                        case SOCK_DGRAM:
     274                                rc = sendto(socket_ids[index], data, size, 0, address, *addrlen);
     275                                break;
     276                        default:
     277                                rc = EINVAL;
     278                        }
     279                       
    252280                        if (rc != EOK) {
    253                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     281                                printf("Socket %u (%d), message %u error:\n",
     282                                    index, socket_ids[index], message);
    254283                                socket_print_error(stderr, rc, "Socket send: ", "\n");
    255284                                return rc;
    256285                        }
    257                         value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
    258                         if (value < 0) {
    259                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
    260                                 socket_print_error(stderr, value, "Socket receive: ", "\n");
    261                                 return value;
    262                         }
    263                 }
     286                       
     287                        rc = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
     288                        if (rc < 0) {
     289                                printf("Socket %u (%d), message %u error:\n",
     290                                    index, socket_ids[index], message);
     291                                socket_print_error(stderr, rc, "Socket receive: ", "\n");
     292                                return rc;
     293                        }
     294                }
     295               
    264296                if (verbose)
    265297                        print_mark(index);
    … …  
    274306 *
    275307 * @param[in] index The index of the mark to be printed.
    276  */
    277 void print_mark(int index)
     308 *
     309 */
     310void print_mark(unsigned int index)
    278311{
    279312        if ((index + 1) % 10)
    … …  
    281314        else
    282315                printf("|");
     316       
    283317        fflush(stdout);
    284318}

  • uspace/app/nettest1/nettest.h

    r52f1882 rdb71e2a  
    4040#include <net/socket.h>
    4141
    42 extern void print_mark(int);
    43 extern int sockets_create(int, int *, int, int, sock_type_t);
    44 extern int sockets_close(int, int *, int);
    45 extern int sockets_connect(int, int *, int, struct sockaddr *, socklen_t);
    46 extern int sockets_sendto(int, int *, int, struct sockaddr *, socklen_t, char *, int, int);
    47 extern int sockets_recvfrom(int, int *, int, struct sockaddr *, socklen_t *, char *, int, int);
    48 extern int sockets_sendto_recvfrom(int, int *, int, struct sockaddr *, socklen_t *, char *, int, int);
     42extern void print_mark(unsigned int);
     43extern int sockets_create(int, int *, unsigned int, uint16_t, sock_type_t);
     44extern int sockets_close(int, int *, unsigned int);
     45extern int sockets_connect(int, int *, unsigned int, struct sockaddr *,
     46    socklen_t);
     47extern int sockets_sendto(int, int *, unsigned int, struct sockaddr *,
     48    socklen_t, char *, size_t, unsigned int, sock_type_t);
     49extern int sockets_recvfrom(int, int *, unsigned int, struct sockaddr *,
     50    socklen_t *, char *, size_t, unsigned int);
     51extern int sockets_sendto_recvfrom(int, int *, unsigned int, struct sockaddr *,
     52    socklen_t *, char *, size_t, unsigned int, sock_type_t);
    4953
    5054#endif

  • uspace/app/nettest1/nettest1.c

    r52f1882 rdb71e2a  
    4646#include <arg_parse.h>
    4747
     48#include <inet/dnsr.h>
    4849#include <net/in.h>
    4950#include <net/in6.h>
    … …  
    5354
    5455/** Echo module name. */
    55 #define NAME    "Nettest1"
     56#define NAME  "nettest1"
    5657
    5758/** Packet data pattern. */
    58 #define NETTEST1_TEXT   "Networking test 1 - sockets"
    59 
    60 static int family = PF_INET;
     59#define NETTEST1_TEXT  "Networking test 1 - sockets"
     60
     61static uint16_t family = AF_INET;
    6162static sock_type_t type = SOCK_DGRAM;
    62 static char *data;
    6363static size_t size = 27;
    64 static int verbose = 0;
     64static bool verbose = false;
     65static int sockets = 10;
     66static int messages = 10;
     67static uint16_t port = 7;
    6568
    6669static struct sockaddr *address;
    6770static socklen_t addrlen;
    6871
    69 static int sockets;
    70 static int messages;
    71 static uint16_t port;
     72static char *data;
    7273
    7374static void nettest1_print_help(void)
    … …  
    7576        printf(
    7677            "Network Networking test 1 aplication - sockets\n"
    77             "Usage: echo [options] numeric_address\n"
     78            "Usage: nettest1 [options] host\n"
    7879            "Where options are:\n"
    7980            "-f protocol_family | --family=protocol_family\n"
    … …  
    113114        int value;
    114115        int rc;
    115 
     116       
    116117        switch (argv[*index][1]) {
    117118        /*
    … …  
    119120         */
    120121        case 'f':
    121                 rc = arg_parse_name_int(argc, argv, index, &family, 0, socket_parse_protocol_family);
    122                 if (rc != EOK)
    123                         return rc;
     122                rc = arg_parse_name_int(argc, argv, index, &value, 0,
     123                    socket_parse_protocol_family);
     124                if (rc != EOK)
     125                        return rc;
     126               
     127                family = (uint16_t) value;
    124128                break;
    125129        case 'h':
    … …  
    130134                if (rc != EOK)
    131135                        return rc;
     136               
    132137                break;
    133138        case 'n':
    … …  
    135140                if (rc != EOK)
    136141                        return rc;
     142               
    137143                break;
    138144        case 'p':
    … …  
    140146                if (rc != EOK)
    141147                        return rc;
     148               
    142149                port = (uint16_t) value;
    143150                break;
    … …  
    146153                if (rc != EOK)
    147154                        return rc;
     155               
    148156                size = (value >= 0) ? (size_t) value : 0;
    149157                break;
    150158        case 't':
    151                 rc = arg_parse_name_int(argc, argv, index, &value, 0, socket_parse_socket_type);
    152                 if (rc != EOK)
    153                         return rc;
     159                rc = arg_parse_name_int(argc, argv, index, &value, 0,
     160                    socket_parse_socket_type);
     161                if (rc != EOK)
     162                        return rc;
     163               
    154164                type = (sock_type_t) value;
    155165                break;
    … …  
    157167                verbose = 1;
    158168                break;
     169       
    159170        /*
    160171         * Long options with double dash ('-')
    … …  
    162173        case '-':
    163174                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    164                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     175                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    165176                            socket_parse_protocol_family);
    166177                        if (rc != EOK)
    167178                                return rc;
     179                       
     180                        family = (uint16_t) value;
    168181                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    169182                        nettest1_print_help();
    … …  
    181194                        if (rc != EOK)
    182195                                return rc;
     196                       
    183197                        port = (uint16_t) value;
    184198                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    187201                        if (rc != EOK)
    188202                                return rc;
     203                       
    189204                        type = (sock_type_t) value;
    190205                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    199214                return EINVAL;
    200215        }
    201 
     216       
    202217        return EOK;
    203218}
    … …  
    210225static void nettest1_fill_buffer(char *buffer, size_t size)
    211226{
    212         size_t length;
    213 
    214         length = 0;
     227        size_t length = 0;
    215228        while (size > length + sizeof(NETTEST1_TEXT) - 1) {
    216229                memcpy(buffer + length, NETTEST1_TEXT,
    … …  
    218231                length += sizeof(NETTEST1_TEXT) - 1;
    219232        }
    220 
     233       
    221234        memcpy(buffer + length, NETTEST1_TEXT, size - length);
    222235        buffer[size] = '\0';
    … …  
    225238static int nettest1_test(int *socket_ids, int nsockets, int nmessages)
    226239{
    227         int rc;
    228 
    229240        if (verbose)
    230241                printf("%d sockets, %d messages\n", nsockets, nmessages);
    231 
    232         rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    233         if (rc != EOK)
    234                 return rc;
    235 
     242       
     243        int rc = sockets_create(verbose, socket_ids, nsockets, family, type);
     244        if (rc != EOK)
     245                return rc;
     246       
    236247        if (type == SOCK_STREAM) {
    237248                rc = sockets_connect(verbose, socket_ids, nsockets, address,
    … …  
    240251                        return rc;
    241252        }
    242 
     253       
    243254        rc = sockets_sendto_recvfrom(verbose, socket_ids, nsockets, address,
    244             &addrlen, data, size, nmessages);
    245         if (rc != EOK)
    246                 return rc;
    247 
     255            &addrlen, data, size, nmessages, type);
     256        if (rc != EOK)
     257                return rc;
     258       
    248259        rc = sockets_close(verbose, socket_ids, nsockets);
    249260        if (rc != EOK)
    250261                return rc;
    251 
     262       
    252263        if (verbose)
    253264                printf("\tOK\n");
    254 
     265       
    255266        /****/
    256 
     267       
    257268        rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    258269        if (rc != EOK)
    259270                return rc;
    260 
     271       
    261272        if (type == SOCK_STREAM) {
    262273                rc = sockets_connect(verbose, socket_ids, nsockets, address,
    … …  
    265276                        return rc;
    266277        }
    267 
     278       
    268279        rc = sockets_sendto(verbose, socket_ids, nsockets, address, addrlen,
    269             data, size, nmessages);
    270         if (rc != EOK)
    271                 return rc;
    272 
     280            data, size, nmessages, type);
     281        if (rc != EOK)
     282                return rc;
     283       
    273284        rc = sockets_recvfrom(verbose, socket_ids, nsockets, address, &addrlen,
    274285            data, size, nmessages);
    275286        if (rc != EOK)
    276287                return rc;
    277 
     288       
    278289        rc = sockets_close(verbose, socket_ids, nsockets);
    279290        if (rc != EOK)
    280291                return rc;
    281 
     292       
    282293        if (verbose)
    283294                printf("\tOK\n");
    284 
     295       
    285296        return EOK;
    286297}
    … …  
    288299int main(int argc, char *argv[])
    289300{
    290         struct sockaddr_in address_in;
    291         struct sockaddr_in6 address_in6;
    292         uint8_t *address_start;
    293 
    294         int *socket_ids;
    295         int index;
    296         struct timeval time_before;
    297         struct timeval time_after;
    298 
    299         int rc;
    300 
    301         sockets = 10;
    302         messages = 10;
    303         port = 7;
    304 
    305301        /*
    306302         * Parse the command line arguments. Stop before the last argument
    307303         * if it does not start with dash ('-')
    308304         */
    309         for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); index++) {
     305        int index;
     306        int rc;
     307       
     308        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
     309            (argv[index][0] == '-')); index++) {
    310310                /* Options should start with dash ('-') */
    311311                if (argv[index][0] == '-') {
    … …  
    318318                }
    319319        }
    320 
    321         /* If not before the last argument containing the address */
     320       
     321        /* The last argument containing the host */
    322322        if (index >= argc) {
    323                 printf("Command line error: missing address\n");
     323                printf("Host name missing.\n");
    324324                nettest1_print_help();
    325325                return EINVAL;
    326326        }
    327 
     327       
     328        char *addr_s = argv[argc - 1];
     329       
     330        /* Interpret as address */
     331        inet_addr_t addr_addr;
     332        rc = inet_addr_parse(addr_s, &addr_addr);
     333       
     334        if (rc != EOK) {
     335                /* Interpret as a host name */
     336                dnsr_hostinfo_t *hinfo = NULL;
     337                rc = dnsr_name2host(addr_s, &hinfo, family);
     338               
     339                if (rc != EOK) {
     340                        printf("Error resolving host '%s'.\n", addr_s);
     341                        return EINVAL;
     342                }
     343               
     344                addr_addr = hinfo->addr;
     345        }
     346       
     347        struct sockaddr_in addr;
     348        struct sockaddr_in6 addr6;
     349        uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
     350       
     351        if (af != family) {
     352                printf("Address family does not match explicitly set family.\n");
     353                return EINVAL;
     354        }
     355       
    328356        /* Prepare the address buffer */
    329 
    330         switch (family) {
    331         case PF_INET:
    332                 address_in.sin_family = AF_INET;
    333                 address_in.sin_port = htons(port);
    334                 address = (struct sockaddr *) &address_in;
    335                 addrlen = sizeof(address_in);
    336                 address_start = (uint8_t *) &address_in.sin_addr.s_addr;
    337                 break;
    338         case PF_INET6:
    339                 address_in6.sin6_family = AF_INET6;
    340                 address_in6.sin6_port = htons(port);
    341                 address = (struct sockaddr *) &address_in6;
    342                 addrlen = sizeof(address_in6);
    343                 address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
     357       
     358        switch (af) {
     359        case AF_INET:
     360                addr.sin_port = htons(port);
     361                address = (struct sockaddr *) &addr;
     362                addrlen = sizeof(addr);
     363                break;
     364        case AF_INET6:
     365                addr6.sin6_port = htons(port);
     366                address = (struct sockaddr *) &addr6;
     367                addrlen = sizeof(addr6);
    344368                break;
    345369        default:
    … …  
    347371                return EAFNOSUPPORT;
    348372        }
    349 
    350         /* Parse the last argument which should contain the address */
    351         rc = inet_pton(family, argv[argc - 1], address_start);
    352         if (rc != EOK) {
    353                 fprintf(stderr, "Address parse error %d\n", rc);
    354                 return rc;
    355         }
    356 
     373       
    357374        /* Check data buffer size */
    358375        if (size <= 0) {
    … …  
    361378                size = 1024;
    362379        }
    363 
     380       
    364381        /*
    365382         * Prepare data buffer. Allocate size bytes plus one for the
    … …  
    372389        }
    373390        nettest1_fill_buffer(data, size);
    374 
     391       
    375392        /* Check socket count */
    376393        if (sockets <= 0) {
    … …  
    379396                sockets = 2;
    380397        }
    381 
     398       
    382399        /*
    383400         * Prepare socket buffer. Allocate count fields plus the terminating
    384401         * null (\0).
    385402         */
    386         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     403        int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    387404        if (!socket_ids) {
    388405                fprintf(stderr, "Failed to allocate receive buffer.\n");
    389406                return ENOMEM;
    390407        }
     408       
    391409        socket_ids[sockets] = 0;
    392 
     410       
    393411        if (verbose)
    394412                printf("Starting tests\n");
    395 
     413       
     414        struct timeval time_before;
    396415        rc = gettimeofday(&time_before, NULL);
    397416        if (rc != EOK) {
    … …  
    399418                return rc;
    400419        }
    401 
     420       
    402421        nettest1_test(socket_ids,       1,        1);
    403422        nettest1_test(socket_ids,       1, messages);
    404423        nettest1_test(socket_ids, sockets,        1);
    405424        nettest1_test(socket_ids, sockets, messages);
    406 
     425       
     426        struct timeval time_after;
    407427        rc = gettimeofday(&time_after, NULL);
    408428        if (rc != EOK) {
    … …  
    410430                return rc;
    411431        }
    412 
     432       
    413433        printf("Tested in %ld microseconds\n", tv_sub(&time_after,
    414434            &time_before));
    415 
     435       
    416436        if (verbose)
    417437                printf("Exiting\n");
    418 
     438       
    419439        return EOK;
    420440}
    421441
    422 
    423442/** @}
    424443 */

  • uspace/app/nettest2/nettest2.c

    r52f1882 rdb71e2a  
    4747#include <stdbool.h>
    4848
     49#include <inet/dnsr.h>
    4950#include <net/in.h>
    5051#include <net/in6.h>
    … …  
    5455
    5556/** Echo module name. */
    56 #define NAME    "Nettest2"
     57#define NAME  "nettest2"
    5758
    5859/** Packet data pattern. */
    59 #define NETTEST2_TEXT   "Networking test 2 - transfer"
    60 
    61 static size_t size;
    62 static bool verbose;
    63 static sock_type_t type;
    64 static int sockets;
    65 static int messages;
    66 static int family;
    67 static uint16_t port;
     60#define NETTEST2_TEXT  "Networking test 2 - transfer"
     61
     62static uint16_t family = PF_INET;
     63static size_t size = 28;
     64static bool verbose = false;
     65static sock_type_t type = SOCK_DGRAM;
     66static int sockets = 10;
     67static int messages = 10;
     68static uint16_t port = 7;
    6869
    6970static void nettest2_print_help(void)
    … …  
    7172        printf(
    7273            "Network Networking test 2 aplication - UDP transfer\n"
    73             "Usage: echo [options] address\n"
     74            "Usage: nettest2 [options] host\n"
    7475            "Where options are:\n"
    7576            "-f protocol_family | --family=protocol_family\n"
    … …  
    106107static void nettest2_fill_buffer(char *buffer, size_t size)
    107108{
    108         size_t length;
    109 
    110         length = 0;
     109        size_t length = 0;
    111110        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    112111                memcpy(buffer + length, NETTEST2_TEXT,
    … …  
    114113                length += sizeof(NETTEST2_TEXT) - 1;
    115114        }
    116 
     115       
    117116        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    118117        buffer[size] = '\0';
    … …  
    129128        int value;
    130129        int rc;
    131 
     130       
    132131        switch (argv[*index][1]) {
    133132        /*
    … …  
    135134         */
    136135        case 'f':
    137                 rc = arg_parse_name_int(argc, argv, index, &family, 0,
     136                rc = arg_parse_name_int(argc, argv, index, &value, 0,
    138137                    socket_parse_protocol_family);
    139138                if (rc != EOK)
    140139                        return rc;
     140               
     141                family = (uint16_t) value;
    141142                break;
    142143        case 'h':
    143144                nettest2_print_help();
    144145                return EOK;
    145                 break;
    146146        case 'm':
    147147                rc = arg_parse_int(argc, argv, index, &messages, 0);
    148148                if (rc != EOK)
    149149                        return rc;
     150               
    150151                break;
    151152        case 'n':
    … …  
    153154                if (rc != EOK)
    154155                        return rc;
     156               
    155157                break;
    156158        case 'p':
    … …  
    158160                if (rc != EOK)
    159161                        return rc;
     162               
    160163                port = (uint16_t) value;
    161164                break;
    … …  
    164167                if (rc != EOK)
    165168                        return rc;
     169               
    166170                size = (value >= 0) ? (size_t) value : 0;
    167171                break;
    … …  
    171175                if (rc != EOK)
    172176                        return rc;
     177               
    173178                type = (sock_type_t) value;
    174179                break;
    … …  
    176181                verbose = true;
    177182                break;
     183       
    178184        /*
    179185         * Long options with double dash ('-')
    … …  
    181187        case '-':
    182188                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    183                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     189                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    184190                            socket_parse_protocol_family);
    185191                        if (rc != EOK)
    186192                                return rc;
     193                       
     194                        family = (uint16_t) value;
    187195                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    188196                        nettest2_print_help();
    … …  
    200208                        if (rc != EOK)
    201209                                return rc;
     210                       
    202211                        port = (uint16_t) value;
    203212                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    206215                        if (rc != EOK)
    207216                                return rc;
     217                       
    208218                        type = (sock_type_t) value;
    209219                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    218228                return EINVAL;
    219229        }
    220 
     230       
    221231        return EOK;
    222232}
    … …  
    224234int main(int argc, char *argv[])
    225235{
    226         struct sockaddr *address;
    227         struct sockaddr_in address_in;
    228         struct sockaddr_in6 address_in6;
    229         socklen_t addrlen;
    230         uint8_t *address_start;
    231 
    232         int *socket_ids;
    233         char *data;
    234236        int index;
    235         struct timeval time_before;
    236         struct timeval time_after;
    237 
    238237        int rc;
    239 
    240         size = 28;
    241         verbose = false;
    242         type = SOCK_DGRAM;
    243         sockets = 10;
    244         messages = 10;
    245         family = PF_INET;
    246         port = 7;
    247 
     238       
    248239        /*
    249240         * Parse the command line arguments.
    … …  
    253244        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    254245            (argv[index][0] == '-')); ++index) {
    255 
    256246                /* Options should start with dash ('-') */
    257247                if (argv[index][0] == '-') {
    … …  
    264254                }
    265255        }
    266 
    267         /* If not before the last argument containing the address */
     256       
     257        /* The last argument containing the host */
    268258        if (index >= argc) {
    269                 printf("Command line error: missing address\n");
     259                printf("Host name missing.\n");
    270260                nettest2_print_help();
    271261                return EINVAL;
    272262        }
    273 
     263       
     264        char *addr_s = argv[argc - 1];
     265       
     266        /* Interpret as address */
     267        inet_addr_t addr_addr;
     268        rc = inet_addr_parse(addr_s, &addr_addr);
     269       
     270        if (rc != EOK) {
     271                /* Interpret as a host name */
     272                dnsr_hostinfo_t *hinfo = NULL;
     273                rc = dnsr_name2host(addr_s, &hinfo, family);
     274               
     275                if (rc != EOK) {
     276                        printf("Error resolving host '%s'.\n", addr_s);
     277                        return EINVAL;
     278                }
     279               
     280                addr_addr = hinfo->addr;
     281        }
     282       
     283        struct sockaddr_in addr;
     284        struct sockaddr_in6 addr6;
     285        uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
     286       
     287        if (af != family) {
     288                printf("Address family does not match explicitly set family.\n");
     289                return EINVAL;
     290        }
     291       
    274292        /* Prepare the address buffer */
    275 
    276         switch (family) {
    277         case PF_INET:
    278                 address_in.sin_family = AF_INET;
    279                 address_in.sin_port = htons(port);
    280                 address = (struct sockaddr *) &address_in;
    281                 addrlen = sizeof(address_in);
    282                 address_start = (uint8_t *) &address_in.sin_addr.s_addr;
    283                 break;
    284         case PF_INET6:
    285                 address_in6.sin6_family = AF_INET6;
    286                 address_in6.sin6_port = htons(port);
    287                 address = (struct sockaddr *) &address_in6;
    288                 addrlen = sizeof(address_in6);
    289                 address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
     293       
     294        struct sockaddr *address;
     295        socklen_t addrlen;
     296       
     297        switch (af) {
     298        case AF_INET:
     299                addr.sin_port = htons(port);
     300                address = (struct sockaddr *) &addr;
     301                addrlen = sizeof(addr);
     302                break;
     303        case AF_INET6:
     304                addr6.sin6_port = htons(port);
     305                address = (struct sockaddr *) &addr6;
     306                addrlen = sizeof(addr6);
    290307                break;
    291308        default:
    … …  
    293310                return EAFNOSUPPORT;
    294311        }
    295 
    296         /* Parse the last argument which should contain the address. */
    297         rc = inet_pton(family, argv[argc - 1], address_start);
    298         if (rc != EOK) {
    299                 fprintf(stderr, "Address parse error %d\n", rc);
    300                 return rc;
    301         }
    302 
     312       
    303313        /* Check data buffer size. */
    304314        if (size <= 0) {
    … …  
    307317                size = 1024;
    308318        }
    309 
     319       
    310320        /*
    311321         * Prepare the buffer. Allocate size bytes plus one for terminating
    312322         * null character.
    313323         */
    314         data = (char *) malloc(size + 1);
     324        char *data = (char *) malloc(size + 1);
    315325        if (!data) {
    316326                fprintf(stderr, "Failed to allocate data buffer.\n");
    317327                return ENOMEM;
    318328        }
    319 
     329       
    320330        /* Fill buffer with a pattern. */
    321331        nettest2_fill_buffer(data, size);
    322 
     332       
    323333        /* Check socket count. */
    324334        if (sockets <= 0) {
    … …  
    327337                sockets = 2;
    328338        }
    329 
     339       
    330340        /*
    331341         * Prepare the socket buffer.
    332342         * Allocate count entries plus the terminating null (\0)
    333343         */
    334         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     344        int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    335345        if (!socket_ids) {
    336346                fprintf(stderr, "Failed to allocate receive buffer.\n");
    337347                return ENOMEM;
    338348        }
     349       
    339350        socket_ids[sockets] = 0;
    340 
     351       
    341352        if (verbose)
    342353                printf("Starting tests\n");
    343 
     354       
    344355        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    345356        if (rc != EOK)
    346357                return rc;
    347 
     358       
    348359        if (type == SOCK_STREAM) {
    349360                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    352363                        return rc;
    353364        }
    354 
     365       
    355366        if (verbose)
    356367                printf("\n");
    357 
     368       
     369        struct timeval time_before;
    358370        rc = gettimeofday(&time_before, NULL);
    359371        if (rc != EOK) {
    … …  
    361373                return rc;
    362374        }
    363 
     375       
    364376        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    365             &addrlen, data, size, messages);
     377            &addrlen, data, size, messages, type);
    366378        if (rc != EOK)
    367379                return rc;
    368 
     380       
     381        struct timeval time_after;
    369382        rc = gettimeofday(&time_after, NULL);
    370383        if (rc != EOK) {
    … …  
    372385                return rc;
    373386        }
    374 
     387       
    375388        if (verbose)
    376389                printf("\tOK\n");
    377 
     390       
    378391        printf("sendto + recvfrom tested in %ld microseconds\n",
    379392            tv_sub(&time_after, &time_before));
    380 
     393       
    381394        rc = gettimeofday(&time_before, NULL);
    382395        if (rc != EOK) {
    … …  
    384397                return rc;
    385398        }
    386 
     399       
    387400        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    388             data, size, messages);
     401            data, size, messages, type);
    389402        if (rc != EOK)
    390403                return rc;
    391 
     404       
    392405        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    393406            data, size, messages);
    394407        if (rc != EOK)
    395408                return rc;
    396 
     409       
    397410        rc = gettimeofday(&time_after, NULL);
    398411        if (rc != EOK) {
    … …  
    400413                return rc;
    401414        }
    402 
     415       
    403416        if (verbose)
    404417                printf("\tOK\n");
    405 
     418       
    406419        printf("sendto, recvfrom tested in %ld microseconds\n",
    407420            tv_sub(&time_after, &time_before));
    408 
     421       
    409422        rc = sockets_close(verbose, socket_ids, sockets);
    410423        if (rc != EOK)
    411424                return rc;
    412 
     425       
    413426        if (verbose)
    414427                printf("\nExiting\n");
    415 
     428       
    416429        return EOK;
    417430}

  • uspace/app/nettest3/nettest3.c

    r52f1882 rdb71e2a  
    3939#include <str.h>
    4040
     41#include <inet/dnsr.h>
    4142#include <net/in.h>
    4243#include <net/in6.h>
    … …  
    6061        int fd;
    6162        char *endptr;
     63        dnsr_hostinfo_t *hinfo;
    6264
    6365        port = 7;
    6466
    65         data = (char *)"Hello World!";
     67        data = (char *) "Hello World!";
    6668        size = str_size(data);
    6769
    … …  
    7577                rc = inet_pton(AF_INET, argv[1], (uint8_t *)&addr.sin_addr.s_addr);
    7678                if (rc != EOK) {
    77                         fprintf(stderr, "Error parsing address\n");
    78                         return 1;
     79                        /* Try interpreting as a host name */
     80                        rc = dnsr_name2host(argv[1], &hinfo, AF_INET);
     81                        if (rc != EOK) {
     82                                printf("Error resolving host '%s'.\n", argv[1]);
     83                                return rc;
     84                        }
     85                       
     86                        uint16_t af = inet_addr_sockaddr_in(&hinfo->addr, &addr, NULL);
     87                        if (af != AF_INET) {
     88                                printf("Host '%s' not resolved as IPv4 address.\n", argv[1]);
     89                                return rc;
     90                        }
    7991                }
    8092                printf("result: rc=%d, family=%d, addr=%x\n", rc,
    … …  
    98110
    99111        printf("connect()\n");
    100         rc = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
     112        rc = connect(fd, (struct sockaddr *) &addr, sizeof(addr));
    101113        printf(" -> %d\n", rc);
    102114        if (rc != 0)
    … …  
    115127        } while (rc > 0);
    116128
    117         async_usleep(1000*1000);
     129        async_usleep(1000 * 1000);
    118130
    119131        printf("closesocket()\n");
    … …  
    124136}
    125137
    126 
    127138/** @}
    128139 */

  • uspace/app/nterm/conn.c

    r52f1882 rdb71e2a  
    3333 */
    3434
     35#include <byteorder.h>
    3536#include <stdbool.h>
    3637#include <errno.h>
    3738#include <fibril.h>
     39#include <inet/dnsr.h>
    3840#include <net/socket.h>
    3941#include <stdio.h>
    … …  
    7375int conn_open(const char *addr_s, const char *port_s)
    7476{
     77        int conn_fd = -1;
     78       
     79        /* Interpret as address */
     80        inet_addr_t addr_addr;
     81        int rc = inet_addr_parse(addr_s, &addr_addr);
     82       
     83        if (rc != EOK) {
     84                /* Interpret as a host name */
     85                dnsr_hostinfo_t *hinfo = NULL;
     86                rc = dnsr_name2host(addr_s, &hinfo, 0);
     87               
     88                if (rc != EOK) {
     89                        printf("Error resolving host '%s'.\n", addr_s);
     90                        goto error;
     91                }
     92               
     93                addr_addr = hinfo->addr;
     94        }
     95       
    7596        struct sockaddr_in addr;
    76         int rc;
     97        struct sockaddr_in6 addr6;
     98        uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
     99       
    77100        char *endptr;
    78 
    79         addr.sin_family = AF_INET;
    80 
    81         rc = inet_pton(addr.sin_family, addr_s, (uint8_t *)&addr.sin_addr);
    82         if (rc != EOK) {
    83                 printf("Invalid addres %s\n", addr_s);
    84                 return EINVAL;
    85         }
    86 
    87         addr.sin_port = htons(strtol(port_s, &endptr, 10));
     101        uint16_t port = strtol(port_s, &endptr, 10);
    88102        if (*endptr != '\0') {
    89103                printf("Invalid port number %s\n", port_s);
    90                 return EINVAL;
     104                goto error;
    91105        }
    92 
     106       
     107        printf("Connecting to host %s port %u\n", addr_s, port);
     108       
    93109        conn_fd = socket(PF_INET, SOCK_STREAM, 0);
    94110        if (conn_fd < 0)
    95111                goto error;
    96 
    97         printf("Connecting to address %s port %u\n", addr_s, ntohs(addr.sin_port));
    98 
    99         rc = connect(conn_fd, (struct sockaddr *)&addr, sizeof(addr));
     112       
     113        switch (af) {
     114        case AF_INET:
     115                addr.sin_port = htons(port);
     116                rc = connect(conn_fd, (struct sockaddr *) &addr, sizeof(addr));
     117                break;
     118        case AF_INET6:
     119                addr6.sin6_port = htons(port);
     120                rc = connect(conn_fd, (struct sockaddr *) &addr6, sizeof(addr6));
     121                break;
     122        default:
     123                printf("Unknown address family.\n");
     124                goto error;
     125        }
     126       
    100127        if (rc != EOK)
    101128                goto error;
    102 
     129       
    103130        rcv_fid = fibril_create(rcv_fibril, NULL);
    104131        if (rcv_fid == 0)
    105132                goto error;
    106 
     133       
    107134        fibril_add_ready(rcv_fid);
    108 
     135       
    109136        return EOK;
    110 
     137       
    111138error:
    112139        if (conn_fd >= 0) {
    … …  
    114141                conn_fd = -1;
    115142        }
    116 
     143       
    117144        return EIO;
    118145}
    … …  
    120147int conn_send(void *data, size_t size)
    121148{
    122         int rc;
    123 
    124         rc = send(conn_fd, data, size, 0);
     149        int rc = send(conn_fd, data, size, 0);
    125150        if (rc != EOK)
    126151                return EIO;
    127 
     152       
    128153        return EOK;
    129154}

  • uspace/app/nterm/nterm.c

    r52f1882 rdb71e2a  
    104104static void print_syntax(void)
    105105{
    106         printf("syntax: nterm <ip-address> <port>\n");
     106        printf("syntax: nterm <host> <port>\n");
    107107}
    108108
    109109int main(int argc, char *argv[])
    110110{
    111         kbd_event_t ev;
     111        cons_event_t ev;
    112112        int rc;
    113113
    … …  
    129129        done = false;
    130130        while (!done) {
    131                 console_get_kbd_event(con, &ev);
    132                 if (ev.type == KEY_PRESS)
    133                         key_handle(&ev);
     131                console_get_event(con, &ev);
     132                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS)
     133                        key_handle(&ev.ev.key);
    134134        }
    135135

  • uspace/app/pcc/config.h

    r52f1882 rdb71e2a  
    5050
    5151/* Define to 1 if you have the `mkstemp' function. */
    52 //#define HAVE_MKSTEMP 1
     52#define HAVE_MKSTEMP 1
    5353
    5454/* Define to 1 if you have the `snprintf' function. */

  • uspace/app/ping/ping.c

    r52f1882 rdb71e2a  
    11/*
    2  * Copyright (c) 2012 Jiri Svoboda
     2 * Copyright (c) 2013 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    3737#include <errno.h>
    3838#include <fibril_synch.h>
     39#include <net/socket_codes.h>
     40#include <inet/dnsr.h>
     41#include <inet/addr.h>
    3942#include <inet/inetping.h>
    4043#include <io/console.h>
    … …  
    6164};
    6265
    63 static inet_addr_t src_addr;
    64 static inet_addr_t dest_addr;
     66static addr32_t src;
     67static addr32_t dest;
    6568
    6669static bool ping_repeat = false;
    … …  
    6871static void print_syntax(void)
    6972{
    70         printf("syntax: " NAME " [-r] <addr>\n");
    71 }
    72 
    73 static int addr_parse(const char *text, inet_addr_t *addr)
    74 {
    75         unsigned long a[4];
    76         char *cp = (char *)text;
    77         int i;
    78 
    79         for (i = 0; i < 3; i++) {
    80                 a[i] = strtoul(cp, &cp, 10);
    81                 if (*cp != '.')
    82                         return EINVAL;
    83                 ++cp;
    84         }
    85 
    86         a[3] = strtoul(cp, &cp, 10);
    87         if (*cp != '\0')
    88                 return EINVAL;
    89 
    90         addr->ipv4 = 0;
    91         for (i = 0; i < 4; i++) {
    92                 if (a[i] > 255)
    93                         return EINVAL;
    94                 addr->ipv4 = (addr->ipv4 << 8) | a[i];
    95         }
    96 
    97         return EOK;
    98 }
    99 
    100 static int addr_format(inet_addr_t *addr, char **bufp)
    101 {
    102         int rc;
    103 
    104         rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
    105             (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
    106             addr->ipv4 & 0xff);
    107 
    108         if (rc < 0)
    109                 return ENOMEM;
    110 
    111         return EOK;
     73        printf("syntax: " NAME " [-r] <host>\n");
    11274}
    11375
    … …  
    12284static int ping_ev_recv(inetping_sdu_t *sdu)
    12385{
    124         char *asrc, *adest;
    125         int rc;
    126 
    127         rc = addr_format(&sdu->src, &asrc);
     86        inet_addr_t src_addr;
     87        inet_addr_set(sdu->src, &src_addr);
     88       
     89        inet_addr_t dest_addr;
     90        inet_addr_set(sdu->dest, &dest_addr);
     91       
     92        char *asrc;
     93        int rc = inet_addr_format(&src_addr, &asrc);
    12894        if (rc != EOK)
    12995                return ENOMEM;
    130 
    131         rc = addr_format(&sdu->dest, &adest);
     96       
     97        char *adest;
     98        rc = inet_addr_format(&dest_addr, &adest);
    13299        if (rc != EOK) {
    133100                free(asrc);
    134101                return ENOMEM;
    135102        }
     103       
    136104        printf("Received ICMP echo reply: from %s to %s, seq. no %u, "
    137105            "payload size %zu\n", asrc, adest, sdu->seq_no, sdu->size);
    138 
    139         if (!ping_repeat) {
     106       
     107        if (!ping_repeat)
    140108                ping_signal_done();
    141         }
    142 
     109       
    143110        free(asrc);
    144111        free(adest);
    … …  
    151118        int rc;
    152119
    153         sdu.src = src_addr;
    154         sdu.dest = dest_addr;
     120        sdu.src = src;
     121        sdu.dest = dest;
    155122        sdu.seq_no = seq_no;
    156123        sdu.data = (void *) "foo";
    … …  
    188155{
    189156        console_ctrl_t *con;
    190         kbd_event_t ev;
     157        cons_event_t ev;
    191158
    192159        con = console_init(stdin, stdout);
    … …  
    194161
    195162        while (true) {
    196                 if (!console_get_kbd_event(con, &ev))
     163                if (!console_get_event(con, &ev))
    197164                        break;
    198165
    199                 if (ev.type == KEY_PRESS && (ev.mods & (KM_ALT | KM_SHIFT)) ==
    200                     0 && (ev.mods & KM_CTRL) != 0) {
     166                if (ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS &&
     167                    (ev.ev.key.mods & (KM_ALT | KM_SHIFT)) ==
     168                    0 && (ev.ev.key.mods & KM_CTRL) != 0) {
    201169                        /* Ctrl+key */
    202                         if (ev.key == KC_Q) {
     170                        if (ev.ev.key.key == KC_Q) {
    203171                                ping_signal_done();
    204172                                return 0;
    … …  
    212180int main(int argc, char *argv[])
    213181{
     182        dnsr_hostinfo_t *hinfo = NULL;
     183        char *asrc = NULL;
     184        char *adest = NULL;
     185        char *sdest = NULL;
    214186        int rc;
    215187        int argi;
    … …  
    219191                printf(NAME ": Failed connecting to internet ping service "
    220192                    "(%d).\n", rc);
    221                 return 1;
     193                goto error;
    222194        }
    223195
    … …  
    232204        if (argc - argi != 1) {
    233205                print_syntax();
    234                 return 1;
     206                goto error;
    235207        }
    236208
    237209        /* Parse destination address */
    238         rc = addr_parse(argv[argi], &dest_addr);
    239         if (rc != EOK) {
    240                 printf(NAME ": Invalid address format.\n");
    241                 print_syntax();
    242                 return 1;
    243         }
    244 
     210        inet_addr_t dest_addr;
     211        rc = inet_addr_parse(argv[argi], &dest_addr);
     212        if (rc != EOK) {
     213                /* Try interpreting as a host name */
     214                rc = dnsr_name2host(argv[argi], &hinfo, AF_INET);
     215                if (rc != EOK) {
     216                        printf(NAME ": Error resolving host '%s'.\n", argv[argi]);
     217                        goto error;
     218                }
     219               
     220                dest_addr = hinfo->addr;
     221        }
     222       
     223        uint16_t af = inet_addr_get(&dest_addr, &dest, NULL);
     224        if (af != AF_INET) {
     225                printf(NAME ": Destination '%s' is not an IPv4 address.\n",
     226                    argv[argi]);
     227                goto error;
     228        }
     229       
    245230        /* Determine source address */
    246         rc = inetping_get_srcaddr(&dest_addr, &src_addr);
     231        rc = inetping_get_srcaddr(dest, &src);
    247232        if (rc != EOK) {
    248233                printf(NAME ": Failed determining source address.\n");
    249                 return 1;
    250         }
     234                goto error;
     235        }
     236       
     237        inet_addr_t src_addr;
     238        inet_addr_set(src, &src_addr);
     239       
     240        rc = inet_addr_format(&src_addr, &asrc);
     241        if (rc != EOK) {
     242                printf(NAME ": Out of memory.\n");
     243                goto error;
     244        }
     245       
     246        rc = inet_addr_format(&dest_addr, &adest);
     247        if (rc != EOK) {
     248                printf(NAME ": Out of memory.\n");
     249                goto error;
     250        }
     251       
     252        if (hinfo != NULL) {
     253                rc = asprintf(&sdest, "%s (%s)", hinfo->cname, adest);
     254                if (rc < 0) {
     255                        printf(NAME ": Out of memory.\n");
     256                        goto error;
     257                }
     258        } else {
     259                sdest = adest;
     260                adest = NULL;
     261        }
     262
     263        printf("Sending ICMP echo request from %s to %s.\n",
     264            asrc, sdest);
    251265
    252266        fid_t fid;
    … …  
    256270                if (fid == 0) {
    257271                        printf(NAME ": Failed creating transmit fibril.\n");
    258                         return 1;
     272                        goto error;
    259273                }
    260274
    … …  
    264278                if (fid == 0) {
    265279                        printf(NAME ": Failed creating input fibril.\n");
    266                         return 1;
     280                        goto error;
    267281                }
    268282
    … …  
    282296        if (rc == ETIMEOUT) {
    283297                printf(NAME ": Echo request timed out.\n");
    284                 return 1;
    285         }
    286 
     298                goto error;
     299        }
     300
     301        free(asrc);
     302        free(adest);
     303        free(sdest);
     304        dnsr_hostinfo_destroy(hinfo);
    287305        return 0;
     306       
     307error:
     308        free(asrc);
     309        free(adest);
     310        free(sdest);
     311        dnsr_hostinfo_destroy(hinfo);
     312        return 1;
    288313}
    289314

  • uspace/app/taskdump/symtab.c

    r52f1882 rdb71e2a  
    267267                        continue;
    268268
    269                 if (best_name == NULL || (saddr <= addr && saddr > best_addr)) {
     269                if (saddr <= addr && (best_name == NULL || saddr > best_addr)) {
    270270                        best_name = sname;
    271271                        best_addr = saddr;

  • uspace/app/tester/ipc/starve.c

    r52f1882 rdb71e2a  
    6262                        break;
    6363               
    64                 kbd_event_t ev;
     64                cons_event_t ev;
    6565                suseconds_t timeout = 0;
    66                 bool has_event = console_get_kbd_event_timeout(console, &ev, &timeout);
    67                 if (has_event && (ev.type == KEY_PRESS)) {
    68                         TPRINTF("Key %d pressed, terminating.\n", ev.key);
     66                bool has_event = console_get_event_timeout(console, &ev, &timeout);
     67                if (has_event && ev.type == CEV_KEY && ev.ev.key.type == KEY_PRESS) {
     68                        TPRINTF("Key %d pressed, terminating.\n", ev.ev.key.key);
    6969                        break;
    7070                }

  • uspace/app/tetris/scores.c

    r52f1882 rdb71e2a  
    125125        int j;
    126126        size_t off;
    127         kbd_event_t ev;
     127        cons_event_t ev;
     128        kbd_event_t *kev;
    128129       
    129130        clear_screen();
    … …  
    141142        while (1) {
    142143                console_flush(console);
    143                 if (!console_get_kbd_event(console, &ev))
     144                if (!console_get_event(console, &ev))
    144145                        exit(1);
    145146               
    146                 if (ev.type == KEY_RELEASE)
     147                if (ev.type != CEV_KEY || ev.ev.key.type == KEY_RELEASE)
    147148                        continue;
    148149               
    149                 if (ev.key == KC_ENTER || ev.key == KC_NENTER)
     150                kev = &ev.ev.key;
     151               
     152                if (kev->key == KC_ENTER || kev->key == KC_NENTER)
    150153                        break;
    151154               
    152                 if (ev.key == KC_BACKSPACE) {
     155                if (kev->key == KC_BACKSPACE) {
    153156                        if (i > 0) {
    154157                                wchar_t uc;
    … …  
    166169                                scores[NUMSPOTS - 1].hs_name[off] = '\0';
    167170                        }
    168                 } else if (ev.c != '\0') {
     171                } else if (kev->c != '\0') {
    169172                        if (i < (MAXLOGNAME - 1)) {
    170                                 if (chr_encode(ev.c, scores[NUMSPOTS - 1].hs_name,
     173                                if (chr_encode(kev->c, scores[NUMSPOTS - 1].hs_name,
    171174                                    &off, STR_BOUNDS(MAXLOGNAME) + 1) == EOK) {
    172175                                        ++i;

  • uspace/app/tetris/screen.c

    r52f1882 rdb71e2a  
    344344       
    345345        while (timeout > 0) {
    346                 kbd_event_t event;
    347                
    348                 if (!console_get_kbd_event_timeout(console, &event, &timeout))
     346                cons_event_t event;
     347               
     348                if (!console_get_event_timeout(console, &event, &timeout))
    349349                        break;
    350350        }
    … …  
    376376       
    377377        while (c == 0) {
    378                 kbd_event_t event;
    379                
    380                 if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
     378                cons_event_t event;
     379               
     380                if (!console_get_event_timeout(console, &event, &timeleft)) {
    381381                        timeleft = 0;
    382382                        return -1;
    383383                }
    384384               
    385                 if (event.type == KEY_PRESS)
    386                         c = event.c;
     385                if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
     386                        c = event.ev.key.c;
    387387        }
    388388       
    … …  
    398398       
    399399        while (c == 0) {
    400                 kbd_event_t event;
    401                
    402                 if (!console_get_kbd_event(console, &event))
     400                cons_event_t event;
     401               
     402                if (!console_get_event(console, &event))
    403403                        return -1;
    404404               
    405                 if (event.type == KEY_PRESS)
    406                         c = event.c;
     405                if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
     406                        c = event.ev.key.c;
    407407        }
    408408       

  • uspace/app/top/screen.c

    r52f1882 rdb71e2a  
    556556       
    557557        while (c == 0) {
    558                 kbd_event_t event;
     558                cons_event_t event;
    559559               
    560560                warning_timeleft -= timeleft;
    561                 if (!console_get_kbd_event_timeout(console, &event, &timeleft)) {
     561                if (!console_get_event_timeout(console, &event, &timeleft)) {
    562562                        timeleft = 0;
    563563                        return -1;
    … …  
    565565                warning_timeleft += timeleft;
    566566               
    567                 if (event.type == KEY_PRESS)
    568                         c = event.c;
     567                if (event.type == CEV_KEY && event.ev.key.type == KEY_PRESS)
     568                        c = event.ev.key.c;
    569569        }
    570570       

  • uspace/app/trace/ipc_desc.c

    r52f1882 rdb71e2a  
    4949        { IPC_M_DATA_READ,        "DATA_READ" },
    5050        { IPC_M_DEBUG,            "DEBUG" },
    51        
    52         /* Terminating entry */
    53         { 0, NULL }
    5451};
     52
     53size_t ipc_methods_len = sizeof(ipc_methods) / sizeof(ipc_m_desc_t);
    5554
    5655/** @}

  • uspace/app/trace/ipc_desc.h

    r52f1882 rdb71e2a  
    4242
    4343extern ipc_m_desc_t ipc_methods[];
     44extern size_t ipc_methods_len;
    4445
    4546#endif

  • uspace/app/trace/ipcp.c

    r52f1882 rdb71e2a  
    140140void ipcp_init(void)
    141141{
    142         ipc_m_desc_t *desc;
    143         oper_t *oper;
    144 
    145142        val_type_t arg_def[OPER_MAX_ARGS] = {
    146143                V_INTEGER,
    … …  
    162159        proto_system = proto_new("system");
    163160
    164         desc = ipc_methods;
    165         while (desc->number != 0) {
    166                 oper = oper_new(desc->name, OPER_MAX_ARGS, arg_def, V_INTEGER,
    167                         OPER_MAX_ARGS, arg_def);
    168                 proto_add_oper(proto_system, desc->number, oper);
    169 
    170                 ++desc;
     161        for (size_t i = 0; i < ipc_methods_len; i++) {
     162                oper_t *oper = oper_new(ipc_methods[i].name, OPER_MAX_ARGS,
     163                    arg_def, V_INTEGER, OPER_MAX_ARGS, arg_def);
     164                proto_add_oper(proto_system, ipc_methods[i].number, oper);
    171165        }
    172166

  • uspace/app/trace/syscalls.c

    r52f1882 rdb71e2a  
    4646
    4747    [SYS_TASK_GET_ID] = { "task_get_id",                1,      V_ERRNO },
     48    [SYS_TASK_SET_NAME] = { "task_set_name",            2,      V_ERRNO },
    4849    [SYS_FUTEX_SLEEP] = { "futex_sleep_timeout",        3,      V_ERRNO },
    4950    [SYS_FUTEX_WAKEUP] = { "futex_wakeup",              1,      V_ERRNO },
    … …  
    8283};
    8384
     85const size_t syscall_desc_len = (sizeof(syscall_desc) / sizeof(sc_desc_t));
     86
    8487/** @}
    8588 */

  • uspace/app/trace/syscalls.h

    r52f1882 rdb71e2a  
    3636#define SYSCALLS_H_
    3737
     38#include <stdbool.h>
     39#include <unistd.h>
     40
    3841#include "trace.h"
    3942
    … …  
    4548
    4649extern const sc_desc_t syscall_desc[];
     50extern const size_t syscall_desc_len;
     51
     52static inline bool syscall_desc_defined(unsigned sc_id)
     53{
     54        return (sc_id < syscall_desc_len && syscall_desc[sc_id].name != NULL);
     55}
    4756
    4857#endif

  • uspace/app/trace/trace.c

    r52f1882 rdb71e2a  
    136136        }
    137137
    138         free(task_ldr);
    139138        task_ldr = NULL;
    140139
    … …  
    348347        if ((display_mask & DM_SYSCALL) != 0) {
    349348                /* Print syscall name and arguments */
    350                 printf("%s", syscall_desc[sc_id].name);
    351                 print_sc_args(sc_args, syscall_desc[sc_id].n_args);
     349                if (syscall_desc_defined(sc_id)) {
     350                        printf("%s", syscall_desc[sc_id].name);
     351                        print_sc_args(sc_args, syscall_desc[sc_id].n_args);
     352                }
     353                else {
     354                        printf("unknown_syscall<%d>", sc_id);
     355                        print_sc_args(sc_args, 6);
     356                }
    352357        }
    353358}
    … …  
    372377        if ((display_mask & DM_SYSCALL) != 0) {
    373378                /* Print syscall return value */
    374                 rv_type = syscall_desc[sc_id].rv_type;
     379                if (syscall_desc_defined(sc_id))
     380                        rv_type = syscall_desc[sc_id].rv_type;
     381                else
     382                        rv_type = V_PTR;
    375383                print_sc_retval(sc_rc, rv_type);
    376384        }
    … …  
    497505        ldr = loader_connect();
    498506        if (ldr == NULL)
    499                 return 0;
     507                return NULL;
    500508
    501509        /* Get task ID. */
    … …  
    557565static int cev_fibril(void *arg)
    558566{
     567        cons_event_t event;
     568
    559569        (void) arg;
    560570       
    … …  
    567577                fibril_mutex_unlock(&state_lock);
    568578               
    569                 if (!console_get_kbd_event(console, &cev))
     579                if (!console_get_event(console, &event))
    570580                        return -1;
    571581               
    572                 fibril_mutex_lock(&state_lock);
    573                 cev_valid = true;
    574                 fibril_condvar_broadcast(&state_cv);
    575                 fibril_mutex_unlock(&state_lock);
     582                if (event.type == CEV_KEY) {
     583                        fibril_mutex_lock(&state_lock);
     584                        cev = event.ev.key;
     585                        cev_valid = true;
     586                        fibril_condvar_broadcast(&state_cv);
     587                        fibril_mutex_unlock(&state_lock);
     588                }
    576589        }
    577590}

  • uspace/app/vdemo/vdemo.c

    r52f1882 rdb71e2a  
    141141                    lbl_action->cancel);
    142142
    143                 grid->add(grid, &lbl_action->label.widget, 0, 0, 1, 2);
    144                 grid->add(grid, &btn_confirm->widget, 1, 0, 1, 1);
     143                grid->add(grid, &lbl_action->label.widget, 0, 0, 2, 1);
     144                grid->add(grid, &btn_confirm->widget, 0, 1, 1, 1);
    145145                grid->add(grid, &btn_cancel->widget, 1, 1, 1, 1);
    146                 window_resize(main_window, 200, 70);
     146                window_resize(main_window, 200, 76);
    147147
    148148                window_exec(main_window);

  • uspace/app/vlaunch/Makefile

    r52f1882 rdb71e2a  
    3535
    3636SOURCES = \
    37         vlaunch.c
     37        vlaunch.c \
     38        images.c
     39
     40IMAGES = \
     41        gfx/helenos.tga
     42
     43PRE_DEPEND = images.c images.h
     44EXTRA_CLEAN = images.c images.h
    3845
    3946include $(USPACE_PREFIX)/Makefile.common
     47
     48images.c images.h: $(IMAGES)
     49        $(ROOT_PATH)/tools/mkarray.py images COMPOSITOR_IMAGES $^

  • uspace/app/vlaunch/vlaunch.c

    r52f1882 rdb71e2a  
    4646#include <button.h>
    4747#include <label.h>
     48#include <canvas.h>
    4849
    49 #define NAME "vlaunch"
     50#include <surface.h>
     51#include <source.h>
     52#include <drawctx.h>
     53#include <codec/tga.h>
     54
     55#include "images.h"
     56
     57#define NAME  "vlaunch"
     58
     59#define LOGO_WIDTH   196
     60#define LOGO_HEIGHT  66
    5061
    5162static char *winreg = NULL;
    … …  
    97108        }
    98109       
     110        surface_t *logo = decode_tga((void *) helenos_tga, helenos_tga_size, 0);
     111        if (!logo) {
     112                printf("Unable to decode logo.\n");
     113                return 1;
     114        }
     115       
    99116        winreg = argv[1];
    100117        window_t *main_window = window_open(argv[1], true, true, "vlaunch", 0, 0);
    … …  
    104121        }
    105122       
    106         pixel_t grd_bg = PIXEL(255, 240, 240, 240);
     123        pixel_t grd_bg = PIXEL(255, 255, 255, 255);
    107124        pixel_t btn_bg = PIXEL(255, 0, 0, 0);
    108125        pixel_t btn_fg = PIXEL(255, 240, 240, 240);
    109         pixel_t lbl_bg = PIXEL(255, 240, 240, 240);
     126        pixel_t lbl_bg = PIXEL(255, 255, 255, 255);
    110127        pixel_t lbl_fg = PIXEL(255, 0, 0, 0);
    111128       
     129        canvas_t *logo_canvas = create_canvas(NULL, LOGO_WIDTH, LOGO_HEIGHT,
     130            logo);
    112131        label_t *lbl_caption = create_label(NULL, "Launch application:", 16,
    113132            lbl_bg, lbl_fg);
    … …  
    118137        button_t *btn_vlaunch = create_button(NULL, "vlaunch", 16, btn_bg,
    119138            btn_fg);
    120         grid_t *grid = create_grid(window_root(main_window), 4, 1, grd_bg);
     139        grid_t *grid = create_grid(window_root(main_window), 1, 5, grd_bg);
    121140       
    122         if ((!lbl_caption) || (!btn_vterm) || (!btn_vdemo) ||
    123             (!btn_vlaunch) || (!grid)) {
     141        if ((!logo_canvas) || (!lbl_caption) || (!btn_vterm) ||
     142            (!btn_vdemo) || (!btn_vlaunch) || (!grid)) {
    124143                window_close(main_window);
    125144                printf("Cannot create widgets.\n");
    … …  
    131150        sig_connect(&btn_vlaunch->clicked, NULL, on_vlaunch);
    132151       
    133         grid->add(grid, &lbl_caption->widget, 0, 0, 1, 1);
    134         grid->add(grid, &btn_vterm->widget, 1, 0, 1, 1);
    135         grid->add(grid, &btn_vdemo->widget, 2, 0, 1, 1);
    136         grid->add(grid, &btn_vlaunch->widget, 3, 0, 1, 1);
     152        grid->add(grid, &logo_canvas->widget, 0, 0, 1, 1);
     153        grid->add(grid, &lbl_caption->widget, 0, 1, 1, 1);
     154        grid->add(grid, &btn_vterm->widget, 0, 2, 1, 1);
     155        grid->add(grid, &btn_vdemo->widget, 0, 3, 1, 1);
     156        grid->add(grid, &btn_vlaunch->widget, 0, 4, 1, 1);
    137157       
    138         window_resize(main_window, 180, 130);
     158        window_resize(main_window, 210, 130 + LOGO_HEIGHT);
    139159        window_exec(main_window);
     160       
    140161        task_retval(0);
    141162        async_manager();
Note: See TracChangeset for help on using the changeset viewer.