--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/openenvutils/commandshell/shell/src/modules/system.c Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,435 @@
+// sysread.c - interface to system read/write
+//
+// © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.
+//
+/*
+ * This file is part of zsh, the Z shell.
+ *
+ * Copyright (c) 1998-2003 Peter Stephenson
+ * All rights reserved.
+ *
+ * Permission is hereby granted, without written agreement and without
+ * license or royalty fees, to use, copy, modify, and distribute this
+ * software and to distribute modified versions of this software for any
+ * purpose, provided that the above copyright notice and the following
+ * two paragraphs appear in all copies of this software.
+ *
+ * In no event shall Peter Stephenson or the Zsh Development
+ * Group be liable to any party for direct, indirect, special, incidental,
+ * or consequential damages arising out of the use of this software and
+ * its documentation, even if Peter Stephenson, and the Zsh
+ * Development Group have been advised of the possibility of such damage.
+ *
+ * Peter Stephenson and the Zsh Development Group specifically
+ * disclaim any warranties, including, but not limited to, the implied
+ * warranties of merchantability and fitness for a particular purpose. The
+ * software provided hereunder is on an "as is" basis, and Peter Stephenson
+ * and the Zsh Development Group have no obligation to provide maintenance,
+ * support, updates, enhancements, or modifications.
+ *
+ */
+#include "system.mdh"
+#include "system.pro"
+
+#ifdef __SYMBIAN32__
+#include "dummy.h" //poll
+#endif //__SYMBIAN32__
+
+#ifdef HAVE_POLL_H
+#ifndef __SYMBIAN32__
+# include <sys/poll.h>
+#else
+#include "poll.h"
+#endif
+#endif
+#if defined(HAVE_POLL) && !defined(POLLIN)
+# undef HAVE_POLL
+#endif
+
+#ifdef __SYMBIAN32__
+#ifdef __WINSCW__
+#pragma warn_unusedarg off
+#endif//__WINSCW__
+#endif//__SYMBIAN32__
+
+#define SYSREAD_BUFSIZE 8192
+
+/**/
+static int
+getposint(char *instr, char *nam)
+{
+ char *eptr;
+ int ret;
+
+ ret = (int)zstrtol(instr, &eptr, 10);
+ if (*eptr || ret < 0) {
+ zwarnnam(nam, "integer expected: %s", instr, 0);
+ return -1;
+ }
+
+ return ret;
+}
+
+
+/*
+ * Return values of bin_sysread:
+ * 0 Successfully read (and written if appropriate)
+ * 1 Error in parameters to command
+ * 2 Error on read, or polling read fd ) ERRNO set by
+ * 3 Error on write ) system
+ * 4 Timeout on read
+ * 5 Zero bytes read, end of file
+ */
+
+/**/
+static int
+bin_sysread(char *nam, char **args, Options ops, UNUSED(int func))
+{
+ int infd = 0, outfd = -1, bufsize = SYSREAD_BUFSIZE, count;
+ char *outvar = NULL, *countvar = NULL, *inbuf;
+
+ /* -i: input file descriptor if not stdin */
+ if (OPT_ISSET(ops, 'i')) {
+ infd = getposint(OPT_ARG(ops, 'i'), nam);
+ if (infd < 0)
+ return 1;
+ }
+
+ /* -o: output file descriptor, else store in REPLY */
+ if (OPT_ISSET(ops, 'o')) {
+ if (*args) {
+ zwarnnam(nam, "no argument allowed with -o", NULL, 0);
+ return 1;
+ }
+ outfd = getposint(OPT_ARG(ops, 'o'), nam);
+ if (outfd < 0)
+ return 1;
+ }
+
+ /* -s: buffer size if not default SYSREAD_BUFSIZE */
+ if (OPT_ISSET(ops, 's')) {
+ bufsize = getposint(OPT_ARG(ops, 's'), nam);
+ if (bufsize < 0)
+ return 1;
+ }
+
+ /* -c: name of variable to store count of transferred bytes */
+ if (OPT_ISSET(ops, 'c')) {
+ countvar = OPT_ARG(ops, 'c');
+ if (!isident(countvar)) {
+ zwarnnam(nam, "not an identifier: %s", countvar, 0);
+ return 1;
+ }
+ }
+
+ if (*args) {
+ /*
+ * Variable in which to store result if doing a plain read.
+ * Default variable if not specified is REPLY.
+ * If writing, only stuff we couldn't write is stored here,
+ * no default in that case (we just discard it if no variable).
+ */
+ outvar = *args;
+ if (!isident(outvar)) {
+ zwarnnam(nam, "not an identifier: %s", outvar, 0);
+ return 1;
+ }
+ }
+
+ inbuf = zhalloc(bufsize);
+
+#if defined(HAVE_POLL) || defined(HAVE_SELECT)
+ /* -t: timeout */
+ if (OPT_ISSET(ops, 't'))
+ {
+# ifdef HAVE_POLL
+ struct pollfd poll_fd;
+ mnumber to_mn;
+ int to_int, ret;
+
+ poll_fd.fd = infd;
+ poll_fd.events = POLLIN;
+
+ to_mn = matheval(OPT_ARG(ops, 't'));
+ if (errflag)
+ return 1;
+ if (to_mn.type == MN_FLOAT)
+ to_int = (int) (1000 * to_mn.u.d);
+ else
+ to_int = 1000 * (int)to_mn.u.l;
+
+ while ((ret = poll(&poll_fd, 1, to_int)) < 0) {
+ if (errno != EINTR || errflag || retflag || breaks || contflag)
+ break;
+ }
+ if (ret <= 0) {
+ /* treat non-timeout error as error on read */
+ return ret ? 2 : 4;
+ }
+# else
+ /* using select */
+ struct timeval select_tv;
+ fd_set fds;
+ mnumber to_mn;
+ int ret;
+
+ FD_ZERO(&fds);
+ FD_SET(infd, &fds);
+ to_mn = matheval(OPT_ARG(ops, 't'));
+ if (errflag)
+ return 1;
+
+ if (to_mn.type == MN_FLOAT) {
+ select_tv.tv_sec = (int) to_mn.u.d;
+ select_tv.tv_usec =
+ (int) ((to_mn.u.d - select_tv.tv_sec) * 1e6);
+ } else {
+ select_tv.tv_sec = (int) to_mn.u.l;
+ select_tv.tv_usec = 0;
+ }
+
+ while ((ret = select(infd+1, (SELECT_ARG_2_T) &fds,
+ NULL, NULL,&select_tv)) < 1) {
+ if (errno != EINTR || errflag || retflag || breaks || contflag)
+ break;
+ }
+ if (ret <= 0) {
+ /* treat non-timeout error as error on read */
+ return ret ? 2 : 4;
+ }
+# endif
+ }
+#endif
+
+ while ((count = read(infd, inbuf, bufsize)) < 0) {
+ if (errno != EINTR || errflag || retflag || breaks || contflag)
+ break;
+ }
+ if (countvar)
+ setiparam(countvar, count);
+ if (count < 0)
+ return 2;
+
+ if (outfd >= 0) {
+ if (!count)
+ return 5;
+ while (count > 0) {
+ int ret;
+
+ ret = write(outfd, inbuf, count);
+ if (ret < 0) {
+ if (errno == EINTR && !errflag &&
+ !retflag && !breaks && !contflag)
+ continue;
+ if (outvar)
+ setsparam(outvar, metafy(inbuf, count, META_DUP));
+ if (countvar)
+ setiparam(countvar, count);
+ return 3;
+ }
+ inbuf += ret;
+ count -= ret;
+ }
+ return 0;
+ }
+
+ if (!outvar)
+ outvar = "REPLY";
+ /* do this even if we read zero bytes */
+ setsparam(outvar, metafy(inbuf, count, META_DUP));
+
+ return count ? 0 : 5;
+}
+
+
+/*
+ * Return values of bin_syswrite:
+ * 0 Successfully written
+ * 1 Error in parameters to command
+ * 2 Error on write, ERRNO set by system
+ */
+
+/**/
+static int
+bin_syswrite(char *nam, char **args, Options ops, UNUSED(int func))
+{
+ int outfd = 1, len, count, totcount;
+ char *countvar = NULL;
+
+ /* -o: output file descriptor if not stdout */
+ if (OPT_ISSET(ops, 'o')) {
+ outfd = getposint(OPT_ARG(ops, 'o'), nam);
+ if (outfd < 0)
+ return 1;
+ }
+
+ /* -c: variable in which to store count of bytes written */
+ if (OPT_ISSET(ops, 'c')) {
+ countvar = OPT_ARG(ops, 'c');
+ if (!isident(countvar)) {
+ zwarnnam(nam, "not an identifier: %s", countvar, 0);
+ return 1;
+ }
+ }
+
+ totcount = 0;
+ unmetafy(*args, &len);
+ while (len) {
+ while ((count = write(outfd, *args, len)) < 0) {
+ if (errno != EINTR || errflag || retflag || breaks || contflag)
+ {
+ if (countvar)
+ setiparam(countvar, totcount);
+ return 2;
+ }
+ }
+ *args += count;
+ totcount += count;
+ len -= count;
+ }
+ if (countvar)
+ setiparam(countvar, totcount);
+
+ return 0;
+}
+
+
+/*
+ * Return values of bin_syserror:
+ * 0 Successfully processed error
+ * (although if the number was invalid the string
+ * may not be useful)
+ * 1 Error in parameters
+ * 2 Name of error not recognised.
+ */
+
+/**/
+static int
+bin_syserror(char *nam, char **args, Options ops, UNUSED(int func))
+{
+ int num = 0;
+ char *errvar = NULL, *msg, *pfx = "", *str;
+
+ /* variable in which to write error message */
+ if (OPT_ISSET(ops, 'e')) {
+ errvar = OPT_ARG(ops, 'e');
+ if (!isident(errvar)) {
+ zwarnnam(nam, "not an identifier: %s", errvar, 0);
+ return 1;
+ }
+ }
+ /* prefix for error message */
+ if (OPT_ISSET(ops, 'p'))
+ pfx = OPT_ARG(ops, 'p');
+
+ if (!*args)
+ num = errno;
+ else {
+ char *ptr = *args;
+ while (*ptr && idigit(*ptr))
+ ptr++;
+ if (!*ptr && ptr > *args)
+ num = atoi(*args);
+ else {
+ const char **eptr;
+ for (eptr = sys_errnames; *eptr; eptr++) {
+ if (!strcmp(*eptr, *args)) {
+ num = (eptr - sys_errnames) + 1;
+ break;
+ }
+ }
+ if (!*eptr)
+ return 2;
+ }
+ }
+
+ msg = strerror(num);
+ if (errvar) {
+ str = (char *)zalloc(strlen(msg) + strlen(pfx) + 1);
+ sprintf(str, "%s%s", pfx, msg);
+ setsparam(errvar, str);
+ } else {
+ fprintf(stderr, "%s%s\n", pfx, msg);
+ }
+
+ return 0;
+}
+
+
+/* Functions for the errnos special parameter. */
+
+/**/
+static char **
+errnosgetfn(UNUSED(Param pm))
+{
+ /* arrdup etc. should really take const pointers as arguments */
+ return arrdup((char **)sys_errnames);
+}
+
+
+static struct builtin bintab[] = {
+ BUILTIN("syserror", 0, bin_syserror, 0, 1, 0, "e:p:", NULL),
+ BUILTIN("sysread", 0, bin_sysread, 0, 1, 0, "c:i:o:s:t:", NULL),
+ BUILTIN("syswrite", 0, bin_syswrite, 1, 1, 0, "c:o:", NULL),
+};
+
+static const struct gsu_array errnos_gsu =
+{ errnosgetfn, arrsetfn, stdunsetfn };
+
+/* The load/unload routines required by the zsh library interface */
+
+/**/
+int
+setup_(UNUSED(Module m))
+{
+ return 0;
+}
+
+/**/
+static void
+tidyparam(Param pm)
+{
+ if (!pm)
+ return;
+ pm->flags &= ~PM_READONLY;
+ unsetparam_pm(pm, 0, 1);
+}
+
+
+/**/
+int
+boot_(Module m)
+{
+ Param pm_nos;
+
+ /* this takes care of an autoload on errnos */
+ unsetparam("errnos");
+ if (!(pm_nos = createparam("errnos", PM_ARRAY|PM_SPECIAL|PM_READONLY|
+ PM_HIDE|PM_HIDEVAL|PM_REMOVABLE)))
+ return 1;
+ pm_nos->gsu.a = &errnos_gsu;
+
+ if (!addbuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab))) {
+ tidyparam(pm_nos);
+ return 1;
+ }
+ return 0;
+}
+
+
+/**/
+int
+cleanup_(Module m)
+{
+ tidyparam((Param)paramtab->getnode(paramtab, "errnos"));
+
+ deletebuiltins(m->nam, bintab, sizeof(bintab)/sizeof(*bintab));
+ return 0;
+}
+
+/**/
+int
+finish_(UNUSED(Module m))
+{
+ return 0;
+}