/*
|| Program to test mq_getattr(3), displaying queue information.
||    mq_attr <path>
||    <path>   pathname of the queue, which must exist
*/
#include <mqueue.h>     /* message queue stuff */
#include <errno.h>      /* errno and perror */
#include <fcntl.h>      /* O_RDONLY */
#include <stdio.h>
int main(int argc, char **argv)
{
   mqd_t mqd;           /* queue descriptor */
   struct mq_attr obuf; /* output attr struct for getattr */
   if (argc < 2)
   {
      printf("A pathname of a message queue is required\n");
      return -1;
   }
   mqd = mq_open(argv[1],O_RDONLY);
   if (-1 != mqd)
   {
      if ( ! mq_getattr(mqd,&obuf) )
      {
         printf("flags: 0x%x  maxmsg: %d  msgsize: %d  curmsgs: %d\n",
         obuf.mq_flags, obuf.mq_maxmsg, obuf.mq_msgsize, obuf.mq_curmsgs);
      }
      else
         perror("mq_getattr()");
   }
   else
      perror("mq_open()");
}

/*
|| Program to test mq_open(3).
||    mq_open  [-p <perms>] [-b <bytes>] [-m <msgs>] [-c] [-x] <path>
||    -p <perms>  access mode to use when creating, default 0600
||    -b <bytes>  maximum message size to set, default MQ_DEF_MSGSIZE
||    -m <msgs>   maximum messages on the queue, default MQ_DEF_MAXMSG
||    -f <flags>  flags to use with mq_open, including:
||       c        use O_CREAT
||       x        use O_EXCL
||    <path>      the pathname of the queue, required
|| Numeric arguments can be given in any form supported by strtoul(3).
*/
#include <mqueue.h>     /* message queue stuff */
#define MQ_DEF_MSGSIZE 1024
#define MQ_DEF_MAXMSG 16
#include <unistd.h>     /* for getopt() */
#include <errno.h>      /* errno and perror */
#include <fcntl.h>      /* O_flags */
#include <stdio.h>
int main(int argc, char **argv)
{
   int perms = 0600;          /* permissions */
   int oflags = O_RDWR;       /* flags: O_CREAT + O_EXCL */
   int rd=0, wr=0;            /* -r and -w options */
   mqd_t mqd;                 /* returned msg queue descriptor */
   int c;
   char *path;                /* ->first non-option argument */
   struct mq_attr buf;        /* buffer for stat info */
   buf.mq_msgsize = MQ_DEF_MSGSIZE;
   buf.mq_maxmsg = MQ_DEF_MAXMSG;
   while ( -1 != (c = getopt(argc,argv,"p:b:m:cx")) )
   {
      switch (c)
      {
      case 'p': /* permissions */
         perms = (int) strtoul(optarg, NULL, 0);
         break;
      case 'b': /* message size */
         buf.mq_msgsize = (int) strtoul(optarg, NULL, 0);
         break;
      case 'm': /* max messages */
         buf.mq_maxmsg = (int) strtoul(optarg, NULL, 0);
         break;
      case 'c': /* use O_CREAT */
         oflags |= O_CREAT;
         break;
      case 'x': /* use O_EXCL */
         oflags |= O_EXCL;
         break;
      default: /* unknown or missing argument */
         return -1;      
      } /* switch */
   } /* while */
   if (optind < argc)
      path = argv[optind]; /* first non-option argument */
   else
      { printf("Queue pathname required\n"); return -1; }
   mqd = mq_open(path,oflags,perms,&buf);
   if (-1 != mqd)
   {
      if ( ! mq_getattr(mqd,&buf) )
      {
         printf("flags: 0x%x  maxmsg: %d  msgsize: %d  curmsgs: %d\n",
         buf.mq_flags, buf.mq_maxmsg, buf.mq_msgsize, buf.mq_curmsgs);
      }
      else
         perror("mq_getattr()");
   }
   else
      perror("mq_open()");
}

