File:  [DragonFly] / src / usr.sbin / timed / timed / readmsg.c
Revision 1.2: download - view: text, annotated - select for diffs
Tue Jun 17 04:30:03 2003 UTC (11 years, 5 months ago) by dillon
Branches: MAIN
CVS tags: HEAD
Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids.  Most
ids have been removed from !lint sections and moved into comment sections.

    1: /*-
    2:  * Copyright (c) 1985, 1993
    3:  *	The Regents of the University of California.  All rights reserved.
    4:  *
    5:  * Redistribution and use in source and binary forms, with or without
    6:  * modification, are permitted provided that the following conditions
    7:  * are met:
    8:  * 1. Redistributions of source code must retain the above copyright
    9:  *    notice, this list of conditions and the following disclaimer.
   10:  * 2. Redistributions in binary form must reproduce the above copyright
   11:  *    notice, this list of conditions and the following disclaimer in the
   12:  *    documentation and/or other materials provided with the distribution.
   13:  * 3. All advertising materials mentioning features or use of this software
   14:  *    must display the following acknowledgement:
   15:  *	This product includes software developed by the University of
   16:  *	California, Berkeley and its contributors.
   17:  * 4. Neither the name of the University nor the names of its contributors
   18:  *    may be used to endorse or promote products derived from this software
   19:  *    without specific prior written permission.
   20:  *
   21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31:  * SUCH DAMAGE.
   32:  *
   33:  * @(#)readmsg.c	8.1 (Berkeley) 6/6/93
   34:  * $FreeBSD: src/usr.sbin/timed/timed/readmsg.c,v 1.5.2.3 2001/08/31 08:02:05 kris Exp $
   35:  * $DragonFly: src/usr.sbin/timed/timed/readmsg.c,v 1.2 2003/06/17 04:30:03 dillon Exp $
   36:  */
   37: 
   38: #include "globals.h"
   39: 
   40: extern char *tsptype[];
   41: 
   42: /*
   43:  * LOOKAT checks if the message is of the requested type and comes from
   44:  * the right machine, returning 1 in case of affirmative answer
   45:  */
   46: #define LOOKAT(msg, mtype, mfrom, netp, froms) \
   47: 	(((mtype) == TSP_ANY || (mtype) == (msg).tsp_type) &&		\
   48: 	 ((mfrom) == 0 || !strcmp((mfrom), (msg).tsp_name)) &&		\
   49: 	 ((netp) == 0 || 						\
   50: 	  ((netp)->mask & (froms).sin_addr.s_addr) == (netp)->net.s_addr))
   51: 
   52: struct timeval rtime, rwait, rtout;
   53: struct tsp msgin;
   54: static struct tsplist {
   55: 	struct tsp info;
   56: 	struct timeval when;
   57: 	struct sockaddr_in addr;
   58: 	struct tsplist *p;
   59: } msgslist;
   60: struct sockaddr_in from;
   61: struct netinfo *fromnet;
   62: struct timeval from_when;
   63: 
   64: /*
   65:  * `readmsg' returns message `type' sent by `machfrom' if it finds it
   66:  * either in the receive queue, or in a linked list of previously received
   67:  * messages that it maintains.
   68:  * Otherwise it waits to see if the appropriate message arrives within
   69:  * `intvl' seconds. If not, it returns NULL.
   70:  */
   71: 
   72: struct tsp *
   73: readmsg(type, machfrom, intvl, netfrom)
   74: 	int type;
   75: 	char *machfrom;
   76: 	struct timeval *intvl;
   77: 	struct netinfo *netfrom;
   78: {
   79: 	int length;
   80: 	fd_set ready;
   81: 	static struct tsplist *head = &msgslist;
   82: 	static struct tsplist *tail = &msgslist;
   83: 	static int msgcnt = 0;
   84: 	struct tsplist *prev;
   85: 	register struct netinfo *ntp;
   86: 	register struct tsplist *ptr;
   87: 	ssize_t n;
   88: 
   89: 	if (trace) {
   90: 		fprintf(fd, "readmsg: looking for %s from %s, %s\n",
   91: 			tsptype[type], machfrom == NULL ? "ANY" : machfrom,
   92: 			netfrom == NULL ? "ANYNET" : inet_ntoa(netfrom->net));
   93: 		if (head->p != 0) {
   94: 			length = 1;
   95: 			for (ptr = head->p; ptr != 0; ptr = ptr->p) {
   96: 				/* do not repeat the hundreds of messages */
   97: 				if (++length > 3) {
   98: 					if (ptr == tail) {
   99: 						fprintf(fd,"\t ...%d skipped\n",
  100: 							length);
  101: 					} else {
  102: 						continue;
  103: 					}
  104: 				}
  105: 				fprintf(fd, length > 1 ? "\t" : "queue:\t");
  106: 				print(&ptr->info, &ptr->addr);
  107: 			}
  108: 		}
  109: 	}
  110: 
  111: 	ptr = head->p;
  112: 	prev = head;
  113: 
  114: 	/*
  115: 	 * Look for the requested message scanning through the
  116: 	 * linked list. If found, return it and free the space
  117: 	 */
  118: 
  119: 	while (ptr != NULL) {
  120: 		if (LOOKAT(ptr->info, type, machfrom, netfrom, ptr->addr)) {
  121: again:
  122: 			msgin = ptr->info;
  123: 			from = ptr->addr;
  124: 			from_when = ptr->when;
  125: 			prev->p = ptr->p;
  126: 			if (ptr == tail)
  127: 				tail = prev;
  128: 			free((char *)ptr);
  129: 			fromnet = NULL;
  130: 			if (netfrom == NULL)
  131: 			    for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
  132: 				    if ((ntp->mask & from.sin_addr.s_addr) ==
  133: 					ntp->net.s_addr) {
  134: 					    fromnet = ntp;
  135: 					    break;
  136: 				    }
  137: 			    }
  138: 			else
  139: 			    fromnet = netfrom;
  140: 			if (trace) {
  141: 				fprintf(fd, "readmsg: found ");
  142: 				print(&msgin, &from);
  143: 			}
  144: 
  145: /* The protocol can get far behind.  When it does, it gets
  146:  *	hopelessly confused.  So delete duplicate messages.
  147:  */
  148: 			for (ptr = prev; (ptr = ptr->p) != NULL; prev = ptr) {
  149: 				if (ptr->addr.sin_addr.s_addr
  150: 					== from.sin_addr.s_addr
  151: 				    && ptr->info.tsp_type == msgin.tsp_type) {
  152: 					if (trace)
  153: 						fprintf(fd, "\tdup ");
  154: 					goto again;
  155: 				}
  156: 			}
  157: 			msgcnt--;
  158: 			return(&msgin);
  159: 		} else {
  160: 			prev = ptr;
  161: 			ptr = ptr->p;
  162: 		}
  163: 	}
  164: 
  165: 	/*
  166: 	 * If the message was not in the linked list, it may still be
  167: 	 * coming from the network. Set the timer and wait
  168: 	 * on a select to read the next incoming message: if it is the
  169: 	 * right one, return it, otherwise insert it in the linked list.
  170: 	 */
  171: 
  172: 	(void)gettimeofday(&rtout, 0);
  173: 	timevaladd(&rtout, intvl);
  174: 	FD_ZERO(&ready);
  175: 	for (;;) {
  176: 		(void)gettimeofday(&rtime, 0);
  177: 		timevalsub(&rwait, &rtout, &rtime);
  178: 		if (rwait.tv_sec < 0)
  179: 			rwait.tv_sec = rwait.tv_usec = 0;
  180: 		else if (rwait.tv_sec == 0
  181: 			 && rwait.tv_usec < 1000000/CLK_TCK)
  182: 			rwait.tv_usec = 1000000/CLK_TCK;
  183: 
  184: 		if (trace) {
  185: 			fprintf(fd, "readmsg: wait %ld.%6ld at %s\n",
  186: 				rwait.tv_sec, rwait.tv_usec, date());
  187: 			/* Notice a full disk, as we flush trace info.
  188: 			 * It is better to flush periodically than at
  189: 			 * every line because the tracing consists of bursts
  190: 			 * of many lines.  Without care, tracing slows
  191: 			 * down the code enough to break the protocol.
  192: 			 */
  193: 			if (rwait.tv_sec != 0
  194: 			    && EOF == fflush(fd))
  195: 				traceoff("Tracing ended for cause at %s\n");
  196: 		}
  197: 
  198: 		FD_SET(sock, &ready);
  199: 		if (!select(sock+1, &ready, (fd_set *)0, (fd_set *)0,
  200: 			   &rwait)) {
  201: 			if (rwait.tv_sec == 0 && rwait.tv_usec == 0)
  202: 				return(0);
  203: 			continue;
  204: 		}
  205: 		length = sizeof(from);
  206: 		if ((n = recvfrom(sock, (char *)&msgin, sizeof(struct tsp), 0,
  207: 			     (struct sockaddr*)&from, &length)) < 0) {
  208: 			syslog(LOG_ERR, "recvfrom: %m");
  209: 			exit(1);
  210: 		}
  211: 		/*
  212: 		 * The 4.3BSD protocol spec had a 32-byte tsp_name field, and
  213: 		 * this is still OS-dependent.  Demand that the packet is at
  214: 		 * least long enough to hold a 4.3BSD packet.
  215: 		 */
  216: 		if (n < (ssize_t)(sizeof(struct tsp) - MAXHOSTNAMELEN + 32)) {
  217: 			syslog(LOG_NOTICE,
  218: 			    "short packet (%u/%u bytes) from %s",
  219: 			      n, sizeof(struct tsp) - MAXHOSTNAMELEN + 32,
  220: 			      inet_ntoa(from.sin_addr));
  221: 			continue;
  222: 		}
  223: 		(void)gettimeofday(&from_when, (struct timezone *)0);
  224: 		bytehostorder(&msgin);
  225: 
  226: 		if (msgin.tsp_vers > TSPVERSION) {
  227: 			if (trace) {
  228: 			    fprintf(fd,"readmsg: version mismatch\n");
  229: 			    /* should do a dump of the packet */
  230: 			}
  231: 			continue;
  232: 		}
  233: 
  234: 		if (memchr(msgin.tsp_name,
  235: 		    '\0', sizeof msgin.tsp_name) == NULL) {
  236: 			syslog(LOG_NOTICE, "hostname field not NUL terminated "
  237: 			    "in packet from %s", inet_ntoa(from.sin_addr));
  238: 			continue;
  239: 		}
  240: 
  241: 		fromnet = NULL;
  242: 		for (ntp = nettab; ntp != NULL; ntp = ntp->next)
  243: 			if ((ntp->mask & from.sin_addr.s_addr) ==
  244: 			    ntp->net.s_addr) {
  245: 				fromnet = ntp;
  246: 				break;
  247: 			}
  248: 
  249: 		/*
  250: 		 * drop packets from nets we are ignoring permanently
  251: 		 */
  252: 		if (fromnet == NULL) {
  253: 			/*
  254: 			 * The following messages may originate on
  255: 			 * this host with an ignored network address
  256: 			 */
  257: 			if (msgin.tsp_type != TSP_TRACEON &&
  258: 			    msgin.tsp_type != TSP_SETDATE &&
  259: 			    msgin.tsp_type != TSP_MSITE &&
  260: 			    msgin.tsp_type != TSP_TEST &&
  261: 			    msgin.tsp_type != TSP_TRACEOFF) {
  262: 				if (trace) {
  263: 				    fprintf(fd,"readmsg: discard null net ");
  264: 				    print(&msgin, &from);
  265: 				}
  266: 				continue;
  267: 			}
  268: 		}
  269: 
  270: 		/*
  271: 		 * Throw away messages coming from this machine,
  272: 		 * unless they are of some particular type.
  273: 		 * This gets rid of broadcast messages and reduces
  274: 		 * master processing time.
  275: 		 */
  276: 		if (!strcmp(msgin.tsp_name, hostname)
  277: 		    && msgin.tsp_type != TSP_SETDATE
  278: 		    && msgin.tsp_type != TSP_TEST
  279: 		    && msgin.tsp_type != TSP_MSITE
  280: 		    && msgin.tsp_type != TSP_TRACEON
  281: 		    && msgin.tsp_type != TSP_TRACEOFF
  282: 		    && msgin.tsp_type != TSP_LOOP) {
  283: 			if (trace) {
  284: 				fprintf(fd, "readmsg: discard own ");
  285: 				print(&msgin, &from);
  286: 			}
  287: 			continue;
  288: 		}
  289: 
  290: 		/*
  291: 		 * Send acknowledgements here; this is faster and
  292: 		 * avoids deadlocks that would occur if acks were
  293: 		 * sent from a higher level routine.  Different
  294: 		 * acknowledgements are necessary, depending on
  295: 		 * status.
  296: 		 */
  297: 		if (fromnet == NULL)	/* do not de-reference 0 */
  298: 			ignoreack();
  299: 		else if (fromnet->status == MASTER)
  300: 			masterack();
  301: 		else if (fromnet->status == SLAVE)
  302: 			slaveack();
  303: 		else
  304: 			ignoreack();
  305: 
  306: 		if (LOOKAT(msgin, type, machfrom, netfrom, from)) {
  307: 			if (trace) {
  308: 				fprintf(fd, "readmsg: ");
  309: 				print(&msgin, &from);
  310: 			}
  311: 			return(&msgin);
  312: 		} else if (++msgcnt > NHOSTS*3) {
  313: 
  314: /* The protocol gets hopelessly confused if it gets too far
  315: *	behind.  However, it seems able to recover from all cases of lost
  316: *	packets.  Therefore, if we are swamped, throw everything away.
  317: */
  318: 			if (trace)
  319: 				fprintf(fd,
  320: 					"readmsg: discarding %d msgs\n",
  321: 					msgcnt);
  322: 			msgcnt = 0;
  323: 			while ((ptr=head->p) != NULL) {
  324: 				head->p = ptr->p;
  325: 				free((char *)ptr);
  326: 			}
  327: 			tail = head;
  328: 		} else {
  329: 			tail->p = (struct tsplist *)
  330: 				    malloc(sizeof(struct tsplist));
  331: 			tail = tail->p;
  332: 			tail->p = NULL;
  333: 			tail->info = msgin;
  334: 			tail->addr = from;
  335: 			/* timestamp msgs so SETTIMEs are correct */
  336: 			tail->when = from_when;
  337: 		}
  338: 	}
  339: }
  340: 
  341: /*
  342:  * Send the necessary acknowledgements:
  343:  * only the type ACK is to be sent by a slave
  344:  */
  345: void
  346: slaveack()
  347: {
  348: 	switch(msgin.tsp_type) {
  349: 
  350: 	case TSP_ADJTIME:
  351: 	case TSP_SETTIME:
  352: 	case TSP_ACCEPT:
  353: 	case TSP_REFUSE:
  354: 	case TSP_TRACEON:
  355: 	case TSP_TRACEOFF:
  356: 	case TSP_QUIT:
  357: 		if (trace) {
  358: 			fprintf(fd, "Slaveack: ");
  359: 			print(&msgin, &from);
  360: 		}
  361: 		xmit(TSP_ACK,msgin.tsp_seq, &from);
  362: 		break;
  363: 
  364: 	default:
  365: 		if (trace) {
  366: 			fprintf(fd, "Slaveack: no ack: ");
  367: 			print(&msgin, &from);
  368: 		}
  369: 		break;
  370: 	}
  371: }
  372: 
  373: /*
  374:  * Certain packets may arrive from this machine on ignored networks.
  375:  * These packets should be acknowledged.
  376:  */
  377: void
  378: ignoreack()
  379: {
  380: 	switch(msgin.tsp_type) {
  381: 
  382: 	case TSP_TRACEON:
  383: 	case TSP_TRACEOFF:
  384: 	case TSP_QUIT:
  385: 		if (trace) {
  386: 			fprintf(fd, "Ignoreack: ");
  387: 			print(&msgin, &from);
  388: 		}
  389: 		xmit(TSP_ACK,msgin.tsp_seq, &from);
  390: 		break;
  391: 
  392: 	default:
  393: 		if (trace) {
  394: 			fprintf(fd, "Ignoreack: no ack: ");
  395: 			print(&msgin, &from);
  396: 		}
  397: 		break;
  398: 	}
  399: }
  400: 
  401: /*
  402:  * `masterack' sends the necessary acknowledgments
  403:  * to the messages received by a master
  404:  */
  405: void
  406: masterack()
  407: {
  408: 	struct tsp resp;
  409: 
  410: 	resp = msgin;
  411: 	resp.tsp_vers = TSPVERSION;
  412: 	(void)strcpy(resp.tsp_name, hostname);
  413: 
  414: 	switch(msgin.tsp_type) {
  415: 
  416: 	case TSP_QUIT:
  417: 	case TSP_TRACEON:
  418: 	case TSP_TRACEOFF:
  419: 	case TSP_MSITEREQ:
  420: 		if (trace) {
  421: 			fprintf(fd, "Masterack: ");
  422: 			print(&msgin, &from);
  423: 		}
  424: 		xmit(TSP_ACK,msgin.tsp_seq, &from);
  425: 		break;
  426: 
  427: 	case TSP_RESOLVE:
  428: 	case TSP_MASTERREQ:
  429: 		if (trace) {
  430: 			fprintf(fd, "Masterack: ");
  431: 			print(&msgin, &from);
  432: 		}
  433: 		xmit(TSP_MASTERACK,msgin.tsp_seq, &from);
  434: 		break;
  435: 
  436: 	default:
  437: 		if (trace) {
  438: 			fprintf(fd,"Masterack: no ack: ");
  439: 			print(&msgin, &from);
  440: 		}
  441: 		break;
  442: 	}
  443: }
  444: 
  445: /*
  446:  * Print a TSP message
  447:  */
  448: void
  449: print(msg, addr)
  450: 	struct tsp *msg;
  451: 	struct sockaddr_in *addr;
  452: {
  453: 	char tm[26];
  454: 	time_t tsp_time_sec;
  455: 
  456: 	if (msg->tsp_type >= TSPTYPENUMBER) {
  457: 		fprintf(fd, "bad type (%u) on packet from %s\n",
  458: 		  msg->tsp_type, inet_ntoa(addr->sin_addr));
  459: 		return;
  460: 	}
  461: 
  462: 	switch (msg->tsp_type) {
  463: 
  464: 	case TSP_LOOP:
  465: 		fprintf(fd, "%s %d %-6u #%d %-15s %s\n",
  466: 			tsptype[msg->tsp_type],
  467: 			msg->tsp_vers,
  468: 			msg->tsp_seq,
  469: 			msg->tsp_hopcnt,
  470: 			inet_ntoa(addr->sin_addr),
  471: 			msg->tsp_name);
  472: 		break;
  473: 
  474: 	case TSP_SETTIME:
  475: 	case TSP_SETDATE:
  476: 	case TSP_SETDATEREQ:
  477: #ifdef sgi
  478: 		(void)cftime(tm, "%D %T", &msg->tsp_time.tv_sec);
  479: #else
  480: 		tsp_time_sec = msg->tsp_time.tv_sec;
  481: 		strncpy(tm, ctime(&tsp_time_sec)+3+1, sizeof(tm));
  482: 		tm[15] = '\0';		/* ugh */
  483: #endif /* sgi */
  484: 		fprintf(fd, "%s %d %-6u %s %-15s %s\n",
  485: 			tsptype[msg->tsp_type],
  486: 			msg->tsp_vers,
  487: 			msg->tsp_seq,
  488: 			tm,
  489: 			inet_ntoa(addr->sin_addr),
  490: 			msg->tsp_name);
  491: 		break;
  492: 
  493: 	case TSP_ADJTIME:
  494: 		fprintf(fd, "%s %d %-6u (%ld,%ld) %-15s %s\n",
  495: 			tsptype[msg->tsp_type],
  496: 			msg->tsp_vers,
  497: 			msg->tsp_seq,
  498: 			msg->tsp_time.tv_sec,
  499: 			msg->tsp_time.tv_usec,
  500: 			inet_ntoa(addr->sin_addr),
  501: 			msg->tsp_name);
  502: 		break;
  503: 
  504: 	default:
  505: 		fprintf(fd, "%s %d %-6u %-15s %s\n",
  506: 			tsptype[msg->tsp_type],
  507: 			msg->tsp_vers,
  508: 			msg->tsp_seq,
  509: 			inet_ntoa(addr->sin_addr),
  510: 			msg->tsp_name);
  511: 		break;
  512: 	}
  513: }