Changes in / [9fd39d6:68f0c3a] in mainline


Ignore:
Location:
uspace
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/bdsh/exec.c

    r9fd39d6 r68f0c3a  
    4141#include <fcntl.h>
    4242#include <str_error.h>
    43 #include <errno.h>
    4443
    4544#include "config.h"
    … …  
    117116        task_exit_t texit;
    118117        char *tmp;
    119         int rc, retval;
     118        int retval;
    120119
    121120        tmp = str_dup(find_command(cmd));
    122121        free(found);
    123122
    124         rc = task_spawnv(&tid, tmp, (const char **) argv);
     123        tid = task_spawn(tmp, (const char **) argv, &retval);
    125124        free(tmp);
    126125
    127         if (rc != 0) {
     126        if (tid == 0) {
    128127                cli_error(CL_EEXEC, "%s: Cannot spawn `%s' (%s)", progname, cmd,
    129                     str_error(rc));
     128                    str_error(retval));
    130129                return 1;
    131130        }
    132131       
    133         rc = task_wait(tid, &texit, &retval);
    134         if (rc != EOK) {
    135                 printf("%s: Failed waiting for command (%s)\n", str_error(rc));
    136         } else if (texit != TASK_EXIT_NORMAL) {
     132        task_wait(tid, &texit, &retval);
     133        if (texit != TASK_EXIT_NORMAL) {
    137134                printf("%s: Command failed (unexpectedly terminated)\n", progname);
    138135        } else if (retval != 0) {
    139                 printf("%s: Command failed (exit code %d)\n",
    140                     progname, retval);
     136                printf("%s: Command failed (%s)\n",
     137                    progname, str_error(retval));
    141138        }
    142139

  • uspace/app/getterm/getterm.c

    r9fd39d6 r68f0c3a  
    4141#include <task.h>
    4242#include <str_error.h>
    43 #include <errno.h>
    4443#include "version.h"
    4544
    … …  
    7574static task_id_t spawn(const char *fname)
    7675{
    77         task_id_t id;
    78         int rc;
     76        const char *args[2];
    7977       
    80         rc = task_spawnl(&id, fname, fname, NULL);
    81         if (rc != EOK) {
     78        args[0] = fname;
     79        args[1] = NULL;
     80       
     81        int err;
     82        task_id_t id = task_spawn(fname, args, &err);
     83       
     84        if (id == 0)
    8285                printf("%s: Error spawning %s (%s)\n", APP_NAME, fname,
    83                     str_error(rc));
    84                 return 0;
    85         }
     86                    str_error(err));
    8687       
    8788        return id;

  • uspace/app/init/init.c

    r9fd39d6 r68f0c3a  
    124124static void spawn(const char *fname)
    125125{
    126         int rc;
     126        const char *argv[2];
    127127        struct stat s;
    128128       
    … …  
    131131       
    132132        printf("%s: Spawning %s\n", NAME, fname);
    133         rc = task_spawnl(NULL, fname, fname, NULL);
    134         if (rc != EOK) {
     133       
     134        argv[0] = fname;
     135        argv[1] = NULL;
     136       
     137        int err;
     138        if (!task_spawn(fname, argv, &err))
    135139                printf("%s: Error spawning %s (%s)\n", NAME, fname,
    136                     str_error(rc));
    137         }
     140                    str_error(err));
    138141}
    139142
    140143static void srv_start(const char *fname)
    141144{
     145        const char *argv[2];
    142146        task_id_t id;
    143147        task_exit_t texit;
    … …  
    149153       
    150154        printf("%s: Starting %s\n", NAME, fname);
    151         rc = task_spawnl(&id, fname, fname, NULL);
     155       
     156        argv[0] = fname;
     157        argv[1] = NULL;
     158       
     159        id = task_spawn(fname, argv, &retval);
    152160        if (!id) {
    153161                printf("%s: Error spawning %s (%s)\n", NAME, fname,
    154                     str_error(rc));
     162                    str_error(retval));
    155163                return;
    156164        }
    … …  
    159167        if (rc != EOK) {
    160168                printf("%s: Error waiting for %s (%s(\n", NAME, fname,
    161                     str_error(rc));
     169                    str_error(retval));
    162170                return;
    163171        }
    164172       
    165         if (texit != TASK_EXIT_NORMAL) {
    166                 printf("%s: Server %s failed to start (unexpectedly "
    167                     "terminated)\n", NAME, fname);
    168                 return;
    169         }
    170 
    171         if (retval != 0) {
    172                 printf("%s: Server %s failed to start (exit code %d)\n", NAME,
    173                         fname, retval);
     173        if ((texit != TASK_EXIT_NORMAL) || (retval != 0)) {
     174                printf("%s: Server %s failed to start (%s)\n", NAME,
     175                        fname, str_error(retval));
    174176        }
    175177}
    … …  
    177179static void console(const char *dev)
    178180{
     181        const char *argv[3];
    179182        char hid_in[DEVMAP_NAME_MAXLEN];
    180183        int rc;
    … …  
    187190        dev_handle_t handle;
    188191        rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
    189         if (rc != EOK) {
     192       
     193        if (rc == EOK) {
     194                argv[0] = SRV_CONSOLE;
     195                argv[1] = hid_in;
     196                argv[2] = NULL;
     197               
     198                if (!task_spawn(SRV_CONSOLE, argv, &rc))
     199                        printf("%s: Error spawning %s %s (%s)\n", NAME, SRV_CONSOLE,
     200                            hid_in, str_error(rc));
     201        } else
    190202                printf("%s: Error waiting on %s (%s)\n", NAME, hid_in,
    191203                    str_error(rc));
    192                 return;
    193         }
    194        
    195         rc = task_spawnl(NULL, SRV_CONSOLE, SRV_CONSOLE, hid_in, NULL);
    196         if (rc != EOK) {
    197                 printf("%s: Error spawning %s %s (%s)\n", NAME, SRV_CONSOLE,
    198                     hid_in, str_error(rc));
    199         }
    200204}
    201205
    202206static void getterm(const char *dev, const char *app)
    203207{
     208        const char *argv[4];
    204209        char term[DEVMAP_NAME_MAXLEN];
    205210        int rc;
    … …  
    212217        dev_handle_t handle;
    213218        rc = devmap_device_get_handle(dev, &handle, IPC_FLAG_BLOCKING);
    214         if (rc != EOK) {
     219       
     220        if (rc == EOK) {
     221                argv[0] = APP_GETTERM;
     222                argv[1] = term;
     223                argv[2] = app;
     224                argv[3] = NULL;
     225               
     226                if (!task_spawn(APP_GETTERM, argv, &rc))
     227                        printf("%s: Error spawning %s %s %s (%s)\n", NAME, APP_GETTERM,
     228                            term, app, str_error(rc));
     229        } else
    215230                printf("%s: Error waiting on %s (%s)\n", NAME, term,
    216231                    str_error(rc));
    217                 return;
    218         }
    219        
    220         rc = task_spawnl(NULL, APP_GETTERM, APP_GETTERM, term, app, NULL);
    221         if (rc != EOK) {
    222                 printf("%s: Error spawning %s %s %s (%s)\n", NAME,
    223                     APP_GETTERM, term, app, str_error(rc));
    224         }
    225232}
    226233

  • uspace/app/netecho/netecho.c

    r9fd39d6 r68f0c3a  
    4141#include <task.h>
    4242#include <arg_parse.h>
     43#include <err.h>
    4344
    4445#include <net/in.h>
    … …  
    9091int main(int argc, char *argv[])
    9192{
     93        ERROR_DECLARE;
     94
    9295        size_t size = 1024;
    9396        int verbose = 0;
    … …  
    114117        size_t reply_length;
    115118        int value;
    116         int rc;
    117119
    118120        // parse the command line arguments
    … …  
    121123                        switch (argv[index][1]) {
    122124                        case 'b':
    123                                 rc = arg_parse_int(argc, argv, &index, &backlog, 0);
    124                                 if (rc != EOK)
    125                                         return rc;
     125                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &backlog, 0));
    126126                                break;
    127127                        case 'c':
    128                                 rc = arg_parse_int(argc, argv, &index, &count, 0);
    129                                 if (rc != EOK)
    130                                         return rc;
     128                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &count, 0));
    131129                                break;
    132130                        case 'f':
    133                                 rc = arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family);
    134                                 if (rc != EOK)
    135                                         return rc;
     131                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family));
    136132                                break;
    137133                        case 'h':
    … …  
    140136                                break;
    141137                        case 'p':
    142                                 rc = arg_parse_int(argc, argv, &index, &value, 0);
    143                                 if (rc != EOK)
    144                                         return rc;
     138                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
    145139                                port = (uint16_t) value;
    146140                                break;
    147141                        case 'r':
    148                                 rc = arg_parse_string(argc, argv, &index, &reply, 0);
    149                                 if (rc != EOK)
    150                                         return rc;
     142                                ERROR_PROPAGATE(arg_parse_string(argc, argv, &index, &reply, 0));
    151143                                break;
    152144                        case 's':
    153                                 rc = arg_parse_int(argc, argv, &index, &value, 0);
    154                                 if (rc != EOK)
    155                                         return rc;
     145                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
    156146                                size = (value >= 0) ? (size_t) value : 0;
    157147                                break;
    158148                        case 't':
    159                                 rc = arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type);
    160                                 if (rc != EOK)
    161                                         return rc;
     149                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type));
    162150                                type = (sock_type_t) value;
    163151                                break;
    … …  
    168156                        case '-':
    169157                                if (str_lcmp(argv[index] + 2, "backlog=", 6) == 0) {
    170                                         rc = arg_parse_int(argc, argv, &index, &backlog, 8);
    171                                         if (rc != EOK)
    172                                                 return rc;
     158                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &backlog, 8));
    173159                                } else if (str_lcmp(argv[index] + 2, "count=", 6) == 0) {
    174                                         rc = arg_parse_int(argc, argv, &index, &count, 8);
     160                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &count, 8));
    175161                                } else if (str_lcmp(argv[index] + 2, "family=", 7) == 0) {
    176                                         rc = arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family);
    177                                         if (rc != EOK)
    178                                                 return rc;
     162                                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family));
    179163                                } else if (str_lcmp(argv[index] + 2, "help", 5) == 0) {
    180164                                        echo_print_help();
    181165                                        return EOK;
    182166                                } else if (str_lcmp(argv[index] + 2, "port=", 5) == 0) {
    183                                         rc = arg_parse_int(argc, argv, &index, &value, 7);
    184                                         if (rc != EOK)
    185                                                 return rc;
     167                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 7));
    186168                                        port = (uint16_t) value;
    187169                                } else if (str_lcmp(argv[index] + 2, "reply=", 6) == 0) {
    188                                         rc = arg_parse_string(argc, argv, &index, &reply, 8);
    189                                         if (rc != EOK)
    190                                                 return rc;
     170                                        ERROR_PROPAGATE(arg_parse_string(argc, argv, &index, &reply, 8));
    191171                                } else if (str_lcmp(argv[index] + 2, "size=", 5) == 0) {
    192                                         rc = arg_parse_int(argc, argv, &index, &value, 7);
    193                                         if (rc != EOK)
    194                                                 return rc;
     172                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 7));
    195173                                        size = (value >= 0) ? (size_t) value : 0;
    196174                                } else if (str_lcmp(argv[index] + 2, "type=", 5) == 0) {
    197                                         rc = arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type);
    198                                         if (rc != EOK)
    199                                                 return rc;
     175                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type));
    200176                                        type = (sock_type_t) value;
    201177                                } else if (str_lcmp(argv[index] + 2, "verbose", 8) == 0) {
    … …  
    264240                }
    265241                // set the backlog
    266                 rc = listen(listening_id, backlog);
    267                 if (rc != EOK) {
    268                         socket_print_error(stderr, rc, "Socket listen: ", "\n");
    269                         return rc;
     242                if (ERROR_OCCURRED(listen(listening_id, backlog))) {
     243                        socket_print_error(stderr, ERROR_CODE, "Socket listen: ", "\n");
     244                        return ERROR_CODE;
    270245                }
    271246        }
    272247
    273248        // bind the listenning socket
    274         rc = bind(listening_id, address, addrlen);
    275         if (rc != EOK) {
    276                 socket_print_error(stderr, rc, "Socket bind: ", "\n");
    277                 return rc;
     249        if (ERROR_OCCURRED(bind(listening_id, address, addrlen))) {
     250                socket_print_error(stderr, ERROR_CODE, "Socket bind: ", "\n");
     251                return ERROR_CODE;
    278252        }
    279253
    … …  
    327301                                        // parse the source address
    328302                                        if (address_start) {
    329                                                 rc = inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string));
    330                                                 if (rc != EOK) {
    331                                                         fprintf(stderr, "Received address error %d\n", rc);
     303                                                if (ERROR_OCCURRED(inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string)))) {
     304                                                        fprintf(stderr, "Received address error %d\n", ERROR_CODE);
    332305                                                } else {
    333306                                                        data[length] = '\0';
    … …  
    338311
    339312                                // answer the request either with the static reply or the original data
    340                                 rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
    341                                 if (rc != EOK)
    342                                         socket_print_error(stderr, rc, "Socket send: ", "\n");
     313                                if (ERROR_OCCURRED(sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen)))
     314                                        socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
    343315                        }
    344316
    345317                        // close the accepted stream socket
    346318                        if (type == SOCK_STREAM) {
    347                                 rc = closesocket(socket_id);
    348                                 if (rc != EOK)
    349                                         socket_print_error(stderr, rc, "Close socket: ", "\n");
     319                                if (ERROR_OCCURRED(closesocket(socket_id)))
     320                                        socket_print_error(stderr, ERROR_CODE, "Close socket: ", "\n");
    350321                        }
    351322
    … …  
    364335
    365336        // close the listenning socket
    366         rc = closesocket(listening_id);
    367         if (rc != EOK) {
    368                 socket_print_error(stderr, rc, "Close socket: ", "\n");
    369                 return rc;
     337        if (ERROR_OCCURRED(closesocket(listening_id))) {
     338                socket_print_error(stderr, ERROR_CODE, "Close socket: ", "\n");
     339                return ERROR_CODE;
    370340        }
    371341

  • uspace/app/netstart/netstart.c

    r9fd39d6 r68f0c3a  
    4141#include <task.h>
    4242#include <str_error.h>
     43#include <err.h>
    4344#include <ipc/ipc.h>
    4445#include <ipc/services.h>
    … …  
    5657static bool spawn(const char *desc, const char *path)
    5758{
    58         int rc;
    59 
    6059        printf("%s: Spawning %s (%s)\n", NAME, desc, path);
    61         rc = task_spawnl(NULL, path, path, NULL);
    62         if (rc != EOK) {
     60       
     61        const char *argv[2];
     62       
     63        argv[0] = path;
     64        argv[1] = NULL;
     65       
     66        int err;
     67        if (task_spawn(path, argv, &err) == 0) {
    6368                fprintf(stderr, "%s: Error spawning %s (%s)\n", NAME, path,
    64                     str_error(rc));
     69                    str_error(err));
    6570                return false;
    6671        }
    … …  
    7176int main(int argc, char *argv[])
    7277{
    73         int rc;
     78        ERROR_DECLARE;
    7479       
    7580        if (!spawn("networking service", "/srv/net"))
    … …  
    7984       
    8085        int net_phone = connect_to_service(SERVICE_NETWORKING);
    81         rc = ipc_call_sync_0_0(net_phone, NET_NET_STARTUP);
    82         if (rc != EOK) {
    83                 fprintf(stderr, "%s: Startup error %d\n", NAME, rc);
    84                 return rc;
     86        if (ERROR_OCCURRED(ipc_call_sync_0_0(net_phone, NET_NET_STARTUP))) {
     87                fprintf(stderr, "%s: Startup error %d\n", NAME, ERROR_CODE);
     88                return ERROR_CODE;
    8589        }
    8690       

  • uspace/app/nettest1/nettest.c

    r9fd39d6 r68f0c3a  
    3636
    3737#include <stdio.h>
     38#include <err.h>
     39
    3840#include <net/socket.h>
    3941
    … …  
    8587int sockets_close(int verbose, int *socket_ids, int sockets)
    8688{
    87         int index;
    88         int rc;
     89        ERROR_DECLARE;
     90
     91        int index;
    8992
    9093        if (verbose)
    … …  
    9497       
    9598        for (index = 0; index < sockets; index++) {
    96                 rc = closesocket(socket_ids[index]);
    97                 if (rc != EOK) {
     99                if (ERROR_OCCURRED(closesocket(socket_ids[index]))) {
    98100                        printf("Socket %d (%d) error:\n", index, socket_ids[index]);
    99                         socket_print_error(stderr, rc, "Socket close: ", "\n");
    100                         return rc;
     101                        socket_print_error(stderr, ERROR_CODE, "Socket close: ", "\n");
     102                        return ERROR_CODE;
    101103                }
    102104                if (verbose)
    … …  
    119121int sockets_connect(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t addrlen)
    120122{
    121         int index;
    122         int rc;
     123        ERROR_DECLARE;
     124
     125        int index;
    123126
    124127        if (verbose)
    … …  
    128131       
    129132        for (index = 0; index < sockets; index++) {
    130                 rc = connect(socket_ids[index], address, addrlen);
    131                 if (rc != EOK) {
    132                         socket_print_error(stderr, rc, "Socket connect: ", "\n");
    133                         return rc;
     133                if (ERROR_OCCURRED(connect(socket_ids[index], address, addrlen))) {
     134                        socket_print_error(stderr, ERROR_CODE, "Socket connect: ", "\n");
     135                        return ERROR_CODE;
    134136                }
    135137                if (verbose)
    … …  
    155157int sockets_sendto(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t addrlen, char *data, int size, int messages)
    156158{
     159        ERROR_DECLARE;
     160
    157161        int index;
    158162        int message;
    159         int rc;
    160163
    161164        if (verbose)
    … …  
    166169        for (index = 0; index < sockets; index++) {
    167170                for (message = 0; message < messages; message++) {
    168                         rc = sendto(socket_ids[index], data, size, 0, address, addrlen);
    169                         if (rc != EOK) {
    170                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
    171                                 socket_print_error(stderr, rc, "Socket send: ", "\n");
    172                                 return rc;
     171                        if (ERROR_OCCURRED(sendto(socket_ids[index], data, size, 0, address, addrlen))) {
     172                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     173                                socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
     174                                return ERROR_CODE;
    173175                        }
    174176                }
    … …  
    237239int sockets_sendto_recvfrom(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t *addrlen, char *data, int size, int messages)
    238240{
     241        ERROR_DECLARE;
     242
    239243        int value;
    240244        int index;
    241245        int message;
    242         int rc;
    243246
    244247        if (verbose)
    … …  
    249252        for (index = 0; index < sockets; index++) {
    250253                for (message = 0; message < messages; message++) {
    251                         rc = sendto(socket_ids[index], data, size, 0, address, *addrlen);
    252                         if (rc != EOK) {
    253                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
    254                                 socket_print_error(stderr, rc, "Socket send: ", "\n");
    255                                 return rc;
     254                        if (ERROR_OCCURRED(sendto(socket_ids[index], data, size, 0, address, *addrlen))) {
     255                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     256                                socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
     257                                return ERROR_CODE;
    256258                        }
    257259                        value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);

  • uspace/app/nettest1/nettest1.c

    r9fd39d6 r68f0c3a  
    4444#include <time.h>
    4545#include <arg_parse.h>
     46#include <err.h>
    4647
    4748#include <net/in.h>
    … …  
    5758#define NETTEST1_TEXT   "Networking test 1 - sockets"
    5859
    59 static int family = PF_INET;
    60 static sock_type_t type = SOCK_DGRAM;
    61 static char *data;
    62 static size_t size = 27;
    63 static int verbose = 0;
    64 
    65 static struct sockaddr *address;
    66 static socklen_t addrlen;
    67 
    68 static int sockets;
    69 static int messages;
    70 static uint16_t port;
    71 
    7260static void nettest1_print_help(void)
    7361{
    7462        printf(
    75             "Network Networking test 1 aplication - sockets\n"
    76             "Usage: echo [options] numeric_address\n"
    77             "Where options are:\n"
    78             "-f protocol_family | --family=protocol_family\n"
    79             "\tThe listenning socket protocol family. Only the PF_INET and "
    80             "PF_INET6 are supported.\n"
    81             "\n"
    82             "-h | --help\n"
    83             "\tShow this application help.\n"
    84             "\n"
    85             "-m count | --messages=count\n"
    86             "\tThe number of messages to send and receive per socket. The "
    87             "default is 10.\n"
    88             "\n"
    89             "-n sockets | --sockets=count\n"
    90             "\tThe number of sockets to use. The default is 10.\n"
    91             "\n"
    92             "-p port_number | --port=port_number\n"
    93             "\tThe port number the application should send messages to. The "
    94             "default is 7.\n"
    95             "\n"
    96             "-s packet_size | --size=packet_size\n"
    97             "\tThe packet data size the application sends. The default is "
    98             "28 bytes.\n"
    99             "\n"
    100             "-v | --verbose\n"
    101             "\tShow all output messages.\n");
     63                "Network Networking test 1 aplication - sockets\n" \
     64                "Usage: echo [options] numeric_address\n" \
     65                "Where options are:\n" \
     66                "-f protocol_family | --family=protocol_family\n" \
     67                "\tThe listenning socket protocol family. Only the PF_INET and PF_INET6 are supported.\n"
     68                "\n" \
     69                "-h | --help\n" \
     70                "\tShow this application help.\n"
     71                "\n" \
     72                "-m count | --messages=count\n" \
     73                "\tThe number of messages to send and receive per socket. The default is 10.\n" \
     74                "\n" \
     75                "-n sockets | --sockets=count\n" \
     76                "\tThe number of sockets to use. The default is 10.\n" \
     77                "\n" \
     78                "-p port_number | --port=port_number\n" \
     79                "\tThe port number the application should send messages to. The default is 7.\n" \
     80                "\n" \
     81                "-s packet_size | --size=packet_size\n" \
     82                "\tThe packet data size the application sends. The default is 28 bytes.\n" \
     83                "\n" \
     84                "-v | --verbose\n" \
     85                "\tShow all output messages.\n"
     86        );
    10287}
    10388
    104 /** Parse one command-line option.
    105  *
    106  * @param argc          Number of all command-line arguments.
    107  * @param argv          All command-line arguments.
    108  * @param index         Current argument index (in, out).
    109  */
    110 static int nettest1_parse_opt(int argc, char *argv[], int *index)
     89/** Refreshes the data.
     90 *
     91 * Fills the data block with the NETTEST1_TEXT pattern.
     92 *
     93 * @param[out] data The data block.
     94 * @param[in] size The data block size in bytes.
     95 */
     96static void nettest1_refresh_data(char *data, size_t size)
    11197{
     98        size_t length;
     99
     100        // fill the data
     101        length = 0;
     102        while (size > length + sizeof(NETTEST1_TEXT) - 1) {
     103                memcpy(data + length, NETTEST1_TEXT, sizeof(NETTEST1_TEXT) - 1);
     104                length += sizeof(NETTEST1_TEXT) - 1;
     105        }
     106        memcpy(data + length, NETTEST1_TEXT, size - length);
     107        data[size] = '\0';
     108}
     109
     110
     111int main(int argc, char *argv[])
     112{
     113        ERROR_DECLARE;
     114
     115        size_t size = 27;
     116        int verbose = 0;
     117        sock_type_t type = SOCK_DGRAM;
     118        int sockets = 10;
     119        int messages = 10;
     120        int family = PF_INET;
     121        uint16_t port = 7;
     122
     123        socklen_t max_length = sizeof(struct sockaddr_in6);
     124        uint8_t address_data[max_length];
     125        struct sockaddr *address = (struct sockaddr *) address_data;
     126        struct sockaddr_in *address_in = (struct sockaddr_in *) address;
     127        struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address;
     128        socklen_t addrlen;
     129        uint8_t *address_start;
     130
     131        int *socket_ids;
     132        char *data;
    112133        int value;
    113         int rc;
    114 
    115         switch (argv[*index][1]) {
    116         /*
    117          * Short options with only one letter
    118          */
    119         case 'f':
    120                 rc = arg_parse_name_int(argc, argv, index, &family, 0, socket_parse_protocol_family);
    121                 if (rc != EOK)
    122                         return rc;
    123                 break;
    124         case 'h':
    125                 nettest1_print_help();
    126                 return EOK;
    127         case 'm':
    128                 rc = arg_parse_int(argc, argv, index, &messages, 0);
    129                 if (rc != EOK)
    130                         return rc;
    131                 break;
    132         case 'n':
    133                 rc = arg_parse_int(argc, argv, index, &sockets, 0);
    134                 if (rc != EOK)
    135                         return rc;
    136                 break;
    137         case 'p':
    138                 rc = arg_parse_int(argc, argv, index, &value, 0);
    139                 if (rc != EOK)
    140                         return rc;
    141                 port = (uint16_t) value;
    142                 break;
    143         case 's':
    144                 rc = arg_parse_int(argc, argv, index, &value, 0);
    145                 if (rc != EOK)
    146                         return rc;
    147                 size = (value >= 0) ? (size_t) value : 0;
    148                 break;
    149         case 't':
    150                 rc = arg_parse_name_int(argc, argv, index, &value, 0, socket_parse_socket_type);
    151                 if (rc != EOK)
    152                         return rc;
    153                 type = (sock_type_t) value;
    154                 break;
    155         case 'v':
    156                 verbose = 1;
    157                 break;
    158         /*
    159          * Long options with double dash ('-')
    160          */
    161         case '-':
    162                 if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    163                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
    164                             socket_parse_protocol_family);
    165                         if (rc != EOK)
    166                                 return rc;
    167                 } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    168                         nettest1_print_help();
    169                         return EOK;
    170                 } else if (str_lcmp(argv[*index] + 2, "messages=", 6) == 0) {
    171                         rc = arg_parse_int(argc, argv, index, &messages, 8);
    172                         if (rc != EOK)
    173                                 return rc;
    174                 } else if (str_lcmp(argv[*index] + 2, "sockets=", 6) == 0) {
    175                         rc = arg_parse_int(argc, argv, index, &sockets, 8);
    176                         if (rc != EOK)
    177                                 return rc;
    178                 } else if (str_lcmp(argv[*index] + 2, "port=", 5) == 0) {
    179                         rc = arg_parse_int(argc, argv, index, &value, 7);
    180                         if (rc != EOK)
    181                                 return rc;
    182                         port = (uint16_t) value;
    183                 } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    184                         rc = arg_parse_name_int(argc, argv, index, &value, 7,
    185                             socket_parse_socket_type);
    186                         if (rc != EOK)
    187                                 return rc;
    188                         type = (sock_type_t) value;
    189                 } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    190                         verbose = 1;
     134        int index;
     135        struct timeval time_before;
     136        struct timeval time_after;
     137
     138        // parse the command line arguments
     139        // stop before the last argument if it does not start with the minus sign ('-')
     140        for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); index++) {
     141                // options should start with the minus sign ('-')
     142                if (argv[index][0] == '-') {
     143                        switch (argv[index][1]) {
     144                        // short options with only one letter
     145                        case 'f':
     146                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family));
     147                                break;
     148                        case 'h':
     149                                nettest1_print_help();
     150                                return EOK;
     151                                break;
     152                        case 'm':
     153                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 0));
     154                                break;
     155                        case 'n':
     156                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 0));
     157                                break;
     158                        case 'p':
     159                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     160                                port = (uint16_t) value;
     161                                break;
     162                        case 's':
     163                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     164                                size = (value >= 0) ? (size_t) value : 0;
     165                                break;
     166                        case 't':
     167                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type));
     168                                type = (sock_type_t) value;
     169                                break;
     170                        case 'v':
     171                                verbose = 1;
     172                                break;
     173                        // long options with the double minus sign ('-')
     174                        case '-':
     175                                if (str_lcmp(argv[index] + 2, "family=", 7) == 0) {
     176                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family));
     177                                } else if (str_lcmp(argv[index] + 2, "help", 5) == 0) {
     178                                        nettest1_print_help();
     179                                        return EOK;
     180                                } else if (str_lcmp(argv[index] + 2, "messages=", 6) == 0) {
     181                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 8));
     182                                } else if (str_lcmp(argv[index] + 2, "sockets=", 6) == 0) {
     183                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 8));
     184                                } else if (str_lcmp(argv[index] + 2, "port=", 5) == 0) {
     185                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 7));
     186                                        port = (uint16_t) value;
     187                                } else if (str_lcmp(argv[index] + 2, "type=", 5) == 0) {
     188                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type));
     189                                        type = (sock_type_t) value;
     190                                } else if (str_lcmp(argv[index] + 2, "verbose", 8) == 0) {
     191                                        verbose = 1;
     192                                } else {
     193                                        nettest1_print_help();
     194                                        return EINVAL;
     195                                }
     196                                break;
     197                        default:
     198                                nettest1_print_help();
     199                                return EINVAL;
     200                        }
    191201                } else {
    192202                        nettest1_print_help();
    193203                        return EINVAL;
    194204                }
    195                 break;
    196         default:
    197                 nettest1_print_help();
    198                 return EINVAL;
    199         }
    200 
    201         return EOK;
    202 }
    203 
    204 /** Fill buffer with the NETTEST1_TEXT pattern.
    205  *
    206  * @param buffer        Data buffer.
    207  * @param size          Buffer size in bytes.
    208  */
    209 static void nettest1_fill_buffer(char *buffer, size_t size)
    210 {
    211         size_t length;
    212 
    213         length = 0;
    214         while (size > length + sizeof(NETTEST1_TEXT) - 1) {
    215                 memcpy(buffer + length, NETTEST1_TEXT,
    216                     sizeof(NETTEST1_TEXT) - 1);
    217                 length += sizeof(NETTEST1_TEXT) - 1;
    218         }
    219 
    220         memcpy(buffer + length, NETTEST1_TEXT, size - length);
    221         buffer[size] = '\0';
    222 }
    223 
    224 static int nettest1_test(int *socket_ids, int nsockets, int nmessages)
    225 {
    226         int rc;
    227 
    228         if (verbose)
    229                 printf("%d sockets, %d messages\n", nsockets, nmessages);
    230 
    231         rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    232         if (rc != EOK)
    233                 return rc;
    234 
    235         if (type == SOCK_STREAM) {
    236                 rc = sockets_connect(verbose, socket_ids, nsockets, address,
    237                     addrlen);
    238                 if (rc != EOK)
    239                         return rc;
    240         }
    241 
    242         rc = sockets_sendto_recvfrom(verbose, socket_ids, nsockets, address,
    243             &addrlen, data, size, nmessages);
    244         if (rc != EOK)
    245                 return rc;
    246 
    247         rc = sockets_close(verbose, socket_ids, nsockets);
    248         if (rc != EOK)
    249                 return rc;
    250 
    251         if (verbose)
    252                 printf("\tOK\n");
    253 
    254         /****/
    255 
    256         rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    257         if (rc != EOK)
    258                 return rc;
    259 
    260         if (type == SOCK_STREAM) {
    261                 rc = sockets_connect(verbose, socket_ids, nsockets, address,
    262                     addrlen);
    263                 if (rc != EOK)
    264                         return rc;
    265         }
    266 
    267         rc = sockets_sendto(verbose, socket_ids, nsockets, address, addrlen,
    268             data, size, nmessages);
    269         if (rc != EOK)
    270                 return rc;
    271 
    272         rc = sockets_recvfrom(verbose, socket_ids, nsockets, address, &addrlen,
    273             data, size, nmessages);
    274         if (rc != EOK)
    275                 return rc;
    276 
    277         rc = sockets_close(verbose, socket_ids, nsockets);
    278         if (rc != EOK)
    279                 return rc;
    280 
    281         if (verbose)
    282                 printf("\tOK\n");
    283 
    284         return EOK;
    285 }
    286 
    287 int main(int argc, char *argv[])
    288 {
    289 
    290         socklen_t max_length;
    291         uint8_t *address_data[sizeof(struct sockaddr_in6)];
    292         struct sockaddr_in *address_in;
    293         struct sockaddr_in6 *address_in6;
    294         uint8_t *address_start;
    295 
    296         int *socket_ids;
    297         int index;
    298         struct timeval time_before;
    299         struct timeval time_after;
    300 
    301         int rc;
    302 
    303         max_length = sizeof(address_data);
    304         address = (struct sockaddr *) address_data;
    305         address_in = (struct sockaddr_in *) address;
    306         address_in6 = (struct sockaddr_in6 *) address;
    307 
    308         sockets = 10;
    309         messages = 10;
    310         port = 7;
    311 
    312         /*
    313          * Parse the command line arguments. Stop before the last argument
    314          * if it does not start with dash ('-')
    315          */
    316         for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); index++) {
    317                 /* Options should start with dash ('-') */
    318                 if (argv[index][0] == '-') {
    319                         rc = nettest1_parse_opt(argc, argv, &index);
    320                         if (rc != EOK)
    321                                 return rc;
    322                 } else {
    323                         nettest1_print_help();
    324                         return EINVAL;
    325                 }
    326         }
    327 
    328         /* If not before the last argument containing the address */
     205        }
     206
     207        // if not before the last argument containing the address
    329208        if (index >= argc) {
    330209                printf("Command line error: missing address\n");
    … …  
    333212        }
    334213
    335         /* Prepare the address buffer */
     214        // prepare the address buffer
    336215        bzero(address_data, max_length);
    337 
    338216        switch (family) {
    339217        case PF_INET:
    … …  
    354232        }
    355233
    356         /* Parse the last argument which should contain the address */
    357         rc = inet_pton(family, argv[argc - 1], address_start);
    358         if (rc != EOK) {
    359                 fprintf(stderr, "Address parse error %d\n", rc);
    360                 return rc;
    361         }
    362 
    363         /* Check data buffer size */
     234        // parse the last argument which should contain the address
     235        if (ERROR_OCCURRED(inet_pton(family, argv[argc - 1], address_start))) {
     236                fprintf(stderr, "Address parse error %d\n", ERROR_CODE);
     237                return ERROR_CODE;
     238        }
     239
     240        // check the buffer size
    364241        if (size <= 0) {
    365                 fprintf(stderr, "Data buffer size too small (%d). Using 1024 "
    366                     "bytes instead.\n", size);
     242                fprintf(stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size);
    367243                size = 1024;
    368244        }
    369245
    370         /*
    371          * Prepare data buffer. Allocate size bytes plus one for the
    372          * trailing null character.
    373          */
     246        // prepare the buffer
     247        // size plus the terminating null (\0)
    374248        data = (char *) malloc(size + 1);
    375249        if (!data) {
    … …  
    377251                return ENOMEM;
    378252        }
    379         nettest1_fill_buffer(data, size);
    380 
    381         /* Check socket count */
     253        nettest1_refresh_data(data, size);
     254
     255        // check the socket count
    382256        if (sockets <= 0) {
    383                 fprintf(stderr, "Socket count too small (%d). Using "
    384                     "2 instead.\n", sockets);
     257                fprintf(stderr, "Socket count too small (%d). Using 2 instead.\n", sockets);
    385258                sockets = 2;
    386259        }
    387260
    388         /*
    389          * Prepare socket buffer. Allocate count fields plus the terminating
    390          * null (\0).
    391          */
     261        // prepare the socket buffer
     262        // count plus the terminating null (\0)
    392263        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    393264        if (!socket_ids) {
    … …  
    400271                printf("Starting tests\n");
    401272
    402         rc = gettimeofday(&time_before, NULL);
    403         if (rc != EOK) {
    404                 fprintf(stderr, "Get time of day error %d\n", rc);
    405                 return rc;
    406         }
    407 
    408         nettest1_test(socket_ids,       1,        1);
    409         nettest1_test(socket_ids,       1, messages);
    410         nettest1_test(socket_ids, sockets,        1);
    411         nettest1_test(socket_ids, sockets, messages);
    412 
    413         rc = gettimeofday(&time_after, NULL);
    414         if (rc != EOK) {
    415                 fprintf(stderr, "Get time of day error %d\n", rc);
    416                 return rc;
    417         }
    418 
    419         printf("Tested in %d microseconds\n", tv_sub(&time_after,
    420             &time_before));
     273        if (verbose)
     274                printf("1 socket, 1 message\n");
     275
     276        if (ERROR_OCCURRED(gettimeofday(&time_before, NULL))) {
     277                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     278                return ERROR_CODE;
     279        }
     280
     281        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     282        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     283        if (verbose)
     284                printf("\tOK\n");
     285
     286        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     287        if (type == SOCK_STREAM)
     288                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     289        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, 1));
     290        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     291        if (verbose)
     292                printf("\tOK\n");
     293
     294        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     295        if (type == SOCK_STREAM)
     296                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     297        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, 1, address, addrlen, data, size, 1));
     298        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, 1));
     299        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     300        if (verbose)
     301                printf("\tOK\n");
     302
     303        if (verbose)
     304                printf("1 socket, %d messages\n", messages);
     305
     306        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     307        if (type == SOCK_STREAM)
     308                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     309        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, messages));
     310        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     311        if (verbose)
     312                printf("\tOK\n");
     313
     314        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     315        if (type == SOCK_STREAM)
     316                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     317        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, 1, address, addrlen, data, size, messages));
     318        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, messages));
     319        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     320        if (verbose)
     321                printf("\tOK\n");
     322
     323        if (verbose)
     324                printf("%d sockets, 1 message\n", sockets);
     325
     326        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     327        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     328        if (verbose)
     329                printf("\tOK\n");
     330
     331        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     332        if (type == SOCK_STREAM)
     333                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     334        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, 1));
     335        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     336        if (verbose)
     337                printf("\tOK\n");
     338
     339        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     340        if (type == SOCK_STREAM)
     341                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     342        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, 1));
     343        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, 1));
     344        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     345        if (verbose)
     346                printf("\tOK\n");
     347
     348        if (verbose)
     349                printf("%d sockets, %d messages\n", sockets, messages);
     350
     351        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     352        if (type == SOCK_STREAM)
     353                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     354        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     355        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     356        if (verbose)
     357                printf("\tOK\n");
     358
     359        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     360        if (type == SOCK_STREAM)
     361                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     362        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, messages));
     363        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     364        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     365
     366        if (ERROR_OCCURRED(gettimeofday(&time_after, NULL))) {
     367                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     368                return ERROR_CODE;
     369        }
     370
     371        if (verbose)
     372                printf("\tOK\n");
     373
     374        printf("Tested in %d microseconds\n", tv_sub(&time_after, &time_before));
    421375
    422376        if (verbose)

  • uspace/app/nettest2/nettest2.c

    r9fd39d6 r68f0c3a  
    4444#include <time.h>
    4545#include <arg_parse.h>
    46 #include <bool.h>
     46#include <err.h>
    4747
    4848#include <net/in.h>
    … …  
    5858#define NETTEST2_TEXT   "Networking test 2 - transfer"
    5959
    60 static size_t size;
    61 static bool verbose;
    62 static sock_type_t type;
    63 static int sockets;
    64 static int messages;
    65 static int family;
    66 static uint16_t port;
    67 
    6860static void nettest2_print_help(void)
    6961{
    7062        printf(
    71             "Network Networking test 2 aplication - UDP transfer\n"
    72             "Usage: echo [options] address\n"
    73             "Where options are:\n"
    74             "-f protocol_family | --family=protocol_family\n"
    75             "\tThe listenning socket protocol family. Only the PF_INET and "
    76             "PF_INET6 are supported.\n"
    77             "\n"
    78             "-h | --help\n"
    79             "\tShow this application help.\n"
    80             "\n"
    81             "-m count | --messages=count\n"
    82             "\tThe number of messages to send and receive per socket. The "
    83             "default is 10.\n"
    84             "\n"
    85             "-n sockets | --sockets=count\n"
    86             "\tThe number of sockets to use. The default is 10.\n"
    87             "\n"
    88             "-p port_number | --port=port_number\n"
    89             "\tThe port number the application should send messages to. The "
    90             "default is 7.\n"
    91             "\n"
    92             "-s packet_size | --size=packet_size\n"
    93             "\tThe packet data size the application sends. The default is 29 "
    94             "bytes.\n"
    95             "\n"
    96             "-v | --verbose\n"
    97             "\tShow all output messages.\n");
     63                "Network Networking test 2 aplication - UDP transfer\n" \
     64                "Usage: echo [options] numeric_address\n" \
     65                "Where options are:\n" \
     66                "-f protocol_family | --family=protocol_family\n" \
     67                "\tThe listenning socket protocol family. Only the PF_INET and PF_INET6 are supported.\n"
     68                "\n" \
     69                "-h | --help\n" \
     70                "\tShow this application help.\n"
     71                "\n" \
     72                "-m count | --messages=count\n" \
     73                "\tThe number of messages to send and receive per socket. The default is 10.\n" \
     74                "\n" \
     75                "-n sockets | --sockets=count\n" \
     76                "\tThe number of sockets to use. The default is 10.\n" \
     77                "\n" \
     78                "-p port_number | --port=port_number\n" \
     79                "\tThe port number the application should send messages to. The default is 7.\n" \
     80                "\n" \
     81                "-s packet_size | --size=packet_size\n" \
     82                "\tThe packet data size the application sends. The default is 29 bytes.\n" \
     83                "\n" \
     84                "-v | --verbose\n" \
     85                "\tShow all output messages.\n"
     86        );
    9887}
    9988
    100 /** Fill buffer with the NETTEST2_TEXT pattern.
    101  *
    102  * @param buffer        Data buffer.
    103  * @param size          Buffer size in bytes.
    104  */
    105 static void nettest2_fill_buffer(char *buffer, size_t size)
     89/** Refreshes the data.
     90 *
     91 * Fills the data block with the NETTEST1_TEXT pattern.
     92 *
     93 * @param[out] data The data block.
     94 * @param[in] size The data block size in bytes.
     95 */
     96static void nettest2_refresh_data(char *data, size_t size)
    10697{
    10798        size_t length;
    10899
     100        // fill the data
    109101        length = 0;
    110102        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    111                 memcpy(buffer + length, NETTEST2_TEXT,
    112                     sizeof(NETTEST2_TEXT) - 1);
     103                memcpy(data + length, NETTEST2_TEXT, sizeof(NETTEST2_TEXT) - 1);
    113104                length += sizeof(NETTEST2_TEXT) - 1;
    114105        }
    115 
    116         memcpy(buffer + length, NETTEST2_TEXT, size - length);
    117         buffer[size] = '\0';
     106        memcpy(data + length, NETTEST2_TEXT, size - length);
     107        data[size] = '\0';
    118108}
    119109
    120 /** Parse one command-line option.
    121  *
    122  * @param argc          Number of all command-line arguments.
    123  * @param argv          All command-line arguments.
    124  * @param index         Current argument index (in, out).
    125  */
    126 static int nettest2_parse_opt(int argc, char *argv[], int *index)
     110
     111int main(int argc, char *argv[])
    127112{
     113        ERROR_DECLARE;
     114
     115        size_t size = 28;
     116        int verbose = 0;
     117        sock_type_t type = SOCK_DGRAM;
     118        int sockets = 10;
     119        int messages = 10;
     120        int family = PF_INET;
     121        uint16_t port = 7;
     122
     123        socklen_t max_length = sizeof(struct sockaddr_in6);
     124        uint8_t address_data[max_length];
     125        struct sockaddr *address = (struct sockaddr *) address_data;
     126        struct sockaddr_in *address_in = (struct sockaddr_in *) address;
     127        struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address;
     128        socklen_t addrlen;
     129        uint8_t *address_start;
     130
     131        int *socket_ids;
     132        char *data;
    128133        int value;
    129         int rc;
    130 
    131         switch (argv[*index][1]) {
    132         /*
    133          * Short options with only one letter
    134          */
    135         case 'f':
    136                 rc = arg_parse_name_int(argc, argv, index, &family, 0,
    137                     socket_parse_protocol_family);
    138                 if (rc != EOK)
    139                         return rc;
    140                 break;
    141         case 'h':
    142                 nettest2_print_help();
    143                 return EOK;
    144                 break;
    145         case 'm':
    146                 rc = arg_parse_int(argc, argv, index, &messages, 0);
    147                 if (rc != EOK)
    148                         return rc;
    149                 break;
    150         case 'n':
    151                 rc = arg_parse_int(argc, argv, index, &sockets, 0);
    152                 if (rc != EOK)
    153                         return rc;
    154                 break;
    155         case 'p':
    156                 rc = arg_parse_int(argc, argv, index, &value, 0);
    157                 if (rc != EOK)
    158                         return rc;
    159                 port = (uint16_t) value;
    160                 break;
    161         case 's':
    162                 rc = arg_parse_int(argc, argv, index, &value, 0);
    163                 if (rc != EOK)
    164                         return rc;
    165                 size = (value >= 0) ? (size_t) value : 0;
    166                 break;
    167         case 't':
    168                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
    169                     socket_parse_socket_type);
    170                 if (rc != EOK)
    171                         return rc;
    172                 type = (sock_type_t) value;
    173                 break;
    174         case 'v':
    175                 verbose = true;
    176                 break;
    177         /*
    178          * Long options with double dash ('-')
    179          */
    180         case '-':
    181                 if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    182                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
    183                             socket_parse_protocol_family);
    184                         if (rc != EOK)
    185                                 return rc;
    186                 } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    187                         nettest2_print_help();
    188                         return EOK;
    189                 } else if (str_lcmp(argv[*index] + 2, "messages=", 6) == 0) {
    190                         rc = arg_parse_int(argc, argv, index, &messages, 8);
    191                         if (rc != EOK)
    192                                 return rc;
    193                 } else if (str_lcmp(argv[*index] + 2, "sockets=", 6) == 0) {
    194                         rc = arg_parse_int(argc, argv, index, &sockets, 8);
    195                         if (rc != EOK)
    196                                 return rc;
    197                 } else if (str_lcmp(argv[*index] + 2, "port=", 5) == 0) {
    198                         rc = arg_parse_int(argc, argv, index, &value, 7);
    199                         if (rc != EOK)
    200                                 return rc;
    201                         port = (uint16_t) value;
    202                 } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    203                         rc = arg_parse_name_int(argc, argv, index, &value, 7,
    204                             socket_parse_socket_type);
    205                         if (rc != EOK)
    206                                 return rc;
    207                         type = (sock_type_t) value;
    208                 } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    209                         verbose = 1;
     134        int index;
     135        struct timeval time_before;
     136        struct timeval time_after;
     137
     138        // parse the command line arguments
     139        // stop before the last argument if it does not start with the minus sign ('-')
     140        for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); ++ index) {
     141                // options should start with the minus sign ('-')
     142                if (argv[index][0] == '-') {
     143                        switch(argv[index][1]){
     144                        // short options with only one letter
     145                        case 'f':
     146                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family));
     147                                break;
     148                        case 'h':
     149                                nettest2_print_help();
     150                                return EOK;
     151                                break;
     152                        case 'm':
     153                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 0));
     154                                break;
     155                        case 'n':
     156                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 0));
     157                                break;
     158                        case 'p':
     159                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     160                                port = (uint16_t) value;
     161                                break;
     162                        case 's':
     163                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     164                                size = (value >= 0) ? (size_t) value : 0;
     165                                break;
     166                        case 't':
     167                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type));
     168                                type = (sock_type_t) value;
     169                                break;
     170                        case 'v':
     171                                verbose = 1;
     172                                break;
     173                        // long options with the double minus sign ('-')
     174                        case '-':
     175                                if (str_lcmp(argv[index] + 2, "family=", 7) == 0) {
     176                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family));
     177                                } else if (str_lcmp(argv[index] + 2, "help", 5) == 0) {
     178                                        nettest2_print_help();
     179                                        return EOK;
     180                                } else if (str_lcmp(argv[index] + 2, "messages=", 6) == 0) {
     181                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 8));
     182                                } else if (str_lcmp(argv[index] + 2, "sockets=", 6) == 0) {
     183                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 8));
     184                                } else if (str_lcmp(argv[index] + 2, "port=", 5) == 0) {
     185                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 7));
     186                                        port = (uint16_t) value;
     187                                } else if (str_lcmp(argv[index] + 2, "type=", 5) == 0) {
     188                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type));
     189                                        type = (sock_type_t) value;
     190                                } else if (str_lcmp(argv[index] + 2, "verbose", 8) == 0) {
     191                                        verbose = 1;
     192                                } else {
     193                                        nettest2_print_help();
     194                                        return EINVAL;
     195                                }
     196                                break;
     197                        default:
     198                                nettest2_print_help();
     199                                return EINVAL;
     200                        }
    210201                } else {
    211202                        nettest2_print_help();
    212203                        return EINVAL;
    213204                }
    214                 break;
    215         default:
    216                 nettest2_print_help();
    217                 return EINVAL;
    218         }
    219 
    220         return EOK;
    221 }
    222 
    223 int main(int argc, char *argv[])
    224 {
    225         socklen_t max_length;
    226         uint8_t address_data[sizeof(struct sockaddr_in6)];
    227         struct sockaddr *address;
    228         struct sockaddr_in *address_in;
    229         struct sockaddr_in6 *address_in6;
    230         socklen_t addrlen;
    231         uint8_t *address_start;
    232 
    233         int *socket_ids;
    234         char *data;
    235         int index;
    236         struct timeval time_before;
    237         struct timeval time_after;
    238 
    239         int rc;
    240 
    241         size = 28;
    242         verbose = false;
    243         type = SOCK_DGRAM;
    244         sockets = 10;
    245         messages = 10;
    246         family = PF_INET;
    247         port = 7;
    248 
    249         max_length = sizeof(address_data);
    250         address = (struct sockaddr *) address_data;
    251         address_in = (struct sockaddr_in *) address;
    252         address_in6 = (struct sockaddr_in6 *) address;
    253 
    254         /*
    255          * Parse the command line arguments.
    256          *
    257          * Stop before the last argument if it does not start with dash ('-')
    258          */
    259         for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    260             (argv[index][0] == '-')); ++index) {
    261 
    262                 /* Options should start with dash ('-') */
    263                 if (argv[index][0] == '-') {
    264                         rc = nettest2_parse_opt(argc, argv, &index);
    265                         if (rc != EOK)
    266                                 return rc;
    267                 } else {
    268                         nettest2_print_help();
    269                         return EINVAL;
    270                 }
    271         }
    272 
    273         /* If not before the last argument containing the address */
     205        }
     206
     207        // if not before the last argument containing the address
    274208        if (index >= argc) {
    275209                printf("Command line error: missing address\n");
    … …  
    278212        }
    279213
    280         /* Prepare the address buffer */
     214        // prepare the address buffer
    281215        bzero(address_data, max_length);
    282 
    283216        switch (family) {
    284217        case PF_INET:
    … …  
    299232        }
    300233
    301         /* Parse the last argument which should contain the address. */
    302         rc = inet_pton(family, argv[argc - 1], address_start);
    303         if (rc != EOK) {
    304                 fprintf(stderr, "Address parse error %d\n", rc);
    305                 return rc;
    306         }
    307 
    308         /* Check data buffer size. */
     234        // parse the last argument which should contain the address
     235        if (ERROR_OCCURRED(inet_pton(family, argv[argc - 1], address_start))) {
     236                fprintf(stderr, "Address parse error %d\n", ERROR_CODE);
     237                return ERROR_CODE;
     238        }
     239
     240        // check the buffer size
    309241        if (size <= 0) {
    310                 fprintf(stderr, "Data buffer size too small (%d). Using 1024 "
    311                     "bytes instead.\n", size);
     242                fprintf(stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size);
    312243                size = 1024;
    313244        }
    314245
    315         /*
    316          * Prepare the buffer. Allocate size bytes plus one for terminating
    317          * null character.
    318          */
     246        // prepare the buffer
     247        // size plus terminating null (\0)
    319248        data = (char *) malloc(size + 1);
    320249        if (!data) {
    … …  
    322251                return ENOMEM;
    323252        }
    324 
    325         /* Fill buffer with a pattern. */
    326         nettest2_fill_buffer(data, size);
    327 
    328         /* Check socket count. */
     253        nettest2_refresh_data(data, size);
     254
     255        // check the socket count
    329256        if (sockets <= 0) {
    330                 fprintf(stderr, "Socket count too small (%d). Using "
    331                     "2 instead.\n", sockets);
     257                fprintf(stderr, "Socket count too small (%d). Using 2 instead.\n", sockets);
    332258                sockets = 2;
    333259        }
    334260
    335         /*
    336          * Prepare the socket buffer.
    337          * Allocate count entries plus the terminating null (\0)
    338          */
     261        // prepare the socket buffer
     262        // count plus the terminating null (\0)
    339263        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    340264        if (!socket_ids) {
    … …  
    347271                printf("Starting tests\n");
    348272
    349         rc = sockets_create(verbose, socket_ids, sockets, family, type);
    350         if (rc != EOK)
    351                 return rc;
    352 
    353         if (type == SOCK_STREAM) {
    354                 rc = sockets_connect(verbose, socket_ids, sockets,
    355                     address, addrlen);
    356                 if (rc != EOK)
    357                         return rc;
    358         }
     273        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     274
     275        if (type == SOCK_STREAM)
     276                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
    359277
    360278        if (verbose)
    361279                printf("\n");
    362280
    363         rc = gettimeofday(&time_before, NULL);
    364         if (rc != EOK) {
    365                 fprintf(stderr, "Get time of day error %d\n", rc);
    366                 return rc;
    367         }
    368 
    369         rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    370             &addrlen, data, size, messages);
    371         if (rc != EOK)
    372                 return rc;
    373 
    374         rc = gettimeofday(&time_after, NULL);
    375         if (rc != EOK) {
    376                 fprintf(stderr, "Get time of day error %d\n", rc);
    377                 return rc;
     281        if (ERROR_OCCURRED(gettimeofday(&time_before, NULL))) {
     282                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     283                return ERROR_CODE;
     284        }
     285
     286        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     287
     288        if (ERROR_OCCURRED(gettimeofday(&time_after, NULL))) {
     289                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     290                return ERROR_CODE;
    378291        }
    379292
    … …  
    381294                printf("\tOK\n");
    382295
    383         printf("sendto + recvfrom tested in %d microseconds\n",
    384             tv_sub(&time_after, &time_before));
    385 
    386         rc = gettimeofday(&time_before, NULL);
    387         if (rc != EOK) {
    388                 fprintf(stderr, "Get time of day error %d\n", rc);
    389                 return rc;
    390         }
    391 
    392         rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    393             data, size, messages);
    394         if (rc != EOK)
    395                 return rc;
    396 
    397         rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    398             data, size, messages);
    399         if (rc != EOK)
    400                 return rc;
    401 
    402         rc = gettimeofday(&time_after, NULL);
    403         if (rc != EOK) {
    404                 fprintf(stderr, "Get time of day error %d\n", rc);
    405                 return rc;
     296        printf("sendto + recvfrom tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     297
     298        if (ERROR_OCCURRED(gettimeofday(&time_before, NULL))) {
     299                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     300                return ERROR_CODE;
     301        }
     302
     303        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, messages));
     304        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     305
     306        if (ERROR_OCCURRED(gettimeofday(&time_after, NULL))) {
     307                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     308                return ERROR_CODE;
    406309        }
    407310
    … …  
    409312                printf("\tOK\n");
    410313
    411         printf("sendto, recvfrom tested in %d microseconds\n",
    412             tv_sub(&time_after, &time_before));
    413 
    414         rc = sockets_close(verbose, socket_ids, sockets);
    415         if (rc != EOK)
    416                 return rc;
     314        printf("sendto, recvfrom tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     315
     316        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
    417317
    418318        if (verbose)

  • uspace/app/redir/redir.c

    r9fd39d6 r68f0c3a  
    4343#include <task.h>
    4444#include <str_error.h>
    45 #include <errno.h>
    4645
    4746#define NAME  "redir"
    … …  
    7776static task_id_t spawn(int argc, char *argv[])
    7877{
    79         const char **args;
    80         task_id_t id;
    81         int rc;
    82 
    83         args = (const char **) calloc(argc + 1, sizeof(char *));
     78        const char **args = (const char **) calloc(argc + 1, sizeof(char *));
    8479        if (!args) {
    8580                printf("No memory available\n");
    … …  
    9388        args[argc] = NULL;
    9489       
    95         rc = task_spawnv(&id, argv[0], args);
     90        int err;
     91        task_id_t id = task_spawn(argv[0], args, &err);
    9692       
    9793        free(args);
    9894       
    99         if (rc != EOK) {
     95        if (id == 0)
    10096                printf("%s: Error spawning %s (%s)\n", NAME, argv[0],
    101                     str_error(rc));
    102         }
     97                    str_error(err));
    10398       
    10499        return id;

  • uspace/app/sbi/src/os/helenos.c

    r9fd39d6 r68f0c3a  
    249249        task_id_t tid;
    250250        task_exit_t texit;
    251         int rc, retval;
    252 
    253         rc = task_spawnv(&tid, cmd[0], (char const * const *) cmd);
    254         if (rc != EOK) {
     251        int retval;
     252
     253        tid = task_spawn(cmd[0], (char const * const *) cmd, &retval);
     254        if (tid == 0) {
    255255                printf("Error: Failed spawning '%s' (%s).\n", cmd[0],
    256                     str_error(rc));
     256                    str_error(retval));
    257257                exit(1);
    258258        }
    259259
    260260        /* XXX Handle exit status and return value. */
    261         rc = task_wait(tid, &texit, &retval);
    262         (void) rc;
     261        task_wait(tid, &texit, &retval);
    263262
    264263        return EOK;

  • uspace/lib/c/generic/task.c

    r9fd39d6 r68f0c3a  
    3939#include <errno.h>
    4040#include <loader/loader.h>
    41 #include <stdarg.h>
    4241#include <str.h>
    4342#include <ipc/ns.h>
    … …  
    6968 *
    7069 * This is really just a convenience wrapper over the more complicated
    71  * loader API. Arguments are passed as a null-terminated array of strings.
     70 * loader API.
    7271 *
    73  * @param id    If not NULL, the ID of the task is stored here on success.
    74  * @param path  Pathname of the binary to execute.
    75  * @param argv  Command-line arguments.
     72 * @param path Pathname of the binary to execute.
     73 * @param argv Command-line arguments.
     74 * @param err  If not NULL, the error value is stored here.
    7675 *
    77  * @return      Zero on success or negative error code.
     76 * @return ID of the newly created task or zero on error.
     77 *
    7878 */
    79 int task_spawnv(task_id_t *id, const char *path, const char *const args[])
     79task_id_t task_spawn(const char *path, const char *const args[], int *err)
    8080{
    81         loader_t *ldr;
    82         task_id_t task_id;
    83         int rc;
    84 
    8581        /* Connect to a program loader. */
    86         ldr = loader_connect();
    87         if (ldr == NULL)
    88                 return EREFUSED;
     82        loader_t *ldr = loader_connect();
     83        if (ldr == NULL) {
     84                if (err != NULL)
     85                        *err = EREFUSED;
     86               
     87                return 0;
     88        }
    8989       
    9090        /* Get task ID. */
    91         rc = loader_get_task_id(ldr, &task_id);
     91        task_id_t task_id;
     92        int rc = loader_get_task_id(ldr, &task_id);
    9293        if (rc != EOK)
    9394                goto error;
    … …  
    148149        free(ldr);
    149150       
    150         if (id != NULL)
    151                 *id = task_id;
     151        if (err != NULL)
     152                *err = EOK;
    152153       
    153         return EOK;
     154        return task_id;
    154155       
    155156error:
    … …  
    157158        loader_abort(ldr);
    158159        free(ldr);
    159         return rc;
    160 }
    161 
    162 /** Create a new task by running an executable from the filesystem.
    163  *
    164  * This is really just a convenience wrapper over the more complicated
    165  * loader API. Arguments are passed as a null-terminated list of arguments.
    166  *
    167  * @param id    If not NULL, the ID of the task is stored here on success.
    168  * @param path  Pathname of the binary to execute.
    169  * @param ...   Command-line arguments.
    170  *
    171  * @return      Zero on success or negative error code.
    172  */
    173 int task_spawnl(task_id_t *task_id, const char *path, ...)
    174 {
    175         va_list ap;
    176         int rc, cnt;
    177         const char *arg;
    178         const char **arglist;
    179 
    180         /* Count the number of arguments. */
    181         cnt = 0;
    182         va_start(ap, path);
    183         do {
    184                 arg = va_arg(ap, const char *);
    185                 cnt++;
    186         } while (arg != NULL);
    187         va_end(ap);
    188 
    189         /* Allocate argument list. */
    190         arglist = malloc(cnt * sizeof(const char *));
    191         if (arglist == NULL)
    192                 return ENOMEM;
    193 
    194         /* Fill in arguments. */
    195         cnt = 0;
    196         va_start(ap, path);
    197         do {
    198                 arg = va_arg(ap, const char *);
    199                 arglist[cnt++] = arg;
    200         } while (arg != NULL);
    201         va_end(ap);
    202 
    203         /* Spawn task. */
    204         rc = task_spawnv(task_id, path, arglist);
    205 
    206         /* Free argument list. */
    207         free(arglist);
    208         return rc;
     160       
     161        if (err != NULL)
     162                *err = rc;
     163       
     164        return 0;
    209165}
    210166

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

    r9fd39d6 r68f0c3a  
    4848extern int task_set_name(const char *);
    4949extern task_id_t task_spawn(const char *, const char *const[], int *);
    50 extern int task_spawnv(task_id_t *, const char *path, const char *const []);
    51 extern int task_spawnl(task_id_t *, const char *path, ...);
    52 
    5350extern int task_wait(task_id_t id, task_exit_t *, int *);
    5451extern int task_retval(int);

  • uspace/lib/net/adt/module_map.c

    r9fd39d6 r68f0c3a  
    132132task_id_t spawn(const char *fname)
    133133{
    134         task_id_t id;
    135         int rc;
     134        const char *argv[2];
     135        task_id_t res;
    136136       
    137         rc = task_spawnl(&id, fname, fname, NULL);
    138         if (rc != EOK)
    139                 return 0;
     137        argv[0] = fname;
     138        argv[1] = NULL;
     139        res = task_spawn(fname, argv, NULL);
    140140       
    141         return id;
     141        return res;
    142142}
    143143

  • uspace/srv/devman/devman.c

    r9fd39d6 r68f0c3a  
    3737#include <ipc/devman.h>
    3838#include <devmap.h>
    39 #include <str_error.h>
    4039
    4140#include "devman.h"
    … …  
    447446bool start_driver(driver_t *drv)
    448447{
    449         int rc;
    450 
    451448        printf(NAME ": start_driver '%s'\n", drv->name);
    452449       
    453         rc = task_spawnl(NULL, drv->binary_path, drv->binary_path, NULL);
    454         if (rc != EOK) {
    455                 printf(NAME ": error spawning %s (%s)\n",
    456                     drv->name, str_error(rc));
     450        const char *argv[2];
     451       
     452        argv[0] = drv->name;
     453        argv[1] = NULL;
     454       
     455        int err;
     456        if (task_spawn(drv->binary_path, argv, &err) == 0) {
     457                printf(NAME ": error spawning %s, errno = %d\n",
     458                    drv->name, err);
    457459                return false;
    458460        }

  • uspace/srv/taskmon/taskmon.c

    r9fd39d6 r68f0c3a  
    5050static void fault_event(ipc_callid_t callid, ipc_call_t *call)
    5151{
     52        const char *argv[6];
    5253        const char *fname;
     54        char *dump_fname;
    5355        char *s_taskid;
    54         int rc;
     56        const char **s;
    5557
    5658        task_id_t taskid;
    … …  
    6567        }
    6668
    67         printf(NAME ": Task %" PRIuTASKID " fault in thread %p.\n", taskid, thread);
    68 
    69         fname = "/app/taskdump";
    70 
    71 #ifdef CONFIG_WRITE_CORE_FILES
    72         char *dump_fname;
    73 
    7469        if (asprintf(&dump_fname, "/data/core%" PRIuTASKID, taskid) < 0) {
    7570                printf("Memory allocation failed.\n");
    … …  
    7772        }
    7873
    79         printf(NAME ": Executing %s -c %s -t %s\n", dump_fname, s_taskid);
    80         rc = task_spawnl(NULL, fname, fname, "-c", dump_fname, "-t", s_taskid,
    81             NULL);
     74        printf(NAME ": Task %" PRIuTASKID " fault in thread %p.\n", taskid, thread);
     75
     76#ifdef CONFIG_WRITE_CORE_FILES
     77        argv[0] = "/app/taskdump";
     78        argv[1] = "-c";
     79        argv[2] = dump_fname;
     80        argv[3] = "-t";
     81        argv[4] = s_taskid;
     82        argv[5] = NULL;
    8283#else
    83         printf(NAME ": Executing %s -t %s\n", s_taskid);
    84         rc = task_spawnl(NULL, fname, fname, "-t", s_taskid, NULL);
     84        argv[0] = "/app/taskdump";
     85        argv[1] = "-t";
     86        argv[2] = s_taskid;
     87        argv[3] = NULL;
    8588#endif
    86         if (rc != EOK) {
     89        fname = argv[0];
     90
     91        printf(NAME ": Executing");
     92       
     93        s = argv;
     94        while (*s != NULL) {
     95                printf(" %s", *s);
     96                ++s;
     97        }
     98        putchar('\n');
     99       
     100        int err;
     101        if (!task_spawn(fname, argv, &err))
    87102                printf("%s: Error spawning %s (%s).\n", NAME, fname,
    88                     str_error(rc));
    89         }
     103                    str_error(err));
    90104}
    91105
Note: See TracChangeset for help on using the changeset viewer.