Return to msg.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src

mpd 5.9

    1: 
    2: /*
    3:  * msg.c
    4:  *
    5:  * Written by Archie Cobbs <archie@freebsd.org>
    6:  * Copyright (c) 1995-1999 Whistle Communications, Inc. All rights reserved.
    7:  * See ``COPYRIGHT.whistle''
    8:  */
    9: 
   10: #include "ppp.h"
   11: #include "msg.h"
   12: 
   13: /*
   14:  * DEFINITIONS
   15:  */
   16: 
   17: /* Which pipe file descriptor is which */
   18: 
   19:   #define PIPE_READ		0
   20:   #define PIPE_WRITE		1
   21: 
   22:   struct mpmsg
   23:   {
   24:     int		type;
   25:     void	(*func)(int type, void *arg);
   26:     void	*arg;
   27:     const char	*dbg;
   28:   };
   29:   typedef struct mpmsg	*Msg;
   30: 
   31:   static struct mpmsg	msgqueue[MSG_QUEUE_LEN];
   32:   static int		msgqueueh = 0;
   33:   static int		msgqueuet = 0;
   34:   #define	QUEUELEN()	((msgqueueh >= msgqueuet)?	\
   35: 	(msgqueueh - msgqueuet):(msgqueueh + MSG_QUEUE_LEN - msgqueuet))
   36: 
   37:   static int		msgpipe[2];
   38:   static int		msgpipesent = 0;
   39:   static EventRef	msgevent;
   40: 
   41: /*
   42:  * GLOBAL VARIABLES
   43:  */
   44: 
   45:   int		gQThresMin = 64;
   46:   int		gQThresMax = 256;
   47:   int		gQThresDiff = 256 - 64;
   48: 
   49: /*
   50:  * INTERNAL FUNCTIONS
   51:  */
   52: 
   53:   static void	MsgEvent(int type, void *cookie);
   54: 
   55: /*
   56:  * MsgRegister()
   57:  */
   58: 
   59: void
   60: MsgRegister2(MsgHandler *m, void (*func)(int type, void *arg), const char *dbg)
   61: {
   62:     if ((msgpipe[0]==0) || (msgpipe[1]==0)) {
   63: 	if (pipe(msgpipe) < 0) {
   64: 	    Perror("%s: Can't create message pipe", 
   65: 		__FUNCTION__);
   66: 	    DoExit(EX_ERRDEAD);
   67: 	}
   68: 	fcntl(msgpipe[PIPE_READ], F_SETFD, 1);
   69: 	fcntl(msgpipe[PIPE_WRITE], F_SETFD, 1);
   70: 
   71: 	if (fcntl(msgpipe[PIPE_READ], F_SETFL, O_NONBLOCK) < 0)
   72:     	    Perror("%s: fcntl", __FUNCTION__);
   73: 	if (fcntl(msgpipe[PIPE_WRITE], F_SETFL, O_NONBLOCK) < 0)
   74:     	    Perror("%s: fcntl", __FUNCTION__);
   75: 
   76: 	if (EventRegister(&msgevent, EVENT_READ,
   77: 		msgpipe[PIPE_READ], EVENT_RECURRING, MsgEvent, NULL) < 0) {
   78: 	    Perror("%s: Can't register event", __FUNCTION__);
   79: 	    DoExit(EX_ERRDEAD);
   80:         }
   81:     }
   82: 
   83:     m->func = func;
   84:     m->dbg = dbg;
   85: }
   86: 
   87: /*
   88:  * MsgUnRegister()
   89:  */
   90: 
   91: void
   92: MsgUnRegister(MsgHandler *m)
   93: {
   94:     m->func = NULL;
   95:     m->dbg = NULL;
   96: }
   97: 
   98: /*
   99:  * MsgEvent()
  100:  */
  101: 
  102: static void
  103: MsgEvent(int type, void *cookie)
  104: {
  105:     char	buf[16];
  106: 
  107:     (void)type;
  108:     (void)cookie;
  109:     /* flush signaling pipe */
  110:     msgpipesent = 0;
  111:     while (read(msgpipe[PIPE_READ], buf, sizeof(buf)) == sizeof(buf));
  112: 
  113:     while (msgqueuet != msgqueueh) {
  114: 	Log(LG_EVENTS, ("EVENT: Message %d to %s received",
  115: 	    msgqueue[msgqueuet].type, msgqueue[msgqueuet].dbg));
  116: 	(*(msgqueue[msgqueuet].func))(msgqueue[msgqueuet].type, msgqueue[msgqueuet].arg);
  117: 	Log(LG_EVENTS, ("EVENT: Message %d to %s processed",
  118: 	    msgqueue[msgqueuet].type, msgqueue[msgqueuet].dbg));
  119: 
  120: 	msgqueuet = (msgqueuet + 1) & MSG_QUEUE_MASK;
  121: 	SETOVERLOAD(QUEUELEN());
  122:     }
  123: }
  124: 
  125: /*
  126:  * MsgSend()
  127:  */
  128: 
  129: void
  130: MsgSend(MsgHandler *m, int type, void *arg)
  131: {
  132:     assert(m);
  133:     assert(m->func);
  134: 
  135:     msgqueue[msgqueueh].type = type;
  136:     msgqueue[msgqueueh].func = m->func;
  137:     msgqueue[msgqueueh].arg = arg;
  138:     msgqueue[msgqueueh].dbg = m->dbg;
  139: 
  140:     msgqueueh = (msgqueueh + 1) & MSG_QUEUE_MASK;
  141:     if (msgqueuet == msgqueueh) {
  142:         Log(LG_ERR, ("%s: Fatal message queue overflow!", __FUNCTION__));
  143:         DoExit(EX_ERRDEAD);
  144:     }
  145: 
  146:     SETOVERLOAD(QUEUELEN());
  147: 
  148:     if (!msgpipesent) {
  149: 	char	buf[1] = { 0x2a };
  150: 	if (write(msgpipe[PIPE_WRITE], buf, 1) > 0)
  151: 	    msgpipesent = 1;
  152:     }
  153:     Log(LG_EVENTS, ("EVENT: Message %d to %s sent", type, m->dbg));
  154: }
  155: 
  156: /*
  157:  * MsgName()
  158:  */
  159: 
  160: const char *
  161: MsgName(int msg)
  162: {
  163:   switch (msg)
  164:   {
  165:     case MSG_OPEN:
  166:       return("OPEN");
  167:     case MSG_CLOSE:
  168:       return("CLOSE");
  169:     case MSG_UP:
  170:       return("UP");
  171:     case MSG_DOWN:
  172:       return("DOWN");
  173:     case MSG_SHUTDOWN:
  174:       return("SHUTDOWN");
  175:     default:
  176:       return("???");
  177:   }
  178: }
  179: