WebSVN – HelenOS – Path Comparison – / – /branches/dynload/uspace/ Rev 4341 and /branches/dynload/uspace Rev 4340

Ignore whitespace Rev 4341 → Rev 4340

/branches/dynload/uspace/app/bdsh/Makefile
58,6 → 58,7
cmds/ \
cmds/modules/ \
cmds/modules/help/ \
cmds/modules/quit/ \
cmds/modules/mkdir/ \
cmds/modules/rm/ \
cmds/modules/cat/ \
67,11 → 68,11
cmds/modules/sleep/ \
cmds/modules/cp/ \
cmds/builtins/ \
cmds/builtins/exit/\
cmds/builtins/cd/

SOURCES = \
cmds/modules/help/help.c \
cmds/modules/quit/quit.c \
cmds/modules/mkdir/mkdir.c \
cmds/modules/rm/rm.c \
cmds/modules/cat/cat.c \
80,7 → 81,6
cmds/modules/pwd/pwd.c \
cmds/modules/sleep/sleep.c \
cmds/modules/cp/cp.c \
cmds/builtins/exit/exit.c \
cmds/builtins/cd/cd.c \
cmds/mod_cmds.c \
cmds/builtin_cmds.c \

 /branches/dynload/uspace/app/bdsh/input.c
 ,8 → 42,21
 #include "errors.h"
 #include "exec.h"
+extern volatile unsigned int cli_interactive;
+/* Not exposed in input.h */
+static void cli_restricted(char *);
 static void read_line(char *, int);
+/* More than a macro than anything */
+static void cli_restricted(char *cmd)
+{
+    printf("%s is not available in %s mode\n", cmd,
+        cli_interactive ? "interactive" : "non-interactive");
+    return;
+}
 /* Tokenizes input from console, sees if the first word is a built-in, if so
  * invokes the built-in entry point (a[0]) passing all arguments in a[] to
  * the handler */
 ,11 → 70,14
     if (NULL == usr->line)
         return CL_EFAIL;
-    tmp = strdup(usr->line);
+    tmp = cli_strdup(usr->line);
-    cmd[n] = strtok(tmp, " ");
+    /* Break up what the user typed, space delimited */
+    /* TODO: Protect things in quotes / ticks, expand wildcards */
+    cmd[n] = cli_strtok(tmp, " ");
     while (cmd[n] && n < WORD_MAX) {
-        cmd[++n] = strtok(NULL, " ");
+        cmd[++n] = cli_strtok(NULL, " ");
     }
     /* We have rubbish */
 ,19 → 86,39
         goto finit;
     }
-    /* Its a builtin command ? */
+    /* Its a builtin command */
     if ((i = (is_builtin(cmd[0]))) > -1) {
+        /* Its not available in this mode, see what try_exec() thinks */
+        if (builtin_is_restricted(i)) {
+                rc = try_exec(cmd[0], cmd);
+                if (rc)
+                    /* No external matching it could be found, tell the
+                     * user that the command does exist, but is not
+                     * available in this mode. */
+                    cli_restricted(cmd[0]);
+                goto finit;
+        }
+        /* Its a builtin, its available, run it */
         rc = run_builtin(i, cmd, usr);
         goto finit;
-    /* Its a module ? */
+    /* We repeat the same dance for modules */
     } else if ((i = (is_module(cmd[0]))) > -1) {
+        if (module_is_restricted(i)) {
+            rc = try_exec(cmd[0], cmd);
+            if (rc)
+                cli_restricted(cmd[0]);
+            goto finit;
+        }
         rc = run_module(i, cmd);
         goto finit;
+    } else {
+        /* Its not a module or builtin, restricted or otherwise.
+         * See what try_exec() thinks of it and just pass its return
+         * value back to the caller */
+        rc = try_exec(cmd[0], cmd);
+        goto finit;
     }
-    /* See what try_exec thinks of it */
-    rc = try_exec(cmd[0], cmd);
 finit:
     if (NULL != usr->line) {
         free(usr->line);
 ,7 → 174,7
     /* Make sure we don't have rubbish or a C/R happy user */
     if (len == 0 || line[0] == '\n')
         return;
-    usr->line = strdup(line);
+    usr->line = cli_strdup(line);
     return;
 }

 /branches/dynload/uspace/app/bdsh/cmds/modules/cp/cp.c
 ,6 → 34,7
 #include <getopt.h>
 #include <string.h>
 #include <fcntl.h>
+#include <assert.h>
 #include "config.h"
 #include "util.h"
 #include "errors.h"
 ,8 → 70,7
     return (int) t1;
 }
-static int64_t copy_file(const char *src, const char *dest,
-    size_t blen, int vb)
+static int64_t copy_file(const char *src, const char *dest, size_t blen, int vb)
 {
     int fd1, fd2, bytes = 0;
     off_t total = 0;
 ,19 → 124,12
                 goto err;
             res -= bytes;
         } while (res > 0);
-        /* TODO: re-insert assert() once this is stand alone,
-         * removed as abort() exits the entire shell
-         */
-        if (res != 0) {
-            printf("\n%d more bytes than actually exist were copied\n", res);
-            goto err;
-        }
+        assert(res == 0);
     }
     if (bytes < 0) {
 err:
-        printf("\nError copying %s, (%d)\n", src, bytes);
+        printf("Error copying %s, (%d)\n", src, bytes);
         copied = bytes;
     }