/*
|| Program to test mq_send(3)
||    mq_send [-p <priority>] [-b <bytes>] [-c <count>] [-n] <path>
||       -p <priority>  priority code to use, default 0
||       -b <bytes>     size of the message, default 64, min 32
||       -c <count>     number of messages to send, default 1, max 9999
||       -n             use O_NONBLOCK flag in open
||       <path>         path to queue, required
|| The program sends <count> messages of <bytes> each at <priority>.
|| Each message is an ASCII string containing the time and date and
|| a serial number 1..<count>. The minimum message is 32 bytes.
*/
#include <mqueue.h>        /* message queue stuff */
#include <unistd.h>        /* for getopt() */
#include <errno.h>         /* errno and perror */
#include <time.h>          /* time(2) and ctime_r(3) */
#include <fcntl.h>         /* O_WRONLY */
#include <stdlib.h>        /* calloc(3) */
#include <stdio.h>
int main(int argc, char **argv)
{
   char *path;             /* -> first non-option argument */
   int oflags = O_WRONLY;  /* open flags, O_NONBLOCK may be added */
   mqd_t mqd;              /* queue descriptor from mq_open */
   unsigned int msg_prio = 0; /* message priority to use */
   size_t msglen = 64;     /* message size */
   int count = 1;          /* number of messages to send */
   char *msgptr;           /* -> allocated message space */
   int c;
   while ( -1 != (c = getopt(argc,argv,"p:b:c:n")) )
   {
      switch (c)
      {
      case 'p': /* priority */
         msg_prio = strtoul(optarg, NULL, 0);
         break;
      case 'b': /* bytes */
         msglen = strtoul(optarg, NULL, 0);
         if (msglen<32) msglen = 32;
         break;
      case 'c': /* count */
         count = strtoul(optarg, NULL, 0);
         if (count > 99999) count = 99999;
         break;
      case 'n': /* use nonblock */
         oflags |= O_NONBLOCK;
         break;
      default: /* unknown or missing argument */
         return -1;      
      }
   }
   if (optind < argc)
      path = argv[optind]; /* first non-option argument */
   else
      { printf("Queue pathname required\n"); return -1; }
   msgptr = calloc(1,msglen);
   mqd = mq_open(path,oflags);
   if (-1 != mqd)
   {
      char stime[26];
      const time_t tm = time(NULL); /* current time value */
      (void)ctime_r (&tm,stime);    /* formatted time string */
      stime[24] = '\0' ;            /* drop annoying \n */
      for( c=1; c<=count; ++c)
      {
         sprintf(msgptr,"%05d %s",c,stime);
         if ( mq_send(mqd,msgptr,msglen,msg_prio) )
         {
            perror("mq_send()");
            break;
         }
      }
   }
   else
      perror("mq_open(O_WRONLY)");
}

/*
|| Program to test mq_receive(3)
||    mq_receive [-c <count>] [-n] [-q] <path>
||       -c <count>     number of messages to request, default 1
||       -n             use O_NONBLOCK flag on open
||       -q             quiet, do not display messages
||       <path>         path to message queue, required
|| The program calls mq_receive <count> times or until an error occurs.
*/
#include <mqueue.h>        /* message queue stuff */
#include <unistd.h>        /* for getopt() */
#include <errno.h>         /* errno and perror */
#include <fcntl.h>         /* O_RDONLY */
#include <stdlib.h>        /* calloc(3) */
#include <stdio.h>
int main(int argc, char **argv)
{
   char *path;             /* -> first non-option argument */
   int oflags = O_RDONLY;  /* open flags, O_NONBLOCK may be added */
   int quiet = 0;          /* -q option */
   int count = 1;          /* number of messages to request */
   mqd_t mqd;              /* queue descriptor from mq_open */
   char *msgptr;           /* -> allocated message space */
   unsigned int msg_prio;  /* received message priority */
   int c, ret;
   struct mq_attr obuf;    /* output of mq_getattr(): mq_msgsize */
   while ( -1 != (c = getopt(argc,argv,"c:nq")) )
   {
      switch (c)
      {
      case 'c': /* count */
         count = strtoul(optarg, NULL, 0);
         break;
      case 'q': /* quiet */
         quiet = 1;
         break;
      case 'n': /* nonblock */
         oflags |= O_NONBLOCK;
         break;
      default: /* unknown or missing argument */
         return -1;      
      }
   }
   if (optind < argc)
      path = argv[optind]; /* first non-option argument */
   else
      { printf("Queue pathname required\n"); return -1; }
   mqd = mq_open(path,oflags);
   if (-1 != mqd)
   {
      if (! (mq_getattr(mqd,&obuf)) ) /* get max message size */
      {
         msgptr = calloc(1,obuf.mq_msgsize);
         for( c=1; c<=count; ++c)
         {
            ret = mq_receive(mqd,msgptr,obuf.mq_msgsize,&msg_prio);
            if (ret >= 0) /* got a message */
            {
               if (!quiet)
               {
                  if ( isascii(*msgptr) )
                     printf("%d: priority %ld  len %d text %-32.32s\n",
                              c, msg_prio,        ret,      msgptr);
                  else
                     printf("%d: priority %ld  len %d (nonascii)\n",
                              c,  msg_prio,        ret);
               }
            }
            else /* an error on receive, stop */
            {
               perror("mq_receive()");
               break;
            }
         } /* for c <= count */
      } /* if getattr */
      else
      {
         perror("mq_getattr()");
         return -1;
      }     
   } /* if open */
   else
      perror("mq_open(O_WRONLY)");
}  

