From a022372912592ef2bf5f1c1bddee391bcaa17b7d Mon Sep 17 00:00:00 2001 From: Greg Brockman Date: Tue, 23 Mar 2010 17:03:07 -0400 Subject: [PATCH] Added source for zsend --- bin/zsend | Bin 36166 -> 0 bytes src/zsend-0.0.1/Makefile | 50 ++ src/zsend-0.0.1/ZCkAuth.c | 75 +++ src/zsend-0.0.1/debian/changelog | 6 + src/zsend-0.0.1/debian/control | 15 + src/zsend-0.0.1/debian/copyright | 29 ++ src/zsend-0.0.1/debian/dirs | 1 + src/zsend-0.0.1/debian/rules | 90 ++++ src/zsend-0.0.1/debian/zsend.files | 1 + src/zsend-0.0.1/lread.c | 703 +++++++++++++++++++++++++++++ src/zsend-0.0.1/lread.h | 71 +++ src/zsend-0.0.1/zsend.c | 334 ++++++++++++++ 12 files changed, 1375 insertions(+) delete mode 100755 bin/zsend create mode 100644 src/zsend-0.0.1/Makefile create mode 100644 src/zsend-0.0.1/ZCkAuth.c create mode 100644 src/zsend-0.0.1/debian/changelog create mode 100644 src/zsend-0.0.1/debian/control create mode 100644 src/zsend-0.0.1/debian/copyright create mode 100644 src/zsend-0.0.1/debian/dirs create mode 100755 src/zsend-0.0.1/debian/rules create mode 100644 src/zsend-0.0.1/debian/zsend.files create mode 100644 src/zsend-0.0.1/lread.c create mode 100644 src/zsend-0.0.1/lread.h create mode 100644 src/zsend-0.0.1/zsend.c diff --git a/bin/zsend b/bin/zsend deleted file mode 100755 index 7dde6b3ab433ea7cebb174a9ab1da5dc4aeaec6f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 36166 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 Xag7zhXgF5CE_dy diff --git a/src/zsend-0.0.1/Makefile b/src/zsend-0.0.1/Makefile new file mode 100644 index 0000000..e3751b3 --- /dev/null +++ b/src/zsend-0.0.1/Makefile @@ -0,0 +1,50 @@ +SHELL = /bin/sh + +prefix=/usr +exec_prefix=${prefix} +datadir=${prefix}/share +sysconfdir=${prefix}/etc +sbindir=${exec_prefix}/sbin +lsbindir=${sbindir} +mandir=${prefix}/share/man + +includedir=${prefix}/include +libdir=${exec_prefix}/lib +bindir=${exec_prefix}/bin + +srcdir= +top_srcdir= +BUILDTOP= +CC=gcc -m32 +INSTALL=/usr/bin/install -c + +IRFLAGS=-DINTERREALM +CPPFLAGS=-I/usr/athena/include +CFLAGS=-g -O2 +ALL_CFLAGS=${CFLAGS} ${IRFLAGS} ${CPPFLAGS} +LDFLAGS=-L${BUILDTOP}/lib +#LIBS=-lreadline -L/usr/athena/lib -Wl,-R /usr/athena/lib -lzephyr -lkrb4 -lkrb5 -lcrypto -lcrypt -lresolv -lcom_err -ldl +LIBS=-lreadline -L/usr/athena/lib -lzephyr -lkrb4 -lkrb5 -lcrypto -lcrypt -lresolv -lcom_err -ldl + +OBJS= ZCkAuth.o lread.o + +all: zsend + +zsend.o: zsend.c + +zsend: zsend.o lread.o lread.h ZCkAuth.o + ${CC} ${LDFLAGS} -o $@ ZCkAuth.o lread.o zsend.o ${LIBS} + +.c.o: + ${CC} -c ${ALL_CFLAGS} $< + +check: + +install: zsend + ${INSTALL} -m 755 -s zsend ../../bin + +clean: + rm -f *.o zsend + +.PHONY: all check install clean + diff --git a/src/zsend-0.0.1/ZCkAuth.c b/src/zsend-0.0.1/ZCkAuth.c new file mode 100644 index 0000000..6b65387 --- /dev/null +++ b/src/zsend-0.0.1/ZCkAuth.c @@ -0,0 +1,75 @@ +/* Modifications for tzc by Darrell Kindred , April 1997: + * - cache the kerberos credentials, so we can continue to check auth + * even if the user re-kinits. + */ + +/* This file is part of the Project Athena Zephyr Notification System. + * It contains source for the ZCheckAuthentication function. + * + * Created by: Robert French + * + * /mit/zephyr/src/CVS/zephyr/lib/zephyr/ZCkAuth.c,v + * ghudson + * + * Copyright (c) 1987,1991 by the Massachusetts Institute of Technology. + * For copying and distribution information, see the file + * "mit-copyright.h". + */ +/* /mit/zephyr/src/CVS/zephyr/lib/zephyr/ZCkAuth.c,v 1.21 1995/06/30 22:03:53 ghudson Exp */ + + +#if 0 +#include +#else +#include +#define ZAUTH_UNSET (-3) /* from internal.h */ +#include /* for NULL */ +#endif + +/* Check authentication of the notice. + If it looks authentic but fails the Kerberos check, return -1. + If it looks authentic and passes the Kerberos check, return 1. + If it doesn't look authentic, return 0 + + When not using Kerberos, return true if the notice claims to be authentic. + Only used by clients; the server uses its own routine. + */ +Code_t ZCheckAuthentication(notice, from) + ZNotice_t *notice; + struct sockaddr_in *from; +{ +#ifdef ZEPHYR_USES_KERBEROS + int result; + ZChecksum_t our_checksum; + static CREDENTIALS cred; + static int got_cred = 0; + + /* If the value is already known, return it. */ + if (notice->z_checked_auth != ZAUTH_UNSET) + return (notice->z_checked_auth); + + if (!notice->z_auth) + return (ZAUTH_NO); + + if (!got_cred && + (result = krb_get_cred(SERVER_SERVICE, SERVER_INSTANCE, + __Zephyr_realm, &cred)) != 0) + return (ZAUTH_NO); + + got_cred = 1; + +#ifdef NOENCRYPTION + our_checksum = 0; +#else /* NOENCRYPTION */ + our_checksum = des_quad_cksum(notice->z_packet, NULL, + notice->z_default_format+ + strlen(notice->z_default_format)+1- + notice->z_packet, 0, cred.session); +#endif /* NOENCRYPTION */ + /* if mismatched checksum, then the packet was corrupted */ + return ((our_checksum == notice->z_checksum) ? ZAUTH_YES : ZAUTH_FAILED); + +#else /* ZEPHYR_USES_KERBEROS */ + return (notice->z_auth ? ZAUTH_YES : ZAUTH_NO); +#endif +} diff --git a/src/zsend-0.0.1/debian/changelog b/src/zsend-0.0.1/debian/changelog new file mode 100644 index 0000000..0e910aa --- /dev/null +++ b/src/zsend-0.0.1/debian/changelog @@ -0,0 +1,6 @@ +zsend (0.0.1-1) stable; urgency=low + + * Initial Release. + + -- Aaron Solochek Sun, 09 Oct 2005 10:30:00 -0600 + diff --git a/src/zsend-0.0.1/debian/control b/src/zsend-0.0.1/debian/control new file mode 100644 index 0000000..4960cb8 --- /dev/null +++ b/src/zsend-0.0.1/debian/control @@ -0,0 +1,15 @@ +Source: zsend +Section: net +Priority: optional +Maintainer: Aaron Solochek +Build-Depends: debhelper, bison, libzephyr-dev, libreadline-dev +Standards-Version: 3.1.1 + +Package: zsend +Section: net +Architecture: any +Depends: zephyr-clients, ${shlibs:Depends} +Description: zsend is a stripped zwrite ideal for use in scripts + . + This package contains the zsend binary for use in zephyr notification + scripts. diff --git a/src/zsend-0.0.1/debian/copyright b/src/zsend-0.0.1/debian/copyright new file mode 100644 index 0000000..bce481d --- /dev/null +++ b/src/zsend-0.0.1/debian/copyright @@ -0,0 +1,29 @@ +This package was debianized by Aaron Solochek on +Mon, 4 Dec 2000 05:28:22 -0500. + +Copyright: + +/* + +Copyright 1987,1988,1995 by the Massachusetts Institute of Technology + +All rights reserved. + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of the Massachusetts +Institute of Technology (M.I.T.) not be used in advertising or publicity +pertaining to distribution of the software without specific, written +prior permission. + +M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +M.I.T. BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +*/ diff --git a/src/zsend-0.0.1/debian/dirs b/src/zsend-0.0.1/debian/dirs new file mode 100644 index 0000000..e772481 --- /dev/null +++ b/src/zsend-0.0.1/debian/dirs @@ -0,0 +1 @@ +usr/bin diff --git a/src/zsend-0.0.1/debian/rules b/src/zsend-0.0.1/debian/rules new file mode 100755 index 0000000..1d06031 --- /dev/null +++ b/src/zsend-0.0.1/debian/rules @@ -0,0 +1,90 @@ +#!/usr/bin/make -f +# Sample debian/rules that uses debhelper. +# GNU copyright 1997 by Joey Hess. +# +# This version is for a hypothetical package that builds an +# architecture-dependant package, as well as an architecture-independent +# package. + +# Uncomment this to turn on verbose mode. +#export DH_VERBOSE=1 + +# This is the debhelper compatability version to use. +export DH_COMPAT=3 + +# This has to be exported to make some magic below work. +export DH_OPTIONS +SONAME=3 + +configure: configure-stamp +configure-stamp: + dh_testdir + + # Add here commands to configure the package. + -mkdir build-tree + cp *.c build-tree/ + cp *.h build-tree/ + cp Makefile build-tree/ + +build: configure-stamp build-stamp +build-stamp: + dh_testdir + + # Add here commands to compile the package. + $(MAKE) -C `pwd`/build-tree + touch build-stamp + +clean: + dh_testdir + dh_testroot + -rm -f build-stamp configure-stamp + + # Add here commands to clean up after the build process. + -rm -rf build-tree debian/tmp + + dh_clean + +install: DH_OPTIONS= +install: build + dh_testdir + dh_testroot + dh_clean -k + -rm -rf debian/tmp + dh_installdirs + mkdir -p debian/tmp/usr/bin/ + + # Add here commands to install the package into debian/tmp. + cd build-tree&&$(MAKE) DESTDIR=`pwd`/../debian/tmp install + + +# Build architecture-independent files here. +# Pass -i to all debhelper commands in this target to reduce clutter. +binary-indep: build install + + +# Build architecture-dependent files here. +# Pass -a to all debhelper commands in this target to reduce clutter. +binary-arch: build install + dh_testdir + dh_testroot + set -e; \ + dh_movefiles -pzsend + dh_movefiles --sourcedir=debian/tmp -pzsend + dh_installdebconf + dh_installdocs + dh_installchangelogs + dh_strip + dh_compress + dh_fixperms + dh_makeshlibs + dh_shlibdeps + dh_installdeb + dh_gencontrol + dh_md5sums + dh_builddeb + +binary: binary-indep binary-arch + +.PHONY: build clean binary-indep binary-arch binary install configure + + diff --git a/src/zsend-0.0.1/debian/zsend.files b/src/zsend-0.0.1/debian/zsend.files new file mode 100644 index 0000000..e772481 --- /dev/null +++ b/src/zsend-0.0.1/debian/zsend.files @@ -0,0 +1 @@ +usr/bin diff --git a/src/zsend-0.0.1/lread.c b/src/zsend-0.0.1/lread.c new file mode 100644 index 0000000..852c82e --- /dev/null +++ b/src/zsend-0.0.1/lread.c @@ -0,0 +1,703 @@ +/* + lread.c: simple sexp-like data structures in C. + useful for communication between emacs and C client programs + + Copyright (C) 1992 Nick Thompson (nix@cs.cmu.edu) + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + TODO + + add tag checking on CAR, CDR, etc? + */ + +#include + +#include "lread.h" +#include +#include /* for strlen() */ + +Value * +vmake_cons(Value *car, Value *cdr) +{ + Value *v = ALLOC_VALUE(); + v->tag = cons; + VCAR(v) = car; + VCDR(v) = cdr; + return v; +} + +Value * +vmake_symbol(int length, char *data) +{ + Value *v = ALLOC_VALUE(); + v->tag = symbol; + VSLENGTH(v) = length; + VSDATA(v) = data; + return v; +} + +Value * +vmake_symbol_c(char *s) +{ + Value *v = ALLOC_VALUE(); + v->tag = symbol; + VSLENGTH(v) = strlen(s); + VSDATA(v) = s; + return v; +} + +Value * +vmake_string(int length, char *data) +{ + Value *v = ALLOC_VALUE(); + v->tag = string; + VSLENGTH(v) = length; + VSDATA(v) = data; + return v; +} + +Value * +vmake_string_c(char *s) +{ + Value *v = ALLOC_VALUE(); + v->tag = string; + VSLENGTH(v) = strlen(s); + VSDATA(v) = s; + return v; +} + +char * +vextract_string_c(Value *v) +{ + char *s = (char *) malloc(VSLENGTH(v) + 1); + memcpy(s, VSDATA(v), VSLENGTH(v)); + s[VSLENGTH(v)] = '\0'; + return s; +} + +Value * +vmake_integer(int n) +{ + Value *v = ALLOC_VALUE(); + v->tag = integer; + VINTEGER(v) = n; + return v; +} + +Value * +vmake_var(enum Vtag tag, void **value) +{ + Value *v = ALLOC_VALUE(); + v->tag = var; + VVTAG(v) = tag; + VVDATA(v) = value; + return v; +} + +int +vlength(Value *l) +{ + int i; + for (i=0; VTAG(l) == cons; i++, l = VCDR(l)) + ; + return i; +} + +typedef struct { + jmp_buf abort; /* nonlocal exit for abort */ + + char *input_string; /* input string */ + int buflen; /* amount left in input string */ + char *buf; /* pointer into input */ + + int strbuflen; /* length of scratch buffer */ + char *strbuf; /* scratch buffer for building strings */ +} Globals; + +Value *read_value(Globals *g); +Value *read_list(Globals *g); + +#define PEEK_CHAR(g) (*(g)->buf) +#define NEXT_CHAR(g) ((g)->buflen > 0 ? \ + (void) ((g)->buf++,((g)->buflen--)) : \ + (void) (ABORT(g, 23))) +#define ABORT(g, code) longjmp((g)->abort, (code)) + +/* A pox on languages without coroutines. */ +/* I don't feel like putting the entire state of the parser in data + * structures that I can save and restore myself, so if EOF is + * encountered while parsing the parser will have to start from + * scratch when it gets more data */ + +void +expand_strbuf(Globals *g) +{ + if (g->strbuflen == 0) { + g->strbuflen = 128; + g->strbuf = (char *) malloc(g->strbuflen); + } + else { + int newbuflen = 3 * g->strbuflen / 2; + char *newbuf = (char *) malloc(newbuflen); + memcpy(newbuf, g->strbuf, g->strbuflen); + free(g->strbuf); + g->strbuf = newbuf; + g->strbuflen = newbuflen; + } +} + +int parse(int slen, char *s, Value **v) +{ + Globals g; + int jmpret; + + if (0 == (jmpret = setjmp(g.abort))) { /* successful parse */ + g.input_string = s; + g.buflen = slen; + g.buf = g.input_string; + g.strbuflen = 0; + g.strbuf = NULL; + expand_strbuf(&g); + *v = read_value(&g); + return g.buf - g.input_string; + } + else { /* return from nonlocal abort */ + free(g.strbuf); + *v = NULL; + return 0; + } +} + +int +read_escape(Globals *g, char *c) +{ + int valid = 1; + int nc = PEEK_CHAR(g); + + switch (nc) { + case '\n': + valid = 0; + NEXT_CHAR(g); + break; + case 'n': + *c = '\n'; + NEXT_CHAR(g); + break; + case 't': + *c = '\t'; + NEXT_CHAR(g); + break; + default: + if (nc >= '0' && nc <= '7') { + int digits; + /* handle octal \nnn notation */ + *c = 0; + for (digits = 0; digits < 3; digits++) { + if (nc < '0' || nc > '7') + break; + *c = (*c * 8) + (nc - '0'); + NEXT_CHAR(g); + nc = PEEK_CHAR(g); + } + } else { + /* backslash followed by some random char, like \q. + * (some of these are actually valid, but I don't think prin1 will + * produce them, so it's not too critical). */ + *c = nc; + NEXT_CHAR(g); + } + break; + } + return valid; +} + +Value * +read_string(Globals *g) +{ + int strpos = 0; + Value *v; + char c; + +#define ADD_CHAR(c) \ + if (strpos >= g->strbuflen) \ + expand_strbuf(g); \ + g->strbuf[strpos++] = (c) + + while (1) { + switch (PEEK_CHAR(g)) { + case '\"': + NEXT_CHAR(g); + v = ALLOC_VALUE(); + v->tag = string; + v->value.s.length = strpos; + v->value.s.string = (char *) malloc(v->value.s.length); + memcpy(v->value.s.string, g->strbuf, v->value.s.length); + return v; + break; + case '\\': + NEXT_CHAR(g); + if (read_escape(g, &c)) + ADD_CHAR(c); + break; + default: + ADD_CHAR(PEEK_CHAR(g)); + NEXT_CHAR(g); + break; + } + } +} + +/* characters +( +) +" +\ + + + + */ + +Value * +read_num_or_symbol(Globals *g) +{ + Value *v; + int strpos = 0; + int i; + int is_integer; + +#define ADD_CHAR(c) \ + if (strpos >= g->strbuflen) \ + expand_strbuf(g); \ + g->strbuf[strpos++] = (c) + + while (g->buflen > 0) { + switch (PEEK_CHAR(g)) { + case ' ': + case '\t': + case '\n': + case '\0': + case '\"': + case '(': + case ')': + case '.': + goto done; + break; + case '\\': + NEXT_CHAR(g); + ADD_CHAR(PEEK_CHAR(g)); + NEXT_CHAR(g); + break; + default: + ADD_CHAR(PEEK_CHAR(g)); + NEXT_CHAR(g); + break; + } + } + ABORT(g, 23); + + done: + /* is this a number or a symbol? */ + /* assume integer to start */ + is_integer = 1; + + /* assume no empty strings? */ + + /* if the first character is '+' or '-' and that's not the only */ + /* character it can still be an integer */ + i = 0; + if (strpos > 0) { + if (g->strbuf[0] == '-' || g->strbuf[0] == '+') { + if (strpos > 1) { + i = 1; + } else { + is_integer = 0; + } + } + } + + while (is_integer && i < strpos) { + if (g->strbuf[i] < '0' || g->strbuf[i] > '9') + is_integer = 0; + i++; + } + + if (is_integer) { + /* it's an integer */ + v = ALLOC_VALUE(); + v->tag = integer; + ADD_CHAR('\0'); + v->value.integer.i = atoi(g->strbuf); + } + else { + /* it's a symbol */ + if (3 == strpos && + !memcmp(g->strbuf, "nil", 3)) { + v = NULL; + } else { + v = ALLOC_VALUE(); + v->tag = symbol; + v->value.s.length = strpos; + v->value.s.string = (char *) malloc(v->value.s.length); + memcpy(v->value.s.string, g->strbuf, v->value.s.length); + } + } + return v; +} + +Value * +read_value(Globals *g) +{ + while (g->buflen > 0) { + switch (PEEK_CHAR(g)) { + case ' ': + case '\t': + case '\n': + case '\0': + NEXT_CHAR(g); + break; + case '\"': /* begin string */ + NEXT_CHAR(g); + return read_string(g); + break; + case '(': + NEXT_CHAR(g); + return read_list(g); + break; + case ')': + case '.': + return NULL; + break; + default: + return read_num_or_symbol(g); + break; + } + } + ABORT(g, 23); +} + +Value * +read_list(Globals *g) +{ + Value *list; + Value **tail; + Value *v; + + tail = &list; + while (g->buflen > 0) { + if (NULL == (v = read_value(g))) { + switch (PEEK_CHAR(g)) { + + case ')': + if (tail != NULL) { /* if no last cdr yet, use nil */ + *tail = NULL; + } + NEXT_CHAR(g); + return list; + break; + + case '.': /* set last cdr explicitly */ + NEXT_CHAR(g); + *tail = read_value(g); + if (*tail == NULL) { + /* badly formed input ??? */ + ABORT(g, 13); + } + tail = NULL; + break; + + default: + /* badly formed input ??? */ + ABORT(g, 13); + break; + } + } + else { /* read a value, add it to the list */ + if (NULL == tail) { + /* two values after a . in a list. very bad! ??? */ + ABORT(g, 13); + } + *tail = ALLOC_VALUE(); + (*tail)->tag = cons; + (*tail)->value.cons.car = v; + tail = &(*tail)->value.cons.cdr; + } + } + ABORT(g, 23); /* added this -dkindred */ +} + +void free_value(Value *v) +{ + switch(VTAG(v)) { + case cons: + free_value(v->value.cons.car); + free_value(v->value.cons.cdr); + break; + case string: + case symbol: + free(v->value.s.string); + break; + default: + break; + } + free(v); +} + +void prin(FILE *f, Value *v); + +void +prinlis(FILE *f, Value *v, int first) +{ + switch(VTAG(v)) { + case cons: /* continue printing list */ + if (! first) + putc(' ', f); + prin(f, v->value.cons.car); + prinlis(f, v->value.cons.cdr, 0); + break; + case nil: /* last elt in list */ + putc(')', f); + break; + default: /* dotted pair */ + putc(' ', f); + putc('.', f); + putc(' ', f); + prin(f, v); + putc(')', f); + break; + } +} + +void +prin(FILE *f, Value *v) +{ + switch (VTAG(v)) { + case nil: + fputs("\'()", f); + break; + case cons: + putc('(', f); + prinlis(f, v, 1); + break; + case string: + /* ??? do quoting of '"' ??? */ + putc('\"', f); + fwrite(v->value.s.string, 1, v->value.s.length, f); + putc('\"', f); + break; + case symbol: + /* ??? do quoting of all whitespace and special chars ??? */ + fwrite(v->value.s.string, 1, v->value.s.length, f); + break; + case integer: + fprintf(f, "%ld", v->value.integer.i); + break; + default: + fputs("#", f); + break; + } +} + +#define CHECK_TAG(v, t) if (VTAG(v) != (t)) return 0 + +int +eqv(Value *v1, Value *v2) +{ + + switch (v1->tag) { +/* + case any: + return 1; + break; + */ + case nil: + CHECK_TAG(v2, nil); + return 1; + break; + case cons: + CHECK_TAG(v2, cons); + return (eqv(VCAR(v1), VCAR(v2)) && + eqv(VCDR(v1), VCDR(v2))); + break; + case string: + CHECK_TAG(v2, string); + return (VSLENGTH(v1) == VSLENGTH(v2) && + 0 == memcmp(VSDATA(v1), VSDATA(v2), VSLENGTH(v1))); + break; + case symbol: + CHECK_TAG(v2, symbol); + return (VSLENGTH(v1) == VSLENGTH(v2) && + 0 == memcmp(VSDATA(v1), VSDATA(v2), VSLENGTH(v1))); + break; + case integer: + CHECK_TAG(v2, integer); + return (VINTEGER(v1) == VINTEGER(v2)); + break; + case var: + if (VVTAG(v1) != any) + CHECK_TAG(v2, VVTAG(v1)); + return 1; + break; + default: + fprintf(stderr,"eqv(): bad tag: %d\n",(int)(v1->tag)); + /* die? */ + return 0; + break; + } +} + +Value * +assqv(Value *key, Value *assoc) +{ + Value *pair; + + /* cdr on through */ + while (VTAG(assoc) == cons) { + pair = VCAR(assoc); + if (VTAG(pair) == cons && eqv(VCAR(pair), key)) { + return pair; + } + assoc = VCDR(assoc); + } + return NULL; +} + +int +destructure(Value *pattern, Value *match) +{ + switch (VTAG(pattern)) { + case any: + return 1; + break; + case nil: + CHECK_TAG(match, nil); + return 1; + break; + case cons: + CHECK_TAG(match, cons); + return (destructure(VCAR(pattern), VCAR(match)) && + destructure(VCDR(pattern), VCDR(match))); + break; + case string: + CHECK_TAG(match, string); + return (VSLENGTH(pattern) == VSLENGTH(match) && + 0 == memcmp(VSDATA(pattern), VSDATA(match), VSLENGTH(pattern))); + break; + case symbol: + CHECK_TAG(match, symbol); + return (VSLENGTH(pattern) == VSLENGTH(match) && + 0 == memcmp(VSDATA(pattern), VSDATA(match), VSLENGTH(pattern))); + break; + case integer: + CHECK_TAG(match, integer); + return (VINTEGER(pattern) == VINTEGER(match)); + break; + case var: + if (VVTAG(pattern) != any) + CHECK_TAG(match, VVTAG(pattern)); + if (VVDATA(pattern) != NULL) + *VVDATA(pattern) = (void *) match; + return 1; + break; + default: + fprintf(stderr,"destructure(): bad tag: %d\n",(int)VTAG(pattern)); + /* die? */ + return 0; + break; + } +} + +#ifdef TEST + +read_and_parse() +{ +#define BUFLEN 512 + char buf[BUFLEN]; /* this will have to be dynamically expanded */ + int bufpos = 0; + int ret; + Value *v = NULL; + Value *match_data; + Value *pattern = vmake_cons(vmake_symbol_c("integer"), + vmake_var(integer, (void **) &match_data)); + + while (1) { + ret = read(0, buf + bufpos, BUFLEN - bufpos); + if (ret < 0) { + perror("read"); + exit(1); + } + else { + bufpos += ret; + + do { + if (v != NULL) { + free_value(v); + v = NULL; + } + ret = parse(bufpos, buf, &v); + if (ret > 0) { + memmove(buf, buf + ret, bufpos - ret); + bufpos -= ret; + printf("parsed: "); + prin(stdout, v); + fputc('\n', stdout); + + if (destructure(pattern, v)) { + printf("match_data = "); + prin(stdout, match_data); + fputc('\n', stdout); + } + else { + printf("destructure failed\n"); + } + + free_value(v); + } + else + printf("EOF\n"); + } while (ret > 0); + } + } +} + +main(int argc, char *argv[]) +{ + read_and_parse(); +#if 0 + Value *v; + v = ALLOC_VALUE(); + + v->tag = cons; + v->value.cons.car = ALLOC_VALUE(); + v->value.cons.car->tag = symbol; + v->value.cons.car->value.s.length = 6; + v->value.cons.car->value.s.string = "symbol"; + + v->value.cons.cdr = ALLOC_VALUE(); + v->value.cons.cdr->tag = cons; + + v->value.cons.cdr->value.cons.car = ALLOC_VALUE(); + v->value.cons.cdr->value.cons.car->tag = string; + v->value.cons.cdr->value.cons.car->value.s.length = 6; + v->value.cons.cdr->value.cons.car->value.s.string = "string"; + + v->value.cons.cdr->value.cons.cdr = ALLOC_VALUE(); + v->value.cons.cdr->value.cons.cdr->tag = integer; + v->value.cons.cdr->value.cons.cdr->value.integer.i = 23; + prin(stdout, v); + fputc('\n', stdout); +#endif +} +#endif diff --git a/src/zsend-0.0.1/lread.h b/src/zsend-0.0.1/lread.h new file mode 100644 index 0000000..57daf67 --- /dev/null +++ b/src/zsend-0.0.1/lread.h @@ -0,0 +1,71 @@ +/* + lread.h Header file for elisp reader and destructurer + Copyright (C) 1992 Nick Thompson (nix@cs.cmu.edu) + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + This code is useful for communicating with emacs, particularly in + subprocesses which are started by emacs. It allows you to do structured + ipc by passing printed s-expressions between emacs and the subprocess - + strings are parsed into a union "Value" by this code and there is also a + fairly convenient way to extract data. + + */ + +#include /* for malloc() */ + +enum Vtag { any, nil, cons, string, symbol, integer, var }; + +typedef struct Value Value; +struct Value { + enum Vtag tag; + union { + /* tag nil has no data */ + struct { Value *car, *cdr; } cons; + struct { int length; char *string; } s; /* tag string or symbol */ + struct { long i; } integer; + struct { enum Vtag tag; void **value; } var; + } value; +}; + +#define ALLOC_VALUE() ((Value *) malloc(sizeof(Value))) + +#define VTAG(v) (v?((v)->tag):nil) + +extern Value *vmake_cons(Value *car, Value *cdr); +#define VCAR(v) ((v)->value.cons.car) +#define VCDR(v) ((v)->value.cons.cdr) + +extern Value *vmake_symbol(int length, char *data); +extern Value *vmake_symbol_c(char *s); +extern Value *vmake_string(int length, char *data); +extern Value *vmake_string_c(char *s); +extern char *vextract_string_c(Value *v); +#define VSLENGTH(v) ((v)->value.s.length) +#define VSDATA(v) ((v)->value.s.string) + +extern Value *vmake_integer(int n); +#define VINTEGER(v) ((v)->value.integer.i) + +extern Value *vmake_var(enum Vtag tag, void **value); +#define VVTAG(v) ((v)->value.var.tag) +#define VVDATA(v) ((v)->value.var.value) + +extern Value *assqv(Value *key, Value *assoc); +extern int vlength(Value *l); + +extern int eqv(); +extern int parse(); +extern void free_value(); diff --git a/src/zsend-0.0.1/zsend.c b/src/zsend-0.0.1/zsend.c new file mode 100644 index 0000000..f3149d0 --- /dev/null +++ b/src/zsend-0.0.1/zsend.c @@ -0,0 +1,334 @@ +/* + zsend.c simple zephyr sender + Copyright (C) 1994 Darrell Kindred + + 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEFAULT_CLASS "MESSAGE" +#define DEFAULT_INSTANCE "PERSONAL" +#define URGENT_INSTANCE "URGENT" +#define DEFAULT_OPCODE "" +#define FILSRV_CLASS "FILSRV" +#ifdef CMU_INTERREALM +#define DEFAULT_REALM "ANDREW.CMU.EDU" +#endif + +extern Code_t ZCancelSubscriptions(), ZUnsetLocation(), ZClosePort(), + //ZRetrieveSubscriptions(), + ZGetSubscriptions(), ZSubscribeTo(), + ZSendNotice(), ZInitialize(), ZOpenPort(), ZPending(), + ZCompareUID(), ZReceiveNotice(), ZCheckAuthentication(), + ZFreeNotice(), ZSetLocation(); +#ifdef CMU_INTERREALM +extern char *ZExpandRealm(); +#endif + +typedef struct PendingReply PendingReply; +struct PendingReply { + char *instance; + char *recipient; + ZUnique_Id_t uid; + PendingReply *next; +}; + +struct Globals { + const char *program; + int argc; + const char **argv; + + u_short port; + int zfd; + + int debug; + + /* linked list of messages sent which are waiting for replies */ + PendingReply *pending_replies; + +}; + +struct Globals global_storage, *globals = &global_storage; + +void usage(const char *progname) { + fprintf(stderr, "usage: %s [options] [recipients]\n", progname); + fprintf(stderr, " options:\n"); + fprintf(stderr, " -i use instance \n"); + fprintf(stderr, " -c use class \n"); +#ifdef CMU_INTERREALM + fprintf(stderr, " -r use realm \n"); +#endif + fprintf(stderr, " -s use signature \n"); + fprintf(stderr, " -S use sender \n"); + fprintf(stderr, " -O use opcode \n"); + fprintf(stderr, " -m send msg instead of reading stdin (must be last arg)\n"); + fprintf(stderr, " -d print debugging information\n"); +} + +void exit_tzc() { + ZClosePort(); + exit(0); +} + +Code_t check(Code_t e, char *s) { + if (e) { + printf(";;; return code %d\n",(int) e); + fflush(stdout); + com_err(__FILE__, e, s); + exit(1); + } + return e; +} + +Code_t warn(Code_t e, char *s) { + if (e) + com_err(__FILE__, e, s); + return e; +} + +char *auth_string(int n) { + switch (n) { + case ZAUTH_YES : return "yes"; + case ZAUTH_FAILED : return "failed"; + case ZAUTH_NO : return "no"; + default : return "bad-auth-value"; + } +} + +char *kind_string(int n) { + switch (n) { + case UNSAFE: return "unsafe"; + case UNACKED: return "unacked"; + case ACKED: return "acked"; + case HMACK: return "hmack"; + case HMCTL: return "hmctl"; + case SERVACK: return "servack"; + case SERVNAK: return "servnak"; + case CLIENTACK: return "clientack"; + case STAT: return "stat"; + default: return "bad-kind-value"; + } +} + +/* warning: this uses ctime which returns a pointer to a static buffer + * which is overwritten with each call. */ +char *time_str(time_t time_num) +{ + char *now_name; + now_name = ctime(&time_num); + now_name[24] = '\0'; /* dump newline at end */ + return(now_name); +} + +/* return time in the format "14:15:03" */ +/* uses ctime, which returns a ptr to a static buffer */ +char *debug_time_str(time_t time_num) +{ + char *now_name; + now_name = ctime(&time_num); + now_name[19] = '\0'; /* strip year */ + return now_name+11; /* strip date */ +} + +void +setup() +{ + check(ZInitialize(), "ZInitialize"); + globals->port = 0; + check(ZOpenPort(&globals->port), "ZOpenPort"); + + globals->pending_replies = NULL; +} + +int get_message(char **msg, char *sig) { + /* XXX fix this to be dynamic */ + static char buf[65535]; + int c, len; + char *p; + strcpy(buf, sig); + len = strlen(sig)+1; + p = &(buf[len]); + while ((c=getchar()) != EOF) { + *p++ = c; + len++; + } + len++; + *p = '\0'; + *msg = buf; + return len; +} + +int get_message_arg(char **msg, char *msgptr, char *sig) { + /* XXX fix this to be dynamic */ + static char buf[65535]; + int c, len; + int i = 0; + char *p; + strcpy(buf, sig); + len = strlen(sig)+1; + strcpy(&buf[len], msgptr); + len += strlen(msgptr)+1; + *msg = buf; + return len; +} + +int main(int argc, const char *argv[]) { + const char *program; + const char **recipient; + char *msg; + int broadcast, msglen; + int n_recips = 0; + int (*auth)(); + int use_zctl = 0, sw; + int havemsg = 0; + int haverealm = 0; + extern char *optarg; + extern int optind; + char location[BUFSIZ]; + ZNotice_t notice; + int retval; + char *sender=NULL, *signature="", *instance=DEFAULT_INSTANCE, + *class=DEFAULT_CLASS, *opcode=DEFAULT_OPCODE, *msgptr=""; +#ifdef CMU_INTERREALM + char *realm=DEFAULT_REALM; + char rlmrecip[BUFSIZ]; + char *cp; +#endif + + program = strrchr(argv[0], '/'); + if (program == NULL) + program = argv[0]; + else + program++; + + while ((sw = getopt(argc, argv, "di:s:c:S:m:O:r:")) != EOF) + switch (sw) { + case 'O': + opcode = optarg; + break; + case 'i': + instance = optarg; + break; + case 'c': + class = optarg; + break; + case 's': + signature = optarg; + break; + case 'S': + sender = optarg; + break; + case 'd': + /* debug = 1; */ + break; +#ifdef CMU_INTERREALM + case 'r': + realm = optarg; + haverealm = 1; + break; +#endif + case 'm': + msgptr = optarg; + havemsg = 1; + break; + case '?': + default: + usage(program); + exit(1); + } + + broadcast = (optind == argc); + + if (broadcast && !(strcmp(class, DEFAULT_CLASS) || + (strcmp(instance, DEFAULT_INSTANCE) && + strcmp(instance, URGENT_INSTANCE)))) { + /* must specify recipient if using default class and + (default instance or urgent instance) */ + fprintf(stderr, "No recipients specified.\n"); + usage(program); + exit(1); + } + + if(havemsg) + msglen = get_message_arg(&msg, msgptr, signature); + else + msglen = get_message(&msg, signature); + + setup(); + + for ( ; broadcast || optind < argc; optind++) { + bzero((char *) ¬ice, sizeof(notice)); + + notice.z_kind = UNACKED; + notice.z_port = 0; + notice.z_class = class; + notice.z_opcode = opcode; + notice.z_sender = sender; + notice.z_class_inst = instance; +#ifdef CMU_INTERREALM + if (!broadcast && (cp = strchr(argv[optind], '@'))) { + (void) strcpy(rlmrecip, argv[optind]); + cp = strchr(rlmrecip, '@'); + if (cp) { + cp++; + (void) strcpy(cp, (char *) ZExpandRealm(cp)); + } + notice.z_recipient = rlmrecip; + } else if(haverealm) { + rlmrecip[0] = '@'; + (void) strcpy(&rlmrecip[1], (char *) ZExpandRealm(realm)); + notice.z_recipient = rlmrecip; + } else +#endif + notice.z_recipient = (char *) (broadcast ? "" : argv[optind]); + notice.z_message = msg; + notice.z_message_len = msglen; + notice.z_default_format = "@bold(UNAUTHENTIC) Class $class, Instance $instance:\n$message"; + auth = ZNOAUTH; + if (auth == ZAUTH) { + notice.z_default_format = "Class $class, Instance $instance:\nTo: @bold($recipient)\n$message"; + } + if ((retval = ZSendNotice(¬ice, auth)) != ZERR_NONE) { +#if 1 + char bfr[BUFSIZ]; + (void) sprintf(bfr, "while sending notice to %s", + notice.z_recipient); + com_err(__FILE__, retval, bfr); +#endif + fprintf(stderr, "error %d from ZSendNotice while sending to %s\n", + retval, notice.z_recipient); + exit(1); + } + if (broadcast) + break; + } + exit(0); +} -- 2.45.1