/branches/dynload/uspace/app/bdsh/cmds/modules/cp/cp_def.h
3,5 → 3,6
"Copy files and directories",
&cmd_cp,
&help_cmd_cp,
0
},

/branches/dynload/uspace/app/bdsh/cmds/modules/cat/cat_def.h
3,5 → 3,6
"Show the contents of a file",
&cmd_cat,
&help_cmd_cat,
0
},

 /branches/dynload/uspace/app/bdsh/cmds/modules/quit/quit.c
 ,0 → 1,55
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of the original program's authors nor the names of its
+ * contributors may be used to endorse or promote products derived from this
+ * software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "entry.h"
+#include "quit.h"
+#include "cmds.h"
+static char *cmdname = "quit";
+extern volatile unsigned int cli_quit;
+extern const char *progname;
+void help_cmd_quit(unsigned int level)
+{
+    printf("Type `%s' to exit %s\n", cmdname, progname);
+    return;
+}
+/* Quits the program and returns the status of whatever command
+ * came before invoking 'quit' */
+int cmd_quit(char *argv[])
+{
+    /* Inform that we're outta here */
+    cli_quit = 1;
+    return CMD_SUCCESS;
+}

 /branches/dynload/uspace/app/bdsh/cmds/modules/quit/entry.h
 ,0 → 1,10
+#ifndef QUIT_ENTRY_H_
+#define QUIT_ENTRY_H_
+/* Entry points for the quit command */
+extern void help_cmd_quit(unsigned int);
+extern int cmd_quit(char *[]);
+#endif

 /branches/dynload/uspace/app/bdsh/cmds/modules/quit/quit_def.h
 ,0 → 1,14
+{
+    "quit",
+    "Exit the console",
+    &cmd_quit,
+    &help_cmd_quit,
+    -1
+},
+{
+    "exit",
+    NULL,
+    &cmd_quit,
+    &help_cmd_quit,
+    -1
+},

/branches/dynload/uspace/app/bdsh/cmds/modules/quit/quit.h
0,0 → 1,6
#ifndef QUIT_H
#define QUIT_H

/* Prototypes for the quit command (excluding entry points) */

#endif

 /branches/dynload/uspace/app/bdsh/cmds/modules/touch/touch.c
 ,7 → 37,6
 #include <fcntl.h>
 #include <dirent.h>
 #include <sys/types.h>
-#include <string.h>
 #include "config.h"
 #include "errors.h"
 ,7 → 79,7
     }
     for (i = 1; i < argc; i ++) {
-        buff = strdup(argv[i]);
+        buff = cli_strdup(argv[i]);
         dirp = opendir(buff);
         if (dirp) {
             cli_error(CL_ENOTSUP, "%s is a directory", buff);

/branches/dynload/uspace/app/bdsh/cmds/modules/touch/touch_def.h
3,5 → 3,6
"Create files or update access times",
&cmd_touch,
&help_cmd_touch,
0
},

 /branches/dynload/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
 ,7 → 93,7
     /* Its a good idea to allocate path, plus we (may) need a copy of
      * path to tokenize if parents are specified */
-    if (NULL == (tmp = strdup(path))) {
+    if (NULL == (tmp = cli_strdup(path))) {
         cli_error(CL_ENOMEM, "%s: path too big?", cmdname);
         return 1;
     }
 ,9 → 128,9
         absolute = 1;
     /* TODO: Canonify the path prior to tokenizing it, see below */
-    dirs[i] = strtok(tmp, "/");
+    dirs[i] = cli_strtok(tmp, "/");
     while (dirs[i] && i < 255)
-        dirs[++i] = strtok(NULL, "/");
+        dirs[++i] = cli_strtok(NULL, "/");
     if (NULL == dirs[0])
         return 1;

 /branches/dynload/uspace/app/bdsh/cmds/modules/mkdir/mkdir_def.h
 ,6 → 3,14
     "Create new directories",
     &cmd_mkdir,
     &help_cmd_mkdir,
 },
+{
+    "md",
+    NULL,
+    &cmd_mkdir,
+    &help_cmd_mkdir,
+},

/branches/dynload/uspace/app/bdsh/cmds/modules/help/help.c
133,11 → 133,13

/* First, show a list of built in commands that are available in this mode */
for (cmd = builtins; cmd->name != NULL; cmd++, i++) {
if (!builtin_is_restricted(i)) {
if (is_builtin_alias(cmd->name))
printf(" %-16s\tAlias for `%s'\n", cmd->name,
alias_for_builtin(cmd->name));
else
printf(" %-16s\t%s\n", cmd->name, cmd->desc);
}
}

i = 0;
144,11 → 146,13

/* Now, show a list of module commands that are available in this mode */
for (mod = modules; mod->name != NULL; mod++, i++) {
if (!module_is_restricted(i)) {
if (is_module_alias(mod->name))
printf(" %-16s\tAlias for `%s'\n", mod->name,
alias_for_module(mod->name));
else
printf(" %-16s\t%s\n", mod->name, mod->desc);
}
}

printf("\n Try %s %s for more information on how `%s' works.\n\n",

/branches/dynload/uspace/app/bdsh/cmds/modules/help/help_def.h
3,4 → 3,5
"Show help for commands",
&cmd_help,
&help_cmd_help,
0
},

/branches/dynload/uspace/app/bdsh/cmds/modules/sleep/sleep_def.h
3,5 → 3,6
"Pause for given time interval (in seconds)",
&cmd_sleep,
&help_cmd_sleep,
0
},