/*
|| Program to test msgget(2).
||    msgget [-k <key>] [-p <perms>] [-x] [-c]
||       -k <key>    the key to use, default == 0 == IPC_PRIVATE
||       -p <perms>  permissions to use, default 600
||       -x          use IPC_EXCL
||       -c          use IPC_CREAT
*/
#include <sys/msg.h>    /* msg queue stuff, ipc.h, types.h */
#include <unistd.h>     /* for getopt() */
#include <errno.h>      /* errno and perror */
#include <stdio.h>
int main(int argc, char **argv)
{
   key_t key = IPC_PRIVATE;   /* key */
   int perms = 0600;          /* permissions */
   int msgflg = 0;            /* flags: CREAT + EXCL */
   int msqid;                 /* returned msg queue id */
   struct msqid_ds buf;       /* buffer for stat info */
   int c;
   while ( -1 != (c = getopt(argc,argv,"k:p:xc")) )
   {
      switch (c)
      {
      case 'k': /* key */
         key = (key_t) strtoul(optarg, NULL, 0);
         break;
      case 'p': /* permissions */
         perms = (int) strtoul(optarg, NULL, 0);
         break;
      case 'c':
         msgflg |= IPC_CREAT;
         break;
      case 'x':
         msgflg |= IPC_EXCL;
         break;
      default: /* unknown or missing argument */
         return -1;      
      }
   }
   msqid = msgget (key, msgflg|perms);
   if (-1 != msqid)
   {
      printf("msqid = 0x%04x. ",msqid);
      if (-1 != msgctl(msqid,IPC_STAT,&buf))
      {
         printf("owner = %d.%d, perms = %04o, max bytes = %d\n",
                  buf.msg_perm.uid,
                  buf.msg_perm.gid,
                  buf.msg_perm.mode,
                  buf.msg_qbytes);           
         printf("%d msgs = %d bytes on queue\n",
                  buf.msg_qnum, buf.msg_cbytes);
      }
      else
         perror("\nmsgctl()");
   }
   else
      perror("msgget()");
}

