WebSVN – HelenOS – Path Comparison – / – /branches/network/uspace/app/bdsh/cmds Rev 3386 and /branches/network/uspace/app/bdsh/cmds Rev 4153

Ignore whitespace Rev 3386 → Rev 4153

 /branches/network/uspace/app/bdsh/cmds/mknewcmd
 ,8 → 46,6
   -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
 ,8 → 65,7
     $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' and available in either interactive or noninteractive
-  mode.
+  reached by typing 'bar'.
   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.
 ,7 → 94,6
     "${CMDDESC}",
     &${CMDENTRY},
     &${HELPENTRY},
-    ${CMDRESTRICT}
 },
 EOF
 ,7 → 103,6
     NULL,
     &${CMDENTRY},
     &${HELPENTRY},
-    ${CMDRESTRICT}
 },
 EOF
 ,8 → 115,8
 EOF
     [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/entry.h
 /* Entry points for the ${CMDNAME} command */
-extern int * ${CMDENTRY}(char **);
-extern void * ${HELPENTRY}(unsigned int);
+extern int ${CMDENTRY}(char **);
+extern void ${HELPENTRY}(unsigned int);
 #endif /* ${defname}_ENTRY_H */
 ,25 → 162,25
 #include "${CMDNAME}.h"
 #include "cmds.h"
-static char *cmdname = "${CMDNAME}";
+static const char *cmdname = "${CMDNAME}";
 /* Dispays help for ${CMDNAME} in various levels */
-void * ${HELPENTRY}(unsigned int level)
+void ${HELPENTRY}(unsigned int level)
 {
     printf("This is the %s help for '%s'.\n",
         level ? EXT_HELP : SHORT_HELP, cmdname);
-    return CMD_VOID;
+    return;
 }
 EOF
     [ "${CMDTYPE}" = "module" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 /* Main entry point for ${CMDNAME}, accepts an array of arguments */
-int * ${CMDENTRY}(char **argv)
+int ${CMDENTRY}(char **argv)
 EOF
     [ "${CMDTYPE}" = "builtin" ] && cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 /* Main entry point for ${CMDNAME}, accepts an array of arguments and a
  * pointer to the cliuser_t structure */
-int * ${CMDENTRY}(char **argv, cliuser_t *usr)
+int ${CMDENTRY}(char **argv, cliuser_t *usr)
 EOF
     cat << EOF >> ${OUTDIR}/${CMDNAME}.c
 {
 ,8 → 229,8
 # We need at least one
 [ $# = 0 ] && usage && exit 1;
-TEMP=$(getopt -o n:d:e:h:a:r:t:HV \
---long name:,desc:,entry:,help-entry:,alias:,restrict:,type:,help,version \
+TEMP=$(getopt -o n:d:e:h:a:t:HV \
+--long name:,desc:,entry:,help-entry:,alias:,type:,help,version \
 -- "$@") || {
     echo "Try $PROGNAME --help for help"
 }
 ,11 → 264,6
         shift 2
         continue
     ;;
-    -r | --restrict)
-        CMDRESTRICT="$2"
-        shift 2
-        continue
-    ;;
     -t | --type)
         CMDTYPE="$2"
         shift 2
 ,30 → 295,7
 [ -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/network/uspace/app/bdsh/cmds/mod_cmds.c
 ,26 → 53,6
 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/network/uspace/app/bdsh/cmds/modules/touch/touch.c
 ,6 → 37,7
 #include <fcntl.h>
 #include <dirent.h>
 #include <sys/types.h>
+#include <string.h>
 #include "config.h"
 #include "errors.h"
 ,7 → 49,7
 static char *cmdname = "touch";
 /* Dispays help for touch in various levels */
-void * help_cmd_touch(unsigned int level)
+void help_cmd_touch(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' updates access times for files\n", cmdname);
 ,11 → 59,11
                 "created\n", cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 /* Main entry point for touch, accepts an array of arguments */
-int * cmd_touch(char **argv)
+int cmd_touch(char **argv)
 {
     unsigned int argc, i = 0, ret = 0;
     int fd;
 ,7 → 80,7
     }
     for (i = 1; i < argc; i ++) {
-        buff = cli_strdup(argv[i]);
+        buff = strdup(argv[i]);
         dirp = opendir(buff);
         if (dirp) {
             cli_error(CL_ENOTSUP, "%s is a directory", buff);

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

 /branches/network/uspace/app/bdsh/cmds/modules/touch/entry.h
 ,8 → 2,8
 #define TOUCH_ENTRY_H
 /* Entry points for the touch command */
-extern int * cmd_touch(char **);
-extern void * help_cmd_touch(unsigned int);
+extern int cmd_touch(char **);
+extern void help_cmd_touch(unsigned int);
 #endif /* TOUCH_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/cp/cp.c
 ,0 → 1,231
+/* 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 <unistd.h>
+#include <getopt.h>
+#include <string.h>
+#include <fcntl.h>
+#include "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "cp.h"
+#include "cmds.h"
+#define CP_VERSION "0.0.1"
+#define CP_DEFAULT_BUFLEN  1024
+static const char *cmdname = "cp";
+static struct option const long_options[] = {
+    { "buffer", required_argument, 0, 'b' },
+    { "force", no_argument, 0, 'f' },
+    { "recursive", no_argument, 0, 'r' },
+    { "help", no_argument, 0, 'h' },
+    { "version", no_argument, 0, 'v' },
+    { "verbose", no_argument, 0, 'V' },
+    { 0, 0, 0, 0 }
+};
+static int strtoint(const char *s1)
+{
+    long t1;
+    if (-1 == (t1 = strtol(s1, (char **) NULL, 10)))
+        return -1;
+    if (t1 <= 0)
+        return -1;
+    return (int) t1;
+}
+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;
+    int64_t copied = 0;
+    char *buff = NULL;
+    if (vb)
+        printf("Copying %s to %s\n", src, dest);
+    if (-1 == (fd1 = open(src, O_RDONLY))) {
+        printf("Unable to open source file %s\n", src);
+        return -1;
+    }
+    if (-1 == (fd2 = open(dest, O_CREAT))) {
+        printf("Unable to open destination file %s\n", dest);
+        close(fd1);
+        return -1;
+    }
+    total = lseek(fd1, 0, SEEK_END);
+    if (vb)
+        printf("%d bytes to copy\n", total);
+    lseek(fd1, 0, SEEK_SET);
+    if (NULL == (buff = (char *) malloc(blen))) {
+        printf("Unable to allocate enough memory to read %s\n",
+            src);
+        copied = -1;
+        goto out;
+    }
+    for (;;) {
+        ssize_t res;
+        bytes = read(fd1, buff, blen);
+        if (bytes <= 0)
+            break;
+        copied += bytes;
+        res = bytes;
+        do {
+            /*
+             * Theoretically, it may not be enough to call write()
+             * only once. Also the previous read() may have
+             * returned less data than requested.
+             */
+            bytes = write(fd2, buff, res);
+            if (bytes < 0)
+                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;
+        }
+    }
+    if (bytes < 0) {
+err:
+        printf("\nError copying %s, (%d)\n", src, bytes);
+        copied = bytes;
+    }
+out:
+    close(fd1);
+    close(fd2);
+    if (buff)
+        free(buff);
+    return copied;
+}
+void help_cmd_cp(unsigned int level)
+{
+    static char helpfmt[] =
+        "Usage:  %s [options] <source> <dest>\n"
+        "Options: (* indicates not yet implemented)\n"
+        "  -h, --help       A short option summary\n"
+        "  -v, --version    Print version information and exit\n"
+        "* -V, --verbose    Be annoyingly noisy about what's being done\n"
+        "* -f, --force      Do not complain when <dest> exists\n"
+        "* -r, --recursive  Copy entire directories\n"
+        "  -b, --buffer ## Set the read buffer size to ##\n"
+        "Currently, %s is under development, some options may not work.\n";
+    if (level == HELP_SHORT) {
+        printf("`%s' copies files and directories\n", cmdname);
+    } else {
+        help_cmd_cp(HELP_SHORT);
+        printf(helpfmt, cmdname, cmdname);
+    }
+    return;
+}
+int cmd_cp(char **argv)
+{
+    unsigned int argc, buffer = 0, verbose = 0;
+    int c, opt_ind;
+    int64_t ret;
+    argc = cli_count_args(argv);
+    for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
+        c = getopt_long(argc, argv, "hvVfrb:", long_options, &opt_ind);
+        switch (c) {
+        case 'h':
+            help_cmd_cp(1);
+            return CMD_SUCCESS;
+        case 'v':
+            printf("%d\n", CP_VERSION);
+            return CMD_SUCCESS;
+        case 'V':
+            verbose = 1;
+            break;
+        case 'f':
+            break;
+        case 'r':
+            break;
+        case 'b':
+            if (-1 == (buffer = strtoint(optarg))) {
+                printf("%s: Invalid buffer specification, "
+                    "(should be a number greater than zero)\n",
+                    cmdname);
+                return CMD_FAILURE;
+            }
+            if (verbose)
+                printf("Buffer = %d\n", buffer);
+            break;
+        }
+    }
+    if (buffer == 0)
+        buffer = CP_DEFAULT_BUFLEN;
+    argc -= optind;
+    if (argc != 2) {
+        printf("%s: invalid number of arguments. Try %s --help\n",
+            cmdname, cmdname);
+        return CMD_FAILURE;
+    }
+    ret = copy_file(argv[optind], argv[optind + 1], buffer, verbose);
+    if (verbose)
+        printf("%d bytes copied\n", ret);
+    if (ret >= 0)
+        return CMD_SUCCESS;
+    else
+        return CMD_FAILURE;
+}

/branches/network/uspace/app/bdsh/cmds/modules/cp/cp_def.h
0,0 → 1,7
{
"cp",
"Copy files and directories",
&cmd_cp,
&help_cmd_cp,
},

 /branches/network/uspace/app/bdsh/cmds/modules/cp/entry.h
 ,0 → 1,9
+#ifndef CP_ENTRY_H
+#define CP_ENTRY_H
+/* Entry points for the cp command */
+extern int cmd_cp(char **);
+extern void help_cmd_cp(unsigned int);
+#endif /* CP_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/cp/cp.h
 ,0 → 1,8
+#ifndef CP_H
+#define CP_H
+/* Prototypes for the cp command, excluding entry points */
+#endif /* CP_H */

 /branches/network/uspace/app/bdsh/cmds/modules/mkdir/entry.h
 ,8 → 2,8
 #define MKDIR_ENTRY_H
 /* Entry points for the mkdir command */
-extern int * cmd_mkdir(char **);
-extern void * help_cmd_mkdir(unsigned int);
+extern int cmd_mkdir(char **);
+extern void help_cmd_mkdir(unsigned int);
 #endif /* MKDIR_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/mkdir/mkdir.c
 ,7 → 60,7
 };
-void * help_cmd_mkdir(unsigned int level)
+void help_cmd_mkdir(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' creates a new directory\n", cmdname);
 ,7 → 79,7
         cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 /* This is kind of clunky, but effective for now */
 ,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 = cli_strdup(path))) {
+    if (NULL == (tmp = 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] = cli_strtok(tmp, "/");
+    dirs[i] = strtok(tmp, "/");
     while (dirs[i] && i < 255)
-        dirs[++i] = cli_strtok(NULL, "/");
+        dirs[++i] = strtok(NULL, "/");
     if (NULL == dirs[0])
         return 1;
 ,7 → 181,7
     return ret;
 }
-int * cmd_mkdir(char **argv)
+int cmd_mkdir(char **argv)
 {
     unsigned int argc, create_parents = 0, i, ret = 0, follow = 0;
     unsigned int verbose = 0;

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

 /branches/network/uspace/app/bdsh/cmds/modules/cat/entry.h
 ,8 → 2,8
 #define CAT_ENTRY_H
 /* Entry points for the cat command */
-extern int * cmd_cat(char **);
-extern void * help_cmd_cat(unsigned int);
+extern int cmd_cat(char **);
+extern void help_cmd_cat(unsigned int);
 #endif /* CAT_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/cat/cat.c
 ,7 → 59,7
 };
 /* Dispays help for cat in various levels */
-void * help_cmd_cat(unsigned int level)
+void help_cmd_cat(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' shows the contents of files\n", cmdname);
 ,7 → 78,7
         cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 static unsigned int cat_file(const char *fname, size_t blen)
 ,13 → 103,11
     }
     do {
-        memset(buff, 0, sizeof(buff));
         bytes = read(fd, buff, blen);
         if (bytes > 0) {
             count += bytes;
-            if (bytes < blen)
-                buff[bytes] = '\0';
-            printf(buff);
+            buff[bytes] = '\0';
+            printf("%s", buff);
             reads++;
         }
     } while (bytes > 0);
 ,12 → 119,6
         return 1;
     }
-    /* Debug stuff, newline not added purposefully */
-    printf("** %s is a file with the size of %ld bytes\n",
-        fname, total);
-    printf( "** %d bytes were read in a buffer of %d bytes in %d reads\n",
-        count, blen, reads);
-    printf("** Read %s\n", count == total ? "Succeeded" : "Failed");
     free(buff);
     return 0;
 ,7 → 125,7
 }
 /* Main entry point for cat, accepts an array of arguments */