/branches/dynload/uspace/app/bdsh/cmds/modules/pwd/pwd_def.h
3,4 → 3,5
"Prints the current working directory",
&cmd_pwd,
&help_cmd_pwd,
-1
},

 /branches/dynload/uspace/app/bdsh/cmds/modules/ls/ls.c
 ,24 → 50,6
 static char *cmdname = "ls";
-static inline off_t flen(const char *f)
-{
-    int fd;
-    off_t size;
-    fd = open(f, O_RDONLY);
-    if (fd == -1)
-        return 0;
-    size = lseek(fd, 0, SEEK_END);
-    close(fd);
-    if (size < 0)
-        size = 0;
-    return size;
-}
 static unsigned int ls_scope(const char *path)
 {
     int fd;
 ,7 → 120,7
 static void ls_print_dir(const char *d)
 {
-    printf("%-40s\t<dir>\n", d);
+    printf("%-40s\t<DIR>\n", d);
     return;
 }
 ,7 → 127,7
 static void ls_print_file(const char *f)
 {
-    printf("%-40s\t%llu\n", f, (long long) flen(f));
+    printf("%-40s\n", f);
     return;
 }

 /branches/dynload/uspace/app/bdsh/cmds/modules/ls/ls_def.h
 ,4 → 3,14
     "List files and directories",
     &cmd_ls,
     &help_cmd_ls,
 },
+{
+    "dir",
+    NULL,
+    &cmd_ls,
+    &help_cmd_ls,
+},

/branches/dynload/uspace/app/bdsh/cmds/modules/modules.h
18,6 → 18,7
/* Prototypes for each module's entry (help/exec) points */

#include "help/entry.h"
#include "quit/entry.h"
#include "mkdir/entry.h"
#include "rm/entry.h"
#include "cat/entry.h"
33,6 → 34,7

module_t modules[] = {
#include "help/help_def.h"
#include "quit/quit_def.h"
#include "mkdir/mkdir_def.h"
#include "rm/rm_def.h"
#include "cat/cat_def.h"

 /branches/dynload/uspace/app/bdsh/cmds/modules/rm/rm.c
 ,6 → 33,7
 #include <unistd.h>
 #include <fcntl.h>
 #include <dirent.h>
+#include <assert.h>
 #include <getopt.h>
 #include "config.h"
 ,11 → 219,7
     while (NULL != argv[i]) {
         len = strlen(argv[i]) + 2;
         buff = (char *) realloc(buff, len);
-        if (buff == NULL) {
-            printf("rm: out of memory\n");
-            ret = 1;
-            break;
-        }
+        assert(buff != NULL);
         memset(buff, 0, sizeof(buff));
         snprintf(buff, len, argv[i]);

 /branches/dynload/uspace/app/bdsh/cmds/modules/rm/rm_def.h
 ,5 → 3,14
     "Remove files and directories",
     &cmd_rm,
     &help_cmd_rm,
 },
+{
+    "del",
+    NULL,
+    &cmd_rm,
+    &help_cmd_rm,
+},

 /branches/dynload/uspace/app/bdsh/cmds/modules/module_aliases.h
 ,6 → 12,10
  * the entry point being reached. */
 char *mod_aliases[] = {
+    "exit", "quit",
+    "md", "mkdir",
+    "del", "rm",
+    "dir", "ls",
     NULL, NULL
 };

 /branches/dynload/uspace/app/bdsh/cmds/mknewcmd
 ,6 → 46,8
   -e, --entry        Entry function of the command (def: cmd_${def})
   -h, --help-entry   Entry function for command help (def: help_cmd_${def})
   -a, --alias        Alias (nickname) for this command (def: none)
+  -r, --restrict     Restriction level (interactive, non-interactive, both)
+                     (def: module is both, builtin is interactive only)
   -t, --type         Type of command (module or builtin) (def: module)
   -H, --help         This help summary
   -V, --version      Print $PROGNAME version and exit normally
 ,7 → 67,8
     $PROGNAME -n foo -d "Foo power" -a bar -r both -t module modules/foo
   The example would generate a modular command named 'foo', which is also
-  reached by typing 'bar'.
+  reached by typing 'bar' and available in either interactive or noninteractive
+  mode.
   Skeletal files do *not* depend on the autoconf generated "config.h" unless you
   include it. This may or may not be desirable depending on your use.
 ,6 → 97,7
     "${CMDDESC}",
     &${CMDENTRY},
     &${HELPENTRY},
+    ${CMDRESTRICT}
 },
 EOF
 ,6 → 107,7
     NULL,
     &${CMDENTRY},
     &${HELPENTRY},
+    ${CMDRESTRICT}
 },
 EOF
 ,7 → 167,7
 #include "${CMDNAME}.h"
 #include "cmds.h"
-static const char *cmdname = "${CMDNAME}";
+static char *cmdname = "${CMDNAME}";
 /* Dispays help for ${CMDNAME} in various levels */
 void ${HELPENTRY}(unsigned int level)
 ,8 → 234,8
 # We need at least one
 [ $# = 0 ] && usage && exit 1;
-TEMP=$(getopt -o n:d:e:h:a:t:HV \
---long name:,desc:,entry:,help-entry:,alias:,type:,help,version \
+TEMP=$(getopt -o n:d:e:h:a:r:t:HV \
+--long name:,desc:,entry:,help-entry:,alias:,restrict:,type:,help,version \
 -- "$@") || {
     echo "Try $PROGNAME --help for help"
 }
 ,6 → 269,11
         shift 2
         continue
     ;;
+    -r | --restrict)
+        CMDRESTRICT="$2"
+        shift 2
+        continue
+    ;;
     -t | --type)
         CMDTYPE="$2"
         shift 2
 ,7 → 305,30
 [ -n "$CMDTYPE" ] || CMDTYPE="module"
 [ -n "$OUTDIR" ] || OUTDIR="${CMDTYPE}s/${CMDNAME}"