/*
|| Program to test msgctl(2).
||    msgctl {-k <key> -i <id>} [-b <bytes>] [-p <perms>] [-u <uid>] [-g <gid>]
||       -k <key>    the key to use, or..
||       -i <id>     ..the mq id
||       -b <bytes>  new max number of bytes to set in msg_qbytes
||       -p <perms>  new permissions to assign in msg_perm.mode
||       -u <uid>    new user id (numeric) for msg_perm.uid
||       -g <gid>    new group id (numeric) for msg_perm.gid
*/
#include <sys/msg.h>    /* msg queue stuff, ipc.h, types.h */
#include <unistd.h>     /* for getopt() */
#include <errno.h>      /* errno and perror */
#include <stdio.h>
int main(int argc, char **argv)
{
   key_t key;           /* key for msgget.. */
   int msqid = -1;      /* ..specified or received msg queue id */
   long perms = -1L;    /* -1L is not valid for any of these */
   long bytes = -1L;
   long uid = -1L;
   long gid = -1L;
   struct msqid_ds buf;
   int c;
   while ( -1 != (c = getopt(argc,argv,"k:i:b:p:u:g:")) )
   {
      switch (c)
      {
      case 'k': /* key */
         key = (key_t) strtoul(optarg, NULL, 0);
         break;
      case 'i': /* id */
         msqid = (int) strtoul(optarg, NULL, 0);
         break;
      case 'p': /* permissions */
         perms = strtoul(optarg, NULL, 0);
         break;
      case 'b': /* bytes */
         bytes = strtoul(optarg, NULL, 0);
         break;
      case 'u': /* uid */
         uid = strtoul(optarg, NULL, 0);
         break;
      case 'g': /* gid */
         gid = strtoul(optarg, NULL, 0);
         break;
      default: /* unknown or missing argument */
         return -1;      
      }
   }
   if (-1 == msqid) /* no id given, try key */
      msqid = msgget (key, 0);
   if (-1 != msqid)
   {
      if (-1 != msgctl(msqid,IPC_STAT,&buf))
      {
         if ((perms!=-1L)||(bytes!=-1L)||(uid!=-1L)||(gid!=-1L))
         {
            /* put new values in buf fields as requested */
            if (perms != -1L) buf.msg_perm.mode = (mode_t)perms;
            if (uid   != -1L) buf.msg_perm.uid  = (uid_t)uid;
            if (gid   != -1L) buf.msg_perm.gid  = (gid_t)gid;
            if (bytes != -1L) buf.msg_qbytes = (ulong_t)bytes;
            if (-1 == msgctl(msqid,IPC_SET,&buf))
               perror("\nmsgctl(IPC_SET)");
         }
         printf("owner = %d.%d, perms = %04o, max bytes = %d\n",
               buf.msg_perm.uid,
               buf.msg_perm.gid,
               buf.msg_perm.mode,
               buf.msg_qbytes);           
         printf("%d msgs = %d bytes on queue\n",
               buf.msg_qnum, buf.msg_cbytes);
      }
      else
         perror("\nmsgctl(IPC_STAT)");
   }
   else
      perror("msgget()");
}

/*
|| Program to test msgsnd(2)
||    msgsnd {-k <key> -i <id>} [-t <type>] [-b <bytes>] [-c <count>] [-n]
||       -k <key>    the key to use, or..
||       -i <id>     ..the mq id
||       -t <type>   the type of each message, default = 1
||       -b <bytes>  the size of each message, default = 64, min 32
||       -c <count>  the number of messages to send, default = 1, max 99999
||       -n          use IPC_NOWAIT flag
|| The program sends <count> messages of <type>, <bytes> each on the queue.
|| Each message is an ASCII string containing the time and date, and
|| a serial number 1..<count>, minimum message is 32 bytes.
*/
#include <sys/msg.h>    /* msg queue stuff, ipc.h, types.h */
#include <unistd.h>     /* for getopt() */
#include <errno.h>      /* errno and perror */
#include <time.h>       /* time(2) and ctime_r(3) */
#include <stdio.h>
int main(int argc, char **argv)
{
   key_t key;           /* key for msgget.. */
   int msqid = -1;      /* ..specified or received msg queue id */
   int msgflg = 0;      /* flag, 0 or IPC_NOWAIT */
   long type = 1;       /* message type -- 0 is not valid to msgsnd() */
   size_t bytes = 64;   /* message text size */
   int count = 1;       /* number to send */
   int c;
   struct msgspace { long type; char text[32]; } *msg;
   while ( -1 != (c = getopt(argc,argv,"k:i:t:b:c:n")) )
   {
      switch (c)
      {
      case 'k': /* key */
         key = (key_t) strtoul(optarg, NULL, 0);
         break;
      case 'i': /* id */
         msqid = (int) strtoul(optarg, NULL, 0);
         break;
      case 't': /* type */
         type = strtoul(optarg, NULL, 0);
         break;
      case 'b': /* bytes */
         bytes = strtoul(optarg, NULL, 0);
         if (bytes<32) bytes = 32;
         break;
      case 'c': /* count */
         count = strtoul(optarg, NULL, 0);
         if (count > 99999) count = 99999;
         break;
      case 'n': /* nowait */
         msgflg |= IPC_NOWAIT;
         break;
      default: /* unknown or missing argument */
         return -1;      
      }
   }
   msg = (struct msgspace *)calloc(1,sizeof(long)+bytes);    
   if (-1 == msqid) /* no id given, try key */
      msqid = msgget (key, 0);
   if (-1 != msqid)
   {
      const time_t tm = time(NULL);
      char stime[26];
      (void)ctime_r (&tm,stime); /* format timestamp for msg */
      stime[24] = '\0';          /* drop annoying \n */
      for( c=1; c<=count; ++c)
      {
         msg->type = type;
         sprintf(msg->text,"%05d %s",c,stime);
         if (-1 == msgsnd(msqid,msg,bytes,msgflg))
         {
            perror("msgsnd()");
            break;
         }
      }
   }
   else
      perror("msgget()");
}

