/*
 * Message Queue example 
 * 
 * Written by Ori Idan Based on demonstration by Gilad Ben-Yosef of codefidence Ltd.
 *
 * To send a message use ./msgqueue -t n -s "message"
 * To receive a message use ./msgqueue -r -t n
 * n - is message type
 *
 * In addition to demonstrating message queues this example also shows how to use getopt() to
 * parse command line arguments
 */
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

#define MAX_MSG_SIZE (255)
#define DEFAULT_TYPE (1)
#define MAX_TYPE (65536)

enum op_mode { NULL_MODE, RECV_MODE, SEND_MODE };

struct msgbuf {
  long mtype;     /* message type, must be > 0 */
  char mtext[MAX_MSG_SIZE];  /* message data */
};

enum op_mode mode = NULL_MODE;
int msgtype = 0;
char * arg = NULL;
unsigned char blocking = 0;


/* Helper Functions */

/* Translate state to msgrcv/msgsnd msg_flags field */
int inline msg_flags(void) {
        return (blocking ? 0 : IPC_NOWAIT);
}

void usage(char *str)
{
        printf("%s [-s message | -r] [-t type]\n -s messages: send the specified message.\n"
                " -r: reciecve a message.\n -t type: use specified type, from 1 to 65536 for receive or send.\n",
                 str);
        exit(0);
}

/* Parse command line and initalize state accordingly */

void parse_param(int argc, char *argv[])
{
        int opt;

        while((opt = getopt(argc, argv, "s:t:rn")) != -1) {
                switch(opt) {
                        case 'r':
                                mode = RECV_MODE;
                                if(msgtype == 0)
                                        msgtype = -MAX_PRIORITY;
                                break;
                        case 's':
                                mode = SEND_MODE;
                                arg = optarg;
                                if(msgtype == 0)
                                        msgtype = DEFAULT_TYPE;
                                break;
                        case 'n':
                                blocking=1;
                                break;
                        case 't':
                                msgtype = atoi(optarg);
                                if((msgtype <= 0) || (msgtype > MAX_PRIORITY)) {
                                        printf("Invalid type requested.\n");
                                        usage(argv[0]);
                                }
                                break;
                        default:
                                usage(argv[0]);
                }
        }

        if(mode == NULL_MODE)
                usage(argv[0]);
  
        return;
}

int main(int argc, char * argv[])
{  
        key_t qkey;               /* This is the SysV IPC key */
        int msgqid;               /* The queue handle */
        struct msgbuf my_msg;     /* This is the message buffer */
        char *err_reason = NULL;

        parse_param(argc, argv);

        /* Obtain queue key */
        qkey = ftok(argv[0], 0);

        if(qkey == -1) {
                printf("ERROR! %s: %s\n", "failed getting queue key", strerror(errno));
                return errno;
        }

        /* Open queue for read and write, creating it if needed */
        msgqid = msgget(qkey,  S_IRWXU | IPC_CREAT);

        if(msgqid == -1) {
                printf("ERROR! %s: %s\n", "failed getting queue id", strerror(errno));
                return errno;
        }
  
        switch(mode) {
                case RECV_MODE:
                           /* Recieve a message, blocking for it if requested */
                        do {
                                if(msgrcv(msgqid, &my_msg, MAX_MSG_SIZE, msgtype, msg_flags()) == -1) {
                                        if (errno != EINTR) {
                                                printf("ERROR! %s: %s\n", "failed to receive a message", 
                                                        strerror(errno));
                                                return errno;
                                        }
                                }
                                /* If we got a signal in the middle of operation, we will have to redo it. 
                                   This is especially of concern if we block. */
                        } while (errno == EINTR);  
                        printf("Message of type %d recevied: %s\n", my_msg.mtype, my_msg.mtext);
                        break;
                case SEND_MODE:
                        /* Prepare a message to send */
                        strncpy(my_msg.mtext, arg, MAX_MSG_SIZE);
                        my_msg.mtype = msgtype;
    
                        /* Send a message, blocking for it if requested */
                        do {
                            /* See remark about signals above */
                                if(msgsnd(msgqid, &my_msg, MAX_MSG_SIZE, msg_flags()) == -1) {
                                        if (errno != EINTR) {
                                                printf("ERROR! %s: %s\n", "failed to send a message", 
                                                        strerror(errno));
                                                return(errno);
                                        }
                                }
                        } while (errno == EINTR);
                        printf("Message sent.\n");
                        break;
                default:
                        printf("ERROR! This should never happen!\n");
                        exit(2);
        }       
        return 0;
}