+# Builtins typically only need to be available in interactive mode,
+# set the default accordingly.
+[ -n "$CMDRESTRICT" ] || {
+    [ "$CMDTYPE" = "module" ] && CMDRESTRICT="both"
+    [ "$CMDTYPE" = "builtin" ] && CMDRESTRICT="interactive"
+}
+# Set the restriction level as the structure expects to see it
+case "$CMDRESTRICT" in
+| both)
+        CMDRESTRICT="0"
+    ;;
+| non-interactive)
+        CMDRESTRICT="1"
+    ;;
+    -1 | interactive)
+        CMDRESTRICT="-1"
+    ;;
+    *)
+        usage
+        exit 1
+    ;;
+esac
 # Do a little sanity
 [ -d $OUTDIR ] && {
     echo "$OUTDIR already exists, remove it to proceed."

/branches/dynload/uspace/app/bdsh/cmds/builtins/exit/exit.c
File deleted

/branches/dynload/uspace/app/bdsh/cmds/builtins/exit/exit_def.h
File deleted

/branches/dynload/uspace/app/bdsh/cmds/builtins/exit/exit.h
File deleted

/branches/dynload/uspace/app/bdsh/cmds/builtins/exit/entry.h
File deleted

 /branches/dynload/uspace/app/bdsh/cmds/builtins/cd/cd_def.h
 ,4 → 3,12
     "Change the current working directory",
     &cmd_cd,
     &help_cmd_cd,
+    -1
 },
+{
+    "chdir",
+    NULL,
+    &cmd_cd,
+    &help_cmd_cd,
+    -1
+},

/branches/dynload/uspace/app/bdsh/cmds/builtins/builtins.h
4,11 → 4,9
#include "config.h"

#include "cd/entry.h"
#include "exit/entry.h"

builtin_t builtins[] = {
#include "cd/cd_def.h"
#include "exit/exit_def.h"
{NULL, NULL, NULL, NULL}
};

/branches/dynload/uspace/app/bdsh/cmds/builtins/builtin_aliases.h
4,6 → 4,7
/* See modules/module_aliases.h for an explanation of this file */

char *builtin_aliases[] = {
"chdir", "cd",
NULL, NULL
};

/branches/dynload/uspace/app/bdsh/cmds/cmds.h
36,6 → 36,7
char desc; / Description of the command */
mod_entry_t entry; /* Command (exec) entry function */
mod_help_t help; /* Command (help) entry function */
int restricted; /* Restricts to interactive/non-interactive only */
} module_t;

/* Builtin structure, same as modules except different types of entry points */

 /branches/dynload/uspace/app/bdsh/cmds/mod_cmds.c
 ,6 → 53,26
 extern volatile unsigned int cli_interactive;
+int module_is_restricted(int pos)
+{
+    /* Restriction Levels:
+     * -1 -> Available only in interactive mode
+     *  0 -> Available in any mode
+     *  1 -> Available only in non-interactive mode */
+    module_t *mod = modules;
+    mod += pos;
+    /* We're interactive, and the module is OK to run */
+    if (cli_interactive && mod->restricted <= 0)
+        return 0;
+    /* We're not interactive, and the module is OK to run */
+    if (!cli_interactive && mod->restricted >= 0)
+        return 0;
+    /* Anything else is just a big fat no :) */
+    return 1;
+}
 /* Checks if an entry function matching command exists in modules[], if so
  * its position in the array is returned */
 int is_module(const char *command)

 /branches/dynload/uspace/app/bdsh/cmds/builtin_cmds.c
 ,6 → 40,19
 extern volatile unsigned int cli_interactive;