-int * cmd_cat(char **argv)
+int cmd_cat(char **argv)
 {
     unsigned int argc, i, ret = 0, buffer = 0;
     int c, opt_ind;

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

 /branches/network/uspace/app/bdsh/cmds/modules/help/entry.h
 ,7 → 2,7
 #define HELP_ENTRY_H_
 /* Entry points for the help command */
-extern void * help_cmd_help(unsigned int);
-extern int * cmd_help(char *[]);
+extern void help_cmd_help(unsigned int);
+extern int cmd_help(char *[]);
 #endif

 /branches/network/uspace/app/bdsh/cmds/modules/help/help.c
 ,7 → 69,7
     return HELP_IS_RUBBISH;
 }
-void *help_cmd_help(unsigned int level)
+void help_cmd_help(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf(
 ,10 → 86,10
         cmdname, cmdname, cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
-int *cmd_help(char *argv[])
+int cmd_help(char *argv[])
 {
     module_t *mod;
     builtin_t *cmd;
 ,13 → 133,11
     /* 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;
 ,13 → 144,11
     /* 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/network/uspace/app/bdsh/cmds/modules/help/help_def.h
3,5 → 3,4
"Show help for commands",
&cmd_help,
&help_cmd_help,
0
},

/branches/network/uspace/app/bdsh/cmds/modules/sleep/sleep_def.h
0,0 → 1,7
{
"sleep",
"Pause for given time interval (in seconds)",
&cmd_sleep,
&help_cmd_sleep,
},

 /branches/network/uspace/app/bdsh/cmds/modules/sleep/entry.h
 ,0 → 1,9
+#ifndef SLEEP_ENTRY_H
+#define SLEEP_ENTRY_H
+/* Entry points for the sleep command */
+extern int cmd_sleep(char **);
+extern void help_cmd_sleep(unsigned int);
+#endif /* SLEEP_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/sleep/sleep.c
 ,0 → 1,73
+/* 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 "config.h"
+#include "util.h"
+#include "errors.h"
+#include "entry.h"
+#include "sleep.h"
+#include "cmds.h"
+static char *cmdname = "sleep";
+/* Dispays help for sleep in various levels */
+void help_cmd_sleep(unsigned int level)
+{
+    printf("This is the %s help for '%s'.\n",
+        level ? EXT_HELP : SHORT_HELP, cmdname);
+    return;
+}
+/* Main entry point for sleep, accepts an array of arguments */
+int cmd_sleep(char **argv)
+{
+    unsigned int argc;
+    unsigned int i;
+    /* Count the arguments */
+    for (argc = 0; argv[argc] != NULL; argc ++);
+    printf("%s %s\n", TEST_ANNOUNCE, cmdname);
+    printf("%d arguments passed to %s", argc - 1, cmdname);
+    if (argc < 2) {
+        printf("\n");
+        return CMD_SUCCESS;
+    }
+    printf(":\n");
+    for (i = 1; i < argc; i++)
+        printf("[%d] -> %s\n", i, argv[i]);
+    return CMD_SUCCESS;
+}

 /branches/network/uspace/app/bdsh/cmds/modules/sleep/sleep.h
 ,0 → 1,8
+#ifndef SLEEP_H
+#define SLEEP_H
+/* Prototypes for the sleep command, excluding entry points */
+#endif /* SLEEP_H */

 /branches/network/uspace/app/bdsh/cmds/modules/pwd/entry.h
 ,8 → 4,8
 #include "scli.h"
 /* Entry points for the pwd command */
-extern void * help_cmd_pwd(unsigned int);
-extern int * cmd_pwd(char **);
+extern void help_cmd_pwd(unsigned int);
+extern int cmd_pwd(char **);
 #endif

 /branches/network/uspace/app/bdsh/cmds/modules/pwd/pwd.c
 ,13 → 39,13
 static char * cmdname = "pwd";
-void * help_cmd_pwd(unsigned int level)
+void help_cmd_pwd(unsigned int level)
 {
     printf("`%s' prints your current working directory.\n", cmdname);
-    return CMD_VOID;
+    return;
 }
-int * cmd_pwd(char *argv[])
+int cmd_pwd(char *argv[])
 {
     char *buff;

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

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

 /branches/network/uspace/app/bdsh/cmds/modules/ls/ls.c
 ,6 → 50,24
 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 → 114,7
             ls_print_dir(dp->d_name);
             break;
         case LS_FILE:
-            ls_print_file(dp->d_name);
+            ls_print_file(dp->d_name, buff);
             break;
         case LS_BOGUS:
             /* Odd chance it was deleted from the time readdir() found
 ,19 → 138,19
 static void ls_print_dir(const char *d)
 {
-    printf("%-40s\t<DIR>\n", d);
+    printf("%-40s\t<dir>\n", d);
     return;
 }
-static void ls_print_file(const char *f)
+static void ls_print_file(const char *name, const char *pathname)
 {
-    printf("%-40s\n", f);
+    printf("%-40s\t%llu\n", name, (long long) flen(pathname));
     return;
 }
-void * help_cmd_ls(unsigned int level)
+void help_cmd_ls(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' lists files and directories.\n", cmdname);
 ,10 → 160,10
                 "working directory is used.\n", cmdname);
     }
-    return CMD_VOID;
+    return;
 }
-int * cmd_ls(char **argv)
+int cmd_ls(char **argv)
 {
     unsigned int argc;
     unsigned int scope;
 ,7 → 192,7
         free(buff);
         return CMD_FAILURE;
     case LS_FILE:
-        ls_print_file(buff);
+        ls_print_file(buff, buff);
         break;
     case LS_DIR:
         dirp = opendir(buff);

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

 /branches/network/uspace/app/bdsh/cmds/modules/ls/ls.h
 ,7 → 10,7
 static unsigned int ls_scope(const char *);
 static void ls_scan_dir(const char *, DIR *);
 static void ls_print_dir(const char *);
-static void ls_print_file(const char *);
+static void ls_print_file(const char *, const char *);
 #endif /* LS_H */

 /branches/network/uspace/app/bdsh/cmds/modules/ls/entry.h
 ,8 → 2,8
 #define LS_ENTRY_H
 /* Entry points for the ls command */
-extern int * cmd_ls(char **);
-extern void * help_cmd_ls(unsigned int);
+extern int cmd_ls(char **);
+extern void help_cmd_ls(unsigned int);
 #endif /* LS_ENTRY_H */

 /branches/network/uspace/app/bdsh/cmds/modules/modules.h
 ,7 → 18,6
 /* 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"
 ,6 → 24,8
 #include "touch/entry.h"
 #include "ls/entry.h"
 #include "pwd/entry.h"
+#include "sleep/entry.h"
+#include "cp/entry.h"
 /* Each .def function fills the module_t struct with the individual name, entry
  * point, help entry point, etc. You can use config.h to control what modules
 ,7 → 33,6
 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"
 ,6 → 39,8
 #include "touch/touch_def.h"
 #include "ls/ls_def.h"
 #include "pwd/pwd_def.h"
+#include "sleep/sleep_def.h"
+#include "cp/cp_def.h"
     {NULL, NULL, NULL, NULL}
 };

 /branches/network/uspace/app/bdsh/cmds/modules/rm/rm.c
 ,7 → 33,6
 #include <unistd.h>
 #include <fcntl.h>
 #include <dirent.h>
-#include <assert.h>
 #include <getopt.h>
 #include "config.h"
 ,7 → 143,7
 }
 /* Dispays help for rm in various levels */
-void * help_cmd_rm(unsigned int level)
+void help_cmd_rm(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' removes files and directories.\n", cmdname);
 ,11 → 160,11
         "Currently, %s is under development, some options don't work.\n",
         cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 /* Main entry point for rm, accepts an array of arguments */
-int * cmd_rm(char **argv)
+int cmd_rm(char **argv)
 {
     unsigned int argc;
     unsigned int i, scope, ret = 0;
 ,7 → 218,11
     while (NULL != argv[i]) {
         len = strlen(argv[i]) + 2;
         buff = (char *) realloc(buff, len);
-        assert(buff != NULL);
+        if (buff == NULL) {
+            printf("rm: out of memory\n");
+            ret = 1;
+            break;
+        }
         memset(buff, 0, sizeof(buff));
         snprintf(buff, len, argv[i]);

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

 /branches/network/uspace/app/bdsh/cmds/modules/rm/entry.h
 ,8 → 2,8
 #define RM_ENTRY_H
 /* Entry points for the rm command */
-extern int * cmd_rm(char **);
-extern void * help_cmd_rm(unsigned int);
+extern int cmd_rm(char **);
+extern void help_cmd_rm(unsigned int);
 #endif /* RM_ENTRY_H */

/branches/network/uspace/app/bdsh/cmds/builtins/builtins.h
4,9 → 4,11
#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/network/uspace/app/bdsh/cmds/builtins/cd/cd.c
 ,7 → 42,7
 static char * cmdname = "cd";
-void * help_cmd_cd(unsigned int level)
+void help_cmd_cd(unsigned int level)
 {
     if (level == HELP_SHORT) {
         printf("`%s' changes the current working directory.\n", cmdname);
 ,12 → 53,12
             cmdname, cmdname);
     }
-    return CMD_VOID;
+    return;
 }
 /* This is a very rudamentary 'cd' command. It is not 'link smart' (yet) */
-int * cmd_cd(char **argv, cliuser_t *usr)
+int cmd_cd(char **argv, cliuser_t *usr)
 {
     int argc, rc = 0;

 /branches/network/uspace/app/bdsh/cmds/builtins/cd/entry.h
 ,8 → 4,8
 #include "scli.h"
 /* Entry points for the cd command */
-extern void * help_cmd_cd(unsigned int);
-extern int * cmd_cd(char **, cliuser_t *);
+extern void help_cmd_cd(unsigned int);
+extern int cmd_cd(char **, cliuser_t *);
 #endif

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

/branches/network/uspace/app/bdsh/cmds/builtins/exit/exit.h
0,0 → 1,6
#ifndef EXIT_H
#define EXIT_H

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

#endif

 /branches/network/uspace/app/bdsh/cmds/builtins/exit/entry.h
 ,0 → 1,12
+#ifndef EXIT_ENTRY_H_
+#define EXIT_ENTRY_H_
+#include "scli.h"
+/* Entry points for the quit command */
+extern void help_cmd_exit(unsigned int);
+extern int cmd_exit(char *[], cliuser_t *);
+#endif

 /branches/network/uspace/app/bdsh/cmds/builtins/exit/exit.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 "exit.h"
+#include "cmds.h"
+static const char *cmdname = "exit";
+extern volatile unsigned int cli_quit;
+extern const char *progname;
+void help_cmd_exit(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_exit(char *argv[], cliuser_t *usr)
+{
+    /* Inform that we're outta here */
+    cli_quit = 1;
+    return CMD_SUCCESS;
+}

/branches/network/uspace/app/bdsh/cmds/builtins/exit/exit_def.h
0,0 → 1,6
{
"exit",
"Exit the shell",
&cmd_exit,
&help_cmd_exit,
},

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

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

 /branches/network/uspace/app/bdsh/cmds/cmds.h
 ,17 → 19,16
 #define BUFF_SMALL  255
 /* Return macros for int type entry points */
-#define CMD_FAILURE (int*)1
+#define CMD_FAILURE 1
 #define CMD_SUCCESS 0
-#define CMD_VOID (void *)NULL
 /* Types for module command entry and help */
-typedef int * (* mod_entry_t)(char **);
-typedef void * (* mod_help_t)(unsigned int);
+typedef int (* mod_entry_t)(char **);
+typedef void (* mod_help_t)(unsigned int);
 /* Built-in commands need to be able to modify cliuser_t */
-typedef int * (* builtin_entry_t)(char **, cliuser_t *);
-typedef void * (* builtin_help_t)(unsigned int);
+typedef int (* builtin_entry_t)(char **, cliuser_t *);
+typedef void (* builtin_help_t)(unsigned int);
 /* Module structure */
 typedef struct {
 ,7 → 36,6
     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/network/uspace/app/bdsh/cmds/builtin_cmds.c
 ,19 → 40,6
 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;

Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3386 → Rev 4153