Initial revision

1 files changed, 2153 insertions, 0 deletions

diff --git a/logs/changes.ghudson b/logs/changes.ghudson
new file mode 100644
index 0000000..1d41f86
--- /dev/null
+++ b/logs/changes.ghudson
@@ -0,0 +1,2153 @@
+diff -c /mit/zephyr/src/server/Imakefile ./Imakefile
+*** /mit/zephyr/src/server/Imakefile	Wed Nov 24 14:39:08 1993
+--- ./Imakefile	Wed Jul  6 17:19:09 1994
+***************
+*** 9,18 ****
+  /**/#
+  
+  #if defined(SYSLOG_COMPAT42)
+! SYSLOG_LIB= ../clients/syslogd/syslog.o
+  SYSLOG_DEF= -I../clients/syslogd
+  #else
+! SYSLOG_LIB=
+  SYSLOG_DEF=
+  #endif
+  
+--- 9,18 ----
+  /**/#
+  
+  #if defined(SYSLOG_COMPAT42)
+! SYSLOG_OBJ= ../clients/syslogd/syslog.o
+  SYSLOG_DEF= -I../clients/syslogd
+  #else
+! SYSLOG_OBJ=
+  SYSLOG_DEF=
+  #endif
+  
+***************
+*** 54,60 ****
+  	zstring.o
+  
+  error_table(zsrv_err)
+! SimpleProgram(zephyrd,$(OBJS) version.o $(ZLIB),$(ZLIBS) $(LIB_HES),$(ATHETCDIR))
+  install_man(zephyrd.8,zephyrd.8)
+  install_file(default.subscriptions,$(ZLIBDIR))
+  
+--- 54,60 ----
+  	zstring.o
+  
+  error_table(zsrv_err)
+! SimpleProgram(zephyrd,$(OBJS) $(SYSLOG_OBJ) version.o $(ZLIB), $(ZLIBS) $(LIB_HES), $(ATHETCDIR))
+  install_man(zephyrd.8,zephyrd.8)
+  install_file(default.subscriptions,$(ZLIBDIR))
+  
+diff -c /mit/zephyr/src/server/class.c ./class.c
+*** /mit/zephyr/src/server/class.c	Mon Aug  1 08:38:18 1994
+--- ./class.c	Wed Jul  6 17:19:14 1994
+***************
+*** 28,44 ****
+   *
+   * External functions are:
+   *
+!  * Code_t class_register(client, subs)
+   *
+!  * Code_t class_deregister(client, subs)
+   *
+!  * ZClientList_t *class_lookup(subs)
+   *	ZClient_t *client;
+   *	ZSubscr_t *subs;
+   *
+-  * void class_free(lyst)
+-  *	ZClientList_t *lyst;
+-  *
+   * ZAcl_t *class_get_acl(ZString class_name)
+   *
+   * Code_t class_restrict(class_name, acl)
+--- 28,41 ----
+   *
+   * External functions are:
+   *
+!  * Code_t triplet_register(client, subs)
+   *
+!  * Code_t triplet_deregister(client, subs)
+   *
+!  * ZClientList_t *triplet_lookup(subs)
+   *	ZClient_t *client;
+   *	ZSubscr_t *subs;
+   *
+   * ZAcl_t *class_get_acl(ZString class_name)
+   *
+   * Code_t class_restrict(class_name, acl)
+***************
+*** 75,83 ****
+  #define	EMPTY_CLASS	2000
+  
+  #define	HASHSIZE	1023
+! #define CLASS_HASHVAL(cl,in) (cl->hash_val ^ in->hash_val) % HASHSIZE
+  
+! static ZClass_t *class_bucket[HASHSIZE]; /* the hash table of pointers */
+  
+  
+  #ifdef __STDC__
+--- 72,82 ----
+  #define	EMPTY_CLASS	2000
+  
+  #define	HASHSIZE	1023
+! #define HASHVAL(c, i, r) (((c)->hash_val ^ (i)->hash_val ^ (r)->hash_val) \
+! 			  % HASHSIZE)
+! #define DEST_HASHVAL(dest) HASHVAL((dest).classname, (dest).inst, (dest).recip)
+  
+! static ZTriplet_t *class_bucket[HASHSIZE]; /* the hash table of pointers */
+  
+  
+  #ifdef __STDC__
+***************
+*** 86,165 ****
+  # define P(s) ()
+  #endif
+  
+! static Code_t remove_client P((ZClass_t *ptr, ZClient_t *client)),
+!     insert_client P((ZClass_t *ptr, ZClient_t *client));
+  static ZClientList_t *client_alloc P((ZClient_t *client));
+! static ZClass_t *class_alloc P((ZSTRING *classname, ZSTRING *inst));
+! static void free_class P((ZClass_t *));
+  
+  /* public routines */
+  
+! void
+! set_ZDestination_hash(zd)
+!      ZDestination *zd;
+! {
+!   zd->hash_value = (zd->classname->hash_val ^ zd->inst->hash_val) % HASHSIZE;
+! }
+  
+- 
+  int ZDest_eq(d1, d2)
+       ZDestination *d1, *d2;
+  {
+!   return((d1->hash_value == d2->hash_value) &&
+! 	 (d1->classname == d2->classname) &&
+! 	 (d1->inst == d2->inst));
+  }
+  
+- int order_dest_strings(d1, d2)
+-      ZDestination *d1, *d2;
+- {
+-   int i;
+  
+!   i = strcmp(d1->classname->string, d2->classname->string);
+!   if (i != 0)
+!     return (i);
+!   i = strcmp(d1->inst->string, d2->inst->string);
+!   if (i != 0)
+!     return(i);
+!   i = strcmp(d1->recip->string, d2->recip->string);
+!   if (i != 0)
+!     return(i);
+!   syslog(LOG_WARNING,"order_dest_strings equal");
+!   return(1); /* be arbitrary */
+! }
+  
+- int ZDest_geq(d1, d2)
+-      ZDestination *d1, *d2;
+- {
+-   return((d1->hash_value != d2->hash_value) ?
+- 	 (d1->hash_value < d2->hash_value) :
+- 	 ((order_dest_strings(d1,d2) < 0)));
+- }
+- 
+- 
+- 
+- /* register the client as interested in class */
+- 
+  Code_t
+! class_register(client, subs)
+       ZClient_t *client;
+!      ZSubscr_t *subs;
+  {
+! 	register ZClass_t *ptr, *ptr2;
+  	unsigned long hashval;
+  
+! 	hashval = CLASS_HASHVAL(subs->zst_dest.classname, subs->zst_dest.inst);
+  
+  	if (!(ptr = class_bucket[hashval])) {
+  		/* not registered */
+  		
+! 		if (!(ptr = class_alloc(subs->zst_dest.classname,
+! 					subs->zst_dest.inst)))
+  			return(ENOMEM);
+  
+  		/* allocate the head of the bucket */
+  
+! 		if (!(ptr2 = (ZClass_t *) xmalloc(sizeof(ZClass_t))))
+  		  return(ENOMEM);
+  
+  		ptr2->zct_clientlist = 0;
+--- 85,143 ----
+  # define P(s) ()
+  #endif
+  
+! static Code_t remove_client P((ZTriplet_t *ptr, ZClient_t *client));
+! static Code_t insert_client P((ZTriplet_t *ptr, ZClient_t *client));
+  static ZClientList_t *client_alloc P((ZClient_t *client));
+! static ZTriplet_t *triplet_alloc P((ZSTRING *classname, ZSTRING *inst,
+! 				ZSTRING *recipient));
+! static void free_class P((ZTriplet_t *));
+  
+  /* public routines */
+  
+! /*
+!  * Determine if two destination triplets are equal.  Note the backup
+!  * case-insensitive recipient check in the third term.  Recipients are
+!  * not downcased at subscription time (in order to preserve case for,
+!  * say, "zctl ret"), but traditional zephyr server behavior has not
+!  * been case-sensitive in the recipient string.  In most cases, a
+!  * failed match will fail on the classname or instance, and a successful
+!  * match will succeed on the (d1->recip == d2->recip) check, so this
+!  * shouldn't affect performance.  Note that this invalidates the overall
+!  * hash value check, which was of dubious value to start with.
+!  */
+  
+  int ZDest_eq(d1, d2)
+       ZDestination *d1, *d2;
+  {
+!   return((d1->classname == d2->classname) &&
+! 	 (d1->inst == d2->inst) &&
+! 	 (d1->recip == d2->recip ||
+! 	  strcasecmp(d1->recip->string, d2->recip->string) == 0));
+  }
+  
+  
+! /* register the client as interested in a triplet */
+  
+  Code_t
+! triplet_register(client, dest)
+       ZClient_t *client;
+!      ZDestination *dest;
+  {
+! 	register ZTriplet_t *ptr, *ptr2;
+  	unsigned long hashval;
+  
+! 	hashval = DEST_HASHVAL(*dest);
+  
+  	if (!(ptr = class_bucket[hashval])) {
+  		/* not registered */
+  		
+! 		ptr = triplet_alloc(dest->classname, dest->inst, dest->recip);
+! 		if (!ptr)
+  			return(ENOMEM);
+  
+  		/* allocate the head of the bucket */
+  
+! 		if (!(ptr2 = (ZTriplet_t *) xmalloc(sizeof(ZTriplet_t))))
+  		  return(ENOMEM);
+  
+  		ptr2->zct_clientlist = 0;
+***************
+*** 173,186 ****
+  		return(insert_client(ptr, client));
+  
+  	} else {
+! 		for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw)
+  		    /* walk down the list, looking for a match */
+! 		    if (ZDest_eq(&ptr2->zct_dest,&subs->zst_dest))
+  		      return(insert_client(ptr2, client));
+  
+  		/* fell off the end, no match */
+! 		if (!(ptr2 = class_alloc(subs->zst_dest.classname,
+! 					 subs->zst_dest.inst)))
+  			return(ENOMEM);
+  
+  		xinsque(ptr2, ptr);	/* insert new class into hash bucket */
+--- 151,165 ----
+  		return(insert_client(ptr, client));
+  
+  	} else {
+! 		for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw) {
+  		    /* walk down the list, looking for a match */
+! 		    if (ZDest_eq(&ptr2->zct_dest,dest))
+  		      return(insert_client(ptr2, client));
++ 		}
+  
+  		/* fell off the end, no match */
+! 		ptr2 = triplet_alloc(dest->classname, dest->inst, dest->recip);
+! 		if (!ptr2)
+  			return(ENOMEM);
+  
+  		xinsque(ptr2, ptr);	/* insert new class into hash bucket */
+***************
+*** 191,218 ****
+  /* dissociate client from the class, garbage collecting if appropriate */
+  
+  Code_t
+! class_deregister(client, subs)
+       ZClient_t *client;
+!      ZSubscr_t *subs;
+  {
+! 	register ZClass_t *ptr, *ptr2;
+  	int retval = -1;
+  	unsigned long hashval;
+  
+! 	hashval = CLASS_HASHVAL(subs->zst_dest.classname, subs->zst_dest.inst);
+  #if 0
+! 	zdbug((LOG_DEBUG, "class_dereg: %s %s",
+! 		subs->zst_dest.classname->string,
+! 		subs->zst_dest.inst->string));
+  #endif
+! 	if (!(ptr = class_bucket[hashval]))
+  		/* no such class to deregister */
+  		return(ZSRV_BADASSOC);
+  	
+  	for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw) {
+  		/* walk down the list, looking for a match */
+! 		if (ZDest_eq(&ptr2->zct_dest,&subs->zst_dest)) {
+! 			if ((retval = remove_client(ptr2, client)) == EMPTY_CLASS) {
+  #if 0
+  				zdbug((LOG_DEBUG,"empty class"));
+  #endif
+--- 170,198 ----
+  /* dissociate client from the class, garbage collecting if appropriate */
+  
+  Code_t
+! triplet_deregister(client, dest)
+       ZClient_t *client;
+!      ZDestination *dest;
+  {
+! 	register ZTriplet_t *ptr, *ptr2;
+  	int retval = -1;
+  	unsigned long hashval;
+  
+! 	hashval = DEST_HASHVAL(*dest);
+  #if 0
+! 	zdbug((LOG_DEBUG, "class_dereg: %s %s",	dest->classname->string,
+! 	       dest->inst->string));
+  #endif
+! 	ptr = class_bucket[hashval];
+! 	if (!ptr)
+  		/* no such class to deregister */
+  		return(ZSRV_BADASSOC);
+  	
+  	for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw) {
+  		/* walk down the list, looking for a match */
+! 		if (ZDest_eq(&ptr2->zct_dest,dest)) {
+! 			retval = remove_client(ptr2, client);
+! 			if (retval == EMPTY_CLASS) {
+  #if 0
+  				zdbug((LOG_DEBUG,"empty class"));
+  #endif
+***************
+*** 237,331 ****
+  	return(retval);
+  }
+  
+! /* return a linked list of what clients are interested in this class */
+  
+  ZClientList_t *
+! class_lookup(subs)
+!      ZSubscr_t *subs;
+  {
+! 	register ZClass_t *ptr, *ptr2;
+! 	register int count = 0, wc_count = 0, idx = 1;
+! 	register ZClientList_t *list_return, *list_copy;
+! 	ZClientList_t *list = NULLZCLT;
+! 	ZClientList_t *wc_list = NULLZCLT;
+! 	ZSubscr_t wc_sub;
+  	unsigned long hashval;
+  
+! 	hashval = CLASS_HASHVAL(subs->zst_dest.classname, subs->zst_dest.inst);
+  
+! 	if ((ptr = class_bucket[hashval]) !=  NULLZCT)
+! 		/* go search the list for the class */
+! 		for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw) {
+! 			/* walk down the list, looking for a match */
+! 			if (ZDest_eq(&ptr2->zct_dest,&subs->zst_dest)) {
+! 				list = ptr2->zct_clientlist;
+! 				break;
+! 			}
+! 		}
+! 	/* list is the list of direct matches; now check for wildcards */
+! 	wc_sub = *subs;
+! 	wc_sub.zst_dest.inst = wildcard_instance;
+! 	set_ZDestination_hash(&wc_sub.zst_dest);
+! 
+! 	hashval = CLASS_HASHVAL(wc_sub.zst_dest.classname, wc_sub.zst_dest.inst);
+! 	if ((ptr = class_bucket[hashval]) != NULLZCT)
+! 		/* go search the list for the class */
+! 		for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw) {
+! 			/* walk down the list, looking for a match */
+! 			if (ZDest_eq(&ptr2->zct_dest,&wc_sub.zst_dest)) {
+! 				wc_list = ptr2->zct_clientlist;
+! 				break;
+! 			}
+! 		}
+! 	/* merge the lists for returning */
+! 	if (list)
+! 		for (list_return = list->q_forw;
+! 		     list_return != list;
+! 		     list_return = list_return->q_forw)
+! 			count++;
+! 	if (wc_list)
+! 		for (list_return = wc_list->q_forw;
+! 		     list_return != wc_list;
+! 		     list_return = list_return->q_forw)
+! 			wc_count++;
+! 	
+! 	if (!(wc_count + count))
+! 		return(NULLZCLT);
+! 	list_return = (ZClientList_t *) xmalloc((count + wc_count + 1)
+! 						* sizeof(ZClientList_t));
+! 	if (!list_return) {
+! 		syslog(LOG_ERR, "class_lookup no mem");
+! 		return(NULLZCLT);
+  	}
+! 	list_return[0].q_forw = list_return[0].q_back = &list_return[0];
+! 	if (list)
+! 		for (list_copy = list->q_forw;
+! 		     list_copy != list;
+! 		     list_copy = list_copy->q_forw) {
+! 			list_return[idx].zclt_client = list_copy->zclt_client;
+! 			xinsque(&list_return[idx], &list_return[0]);
+! 			idx++;
+! 		}
+! 	if (wc_list)
+! 		for (list_copy = wc_list->q_forw;
+! 		     list_copy != wc_list;
+! 		     list_copy = list_copy->q_forw) {
+! 			list_return[idx].zclt_client = list_copy->zclt_client;
+! 			xinsque(&list_return[idx], &list_return[0]);
+! 			idx++;
+! 		}
+! 	return(list_return);
+  }
+  
+- /* free up the storage used by a returned list */
+- void
+- class_free(lyst)
+-      ZClientList_t *lyst;
+- {
+- 	xfree(lyst);
+- 	return;
+- }
+- 
+  /*
+   * return the acl structure associated with class, or NULLZACLT if there is
+   * no such acl struct
+--- 217,245 ----
+  	return(retval);
+  }
+  
+! /* return a linked list of what clients are interested in this triplet */
+  
+  ZClientList_t *
+! triplet_lookup(dest)
+!      ZDestination *dest;
+  {
+! 	register ZTriplet_t *class, *p;
+  	unsigned long hashval;
+  
+! 	hashval = DEST_HASHVAL(*dest);
+! 	p = class_bucket[hashval];
+! 	if (p == NULLZT)
+! 		return NULLZCLT;
+  
+! 	/* Go search the list for the class */
+! 	for (class = p->q_forw; class != p; class = class->q_forw) {
+! 		/* walk down the list, looking for a match */
+! 		if (ZDest_eq(&class->zct_dest,dest))
+! 			return class->zct_clientlist;
+  	}
+! 	return NULLZCLT;
+  }
+  
+  /*
+   * return the acl structure associated with class, or NULLZACLT if there is
+   * no such acl struct
+***************
+*** 335,344 ****
+  class_get_acl(class_name)
+       ZSTRING *class_name;
+  {
+! 	register ZClass_t *ptr, *ptr2;
+  	unsigned long hashval;
+  
+! 	hashval = CLASS_HASHVAL(class_name, empty);
+  	if (!(ptr = class_bucket[hashval]))
+  		return(NULLZACLT);
+  
+--- 249,258 ----
+  class_get_acl(class_name)
+       ZSTRING *class_name;
+  {
+! 	register ZTriplet_t *ptr, *ptr2;
+  	unsigned long hashval;
+  
+! 	hashval = HASHVAL(class_name, empty, empty);
+  	if (!(ptr = class_bucket[hashval]))
+  		return(NULLZACLT);
+  
+***************
+*** 345,351 ****
+  	/* walk down the list, looking for a match */
+  	for (ptr2 = ptr->q_back; ptr2 != ptr; ptr2 = ptr2->q_back)
+  	    if ((ptr2->zct_dest.classname == class_name) &&
+! 		(ptr2->zct_dest.inst == empty))
+  		return(ptr2->zct_acl);
+  
+  	/* fell off the end, no match ==> not restricted */
+--- 259,266 ----
+  	/* walk down the list, looking for a match */
+  	for (ptr2 = ptr->q_back; ptr2 != ptr; ptr2 = ptr2->q_back)
+  	    if ((ptr2->zct_dest.classname == class_name) &&
+! 		(ptr2->zct_dest.inst == empty) &&
+! 		(ptr2->zct_dest.recip == empty))
+  		return(ptr2->zct_acl);
+  
+  	/* fell off the end, no match ==> not restricted */
+***************
+*** 363,374 ****
+       char *class_name;
+       ZAcl_t *acl;
+  {
+! 	register ZClass_t *ptr, *ptr2;
+  	ZSTRING *d;
+  	unsigned long hashval;
+  
+  	d = make_zstring(class_name,1);
+! 	hashval = CLASS_HASHVAL(d,empty);
+  
+  	if (!(ptr = class_bucket[hashval])) {
+  	  free_zstring(d);
+--- 278,289 ----
+       char *class_name;
+       ZAcl_t *acl;
+  {
+! 	register ZTriplet_t *ptr, *ptr2;
+  	ZSTRING *d;
+  	unsigned long hashval;
+  
+  	d = make_zstring(class_name,1);
+! 	hashval = HASHVAL(d, empty, empty);
+  
+  	if (!(ptr = class_bucket[hashval])) {
+  	  free_zstring(d);
+***************
+*** 377,383 ****
+  	for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw)
+  		/* walk down the list, looking for a match */
+  		if ((ptr2->zct_dest.classname == d) &&
+! 		    (ptr2->zct_dest.inst == empty)){
+  			if (ptr2->zct_acl)
+  				return ZSRV_CLASSRESTRICTED;
+  			ptr2->zct_acl = acl;
+--- 292,299 ----
+  	for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw)
+  		/* walk down the list, looking for a match */
+  		if ((ptr2->zct_dest.classname == d) &&
+! 		    (ptr2->zct_dest.inst == empty) &&
+! 		    (ptr2->zct_dest.recip == empty)) {
+  			if (ptr2->zct_acl)
+  				return ZSRV_CLASSRESTRICTED;
+  			ptr2->zct_acl = acl;
+***************
+*** 401,423 ****
+       char *class_name;
+       ZAcl_t *acl;
+  {
+! 	register ZClass_t *ptr, *ptr2;
+  	ZSTRING *d;
+  	unsigned long hashval;
+  
+  	d = make_zstring(class_name,1);
+! 	hashval = CLASS_HASHVAL(d,empty);
+  
+  	if (!(ptr = class_bucket[hashval])) {
+  		/* not registered */
+  
+! 		if (!(ptr = class_alloc(d,empty)))
+  		  return(ENOMEM);
+  
+  		ptr->zct_acl = acl;
+  
+  		/* allocate the head of the bucket */
+! 		if (!(ptr2 = (ZClass_t *) xmalloc(sizeof(ZClass_t))))
+  		  return(ENOMEM);
+  
+  		ptr2->q_forw = ptr;
+--- 317,341 ----
+       char *class_name;
+       ZAcl_t *acl;
+  {
+! 	register ZTriplet_t *ptr, *ptr2;
+  	ZSTRING *d;
+  	unsigned long hashval;
+  
+  	d = make_zstring(class_name,1);
+! 	hashval = HASHVAL(d, empty, empty);
+  
+  	if (!(ptr = class_bucket[hashval])) {
+  		/* not registered */
+  
+! 		ptr = triplet_alloc(d,empty,empty);
+! 		if (!ptr)
+  		  return(ENOMEM);
+  
+  		ptr->zct_acl = acl;
+  
+  		/* allocate the head of the bucket */
+! 		ptr2 = (ZTriplet_t *) xmalloc(sizeof(ZTriplet_t));
+! 		if (!ptr2)
+  		  return(ENOMEM);
+  
+  		ptr2->q_forw = ptr;
+***************
+*** 432,442 ****
+  	    for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw)
+  		/* walk down the list, looking for a match */
+  		if ((ptr2->zct_dest.classname == d) &&
+! 		    (ptr2->zct_dest.inst == empty)) {
+  		  free_zstring(d);
+  		  return(ZSRV_CLASSXISTS);
+  		}
+! 	    if (!(ptr2 = class_alloc(d,empty))) {
+  	      free_zstring(d);
+  	      return(ENOMEM);
+  	    }
+--- 350,361 ----
+  	    for (ptr2 = ptr->q_forw; ptr2 != ptr; ptr2 = ptr2->q_forw)
+  		/* walk down the list, looking for a match */
+  		if ((ptr2->zct_dest.classname == d) &&
+! 		    (ptr2->zct_dest.inst == empty) &&
+! 		    (ptr2->zct_dest.recip == empty)) {
+  		  free_zstring(d);
+  		  return(ZSRV_CLASSXISTS);
+  		}
+! 	    if (!(ptr2 = triplet_alloc(d,empty,empty))) {
+  	      free_zstring(d);
+  	      return(ENOMEM);
+  	    }
+***************
+*** 452,477 ****
+  
+  /* allocate space for a class structure */
+  
+! static ZClass_t *
+! class_alloc(classname,inst)
+       ZSTRING *classname;
+       ZSTRING *inst;
+  {
+! 	register ZClass_t *ptr;
+  	ZClientList_t *clist;
+  
+! 	if (!(ptr = (ZClass_t *) xmalloc(sizeof(ZClass_t))))
+! 	    return(NULLZCT);
+  
+  	ptr->q_forw = ptr->q_back = ptr;
+  	ptr->zct_dest.classname = dup_zstring(classname);
+  	ptr->zct_dest.inst = dup_zstring(inst);
+! 	ptr->zct_dest.recip = dup_zstring(empty);
+! 	set_ZDestination_hash(&ptr->zct_dest);
+  
+  	if (!(clist = (ZClientList_t *) xmalloc (sizeof (ZClientList_t)))) {
+  	    xfree(ptr);
+! 	    return(NULLZCT);
+  	}
+  	clist->q_forw = clist->q_back = clist;
+  	ptr->zct_clientlist = clist;
+--- 371,396 ----
+  
+  /* allocate space for a class structure */
+  
+! static ZTriplet_t *
+! triplet_alloc(classname,inst,recipient)
+       ZSTRING *classname;
+       ZSTRING *inst;
++      ZSTRING *recipient;
+  {
+! 	register ZTriplet_t *ptr;
+  	ZClientList_t *clist;
+  
+! 	if (!(ptr = (ZTriplet_t *) xmalloc(sizeof(ZTriplet_t))))
+! 	    return(NULLZT);
+  
+  	ptr->q_forw = ptr->q_back = ptr;
+  	ptr->zct_dest.classname = dup_zstring(classname);
+  	ptr->zct_dest.inst = dup_zstring(inst);
+! 	ptr->zct_dest.recip = dup_zstring(recipient);
+  
+  	if (!(clist = (ZClientList_t *) xmalloc (sizeof (ZClientList_t)))) {
+  	    xfree(ptr);
+! 	    return(NULLZT);
+  	}
+  	clist->q_forw = clist->q_back = clist;
+  	ptr->zct_clientlist = clist;
+***************
+*** 500,506 ****
+  
+  static Code_t
+  insert_client(ptr, client)
+!      ZClass_t *ptr;
+       ZClient_t *client;
+  {
+  	register ZClientList_t *listp, *clist;
+--- 419,425 ----
+  
+  static Code_t
+  insert_client(ptr, client)
+!      ZTriplet_t *ptr;
+       ZClient_t *client;
+  {
+  	register ZClientList_t *listp, *clist;
+***************
+*** 507,516 ****
+  
+  	for (clist = ptr->zct_clientlist->q_forw;
+  	     clist != ptr->zct_clientlist;
+! 	     clist = clist->q_forw)
+  		/* don't duplicate */
+  		if (clist->zclt_client == client)
+! 			return(ZERR_NONE);
+  
+  	if (!(listp = client_alloc(client)))
+  		return(ENOMEM);
+--- 426,436 ----
+  
+  	for (clist = ptr->zct_clientlist->q_forw;
+  	     clist != ptr->zct_clientlist;
+! 	     clist = clist->q_forw) {
+  		/* don't duplicate */
+  		if (clist->zclt_client == client)
+! 			return(ZSRV_CLASSXISTS);
+! 	}
+  
+  	if (!(listp = client_alloc(client)))
+  		return(ENOMEM);
+***************
+*** 525,531 ****
+   */
+  
+  static Code_t remove_client(ptr, client)
+!      ZClass_t *ptr;
+       ZClient_t *client;
+  {
+  	register ZClientList_t *listp = ptr->zct_clientlist; 
+--- 445,451 ----
+   */
+  
+  static Code_t remove_client(ptr, client)
+!      ZTriplet_t *ptr;
+       ZClient_t *client;
+  {
+  	register ZClientList_t *listp = ptr->zct_clientlist; 
+***************
+*** 549,555 ****
+  }
+  
+  static void free_class(class)
+!      ZClass_t *class;
+  {
+    free_zstring(class->zct_dest.classname);
+    free_zstring(class->zct_dest.inst);
+--- 469,475 ----
+  }
+  
+  static void free_class(class)
+!      ZTriplet_t *class;
+  {
+    free_zstring(class->zct_dest.classname);
+    free_zstring(class->zct_dest.inst);
+diff -c /mit/zephyr/src/server/client.c ./client.c
+*** /mit/zephyr/src/server/client.c	Mon Aug  1 08:43:42 1994
+--- ./client.c	Wed Jul  6 17:19:14 1994
+***************
+*** 100,105 ****
+--- 100,106 ----
+  
+  	(*client)->last_msg = 0;
+  	(*client)->last_check = 0;
++ 	(*client)->last_send = 0;
+  
+  	if (!(clist = (ZClientList_t *) xmalloc(sizeof(ZClientList_t)))) {
+  	  xfree(*client);
+diff -c /mit/zephyr/src/server/common.c ./common.c
+*** /mit/zephyr/src/server/common.c	Wed Aug 26 00:36:11 1992
+--- ./common.c	Wed Jul  6 17:19:14 1994
+***************
+*** 49,55 ****
+      return(ret);
+  }
+  
+! /* generic string hash function */
+  
+  unsigned long
+  #ifdef __STDC__
+--- 49,55 ----
+      return(ret);
+  }
+  
+! /* The "& 0x5f" provides case-insensitivity for ASCII. */
+  
+  unsigned long
+  #ifdef __STDC__
+***************
+*** 63,89 ****
+  	register char cp;
+  
+  	while (1) {
+! 	    cp = *string++;
+  	    if (!cp)
+  		break;
+  	    hval += cp;
+  
+! 	    cp = *string++;
+  	    if (!cp)
+  		break;
+  	    hval += cp * (3 + (1 << 16));
+  
+! 	    cp = *string++;
+  	    if (!cp)
+  		break;
+  	    hval += cp * (1 + (1 << 8));
+  
+! 	    cp = *string++;
+  	    if (!cp)
+  		break;
+  	    hval += cp * (1 + (1 << 12));
+  
+! 	    cp = *string++;
+  	    if (!cp)
+  		break;
+  	    hval += cp * (1 + (1 << 4));
+--- 63,89 ----
+  	register char cp;
+  
+  	while (1) {
+! 	    cp = *string++ & 0x5f;
+  	    if (!cp)
+  		break;
+  	    hval += cp;
+  
+! 	    cp = *string++ & 0x5f;
+  	    if (!cp)
+  		break;
+  	    hval += cp * (3 + (1 << 16));
+  
+! 	    cp = *string++ & 0x5f;
+  	    if (!cp)
+  		break;
+  	    hval += cp * (1 + (1 << 8));
+  
+! 	    cp = *string++ & 0x5f;
+  	    if (!cp)
+  		break;
+  	    hval += cp * (1 + (1 << 12));
+  
+! 	    cp = *string++ & 0x5f;
+  	    if (!cp)
+  		break;
+  	    hval += cp * (1 + (1 << 4));
+diff -c /mit/zephyr/src/server/dispatch.c ./dispatch.c
+*** /mit/zephyr/src/server/dispatch.c	Tue Mar 15 12:44:24 1994
+--- ./dispatch.c	Wed Jul  6 17:19:15 1994
+***************
+*** 74,79 ****
+--- 74,80 ----
+  
+  static void nack_cancel P((register ZNotice_t *, struct sockaddr_in *));
+  static void dispatch P((ZNotice_t *, int, struct sockaddr_in *, int));
++ static int send_to_send P((ZNotice_t *, int, ZDestination *dest, int));
+  
+  #undef P
+  
+***************
+*** 346,364 ****
+       int auth;
+       struct sockaddr_in *who;
+  {
+! 	int acked = 0;
+  	ZAcl_t *acl;
+! 	register ZClientList_t *clientlist, *ptr;
+! 	ZSTRING *z;
+  
+! 	z = make_zstring(notice->z_class,1);
+! 	if ((acl = class_get_acl(z)) != NULLZACLT) {
+! 	  free_zstring(z);
+  	    /* if controlled and not auth, fail */
+  	    if (!auth) {
+  		syslog(LOG_WARNING, "sendit unauthentic %s from %s",
+  		       notice->z_class, notice->z_sender);
+  		clt_ack(notice, who, AUTH_FAILED);
+  		return;
+  	    }
+  	    /* if not auth to transmit, fail */
+--- 347,366 ----
+       int auth;
+       struct sockaddr_in *who;
+  {
+! 	static int send_counter = 0;
+! 	int any = 0;
+  	ZAcl_t *acl;
+! 	ZDestination dest;
+! 	ZSTRING *class;
+  
+! 	class = make_zstring(notice->z_class,1);
+! 	if ((acl = class_get_acl(class)) != NULLZACLT) {
+  	    /* if controlled and not auth, fail */
+  	    if (!auth) {
+  		syslog(LOG_WARNING, "sendit unauthentic %s from %s",
+  		       notice->z_class, notice->z_sender);
+  		clt_ack(notice, who, AUTH_FAILED);
++ 		free_zstring(class);
+  		return;
+  	    }
+  	    /* if not auth to transmit, fail */
+***************
+*** 366,371 ****
+--- 368,374 ----
+  		syslog(LOG_WARNING, "sendit unauthorized %s from %s",
+  		       notice->z_class, notice->z_sender);
+  		clt_ack(notice, who, AUTH_FAILED);
++ 		free_zstring(class);
+  		return;
+  	    }
+  	  /* sender != inst and not auth to send to others --> fail */
+***************
+*** 377,382 ****
+--- 380,386 ----
+  		   notice->z_class,
+  		   notice->z_class_inst);
+  	    clt_ack(notice, who, AUTH_FAILED);
++ 	    free_zstring(class);
+  	    return;
+  	  }
+  	}
+***************
+*** 391,396 ****
+--- 395,401 ----
+  		syslog(LOG_WARNING, "sendit unauthentic fake packet: claimed %s, real %s",
+  		       inet_ntoa(notice->z_sender_addr), buffer);
+  		clt_ack(notice, who, AUTH_FAILED);
++ 		free_zstring(class);
+  		return;
+  	    }
+  	    if (ntohl(notice->z_sender_addr.s_addr) != 0) {
+***************
+*** 397,425 ****
+  		syslog(LOG_WARNING, "sendit invalid address: claimed %s, real %s",
+  		       inet_ntoa(notice->z_sender_addr), buffer);
+  		clt_ack(notice, who, AUTH_FAILED);
+  		return;
+  	    }
+  	    syslog(LOG_WARNING, "sendit addr mismatch: claimed %s, real %s",
+  		   inet_ntoa(notice->z_sender_addr), buffer);
+  	}
+- 	if ((clientlist = subscr_match_list(notice)) != NULLZCLT) {
+- 		for (ptr = clientlist->q_forw;
+- 		     ptr != clientlist;
+- 		     ptr = ptr->q_forw) {
+- 			/* for each client who gets this notice,
+- 			   send it along */
+- 			xmit(notice, &(ptr->zclt_client->zct_sin), auth,
+- 			     ptr->zclt_client);
+- 			if (!acked) {
+- 				acked = 1;
+- 				ack(notice, who);
+- 			}
+- 		}
+- 		subscr_free_list(clientlist);
+- 	}
+  
+! 	if (!acked)
+  		nack(notice, who);
+  }
+  
+  /*
+--- 402,473 ----
+  		syslog(LOG_WARNING, "sendit invalid address: claimed %s, real %s",
+  		       inet_ntoa(notice->z_sender_addr), buffer);
+  		clt_ack(notice, who, AUTH_FAILED);
++ 		free_zstring(class);
+  		return;
+  	    }
+  	    syslog(LOG_WARNING, "sendit addr mismatch: claimed %s, real %s",
+  		   inet_ntoa(notice->z_sender_addr), buffer);
+  	}
+  
+! 	/* Increment the send counter, used to prevent duplicate sends to
+! 	 * clients.  On the off-chance that we wrap around to 0, skip over
+! 	 * it to prevent missing clients which have never had a packet
+! 	 * sent to them. */
+! 	send_counter++;
+! 	if (send_counter == 0)
+! 		send_counter = 1;
+! 
+! 	/* Send to clients subscribed to the triplet itself. */
+! 	dest.classname = class;
+! 	dest.inst = make_zstring(notice->z_class_inst, 1);
+! 	dest.recip = make_zstring(notice->z_recipient, 0);
+! 	if (send_to_dest(notice, auth, &dest, send_counter))
+! 		any = 1;
+! 
+! 	/* Send to clients subscribed to the triplet with the instance
+! 	 * substituted with the wildcard instance. */
+! 	free_zstring(dest.inst);
+! 	dest.inst = wildcard_instance;
+! 	if (send_to_dest(notice, auth, &dest, send_counter))
+! 		any = 1;
+! 
+! 	free_zstring(class);
+! 	free_zstring(dest.recip);
+! 	if (any)
+! 		ack(notice, who);
+! 	else
+  		nack(notice, who);
++ }
++ 
++ /*
++  * Send to each client in the list.  Avoid duplicates by setting
++  * last_send on each client to send_counter, a nonce which is updated
++  * by sendit() above.
++  */
++ 
++ static int
++ send_to_dest(notice, auth, dest, send_counter)
++      ZNotice_t *notice;
++      int auth;
++      ZDestination *dest;
++      int send_counter;
++ {
++ 	register ZClientList_t *list, *p;
++ 	register ZClient_t *client;
++ 	register int any = 0;
++ 
++ 	list = triplet_lookup(dest);
++ 	if (list != NULLZCLT) {
++ 		for (p = list->q_forw; p != list; p = p->q_forw) {
++ 			client = p->zclt_client;
++ 			if (client->last_send == send_counter)
++ 				continue;
++ 			client->last_send = send_counter;
++ 			xmit(notice, &(client->zct_sin), auth, client);
++ 			any = 1;
++ 		}
++ 	}
++ 	return any;
+  }
+  
+  /*
+diff -c /mit/zephyr/src/server/main.c ./main.c
+*** /mit/zephyr/src/server/main.c	Mon Aug  1 08:43:47 1994
+--- ./main.c	Wed Jul  6 17:19:15 1994
+***************
+*** 442,458 ****
+  	class_hm = make_zstring(HM_CTL_CLASS, 1);
+  	class_ulogin = make_zstring(LOGIN_CLASS, 1);
+  	class_ulocate = make_zstring(LOCATE_CLASS, 1);
+- 	wildcard_class = make_zstring(MATCHALL_CLASS, 1);
+  	wildcard_instance = make_zstring(WILDCARD_INSTANCE, 1);
+  	empty = make_zstring("", 0);
+  
+- 	matchall_sub.q_forw = &matchall_sub;
+- 	matchall_sub.q_back = &matchall_sub;
+- 	matchall_sub.zst_dest.classname = wildcard_class;
+- 	matchall_sub.zst_dest.inst = dup_zstring(empty);
+- 	matchall_sub.zst_dest.recip = dup_zstring(empty);
+- 
+- 	set_ZDestination_hash(&matchall_sub.zst_dest);
+  	/* restrict certain classes */
+  	access_init();
+  	return(0);
+--- 442,450 ----
+diff -c /mit/zephyr/src/server/server.c ./server.c
+*** /mit/zephyr/src/server/server.c	Mon Aug  1 08:43:51 1994
+--- ./server.c	Wed Jul  6 17:19:16 1994
+***************
+*** 1770,1777 ****
+  
+  	/* search the not-yet-acked list for anything destined to him, and
+  	   flush it. */
+! 	for (nacked = nacklist->q_forw;
+! 	     nacked != nacklist;)
+  		if (&otherservers[nacked->na_srv_idx] == server) {
+  			/* go back, since remque will change things */
+  			nack2 = nacked->q_back;
+--- 1770,1777 ----
+  
+  	/* search the not-yet-acked list for anything destined to him, and
+  	   flush it. */
+! 	for (nacked = srv_nacklist->q_forw;
+! 	     nacked != srv_nacklist;)
+  		if (&otherservers[nacked->na_srv_idx] == server) {
+  			/* go back, since remque will change things */
+  			nack2 = nacked->q_back;
+diff -c /mit/zephyr/src/server/subscr.c ./subscr.c
+*** /mit/zephyr/src/server/subscr.c	Mon Aug  1 08:43:37 1994
+--- ./subscr.c	Wed Jul  6 17:19:16 1994
+***************
+*** 80,86 ****
+  
+  /* for compatibility when sending subscription information to old clients */
+  
+- static void check_sub_order P((ZSubscr_t *subs, int wc));
+  #ifdef OLD_COMPAT
+  #define	OLD_ZEPHYR_VERSION	"ZEPH0.0"
+  #define	OLD_CLIENT_INCOMPSUBS	"INCOMP"
+--- 80,85 ----
+***************
+*** 96,110 ****
+  #endif /* NEW_COMPAT */
+  
+  extern char *re_comp(), *re_conv();
+  static ZSubscr_t *extract_subscriptions P((register ZNotice_t *notice));
+- static int clt_unique P((ZClient_t *clt, ZClientList_t *clist));
+  static void free_subscriptions P((register ZSubscr_t *subs));
+  static char **subscr_marshal_subs P((ZNotice_t *notice, int auth,
+! 					struct sockaddr_in *who,
+! 					register int *found));
+! static Code_t subscr_subscribe_real P((ZClient_t *who, ZSubscr_t *newsubs,
+! 				    ZNotice_t *notice));
+! static ZSubscr_t *subscr_copy_def_subs P((char *));
+  static int cl_match  P((ZSubscr_t*, ZClient_t *));
+  
+  static int defaults_read = 0;		/* set to 1 if the default subs
+--- 95,108 ----
+  #endif /* NEW_COMPAT */
+  
+  extern char *re_comp(), *re_conv();
++ static Code_t add_subscriptions P((ZClient_t *who, ZSubscr_t *subs_queue,
++ 				   ZNotice_t *notice));
+  static ZSubscr_t *extract_subscriptions P((register ZNotice_t *notice));
+  static void free_subscriptions P((register ZSubscr_t *subs));
+  static char **subscr_marshal_subs P((ZNotice_t *notice, int auth,
+! 				     struct sockaddr_in *who,
+! 				     register int *found));
+! static ZSubscr_t *subscr_copy_def_subs P((char *person));
+  static int cl_match  P((ZSubscr_t*, ZClient_t *));
+  
+  static int defaults_read = 0;		/* set to 1 if the default subs
+***************
+*** 113,122 ****
+  
+  #undef P
+  
+- ZSTRING *wildcard_class;
+  ZSTRING *wildcard_instance;
+  ZSTRING *empty;
+- ZSubscr_t matchall_sub;
+  
+  /* WARNING: make sure this is the same as the number of strings you */
+  /* plan to hand back to the user in response to a subscription check, */
+--- 111,118 ----
+***************
+*** 132,268 ****
+       ZClient_t *who;
+       ZNotice_t *notice;
+  {
+! 	ZSubscr_t *subs;
+  	
+  	if (!who->zct_subs) {
+  		/* allocate a subscription head */
+! 		if (!(subs = (ZSubscr_t *) xmalloc(sizeof(ZSubscr_t))))
+  			return(ENOMEM);
+! 		subs->q_forw = subs->q_back = subs;
+! 		subs->zst_dest.classname = subs->zst_dest.inst =
+! 		  subs->zst_dest.recip = NULL;
+! 		subs->zst_dest.hash_value = 0;
+! 		who->zct_subs = subs;
+  	}
+  
+! 	if (!(subs = extract_subscriptions(notice)))
+! 		return(ZERR_NONE);	/* no subscr -> no error */
+! 
+! 	return(subscr_subscribe_real(who, subs, notice));
+  }
+  
+  static Code_t
+! subscr_subscribe_real(who, newsubs, notice)
+       ZClient_t *who;
+!      register ZSubscr_t *newsubs;
+       ZNotice_t *notice;
+  {
+  	Code_t retval;
+  	ZAcl_t *acl;
+  	ZSTRING *sender;
+- 	ZSubscr_t *subs2, *subs3, *subs;
+- 	int relation;
+  
+  	sender = make_zstring(notice->z_sender,0);
+  
+  	START_CRITICAL_CODE;
+  
+! 	for (subs = newsubs->q_forw;
+! 	     subs != newsubs;
+! 	     subs = subs->q_forw) {
+! 		/* for each new subscription */
+  
+  #if 0
+  		zdbug ((LOG_DEBUG, "subscr: %s/%s/%s",
+! 			subs->zst_dest.classname->string,
+! 			subs->zst_dest.inst->string,
+! 			subs->zst_dest.recip->string));
+  #endif
+  
+- 		if (!bdumping
+- 		    && (subs->zst_dest.recip != empty)
+- 		    && (subs->zst_dest.recip != sender)) {
+- 		    syslog(LOG_WARNING, "subscr unauth %s recipient %s",
+- 			   sender->string,
+- 			   subs->zst_dest.recip->string);
+- 		    continue;
+- 		}
+  		if (!bdumping) {
+! 		    acl = class_get_acl(subs->zst_dest.classname);
+  		    if (acl) {
+  			if (!(access_check(sender->string, acl, SUBSCRIBE))) {
+  				syslog(LOG_WARNING,
+  				       "subscr unauth %s class %s",
+  				       sender->string,
+! 				       subs->zst_dest.classname->string);
+  				continue; /* the for loop */
+  			}
+! 			if (wildcard_instance == subs->zst_dest.inst) {
+  			    if (!access_check(sender->string, acl, INSTWILD)) {
+  				syslog(LOG_WARNING,
+  				       "subscr unauth %s class %s wild inst",
+  				       notice->z_sender,
+! 				       subs->zst_dest.classname->string);
+  				continue;
+  			    }
+  			}
+  		    }
+  		}
+! 		/* subscriptions are stored in ascending order by */
+! 		/* subscription hash value */
+! 		/* Scan through list to check for duplicates, and to find */
+! 		/* where to insert these subs */
+! 
+! 		for (subs2 = who->zct_subs->q_forw;
+! 		     subs2 != who->zct_subs;
+! 		     subs2 = subs2->q_forw) {
+! 			/* for each existing subscription */
+! 		  relation = compare_subs(subs2,subs,0);
+! 		  if (relation == 0)
+! 		    goto duplicate;
+! 		  if (relation > 0) /* we have passed last possible one */
+! 		    break;
+! 		  if (relation < 0) /* nope... */
+! 		    continue;
+  		}
+! 
+! 		/* subs2 now points to the first class which is greater
+! 		   than the new class. We need to back up so that the
+! 		   insertion below goes BEFORE this one (i.e. after the
+! 		   previous one) */
+! 		subs2 = subs2->q_back;
+! 
+! 		/* ok, we are a new subscription. register and chain on. */
+! 
+! 		if (!(subs3 = (ZSubscr_t *) xmalloc(sizeof(ZSubscr_t)))) {
+! 			free_subscriptions(newsubs);
+! 			END_CRITICAL_CODE;
+! 			return(ENOMEM);
+! 		}
+! 
+! 		subs3->q_forw = subs3->q_back = subs3;
+! 		subs3->zst_dest.classname =
+! 		  dup_zstring(subs->zst_dest.classname);
+! 		subs3->zst_dest.inst = dup_zstring(subs->zst_dest.inst);
+! 		subs3->zst_dest.recip = dup_zstring(subs->zst_dest.recip);
+! 		set_ZDestination_hash(&subs3->zst_dest);
+! 
+! 		if ((retval = class_register(who, subs)) != ZERR_NONE) {
+! 		    xfree(subs3);
+! 		    free_subscriptions(newsubs);
+! 		    END_CRITICAL_CODE;
+! 		    return(retval);
+! 		}
+! 
+! 		/* subs2 was adjusted above */
+! 		xinsque(subs3, subs2);
+!  duplicate:
+! 		;
+  	}
+  
+  	END_CRITICAL_CODE;
+  
+! 	free_subscriptions(newsubs);
+  	return(ZERR_NONE);
+  }
+  
+--- 128,228 ----
+       ZClient_t *who;
+       ZNotice_t *notice;
+  {
+! 	ZSubscr_t *subs_queue, *sub;
+! 	Code_t retval;
+  	
+  	if (!who->zct_subs) {
+  		/* allocate a subscription head */
+! 		sub = (ZSubscr_t *) xmalloc(sizeof(ZSubscr_t));
+! 		if (!sub)
+  			return(ENOMEM);
+! 		sub->q_forw = sub->q_back = sub;
+! 		sub->zst_dest.classname = sub->zst_dest.inst =
+! 		  sub->zst_dest.recip = NULL;
+! 		who->zct_subs = sub;
+  	}
+  
+! 	subs_queue = extract_subscriptions(notice);
+! 	return(add_subscriptions(who, subs_queue, notice));
+  }
+  
+  static Code_t
+! add_subscriptions(who, subs_queue, notice)
+       ZClient_t *who;
+!      ZSubscr_t *subs_queue;
+       ZNotice_t *notice;
+  {
++ 	ZSubscr_t *sub, *next;
+  	Code_t retval;
+  	ZAcl_t *acl;
+  	ZSTRING *sender;
+  
++ 	if (!subs_queue)
++ 		return(ZERR_NONE);	/* no subscr -> no error */
++ 
+  	sender = make_zstring(notice->z_sender,0);
+  
+  	START_CRITICAL_CODE;
+  
+! 	/* Loop over the new subscriptions. */
+! 	next = subs_queue->q_forw;
+! 	while (next != subs_queue) {
+! 		sub = next;
+! 		next = sub->q_forw;
+  
+  #if 0
+  		zdbug ((LOG_DEBUG, "subscr: %s/%s/%s",
+! 			sub->zst_dest.classname->string,
+! 			sub->zst_dest.inst->string,
+! 			sub->zst_dest.recip->string));
+  #endif
+  
+  		if (!bdumping) {
+! 		    if ((sub->zst_dest.recip != empty)
+! 			&& (sub->zst_dest.recip != sender)) {
+! 			syslog(LOG_WARNING, "subscr unauth %s recipient %s",
+! 			       sender->string,
+! 			       sub->zst_dest.recip->string);
+! 			continue;
+! 		    }
+! 		    acl = class_get_acl(sub->zst_dest.classname);
+  		    if (acl) {
+  			if (!(access_check(sender->string, acl, SUBSCRIBE))) {
+  				syslog(LOG_WARNING,
+  				       "subscr unauth %s class %s",
+  				       sender->string,
+! 				       sub->zst_dest.classname->string);
+  				continue; /* the for loop */
+  			}
+! 			if (wildcard_instance == sub->zst_dest.inst) {
+  			    if (!access_check(sender->string, acl, INSTWILD)) {
+  				syslog(LOG_WARNING,
+  				       "subscr unauth %s class %s wild inst",
+  				       notice->z_sender,
+! 				       sub->zst_dest.classname->string);
+  				continue;
+  			    }
+  			}
+  		    }
+  		}
+! 		xremque(sub);
+! 		retval = triplet_register(who, &sub->zst_dest);
+! 		if (retval != ZERR_NONE) {
+! 			xfree(sub);
+! 			if (retval == ZSRV_CLASSXISTS) {
+! 				continue;
+! 			} else {
+! 				free_subscriptions(subs_queue);
+! 				END_CRITICAL_CODE;
+! 				return(retval);
+! 			}
+  		}
+! 		xinsque(sub, who->zct_subs);
+  	}
+  
+  	END_CRITICAL_CODE;
+  
+! 	free_subscriptions(subs_queue);
+  	return(ZERR_NONE);
+  }
+  
+***************
+*** 285,296 ****
+  		subs->q_forw = subs->q_back = subs;
+  		subs->zst_dest.classname = subs->zst_dest.inst =
+  		  subs->zst_dest.recip = (ZSTRING *) NULL;
+- 		subs->zst_dest.hash_value = 0;
+  		who->zct_subs = subs;
+  	}
+  
+  	subs = subscr_copy_def_subs(who->zct_principal->string);
+! 	return(subscr_subscribe_real(who, subs, &default_notice));
+  }
+  
+  void
+--- 245,255 ----
+  		subs->q_forw = subs->q_back = subs;
+  		subs->zst_dest.classname = subs->zst_dest.inst =
+  		  subs->zst_dest.recip = (ZSTRING *) NULL;
+  		who->zct_subs = subs;
+  	}
+  
+  	subs = subscr_copy_def_subs(who->zct_principal->string);
+! 	return(add_subscriptions(who, subs, &default_notice));
+  }
+  
+  void
+***************
+*** 391,403 ****
+  		  free_zstring(subs2->zst_dest.recip);
+  		  subs2->zst_dest.recip = dup_zstring(empty);
+  		}
+- 		set_ZDestination_hash(&(subs2->zst_dest));
+  	}
+  	return(subs);
+  }
+  
+  /*
+!  * Cancel one subscription.
+   */
+  
+  Code_t
+--- 350,361 ----
+  		  free_zstring(subs2->zst_dest.recip);
+  		  subs2->zst_dest.recip = dup_zstring(empty);
+  		}
+  	}
+  	return(subs);
+  }
+  
+  /*
+!  * Cancel a specific set of subscriptions.
+   */
+  
+  Code_t
+***************
+*** 406,412 ****
+       ZNotice_t *notice;
+  {
+  	ZClient_t *who;
+! 	register ZSubscr_t *subs, *subs2, *subs3, *subs4;
+  	Code_t retval;
+  	int found = 0;
+  	int relation;
+--- 364,370 ----
+       ZNotice_t *notice;
+  {
+  	ZClient_t *who;
+! 	register ZSubscr_t *cancel_queue, *cancel, *sub;
+  	Code_t retval;
+  	int found = 0;
+  	int relation;
+***************
+*** 414,475 ****
+  #if 0
+  	zdbug((LOG_DEBUG,"subscr_cancel"));
+  #endif
+! 	if (!(who = client_which_client(sin, notice)))
+  		return(ZSRV_NOCLT);
+  
+  	if (!who->zct_subs)
+  		return(ZSRV_NOSUB);
+  
+! 	if (!(subs = extract_subscriptions(notice)))
+  		return(ZERR_NONE);	/* no subscr -> no error */
+  
+  	START_CRITICAL_CODE;
+  
+! 	for (subs4 = subs->q_forw; subs4 != subs; subs4 = subs4->q_forw) {
+! 	    for (subs2 = who->zct_subs->q_forw;
+! 		 subs2 != who->zct_subs;) {
+! 		/* for each existing subscription */
+! 		/* is this what we are canceling? */
+! 	      relation = compare_subs(subs2, subs4,0);
+! 	      if (relation < 0) {
+! 		subs2 = subs2->q_forw;
+! 		continue;
+! 	      }
+! 	      if (relation > 0)
+! 		/* We have passed last possible one */
+! 		break;
+! 
+! 	      /* go back, since remque will change things */
+! 	      subs3 = subs2->q_back;
+! 	      xremque(subs2);
+! 	      (void) class_deregister(who, subs2);
+! 	      free_zstring(subs2->zst_dest.classname);
+! 	      free_zstring(subs2->zst_dest.inst);
+! 	      free_zstring(subs2->zst_dest.recip);
+! 	      xfree(subs2);
+! 	      found = 1;
+! 	      /* now that the remque adjusted the linked
+! 		 list, we go forward again */
+! 	      subs2 = subs3->q_forw;
+! 	      break;
+  	    }
+- 	  }
+- 
+- 	/* make sure we are still registered for all the classes */
+- 	if (found) {
+- 	  for (subs2 = who->zct_subs->q_forw;
+- 	       subs2 != who->zct_subs;
+- 	       subs2 = subs2->q_forw)
+- 	    if ((retval = class_register(who, subs2)) != ZERR_NONE) {
+- 	      free_subscriptions(subs);
+- 	      END_CRITICAL_CODE;
+- 	      return(retval);
+- 	    }
+  	}
+  
+  	END_CRITICAL_CODE;
+  
+! 	free_subscriptions(subs);
+  	if (found) {
+  #if 0
+  	  zdbug((LOG_DEBUG, "found & removed"));
+--- 372,410 ----
+  #if 0
+  	zdbug((LOG_DEBUG,"subscr_cancel"));
+  #endif
+! 	who = client_which_client(sin, notice);
+! 	if (!who)
+  		return(ZSRV_NOCLT);
+  
+  	if (!who->zct_subs)
+  		return(ZSRV_NOSUB);
+  
+! 	cancel_queue = extract_subscriptions(notice);
+! 	if (!cancel_queue)
+  		return(ZERR_NONE);	/* no subscr -> no error */
+  
+  	START_CRITICAL_CODE;
+  
+! 	for (cancel = cancel_queue->q_forw; cancel != cancel_queue;
+! 	     cancel = cancel->q_forw) {
+! 	    for (sub = who->zct_subs->q_forw; sub != who->zct_subs;
+! 		 sub = sub->q_forw) {
+! 		if (ZDest_eq(&cancel->zst_dest, &sub->zst_dest)) {
+! 		    xremque(sub);
+! 		    triplet_deregister(who, &sub->zst_dest);
+! 		    free_zstring(sub->zst_dest.classname);
+! 		    free_zstring(sub->zst_dest.inst);
+! 		    free_zstring(sub->zst_dest.recip);
+! 		    xfree(sub);
+! 		    found = 1;
+! 		    break;
+! 		}
+  	    }
+  	}
+  
+  	END_CRITICAL_CODE;
+  
+! 	free_subscriptions(cancel_queue);
+  	if (found) {
+  #if 0
+  	  zdbug((LOG_DEBUG, "found & removed"));
+***************
+*** 509,515 ****
+  		zdbug((LOG_DEBUG,"sub_can %s",
+  		       subs->zst_dest.classname->string));
+  #endif
+! 		if (class_deregister(client, subs) != ZERR_NONE) {
+  #if 0
+  			zdbug((LOG_DEBUG,"sub_can_clt: not registered!"));
+  #endif
+--- 444,450 ----
+  		zdbug((LOG_DEBUG,"sub_can %s",
+  		       subs->zst_dest.classname->string));
+  #endif
+! 		if (triplet_deregister(client, &subs->zst_dest) != ZERR_NONE) {
+  #if 0
+  			zdbug((LOG_DEBUG,"sub_can_clt: not registered!"));
+  #endif
+***************
+*** 565,670 ****
+  #endif
+  
+  /*
+-  * Here is the bulk of the work in the subscription manager.
+-  * We grovel over the list of clients possibly interested in this
+-  * notice, and copy into a list on a match.  Make sure we only add any given
+-  * client once.
+-  */
+- 
+- ZClientList_t *
+- subscr_match_list(notice)
+-      ZNotice_t *notice;
+- {
+- 	register ZClientList_t *hits, *clients, *majik, *clients2, *hit2;
+- 	char *saveclass, *saveclinst;
+- 	ZSTRING *newclass;
+- 	ZSTRING *newclinst;
+- 	ZSubscr_t check_sub;
+- 
+- 	if (!(hits = (ZClientList_t *) xmalloc(sizeof(ZClientList_t))))
+- 		return(NULLZCLT);
+- 	hits->q_forw = hits->q_back = hits;
+- 
+- 	saveclass = notice->z_class;
+- 	newclass = make_zstring(notice->z_class, 1);
+- 
+- 	saveclinst = notice->z_class_inst;
+- 	newclinst = make_zstring(notice->z_class_inst, 1);
+- 
+- 	check_sub.zst_dest.classname = newclass;
+- 	check_sub.zst_dest.inst = newclinst;
+- 	check_sub.zst_dest.recip = make_zstring(notice->z_recipient, 0);
+- 	set_ZDestination_hash(&check_sub.zst_dest);
+- 	check_sub.q_forw = check_sub.q_back = &check_sub;
+- 
+- 	clients = class_lookup (&check_sub);
+- 	majik = class_lookup (&matchall_sub);
+- 	if (!clients && !majik)
+- 	    return NULLZCLT;
+- 
+- 	notice->z_class = (char *) newclass->string;
+- 	notice->z_class_inst = (char *) newclinst->string;
+- 	if (clients) {
+- 		for (clients2 = clients->q_forw;
+- 		     clients2 != clients;
+- 		     clients2 = clients2->q_forw)
+- 		  if (cl_match(&check_sub, clients2->zclt_client)) {
+- 				if (!clt_unique(clients2->zclt_client, hits))
+- 					continue;
+- 				/* we hit */
+- 				if (!(hit2 = (ZClientList_t *) xmalloc(sizeof(ZClientList_t)))) {
+- 					syslog(LOG_WARNING,
+- 					       "subscr_match: punting/no mem");
+- 					notice->z_class = saveclass;
+- 					notice->z_class_inst = saveclinst;
+- 					free_zstring(newclass);
+- 					free_zstring(newclinst);
+- 					free_zstring(check_sub.zst_dest.recip);
+- 					return(hits);
+- 				}
+- 				hit2->zclt_client = clients2->zclt_client;
+- 				hit2->q_forw = hit2->q_back = hit2;
+- 				xinsque(hit2, hits);
+- 			}
+- 		class_free(clients);
+- 	}
+- 	if (majik) {
+- 		for (clients2 = majik->q_forw;
+- 		     clients2 != majik;
+- 		     clients2 = clients2->q_forw) {
+- 			if (!clt_unique(clients2->zclt_client, hits))
+- 				continue;
+- 			/* we hit */
+- 			if (!(hit2 = (ZClientList_t *) xmalloc(sizeof(ZClientList_t)))) {
+- 				syslog(LOG_WARNING,
+- 				       "subscr_match(majik): punting/no mem");
+- 				notice->z_class = saveclass;
+- 				notice->z_class_inst = saveclinst;
+- 				free_zstring(newclass);
+- 				free_zstring(newclinst);
+- 				free_zstring(check_sub.zst_dest.recip);
+- 				return(hits);
+- 			}
+- 			hit2->zclt_client = clients2->zclt_client;
+- 			hit2->q_forw = hit2->q_back = hit2;
+- 
+- 			xinsque(hit2, hits);
+- 		}
+- 		class_free(majik);
+- 	}
+- 	notice->z_class = saveclass;
+- 	notice->z_class_inst = saveclinst;
+- 	free_zstring(newclass);
+- 	free_zstring(newclinst);
+- 	free_zstring(check_sub.zst_dest.recip);
+- 	if (hits->q_forw == hits) {
+- 		xfree(hits);
+- 		return(NULLZCLT);
+- 	}
+- 	return(hits);
+- }
+- 
+- /*
+   * Free memory used by a list we allocated.
+   */
+  
+--- 500,505 ----
+***************
+*** 1149,1206 ****
+  }
+  
+  /*
+-  * is this client unique to this list?  0 = no, 1 = yes
+-  */
+- 
+- static int
+- clt_unique(clt, clist)
+-      ZClient_t *clt;
+-      ZClientList_t *clist;
+- {
+- 	register ZClientList_t *client;
+- 
+- 	for (client = clist->q_forw;
+- 	     client != clist;
+- 	     client = client->q_forw)
+- 		if (client->zclt_client == clt)
+- 			return(0);
+- 	return(1);
+- }
+- 
+- /*
+-  * is this client listening to this notice? 1=yes, 0=no
+-  */
+- 
+- static int
+- cl_match(notice_subs, client)
+-      register ZSubscr_t *notice_subs;
+-      register ZClient_t *client;
+- {
+- 	register ZSubscr_t *subs;
+- 	int relation;
+- 
+- 	if (client->zct_subs == NULLZST) {
+- 		syslog(LOG_WARNING, "cl_match w/ no subs");
+- 		return(0);
+- 	}
+- 		
+- 	for (subs = client->zct_subs->q_forw;
+- 	     subs != client->zct_subs;
+- 	     subs = subs->q_forw) {
+- 	  relation = compare_subs(notice_subs, subs, 1);
+- 
+- /*
+- 	  if (relation < 0)
+- 	    return(0);
+- */
+- 	  if (relation == 0)
+- 	    return(1);
+- 	}
+- 	/* fall through */
+- 	return(0);
+- }	
+- 
+- /*
+   * free the memory allocated for the list of subscriptions.
+   */
+  
+--- 984,989 ----
+***************
+*** 1272,1278 ****
+  			subs->q_forw = subs->q_back = subs;
+  			subs->zst_dest.classname = subs->zst_dest.inst =
+  			  subs->zst_dest.recip = NULL;
+- 			subs->zst_dest.hash_value = 0;
+  		}
+  		if (!(subs2 = (ZSubscr_t *) xmalloc(sizeof(ZSubscr_t)))) {
+  			syslog(LOG_WARNING, "ex_subs: no mem 2");
+--- 1055,1060 ----
+***************
+*** 1282,1288 ****
+  		subs2->zst_dest.classname = make_zstring(class_name,1);
+  		subs2->zst_dest.inst = make_zstring(classinst,1);
+  		subs2->zst_dest.recip = make_zstring(recip,0);
+- 		set_ZDestination_hash(&subs2->zst_dest);
+  		
+  		xinsque(subs2, subs);
+  	}
+--- 1064,1069 ----
+***************
+*** 1317,1384 ****
+  	return;
+  }
+  
+- int
+- compare_subs(s1,s2,do_wildcard)
+-      ZSubscr_t *s1, *s2;
+-      int do_wildcard;
+- {
+- 
+- #if 0
+-   zdbug((LOG_DEBUG,"compare_subs: %s/%s/%s to %s/%s/%s",
+- 	 s1->zst_dest.classname->string, s1->zst_dest.inst->string, s1->zst_dest.recip->string,
+- 	 s2->zst_dest.classname->string, s2->zst_dest.inst->string, s2->zst_dest.recip->string));
+- #endif
+-   /* wildcard must be in s2 in order for it to match */
+- 
+-   if (do_wildcard && (s1->zst_dest.classname == s2->zst_dest.classname) &&
+-       (s2->zst_dest.inst == wildcard_instance) &&
+-       (s1->zst_dest.recip == s2->zst_dest.recip))
+-     return(0);
+- 
+-   if (s1->zst_dest.hash_value > s2->zst_dest.hash_value)
+-     return 1;
+-   if (s1->zst_dest.hash_value < s2->zst_dest.hash_value)
+-     return -1;
+- 
+-   if (s1->zst_dest.classname != s2->zst_dest.classname)
+-     return(strcasecmp(s1->zst_dest.classname->string,
+- 		      s2->zst_dest.classname->string));
+- 
+-   if (s1->zst_dest.inst != s2->zst_dest.inst)
+-     return(strcasecmp(s1->zst_dest.inst->string,
+- 		      s2->zst_dest.inst->string));
+- 
+-   if (s1->zst_dest.recip != s2->zst_dest.recip)
+-     return(strcasecmp(s1->zst_dest.recip->string,
+- 		      s2->zst_dest.recip->string));
+- 
+-   return(0);
+- }
+- 
+- static void
+- check_sub_order(subs,wc)
+-      ZSubscr_t *subs;
+-      int wc;
+- {
+-   ZSubscr_t *subs2;
+-   int relation;
+- 
+-   for (subs2 = subs->q_forw;
+-        subs2->q_forw != subs;
+-        subs2 = subs2->q_forw) {
+- 
+-     /* for each existing subscription */
+-     relation = compare_subs(subs2,subs2->q_forw,wc);
+-     if (relation > 0) {
+-       syslog(LOG_DEBUG, "s_check failed: %s/%s/%s <=> %s/%s/%s = %d",
+- 	     subs2->zst_dest.classname->string,
+- 	     subs2->zst_dest.inst->string,
+- 	     subs2->zst_dest.recip->string,
+- 	     subs2->q_forw->zst_dest.classname->string,
+- 	     subs2->q_forw->zst_dest.inst->string,
+- 	     subs2->q_forw->zst_dest.recip->string,
+- 	     relation);
+-     }
+-     
+-   }
+- }
+--- 1098,1100 ----
+diff -c /mit/zephyr/src/server/uloc.c ./uloc.c
+*** /mit/zephyr/src/server/uloc.c	Mon Aug  1 09:39:54 1994
+--- ./uloc.c	Wed Jul  6 17:19:16 1994
+***************
+*** 108,115 ****
+  static exposure_type ulogin_remove_user P((ZNotice_t *notice, int auth,
+  					struct sockaddr_in *who,
+  					int *err_return));
+! static void login_sendit P((ZNotice_t *notice, int auth, struct sockaddr_in *who)),
+!     sense_logout P((ZNotice_t *notice, struct sockaddr_in *who));
+  static char **ulogin_marshal_locs P((ZNotice_t *notice, int *found, int auth));
+  
+  static int ul_equiv P((ZLocation_t *l1, ZLocation_t *l2));
+--- 108,114 ----
+  static exposure_type ulogin_remove_user P((ZNotice_t *notice, int auth,
+  					struct sockaddr_in *who,
+  					int *err_return));
+! static void login_sendit P((ZNotice_t *notice, int auth, struct sockaddr_in *who));
+  static char **ulogin_marshal_locs P((ZNotice_t *notice, int *found, int auth));
+  
+  static int ul_equiv P((ZLocation_t *l1, ZLocation_t *l2));
+***************
+*** 158,167 ****
+  				       inet_ntoa(who->sin_addr),
+  				       ntohs(notice->z_port)));
+  #endif
+! 				if (server == me_server) {
+  					clt_ack(notice, who, AUTH_FAILED);
+- 					sense_logout(notice, who);
+- 				}
+  				return(ZERR_NONE);
+  			} else if (err_ret == NOLOC) {
+  				if (server == me_server)
+--- 157,164 ----
+  				       inet_ntoa(who->sin_addr),
+  				       ntohs(notice->z_port)));
+  #endif
+! 				if (server == me_server)
+  					clt_ack(notice, who, AUTH_FAILED);
+  				return(ZERR_NONE);
+  			} else if (err_ret == NOLOC) {
+  				if (server == me_server)
+***************
+*** 204,210 ****
+  		zdbug((LOG_DEBUG,"unauthentic ulogin: %d %s %s", auth,
+  		       notice->z_sender, notice->z_class_inst));
+  #endif
+- 		sense_logout(notice, who);
+  		if (server == me_server)
+  			clt_ack(notice, who, AUTH_FAILED);
+  		return(ZERR_NONE);
+--- 201,206 ----
+***************
+*** 322,386 ****
+  }
+  
+  
+- /*ARGSUSED*/
+- static void
+- sense_logout(notice, who)
+-      ZNotice_t *notice;
+-      struct sockaddr_in *who;
+- {
+- 	ZNotice_t sense_notice;
+- 	ZLocation_t *loc;
+- 	struct sockaddr_in owner;
+- 	char message[BUFSIZ];
+- 	int retval, len;
+- 	char *pkt;
+- 	ZClient_t *client;
+- 
+- 	/* XXX todo: have the messsage print the IP addr */
+- 	/*
+- 	  someone tried an unauthentic logout.  Try to send a message
+- 	  to the person named in the message, warning them of this.
+- 	  If there is nobody listening on that port, the retransmission
+- 	  will eventually result in a flush of the location.
+- 	 */
+- 
+- 	if (!(loc = ulogin_find (notice, 1)))
+- 	    return;
+- 
+- 	/* fabricate an addr descriptor for him */
+- 	owner = *who;
+- 	owner.sin_addr.s_addr = loc->zlt_addr.s_addr;
+- 	owner.sin_port = loc->zlt_port;
+- 
+- 	sense_notice = *notice;		/* copy all fields */
+- 	/* and change the ones we need to */
+- 	sense_notice.z_kind = ACKED;
+- 	sense_notice.z_port = loc->zlt_port;
+- 	sense_notice.z_class = "MESSAGE";
+- 	sense_notice.z_class_inst = "URGENT";
+- 	sense_notice.z_opcode = "";
+- 	sense_notice.z_sender = "Zephyr Server";
+- 	sense_notice.z_recipient = (char *) loc->zlt_user->string;
+- 	sense_notice.z_default_format = "Urgent Message from $sender at $time:\n\n$1";
+- 	(void) sprintf(message,
+- 		       "Someone at host %s tried an unauthorized \nchange to your login information",
+- 		       inet_ntoa(notice->z_sender_addr));
+- 	sense_notice.z_message = message;
+- 	sense_notice.z_message_len = strlen(message) + 1;
+- 
+- 	/* we format the notice to generate a UID and other stuff */
+- 	if ((retval = ZFormatNotice(&sense_notice, &pkt, &len, ZNOAUTH))
+- 	    != ZERR_NONE) {
+- 		syslog(LOG_ERR, "sense_logout: %s", error_message(retval));
+- 		return;
+- 	}
+- 	xfree(pkt);			/* free packet */
+- 
+- 	client = client_which_client(who, &sense_notice);
+- 	/* transmit the message to the owning port of the location. */
+- 	xmit(&sense_notice, &owner, 1, client);
+- 	return;	
+- }
+  /*
+   * Dispatch a LOCATE notice.
+   */
+--- 318,323 ----
+diff -c /mit/zephyr/src/server/version.h ./version.h
+*** /mit/zephyr/src/server/version.h	Fri Nov 19 13:34:58 1993
+--- ./version.h	Wed Jul  6 17:19:17 1994
+***************
+*** 1 ****
+! #define ZSERVER_VERSION_STRING "(Fri Nov 19 13:34:58 EST 1993) probe@tardis"
+--- 1 ----
+! #define ZSERVER_VERSION_STRING "(Wed Jul  6 14:39:57 EDT 1994) ghudson@packet-drop"
+diff -c /mit/zephyr/src/server/zserver.h ./zserver.h
+*** /mit/zephyr/src/server/zserver.h	Thu Apr  7 12:40:16 1994
+--- ./zserver.h	Wed Jul  6 17:19:17 1994
+***************
+*** 57,63 ****
+   */
+  
+  typedef struct _ZDestination {
+-     unsigned long hash_value;
+      ZSTRING *classname;
+      ZSTRING *inst;
+      ZSTRING *recip;
+--- 57,62 ----
+***************
+*** 86,91 ****
+--- 85,94 ----
+  	long	last_msg;		/* last message sent to this client */
+  	long	last_check;		/* actually, last time the other
+  					   server was asked to check... */
++ 	int	last_send;		/* The send counter value for the
++ 					 * last packet sent to the client,
++ 					 * used to prevent duplicates.  See
++ 					 * sendit() in dispatch.c. */
+  } ZClient_t;
+  
+  typedef struct _ZClientList_t {
+***************
+*** 94,106 ****
+  	struct _ZClient_t	*zclt_client;
+  } ZClientList_t;
+  
+! typedef struct _ZClass_t {
+! 	struct _ZClass_t *q_forw;
+! 	struct _ZClass_t *q_back;
+  	ZDestination zct_dest;
+  	ZAcl_t	*zct_acl;
+  	ZClientList_t	*zct_clientlist;
+! } ZClass_t;
+  
+  typedef struct _ZHostList_t {
+  	struct _ZHostList_t *q_forw;
+--- 97,109 ----
+  	struct _ZClient_t	*zclt_client;
+  } ZClientList_t;
+  
+! typedef struct _ZTriplet_t {
+! 	struct _ZTriplet_t *q_forw;
+! 	struct _ZTriplet_t *q_back;
+  	ZDestination zct_dest;
+  	ZAcl_t	*zct_acl;
+  	ZClientList_t	*zct_clientlist;
+! } ZTriplet_t;
+  
+  typedef struct _ZHostList_t {
+  	struct _ZHostList_t *q_forw;
+***************
+*** 190,200 ****
+  				  char **lyst, int num));
+  
+  /* found in class.c */
+! extern Code_t class_register P((ZClient_t *client, ZSubscr_t *subs));
+! extern Code_t class_deregister P((ZClient_t *client, ZSubscr_t *subs));
+  extern Code_t class_restrict P((char *z_class, ZAcl_t *acl));
+  extern Code_t class_setup_restricted P((char *z_class, ZAcl_t *acl));
+! extern ZClientList_t *class_lookup P((ZSubscr_t *subs));
+  extern ZAcl_t *class_get_acl P((ZSTRING *z_class));
+  extern void class_free P((ZClientList_t *lyst));
+  extern ZSTRING *class_control, *class_admin, *class_hm;
+--- 193,203 ----
+  				  char **lyst, int num));
+  
+  /* found in class.c */
+! extern Code_t triplet_register P((ZClient_t *client, ZDestination *dest));
+! extern Code_t triplet_deregister P((ZClient_t *client, ZDestination *dest));
+  extern Code_t class_restrict P((char *z_class, ZAcl_t *acl));
+  extern Code_t class_setup_restricted P((char *z_class, ZAcl_t *acl));
+! extern ZClientList_t *triplet_lookup P((ZDestination *dest));
+  extern ZAcl_t *class_get_acl P((ZSTRING *z_class));
+  extern void class_free P((ZClientList_t *lyst));
+  extern ZSTRING *class_control, *class_admin, *class_hm;
+***************
+*** 281,287 ****
+  extern Code_t subscr_cancel P((struct sockaddr_in *sin, ZNotice_t *notice));
+  extern Code_t subscr_subscribe P((ZClient_t *who, ZNotice_t *notice)),
+      subscr_send_subs P((ZClient_t *client, char *vers));;
+- extern ZClientList_t *subscr_match_list P((ZNotice_t *notice));
+  extern void subscr_free_list P((ZClientList_t *list)),
+      subscr_cancel_client P((register ZClient_t *client)),
+      subscr_sendlist P((ZNotice_t *notice, int auth, struct sockaddr_in *who));
+--- 284,289 ----
+***************
+*** 343,350 ****
+  /* found in subscr.c */
+  extern ZSTRING *empty;
+  extern ZSTRING *wildcard_instance;
+- extern ZSTRING *wildcard_class;
+- extern ZSubscr_t matchall_sub;
+  
+  extern struct in_addr my_addr;	/* my inet address */
+  
+--- 345,350 ----
+***************
+*** 369,375 ****
+  #define	ADMIN_YOU	"YOUR_STATE"	/* Class inst: please send your state*/
+  #define	ADMIN_ME	"MY_STATE"	/* Class inst: please send my info */
+  
+! #define	NULLZCT		((ZClass_t *) 0)
+  #define	NULLZCNT	((ZClient_t *) 0)
+  #define	NULLZCLT	((ZClientList_t *) 0)
+  #define	NULLZST		((ZSubscr_t *) 0)
+--- 369,375 ----
+  #define	ADMIN_YOU	"YOUR_STATE"	/* Class inst: please send your state*/
+  #define	ADMIN_ME	"MY_STATE"	/* Class inst: please send my info */
+  
+! #define	NULLZT		((ZTriplet_t *) 0)
+  #define	NULLZCNT	((ZClient_t *) 0)
+  #define	NULLZCLT	((ZClientList_t *) 0)
+  #define	NULLZST		((ZSubscr_t *) 0)
+***************
+*** 397,404 ****
+  #define START_CRITICAL_CODE
+  #define END_CRITICAL_CODE
+  
+- /* the magic class to match all packets */
+- #define	MATCHALL_CLASS	"zmatch_all"
+  /* the instance that matches all instances */
+  #define	WILDCARD_INSTANCE	"*"
+  
+--- 397,402 ----
+diff -c /mit/zephyr/src/server/zsrv_conf.h ./zsrv_conf.h
+*** /mit/zephyr/src/server/zsrv_conf.h	Fri Nov 19 15:57:44 1993
+--- ./zsrv_conf.h	Wed Jul  6 17:19:17 1994
+***************
+*** 18,30 ****
+  
+  /* Magic path names */
+  #ifndef HESIOD
+! #define SERVER_LIST_FILE	"/usr/athena/lib/zephyr/server.list"
+  #endif
+  
+  /* ACL's for pre-registered classes */
+  /* Directory containing acls and other info */
+  #ifndef ZEPHYR_ACL_DIR
+! #define	ZEPHYR_ACL_DIR		"/usr/athena/lib/zephyr/acl/"
+  #endif
+  /* name of the class registry */
+  #define	ZEPHYR_CLASS_REGISTRY	"class-registry.acl"
+--- 18,30 ----
+  
+  /* Magic path names */
+  #ifndef HESIOD
+! #define SERVER_LIST_FILE	"/etc/athena/zephyr/server.list"
+  #endif
+  
+  /* ACL's for pre-registered classes */
+  /* Directory containing acls and other info */
+  #ifndef ZEPHYR_ACL_DIR
+! #define	ZEPHYR_ACL_DIR		"/etc/athena/zephyr/acl/"
+  #endif
+  /* name of the class registry */
+  #define	ZEPHYR_CLASS_REGISTRY	"class-registry.acl"
+***************
+*** 31,45 ****
+  
+  #ifdef KERBEROS
+  /* name of file to hold the tickets for keys to exchange with other servers */
+! #define	ZEPHYR_TKFILE		"/usr/athena/lib/zephyr/ztkts"
+  
+! /* Pathname of Kerberos srvtab file.
+!  * WARNING: lib/ZCkAuth.c needs to have a corresponding definition! */
+! #define SERVER_SRVTAB		"/usr/athena/lib/zephyr/srvtab"
+  #endif /* KERBEROS */
+  
+  /* default subscription file */
+! #define	DEFAULT_SUBS_FILE	"/usr/athena/lib/zephyr/default.subscriptions"
+  
+  /* client defines */
+  #define	REXMIT_SECS	((long) 20)	/* rexmit delay on normal notices */
+--- 31,43 ----
+  
+  #ifdef KERBEROS
+  /* name of file to hold the tickets for keys to exchange with other servers */
+! #define	ZEPHYR_TKFILE		"/etc/athena/zephyr/ztkts"
+  
+! /* The pathname of the Kerberos srvtab file is defined in zephyr_conf.h. */
+  #endif /* KERBEROS */
+  
+  /* default subscription file */
+! #define	DEFAULT_SUBS_FILE	"/etc/athena/zephyr/default.subscriptions"
+  
+  /* client defines */
+  #define	REXMIT_SECS	((long) 20)	/* rexmit delay on normal notices */