Linux-Network-Program-Samples/msgtool.c at master · EternalPeace/Linux-Network-Program-Samples · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define MAX_SEND_SIZE 80

struct mymsgbuf
{
  long mtype;
  char mtext[MAX_SEND_SIZE];
};

void send_message (int qid, struct mymsgbuf *qbuf, long type, char *text);
void read_message (int qid, struct mymsgbuf *qbuf, long type);
void remove_queue (int qid);
void change_queue_mode (int qid, char *mode);
void usage (void);

int
main (int argc, char *argv[])
{
  key_t key;
  int msgqueue_id;
  struct mymsgbuf qbuf;
  if (argc == 1)
    usage ();
  /* Create unique key via call to ftok() */
  key = ftok (".", 'm');
  /* Open the queue - create if necessary */
  if ((msgqueue_id = msgget (key, IPC_CREAT | 0660)) == -1)
    {
      perror ("msgget");
      exit (1);
    }
  switch (tolower (argv[1][0]))
    {

    case 's':
      send_message (msgqueue_id, (struct mymsgbuf *) &qbuf, atol (argv[2]),
		    argv[3]);
      break;
    case 'r':
      read_message (msgqueue_id, &qbuf, atol (argv[2]));
      break;
    case 'd':
      remove_queue (msgqueue_id);
      break;
    case 'm':
      change_queue_mode (msgqueue_id, argv[2]);
      break;
    default:
      usage ();


    }

  return (0);
}

void
usage ();
send_message (int qid, struct mymsgbuf *qbuf, long type, char *text)
{
  /* Send a message to the queue */
  printf ("Sending a message ...\n");
  qbuf->mtype = type;
  strcpy (qbuf->mtext, text);


  if ((msgsnd (qid, (struct msgbuf *) qbuf, strlen (qbuf->mtext) + 1, 0)) ==
      -1)
    {
      perror ("msgsnd");
      exit (1);
    }
}

void
read_message (int qid, struct mymsgbuf *qbuf, long type)
{
  /* Read a message from the queue */
  printf ("Reading a message ...\n");
  qbuf->mtype = type;
  msgrcv (qid, (struct msgbuf *) qbuf, MAX_SEND_SIZE, type, 0);

  printf ("Type: %ld Text: %s\n", qbuf->mtype, qbuf->mtext);
}

void
remove_queue (int qid)
{
  /* Remove the queue */
  msgctl (qid, IPC_RMID, 0);
}

void
change_queue_mode (int qid, char *mode)
{
  struct msqid_ds myqueue_ds;
  /* Get current info */
  msgctl (qid, IPC_STAT, &myqueue_ds);
  /* Convert and load the mode */
  sscanf (mode, "%ho", &myqueue_ds.msg_perm.mode);
  /* Update the mode */
  msgctl (qid, IPC_SET, &myqueue_ds);
}

void
usage (void)
{
  fprintf (stderr, "msgtool - A utility for tinkering with msg queues\n");
  fprintf (stderr, "\nUSAGE: msgtool (s)end <type> <messagetext>\n");
  fprintf (stderr, "		(r)ecv <type>\n");
  fprintf (stderr, "		(d)elete\n");
  fprintf (stderr, "		(m)ode <octal mode>\n");
  exit (1);
}