Return to msgop.c CVS log

Up to [MW Coherent from dump] / coherent / d / kernel / USRSRC / i8086 / drv

Annotation of coherent/d/kernel/USRSRC/i8086/drv/msgop.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * User Message Functions.
                      3:  *
                      4:  *     Note: msgget() must be first function called.
                      5:  *
                      6:  *     91/02/07        Hal Snyder      mwchwc!/u/libc/sys/msgop.c
                      7:  *     msgget():  sizeof(key_t) is 4, not 2.
                      8:  */
                      9: #include <sys/msg.h>
                     10: #include <errno.h>
                     11: 
                     12: static int  msgfno   = -1;
                     13: static char msgdev[] = "/dev/msg";
                     14: 
                     15: /*
                     16:  * Message Control Operations.
                     17:  */
                     18: 
                     19: msgctl( msqid, cmd, buf )
                     20: 
                     21: int msqid;
                     22: int cmd;
                     23: struct msqid_ds * buf;
                     24: 
                     25: {
                     26:        int parm[4];
                     27: 
                     28:        if ( msgfno < 0 ) {
                     29:                errno = ENODEV;
                     30:                return -1;
                     31:        }
                     32: 
                     33:        parm[0] = -1;
                     34:        parm[1] = msqid;
                     35:        parm[2] = cmd;
                     36:        parm[3] = (int) buf;
                     37: 
                     38:        ioctl( msgfno, MSGCTL, parm );
                     39:        return parm[0];
                     40: }
                     41: 
                     42: /*
                     43:  * Get Message Queue.
                     44:  */
                     45: 
                     46: msgget( key, msgflg )
                     47: 
                     48: key_t key;
                     49: int msgflg;
                     50: 
                     51: {
                     52:        int parm[4];
                     53: 
                     54:        if ( msgfno < 0 ) {
                     55: 
                     56:                msgfno = open(msgdev, 0);
                     57: 
                     58:                if ( msgfno < 0 ) {
                     59:                        perror(msgdev);
                     60:                        errno = ENODEV;
                     61:                        return -1;
                     62:                }
                     63:        }
                     64: 
                     65:        parm[0] = -1;
                     66:        parm[1] = key;
                     67:        parm[2] = key >> 16;
                     68:        parm[3] = msgflg;
                     69: 
                     70:        ioctl( msgfno, MSGGET, parm );
                     71:        return parm[0];
                     72: }
                     73: 
                     74: /*
                     75:  * Send Message.
                     76:  */
                     77:  
                     78: msgsnd( msqid, msgp, msgsz, msgflg )
                     79: 
                     80: int msqid;
                     81: struct msgbuf *msgp;
                     82: int msgsz;
                     83: int msgflg;
                     84: 
                     85: {
                     86:        int parm[5];
                     87: 
                     88:        if ( msgfno < 0 ) {
                     89:                errno = ENODEV;
                     90:                return -1;
                     91:        }
                     92: 
                     93:        parm[0] = -1;
                     94:        parm[1] = msqid;
                     95:        parm[2] = (int) msgp;
                     96:        parm[3] = msgsz;
                     97:        parm[4] = msgflg;
                     98: 
                     99:        ioctl( msgfno, MSGSND, parm );
                    100:        return parm[0];
                    101: }
                    102: 
                    103: /*
                    104:  * Receive Message.
                    105:  */
                    106:  
                    107: msgrcv( msqid, msgp, msgsz, msgtyp, msgflg )
                    108: 
                    109: int msqid;
                    110: struct msgbuf *msgp;
                    111: int msgsz;
                    112: long msgtyp;
                    113: int msgflg;
                    114: 
                    115: {
                    116:        int parm[7];
                    117: 
                    118:        if ( msgfno < 0 ) {
                    119:                errno = ENODEV;
                    120:                return -1;
                    121:        }
                    122: 
                    123:        parm[0] = -1;
                    124:        parm[1] = msqid;
                    125:        parm[2] = (int) msgp;
                    126:        parm[3] = msgsz;
                    127:        parm[4] = (int) msgtyp;
                    128:        parm[5] = (int) (msgtyp >> 16);
                    129:        parm[6] = msgflg;
                    130: 
                    131:        ioctl( msgfno, MSGRCV, parm );
                    132:        return parm[0];
                    133: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.