/*
|| Program to test msgrcv(2)
||    msgrcv {-k <key> -i <id>} [-t <type>] [-b <bytes>] [-c <count>]
||                                           [-n] [-e] [-q]
||       -k <key>    the key to use, or..
||       -i <id>     ..the mq id
||       -t <type>   the type of message, default = 0 (any msg)
||       -b <bytes>  the max size to receive, default = 64
||       -c <count>  the number of messages to receive, default = 1
||       -n          use IPC_NOWAIT flag
||       -e          use MSG_NOERROR flag (truncate long msg)
||       -q          quiet, do not display received message
|| The program calls msgrcv <count> times or until an error occurs,
|| each time requesting a message of type <type> and max size <bytes>.
*/
#include <sys/msg.h>    /* msg queue stuff, ipc.h, types.h */
#include <unistd.h>     /* for getopt() */
#include <errno.h>      /* errno and perror */
#include <ctype.h>      /* isascii() */
#include <stdio.h>
int main(int argc, char **argv)
{
   key_t key;           /* key for msgget.. */
   int msqid = -1;      /* ..specified or received msg queue id */
   int msgflg = 0;      /* flag, 0, IPC_NOWAIT, MSG_NOERROR */
   long type = 0;       /* message type */
   size_t bytes = 64;   /* message size limit */
   int count = 1;       /* number to receive */
   int quiet = 0;       /* quiet flag */
   int c;
   struct msgspace { long type; char text[32]; } *msg;
   while ( -1 != (c = getopt(argc,argv,"k:i:t:b:c:enq")) )
   {
      switch (c)
      {
      case 'k': /* key */
         key = (key_t) strtoul(optarg, NULL, 0);
         break;
      case 'i': /* id */
         msqid = (int) strtoul(optarg, NULL, 0);
         break;
      case 't': /* type -- can be negative */
         type = strtol(optarg, NULL, 0);
         break;
      case 'b': /* bytes -- no minimum */
         bytes = strtoul(optarg, NULL, 0);
         break;
      case 'c': /* count - no maximum */
         count = strtoul(optarg, NULL, 0);
         break;
      case 'n': /* nowait */
         msgflg |= IPC_NOWAIT;
         break;
      case 'e': /* noerror -- allow truncation of msgs */
         msgflg |= MSG_NOERROR;
         break;
      case 'q': /* quiet */
         quiet = 1;
         break;
      default: /* unknown or missing argument */
         return -1;      
      }
   }
   if (-1 == msqid) /* no id given, try key */
      msqid = msgget (key, 0);
   msg = (struct msgspace *)calloc(1,sizeof(long)+bytes);    
   if (-1 != msqid)
   {
      for( c=1; c<=count; ++c)
      {
         int ret = msgrcv(msqid,msg,bytes,type,msgflg);
         if (ret >= 0) /* got a message */
         {
            if (!quiet)
            {
               if (isascii(msg->text[0]))
                  printf("%d: type %ld  len %d text %-32.32s\n",
                           c,   msg->type,  ret,      msg->text);
               else
                  printf("%d: type %ld len %d (nonascii)\n",
                           c,   msg->type,  ret);
            }
         }
         else /* an error, end loop */
         {
            perror("msgrcv()");
            break;
         }
      } /* for c<=count */
   } /* good msgget */
   else
      perror("msgget()");
}