+int builtin_is_restricted(int pos)
+{
+    builtin_t *cmd = builtins;
+    cmd += pos;
+    if (cli_interactive && cmd->restricted <= 0)
+        return 0;
+    if (!cli_interactive && cmd->restricted >= 0)
+        return 0;
+    return 1;
+}
 int is_builtin(const char *command)
 {
     builtin_t *cmd;

 /branches/dynload/uspace/app/bdsh/util.c
 ,4 → 1,7
-/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com> - All rights reserved
+/* Copyright (c) 2008, Tim Post <tinkertim@gmail.com>
+ * Copyright (C) 1998 by Wes Peters <wes@softweyr.com>
+ * Copyright (c) 1988, 1993 The Regents of the University of California.
+ * All rights reserved by all copyright holders.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
 ,6 → 30,18
  * POSSIBILITY OF SUCH DAMAGE.
  */
+/* NOTES:
+ * 1 - Various functions were adapted from FreeBSD (copyright holders noted above)
+ *     these functions are identified with comments.
+ *
+ * 2 - Some of these have since appeared in libc. They remain here for various
+ *     reasons, such as the eventual integration of garbage collection for things
+ *     that allocate memory and don't automatically free it.
+ *
+ * 3 - Things that expect a pointer to an allocated string do _no_ sanity checking
+ *     if developing on a simulator with no debugger, take care :)
+ */
 #include <stdio.h>
 #include <string.h>
 #include <stdarg.h>
 ,6 → 54,71
 extern volatile int cli_errno;
+/* some platforms do not have strdup, implement it here.
+ * Returns a pointer to an allocated string or NULL on failure */
+char * cli_strdup(const char *s1)
+{
+    size_t len = strlen(s1) + 1;
+    void *ret = malloc(len);
+    if (ret == NULL) {
+        cli_errno = CL_ENOMEM;
+        return (char *) NULL;
+    }
+    cli_errno = CL_EOK;
+    return (char *) memcpy(ret, s1, len);
+}
+/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
+char * cli_strtok_r(char *s, const char *delim, char **last)
+{
+    char *spanp, *tok;
+    int c, sc;
+    if (s == NULL && (s = *last) == NULL) {
+        cli_errno = CL_EFAIL;
+        return (NULL);
+    }
+cont:
+    c = *s++;
+    for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
+        if (c == sc)
+            goto cont;
+    }
+    if (c == 0) {       /* no non-delimiter characters */
+        *last = NULL;
+        return (NULL);
+    }
+    tok = s - 1;
+    for (;;) {
+        c = *s++;
+        spanp = (char *)delim;
+        do {
+            if ((sc = *spanp++) == c) {
+                if (c == 0)
+                    s = NULL;
+                else
+                    s[-1] = '\0';
+                *last = s;
+                return (tok);
+            }
+        } while (sc != 0);
+    }
+}
+/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
+char * cli_strtok(char *s, const char *delim)
+{
+    static char *last;
+    return (cli_strtok_r(s, delim, &last));
+}
 /* Count and return the # of elements in an array */
 unsigned int cli_count_args(char **args)
 {

 /branches/dynload/uspace/app/bdsh/util.h
 ,6 → 3,11
 #include "scli.h"
+/* Internal string handlers */
+extern char * cli_strdup(const char *);
+extern char * cli_strtok_r(char *, const char *, char **);
+extern char * cli_strtok(char *, const char *);
 /* Utility functions */
 extern unsigned int cli_count_args(char **);
 extern unsigned int cli_set_prompt(cliuser_t *usr);

 /branches/dynload/uspace/app/bdsh/exec.c
 ,10 → 80,10
         return (char *) cmd;
     }
-    path_tok = strdup(PATH);
+    path_tok = cli_strdup(PATH);
     /* Extract the PATH env to a path[] array */
-    path[n] = strtok(path_tok, PATH_DELIM);
+    path[n] = cli_strtok(path_tok, PATH_DELIM);
     while (NULL != path[n]) {
         if ((strlen(path[n]) + x ) > PATH_MAX) {
             cli_error(CL_ENOTSUP,
 ,7 → 91,7
                 n, n-1);
             break;
         }
-        path[++n] = strtok(NULL, PATH_DELIM);
+        path[++n] = cli_strtok(NULL, PATH_DELIM);
     }
     /* We now have n places to look for the command */
 ,7 → 114,7
     task_id_t tid;
     char *tmp;
-    tmp = strdup(find_command(cmd));
+    tmp = cli_strdup(find_command(cmd));
     free(found);
     tid = task_spawn((const char *)tmp, argv);

/branches/dynload/uspace/app/bdsh/scli.c
45,6 → 45,7
/* Globals that are modified during start-up that modules/builtins
* should be aware of. */
volatile unsigned int cli_quit = 0;
volatile unsigned int cli_interactive = 1;
volatile unsigned int cli_verbocity = 1;

/* The official name of this program

 /branches/dynload/uspace/app/bdsh/AUTHORS
 ,6 → 8,9
 * Based on the HelenOS testing sub-system written by Martin Decky
+* cli_strtok() and cli_strtok_r() (util.c) were adapted from the FreeBSD
+  strtok() and strtok_r() functions written by Wes Peters.
 * read_line() (input.c) was written by Jiri Svoboda
 Individual author copyrights are listed in the headers of each file.

 /branches/dynload/uspace/app/trace/trace.c
 ,18 → 642,6
     proto_add_oper(p, VFS_MOUNT, o);
 /*  o = oper_new("unmount", 0, arg_def);
     proto_add_oper(p, VFS_UNMOUNT, o);*/
-    o = oper_new("open", 2, arg_def, V_INT_ERRNO, 0, resp_def);
-    proto_add_oper(p, VFS_OPEN, o);
-    o = oper_new("close", 1, arg_def, V_ERRNO, 0, resp_def);
-    proto_add_oper(p, VFS_CLOSE, o);
-    o = oper_new("seek", 3, arg_def, V_ERRNO, 0, resp_def);
-    proto_add_oper(p, VFS_SEEK, o);
-    o = oper_new("mkdir", 1, arg_def, V_ERRNO, 0, resp_def);
-    proto_add_oper(p, VFS_MKDIR, o);
-    o = oper_new("unlink", 0, arg_def, V_ERRNO, 0, resp_def);
-    proto_add_oper(p, VFS_UNLINK, o);
-    o = oper_new("rename", 0, arg_def, V_ERRNO, 0, resp_def);
-    proto_add_oper(p, VFS_RENAME, o);
     proto_register(SERVICE_VFS, p);
 ,13 → 667,13
     proto_add_oper(p, CONSOLE_FLUSH, o);
     arg_def[0] = V_INTEGER;
-    o = oper_new("set_style", 1, arg_def, V_VOID, 0, resp_def);
+    o = oper_new("set_style", 1, arg_def, V_INTEGER, 0, resp_def);
     proto_add_oper(p, CONSOLE_SET_STYLE, o);
     arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER; arg_def[2] = V_INTEGER;
