[zcommit.git] / src / zsend-0.0.1 / zsend.c

/*
   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 <strings.h>
#include <stdio.h>
#include <sys/types.h>
#include <ctype.h>
#include <zephyr/zephyr.h>
#include <zephyr/zephyr_err.h>
#include <netdb.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/file.h>
#include <signal.h>
#include <string.h>
#include <time.h>

#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 <inst>      use instance <inst>\n");
   fprintf(stderr, "      -c <class>     use class <class>\n");
#ifdef CMU_INTERREALM
   fprintf(stderr, "      -r <realm>     use realm <realm>\n");
#endif
   fprintf(stderr, "      -s <sig>       use signature <sig>\n");
   fprintf(stderr, "      -S <sender>    use sender <sender>\n");
   fprintf(stderr, "      -O <opcode>    use opcode <opcode>\n");
   fprintf(stderr, "      -m <msg>       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 *) &notice, 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(&notice, 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);
}
Commit	Line	Data
a0223729 GB	1	/*
	2	zsend.c simple zephyr sender
	3	Copyright (C) 1994 Darrell Kindred
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	18
	19	*/
	20
	21	#include <strings.h>
	22	#include <stdio.h>
	23	#include <sys/types.h>
	24	#include <ctype.h>
	25	#include <zephyr/zephyr.h>
	26	#include <zephyr/zephyr_err.h>
	27	#include <netdb.h>
	28	#include <sys/socket.h>
	29	#include <sys/wait.h>
	30	#include <netinet/in.h>
	31	#include <arpa/inet.h>
	32	#include <sys/file.h>
	33	#include <signal.h>
	34	#include <string.h>
	35	#include <time.h>
	36
	37	#define DEFAULT_CLASS "MESSAGE"
	38	#define DEFAULT_INSTANCE "PERSONAL"
	39	#define URGENT_INSTANCE "URGENT"
	40	#define DEFAULT_OPCODE ""
	41	#define FILSRV_CLASS "FILSRV"
	42	#ifdef CMU_INTERREALM
	43	#define DEFAULT_REALM "ANDREW.CMU.EDU"
	44	#endif
	45
	46	extern Code_t ZCancelSubscriptions(), ZUnsetLocation(), ZClosePort(),
	47	//ZRetrieveSubscriptions(),
	48	ZGetSubscriptions(), ZSubscribeTo(),
	49	ZSendNotice(), ZInitialize(), ZOpenPort(), ZPending(),
	50	ZCompareUID(), ZReceiveNotice(), ZCheckAuthentication(),
	51	ZFreeNotice(), ZSetLocation();
	52	#ifdef CMU_INTERREALM
	53	extern char *ZExpandRealm();
	54	#endif
	55
	56	typedef struct PendingReply PendingReply;
	57	struct PendingReply {
	58	char *instance;
	59	char *recipient;
	60	ZUnique_Id_t uid;
	61	PendingReply *next;
	62	};
	63
	64	struct Globals {
65	const char *program;
66	int argc;
67	const char **argv;
68
69	u_short port;
70	int zfd;
71
72	int debug;
73
74	/* linked list of messages sent which are waiting for replies */
75	PendingReply *pending_replies;
76
77	};
78
79	struct Globals global_storage, *globals = &global_storage;
80
81	void usage(const char *progname) {
82	fprintf(stderr, "usage: %s [options] [recipients]\n", progname);
83	fprintf(stderr, " options:\n");
84	fprintf(stderr, " -i <inst> use instance <inst>\n");
85	fprintf(stderr, " -c <class> use class <class>\n");
86	#ifdef CMU_INTERREALM
87	fprintf(stderr, " -r <realm> use realm <realm>\n");
88	#endif
89	fprintf(stderr, " -s <sig> use signature <sig>\n");
90	fprintf(stderr, " -S <sender> use sender <sender>\n");
91	fprintf(stderr, " -O <opcode> use opcode <opcode>\n");
92	fprintf(stderr, " -m <msg> send msg instead of reading stdin (must be last arg)\n");
93	fprintf(stderr, " -d print debugging information\n");
94	}
95
96	void exit_tzc() {
97	ZClosePort();
98	exit(0);
99	}
100
101	Code_t check(Code_t e, char *s) {
102	if (e) {
103	printf(";;; return code %d\n",(int) e);
104	fflush(stdout);
105	com_err(__FILE__, e, s);
106	exit(1);
107	}
108	return e;
109	}
110
111	Code_t warn(Code_t e, char *s) {
112	if (e)
113	com_err(__FILE__, e, s);
114	return e;
115	}
116
117	char *auth_string(int n) {
118	switch (n) {
119	case ZAUTH_YES : return "yes";
120	case ZAUTH_FAILED : return "failed";
121	case ZAUTH_NO : return "no";
122	default : return "bad-auth-value";
123	}
124	}
125
126	char *kind_string(int n) {
127	switch (n) {
128	case UNSAFE: return "unsafe";
129	case UNACKED: return "unacked";
130	case ACKED: return "acked";
131	case HMACK: return "hmack";
132	case HMCTL: return "hmctl";
133	case SERVACK: return "servack";
134	case SERVNAK: return "servnak";
135	case CLIENTACK: return "clientack";
136	case STAT: return "stat";
137	default: return "bad-kind-value";
138	}
139	}
140
141	/* warning: this uses ctime which returns a pointer to a static buffer
142	* which is overwritten with each call. */
143	char *time_str(time_t time_num)
144	{
145	char *now_name;
146	now_name = ctime(&time_num);
147	now_name[24] = '\0'; /* dump newline at end */
148	return(now_name);
149	}
150
151	/* return time in the format "14:15:03" */
152	/* uses ctime, which returns a ptr to a static buffer */
153	char *debug_time_str(time_t time_num)
154	{
155	char *now_name;
156	now_name = ctime(&time_num);
157	now_name[19] = '\0'; /* strip year */
158	return now_name+11; /* strip date */
159	}
160
161	void
162	setup()
163	{
164	check(ZInitialize(), "ZInitialize");
165	globals->port = 0;
166	check(ZOpenPort(&globals->port), "ZOpenPort");
167
168	globals->pending_replies = NULL;
169	}
170
171	int get_message(char *msg, char sig) {
172	/* XXX fix this to be dynamic */
173	static char buf[65535];
174	int c, len;
175	char *p;
176	strcpy(buf, sig);
177	len = strlen(sig)+1;
178	p = &(buf[len]);
179	while ((c=getchar()) != EOF) {
180	*p++ = c;
181	len++;
182	}
183	len++;
184	*p = '\0';
185	*msg = buf;
186	return len;
187	}
188
189	int get_message_arg(char *msg, char msgptr, char *sig) {
190	/* XXX fix this to be dynamic */
191	static char buf[65535];
192	int c, len;
193	int i = 0;
194	char *p;
195	strcpy(buf, sig);
196	len = strlen(sig)+1;
197	strcpy(&buf[len], msgptr);
198	len += strlen(msgptr)+1;
199	*msg = buf;
200	return len;
201	}
202
203	int main(int argc, const char *argv[]) {
204	const char *program;
205	const char **recipient;
206	char *msg;
207	int broadcast, msglen;
208	int n_recips = 0;
209	int (*auth)();
210	int use_zctl = 0, sw;
211	int havemsg = 0;
212	int haverealm = 0;
213	extern char *optarg;
214	extern int optind;
215	char location[BUFSIZ];
216	ZNotice_t notice;
217	int retval;
218	char sender=NULL, signature="", *instance=DEFAULT_INSTANCE,
219	class=DEFAULT_CLASS, opcode=DEFAULT_OPCODE, *msgptr="";
220	#ifdef CMU_INTERREALM
221	char *realm=DEFAULT_REALM;
222	char rlmrecip[BUFSIZ];
223	char *cp;
224	#endif
225
226	program = strrchr(argv[0], '/');
227	if (program == NULL)
228	program = argv[0];
229	else
230	program++;
231
232	while ((sw = getopt(argc, argv, "di:s:c:S:m:O:r:")) != EOF)
233	switch (sw) {
234	case 'O':
235	opcode = optarg;
236	break;
237	case 'i':
238	instance = optarg;
239	break;
240	case 'c':
241	class = optarg;
242	break;
243	case 's':
244	signature = optarg;
245	break;
246	case 'S':
247	sender = optarg;
248	break;
249	case 'd':
250	/* debug = 1; */
251	break;
252	#ifdef CMU_INTERREALM
253	case 'r':
254	realm = optarg;
255	haverealm = 1;
256	break;
257	#endif
258	case 'm':
259	msgptr = optarg;
260	havemsg = 1;
261	break;
262	case '?':
263	default:
264	usage(program);
265	exit(1);
266	}
267
268	broadcast = (optind == argc);
269
270	if (broadcast && !(strcmp(class, DEFAULT_CLASS) \|\|
271	(strcmp(instance, DEFAULT_INSTANCE) &&
272	strcmp(instance, URGENT_INSTANCE)))) {
273	/* must specify recipient if using default class and
274	(default instance or urgent instance) */
275	fprintf(stderr, "No recipients specified.\n");
276	usage(program);
277	exit(1);
278	}
279
280	if(havemsg)
281	msglen = get_message_arg(&msg, msgptr, signature);
282	else
283	msglen = get_message(&msg, signature);
284
285	setup();
286
287	for ( ; broadcast \|\| optind < argc; optind++) {
288	bzero((char *) &notice, sizeof(notice));
289
290	notice.z_kind = UNACKED;
291	notice.z_port = 0;
292	notice.z_class = class;
293	notice.z_opcode = opcode;
294	notice.z_sender = sender;
295	notice.z_class_inst = instance;
296	#ifdef CMU_INTERREALM
297	if (!broadcast && (cp = strchr(argv[optind], '@'))) {
298	(void) strcpy(rlmrecip, argv[optind]);
299	cp = strchr(rlmrecip, '@');
300	if (cp) {
301	cp++;
302	(void) strcpy(cp, (char *) ZExpandRealm(cp));
303	}
304	notice.z_recipient = rlmrecip;
305	} else if(haverealm) {
306	rlmrecip[0] = '@';
307	(void) strcpy(&rlmrecip[1], (char *) ZExpandRealm(realm));
308	notice.z_recipient = rlmrecip;
309	} else
310	#endif
311	notice.z_recipient = (char *) (broadcast ? "" : argv[optind]);
312	notice.z_message = msg;
313	notice.z_message_len = msglen;
314	notice.z_default_format = "@bold(UNAUTHENTIC) Class $class, Instance $instance:\n$message";
315	auth = ZNOAUTH;
316	if (auth == ZAUTH) {
317	notice.z_default_format = "Class $class, Instance $instance:\nTo: @bold($recipient)\n$message";
318	}
319	if ((retval = ZSendNotice(&notice, auth)) != ZERR_NONE) {
320	#if 1
321	char bfr[BUFSIZ];
322	(void) sprintf(bfr, "while sending notice to %s",
323	notice.z_recipient);
324	com_err(__FILE__, retval, bfr);
325	#endif
326	fprintf(stderr, "error %d from ZSendNotice while sending to %s\n",
327	retval, notice.z_recipient);
328	exit(1);
329	}
330	if (broadcast)
331	break;
332	}
333	exit(0);
334	}