summaryrefslogtreecommitdiff
path: root/package/sash/src
diff options
context:
space:
mode:
Diffstat (limited to 'package/sash/src')
-rw-r--r--package/sash/src/Makefile38
-rw-r--r--package/sash/src/README6
-rw-r--r--package/sash/src/cmd_uclinux.c127
-rw-r--r--package/sash/src/cmds.c899
-rw-r--r--package/sash/src/cp.c27
-rw-r--r--package/sash/src/date.c54
-rw-r--r--package/sash/src/df.c55
-rw-r--r--package/sash/src/free.c44
-rw-r--r--package/sash/src/hexdump.c127
-rw-r--r--package/sash/src/hostname.c24
-rw-r--r--package/sash/src/libsash/Makefile20
-rw-r--r--package/sash/src/libsash/utils.c706
-rw-r--r--package/sash/src/ls.c311
-rw-r--r--package/sash/src/ps.c317
-rw-r--r--package/sash/src/reboot.c93
-rw-r--r--package/sash/src/sash.c1118
-rw-r--r--package/sash/src/sash.h70
-rw-r--r--package/sash/src/shutdown.c75
18 files changed, 4111 insertions, 0 deletions
diff --git a/package/sash/src/Makefile b/package/sash/src/Makefile
new file mode 100644
index 000000000..90d6adf99
--- /dev/null
+++ b/package/sash/src/Makefile
@@ -0,0 +1,38 @@
+
+SH = sh
+SHOBJS = sash.o cmds.o cmd_uclinux.o ls.o hexdump.o df.o free.o \
+ hostname.o date.o
+
+SHUTDOWN = shutdown
+SHUTDOWNOBJS = shutdown.o
+
+REBOOT = reboot
+REBOOTOBJS = reboot.o
+
+SHOBJS += ps.o
+CFLAGS += -DCONFIG_USER_SASH_PS
+
+LIBSASH = libsash/libsash.a
+
+CFLAGS += -DCOMMAND_HISTORY
+
+all: $(SH) $(SHUTDOWN) $(REBOOT)
+
+$(SH): $(SHOBJS) $(LIBSASH)
+ $(CC) $(LDFLAGS) -o $@ $(SHOBJS) $(LIBSASH) $(LDLIBS$(LDLIBS_$@))
+
+$(SHUTDOWN): $(SHUTDOWNOBJS) $(LIBSASH)
+ $(CC) $(LDFLAGS) -o $@ $(SHUTDOWNOBJS) $(LIBSASH) $(LDLIBS)
+
+$(REBOOT): $(REBOOTOBJS) $(LIBSASH)
+ $(CC) $(LDFLAGS) -o $@ $(REBOOTOBJS) $(LIBSASH) $(LDLIBS$(LDLIBS_$@))
+
+dummy_target:
+
+$(LIBSASH): dummy_target
+ $(MAKE) -C libsash
+
+clean:
+ -rm -f $(SH) $(SHUTDOWN) $(REBOOT) *.elf *.gdb *.o
+ $(MAKE) -C libsash clean
+
diff --git a/package/sash/src/README b/package/sash/src/README
new file mode 100644
index 000000000..191c7de63
--- /dev/null
+++ b/package/sash/src/README
@@ -0,0 +1,6 @@
+
+
+ This shell is an adaption of David Bell's "sash", the stand-along shell,
+with some adaptions (and truncations) for our environment. It also includes
+a few utilities (like reboot and ps) that weren't part of the original sash.
+
diff --git a/package/sash/src/cmd_uclinux.c b/package/sash/src/cmd_uclinux.c
new file mode 100644
index 000000000..bf66c4529
--- /dev/null
+++ b/package/sash/src/cmd_uclinux.c
@@ -0,0 +1,127 @@
+
+#include "sash.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+#include <unistd.h>
+
+#if 0
+char psbuf[256];
+char name[40];
+int pid, state;
+char statec;
+
+void
+do_ps(argc, argv)
+ char **argv;
+{
+ int i;
+ int h;
+ int max;
+ FILE * f;
+ DIR * d;
+ struct dirent * de;
+ int l;
+
+ printf(" PID TTY STAT TIME COMMAND\n");
+
+
+ d = opendir("/proc");
+ if (!d)
+ return;
+
+ while (de = readdir(d)) {
+ for(i=0;i<strlen(de->d_name);i++)
+ if (!isdigit(de->d_name[i]))
+ goto next;
+
+ sprintf(psbuf, "/proc/%s/stat", de->d_name);
+ h = open(psbuf, O_RDONLY);
+
+ if (h==-1)
+ continue;
+
+ l = read(h, psbuf, 255);
+ if (l<=0) {
+ perror("Unable to read status");
+ close(h);
+ continue;
+ }
+
+ psbuf[l] = '\0';
+ psbuf[255] = '\0';
+
+
+ if (sscanf(psbuf,
+ "%d %s %c",
+ &pid, name, &statec)<3)
+ {
+ perror("Unable to parse status");
+ close(h);
+ continue;
+ }
+
+ state = statec;
+
+ close(h);
+
+ sprintf(psbuf, "/proc/%s/cmdline", de->d_name);
+ h = open(psbuf, O_RDONLY);
+
+ if (h == -1) {
+ perror("Unable to open cmdline");
+ continue;
+ }
+
+ l = read(h, psbuf, 255);
+ if (l < 0) {
+ perror("Unable to read cmdline");
+ close(h);
+ continue;
+ }
+
+ close(h);
+
+ psbuf[255] = psbuf[l] = '\0';
+
+ printf("%5d %3s %c --:-- %s\n", pid, "", state, psbuf);
+ next:
+ }
+
+ closedir(d);
+}
+#endif
+
+void
+do_cat(argc, argv)
+ char **argv;
+{
+ int fd;
+ char *name;
+ size_t l;
+ char buf[256];
+
+ while (argc-- > 1) {
+ if (intflag) {
+ return;
+ }
+ name = *(++argv);
+
+ fd = open(name, O_RDONLY);
+ if (fd < 0) {
+ perror(name);
+ return;
+ }
+
+ while ((l = read(fd, buf, sizeof(buf))) > 0) {
+ fwrite(buf, 1, l, stdout);
+ }
+ close(fd);
+ }
+}
diff --git a/package/sash/src/cmds.c b/package/sash/src/cmds.c
new file mode 100644
index 000000000..d822d9f6d
--- /dev/null
+++ b/package/sash/src/cmds.c
@@ -0,0 +1,899 @@
+/*
+ * Modifications for uClinux
+ * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>
+ *
+ * Original code
+ * Copyright (c) 1993 by David I. Bell
+ * Permission is granted to use, distribute, or modify this source,
+ * provided that this copyright notice remains intact.
+ *
+ * Most simple built-in commands are here.
+ */
+
+#include "sash.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <pwd.h>
+#include <grp.h>
+#include <utime.h>
+#include <errno.h>
+#ifdef EMBED
+#include <config/autoconf.h>
+#endif
+
+void
+do_echo(argc, argv)
+ char **argv;
+{
+ BOOL first;
+
+ first = TRUE;
+ while (argc-- > 1) {
+ if (!first)
+ fputc(' ', stdout);
+ first = FALSE;
+ fputs(*++argv, stdout);
+ }
+ fputc('\n', stdout);
+}
+
+
+void
+do_pwd(argc, argv)
+ char **argv;
+{
+ char buf[PATHLEN];
+
+ if (getcwd(buf, PATHLEN) == NULL) {
+ fprintf(stderr, "Cannot get current directory\n");
+ return;
+ }
+
+ printf("%s\n", buf);
+}
+
+void
+do_time(argc, argv)
+ char ** argv;
+{
+ struct timeval tv;
+ gettimeofday(&tv, 0);
+ printf("Time of day = %d.%6.6d seconds\n", tv.tv_sec, tv.tv_usec);
+}
+
+void
+do_cd(argc, argv)
+ char **argv;
+{
+ char *path;
+
+ if (argc > 1)
+ path = argv[1];
+ else {
+ path = getenv("HOME");
+ if (path == NULL) {
+ fprintf(stderr, "No HOME environment variable\n");
+ return;
+ }
+ }
+
+ if (chdir(path) < 0)
+ perror(path);
+}
+
+
+void
+do_mkdir(argc, argv)
+ char **argv;
+{
+ int state = 0, mode = -1;
+
+ while (argc-- > 1) {
+ if (state == 0) {
+ if (strcmp(argv[1], "-m") == 0)
+ state = 1;
+ else if (mkdir(argv[1], 0777) < 0)
+ perror(argv[1]);
+ else if (mode != -1 && chmod(argv[1], mode) < 0)
+ perror(argv[1]);
+ } else if (state == 1) {
+ mode = strtol(argv[1], NULL, 8);
+ state = 0;
+ }
+ argv++;
+ }
+}
+
+void
+do_sleep(argc, argv)
+ char **argv;
+{
+ if (argc > 1)
+ sleep(atoi(argv[1]));
+}
+
+void
+do_mknod(argc, argv)
+ char **argv;
+{
+ char *cp;
+ int mode;
+ int major;
+ int minor;
+
+ mode = 0666;
+
+ if (strcmp(argv[2], "b") == 0)
+ mode |= S_IFBLK;
+ else if (strcmp(argv[2], "c") == 0)
+ mode |= S_IFCHR;
+ else {
+ fprintf(stderr, "Bad device type\n");
+ return;
+ }
+
+ major = 0;
+ cp = argv[3];
+ while (isdecimal(*cp))
+ major = major * 10 + *cp++ - '0';
+
+ if (*cp || (major < 0) || (major > 255)) {
+ fprintf(stderr, "Bad major number\n");
+ return;
+ }
+
+ minor = 0;
+ cp = argv[4];
+ while (isdecimal(*cp))
+ minor = minor * 10 + *cp++ - '0';
+
+ if (*cp || (minor < 0) || (minor > 255)) {
+ fprintf(stderr, "Bad minor number\n");
+ return;
+ }
+
+ if (mknod(argv[1], mode, major * 256 + minor) < 0)
+ perror(argv[1]);
+}
+
+
+void
+do_rmdir(argc, argv)
+ char **argv;
+{
+ while (argc-- > 1) {
+ if (rmdir(argv[1]) < 0)
+ perror(argv[1]);
+ argv++;
+ }
+}
+
+
+void
+do_sync(argc, argv)
+ char **argv;
+{
+#ifdef CONFIG_USER_FLATFSD_FLATFSD
+ system("exec flatfsd -s");
+#endif
+ sync();
+}
+
+
+void
+do_rm(argc, argv)
+ char **argv;
+{
+ while (argc-- > 1) {
+ if (unlink(argv[1]) < 0)
+ perror(argv[1]);
+ argv++;
+ }
+}
+
+
+void
+do_chmod(argc, argv)
+ char **argv;
+{
+ char *cp;
+ int mode;
+
+ mode = 0;
+ cp = argv[1];
+ while (isoctal(*cp))
+ mode = mode * 8 + (*cp++ - '0');
+
+ if (*cp) {
+ fprintf(stderr, "Mode must be octal\n");
+ return;
+ }
+ argc--;
+ argv++;
+
+ while (argc-- > 1) {
+ if (chmod(argv[1], mode) < 0)
+ perror(argv[1]);
+ argv++;
+ }
+}
+
+
+void
+do_chown(argc, argv)
+ char **argv;
+{
+ char *cp;
+ int uid;
+ struct passwd *pwd;
+ struct stat statbuf;
+
+ cp = argv[1];
+ if (isdecimal(*cp)) {
+ uid = 0;
+ while (isdecimal(*cp))
+ uid = uid * 10 + (*cp++ - '0');
+
+ if (*cp) {
+ fprintf(stderr, "Bad uid value\n");
+ return;
+ }
+ } else {
+ pwd = getpwnam(cp);
+ if (pwd == NULL) {
+ fprintf(stderr, "Unknown user name\n");
+ return;
+ }
+
+ uid = pwd->pw_uid;
+ }
+
+ argc--;
+ argv++;
+
+ while (argc-- > 1) {
+ argv++;
+ if ((stat(*argv, &statbuf) < 0) ||
+ (chown(*argv, uid, statbuf.st_gid) < 0))
+ perror(*argv);
+ }
+}
+
+
+void
+do_chgrp(argc, argv)
+ char **argv;
+{
+ char *cp;
+ int gid;
+ struct group *grp;
+ struct stat statbuf;
+
+ cp = argv[1];
+ if (isdecimal(*cp)) {
+ gid = 0;
+ while (isdecimal(*cp))
+ gid = gid * 10 + (*cp++ - '0');
+
+ if (*cp) {
+ fprintf(stderr, "Bad gid value\n");
+ return;
+ }
+ } else {
+ grp = getgrnam(cp);
+ if (grp == NULL) {
+ fprintf(stderr, "Unknown group name\n");
+ return;
+ }
+
+ gid = grp->gr_gid;
+ }
+
+ argc--;
+ argv++;
+
+ while (argc-- > 1) {
+ argv++;
+ if ((stat(*argv, &statbuf) < 0) ||
+ (chown(*argv, statbuf.st_uid, gid) < 0))
+ perror(*argv);
+ }
+}
+
+
+void
+do_touch(argc, argv)
+ char **argv;
+{
+ char *name;
+ int fd;
+ struct utimbuf now;
+
+ time(&now.actime);
+ now.modtime = now.actime;
+
+ while (argc-- > 1) {
+ name = *(++argv);
+
+ if (utime(name, &now) <0)
+ {
+ fd = open(name, O_CREAT | O_WRONLY | O_EXCL, 0666);
+ if (fd >= 0)
+ {
+ close(fd);
+ continue;
+ }
+ perror(name);
+ }
+ }
+}
+
+
+void
+do_mv(argc, argv)
+ char **argv;
+{
+ int dirflag;
+ char *srcname;
+ char *destname;
+ char *lastarg;
+
+ lastarg = argv[argc - 1];
+
+ dirflag = isadir(lastarg);
+
+ if ((argc > 3) && !dirflag) {
+ fprintf(stderr, "%s: not a directory\n", lastarg);
+ return;
+ }
+
+ while (argc-- > 2) {
+ srcname = *(++argv);
+ if (access(srcname, 0) < 0) {
+ perror(srcname);
+ continue;
+ }
+
+ destname = lastarg;
+ if (dirflag)
+ destname = buildname(destname, srcname);
+
+ if (rename(srcname, destname) >= 0)
+ continue;
+
+ if (errno != EXDEV) {
+ perror(destname);
+ continue;
+ }
+
+ if (!copyfile(srcname, destname, TRUE))
+ continue;
+
+ if (unlink(srcname) < 0)
+ perror(srcname);
+ }
+}
+
+
+void
+do_ln(argc, argv)
+ char **argv;
+{
+ int dirflag;
+ char *srcname;
+ char *destname;
+ char *lastarg;
+
+ if (argv[1][0] == '-') {
+ if (strcmp(argv[1], "-s")) {
+ fprintf(stderr, "Unknown option\n");
+ return;
+ }
+
+ if (argc != 4) {
+ fprintf(stderr, "Wrong number of arguments for symbolic link\n");
+ return;
+ }
+
+#ifdef S_ISLNK
+ if (symlink(argv[2], argv[3]) < 0)
+ perror(argv[3]);
+#else
+ fprintf(stderr, "Symbolic links are not allowed\n");
+#endif
+ return;
+ }
+
+ /*
+ * Here for normal hard links.
+ */
+ lastarg = argv[argc - 1];
+ dirflag = isadir(lastarg);
+
+ if ((argc > 3) && !dirflag) {
+ fprintf(stderr, "%s: not a directory\n", lastarg);
+ return;
+ }
+
+ while (argc-- > 2) {
+ srcname = *(++argv);
+ if (access(srcname, 0) < 0) {
+ perror(srcname);
+ continue;
+ }
+
+ destname = lastarg;
+ if (dirflag)
+ destname = buildname(destname, srcname);
+
+ if (link(srcname, destname) < 0) {
+ perror(destname);
+ continue;
+ }
+ }
+}
+
+
+void
+do_cp(argc, argv)
+ char **argv;
+{
+ BOOL dirflag;
+ char *srcname;
+ char *destname;
+ char *lastarg;
+
+ lastarg = argv[argc - 1];
+
+ dirflag = isadir(lastarg);
+
+ if ((argc > 3) && !dirflag) {
+ fprintf(stderr, "%s: not a directory\n", lastarg);
+ return;
+ }
+
+ while (argc-- > 2) {
+ destname = lastarg;
+ srcname = *++argv;
+ if (dirflag)
+ destname = buildname(destname, srcname);
+
+ (void) copyfile(srcname, destname, FALSE);
+ }
+}
+
+
+void
+do_mount(argc, argv)
+ char **argv;
+{
+ char *str;
+ char *type;
+
+ argc--;
+ argv++;
+ type = "minix";
+
+ while ((argc > 0) && (**argv == '-')) {
+ argc--;
+ str = *argv++ ;
+
+ while (*++str) switch (*str) {
+ case 't':
+ if ((argc <= 0) || (**argv == '-')) {
+ fprintf(stderr, "Missing file system type\n");
+ return;
+ }
+
+ type = *argv++;
+ argc--;
+ break;
+
+ default:
+ fprintf(stderr, "Unknown option\n");
+ return;
+ }
+ }
+
+ if (argc != 2) {
+ fprintf(stderr, "Wrong number of arguments for mount\n");
+ return;
+ }
+
+ if (mount(argv[0], argv[1], type, 0, 0) < 0)
+ perror("mount failed");
+}
+
+
+void
+do_umount(argc, argv)
+ char **argv;
+{
+ if (umount(argv[1]) < 0)
+ perror(argv[1]);
+}
+
+
+void
+do_cmp(argc, argv)
+ char **argv;
+{
+ int fd1;
+ int fd2;
+ int cc1;
+ int cc2;
+ long pos;
+ char *srcname;
+ char *destname;
+ char *lastarg;
+ char *bp1;
+ char *bp2;
+ char *buf1;
+ char *buf2;
+ struct stat statbuf1;
+ struct stat statbuf2;
+
+ if (stat(argv[1], &statbuf1) < 0) {
+ perror(argv[1]);
+ return;
+ }
+
+ if (stat(argv[2], &statbuf2) < 0) {
+ perror(argv[2]);
+ return;
+ }
+
+ if ((statbuf1.st_dev == statbuf2.st_dev) &&
+ (statbuf1.st_ino == statbuf2.st_ino))
+ {
+ printf("Files are links to each other\n");
+ return;
+ }
+
+ if (statbuf1.st_size != statbuf2.st_size) {
+ printf("Files are different sizes\n");
+ return;
+ }
+
+ fd1 = open(argv[1], 0);
+ if (fd1 < 0) {
+ perror(argv[1]);
+ return;
+ }
+
+ fd2 = open(argv[2], 0);
+ if (fd2 < 0) {
+ perror(argv[2]);
+ close(fd1);
+ return;
+ }
+
+ buf1 = malloc(8192-16);
+ buf2 = malloc(8192-16);
+
+ pos = 0;
+ while (TRUE) {
+ if (intflag)
+ goto closefiles;
+
+ cc1 = read(fd1, buf1, 8192-16);
+ if (cc1 < 0) {
+ perror(argv[1]);
+ goto closefiles;
+ }
+
+ cc2 = read(fd2, buf2, 8192-16);
+ if (cc2 < 0) {
+ perror(argv[2]);
+ goto closefiles;
+ }
+
+ if ((cc1 == 0) && (cc2 == 0)) {
+ printf("Files are identical\n");
+ goto closefiles;
+ }
+
+ if (cc1 < cc2) {
+ printf("First file is shorter than second\n");
+ goto closefiles;
+ }
+
+ if (cc1 > cc2) {
+ printf("Second file is shorter than first\n");
+ goto closefiles;
+ }
+
+ if (memcmp(buf1, buf2, cc1) == 0) {
+ pos += cc1;
+ continue;
+ }
+
+ bp1 = buf1;
+ bp2 = buf2;
+ while (*bp1++ == *bp2++)
+ pos++;
+
+ printf("Files differ at byte position %ld\n", pos);
+ goto closefiles;
+ }
+
+closefiles:
+ close(fd1);
+ close(fd2);
+ free(buf1);
+ free(buf2);
+}
+
+
+void
+do_more(argc, argv)
+ char **argv;
+{
+ FILE *fp;
+ char *name;
+ int ch;
+ int line;
+ int col;
+ char buf[80];
+
+ while (argc-- > 1) {
+ name = *(++argv);
+
+ fp = fopen(name, "r");
+ if (fp == NULL) {
+ perror(name);
+ return;
+ }
+
+ printf("<< %s >>\n", name);
+ line = 1;
+ col = 0;
+
+ while (fp && ((ch = fgetc(fp)) != EOF)) {
+ switch (ch) {
+ case '\r':
+ col = 0;
+ break;
+
+ case '\n':
+ line++;
+ col = 0;
+ break;
+
+ case '\t':
+ col = ((col + 1) | 0x07) + 1;
+ break;
+
+ case '\b':
+ if (col > 0)
+ col--;
+ break;
+
+ default:
+ col++;
+ }
+
+ putchar(ch);
+ if (col >= 80) {
+ col -= 80;
+ line++;
+ }
+
+ if (line < 24)
+ continue;
+
+ if (col > 0)
+ putchar('\n');
+
+ printf("--More--");
+ fflush(stdout);
+
+ if (intflag || (read(0, buf, sizeof(buf)) < 0)) {
+ if (fp)
+ fclose(fp);
+ return;
+ }
+
+ ch = buf[0];
+ if (ch == ':')
+ ch = buf[1];
+
+ switch (ch) {
+ case 'N':
+ case 'n':
+ fclose(fp);
+ fp = NULL;
+ break;
+
+ case 'Q':
+ case 'q':
+ fclose(fp);
+ return;
+ }
+
+ col = 0;
+ line = 1;
+ }
+ if (fp)
+ fclose(fp);
+ }
+}
+
+
+void
+do_exit(argc, argv)
+ char **argv;
+{
+ exit(0);
+}
+
+
+void
+do_setenv(argc, argv)
+ char **argv;
+{
+ setenv(argv[1], argv[2], 1);
+}
+
+
+void
+do_printenv(argc, argv)
+ char **argv;
+{
+ char **env;
+ extern char **environ;
+ int len;
+
+ env = environ;
+
+ if (argc == 1) {
+ while (*env)
+ printf("%s\n", *env++);
+ return;
+ }
+
+ len = strlen(argv[1]);
+ while (*env) {
+ if ((strlen(*env) > len) && (env[0][len] == '=') &&
+ (memcmp(argv[1], *env, len) == 0))
+ {
+ printf("%s\n", &env[0][len+1]);
+ return;
+ }
+ env++;
+ }
+}
+
+
+void
+do_umask(argc, argv)
+ char **argv;
+{
+ char *cp;
+ int mask;
+
+ if (argc <= 1) {
+ mask = umask(0);
+ umask(mask);
+ printf("%03o\n", mask);
+ return;
+ }
+
+ mask = 0;
+ cp = argv[1];
+ while (isoctal(*cp))
+ mask = mask * 8 + *cp++ - '0';
+
+ if (*cp || (mask & ~0777)) {
+ fprintf(stderr, "Bad umask value\n");
+ return;
+ }
+
+ umask(mask);
+}
+
+
+void
+do_kill(argc, argv)
+ char **argv;
+{
+ char *cp;
+ int sig;
+ int pid;
+
+ sig = SIGTERM;
+
+ if (argv[1][0] == '-') {
+ cp = &argv[1][1];
+ if (strcmp(cp, "HUP") == 0)
+ sig = SIGHUP;
+ else if (strcmp(cp, "INT") == 0)
+ sig = SIGINT;
+ else if (strcmp(cp, "QUIT") == 0)
+ sig = SIGQUIT;
+ else if (strcmp(cp, "ILL") == 0)
+ sig = SIGILL;
+ else if (strcmp(cp, "TRAP") == 0)
+ sig = SIGTRAP;
+ else if (strcmp(cp, "ABRT") == 0)
+ sig = SIGABRT;
+ else if (strcmp(cp, "IOT") == 0)
+ sig = SIGIOT;
+ else if (strcmp(cp, "BUS") == 0)
+ sig = SIGBUS;
+ else if (strcmp(cp, "FPE") == 0)
+ sig = SIGFPE;
+ else if (strcmp(cp, "KILL") == 0)
+ sig = SIGKILL;
+ else if (strcmp(cp, "USR1") == 0)
+ sig = SIGUSR1;
+ else if (strcmp(cp, "SEGV") == 0)
+ sig = SIGSEGV;
+ else if (strcmp(cp, "USR2") == 0)
+ sig = SIGUSR2;
+ else if (strcmp(cp, "PIPE") == 0)
+ sig = SIGPIPE;
+ else if (strcmp(cp, "ALRM") == 0)
+ sig = SIGALRM;
+ else if (strcmp(cp, "TERM") == 0)
+ sig = SIGTERM;
+#ifdef SIGSTKFLT
+ else if (strcmp(cp, "STKFLT") == 0)
+ sig = SIGSTKFLT;
+#endif
+ else if (strcmp(cp, "CHLD") == 0)
+ sig = SIGCHLD;
+ else if (strcmp(cp, "CONT") == 0)
+ sig = SIGCONT;
+ else if (strcmp(cp, "STOP") == 0)
+ sig = SIGSTOP;
+ else if (strcmp(cp, "TSTP") == 0)
+ sig = SIGTSTP;
+ else if (strcmp(cp, "TTIN") == 0)
+ sig = SIGTTIN;
+ else if (strcmp(cp, "TTOU") == 0)
+ sig = SIGTTOU;
+ else if (strcmp(cp, "URG") == 0)
+ sig = SIGURG;
+ else if (strcmp(cp, "PWR") == 0)
+ sig = SIGPWR;
+ else {
+ sig = 0;
+ while (isdecimal(*cp))
+ sig = sig * 10 + *cp++ - '0';
+
+ if (*cp) {
+ fprintf(stderr, "Unknown signal\n");
+ exit_code = 1;
+ return;
+ }
+ }
+ argc--;
+ argv++;
+ }
+
+ while (argc-- > 1) {
+ cp = *++argv;
+ pid = 0;
+ while (isdecimal(*cp))
+ pid = pid * 10 + *cp++ - '0';
+
+ if (*cp) {
+ fprintf(stderr, "Non-numeric pid\n");
+ exit_code = 1;
+ return;
+ }
+
+ if (kill(pid, sig) < 0) {
+ perror(*argv);
+ exit_code = 1;
+ }
+ }
+}
+
+/* END CODE */
diff --git a/package/sash/src/cp.c b/package/sash/src/cp.c
new file mode 100644
index 000000000..11d03f74c
--- /dev/null
+++ b/package/sash/src/cp.c
@@ -0,0 +1,27 @@
+
+void
+do_cp(argc, argv)
+ char **argv;
+{
+ BOOL dirflag;
+ char *srcname;
+ char *destname;
+ char *lastarg;
+
+ lastarg = argv[argc - 1];
+
+ dirflag = isadir(lastarg);
+
+ if ((argc > 3) && !dirflag) {
+ fprintf(stderr, "%s: not a directory\n", lastarg);
+ return;
+ }
+
+ while (argc-- > 2) {
+ destname = lastarg;
+ if (dirflag)
+ destname = buildname(destname, srcname);
+
+ (void) copyfile(*++argv, destname, FALSE);
+ }
+}
diff --git a/package/sash/src/date.c b/package/sash/src/date.c
new file mode 100644
index 000000000..c7317998b
--- /dev/null
+++ b/package/sash/src/date.c
@@ -0,0 +1,54 @@
+/* date.c bradkemp@indusriver.com */
+
+#include <time.h>
+#include <stdio.h>
+
+static const char invalid_date[] = "Invalid date %s\n";
+int do_date(int argc, char * argv[])
+{
+
+ time_t tm;
+ struct tm tm_time;
+ time(&tm);
+ memcpy(&tm_time, localtime(&tm), sizeof(tm_time));
+
+ if (argc > 1) {
+ int nr;
+
+ nr = sscanf(argv[1], "%2d%2d%2d%2d%d",
+ &(tm_time.tm_mon),
+ &(tm_time.tm_mday),
+ &(tm_time.tm_hour),
+ &(tm_time.tm_min), &(tm_time.tm_year));
+
+ if (nr < 4 || nr > 5) {
+ fprintf(stderr, invalid_date, argv[1]);
+ return(0);
+ }
+
+ /* correct for century - minor Y2K problem here? */
+ if (tm_time.tm_year >= 1900)
+ tm_time.tm_year -= 1900;
+ /* adjust date */
+ tm_time.tm_mon -= 1;
+
+ if((tm = mktime(&tm_time)) < 0) {
+ fprintf(stderr, invalid_date, argv[1]);
+ return(0);
+ }
+
+ if(stime(&tm) < 0) {
+ fprintf(stderr, "Unable to set date\n");
+ return(0);
+ }
+
+ return (0);
+
+ }
+ printf("%s\n",asctime(&tm_time));
+
+ return(0);
+}
+
+
+
diff --git a/package/sash/src/df.c b/package/sash/src/df.c
new file mode 100644
index 000000000..99ac2217e
--- /dev/null
+++ b/package/sash/src/df.c
@@ -0,0 +1,55 @@
+/* df.c:
+ *
+ * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>,
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include "sash.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/vfs.h>
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+#include <linux/major.h>
+#ifdef __UC_LIBC__
+#include <linux/types.h>
+#endif
+#include <sys/time.h>
+#include <sys/param.h>
+#include <errno.h>
+
+void
+do_df(int argc, char * argv[])
+{
+ char * name;
+ struct statfs stbuf;
+
+#if 0
+ fclose(stdin);
+#endif
+
+ if (argc<2)
+ name = "/";
+ else
+ name = argv[1];
+
+ if (statfs(name, &stbuf) == -1) {
+ printf("Unable to get disk space of %s: %s\n", name, strerror(errno));
+ return;
+ }
+
+ printf("Total Kbytes: %ld\n", (stbuf.f_bsize / 256) * (stbuf.f_blocks / 4));
+ printf("Free Kbytes: %ld\n", (stbuf.f_bsize / 256) * (stbuf.f_bfree / 4));
+ printf("Total nodes: %ld\n", stbuf.f_files);
+ printf("Free nodes: %ld\n", stbuf.f_ffree);
+}
+
diff --git a/package/sash/src/free.c b/package/sash/src/free.c
new file mode 100644
index 000000000..281f10995
--- /dev/null
+++ b/package/sash/src/free.c
@@ -0,0 +1,44 @@
+/* free.c:
+ *
+ * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>,
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include "sash.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+
+void
+do_free(argc, argv)
+ char **argv;
+{
+ int i;
+ FILE * f;
+ char buf[256];
+
+ f = fopen("/proc/meminfo", "r");
+
+ if (!f) {
+ perror("Unable to open /proc/meminfo: ");
+ return;
+ }
+
+ for(i=0;i<3;i++) {
+ fgets(buf, 250, f);
+ fputs(buf, stdout);
+ }
+
+ fclose(f);
+}
+
diff --git a/package/sash/src/hexdump.c b/package/sash/src/hexdump.c
new file mode 100644
index 000000000..f12f62494
--- /dev/null
+++ b/package/sash/src/hexdump.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 1993 by David I. Bell
+ * Permission is granted to use, distribute, or modify this source,
+ * provided that this copyright notice remains intact.
+ *
+ * Most simple built-in commands are here.
+ */
+
+#include "sash.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <pwd.h>
+#include <grp.h>
+#include <utime.h>
+#include <errno.h>
+
+void
+do_hexdump(argc, argv)
+ int argc;
+ char **argv;
+{
+ FILE *fp;
+ int count;
+ int c;
+ char text[17];
+ unsigned char buf[130];
+
+ char *name = 0;
+ unsigned long pos = 0;
+ char *myname = argv[0];
+
+ if ( (argc > 2) && !strcmp(argv[1],"-s") ) {
+ pos = strtoul(argv[2], 0, 0);
+ argc -= 2;
+ argv += 2;
+ }
+
+ if (argc <= 1) {
+ fprintf(stderr, "No filename provided\n");
+ return;
+ }
+
+ name = argv[1];
+ fp = fopen(name, "r");
+ if (!fp) {
+ fprintf(stderr, "Failed to open file '%s': %s\n",
+ name, strerror(errno));
+ return;
+ }
+
+ if (pos)
+ fseek(fp, pos, SEEK_SET);
+
+ c = 0;
+
+ text[16] = 0;
+
+ while(!feof(fp)) {
+
+ strcmp(text, " ");
+
+ while (c < (pos & 0xf)) {
+ if (c == 0)
+ printf("%4X:", pos & 0xfffffff0);
+ printf( (c == 8) ? "- " : " ");
+ text[c] = ' ';
+ c++;
+ }
+
+ {
+ int p = 0;
+ count = fread(buf, 1, 128 - (pos % 16), fp);
+
+ if (count <= 0)
+ break;
+
+ while (p < count) {
+ c = (pos & 0xf);
+
+ if (c == 0)
+ printf("%4X:", pos & 0xfffffff0);
+
+ if ((buf[p] < 32) || (buf[p]>126))
+ text[c] = '.';
+ else
+ text[c] = buf[p];
+
+ printf( (c==15) ? " %02.2X" : (c == 8) ? "-%02.2X" : " %02.2X", buf[p]);
+
+ if (c == 15)
+ printf(" %s\n", text);
+
+ pos++;
+ p++;
+ }
+ }
+
+ if (c = (pos & 0x0f)) {
+
+ while (c < 16) {
+ printf( (c == 8) ? "- " : " ");
+ text[c] = ' ';
+ c++;
+ }
+
+ printf(" %s\n", text);
+ }
+
+ if (feof(fp))
+ break;
+
+ printf("--more--");
+ fflush(stdout);
+
+ fgets(buf, 80, stdin);
+ if (toupper(buf[0]) == 'Q')
+ break;
+ }
+
+ if (fp != stdin)
+ fclose(fp);
+}
+
diff --git a/package/sash/src/hostname.c b/package/sash/src/hostname.c
new file mode 100644
index 000000000..8841e7fa3
--- /dev/null
+++ b/package/sash/src/hostname.c
@@ -0,0 +1,24 @@
+/* hostname.c - poe@daimi.aau.dk */
+
+#include "sash.h"
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <stdio.h>
+#include <unistd.h>
+
+void do_hostname(int argc, char **argv)
+{
+ char hn[PATHLEN + 1];
+
+ if(argc >= 2) {
+ if(strlen(argv[1]) > PATHLEN) {
+ printf("That name is too long.\n");
+ } else {
+ sethostname(argv[1], strlen(argv[1]));
+ }
+ } else {
+ gethostname(hn, PATHLEN);
+ printf("%s\n", hn);
+ }
+}
diff --git a/package/sash/src/libsash/Makefile b/package/sash/src/libsash/Makefile
new file mode 100644
index 000000000..03a2fafae
--- /dev/null
+++ b/package/sash/src/libsash/Makefile
@@ -0,0 +1,20 @@
+
+LIB = libsash.a
+CHOPSRC = utils.c
+LIBOBJS = intflag.o modestring.o timestring.o isadir.o copyfile.o \
+ buildname.o expandwildcards.o namesort.o match.o makeargs.o \
+ makestring.o chunks.o expandenvvar.o
+
+CFLAGS += -I../
+
+
+all: $(EXEC) $(LIB)
+
+$(LIBOBJS): $(CHOPSRC)
+ $(CC) $(CFLAGS) -DL_$(basename $*) -o $(basename $*).o -c $^
+
+$(LIB): $(LIB)($(LIBOBJS))
+ $(RANLIB) $(LIB)
+
+clean:
+ rm -f $(LIB) $(EXEC) *.o
diff --git a/package/sash/src/libsash/utils.c b/package/sash/src/libsash/utils.c
new file mode 100644
index 000000000..a05b33aee
--- /dev/null
+++ b/package/sash/src/libsash/utils.c
@@ -0,0 +1,706 @@
+/*
+ * Copyright (c) 1993 by David I. Bell
+ * Permission is granted to use, distribute, or modify this source,
+ * provided that this copyright notice remains intact.
+ *
+ * Utility routines.
+ */
+
+#include "sash.h"
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <time.h>
+#include <utime.h>
+#include <fcntl.h>
+#include <fnmatch.h>
+
+#ifdef L_intflag
+
+int intflag;
+
+#endif
+
+#ifdef L_modestring
+
+/*
+ * Return the standard ls-like mode string from a file mode.
+ * This is static and so is overwritten on each call.
+ */
+char *
+modestring(mode)
+{
+ static char buf[12];
+
+ strcpy(buf, "----------");
+
+ /*
+ * Fill in the file type.
+ */
+ if (S_ISDIR(mode))
+ buf[0] = 'd';
+ if (S_ISCHR(mode))
+ buf[0] = 'c';
+ if (S_ISBLK(mode))
+ buf[0] = 'b';
+ if (S_ISFIFO(mode))
+ buf[0] = 'p';
+#ifdef S_ISLNK
+ if (S_ISLNK(mode))
+ buf[0] = 'l';
+#endif
+#ifdef S_ISSOCK
+ if (S_ISSOCK(mode))
+ buf[0] = 's';
+#endif
+
+ /*
+ * Now fill in the normal file permissions.
+ */
+ if (mode & S_IRUSR)
+ buf[1] = 'r';
+ if (mode & S_IWUSR)
+ buf[2] = 'w';
+ if (mode & S_IXUSR)
+ buf[3] = 'x';
+ if (mode & S_IRGRP)
+ buf[4] = 'r';
+ if (mode & S_IWGRP)
+ buf[5] = 'w';
+ if (mode & S_IXGRP)
+ buf[6] = 'x';
+ if (mode & S_IROTH)
+ buf[7] = 'r';
+ if (mode & S_IWOTH)
+ buf[8] = 'w';
+ if (mode & S_IXOTH)
+ buf[9] = 'x';
+
+ /*
+ * Finally fill in magic stuff like suid and sticky text.
+ */
+ if (mode & S_ISUID)
+ buf[3] = ((mode & S_IXUSR) ? 's' : 'S');
+ if (mode & S_ISGID)
+ buf[6] = ((mode & S_IXGRP) ? 's' : 'S');
+ if (mode & S_ISVTX)
+ buf[9] = ((mode & S_IXOTH) ? 't' : 'T');
+
+ return buf;
+}
+
+#endif
+
+#ifdef L_timestring
+
+/*
+ * Get the time to be used for a file.
+ * This is down to the minute for new files, but only the date for old files.
+ * The string is returned from a static buffer, and so is overwritten for
+ * each call.
+ */
+char *
+timestring(t)
+ long t;
+{
+ long now;
+ char *str;
+ static char buf[26];
+
+ time(&now);
+
+ str = ctime(&t);
+
+ strcpy(buf, &str[4]);
+ buf[12] = '\0';
+
+ if ((t > now) || (t < now - 365*24*60*60L)) {
+ strcpy(&buf[7], &str[20]);
+ buf[11] = '\0';
+ }
+
+ return buf;
+}
+
+#endif
+
+#ifdef L_isadir
+
+/*
+ * Return TRUE if a filename is a directory.
+ * Nonexistant files return FALSE.
+ */
+BOOL
+isadir(name)
+ char *name;
+{
+ struct stat statbuf;
+
+ if (stat(name, &statbuf) < 0)
+ return FALSE;
+
+ return S_ISDIR(statbuf.st_mode);
+}
+
+#endif
+
+#ifdef L_copyfile
+
+/*
+ * Copy one file to another, while possibly preserving its modes, times,
+ * and modes. Returns TRUE if successful, or FALSE on a failure with an
+ * error message output. (Failure is not indicted if the attributes cannot
+ * be set.)
+ */
+BOOL
+copyfile(srcname, destname, setmodes)
+ char *srcname;
+ char *destname;
+ BOOL setmodes;
+{
+ int rfd;
+ int wfd;
+ int rcc;
+ int wcc;
+ char *bp;
+ struct stat statbuf1;
+ struct stat statbuf2;
+ struct utimbuf times;
+ int len = 8192-16;
+ char * buf = 0;
+
+ if (stat(srcname, &statbuf1) < 0) {
+ perror(srcname);
+ return FALSE;
+ }
+
+ if (stat(destname, &statbuf2) < 0) {
+ statbuf2.st_ino = -1;
+ statbuf2.st_dev = -1;
+ }
+
+ if (S_ISREG(statbuf1.st_mode) &&
+ (statbuf1.st_dev == statbuf2.st_dev) &&
+ (statbuf1.st_ino == statbuf2.st_ino))
+ {
+ fprintf(stderr, "Copying file \"%s\" to itself\n", srcname);
+ return FALSE;
+ }
+
+ rfd = open(srcname, 0);
+ if (rfd < 0) {
+ perror(srcname);
+ return FALSE;
+ }
+
+ wfd = open(destname, O_WRONLY|O_CREAT|O_TRUNC, statbuf1.st_mode);
+ if (wfd < 0) {
+ perror(destname);
+ close(rfd);
+ return FALSE;
+ }
+
+ buf = malloc(len);
+ if (!buf) {
+ fprintf(stderr,"Unable to allocate buffer of %d bytes\n", len);
+ return FALSE;
+ }
+
+ while ((rcc = read(rfd, buf, len)) > 0) {
+ if (intflag) {
+ close(rfd);
+ close(wfd);
+ free(buf);
+ return FALSE;
+ }
+
+ bp = buf;
+ while (rcc > 0) {
+ wcc = write(wfd, bp, rcc);
+ if (wcc < 0) {
+ perror(destname);
+ free(buf);
+ goto error_exit;
+ }
+ bp += wcc;
+ rcc -= wcc;
+ }
+ }
+
+ free(buf);
+
+ if (rcc < 0) {
+ perror(srcname);
+ goto error_exit;
+ }
+
+ close(rfd);
+ if (close(wfd) < 0) {
+ perror(destname);
+ return FALSE;
+ }
+
+ if (setmodes) {
+ (void) chmod(destname, statbuf1.st_mode);
+
+ (void) chown(destname, statbuf1.st_uid, statbuf1.st_gid);
+
+ times.actime = statbuf1.st_atime;
+ times.modtime = statbuf1.st_mtime;
+
+ (void) utime(destname, &times);
+ }
+
+ return TRUE;
+
+
+error_exit:
+ close(rfd);
+ close(wfd);
+
+ return FALSE;
+}
+
+#endif
+
+#ifdef L_buildname
+
+/*
+ * Build a path name from the specified directory name and file name.
+ * If the directory name is NULL, then the original filename is returned.
+ * The built path is in a static area, and is overwritten for each call.
+ */
+char *
+buildname(dirname, filename)
+ char *dirname;
+ char *filename;
+{
+ char *cp;
+ static char buf[PATHLEN];
+
+ if ((dirname == NULL) || (*dirname == '\0'))
+ return filename;
+
+ cp = strrchr(filename, '/');
+ if (cp)
+ filename = cp + 1;
+
+ strcpy(buf, dirname);
+ strcat(buf, "/");
+ strcat(buf, filename);
+
+ return buf;
+}
+
+#endif
+
+#ifdef L_expandwildcards
+
+/*
+ * Expand the wildcards in a filename, if any.
+ * Returns an argument list with matching filenames in sorted order.
+ * The expanded names are stored in memory chunks which can later all
+ * be freed at once. Returns zero if the name is not a wildcard, or
+ * returns the count of matched files if the name is a wildcard and
+ * there was at least one match, or returns -1 if too many filenames
+ * matched (with an error output).
+ * If the name is a wildcard and no names match, returns 0 as
+ * if the name were not a wildcard.
+ */
+int
+expandwildcards(name, maxargc, retargv)
+ char *name;
+ int maxargc;
+ char *retargv[];
+{
+ char *last;
+ char *cp1, *cp2, *cp3;
+ DIR *dirp;
+ struct dirent *dp;
+ int dirlen;
+ int matches;
+ char dirname[PATHLEN];
+
+ last = strrchr(name, '/');
+ if (last)
+ last++;
+ else
+ last = name;
+
+ cp1 = strchr(name, '*');
+ cp2 = strchr(name, '?');
+ cp3 = strchr(name, '[');
+
+ if ((cp1 == NULL) && (cp2 == NULL) && (cp3 == NULL))
+ return 0;
+
+ if ((cp1 && (cp1 < last)) || (cp2 && (cp2 < last)) ||
+ (cp3 && (cp3 < last)))
+ {
+ fprintf(stderr, "Wildcards only implemented for last filename component\n");
+ return -1;
+ }
+
+ dirname[0] = '.';
+ dirname[1] = '\0';
+
+ if (last != name) {
+ memcpy(dirname, name, last - name);
+ dirname[last - name - 1] = '\0';
+ if (dirname[0] == '\0') {
+ dirname[0] = '/';
+ dirname[1] = '\0';
+ }
+ }
+
+ dirp = opendir(dirname);
+ if (dirp == NULL) {
+ perror(dirname);
+ return -1;
+ }
+
+ dirlen = strlen(dirname);
+ if (last == name) {
+ dirlen = 0;
+ dirname[0] = '\0';
+ } else if (dirname[dirlen - 1] != '/') {
+ dirname[dirlen++] = '/';
+ dirname[dirlen] = '\0';
+ }
+
+ matches = 0;
+
+ while ((dp = readdir(dirp)) != NULL) {
+ if ((strcmp(dp->d_name, ".") == 0) ||
+ (strcmp(dp->d_name, "..") == 0))
+ continue;
+
+ if (!match(dp->d_name, last))
+ continue;
+
+ if (matches >= maxargc) {
+ fprintf(stderr, "Too many filename matches\n");
+ closedir(dirp);
+ return -1;
+ }
+
+ cp1 = getchunk(dirlen + strlen(dp->d_name) + 1);
+ if (cp1 == NULL) {
+ fprintf(stderr, "No memory for filename\n");
+ closedir(dirp);
+ return -1;
+ }
+
+ if (dirlen)
+ memcpy(cp1, dirname, dirlen);
+ strcpy(cp1 + dirlen, dp->d_name);
+
+ retargv[matches++] = cp1;
+ }
+
+ closedir(dirp);
+
+ if (matches == 0) {
+ return 0;
+ }
+
+ qsort((char *) retargv, matches, sizeof(char *), namesort);
+
+ return matches;
+}
+
+#endif
+
+#ifdef L_namesort
+
+/*
+ * Sort routine for list of filenames.
+ */
+int
+namesort(p1, p2)
+ char **p1;
+ char **p2;
+{
+ return strcmp(*p1, *p2);
+}
+
+#endif
+
+#ifdef L_match
+
+/*
+ * Routine to see if a text string is matched by a wildcard pattern.
+ * Returns TRUE if the text is matched, or FALSE if it is not matched
+ * or if the pattern is invalid.
+ * * matches zero or more characters
+ * ? matches a single character
+ * [abc] matches 'a', 'b' or 'c'
+ * \c quotes character c
+ * Adapted from code written by Ingo Wilken.
+ */
+BOOL
+match(text, pattern)
+ char *text;
+ char *pattern;
+{
+ return fnmatch(pattern, text, 0) == 0;
+}
+#endif
+
+#ifdef L_makeargs
+
+/*
+ * Take a command string, and break it up into an argc, argv list.
+ * The returned argument list and strings are in static memory, and so
+ * are overwritten on each call. The argument array is ended with an
+ * extra NULL pointer for convenience. Returns TRUE if successful,
+ * or FALSE on an error with a message already output.
+ *
+ * Note that leading quotes are *not* removed at this point, but
+ * trailing quotes are.
+ */
+BOOL
+makeargs(cmd, argcptr, argvptr)
+ char *cmd;
+ int *argcptr;
+ char ***argvptr;
+{
+ char *cp;
+ int argc;
+ static char strings[CMDLEN+1];
+ static char *argtable[MAXARGS+1];
+ static char quoted[MAXARGS+1];
+
+ /*
+ * Copy the command string and then break it apart
+ * into separate arguments.
+ */
+ strcpy(strings, cmd);
+ argc = 0;
+ cp = strings;
+
+ while (*cp) {
+ if (argc >= MAXARGS) {
+ fprintf(stderr, "Too many arguments\n");
+ return FALSE;
+ }
+
+ quoted[argc] = 0;
+ argtable[argc++] = cp;
+
+ while (*cp && !isblank(*cp)) {
+ if (*cp == '"' || *cp == '\'') {
+ char *sp = cp++;
+
+ while (*cp && *cp != *sp)
+ cp++;
+
+ if (*cp == *sp) {
+ /* Chop off the trailing quote, but leave the leading quote
+ * so that later processing will know the argument is quoted
+ */
+ *cp++ = 0;
+ }
+ } else
+ cp++;
+ }
+
+ while (isblank(*cp))
+ *cp++ = '\0';
+ }
+
+ argtable[argc] = NULL;
+
+ *argcptr = argc;
+ *argvptr = argtable;
+
+ return TRUE;
+}
+
+#endif
+
+#ifdef L_makestring
+
+/*
+ * Make a NULL-terminated string out of an argc, argv pair.
+ * Returns TRUE if successful, or FALSE if the string is too long,
+ * with an error message given. This does not handle spaces within
+ * arguments correctly.
+ */
+BOOL
+makestring(argc, argv, buf, buflen)
+ char **argv;
+ char *buf;
+{
+ int len;
+
+ while (argc-- > 0) {
+ len = strlen(*argv);
+ if (len >= buflen) {
+ fprintf(stderr, "Argument string too long\n");
+ return FALSE;
+ }
+
+ strcpy(buf, *argv++);
+
+ buf += len;
+ buflen -= len;
+
+ if (argc)
+ *buf++ = ' ';
+ buflen--;
+ }
+
+ *buf = '\0';
+
+ return TRUE;
+}
+
+#endif
+
+#ifdef L_chunks
+
+typedef struct chunk CHUNK;
+#define CHUNKINITSIZE 4
+struct chunk {
+ CHUNK *next;
+ char data[CHUNKINITSIZE]; /* actually of varying length */
+};
+
+
+static CHUNK * chunklist;
+
+
+/*
+ * Allocate a chunk of memory (like malloc).
+ * The difference, though, is that the memory allocated is put on a
+ * list of chunks which can be freed all at one time. You CAN NOT free
+ * an individual chunk.
+ */
+char *
+getchunk(size)
+{
+ CHUNK *chunk;
+
+ if (size < CHUNKINITSIZE)
+ size = CHUNKINITSIZE;
+
+ chunk = (CHUNK *) malloc(size + sizeof(CHUNK) - CHUNKINITSIZE);
+ if (chunk == NULL)
+ return NULL;
+
+ chunk->next = chunklist;
+ chunklist = chunk;
+
+ return chunk->data;
+}
+
+
+/*
+ * Free all chunks of memory that had been allocated since the last
+ * call to this routine.
+ */
+void
+freechunks()
+{
+ CHUNK *chunk;
+
+ while (chunklist) {
+ chunk = chunklist;
+ chunklist = chunk->next;
+ free((char *) chunk);
+ }
+}
+
+#endif
+
+
+#ifdef L_expandenvvar
+
+/* Expand environment variables
+ * Variable names must use a-z, A-Z, 0-9, or _
+ * Backslashes are also interpreted to preserve the literal value of the
+ * next character.
+ * Returns NULL if there is an error, otherwise returns a pointer
+ * to a static buffer containing the expand command line.
+ *
+ * Makes a lame attempt to not expand inside single quotes.
+ */
+char *
+expandenvvar(cmd)
+ char *cmd;
+{
+ static char newcmd[CMDLEN+1];
+ char* newp = newcmd;
+ int freelength = CMDLEN; /* Don't include final terminator */
+ char varname[CMDLEN+1];
+ char* varp;
+ char* value;
+ int valuelength;
+ int quoted = 0;
+
+ if (cmd == NULL) {
+ return NULL;
+ }
+
+ if (strlen(cmd) > freelength) {
+ fprintf(stderr, "Variable expansion too long\n");
+ return NULL;
+ }
+
+ while (*cmd) {
+ int copy = 1;
+
+ switch (*cmd) {
+ case '$':
+ if (!quoted) {
+ copy = 0;
+ cmd++;
+ varp = varname;
+ while (isalnum(*cmd) || (*cmd == '_') || (*cmd == '?')) {
+ *varp++ = *cmd++;
+ }
+ *varp = '\0';
+ if ((*varname) && (value = getenv(varname))) {
+ valuelength = strlen(value);
+ if (valuelength > freelength) {
+ fprintf(stderr, "Variable expansion too long\n");
+ return NULL;
+ }
+ strncpy(newp, value, valuelength);
+ newp += valuelength;
+ freelength -= valuelength;
+ }
+ }
+ break;
+
+ case '\'':
+ quoted = !quoted;
+ break;
+
+ case '\\':
+ cmd++;
+ break;
+ }
+
+ if (copy) {
+ if (freelength < 1) {
+ fprintf(stderr, "Variable expansion too long\n");
+ return NULL;
+ }
+ *newp++ = *cmd++;
+ freelength--;
+ }
+ }
+
+ *newp = '\0';
+
+ return newcmd;
+}
+
+#endif
+
+
+/* END CODE */
diff --git a/package/sash/src/ls.c b/package/sash/src/ls.c
new file mode 100644
index 000000000..9b337aeaa
--- /dev/null
+++ b/package/sash/src/ls.c
@@ -0,0 +1,311 @@
+/*
+ * Copyright (c) 1993 by David I. Bell
+ * Permission is granted to use, distribute, or modify this source,
+ * provided that this copyright notice remains intact.
+ *
+ * The "ls" built-in command.
+ */
+
+#include "sash.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/sysmacros.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+
+#define LISTSIZE 256
+
+#define COLWIDTH 20
+
+#ifdef S_ISLNK
+#define LSTAT lstat
+#else
+#define LSTAT stat
+#endif
+
+
+/*
+ * Flags for the LS command.
+ */
+#define LSF_LONG 0x01
+#define LSF_DIR 0x02
+#define LSF_INODE 0x04
+#define LSF_MULT 0x08
+#define LSF_ALL 0x10
+#define LSF_COMPACT 0x20
+
+
+static char **list;
+static int listsize;
+static int listused;
+static int linelen = 0;
+
+
+static void lsfile();
+
+
+void
+do_ls(argc, argv)
+ int argc;
+ char **argv;
+{
+ char *cp;
+ char *name;
+ int flags;
+ int i;
+ DIR *dirp;
+ BOOL endslash;
+ char **newlist;
+ struct dirent *dp;
+ char fullname[PATHLEN];
+ struct stat statbuf;
+ static char *def[2];
+
+ if (listsize == 0) {
+ list = (char **) malloc(LISTSIZE * sizeof(char *));
+ if (list == NULL) {
+ fprintf(stderr, "No memory for ls buffer\n");
+ return;
+ }
+ listsize = LISTSIZE;
+ }
+ listused = 0;
+
+ flags = 0;
+ if ((argc > 1) && (argv[1][0] == '-'))
+ {
+ argc--;
+ cp = *(++argv) + 1;
+
+ while (*cp) switch (*cp++) {
+ case 'l': flags |= LSF_LONG; break;
+ case 'd': flags |= LSF_DIR; break;
+ case 'i': flags |= LSF_INODE; break;
+ case 'a': flags |= LSF_ALL; break;
+ case 'C': flags |= LSF_COMPACT; break;
+ default:
+ fprintf(stderr, "Unknown option -%c\n", cp[-1]);
+ return;
+ }
+ }
+
+ if ((flags & LSF_COMPACT) && (flags & ~LSF_COMPACT)) {
+ fprintf(stderr, "Cannot do compact list with other options\n");
+ return;
+ }
+
+ if (argc <= 1) {
+ argc = 2;
+ argv = def;
+ argv[0] = "ls";
+ argv[1] = ".";
+ }
+
+ if (argc > 2)
+ flags |= LSF_MULT;
+
+ while (argc-- > 1) {
+ name = *(++argv);
+ endslash = (*name && (name[strlen(name) - 1] == '/'));
+
+ if (LSTAT(name, &statbuf) < 0) {
+ perror(name);
+ continue;
+ }
+
+ if ((flags & LSF_DIR) || (!S_ISDIR(statbuf.st_mode))) {
+ lsfile(name, &statbuf, flags);
+ continue;
+ }
+
+ /*
+ * Do all the files in a directory.
+ */
+ dirp = opendir(name);
+ if (dirp == NULL) {
+ perror(name);
+ continue;
+ }
+
+ if (flags & LSF_MULT)
+ printf("\n%s:\n", name);
+
+ while ((dp = readdir(dirp)) != NULL) {
+
+ if ((dp->d_name[0] == '.') && !(flags & LSF_ALL))
+ continue;
+
+ fullname[0] = '\0';
+
+ if ((*name != '.') || (name[1] != '\0')) {
+ strcpy(fullname, name);
+ if (!endslash)
+ strcat(fullname, "/");
+ }
+
+ strcat(fullname, dp->d_name);
+
+ if (listused >= listsize) {
+ newlist = malloc((sizeof(char **)) * (listsize + LISTSIZE));
+ if (newlist == NULL) {
+ fprintf(stderr, "No memory for ls buffer\n");
+ break;
+ }
+ memcpy(newlist, list, sizeof(char**) * listsize);
+ free(list);
+ listsize += LISTSIZE;
+ }
+
+ list[listused] = strdup(fullname);
+ if (list[listused] == NULL) {
+ fprintf(stderr, "No memory for filenames\n");
+ break;
+ }
+ listused++;
+ }
+
+ closedir(dirp);
+
+ /*
+ * Sort the files.
+ */
+ qsort((char *) list, listused, sizeof(char *), namesort);
+
+ /*
+ * Now finally list the filenames.
+ */
+ for (i = 0; i < listused; i++) {
+ name = list[i];
+
+ if (LSTAT(name, &statbuf) < 0) {
+ perror(name);
+ free(name);
+ continue;
+ }
+
+ cp = strrchr(name, '/');
+ if (cp)
+ cp++;
+ else
+ cp = name;
+
+ lsfile(cp, &statbuf, flags);
+
+ free(name);
+ }
+
+ listused = 0;
+ }
+
+ if (linelen)
+ fputc('\n', stdout);
+}
+
+
+/*
+ * Do an LS of a particular file name according to the flags.
+ */
+static void
+lsfile(name, statbuf, flags)
+ char *name;
+ struct stat *statbuf;
+{
+ char *cp;
+ struct passwd *pwd;
+ struct group *grp;
+ int len;
+ char buf[PATHLEN];
+ static char username[12];
+ static int userid;
+ static BOOL useridknown;
+ static char groupname[12];
+ static int groupid;
+ static BOOL groupidknown;
+
+ cp = buf;
+ *cp = '\0';
+
+ if (flags & LSF_INODE) {
+ sprintf(cp, "%5d ", statbuf->st_ino);
+ cp += strlen(cp);
+ }
+
+ if (flags & LSF_LONG) {
+ strcpy(cp, modestring(statbuf->st_mode));
+ cp += strlen(cp);
+
+ sprintf(cp, "%3d ", statbuf->st_nlink);
+ cp += strlen(cp);
+
+ if (!useridknown || (statbuf->st_uid != userid)) {
+ /*pwd = getpwuid(statbuf->st_uid);
+ if (pwd)
+ strcpy(username, pwd->pw_name);
+ else*/
+ sprintf(username, "%d", statbuf->st_uid);
+ userid = statbuf->st_uid;
+ useridknown = TRUE;
+ }
+
+ sprintf(cp, "%-8s ", username);
+ cp += strlen(cp);
+
+ if (!groupidknown || (statbuf->st_gid != groupid)) {
+ /*grp = getgrgid(statbuf->st_gid);
+ if (grp)
+ strcpy(groupname, grp->gr_name);
+ else*/
+ sprintf(groupname, "%d", statbuf->st_gid);
+ groupid = statbuf->st_gid;
+ groupidknown = TRUE;
+ }
+
+ sprintf(cp, "%-8s ", groupname);
+ cp += strlen(cp);
+
+ if (S_ISBLK(statbuf->st_mode) || S_ISCHR(statbuf->st_mode))
+ sprintf(cp, "%3d, %3d ", major(statbuf->st_rdev),
+ minor(statbuf->st_rdev));
+ else
+ sprintf(cp, "%8d ", statbuf->st_size);
+ cp += strlen(cp);
+
+ sprintf(cp, " %-12s ", timestring(statbuf->st_mtime));
+ }
+
+ fputs(buf, stdout);
+ fputs(name, stdout);
+
+#ifdef S_ISLNK
+ if ((flags & LSF_LONG) && S_ISLNK(statbuf->st_mode)) {
+ len = readlink(name, buf, PATHLEN - 1);
+ if (len >= 0) {
+ buf[len] = '\0';
+ printf(" -> %s", buf);
+ }
+ }
+#endif
+
+ if (flags & LSF_COMPACT) {
+ len = strlen(name);
+ if (len < COLWIDTH) {
+ for (; (len < COLWIDTH); len++)
+ fputc(' ', stdout);
+ linelen += COLWIDTH;
+ } else {
+ linelen = 80;
+ }
+
+ if (linelen >= 80) {
+ fputc('\n', stdout);
+ linelen = 0;
+ }
+ } else {
+ fputc('\n', stdout);
+ }
+}
+
+/* END CODE */
diff --git a/package/sash/src/ps.c b/package/sash/src/ps.c
new file mode 100644
index 000000000..ed4226cc9
--- /dev/null
+++ b/package/sash/src/ps.c
@@ -0,0 +1,317 @@
+/* ps.c:
+ *
+ * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>,
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include "sash.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+#include <linux/major.h>
+#ifdef __UC_LIBC_
+#include <linux/types.h>
+#endif
+#include <sys/time.h>
+#include <sys/param.h>
+#ifdef __UC_LIBC__
+#include <mathf.h>
+#endif
+
+char psbuf[256];
+char name[40];
+int pid, state;
+char statec;
+int ppid, pgrp, session;
+dev_t tty;
+char tty_name[10];
+
+char master[] = "pqrstuvwxyzabcde";
+
+#define MAJOR(x) ((x) >> 8)
+#define MINOR(x) ((x) & 0xff)
+
+int port_xlate[16] = {1, 3, 5, 7,9 ,11,13,15,
+ 2, 4, 6, 8,10,12,14,16};
+
+void dev_to_name(dev_t dev, char * ttyname)
+{
+ strcpy(ttyname, "");
+ if (MAJOR(dev) == 75)
+ sprintf(ttyname,"X%d", MINOR(dev));
+ else if (MAJOR(dev) == TTY_MAJOR)
+ sprintf(ttyname,"S%d", MINOR(dev)-64);
+ else if (MAJOR(dev) == PTY_SLAVE_MAJOR)
+ sprintf(ttyname,"%c%x", master[MINOR(dev) / 16], MINOR(dev) & 0xf);
+}
+
+void
+do_ps(argc, argv)
+ char **argv;
+{
+ int i;
+ int h;
+ int max;
+ FILE * f;
+ DIR * d;
+ unsigned long bytes, sbytes;
+ struct dirent * de;
+ char *ext;
+ int l;
+ time_t time_now;
+ long uptime_secs;
+ float idle_secs;
+ float seconds, start, total_time;
+ int utime, stime, start_time;
+ int pcpu;
+ /*extern int _vfprintf_fp_ref, _vfscanf_fp_ref;*/
+
+#if 0
+ fclose(stdin);
+#endif
+
+ printf(" PID PORT STAT SIZE SHARED %%CPU COMMAND\n"/*, _vfprintf_fp_ref, _vfscanf_fp_ref*/);
+
+ h = open("/proc/uptime", O_RDONLY);
+
+ if (h==-1) {
+ perror("Unable to open /proc/uptime\n");
+ return;
+ }
+
+ l = read(h, psbuf, 255);
+
+ close(h);
+
+
+ if (l<=0) {
+ perror("Unable to read uptime");
+ return;
+ }
+
+
+ psbuf[l] = '\0';
+ psbuf[255] = '\0';
+
+ ext = psbuf;
+
+
+ uptime_secs = atol(ext);
+
+
+ time_now = time(0);
+
+ d = opendir("/proc");
+ if (!d)
+ return;
+
+ while (de = readdir(d)) {
+
+
+ for(i=0;i<strlen(de->d_name);i++)
+ if (!isdigit(de->d_name[i]))
+ goto next;
+
+ sprintf(psbuf, "/proc/%s/stat", de->d_name);
+
+ h = open(psbuf, O_RDONLY);
+
+ if (h==-1)
+ continue;
+
+ l = read(h, psbuf, 255);
+ if (l<=0) {
+ perror("Unable to read status");
+ close(h);
+ continue;
+ }
+
+ psbuf[l] = '\0';
+ psbuf[255] = '\0';
+
+ ext = strrchr(psbuf, ')');
+ ext[0] = '\0';
+
+ statec = ext[2];
+
+ ext += 4;
+
+ ppid = atoi(ext);
+ ext = strchr(ext, ' ')+1;
+
+ pgrp = atoi(ext);
+ ext = strchr(ext, ' ')+1;
+
+ session = atoi(ext);
+ ext = strchr(ext, ' ')+1;
+
+ tty = atoi(ext);
+ ext = strchr(ext, ' ')+1;
+
+ //printf("1|%s\n", ext);
+ //tpgid
+ ext = strchr(ext, ' ')+1;
+
+ //printf("2|%s\n", ext);
+ //flags
+ ext = strchr(ext, ' ')+1;
+
+ //printf("3|%s\n", ext);
+ //min_flt
+ ext = strchr(ext, ' ')+1;
+
+ //printf("4|%s\n", ext);
+ //cmin_flt
+ ext = strchr(ext, ' ')+1;
+
+ //printf("5|%s\n", ext);
+ //maj_flt
+ ext = strchr(ext, ' ')+1;
+
+ //printf("6|%s\n", ext);
+ //cmaj_flt
+ ext = strchr(ext, ' ')+1;
+
+ //printf("7|%s\n", ext);
+ utime = atoi(ext);
+ ext = strchr(ext, ' ')+1;
+
+ //printf("8|%s\n", ext);
+ stime = atoi(ext);
+ ext = strchr(ext, ' ')+1;
+
+ //printf("9|%s\n", ext);
+ //cutime
+ ext = strchr(ext, ' ')+1;
+
+ //printf("10|%s\n", ext);
+ //cstime
+ ext = strchr(ext, ' ')+1;
+
+ //priority
+ ext = strchr(ext, ' ')+1;
+
+ //nice
+ ext = strchr(ext, ' ')+1;
+
+ //timeout
+ ext = strchr(ext, ' ')+1;
+
+ //it_real_value
+ ext = strchr(ext, ' ')+1;
+
+ start_time = atoi(ext);
+
+ ext = strchr(psbuf, '(');
+ ext++;
+ strcpy(name, ext);
+
+ pid = atoi(psbuf);
+
+
+ state = statec;
+
+ close(h);
+
+ dev_to_name(tty, tty_name);
+
+ bytes = 0;
+ sbytes = 0;
+ sprintf(psbuf, "/proc/%s/status", de->d_name);
+
+ f = fopen(psbuf, "r");
+
+ if (f) {
+ while (fgets(psbuf, 250, f)) {
+ if (strncmp(psbuf, "Mem:", 4) == 0) {
+ bytes = atol(psbuf+5);
+ bytes /= 1024;
+ } else if (strncmp(psbuf, "Shared:", 7) == 0) {
+ sbytes = atol(psbuf+8);
+ sbytes /= 1024;
+ } else if (strncmp(psbuf, "VmSize:", 7) == 0) {
+ bytes = atol(psbuf+8);
+ }
+ }
+ fclose(f);
+ }
+
+
+ seconds = ((uptime_secs * (long)HZ) - start_time) / HZ;
+
+ /*printf("seconds=%s\n", gcvt(seconds, 15, psbuf));*/
+
+ start = time_now - seconds;
+
+ /*
+ printf("1\n");
+
+ gcvt(start, 15, psbuf);
+
+ printf("2\n");
+
+ printf("start=%s\n", psbuf);
+
+ printf("utime=%d, stime=%d. start_time=%d\n", utime, stime, start_time);
+ */
+
+ total_time = (utime + stime);
+
+ /*printf("total_time=%s\n", gcvt(total_time, 15, psbuf));*/
+
+ pcpu = seconds ?
+ (total_time * 10.0f * 100.0f / (float)HZ) / seconds :
+ 0;
+ if (pcpu > 999) pcpu = 999;
+
+
+ sprintf(psbuf, "/proc/%s/cmdline", de->d_name);
+ h = open(psbuf, O_RDONLY);
+
+ if (h == -1) {
+ perror("Unable to open cmdline");
+ continue;
+ }
+
+ l = read(h, psbuf, 255);
+ if (l < 0) {
+ perror("Unable to read cmdline");
+ close(h);
+ continue;
+ }
+
+ close(h);
+
+ /*
+ * the args are NUL separated, substitute spaces instead
+ */
+ psbuf[l] = '\0';
+ i=l;
+ while(psbuf[i] == '\0')
+ i--; /* Don't bother with trailing NULs */
+ while(--i > 0)
+ if (psbuf[i] == '\0')
+ psbuf[i] = ' ';
+
+ printf("%5d %4s %c %4ldK %3ldK %2u.%u %s\n", pid, tty_name, state,
+ bytes, sbytes,
+ pcpu / 10, pcpu % 10,
+ /*(int)seconds / 60, (int)seconds % 60,*/
+ l ? psbuf : name);
+ next:
+ ;
+ }
+
+ closedir(d);
+}
+
diff --git a/package/sash/src/reboot.c b/package/sash/src/reboot.c
new file mode 100644
index 000000000..8342ec992
--- /dev/null
+++ b/package/sash/src/reboot.c
@@ -0,0 +1,93 @@
+/* shutdown.c:
+ *
+ * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>,
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * JUN/99 -- copied from shutdown.c to make new reboot command.
+ * (gerg@snapgear.com)
+ * AUG/99 -- added delay option to reboot
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include <getopt.h>
+
+#if __GNU_LIBRARY__ > 5
+#include <sys/reboot.h>
+#endif
+
+int main(int argc, char *argv[])
+{
+ int delay = 0; /* delay in seconds before rebooting */
+ int rc;
+ int force = 0;
+
+ while ((rc = getopt(argc, argv, "h?d:f")) > 0) {
+ switch (rc) {
+ case 'd':
+ delay = atoi(optarg);
+ break;
+ case 'f':
+ force = 1;
+ break;
+ case 'h':
+ case '?':
+ default:
+ printf("usage: reboot [-h] [-d <delay>] [-f]\n");
+ exit(0);
+ break;
+ }
+ }
+
+ if(delay > 0)
+ sleep(delay);
+#ifdef CONFIG_DISKtel
+ printf("unmounting /home\n");
+ if(umount("/home") != 0){
+ printf("unmounting failed!!!\n");
+ }
+#endif
+
+#ifdef CONFIG_USER_FLATFSD_FLATFSD
+ if (!force) {
+ /* Ask flatfsd to reboot us safely */
+ execlp("flatfsd", "flatfsd", "-b", NULL);
+ /* if this returns, then force a reboot */
+ }
+#endif
+
+ kill(1, SIGTSTP);
+ sync();
+ signal(SIGTERM,SIG_IGN);
+ signal(SIGHUP,SIG_IGN);
+ setpgrp();
+ kill(-1, SIGTERM);
+ sleep(1);
+ kill(-1, SIGHUP);
+ sleep(1);
+ sync();
+ sleep(1);
+#if __GNU_LIBRARY__ > 5
+ reboot(0x01234567);
+#else
+ reboot(0xfee1dead, 672274793, 0x01234567);
+#endif
+ exit(0); /* Shrug */
+}
+
diff --git a/package/sash/src/sash.c b/package/sash/src/sash.c
new file mode 100644
index 000000000..24fbddbf7
--- /dev/null
+++ b/package/sash/src/sash.c
@@ -0,0 +1,1118 @@
+/*
+ * Copyright (c) 1993 by David I. Bell
+ * Permission is granted to use, distribute, or modify this source,
+ * provided that this copyright notice remains intact.
+ *
+ * Stand-alone shell for system maintainance for Linux.
+ * This program should NOT be built using shared libraries.
+ *
+ * 1.1.1, hacked to re-allow cmd line invocation of script file
+ * Pat Adamo, padamo@unix.asb.com
+ */
+
+#include "sash.h"
+
+#ifndef CMD_HELP
+#define CMD_HELP
+#endif
+#undef INTERNAL_PATH_EXPANSION
+#define FAVOUR_EXTERNAL_COMMANDS
+
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+
+static char version[] = "1.1.1";
+
+extern int intflag;
+
+extern void do_test();
+
+typedef struct {
+ char name[10];
+ char usage[30];
+ void (*func)();
+ int minargs;
+ int maxargs;
+} CMDTAB;
+
+
+CMDTAB cmdtab[] = {
+/*
+ "alias", "[name [command]]", do_alias,
+ 1, MAXARGS,
+*/
+ "cd", "[dirname]", do_cd,
+ 1, 2,
+
+ "sleep", "seconds", do_sleep,
+ 1, 2,
+
+ "chgrp", "gid filename ...", do_chgrp,
+ 3, MAXARGS,
+
+ "chmod", "mode filename ...", do_chmod,
+ 3, MAXARGS,
+
+ "chown", "uid filename ...", do_chown,
+ 3, MAXARGS,
+
+ "cmp", "filename1 filename2", do_cmp,
+ 3, 3,
+
+ "cp", "srcname ... destname", do_cp,
+ 3, MAXARGS,
+
+/*
+ "dd", "if=name of=name [bs=n] [count=n] [skip=n] [seek=n]", do_dd,
+ 3, MAXARGS,
+*/
+ "df", "[file-system]", do_df,
+ 1, 2,
+
+ "echo", "[args] ...", do_echo,
+ 1, MAXARGS,
+
+/*
+ "ed", "[filename]", do_ed,
+ 1, 2,
+*/
+
+ "exec", "filename [args]", do_exec,
+ 2, MAXARGS,
+
+ "exit", "", do_exit,
+ 1, 1,
+
+ "free", "", do_free,
+ 1, 1,
+
+/*
+ "-grep", "[-in] word filename ...", do_grep,
+ 3, MAXARGS,
+*/
+
+#ifdef CMD_HELP
+ "help", "", do_help,
+ 1, MAXARGS,
+#endif
+
+ "hexdump", "[-s pos] filename", do_hexdump,
+ 1, 4,
+
+ "hostname", "[hostname]", do_hostname,
+ 1, 2,
+
+ "kill", "[-sig] pid ...", do_kill,
+ 2, MAXARGS,
+
+ "ln", "[-s] srcname ... destname", do_ln,
+ 3, MAXARGS,
+
+ "ls", "[-lidC] filename ...", do_ls,
+ 1, MAXARGS,
+
+ "mkdir", "dirname ...", do_mkdir,
+ 2, MAXARGS,
+
+ "mknod", "filename type major minor", do_mknod,
+ 5, 5,
+
+ "more", "filename ...", do_more,
+ 2, MAXARGS,
+
+ "mount", "[-t type] devname dirname", do_mount,
+ 3, MAXARGS,
+
+ "mv", "srcname ... destname", do_mv,
+ 3, MAXARGS,
+
+ "printenv", "[name]", do_printenv,
+ 1, 2,
+
+ "pwd", "", do_pwd,
+ 1, 1,
+
+ "pid", "", do_pid,
+ 1, 1,
+
+ "quit", "", do_exit,
+ 1, 1,
+
+ "rm", "filename ...", do_rm,
+ 2, MAXARGS,
+
+ "rmdir", "dirname ...", do_rmdir,
+ 2, MAXARGS,
+
+ "setenv", "name value", do_setenv,
+ 3, 3,
+
+ "source", "filename", do_source,
+ 2, 2,
+
+ "sync", "", do_sync,
+ 1, 1,
+
+/* "time", "", do_time,
+ 1, 1,
+*/
+/*
+ "tar", "[xtv]f devname filename ...", do_tar,
+ 2, MAXARGS,
+*/
+ "touch", "filename ...", do_touch,
+ 2, MAXARGS,
+
+ "umask", "[mask]", do_umask,
+ 1, 2,
+
+ "umount", "filename", do_umount,
+ 2, 2,
+
+/*
+ "unalias", "name", do_unalias,
+ 2, 2,
+*/
+#ifdef CONFIG_USER_SASH_PS
+ "ps", "", do_ps,
+ 1, MAXARGS,
+#endif
+
+/* "reboot", "", do_reboot,
+ 1, MAXARGS,
+*/
+ "cat", "filename ...", do_cat,
+ 2, MAXARGS,
+
+ "date", "date [MMDDhhmm[YYYY]]", do_date,
+ 1, 2,
+
+ 0, 0, 0,
+ 0, 0
+};
+
+
+typedef struct {
+ char *name;
+ char *value;
+} ALIAS;
+
+
+static ALIAS *aliastable;
+static int aliascount;
+
+static FILE *sourcefiles[MAXSOURCE];
+static int sourcecount;
+
+volatile static BOOL intcrlf = TRUE;
+
+
+static void catchint();
+static void catchquit();
+static void catchchild();
+static void readfile();
+static void command();
+#ifdef COMMAND_HISTORY
+#define do_command(c,h) command(c,h)
+#else
+#define do_command(c,h) command(c)
+#endif
+static void runcmd();
+static void showprompt();
+static BOOL trybuiltin();
+static BOOL command_in_path();
+static ALIAS *findalias();
+
+extern char ** environ;
+
+/*
+char text1[] = "Text";
+char * text2 = text1;
+char ** text3 = &text2;
+*/
+
+char buf[CMDLEN];
+int exit_code = 0;
+
+main(argc, argv, env)
+ char **argv;
+ char *env[];
+{
+ struct sigaction act;
+ char *cp;
+/* char buf[PATHLEN];*/
+ int dofile = 0;
+
+ if ((argc > 1) && !strcmp(argv[1], "-c")) {
+ /* We are that fancy a shell */
+ buf[0] = '\0';
+ for (dofile = 2; dofile < argc; dofile++) {
+ strncat(buf, argv[dofile], sizeof(buf));
+ if (dofile + 1 < argc)
+ strncat(buf, " ", sizeof(buf));
+ }
+ do_command(buf, FALSE);
+ exit(exit_code);
+ }
+
+ //;'pa990523 +
+ if ((argc > 1) && strcmp(argv[1], "-t"))
+ {
+ dofile++;
+ printf("Shell invoked to run file: %s\n",argv[1]);
+ }
+ else
+ printf("\nSash command shell (version %s)\n", version);
+ fflush(stdout);
+
+ signal(SIGINT, catchint);
+ signal(SIGQUIT, catchquit);
+
+ memset(&act, 0, sizeof(act));
+ act.sa_handler = catchchild;
+ act.sa_flags = SA_RESTART;
+ sigaction(SIGCHLD, &act, NULL);
+
+ if (getenv("PATH") == NULL)
+ putenv("PATH=/bin:/usr/bin:/etc:/sbin:/usr/sbin");
+
+/* cp = getenv("HOME");
+ if (cp) {
+ strcpy(buf, cp);
+ strcat(buf, "/");
+ strcat(buf, ".aliasrc");
+
+ if ((access(buf, 0) == 0) || (errno != ENOENT))
+ readfile(buf);
+ }
+*/
+ //;'pa990523 -1/+
+ //readfile(NULL);
+ if (dofile)
+ {
+ //open the file for reading!
+ readfile(argv[1]);
+ }
+ else
+ {
+ readfile(NULL); //no arguments!
+ } //end if arguments supplied
+ exit(exit_code);
+}
+
+
+/*
+ * Read commands from the specified file.
+ * A null name pointer indicates to read from stdin.
+ */
+static void
+readfile(name)
+ char *name;
+{
+ FILE *fp;
+ int cc;
+ BOOL ttyflag;
+ char *ptr;
+
+ if (sourcecount >= MAXSOURCE) {
+ fprintf(stderr, "Too many source files\n");
+ return;
+ }
+
+ fp = stdin;
+ if (name) {
+ fp = fopen(name, "r");
+ if (fp == NULL) {
+ perror(name);
+ return;
+ }
+ }
+ sourcefiles[sourcecount++] = fp;
+
+ ttyflag = isatty(fileno(fp));
+
+ while (TRUE) {
+ fflush(stdout);
+ //;'pa990523 -1/+1
+ //if (1)
+ if (fp == stdin) //using terminal, so show prompt
+ showprompt();
+
+ if (intflag && !ttyflag && (fp != stdin)) {
+ fclose(fp);
+ sourcecount--;
+ return;
+ }
+
+ if (fgets(buf, CMDLEN - 1, fp) == NULL) {
+ if (ferror(fp) && (errno == EINTR)) {
+ clearerr(fp);
+ continue;
+ }
+ break;
+ }
+
+ cc = strlen(buf);
+
+ while ((cc > 0) && isspace(buf[cc - 1]))
+ cc--;
+ buf[cc] = '\0';
+ /* remove leading spaces and look for a '#' */
+ ptr = &buf[0];
+ while (*ptr == ' ') {
+ ptr++;
+ }
+ if (*ptr != '#') {
+ //;'pa990523 +
+ if (fp != stdin) {
+ //taking commands from file - echo
+ printf("Command: %s\n",buf);
+ } //end if (fp != stdin)
+
+ do_command(buf, fp == stdin);
+ }
+ }
+
+
+
+ if (ferror(fp)) {
+ perror("Reading command line");
+ if (fp == stdin)
+ exit(1);
+ }
+
+ clearerr(fp);
+ if (fp != stdin)
+ {//;'pa990523 added braces and printf
+ fclose(fp);
+ printf("Execution Finished, Exiting\n");
+ } //end if (fp != stdin)
+
+ sourcecount--;
+}
+
+
+/*
+ * Parse and execute one null-terminated command line string.
+ * This breaks the command line up into words, checks to see if the
+ * command is an alias, and expands wildcards.
+ */
+static void
+#ifdef COMMAND_HISTORY
+command(cmd, do_history)
+ int do_history;
+#else
+command(cmd)
+#endif
+ char *cmd;
+{
+ ALIAS *alias;
+ char **argv;
+ int argc;
+ int bg;
+ char *c;
+
+ char last_exit_code[10];
+
+ sprintf(last_exit_code, "%d", exit_code);
+
+ intflag = FALSE;
+ exit_code = 0;
+
+ freechunks();
+
+ while (isblank(*cmd))
+ cmd++;
+
+#ifdef COMMAND_HISTORY
+ if (do_history) {
+ int i;
+ static char *history[HISTORY_SIZE];
+
+ if (*cmd == '!') {
+ if (cmd[1] == '!')
+ i = 0;
+ else {
+ i = atoi(cmd+1) - 1;
+ if (i < 0 || i >= HISTORY_SIZE) {
+ printf("%s: Out of range\n", cmd);
+ return;
+ }
+ }
+ if (history[i] == NULL) {
+ printf("%s: Null entry\n", cmd);
+ return;
+ }
+ strcpy(cmd, history[i]);
+ } else if (*cmd == 'h' && cmd[1] == '\0') {
+ for (i=0; i<HISTORY_SIZE; i++) {
+ if (history[i] != NULL)
+ printf("%2d: %s\n", i+1, history[i]);
+ }
+ return;
+ } else if (*cmd != '\0') {
+ if (history[HISTORY_SIZE-1] != NULL)
+ free(history[HISTORY_SIZE-1]);
+ for (i=HISTORY_SIZE-1; i>0; i--)
+ history[i] = history[i-1];
+ history[0] = strdup(cmd);
+ }
+ }
+#endif
+ if (c = strchr(cmd, '&')) {
+ *c = '\0';
+ bg = 1;
+ } else
+ bg = 0;
+
+ /* Set the last exit code */
+ setenv("?", last_exit_code, 1);
+
+ if ((cmd = expandenvvar(cmd)) == NULL)
+ return;
+
+ if ((*cmd == '\0') || !makeargs(cmd, &argc, &argv))
+ return;
+
+ /*
+ * Search for the command in the alias table.
+ * If it is found, then replace the command name with
+ * the alias, and append any other arguments to it.
+ */
+ alias = findalias(argv[0]);
+ if (alias) {
+ cmd = buf;
+ strcpy(cmd, alias->value);
+
+ while (--argc > 0) {
+ strcat(cmd, " ");
+ strcat(cmd, *++argv);
+ }
+
+ if (!makeargs(cmd, &argc, &argv))
+ return;
+ }
+
+ /*
+ * BASH-style variable setting
+ */
+ if (argc == 1) {
+ c = index(argv[0], '=');
+ if (c > argv[0]) {
+ *c++ = '\0';
+ setenv(argv[0], c, 1);
+ return;
+ }
+ }
+
+ /*
+ * Now look for the command in the builtin table, and execute
+ * the command if found.
+ */
+#ifdef FAVOUR_EXTERNAL_COMMANDS
+ if (!command_in_path(argv[0]))
+#endif
+ if (trybuiltin(argc, argv))
+ return;
+
+ /*
+ * Not found, run the program along the PATH list.
+ */
+ runcmd(cmd, bg, argc, argv);
+}
+
+
+#ifdef FAVOUR_EXTERNAL_COMMANDS
+/*
+ * return true if we find this command in our
+ * path.
+ */
+static BOOL
+command_in_path(char *cmd)
+{
+ struct stat stat_buf;
+
+ if (strchr(cmd, '/') == 0) {
+ char * path;
+ static char path_copy[PATHLEN];
+
+ /* Search path for binary */
+ for (path = getenv("PATH"); path && *path; ) {
+ char * p2;
+
+ strcpy(path_copy, path);
+ if (p2 = strchr(path_copy, ':')) {
+ *p2 = '\0';
+ }
+
+ if (strlen(path_copy))
+ strcat(path_copy, "/");
+ strcat(path_copy, cmd);
+
+ if (!stat(path_copy, &stat_buf) && (stat_buf.st_mode & 0111))
+ return(TRUE);
+
+ p2 = strchr(path, ':');
+ if (p2)
+ path = p2 + 1;
+ else
+ path = 0;
+ }
+ } else if (!stat(cmd, &stat_buf) && (stat_buf.st_mode & 0111))
+ return(TRUE);
+ return(FALSE);
+}
+#endif /* FAVOUR_EXTERNAL_COMMANDS */
+
+
+/*
+ * Try to execute a built-in command.
+ * Returns TRUE if the command is a built in, whether or not the
+ * command succeeds. Returns FALSE if this is not a built-in command.
+ */
+static BOOL
+trybuiltin(argc, argv)
+ char **argv;
+{
+ CMDTAB *cmdptr;
+ int oac;
+ int newargc;
+ int matches;
+ int i;
+ char *newargv[MAXARGS];
+ char *nametable[MAXARGS];
+
+ cmdptr = cmdtab - 1;
+ do {
+ cmdptr++;
+ if (cmdptr->name[0] == 0)
+ return FALSE;
+
+ } while (strcmp(argv[0], cmdptr->name));
+
+ /*
+ * Give a usage string if the number of arguments is too large
+ * or too small.
+ */
+ if ((argc < cmdptr->minargs) || (argc > cmdptr->maxargs)) {
+ fprintf(stderr, "usage: %s %s\n",
+ cmdptr->name, cmdptr->usage);
+ fflush(stderr);
+
+ return TRUE;
+ }
+
+ /*
+ * Check here for several special commands which do not
+ * have wildcarding done for them.
+ */
+
+/* if (cmdptr->func == do_prompt) {
+ (*cmdptr->func)(argc, argv);
+ return TRUE;
+ }
+*/
+
+ /*
+ * Now for each command argument, see if it is a wildcard, and if
+ * so, replace the argument with the list of matching filenames.
+ */
+ newargv[0] = argv[0];
+ newargc = 1;
+ oac = 0;
+
+ while (++oac < argc) {
+ if (argv[oac][0] == '"' || argv[oac][0] == '\'') {
+ argv[oac]++;
+ matches = 0;
+ }
+ else {
+ matches = expandwildcards(argv[oac], MAXARGS, nametable);
+ if (matches < 0)
+ return TRUE;
+ }
+
+ if ((newargc + matches) >= MAXARGS) {
+ fprintf(stderr, "Too many arguments\n");
+ return TRUE;
+ }
+
+ if (matches == 0)
+ newargv[newargc++] = argv[oac];
+
+ for (i = 0; i < matches; i++)
+ newargv[newargc++] = nametable[i];
+ }
+
+ (*cmdptr->func)(newargc, newargv);
+
+ return TRUE;
+}
+
+
+/*
+ * Execute the specified command.
+ */
+static void
+runcmd(cmd, bg, argc, argv)
+ char *cmd;
+ int bg;
+ int argc;
+ char **argv;
+{
+ register char * cp;
+ BOOL magic;
+ int pid;
+ int status;
+ int oac;
+ int newargc;
+ int matches;
+ int i;
+ char *newargv[MAXARGS];
+ char *nametable[MAXARGS];
+ struct sigaction act;
+
+ newargv[0] = argv[0];
+
+#ifdef INTERNAL_PATH_EXPANSION
+ if (strchr(argv[0], '/') == 0) {
+ char * path;
+ struct stat stat_buf;
+ static char path_copy[PATHLEN];
+
+ /* Search path for binary */
+ for (path = getenv("PATH"); path && *path; ) {
+ char * p2;
+ strncpy(path_copy, path, sizeof(path_copy - 1));
+ if (p2 = strchr(path_copy, ':')) {
+ *p2 = '\0';
+ }
+
+ if (strlen(path_copy))
+ strncat(path_copy, "/", sizeof(path_copy));
+ strncat(path_copy, argv[0], sizeof(path_copy));
+
+ if (!stat(path_copy, &stat_buf) && (stat_buf.st_mode & 0111)) {
+ newargv[0] = path_copy;
+ break;
+ }
+
+ p2 = strchr(path, ':');
+ if (p2)
+ path = p2 + 1;
+ else
+ path = 0;
+ }
+ }
+#endif
+
+ /*
+ * Now for each command argument, see if it is a wildcard, and if
+ * so, replace the argument with the list of matching filenames.
+ */
+ newargc = 1;
+ oac = 0;
+
+ while (++oac < argc) {
+ if (argv[oac][0] == '"' || argv[oac][0] == '\'') {
+ argv[oac]++;
+ matches = 0;
+ }
+ else {
+ matches = expandwildcards(argv[oac], MAXARGS, nametable);
+ if (matches < 0)
+ return;
+ }
+
+ if ((newargc + matches) >= MAXARGS) {
+ fprintf(stderr, "Too many arguments\n");
+ return;
+ }
+
+ if (matches == 0)
+ newargv[newargc++] = argv[oac];
+
+ for (i = 0; i < matches; i++)
+ newargv[newargc++] = nametable[i];
+ }
+
+ newargv[newargc] = 0;
+
+ magic = FALSE;
+
+ /*
+ for (cp = cmd; *cp; cp++) {
+ if ((*cp >= 'a') && (*cp <= 'z'))
+ continue;
+ if ((*cp >= 'A') && (*cp <= 'Z'))
+ continue;
+ if (isdecimal(*cp))
+ continue;
+ if (isblank(*cp))
+ continue;
+
+ if ((*cp == '.') || (*cp == '/') || (*cp == '-') ||
+ (*cp == '+') || (*cp == '=') || (*cp == '_') ||
+ (*cp == ':') || (*cp == ','))
+ continue;
+
+ magic = TRUE;
+ }
+ */
+
+ if (magic) {
+ printf("%s: no such file or directory\n", cmd);
+ system(cmd);
+ return;
+ }
+
+ if (!bg)
+ signal(SIGCHLD, SIG_DFL);
+
+ /*
+ * No magic characters in the expanded command, so do the fork and
+ * exec ourself. If this fails with ENOEXEC, then run the
+ * shell anyway since it might be a shell script.
+ */
+ if (!(pid = vfork())) {
+ int ci;
+
+ /*
+ * We are the child, so run the program.
+ * First close any extra file descriptors we have opened.
+ * be sure not to modify any globals after the vfork !
+ */
+
+ for (ci = 0; ci < sourcecount; ci++)
+ if (sourcefiles[ci] != stdin)
+ close(fileno(sourcefiles[ci]));
+
+ signal(SIGINT, SIG_DFL);
+ signal(SIGQUIT, SIG_DFL);
+ signal(SIGCHLD, SIG_DFL);
+
+ execvp(newargv[0], newargv);
+
+ printf("%s: %s\n", newargv[0], (errno == ENOENT) ? "Bad command or file name" : strerror(errno));
+
+ _exit(0);
+ }
+
+ if (pid < 0) {
+ memset(&act, 0, sizeof(act));
+ act.sa_handler = catchchild;
+ act.sa_flags = SA_RESTART;
+ sigaction(SIGCHLD, &act, NULL);
+
+ perror("vfork failed");
+ return;
+ }
+
+ if (bg) {
+ printf("[%d]\n", pid);
+ return;
+ }
+
+ if (pid) {
+ int cpid;
+ status = 0;
+ intcrlf = FALSE;
+
+ for (;;) {
+ cpid = wait4(pid, &status, 0, 0);
+ if ((cpid < 0) && (errno == EINTR))
+ continue;
+ if (cpid < 0)
+ break;
+ if (cpid != pid) {
+ fprintf(stderr, "sh %d: child %d died\n", getpid(), cpid);
+ continue;
+ }
+ }
+
+ act.sa_handler = catchchild;
+ memset(&act.sa_mask, 0, sizeof(act.sa_mask));
+ act.sa_flags = SA_RESTART;
+ sigaction(SIGCHLD, &act, NULL);
+
+ intcrlf = TRUE;
+
+ if (WIFEXITED(status)) {
+ if (WEXITSTATUS(status) == 0)
+ return;
+ exit_code = WEXITSTATUS(status);
+ } else
+ exit_code = 1;
+
+ return;
+ }
+
+ perror(argv[0]);
+ exit(1);
+}
+
+#ifdef CMD_HELP
+void
+do_help(argc, argv)
+ char **argv;
+{
+ CMDTAB *cmdptr;
+
+ for (cmdptr = cmdtab; cmdptr->name && cmdptr->name[0]; cmdptr++)
+ printf("%-10s %s\n", cmdptr->name, cmdptr->usage);
+}
+#endif /* CMD_HELP */
+
+#ifdef CMD_ALIAS
+void
+do_alias(argc, argv)
+ char **argv;
+{
+ char *name;
+ char *value;
+ ALIAS *alias;
+ int count;
+ char buf[CMDLEN];
+
+ if (argc < 2) {
+ count = aliascount;
+ for (alias = aliastable; count-- > 0; alias++)
+ printf("%s\t%s\n", alias->name, alias->value);
+ return;
+ }
+
+ name = argv[1];
+ if (argc == 2) {
+ alias = findalias(name);
+ if (alias)
+ printf("%s\n", alias->value);
+ else
+ fprintf(stderr, "Alias \"%s\" is not defined\n", name);
+ return;
+ }
+
+ if (strcmp(name, "alias") == 0) {
+ fprintf(stderr, "Cannot alias \"alias\"\n");
+ return;
+ }
+
+ if (!makestring(argc - 2, argv + 2, buf, CMDLEN))
+ return;
+
+ value = malloc(strlen(buf) + 1);
+
+ if (value == NULL) {
+ fprintf(stderr, "No memory for alias value\n");
+ return;
+ }
+
+ strcpy(value, buf);
+
+ alias = findalias(name);
+ if (alias) {
+ free(alias->value);
+ alias->value = value;
+ return;
+ }
+
+ if ((aliascount % ALIASALLOC) == 0) {
+ count = aliascount + ALIASALLOC;
+
+ if (aliastable)
+ alias = (ALIAS *) realloc(aliastable,
+ sizeof(ALIAS *) * count);
+ else
+ alias = (ALIAS *) malloc(sizeof(ALIAS *) * count);
+
+ if (alias == NULL) {
+ free(value);
+ fprintf(stderr, "No memory for alias table\n");
+ return;
+ }
+
+ aliastable = alias;
+ }
+
+ alias = &aliastable[aliascount];
+
+ alias->name = malloc(strlen(name) + 1);
+
+ if (alias->name == NULL) {
+ free(value);
+ fprintf(stderr, "No memory for alias name\n");
+ return;
+ }
+
+ strcpy(alias->name, name);
+ alias->value = value;
+ aliascount++;
+}
+#endif /* CMD_ALIAS */
+
+/*
+ * Look up an alias name, and return a pointer to it.
+ * Returns NULL if the name does not exist.
+ */
+static ALIAS *
+findalias(name)
+ char *name;
+{
+ ALIAS *alias;
+ int count;
+
+ count = aliascount;
+ for (alias = aliastable; count-- > 0; alias++) {
+ if (strcmp(name, alias->name) == 0)
+ return alias;
+ }
+
+ return NULL;
+}
+
+
+void
+do_source(argc, argv)
+ char **argv;
+{
+ readfile(argv[1]);
+}
+
+/*void
+do_cd(argc, argv)
+ char **argv;
+{
+ char *name;
+
+ name = argv[1];
+
+ if (chdir(name))
+ perror("Unable to chdir to %s");
+
+}*/
+
+void
+do_pid(argc, argv)
+{
+ printf("%d\n", getpid());
+}
+
+void
+do_exec(argc, argv)
+ char **argv;
+{
+ while (--sourcecount >= 0) {
+ if (sourcefiles[sourcecount] != stdin)
+ fclose(sourcefiles[sourcecount]);
+ }
+
+ argv[argc] = NULL;
+ execvp(argv[1], &argv[1]);
+
+ perror(argv[1]);
+ exit(1);
+}
+
+/*void
+do_exit(argc, argv)
+ char **argv;
+{
+ if (argc>1)
+ exit(atoi(argv[1]));
+ else
+ exit(0);
+}*/
+
+
+#ifdef CMD_ALIAS
+void
+do_unalias(argc, argv)
+ char **argv;
+{
+ ALIAS *alias;
+
+ while (--argc > 0) {
+ alias = findalias(*++argv);
+ if (alias == NULL)
+ continue;
+
+ free(alias->name);
+ free(alias->value);
+ aliascount--;
+ alias->name = aliastable[aliascount].name;
+ alias->value = aliastable[aliascount].value;
+ }
+}
+#endif /* CMD_ALIAS */
+
+/*
+ * Display the prompt string.
+ */
+static void
+showprompt()
+{
+ char *cp;
+ //;'pa990523 changed from 6...
+ char buf[60];
+
+ if ((cp = getenv("PS1")) != NULL) {
+ printf("%s", cp);
+ }
+ else {
+ *buf = '\0';
+ getcwd(buf, sizeof(buf) - 1);
+ printf("%s> ", buf);
+ }
+ fflush(stdout);
+}
+
+
+static void
+catchint()
+{
+ signal(SIGINT, catchint);
+
+ intflag = TRUE;
+
+ if (intcrlf)
+ write(STDOUT, "\n", 1);
+}
+
+
+static void
+catchquit()
+{
+ signal(SIGQUIT, catchquit);
+
+ intflag = TRUE;
+
+ if (intcrlf)
+ write(STDOUT, "\n", 1);
+}
+
+static void
+catchchild()
+{
+ char buf[40];
+ pid_t pid;
+ int status;
+
+ /*signal(SIGCHLD, catchchild);*/ /* Unneeded */
+
+ pid = wait4(-1, &status, WUNTRACED, 0);
+ if (WIFSTOPPED(status))
+ sprintf(buf, "sh %d: Child %d stopped\n", getpid(), pid);
+ else
+ sprintf(buf, "sh %d: Child %d died\n", getpid(), pid);
+
+ if (intcrlf)
+ write(STDOUT, "\n", 1);
+
+ write(STDOUT, buf, strlen(buf));
+}
+
+/* END CODE */
diff --git a/package/sash/src/sash.h b/package/sash/src/sash.h
new file mode 100644
index 000000000..eb2321fa0
--- /dev/null
+++ b/package/sash/src/sash.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1993 by David I. Bell
+ * Permission is granted to use, distribute, or modify this source,
+ * provided that this copyright notice remains intact.
+ *
+ * Definitions for stand-alone shell for system maintainance for Linux.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <malloc.h>
+#include <ctype.h>
+
+#define PATHLEN 256
+#define CMDLEN 1024
+#define MAXARGS 50
+#define ALIASALLOC 20
+#define STDIN 0
+#define STDOUT 1
+#define MAXSOURCE 10
+#ifdef COMMAND_HISTORY
+#define HISTORY_SIZE 20 /* Number of entries in command history */
+#endif
+
+#ifndef isblank
+#define isblank(ch) (((ch) == ' ') || ((ch) == '\t'))
+#endif
+
+#define isquote(ch) (((ch) == '"') || ((ch) == '\''))
+#define isdecimal(ch) (((ch) >= '0') && ((ch) <= '9'))
+#define isoctal(ch) (((ch) >= '0') && ((ch) <= '7'))
+
+
+typedef int BOOL;
+
+#define FALSE ((BOOL) 0)
+#define TRUE ((BOOL) 1)
+
+
+extern void do_alias(), do_cd(), do_exec(), do_exit(), do_prompt();
+extern void do_source(), do_umask(), do_unalias(), do_help(), do_ln();
+extern void do_cp(), do_mv(), do_rm(), do_chmod(), do_mkdir(), do_rmdir();
+extern void do_mknod(), do_chown(), do_chgrp(), do_sync(), do_printenv();
+extern void do_more(), do_cmp(), do_touch(), do_ls(), do_dd(), do_tar();
+extern void do_mount(), do_umount(), do_setenv(), do_pwd(), do_echo();
+extern void do_kill(), do_grep(), do_ed(), do_hexdump(), do_pid();
+extern void do_df(), do_ps(), do_reboot(), do_cat(), do_time(), do_free();
+extern void do_hostname(), do_sleep();
+extern void do_date();
+
+
+extern char *buildname();
+extern char *modestring();
+extern char *timestring();
+extern BOOL isadir();
+extern BOOL copyfile();
+extern BOOL match();
+extern BOOL makestring();
+extern BOOL makeargs();
+extern int expandwildcards();
+extern int namesort();
+extern char *getchunk();
+extern void freechunks();
+extern char *expandenvvar();
+
+extern BOOL intflag;
+extern int exit_code;
+
+/* END CODE */
diff --git a/package/sash/src/shutdown.c b/package/sash/src/shutdown.c
new file mode 100644
index 000000000..444326483
--- /dev/null
+++ b/package/sash/src/shutdown.c
@@ -0,0 +1,75 @@
+/* shutdown.c:
+ *
+ * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>,
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include "sash.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include <pwd.h>
+#include <grp.h>
+#include <time.h>
+#include <signal.h>
+
+#if __GNU_LIBRARY__ > 5
+#include <sys/reboot.h>
+#endif
+
+int
+main(argc, argv)
+ int argc;
+ char **argv;
+{
+ char *progname = argv[0];
+
+ if (argc > 2 && strcmp(argv[1], "-d") == 0) {
+ sleep(atoi(argv[2]));
+ argc -= 2;
+ }
+ if ((argc != 3) || (strcmp(argv[1], "-h") && strcmp(argv[1], "-r")) || strcmp(argv[2], "now")) {
+ printf("Usage: %s [-d delay] -h|-r now\n", progname);
+ exit(0);
+ }
+
+ kill(1, SIGTSTP);
+ sync();
+ signal(SIGTERM,SIG_IGN);
+ setpgrp();
+ kill(-1, SIGTERM);
+ sleep(1);
+ kill(-1, SIGHUP); /* Force PPPD's down, too */
+ sleep(1);
+ kill(-1, SIGKILL);
+ sync();
+ sleep(1);
+
+ if (strcmp(argv[1], "-h")==0) {
+#if __GNU_LIBRARY__ > 5
+ reboot(0xCDEF0123);
+#else
+ reboot(0xfee1dead, 672274793, 0xCDEF0123);
+#endif
+ } else {
+#if __GNU_LIBRARY__ > 5
+ reboot(0x01234567);
+#else
+ reboot(0xfee1dead, 672274793, 0x01234567);
+#endif
+ }
+
+ exit(0); /* Shrug */
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-02 00:03:29 +0000