-    o = oper_new("set_color", 3, arg_def, V_VOID, 0, resp_def);
+    o = oper_new("set_color", 3, arg_def, V_INTEGER, 0, resp_def);
     proto_add_oper(p, CONSOLE_SET_COLOR, o);
     arg_def[0] = V_INTEGER; arg_def[1] = V_INTEGER;
-    o = oper_new("set_rgb_color", 2, arg_def, V_VOID, 0, resp_def);
+    o = oper_new("set_rgb_color", 2, arg_def, V_INTEGER, 0, resp_def);
     proto_add_oper(p, CONSOLE_SET_RGB_COLOR, o);
     o = oper_new("cursor_visibility", 1, arg_def, V_VOID, 0, resp_def);
     proto_add_oper(p, CONSOLE_CURSOR_VISIBILITY, o);

/branches/dynload/uspace/app/trace/syscalls.c
59,7 → 59,6
[SYS_IPC_ANSWER_FAST] = { "ipc_answer_fast", 6, V_ERRNO },
[SYS_IPC_ANSWER_SLOW] = { "ipc_answer_slow", 2, V_ERRNO },
[SYS_IPC_FORWARD_FAST] = { "ipc_forward_fast", 6, V_ERRNO },
[SYS_IPC_FORWARD_SLOW] = { "ipc_forward_slow", 3, V_ERRNO },
[SYS_IPC_WAIT] = { "ipc_wait_for_call", 3, V_HASH },
[SYS_IPC_HANGUP] = { "ipc_hangup", 1, V_ERRNO },
[SYS_IPC_REGISTER_IRQ] = { "ipc_register_irq", 4, V_ERRNO },

 /branches/dynload/uspace/app/dltest/Makefile
 ,7 → 27,7
 #
 include ../../../version
--include ../../../Makefile.config
+include ../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/app/dltest2/Makefile
 ,7 → 27,7
 #
 include ../../../version
--include ../../../Makefile.config
+include ../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/app/dload/Makefile
 ,7 → 27,7
 #
 include ../../../version
--include ../../../Makefile.config
+include ../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/lib/libc/include/ipc/ipc.h
 ,7 → 47,8
 } ipc_call_t;
 typedef sysarg_t ipc_callid_t;
-typedef void (* ipc_async_callback_t)(void *, int, ipc_call_t *);
+typedef void (* ipc_async_callback_t)(void *private, int retval,
+    ipc_call_t *data);
 /*
  * User-friendly wrappers for ipc_call_sync_fast() and ipc_call_sync_slow().
 ,20 → 173,22
     ipc_call_sync_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), (arg5), (res1), (res2), (res3), (res4), (res5))
-extern int ipc_call_sync_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
-    ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *);
+extern int ipc_call_sync_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
+    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2,
+    ipcarg_t *result3, ipcarg_t *result4, ipcarg_t *result5);
-extern int ipc_call_sync_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
-    ipcarg_t, ipcarg_t, ipcarg_t *, ipcarg_t *, ipcarg_t *, ipcarg_t *,
-    ipcarg_t *);
+extern int ipc_call_sync_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
+    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
+    ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3, ipcarg_t *result4,
+    ipcarg_t *result5);
-extern ipc_callid_t ipc_wait_cycle(ipc_call_t *, uint32_t, int);
-extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *, uint32_t);
+extern ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags);
+extern ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *data, uint32_t usec);
 static inline ipc_callid_t ipc_wait_for_call(ipc_call_t *data)
 {
     return ipc_wait_for_call_timeout(data, SYNCH_NO_TIMEOUT);
 }
-extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *);
+extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *data);
 /*
  * User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow().
 ,10 → 209,10
 #define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \
     ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
-extern ipcarg_t ipc_answer_fast(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
-    ipcarg_t, ipcarg_t);
-extern ipcarg_t ipc_answer_slow(ipc_callid_t, ipcarg_t, ipcarg_t, ipcarg_t,
-    ipcarg_t, ipcarg_t, ipcarg_t);
+extern ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval,
+    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4);
+extern ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval,
+    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5);
 /*
  * User-friendly wrappers for ipc_call_async_fast() and ipc_call_async_slow().
 ,7 → 220,8
  * arguments. The macros decide between the fast and the slow version according
  * to m.
  */
-#define ipc_call_async_0(phoneid, method, private, callback, can_preempt) \
+#define ipc_call_async_0(phoneid, method, private, callback, \
+    can_preempt) \
     ipc_call_async_fast((phoneid), (method), 0, 0, 0, 0, (private), \
         (callback), (can_preempt))
 #define ipc_call_async_1(phoneid, method, arg1, private, callback, \
 ,19 → 245,21
     ipc_call_async_slow((phoneid), (method), (arg1), (arg2), (arg3), \
         (arg4), (arg5), (private), (callback), (can_preempt))
