Return to msg.c CVS log

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

Annotation of embedaddon/mpd/src/msg.c, revision 1.1

1.1     ! misho       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:   #define      MSG_QUEUE_LEN   8192
        !            32:   #define      MSG_QUEUE_MASK  0x1FFF
        !            33: 
        !            34:   struct mpmsg msgqueue[MSG_QUEUE_LEN];
        !            35:   int          msgqueueh = 0;
        !            36:   int          msgqueuet = 0;
        !            37:   #define      QUEUELEN()      ((msgqueueh >= msgqueuet)?      \
        !            38:        (msgqueueh - msgqueuet):(msgqueueh + MSG_QUEUE_LEN - msgqueuet))
        !            39: 
        !            40:   int           msgpipe[2];
        !            41:   int          msgpipesent = 0;
        !            42:   EventRef     msgevent;
        !            43: 
        !            44: /*
        !            45:  * INTERNAL FUNCTIONS
        !            46:  */
        !            47: 
        !            48:   static void  MsgEvent(int type, void *cookie);
        !            49: 
        !            50: /*
        !            51:  * MsgRegister()
        !            52:  */
        !            53: 
        !            54: void
        !            55: MsgRegister2(MsgHandler *m, void (*func)(int type, void *arg), const char *dbg)
        !            56: {
        !            57:     if ((msgpipe[0]==0) || (msgpipe[1]==0)) {
        !            58:        if (pipe(msgpipe) < 0) {
        !            59:            Perror("%s: Can't create message pipe", 
        !            60:                __FUNCTION__);
        !            61:            DoExit(EX_ERRDEAD);
        !            62:        }
        !            63:        fcntl(msgpipe[PIPE_READ], F_SETFD, 1);
        !            64:        fcntl(msgpipe[PIPE_WRITE], F_SETFD, 1);
        !            65: 
        !            66:        if (fcntl(msgpipe[PIPE_READ], F_SETFL, O_NONBLOCK) < 0)
        !            67:            Perror("%s: fcntl", __FUNCTION__);
        !            68:        if (fcntl(msgpipe[PIPE_WRITE], F_SETFL, O_NONBLOCK) < 0)
        !            69:            Perror("%s: fcntl", __FUNCTION__);
        !            70: 
        !            71:        if (EventRegister(&msgevent, EVENT_READ,
        !            72:                msgpipe[PIPE_READ], EVENT_RECURRING, MsgEvent, NULL) < 0) {
        !            73:            Perror("%s: Can't register event", __FUNCTION__);
        !            74:            DoExit(EX_ERRDEAD);
        !            75:         }
        !            76:     }
        !            77: 
        !            78:     m->func = func;
        !            79:     m->dbg = dbg;
        !            80: }
        !            81: 
        !            82: /*
        !            83:  * MsgUnRegister()
        !            84:  */
        !            85: 
        !            86: void
        !            87: MsgUnRegister(MsgHandler *m)
        !            88: {
        !            89:     m->func = NULL;
        !            90:     m->dbg = NULL;
        !            91: }
        !            92: 
        !            93: /*
        !            94:  * MsgEvent()
        !            95:  */
        !            96: 
        !            97: static void
        !            98: MsgEvent(int type, void *cookie)
        !            99: {
        !           100:     char       buf[16];
        !           101:     /* flush signaling pipe */
        !           102:     msgpipesent = 0;
        !           103:     while (read(msgpipe[PIPE_READ], buf, sizeof(buf)) == sizeof(buf));
        !           104: 
        !           105:     while (msgqueuet != msgqueueh) {
        !           106:        Log(LG_EVENTS, ("EVENT: Message %d to %s received",
        !           107:            msgqueue[msgqueuet].type, msgqueue[msgqueuet].dbg));
        !           108:        (*(msgqueue[msgqueuet].func))(msgqueue[msgqueuet].type, msgqueue[msgqueuet].arg);
        !           109:        Log(LG_EVENTS, ("EVENT: Message %d to %s processed",
        !           110:            msgqueue[msgqueuet].type, msgqueue[msgqueuet].dbg));
        !           111: 
        !           112:        msgqueuet = (msgqueuet + 1) & MSG_QUEUE_MASK;
        !           113:        SETOVERLOAD(QUEUELEN());
        !           114:     }
        !           115: }
        !           116: 
        !           117: /*
        !           118:  * MsgSend()
        !           119:  */
        !           120: 
        !           121: void
        !           122: MsgSend(MsgHandler *m, int type, void *arg)
        !           123: {
        !           124:     assert(m);
        !           125:     assert(m->func);
        !           126: 
        !           127:     msgqueue[msgqueueh].type = type;
        !           128:     msgqueue[msgqueueh].func = m->func;
        !           129:     msgqueue[msgqueueh].arg = arg;
        !           130:     msgqueue[msgqueueh].dbg = m->dbg;
        !           131: 
        !           132:     msgqueueh = (msgqueueh + 1) & MSG_QUEUE_MASK;
        !           133:     if (msgqueuet == msgqueueh) {
        !           134:         Log(LG_ERR, ("%s: Fatal message queue overflow!", __FUNCTION__));
        !           135:         DoExit(EX_ERRDEAD);
        !           136:     }
        !           137: 
        !           138:     SETOVERLOAD(QUEUELEN());
        !           139: 
        !           140:     if (!msgpipesent) {
        !           141:        char    buf[1] = { 0x2a };
        !           142:        if (write(msgpipe[PIPE_WRITE], buf, 1) > 0)
        !           143:            msgpipesent = 1;
        !           144:     }
        !           145:     Log(LG_EVENTS, ("EVENT: Message %d to %s sent", type, m->dbg));
        !           146: }
        !           147: 
        !           148: /*
        !           149:  * MsgName()
        !           150:  */
        !           151: 
        !           152: const char *
        !           153: MsgName(int msg)
        !           154: {
        !           155:   switch (msg)
        !           156:   {
        !           157:     case MSG_OPEN:
        !           158:       return("OPEN");
        !           159:     case MSG_CLOSE:
        !           160:       return("CLOSE");
        !           161:     case MSG_UP:
        !           162:       return("UP");
        !           163:     case MSG_DOWN:
        !           164:       return("DOWN");
        !           165:     case MSG_SHUTDOWN:
        !           166:       return("SHUTDOWN");
        !           167:     default:
        !           168:       return("???");
        !           169:   }
        !           170: }
        !           171: