Changeset ea28272 in mainline for uspace/app


Ignore:
Timestamp:
2010-12-30T13:43:27Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d770deb
Parents:
d70d80ed (diff), f418e51 (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.

Location:
uspace/app
Files:
7 added
3 deleted
17 edited
1 moved

Legend:

Unmodified
Added
Removed

  • uspace/app/edit/edit.c

    rd70d80ed rea28272  
    100100static bool cursor_visible;
    101101
    102 static ipcarg_t scr_rows;
    103 static ipcarg_t scr_columns;
     102static sysarg_t scr_rows;
     103static sysarg_t scr_columns;
    104104
    105105#define ROW_BUF_SIZE 4096
    … …  
    684684       
    685685        int i;
    686         ipcarg_t j;
     686        sysarg_t j;
    687687        for (i = rows; i < pane.rows; ++i) {
    688688                console_set_pos(con, 0, i);

  • uspace/app/init/init.c

    rd70d80ed rea28272  
    5757#define DEVFS_MOUNT_POINT  "/dev"
    5858
    59 #define SCRATCH_FS_TYPE      "tmpfs"
    60 #define SCRATCH_MOUNT_POINT  "/scratch"
     59#define TMPFS_FS_TYPE      "tmpfs"
     60#define TMPFS_MOUNT_POINT  "/tmp"
    6161
    6262#define DATA_FS_TYPE      "fat"
    … …  
    235235}
    236236
    237 static bool mount_scratch(void)
    238 {
    239         int rc = mount(SCRATCH_FS_TYPE, SCRATCH_MOUNT_POINT, "", "", 0);
    240         return mount_report("Scratch filesystem", SCRATCH_MOUNT_POINT,
    241             SCRATCH_FS_TYPE, NULL, rc);
     237static bool mount_tmpfs(void)
     238{
     239        int rc = mount(TMPFS_FS_TYPE, TMPFS_MOUNT_POINT, "", "", 0);
     240        return mount_report("Temporary filesystem", TMPFS_MOUNT_POINT,
     241            TMPFS_FS_TYPE, NULL, rc);
    242242}
    243243
    … …  
    271271        }
    272272       
    273         mount_scratch();
     273        mount_tmpfs();
    274274       
    275275        spawn("/srv/fhc");

  • uspace/app/kill/kill.c

    rd70d80ed rea28272  
    11/*
    2  * Copyright (c) 2006 Ondrej Palkovsky
     2 * Copyright (c) 2010 Jiri Svoboda
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
     29/** @addtogroup kill
     30 * @{
     31 */
     32/**
     33 * @file Forecfully terminate a task.
     34 */
     35
     36#include <errno.h>
    2937#include <stdio.h>
    30 #include <unistd.h>
    31 #include <atomic.h>
    32 #include "../tester.h"
     38#include <task.h>
    3339
    34 static atomic_t finish;
     40#define NAME "kill"
    3541
    36 static void callback(void *priv, int retval, ipc_call_t *data)
     42static void print_syntax(void)
    3743{
    38         atomic_set(&finish, 1);
     44        printf("Syntax: " NAME " <task ID>\n");
    3945}
    4046
    41 const char *test_connect(void)
     47int main(int argc, char *argv[])
    4248{
    43         TPRINTF("Connecting to %u...", IPC_TEST_SERVICE);
    44         int phone = ipc_connect_me_to(PHONE_NS, IPC_TEST_SERVICE, 0, 0);
    45         if (phone > 0) {
    46                 TPRINTF("phoneid %d\n", phone);
    47         } else {
    48                 TPRINTF("\n");
    49                 return "ipc_connect_me_to() failed";
     49        char *eptr;
     50        task_id_t taskid;
     51        int rc;
     52
     53        if (argc != 2) {
     54                print_syntax();
     55                return 1;
    5056        }
    51        
    52         printf("Sending synchronous message...\n");
    53         int retval = ipc_call_sync_0_0(phone, IPC_TEST_METHOD);
    54         TPRINTF("Received response to synchronous message\n");
    55        
    56         TPRINTF("Sending asynchronous message...\n");
    57         atomic_set(&finish, 0);
    58         ipc_call_async_0(phone, IPC_TEST_METHOD, NULL, callback, 1);
    59         while (atomic_get(&finish) != 1)
    60                 TPRINTF(".");
    61         TPRINTF("Received response to asynchronous message\n");
    62        
    63         TPRINTF("Hanging up...");
    64         retval = ipc_hangup(phone);
    65         if (retval == 0) {
    66                 TPRINTF("OK\n");
    67         } else {
    68                 TPRINTF("\n");
    69                 return "ipc_hangup() failed";
     57
     58        taskid = strtoul(argv[1], &eptr, 0);
     59        if (*eptr != '\0') {
     60                printf("Invalid task ID argument '%s'.\n", argv[1]);
     61                return 1;
    7062        }
    71        
    72         return NULL;
     63
     64        rc = task_kill(taskid);
     65        if (rc != EOK) {
     66                printf("Failed to kill task with ID %llu (error %d)\n",
     67                    (unsigned long long) taskid, rc);
     68                return 2;
     69        }
     70
     71        return 0;
    7372}
     73
     74/** @}
     75 */

  • uspace/app/netecho/netecho.c

    rd70d80ed rea28272  
    3232
    3333/** @file
    34  * Network echo application.
    35  * Answers received packets.
     34 * Network echo server.
     35 *
     36 * Sockets-based server that echoes incomming messages. If stream mode
     37 * is selected, accepts incoming connections.
    3638 */
    3739
    38 #include <malloc.h>
     40#include <assert.h>
    3941#include <stdio.h>
     42#include <stdlib.h>
    4043#include <str.h>
    4144#include <task.h>
    … …  
    5053#include "print_error.h"
    5154
    52 /** Network echo module name. */
    53 #define NAME    "Network Echo"
     55#define NAME "netecho"
     56
     57static int count = -1;
     58static int family = PF_INET;
     59static sock_type_t type = SOCK_DGRAM;
     60static uint16_t port = 7;
     61static int backlog = 3;
     62static size_t size = 1024;
     63static int verbose = 0;
     64
     65static char *reply = NULL;
     66static size_t reply_length;
     67
     68static char *data;
    5469
    5570static void echo_print_help(void)
    5671{
    5772        printf(
    58                 "Network Echo aplication\n" \
    59                 "Usage: echo [options]\n" \
    60                 "Where options are:\n" \
    61                 "-b backlog | --backlog=size\n" \
    62                 "\tThe size of the accepted sockets queue. Only for SOCK_STREAM. The default is 3.\n" \
    63                 "\n" \
    64                 "-c count | --count=count\n" \
    65                 "\tThe number of received messages to handle. A negative number means infinity. The default is infinity.\n" \
    66                 "\n" \
    67                 "-f protocol_family | --family=protocol_family\n" \
    68                 "\tThe listenning socket protocol family. Only the PF_INET and PF_INET6 are supported.\n"
    69                 "\n" \
    70                 "-h | --help\n" \
    71                 "\tShow this application help.\n"
    72                 "\n" \
    73                 "-p port_number | --port=port_number\n" \
    74                 "\tThe port number the application should listen at. The default is 7.\n" \
    75                 "\n" \
    76                 "-r reply_string | --reply=reply_string\n" \
    77                 "\tThe constant reply string. The default is the original data received.\n" \
    78                 "\n" \
    79                 "-s receive_size | --size=receive_size\n" \
    80                 "\tThe maximum receive data size the application should accept. The default is 1024 bytes.\n" \
    81                 "\n" \
    82                 "-t socket_type | --type=socket_type\n" \
    83                 "\tThe listenning socket type. Only the SOCK_DGRAM and the SOCK_STREAM are supported.\n" \
    84                 "\n" \
    85                 "-v | --verbose\n" \
    86                 "\tShow all output messages.\n"
     73            "Network echo server\n"
     74            "Usage: " NAME " [options]\n"
     75            "Where options are:\n"
     76            "-b backlog | --backlog=size\n"
     77            "\tThe size of the accepted sockets queue. Only for SOCK_STREAM. "
     78            "The default is 3.\n"
     79            "\n"
     80            "-c count | --count=count\n"
     81            "\tThe number of received messages to handle. A negative number "
     82            "means infinity. The default is infinity.\n"
     83            "\n"
     84            "-f protocol_family | --family=protocol_family\n"
     85            "\tThe listenning socket protocol family. Only the PF_INET and "
     86            "PF_INET6 are supported.\n"
     87            "\n"
     88            "-h | --help\n"
     89            "\tShow this application help.\n"
     90            "\n"
     91            "-p port_number | --port=port_number\n"
     92            "\tThe port number the application should listen at. The default "
     93            "is 7.\n"
     94            "\n"
     95            "-r reply_string | --reply=reply_string\n"
     96            "\tThe constant reply string. The default is the original data "
     97            "received.\n"
     98            "\n"
     99            "-s receive_size | --size=receive_size\n"
     100            "\tThe maximum receive data size the application should accept. "
     101            "The default is 1024 bytes.\n"
     102            "\n"
     103            "-t socket_type | --type=socket_type\n"
     104            "\tThe listenning socket type. Only the SOCK_DGRAM and the "
     105            "SOCK_STREAM are supported.\n"
     106            "\n"
     107            "-v | --verbose\n"
     108            "\tShow all output messages.\n"
    87109        );
    88110}
    89111
    90 int main(int argc, char *argv[])
     112static int netecho_parse_option(int argc, char *argv[], int *index)
    91113{
    92         size_t size = 1024;
    93         int verbose = 0;
    94         char *reply = NULL;
    95         sock_type_t type = SOCK_DGRAM;
    96         int count = -1;
    97         int family = PF_INET;
    98         uint16_t port = 7;
    99         int backlog = 3;
    100 
    101         socklen_t max_length = sizeof(struct sockaddr_in6);
    102         uint8_t address_data[max_length];
    103         struct sockaddr *address = (struct sockaddr *) address_data;
    104         struct sockaddr_in *address_in = (struct sockaddr_in *) address;
    105         struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address;
    106         socklen_t addrlen;
    107         char address_string[INET6_ADDRSTRLEN];
    108         uint8_t *address_start;
    109         int socket_id;
    110         int listening_id;
    111         char *data;
    112         size_t length;
    113         int index;
    114         size_t reply_length;
    115114        int value;
    116115        int rc;
    117116
    118         // parse the command line arguments
    119         for (index = 1; index < argc; ++ index) {
    120                 if (argv[index][0] == '-') {
    121                         switch (argv[index][1]) {
    122                         case 'b':
    123                                 rc = arg_parse_int(argc, argv, &index, &backlog, 0);
    124                                 if (rc != EOK)
    125                                         return rc;
    126                                 break;
    127                         case 'c':
    128                                 rc = arg_parse_int(argc, argv, &index, &count, 0);
    129                                 if (rc != EOK)
    130                                         return rc;
    131                                 break;
    132                         case 'f':
    133                                 rc = arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family);
    134                                 if (rc != EOK)
    135                                         return rc;
    136                                 break;
    137                         case 'h':
    138                                 echo_print_help();
    139                                 return EOK;
    140                                 break;
    141                         case 'p':
    142                                 rc = arg_parse_int(argc, argv, &index, &value, 0);
    143                                 if (rc != EOK)
    144                                         return rc;
    145                                 port = (uint16_t) value;
    146                                 break;
    147                         case 'r':
    148                                 rc = arg_parse_string(argc, argv, &index, &reply, 0);
    149                                 if (rc != EOK)
    150                                         return rc;
    151                                 break;
    152                         case 's':
    153                                 rc = arg_parse_int(argc, argv, &index, &value, 0);
    154                                 if (rc != EOK)
    155                                         return rc;
    156                                 size = (value >= 0) ? (size_t) value : 0;
    157                                 break;
    158                         case 't':
    159                                 rc = arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type);
    160                                 if (rc != EOK)
    161                                         return rc;
    162                                 type = (sock_type_t) value;
    163                                 break;
    164                         case 'v':
    165                                 verbose = 1;
    166                                 break;
    167                         // long options with the double minus sign ('-')
    168                         case '-':
    169                                 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;
    173                                 } else if (str_lcmp(argv[index] + 2, "count=", 6) == 0) {
    174                                         rc = arg_parse_int(argc, argv, &index, &count, 8);
    175                                         if (rc != EOK)
    176                                                 return rc;
    177                                 } else if (str_lcmp(argv[index] + 2, "family=", 7) == 0) {
    178                                         rc = arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family);
    179                                         if (rc != EOK)
    180                                                 return rc;
    181                                 } else if (str_lcmp(argv[index] + 2, "help", 5) == 0) {
    182                                         echo_print_help();
    183                                         return EOK;
    184                                 } else if (str_lcmp(argv[index] + 2, "port=", 5) == 0) {
    185                                         rc = arg_parse_int(argc, argv, &index, &value, 7);
    186                                         if (rc != EOK)
    187                                                 return rc;
    188                                         port = (uint16_t) value;
    189                                 } else if (str_lcmp(argv[index] + 2, "reply=", 6) == 0) {
    190                                         rc = arg_parse_string(argc, argv, &index, &reply, 8);
    191                                         if (rc != EOK)
    192                                                 return rc;
    193                                 } else if (str_lcmp(argv[index] + 2, "size=", 5) == 0) {
    194                                         rc = arg_parse_int(argc, argv, &index, &value, 7);
    195                                         if (rc != EOK)
    196                                                 return rc;
    197                                         size = (value >= 0) ? (size_t) value : 0;
    198                                 } else if (str_lcmp(argv[index] + 2, "type=", 5) == 0) {
    199                                         rc = arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type);
    200                                         if (rc != EOK)
    201                                                 return rc;
    202                                         type = (sock_type_t) value;
    203                                 } else if (str_lcmp(argv[index] + 2, "verbose", 8) == 0) {
    204                                         verbose = 1;
    205                                 } else {
    206                                         echo_print_help();
    207                                         return EINVAL;
    208                                 }
    209                                 break;
    210                         default:
    211                                 echo_print_help();
    212                                 return EINVAL;
    213                         }
     117        switch (argv[*index][1]) {
     118        case 'b':
     119                rc = arg_parse_int(argc, argv, index, &backlog, 0);
     120                if (rc != EOK)
     121                        return rc;
     122                break;
     123        case 'c':
     124                rc = arg_parse_int(argc, argv, index, &count, 0);
     125                if (rc != EOK)
     126                        return rc;
     127                break;
     128        case 'f':
     129                rc = arg_parse_name_int(argc, argv, index, &family, 0,
     130                    socket_parse_protocol_family);
     131                if (rc != EOK)
     132                        return rc;
     133                break;
     134        case 'h':
     135                echo_print_help();
     136                exit(0);
     137                break;
     138        case 'p':
     139                rc = arg_parse_int(argc, argv, index, &value, 0);
     140                if (rc != EOK)
     141                        return rc;
     142                port = (uint16_t) value;
     143                break;
     144        case 'r':
     145                rc = arg_parse_string(argc, argv, index, &reply, 0);
     146                if (rc != EOK)
     147                        return rc;
     148                break;
     149        case 's':
     150                rc = arg_parse_int(argc, argv, index, &value, 0);
     151                if (rc != EOK)
     152                        return rc;
     153                size = (value >= 0) ? (size_t) value : 0;
     154                break;
     155        case 't':
     156                rc = arg_parse_name_int(argc, argv, index, &value, 0,
     157                    socket_parse_socket_type);
     158                if (rc != EOK)
     159                        return rc;
     160                type = (sock_type_t) value;
     161                break;
     162        case 'v':
     163                verbose = 1;
     164                break;
     165        /* Long options with double dash */
     166        case '-':
     167                if (str_lcmp(argv[*index] + 2, "backlog=", 6) == 0) {
     168                        rc = arg_parse_int(argc, argv, index, &backlog, 8);
     169                        if (rc != EOK)
     170                                return rc;
     171                } else if (str_lcmp(argv[*index] + 2, "count=", 6) == 0) {
     172                        rc = arg_parse_int(argc, argv, index, &count, 8);
     173                        if (rc != EOK)
     174                                return rc;
     175                } else if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
     176                        rc = arg_parse_name_int(argc, argv, index, &family, 9,
     177                            socket_parse_protocol_family);
     178                        if (rc != EOK)
     179                                return rc;
     180                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
     181                        echo_print_help();
     182                        return EOK;
     183                } else if (str_lcmp(argv[*index] + 2, "port=", 5) == 0) {
     184                        rc = arg_parse_int(argc, argv, index, &value, 7);
     185                        if (rc != EOK)
     186                                return rc;
     187                        port = (uint16_t) value;
     188                } else if (str_lcmp(argv[*index] + 2, "reply=", 6) == 0) {
     189                        rc = arg_parse_string(argc, argv, index, &reply, 8);
     190                        if (rc != EOK)
     191                                return rc;
     192                } else if (str_lcmp(argv[*index] + 2, "size=", 5) == 0) {
     193                        rc = arg_parse_int(argc, argv, index, &value, 7);
     194                        if (rc != EOK)
     195                                return rc;
     196                        size = (value >= 0) ? (size_t) value : 0;
     197                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
     198                        rc = arg_parse_name_int(argc, argv, index, &value, 7,
     199                            socket_parse_socket_type);
     200                        if (rc != EOK)
     201                                return rc;
     202                        type = (sock_type_t) value;
     203                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
     204                        verbose = 1;
    214205                } else {
    215206                        echo_print_help();
    216207                        return EINVAL;
    217208                }
    218         }
    219 
    220         // check the buffer size
     209                break;
     210        default:
     211                echo_print_help();
     212                return EINVAL;
     213        }
     214
     215        return EOK;
     216}
     217
     218/** Echo one message (accept one connection and echo message).
     219 *
     220 * @param listening_id  Listening socket.
     221 * @return              EOK on success or negative error code.
     222 */
     223static int netecho_socket_process_message(int listening_id)
     224{
     225        uint8_t address_buf[sizeof(struct sockaddr_in6)];
     226
     227        socklen_t addrlen;
     228        int socket_id;
     229        ssize_t rcv_size;
     230        size_t length;
     231        uint8_t *address_start;
     232
     233        char address_string[INET6_ADDRSTRLEN];
     234        struct sockaddr_in *address_in = (struct sockaddr_in *) address_buf;
     235        struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address_buf;
     236        struct sockaddr *address = (struct sockaddr *) address_buf;
     237
     238        int rc;
     239
     240        if (type == SOCK_STREAM) {
     241                /* Accept a socket if a stream socket is used */
     242                addrlen = sizeof(address_buf);
     243                socket_id = accept(listening_id, (void *) address_buf, &addrlen);
     244                if (socket_id <= 0) {
     245                        socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
     246                } else {
     247                        if (verbose)
     248                                printf("Socket %d accepted\n", socket_id);
     249                }
     250
     251                assert((size_t) addrlen <= sizeof(address_buf));
     252        } else {
     253                socket_id = listening_id;
     254        }
     255
     256        /* if the datagram socket is used or the stream socked was accepted */
     257        if (socket_id > 0) {
     258
     259                /* Receive a message to echo */
     260                rcv_size = recvfrom(socket_id, data, size, 0, address,
     261                    &addrlen);
     262                if (rcv_size < 0) {
     263                        socket_print_error(stderr, rcv_size, "Socket receive: ", "\n");
     264                } else {
     265                        length = (size_t) rcv_size;
     266                        if (verbose) {
     267                                /* Print the header */
     268
     269                                /* Get the source port and prepare the address buffer */
     270                                address_start = NULL;
     271                                switch (address->sa_family) {
     272                                case AF_INET:
     273                                        port = ntohs(address_in->sin_port);
     274                                        address_start = (uint8_t *) &address_in->sin_addr.s_addr;
     275                                        break;
     276                                case AF_INET6:
     277                                        port = ntohs(address_in6->sin6_port);
     278                                        address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     279                                        break;
     280                                default:
     281                                        fprintf(stderr, "Address family %u (%#x) is not supported.\n",
     282                                            address->sa_family, address->sa_family);
     283                                }
     284
     285                                /* Parse source address */
     286                                if (address_start) {
     287                                        rc = inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string));
     288                                        if (rc != EOK) {
     289                                                fprintf(stderr, "Received address error %d\n", rc);
     290                                        } else {
     291                                                data[length] = '\0';
     292                                                printf("Socket %d received %zu bytes from %s:%d\n%s\n",
     293                                                    socket_id, length, address_string, port, data);
     294                                        }
     295                                }
     296                        }
     297
     298                        /* Answer the request either with the static reply or the original data */
     299                        rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
     300                        if (rc != EOK)
     301                                socket_print_error(stderr, rc, "Socket send: ", "\n");
     302                }
     303
     304                /* Close accepted stream socket */
     305                if (type == SOCK_STREAM) {
     306                        rc = closesocket(socket_id);
     307                        if (rc != EOK)
     308                                socket_print_error(stderr, rc, "Close socket: ", "\n");
     309                }
     310
     311        }
     312
     313        return EOK;
     314}
     315
     316
     317int main(int argc, char *argv[])
     318{
     319        struct sockaddr *address;;
     320        struct sockaddr_in address_in;
     321        struct sockaddr_in6 address_in6;
     322        socklen_t addrlen;
     323
     324        int listening_id;
     325        int index;
     326        int rc;
     327
     328        /* Parse command line arguments */
     329        for (index = 1; index < argc; ++index) {
     330                if (argv[index][0] == '-') {
     331                        rc = netecho_parse_option(argc, argv, &index);
     332                        if (rc != EOK)
     333                                return rc;
     334                } else {
     335                        echo_print_help();
     336                        return EINVAL;
     337                }
     338        }
     339
     340        /* Check buffer size */
    221341        if (size <= 0) {
    222342                fprintf(stderr, "Receive size too small (%zu). Using 1024 bytes instead.\n", size);
    223343                size = 1024;
    224344        }
    225         // size plus the terminating null (\0)
     345
     346        /* size plus the terminating null character. */
    226347        data = (char *) malloc(size + 1);
    227348        if (!data) {
    … …  
    230351        }
    231352
    232         // set the reply size if set
     353        /* Set the reply size if set */
    233354        reply_length = reply ? str_length(reply) : 0;
    234355
    235         // prepare the address buffer
    236         bzero(address_data, max_length);
     356        /* Prepare the address buffer */
    237357        switch (family) {
    238358        case PF_INET:
    239                 address_in->sin_family = AF_INET;
    240                 address_in->sin_port = htons(port);
    241                 addrlen = sizeof(struct sockaddr_in);
     359                address_in.sin_family = AF_INET;
     360                address_in.sin_port = htons(port);
     361                address = (struct sockaddr *) &address_in;
     362                addrlen = sizeof(address_in);
    242363                break;
    243364        case PF_INET6:
    244                 address_in6->sin6_family = AF_INET6;
    245                 address_in6->sin6_port = htons(port);
    246                 addrlen = sizeof(struct sockaddr_in6);
     365                address_in6.sin6_family = AF_INET6;
     366                address_in6.sin6_port = htons(port);
     367                address = (struct sockaddr *) &address_in6;
     368                addrlen = sizeof(address_in6);
    247369                break;
    248370        default:
    … …  
    251373        }
    252374
    253         // get a listening socket
     375        /* Get a listening socket */
    254376        listening_id = socket(family, type, 0);
    255377        if (listening_id < 0) {
    … …  
    258380        }
    259381
    260         // if the stream socket is used
     382        /* if the stream socket is used */
    261383        if (type == SOCK_STREAM) {
    262                 // check the backlog
     384                /* Check backlog size */
    263385                if (backlog <= 0) {
    264386                        fprintf(stderr, "Accepted sockets queue size too small (%zu). Using 3 instead.\n", size);
    265387                        backlog = 3;
    266388                }
    267                 // set the backlog
     389
     390                /* Set the backlog */
    268391                rc = listen(listening_id, backlog);
    269392                if (rc != EOK) {
    … …  
    273396        }
    274397
    275         // bind the listenning socket
     398        /* Bind the listening socket */
    276399        rc = bind(listening_id, address, addrlen);
    277400        if (rc != EOK) {
    … …  
    283406                printf("Socket %d listenning at %d\n", listening_id, port);
    284407
    285         socket_id = listening_id;
    286 
    287         // do count times
    288         // or indefinitely if set to a negative value
     408        /*
     409         * do count times
     410         * or indefinitely if set to a negative value
     411         */
    289412        while (count) {
    290 
    291                 addrlen = max_length;
    292                 if (type == SOCK_STREAM) {
    293                         // acceept a socket if the stream socket is used
    294                         socket_id = accept(listening_id, address, &addrlen);
    295                         if (socket_id <= 0) {
    296                                 socket_print_error(stderr, socket_id, "Socket accept: ", "\n");
    297                         } else {
    298                                 if (verbose)
    299                                         printf("Socket %d accepted\n", socket_id);
    300                         }
    301                 }
    302 
    303                 // if the datagram socket is used or the stream socked was accepted
    304                 if (socket_id > 0) {
    305 
    306                         // receive an echo request
    307                         value = recvfrom(socket_id, data, size, 0, address, &addrlen);
    308                         if (value < 0) {
    309                                 socket_print_error(stderr, value, "Socket receive: ", "\n");
    310                         } else {
    311                                 length = (size_t) value;
    312                                 if (verbose) {
    313                                         // print the header
    314 
    315                                         // get the source port and prepare the address buffer
    316                                         address_start = NULL;
    317                                         switch (address->sa_family) {
    318                                         case AF_INET:
    319                                                 port = ntohs(address_in->sin_port);
    320                                                 address_start = (uint8_t *) &address_in->sin_addr.s_addr;
    321                                                 break;
    322                                         case AF_INET6:
    323                                                 port = ntohs(address_in6->sin6_port);
    324                                                 address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
    325                                                 break;
    326                                         default:
    327                                                 fprintf(stderr, "Address family %u (%#x) is not supported.\n",
    328                                                     address->sa_family, address->sa_family);
    329                                         }
    330                                         // parse the source address
    331                                         if (address_start) {
    332                                                 rc = inet_ntop(address->sa_family, address_start, address_string, sizeof(address_string));
    333                                                 if (rc != EOK) {
    334                                                         fprintf(stderr, "Received address error %d\n", rc);
    335                                                 } else {
    336                                                         data[length] = '\0';
    337                                                         printf("Socket %d received %zu bytes from %s:%d\n%s\n",
    338                                                             socket_id, length, address_string, port, data);
    339                                                 }
    340                                         }
    341                                 }
    342 
    343                                 // answer the request either with the static reply or the original data
    344                                 rc = sendto(socket_id, reply ? reply : data, reply ? reply_length : length, 0, address, addrlen);
    345                                 if (rc != EOK)
    346                                         socket_print_error(stderr, rc, "Socket send: ", "\n");
    347                         }
    348 
    349                         // close the accepted stream socket
    350                         if (type == SOCK_STREAM) {
    351                                 rc = closesocket(socket_id);
    352                                 if (rc != EOK)
    353                                         socket_print_error(stderr, rc, "Close socket: ", "\n");
    354                         }
    355 
    356                 }
    357 
    358                 // decrease the count if positive
     413                rc = netecho_socket_process_message(listening_id);
     414                if (rc != EOK)
     415                        break;
     416
     417                /* Decrease count if positive */
    359418                if (count > 0) {
    360419                        count--;
    361420                        if (verbose)
    362                                 printf("Waiting for next %d packet(s)\n", count);
     421                                printf("Waiting for next %d message(s)\n", count);
    363422                }
    364423        }
    … …  
    367426                printf("Closing the socket\n");
    368427
    369         // close the listenning socket
     428        /* Close listenning socket */
    370429        rc = closesocket(listening_id);
    371430        if (rc != EOK) {

  • uspace/app/netecho/print_error.c

    rd70d80ed rea28272  
    164164        case EDESTADDRREQ:
    165165                fprintf(output, "Destination address required (%d) error", error_code);
    166         case TRY_AGAIN:
     166        case EAGAIN:
    167167                fprintf(output, "Try again (%d) error", error_code);
    168168        default:

  • uspace/app/tester/Makefile

    rd70d80ed rea28272  
    4747        vfs/vfs1.c \
    4848        ipc/ping_pong.c \
    49         ipc/register.c \
    50         ipc/connect.c \
    5149        loop/loop1.c \
    5250        mm/malloc1.c \
     51        hw/misc/virtchar1.c \
    5352        hw/serial/serial1.c
    5453

  • uspace/app/tester/hw/serial/serial1.c

    rd70d80ed rea28272  
    9393        }
    9494       
    95         ipcarg_t old_baud;
    96         ipcarg_t old_par;
    97         ipcarg_t old_stop;
    98         ipcarg_t old_word_size;
     95        sysarg_t old_baud;
     96        sysarg_t old_par;
     97        sysarg_t old_stop;
     98        sysarg_t old_word_size;
    9999       
    100100        res = ipc_call_sync_0_4(phone, SERIAL_GET_COM_PROPS, &old_baud,

  • uspace/app/tester/tester.c

    rd70d80ed rea28272  
    6060#include "vfs/vfs1.def"
    6161#include "ipc/ping_pong.def"
    62 #include "ipc/register.def"
    63 #include "ipc/connect.def"
    6462#include "loop/loop1.def"
    6563#include "mm/malloc1.def"
    6664#include "hw/serial/serial1.def"
     65#include "hw/misc/virtchar1.def"
    6766        {NULL, NULL, NULL, false}
    6867};

  • uspace/app/tester/tester.h

    rd70d80ed rea28272  
    7777extern const char *test_vfs1(void);
    7878extern const char *test_ping_pong(void);
    79 extern const char *test_register(void);
    80 extern const char *test_connect(void);
    8179extern const char *test_loop1(void);
    8280extern const char *test_malloc1(void);
    8381extern const char *test_serial1(void);
     82extern const char *test_virtchar1(void);
    8483
    8584extern test_t tests[];

  • uspace/app/tester/vfs/vfs1.c

    rd70d80ed rea28272  
    4040#include "../tester.h"
    4141
    42 #define FS_TYPE      "tmpfs"
    43 #define MOUNT_POINT  "/tmp"
    44 #define OPTIONS      ""
    45 #define FLAGS        0
    46 
    47 #define TEST_DIRECTORY  MOUNT_POINT "/testdir"
     42#define TEST_DIRECTORY  "/tmp/testdir"
    4843#define TEST_FILE       TEST_DIRECTORY "/testfile"
    4944#define TEST_FILE2      TEST_DIRECTORY "/nextfile"
    … …  
    7570const char *test_vfs1(void)
    7671{
    77         if (mkdir(MOUNT_POINT, 0) != 0)
     72        int rc;
     73        if ((rc = mkdir(TEST_DIRECTORY, 0)) != 0) {
     74                TPRINTF("rc=%d\n", rc);
    7875                return "mkdir() failed";
    79         TPRINTF("Created directory %s\n", MOUNT_POINT);
    80        
    81         int rc = mount(FS_TYPE, MOUNT_POINT, "", OPTIONS, FLAGS);
    82         switch (rc) {
    83         case EOK:
    84                 TPRINTF("Mounted %s on %s\n", FS_TYPE, MOUNT_POINT);
    85                 break;
    86         case EBUSY:
    87                 TPRINTF("(INFO) Filesystem already mounted on %s\n", MOUNT_POINT);
    88                 break;
    89         default:
    90                 TPRINTF("(ERR) IPC returned errno %d (is tmpfs loaded?)\n", rc);
    91                 return "mount() failed";
    9276        }
    93        
    94         if (mkdir(TEST_DIRECTORY, 0) != 0)
    95                 return "mkdir() failed";
    9677        TPRINTF("Created directory %s\n", TEST_DIRECTORY);
    9778       

  • uspace/app/tetris/input.c

    rd70d80ed rea28272  
    9797        struct timeval starttv, endtv, *s;
    9898        static ipc_call_t charcall;
    99         ipcarg_t rc;
     99        sysarg_t rc;
    100100       
    101101        /*

  • uspace/app/tetris/screen.c

    rd70d80ed rea28272  
    120120}
    121121
    122 void moveto(ipcarg_t r, ipcarg_t c)
     122void moveto(sysarg_t r, sysarg_t c)
    123123{
    124124        fflush(stdout);
    … …  
    135135static bool get_display_color_sup(void)
    136136{
    137         ipcarg_t ccap;
     137        sysarg_t ccap;
    138138        int rc = console_get_color_cap(fphone(stdout), &ccap);
    139139       

  • uspace/app/tetris/screen.h

    rd70d80ed rea28272  
    5353
    5454typedef struct {
    55         ipcarg_t ws_row;
    56         ipcarg_t ws_col;
     55        sysarg_t ws_row;
     56        sysarg_t ws_col;
    5757} winsize_t;
    5858
    5959extern winsize_t winsize;
    6060
    61 extern void moveto(ipcarg_t r, ipcarg_t c);
     61extern void moveto(sysarg_t r, sysarg_t c);
    6262extern void clear_screen(void);
    6363

  • uspace/app/top/input.c

    rd70d80ed rea28272  
    9999        struct timeval starttv, endtv, *s;
    100100        static ipc_call_t charcall;
    101         ipcarg_t rc;
     101        sysarg_t rc;
    102102       
    103103        /*

  • uspace/app/top/screen.c

    rd70d80ed rea28272  
    4747#include "top.h"
    4848
    49 static ipcarg_t warn_col = 0;
    50 static ipcarg_t warn_row = 0;
     49static sysarg_t warn_col = 0;
     50static sysarg_t warn_row = 0;
    5151
    5252static void screen_style_normal(void)
    … …  
    6262}
    6363
    64 static void screen_moveto(ipcarg_t col, ipcarg_t row)
     64static void screen_moveto(sysarg_t col, sysarg_t row)
    6565{
    6666        fflush(stdout);
    … …  
    6868}
    6969
    70 static void screen_get_pos(ipcarg_t *col, ipcarg_t *row)
     70static void screen_get_pos(sysarg_t *col, sysarg_t *row)
    7171{
    7272        fflush(stdout);
    … …  
    7474}
    7575
    76 static void screen_get_size(ipcarg_t *col, ipcarg_t *row)
     76static void screen_get_size(sysarg_t *col, sysarg_t *row)
    7777{
    7878        fflush(stdout);
    … …  
    9494static void screen_newline(void)
    9595{
    96         ipcarg_t cols;
    97         ipcarg_t rows;
     96        sysarg_t cols;
     97        sysarg_t rows;
    9898        screen_get_size(&cols, &rows);
    9999       
    100         ipcarg_t c;
    101         ipcarg_t r;
     100        sysarg_t c;
     101        sysarg_t r;
    102102        screen_get_pos(&c, &r);
    103103       
    104         ipcarg_t i;
     104        sysarg_t i;
    105105        for (i = c + 1; i < cols; i++)
    106106                puts(" ");
    … …  
    142142static void print_string(const char *str)
    143143{
    144         ipcarg_t cols;
    145         ipcarg_t rows;
     144        sysarg_t cols;
     145        sysarg_t rows;
    146146        screen_get_size(&cols, &rows);
    147147       
    148         ipcarg_t c;
    149         ipcarg_t r;
     148        sysarg_t c;
     149        sysarg_t r;
    150150        screen_get_pos(&c, &r);
    151151       
    … …  
    282282static inline void print_tasks(data_t *data)
    283283{
    284         ipcarg_t cols;
    285         ipcarg_t rows;
     284        sysarg_t cols;
     285        sysarg_t rows;
    286286        screen_get_size(&cols, &rows);
    287287       
    288         ipcarg_t col;
    289         ipcarg_t row;
     288        sysarg_t col;
     289        sysarg_t row;
    290290        screen_get_pos(&col, &row);
    291291       
    … …  
    329329static inline void print_ipc(data_t *data)
    330330{
    331         ipcarg_t cols;
    332         ipcarg_t rows;
     331        sysarg_t cols;
     332        sysarg_t rows;
    333333        screen_get_size(&cols, &rows);
    334334       
    335         ipcarg_t col;
    336         ipcarg_t row;
     335        sysarg_t col;
     336        sysarg_t row;
    337337        screen_get_pos(&col, &row);
    338338       
    … …  
    396396static inline void print_excs(data_t *data)
    397397{
    398         ipcarg_t cols;
    399         ipcarg_t rows;
     398        sysarg_t cols;
     399        sysarg_t rows;
    400400        screen_get_size(&cols, &rows);
    401401       
    402         ipcarg_t col;
    403         ipcarg_t row;
     402        sysarg_t col;
     403        sysarg_t row;
    404404        screen_get_pos(&col, &row);
    405405       
    … …  
    439439static void print_help(void)
    440440{
    441         ipcarg_t cols;
    442         ipcarg_t rows;
     441        sysarg_t cols;
     442        sysarg_t rows;
    443443        screen_get_size(&cols, &rows);
    444444       
    445         ipcarg_t col;
    446         ipcarg_t row;
     445        sysarg_t col;
     446        sysarg_t row;
    447447        screen_get_pos(&col, &row);
    448448       

  • uspace/app/trace/ipcp.c

    rd70d80ed rea28272  
    4646
    4747typedef struct {
    48         ipcarg_t phone_hash;
     48        sysarg_t phone_hash;
    4949        ipc_call_t question;
    5050        oper_t *oper;
    … …  
    124124}
    125125
    126 static void ipc_m_print(proto_t *proto, ipcarg_t method)
     126static void ipc_m_print(proto_t *proto, sysarg_t method)
    127127{
    128128        oper_t *oper;
    … …  
    192192        unsigned long key[1];
    193193        oper_t *oper;
    194         ipcarg_t *args;
     194        sysarg_t *args;
    195195        int i;
    196196
    … …  
    204204                    (void *) hash, phone,
    205205                    (proto ? proto->name : "n/a"));
    206                 ipc_m_print(proto, IPC_GET_METHOD(*call));
     206                ipc_m_print(proto, IPC_GET_IMETHOD(*call));
    207207                printf(" args: (%" PRIun ", %" PRIun ", %" PRIun ", "
    208208                    "%" PRIun ", %" PRIun ")\n",
    … …  
    214214
    215215                if (proto != NULL) {
    216                         oper = proto_get_oper(proto, IPC_GET_METHOD(*call));
     216                        oper = proto_get_oper(proto, IPC_GET_IMETHOD(*call));
    217217                } else {
    218218                        oper = NULL;
    … …  
    262262    ipc_call_t *answer)
    263263{
    264         ipcarg_t phone;
    265         ipcarg_t method;
    266         ipcarg_t service;
    267         ipcarg_t retval;
     264        sysarg_t phone;
     265        sysarg_t method;
     266        sysarg_t service;
     267        sysarg_t retval;
    268268        proto_t *proto;
    269269        int cphone;
    270270
    271         ipcarg_t *resp;
     271        sysarg_t *resp;
    272272        oper_t *oper;
    273273        int i;
    … …  
    276276
    277277        phone = pcall->phone_hash;
    278         method = IPC_GET_METHOD(pcall->question);
     278        method = IPC_GET_IMETHOD(pcall->question);
    279279        retval = IPC_GET_RETVAL(*answer);
    280280

  • uspace/app/trace/proto.c

    rd70d80ed rea28272  
    5353
    5454typedef struct {
    55         ipcarg_t method;
     55        sysarg_t method;
    5656        oper_t *oper;
    5757        link_t link;

  • uspace/app/trace/trace.c

    rd70d80ed rea28272  
    287287{
    288288        ipc_call_t call;
    289         ipcarg_t phoneid;
     289        sysarg_t phoneid;
    290290       
    291291        if (sc_rc == (sysarg_t) IPC_CALLRET_FATAL ||
    … …  
    295295        phoneid = sc_args[0];
    296296
    297         IPC_SET_METHOD(call, sc_args[1]);
     297        IPC_SET_IMETHOD(call, sc_args[1]);
    298298        IPC_SET_ARG1(call, sc_args[2]);
    299299        IPC_SET_ARG2(call, sc_args[3]);
    … …  
    331331        phoneidx = sc_args[0];
    332332
    333         IPC_SET_METHOD(question, sc_args[1]);
     333        IPC_SET_IMETHOD(question, sc_args[1]);
    334334        IPC_SET_ARG1(question, sc_args[2]);
    335335        IPC_SET_ARG2(question, sc_args[3]);
Note: See TracChangeset for help on using the changeset viewer.