Return to tty_clk_STREAMS.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / kernel

ntp 4.2.6p5

    1: /* tty_clk_STREAMS.c,v 3.1 1993/07/06 01:07:34 jbj Exp
    2:  * Timestamp STREAMS module for SunOS 4.1
    3:  *
    4:  * Copyright 1991, Nick Sayer
    5:  *
    6:  * Special thanks to Greg Onufer for his debug assists.
    7:  *
    8:  * Should be PUSHed directly on top of a serial I/O channel.
    9:  * For any character in a user-designated set, adds a kernel
   10:  * timestamp to that character.
   11:  *
   12:  * BUGS:
   13:  *
   14:  * Only so many characters can be timestamped. This number, however,
   15:  * is adjustable.
   16:  *
   17:  * The null character ($00) cannot be timestamped.
   18:  *
   19:  * The M_DATA messages passed upstream will not be the same
   20:  * size as when they arrive from downstream, even if no
   21:  * timestamp character is in the message. This, however,
   22:  * should not affect anything.
   23:  *
   24:  */
   25: 
   26: #include "clk.h"
   27: #if NCLK > 0
   28: /*
   29:  * How big should the messages we pass upstream be?
   30:  */
   31: #define MESSAGE_SIZE 128
   32: 
   33: #include <string.h>
   34: #include <sys/types.h>
   35: #include <sys/stream.h>
   36: #include <sys/param.h>
   37: #include <sys/time.h>
   38: #include <sys/kernel.h>
   39: #include <sys/user.h>
   40: #include <sys/errno.h>
   41: #include <sys/syslog.h>
   42: 
   43: #include <sys/clkdefs.h>
   44: 
   45: static struct module_info rminfo = { 0, "clk", 0, INFPSZ, 0, 0 };
   46: static struct module_info wminfo = { 0, "clk", 0, INFPSZ, 0, 0 };
   47: static int clkopen(), clkrput(), clkwput(), clkclose();
   48: 
   49: static struct qinit rinit = { clkrput, NULL, clkopen, clkclose, NULL,
   50: 	&rminfo, NULL };
   51: 
   52: static struct qinit winit = { clkwput, NULL, NULL, NULL, NULL,
   53: 	&wminfo, NULL };
   54: 
   55: struct streamtab clkinfo = { &rinit, &winit, NULL, NULL };
   56: 
   57: struct priv_data_type
   58: {
   59:   char in_use;
   60:   char string[CLK_MAXSTRSIZE];
   61: } priv_data[NCLK];
   62: 
   63: char first_open=1;
   64: 
   65: /*
   66:  * God only knows why, but linking with strchr() fails
   67:  * on my system, so here's a renamed copy.
   68:  */
   69: 
   70: u_char *str_chr(s,c)
   71: u_char *s;
   72: int c;
   73: {
   74:   while (*s)
   75:     if(*s++ == c)
   76:       return (s-1);
   77:   return NULL;
   78: }
   79: 
   80: /*ARGSUSED*/
   81: static int clkopen(q, dev, flag, sflag)
   82: queue_t *q;
   83: dev_t dev;
   84: int flag;
   85: int sflag;
   86: {
   87:   int i;
   88: 
   89: /* Damn it! We can't even have the global data struct properly
   90:    initialized! So we have a mark to tell us to init the global
   91:    data on the first open */
   92: 
   93:   if (first_open)
   94:   {
   95:     first_open=0;
   96: 
   97:     for(i=0;i<NCLK;i++)
   98:       priv_data[i].in_use=0;
   99:   }
  100: 
  101:   for(i=0;i<NCLK;i++)
  102:     if(!priv_data[i].in_use)
  103:     {
  104:       priv_data[i].in_use++;
  105:       ((struct priv_data_type *) (q->q_ptr))=priv_data+i;
  106:       priv_data[i].string[0]=0;
  107:       return (0);
  108:     }
  109:   u.u_error = EBUSY;
  110:   return (OPENFAIL);
  111: }
  112: 
  113: /*ARGSUSED*/
  114: static int clkclose(q, flag)
  115: queue_t *q;
  116: int flag;
  117: {
  118:   ((struct priv_data_type *) (q->q_ptr))->in_use=0;
  119: 
  120:   return (0);
  121: }
  122: 
  123: /*
  124:  * Now the crux of the biscuit.
  125:  *
  126:  * If it's an M_DATA package, we take each character and pass
  127:  * it to clkchar.
  128:  */
  129: 
  130: void clkchar();
  131: 
  132: static int clkrput(q, mp)
  133: queue_t *q;
  134: mblk_t *mp;
  135: {
  136:   mblk_t *bp;
  137: 
  138:   switch(mp->b_datap->db_type)
  139:   {
  140:     case M_DATA:
  141:       clkchar(0,q,2);
  142:       for(bp=mp; bp!=NULL; bp=bp->b_cont)
  143:       {
  144: 	while(bp->b_rptr < bp->b_wptr)
  145: 	  clkchar( ((u_char)*(bp->b_rptr++)) , q , 0 );
  146:       }
  147:       clkchar(0,q,1);
  148:       freemsg(mp);
  149:     break;
  150:     default:
  151:       putnext(q,mp);
  152:     break;
  153:   }
  154: 
  155: }
  156: 
  157: /*
  158:  * If it's a matching M_IOCTL, handle it.
  159:  */
  160: 
  161: static int clkwput(q, mp)
  162: queue_t *q;
  163: mblk_t *mp;
  164: {
  165:   struct iocblk *iocp;
  166: 
  167:   switch(mp->b_datap->db_type)
  168:   {
  169:     case M_IOCTL:
  170:       iocp=(struct iocblk*) mp->b_rptr;
  171:       if (iocp->ioc_cmd==CLK_SETSTR)
  172:       {
  173:         strncpy( ((struct priv_data_type *) (RD(q)->q_ptr))->string,
  174: 	  (char *) mp->b_cont->b_rptr,CLK_MAXSTRSIZE);
  175:         /* make sure it's null terminated */
  176: 	((struct priv_data_type *) (RD(q)->q_ptr))->string[CLK_MAXSTRSIZE-1]=0;
  177: 	mp->b_datap->db_type = M_IOCACK;
  178: 	qreply(q,mp);
  179:       }
  180:       else
  181: 	putnext(q,mp);
  182:     break;
  183:     default:
  184:       putnext(q,mp);
  185:     break;
  186:   }
  187: }
  188: 
  189: /*
  190:  * Now clkchar. It takes a character, a queue pointer and an action
  191:  * flag and depending on the flag either:
  192:  *
  193:  * 0 - adds the character to the current message. If there's a
  194:  * timestamp to be done, do that too. If the message is less than
  195:  * 8 chars from being full, link in a new one, and set it up for
  196:  * the next call.
  197:  *
  198:  * 1 - sends the whole mess to Valhala.
  199:  *
  200:  * 2 - set things up.
  201:  *
  202:  * Yeah, it's an ugly hack. Complaints may be filed with /dev/null.
  203:  */
  204: 
  205: 
  206: void clkchar(c,q,f)
  207: 	register u_char c;
  208: 	queue_t *q;
  209: 	char f;
  210: {
  211:   static char error;
  212:   static mblk_t *message,*mp;
  213:   struct timeval tv;
  214: 
  215: /* Get a timestamp ASAP! */
  216:   uniqtime(&tv);
  217: 
  218:   switch(f)
  219:   {
  220:     case 1:
  221:       if (!error)
  222:         putnext(q,message);
  223:     break;
  224:     case 2:
  225:       mp=message= (mblk_t*) allocb(MESSAGE_SIZE,BPRI_LO);
  226:       error=(message==NULL);
  227:       if (error)
  228: 	log(LOG_ERR,"clk: cannot allocate message - data lost");
  229:     break;
  230:     case 0:
  231:       if (error) /* If we had an error, forget it. */
  232: 	return;
  233: 
  234:       *mp->b_wptr++=c; /* Put the char away first.
  235: 
  236:       /* If it's in the special string, append a struct timeval */
  237: 
  238:       if (str_chr( ((struct priv_data_type *) (q->q_ptr))->string ,
  239:         c )!=NULL)
  240:       {
  241: 	  int i;
  242: 
  243: 	  for (i=0;i<sizeof(struct timeval);i++)
  244: 	    *mp->b_wptr++= *( ((char*)&tv) + i );
  245:       }
  246: 
  247:       /* If we don't have space for a complete struct timeval, and a
  248:          char, it's time for a new mp block */
  249: 
  250:       if (((mp->b_wptr-mp->b_rptr)+sizeof(struct timeval)+2)>MESSAGE_SIZE)
  251:       {
  252: 	  mp->b_cont= (mblk_t*) allocb(MESSAGE_SIZE,BPRI_LO);
  253: 	  error=(mp->b_cont==NULL);
  254: 	  if (error)
  255: 	  {
  256: 	    log(LOG_ERR,"clk: cannot allocate message - data lost");
  257: 	    freemsg(message);
  258:           }
  259:           mp=mp->b_cont;
  260:       }
  261: 
  262:     break;
  263:   }
  264: }
  265: 
  266: #endif