-extern void ipc_call_async_fast(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
-    ipcarg_t, void *, ipc_async_callback_t, int);
-extern void ipc_call_async_slow(int, ipcarg_t, ipcarg_t, ipcarg_t, ipcarg_t,
-    ipcarg_t, ipcarg_t, void *, ipc_async_callback_t, int);
+extern void ipc_call_async_fast(int phoneid, ipcarg_t method, ipcarg_t arg1,
+    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, void *private,
+    ipc_async_callback_t callback, int can_preempt);
+extern void ipc_call_async_slow(int phoneid, ipcarg_t method, ipcarg_t arg1,
+    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, void *private,
+    ipc_async_callback_t callback, int can_preempt);
-extern int ipc_connect_to_me(int, int, int, int, ipcarg_t *);
-extern int ipc_connect_me_to(int, int, int, int);
-extern int ipc_hangup(int);
-extern int ipc_register_irq(int, int, int, irq_code_t *);
-extern int ipc_unregister_irq(int, int);
-extern int ipc_forward_fast(ipc_callid_t, int, int, ipcarg_t, ipcarg_t, int);
-extern int ipc_forward_slow(ipc_callid_t, int, int, ipcarg_t, ipcarg_t,
-    ipcarg_t, ipcarg_t, ipcarg_t, int);
+extern int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3,
+    ipcarg_t *phone);
+extern int ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3);
+extern int ipc_hangup(int phoneid);
+extern int ipc_register_irq(int inr, int devno, int method, irq_code_t *code);
+extern int ipc_unregister_irq(int inr, int devno);
+extern int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method,
+    ipcarg_t arg1, ipcarg_t arg2, int mode);
 /*
 ,22 → 274,24
 #define ipc_share_in_start_1_1(phoneid, dst, size, arg, flags) \
     ipc_share_in_start((phoneid), (dst), (size), (arg), (flags))
-extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *);
-extern int ipc_share_in_receive(ipc_callid_t *, size_t *);
-extern int ipc_share_in_finalize(ipc_callid_t, void *, int );
-extern int ipc_share_out_start(int, void *, int);
-extern int ipc_share_out_receive(ipc_callid_t *, size_t *, int *);
-extern int ipc_share_out_finalize(ipc_callid_t, void *);
-extern int ipc_data_read_start(int, void *, size_t);
-extern int ipc_data_read_receive(ipc_callid_t *, size_t *);
-extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t);
-extern int ipc_data_write_start(int, const void *, size_t);
-extern int ipc_data_write_receive(ipc_callid_t *, size_t *);
-extern int ipc_data_write_finalize(ipc_callid_t, void *, size_t);
+extern int ipc_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
+    int *flags);
+extern int ipc_share_in_receive(ipc_callid_t *callid, size_t *size);
+extern int ipc_share_in_finalize(ipc_callid_t callid, void *src, int flags);
+extern int ipc_share_out_start(int phoneid, void *src, int flags);
+extern int ipc_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags);
+extern int ipc_share_out_finalize(ipc_callid_t callid, void *dst);
+extern int ipc_data_read_start(int phoneid, void *dst, size_t size);
+extern int ipc_data_read_receive(ipc_callid_t *callid, size_t *size);
+extern int ipc_data_read_finalize(ipc_callid_t callid, const void *src,
+    size_t size);
+extern int ipc_data_write_start(int phoneid, const void *src, size_t size);
+extern int ipc_data_write_receive(ipc_callid_t *callid, size_t *size);
+extern int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size);
 #include <task.h>
-extern int ipc_connect_kbox(task_id_t);
+extern int ipc_connect_kbox(task_id_t id);
 #endif

 /branches/dynload/uspace/lib/libc/generic/libc.c
 ,6 → 75,8
     f = fibril_setup();
     __tcb_set(f->tcb);
+    open_console();
     /* Save the PCB pointer */
     __pcb = (pcb_t *)pcb_ptr;

 /branches/dynload/uspace/lib/libc/generic/ipc.c
 ,23 → 666,6
         arg2, mode);
 }
-int ipc_forward_slow(ipc_callid_t callid, int phoneid, int method,
-    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5,
-    int mode)
-{
-    ipc_call_t data;
-    IPC_SET_METHOD(data, method);
-    IPC_SET_ARG1(data, arg1);
-    IPC_SET_ARG2(data, arg2);
-    IPC_SET_ARG3(data, arg3);
-    IPC_SET_ARG4(data, arg4);
-    IPC_SET_ARG5(data, arg5);
-    return __SYSCALL3(SYS_IPC_FORWARD_SLOW, callid, (sysarg_t) &data, mode);
-}
 /** Wrapper for making IPC_M_SHARE_IN calls.
  *
  * @param phoneid   Phone that will be used to contact the receiving side.

 /branches/dynload/uspace/lib/libc/shared/Makefile
 ,7 → 27,7
 #
 include ../../../../version
--include ../../../../Makefile.config
+include ../../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/lib/rtld/Makefile
 ,7 → 27,7
 #
 include ../../../version
--include ../../../Makefile.config
+include ../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/lib/libtest/Makefile
 ,7 → 27,7
 #
 include ../../../version
--include ../../../Makefile.config
+include ../../Makefile.config
 ## Setup toolchain
 #

 /branches/dynload/uspace/srv/kbd/arch/ppc32/src/kbd.c
 ,9 → 183,6
 int kbd_arch_init(void)
 {
-    if (!sysinfo_value("kbd"))
-        return 0;
     return ipc_register_irq(sysinfo_value("kbd.inr"), sysinfo_value("kbd.devno"), 0, &cuda_kbd);
 }

 /branches/dynload/uspace/srv/console/console.c
 ,6 → 500,7
     async_set_client_connection(client_connection);
     /* Connect to keyboard driver */
     kbd_phone = ipc_connect_me_to(PHONE_NS, SERVICE_KEYBOARD, 0, 0);
     while (kbd_phone < 0) {
         usleep(10000);
 ,9 → 518,6
         fb_info.phone = ipc_connect_me_to(PHONE_NS, SERVICE_VIDEO, 0, 0);
     }
-    /* Disable kernel output to the console */
-    __SYSCALL0(SYS_DEBUG_DISABLE_CONSOLE);
     /* Initialize gcons */
     gcons_init(fb_info.phone);
     /* Synchronize, the gcons can have something in queue */
 ,6 → 587,6
     return 0;
 }
 /** @}
  */

 /branches/dynload/uspace/srv/fs/tmpfs/tmpfs.c
 ,6 → 55,16
 vfs_info_t tmpfs_vfs_info = {
     .name = "tmpfs",
+    .ops = {
+        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_MOUNTED)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_DESTROY)] = VFS_OP_DEFINED,
+    }
 };
 fs_reg_t tmpfs_reg;

 /branches/dynload/uspace/srv/fs/fat/fat.c
 ,6 → 49,15
 vfs_info_t fat_vfs_info = {
     .name = "fat",
+    .ops = {
+        [IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_READ)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_WRITE)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_TRUNCATE)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_MOUNT)] = VFS_OP_NULL,
+        [IPC_METHOD_TO_VFS_OP(VFS_MOUNTED)] = VFS_OP_DEFINED,
+        [IPC_METHOD_TO_VFS_OP(VFS_UNMOUNT)] = VFS_OP_NULL,
+    }
 };
 fs_reg_t fat_reg;

/branches/dynload/uspace/srv/pci/libpci/Makefile
7,6 → 7,7

LIBC_PREFIX=$(shell cd ../../../lib/libc; pwd)

include ../../../Makefile.config
include $(LIBC_PREFIX)/Makefile.toolchain

LIBS = $(LIBC_PREFIX)/libc.a

 /branches/dynload/uspace/srv/vfs/vfs.h
 ,6 → 47,8
 #define VFS_FIRST   IPC_FIRST_USER_METHOD
+#define IPC_METHOD_TO_VFS_OP(m) ((m) - VFS_FIRST)
 /* Basic types. */
 typedef int16_t fs_handle_t;
 typedef int16_t dev_handle_t;
 ,16 → 81,32
     VFS_LAST_SRV,   /* keep this the last member of this enum */
 } vfs_request_srv_t;
+/**
+ * An instance of this structure is associated with a particular FS operation.
+ * It tells VFS if the FS supports the operation or maybe if a default one
+ * should be used.
+ */
+typedef enum {
+    VFS_OP_NULL = 0,
+    VFS_OP_DEFAULT,
+    VFS_OP_DEFINED
+} vfs_op_t;
 #define FS_NAME_MAXLEN  20
 /**
  * A structure like this is passed to VFS by each individual FS upon its
  * registration. It assosiates a human-readable identifier with each
- * registered FS.
+ * registered FS. More importantly, through this structure, the FS announces
+ * what operations it supports.
  */
 typedef struct {
     /** Unique identifier of the fs. */
     char name[FS_NAME_MAXLEN + 1];
+    /** Operations. */
+    vfs_op_t ops[VFS_LAST_CLNT - VFS_FIRST];
 } vfs_info_t;
 /**

 /branches/dynload/uspace/srv/vfs/vfs.c
 ,8 → 72,6
     while (keep_on_going) {
         ipc_callid_t callid;
         ipc_call_t call;
-        int phone;
-        fs_handle_t fs_handle;
         callid = async_get_call(&call);
 ,28 → 79,9
         case IPC_M_PHONE_HUNGUP:
             keep_on_going = false;
             break;
-        case IPC_M_CONNECT_ME_TO:
-            /*
-             * Connect the client file system to another one.
-             */
-            /* FIXME:
-             * Prevent ordinary clients from connecting to file
-             * system servers directly. This should be solved by
-             * applying some security mechanisms.
-             */
-            fs_handle = IPC_GET_ARG1(call);
-            phone = vfs_grab_phone(fs_handle);
-            (void) ipc_forward_fast(callid, phone, 0, 0, 0,
-                IPC_FF_NONE);
-            vfs_release_phone(phone);
-            break;
         case VFS_REGISTER:
             vfs_register(callid, &call);
-            /*
-             * Keep the connection open so that a file system can
-             * later ask us to connect it to another file system.
-             * This is necessary to support non-root mounts.
-             */
+            keep_on_going = false;
             break;
         case VFS_MOUNT:
             vfs_mount(callid, &call);

 /branches/dynload/uspace/srv/vfs/vfs_register.c
 ,6 → 98,30
         return false;
     }
+    /*
+     * Check if the FS implements mandatory VFS operations.
+     */
+    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_LOOKUP)] != VFS_OP_DEFINED) {
+        dprintf("Operation VFS_LOOKUP not defined by the client.\n");
+        return false;
+    }
+    if (info->ops[IPC_METHOD_TO_VFS_OP(VFS_READ)] != VFS_OP_DEFINED) {
+        dprintf("Operation VFS_READ not defined by the client.\n");
+        return false;
+    }
+    /*
+     * Check if each operation is either not defined, defined or default.
+     */
+    for (i = VFS_FIRST; i < VFS_LAST_CLNT; i++) {
+        if ((info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_NULL) &&
+            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFAULT) &&
+            (info->ops[IPC_METHOD_TO_VFS_OP(i)] != VFS_OP_DEFINED)) {
+            dprintf("Operation info not understood.\n");
+            return false;
+        }
+    }
     return true;
 }

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4341 → Rev 4340