linux IPC programming

//pipe001.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main(void)
{
 int fd[2], nbytes;
 pid_t childpid;
 char string[] = "Hello, world!\n";
 char readbuffer[80];
 pipe(fd);
 if((childpid = fork()) == -1)
 {
  perror("fork");
  exit(1);
 }
 if(childpid == 0)
 {
  /* Child process closes up input side of pipe */
  close(fd[0]);
  /* Send "string" through the output side of pipe */
  write(fd[1], string, strlen(string));
  exit(0);
 }
 else
 {
  /* Parent process closes up output side of pipe */
  close(fd[1]);
  /* Read in a string from the pipe */
  nbytes = read(fd[0], readbuffer, sizeof(readbuffer));
  printf("Received string: %s", readbuffer);
 }
 return(0);
}

//popen1.c
#include <stdio.h>
#define MAXSTRS 5
int main(void)
{
 int cntr;
 FILE *pipe_fp;
 char *strings[MAXSTRS] = { "echo", "bravo", "alpha","charlie", "delta"};
 /* Create one way pipe line with call to popen() */
 if (( pipe_fp = popen("sort", "w")) == NULL)
 {
  perror("popen");
  exit(1);
 }
 /* Processing loop */
 for(cntr=0; cntr<MAXSTRS; cntr++) {
  fputs(strings[cntr], pipe_fp);
  fputc(’\n’, pipe_fp);
 }
 /* Close the pipe */
 pclose(pipe_fp);
 return(0);
}

//popen2.c
#include <stdio.h>
int main(void)
{
 FILE *pipein_fp, *pipeout_fp;
 char readbuf[80];
 /* Create one way pipe line with call to popen() */
 if (( pipein_fp = popen("ls", "r")) == NULL)
 {
  perror("popen");
  exit(1);
 }
 /* Create one way pipe line with call to popen() */
 if (( pipeout_fp = popen("sort", "w")) == NULL)
 {
  perror("popen");
  exit(1);
 }
 /* Processing loop */
 while(fgets(readbuf, 80, pipein_fp))
 fputs(readbuf, pipeout_fp);
 /* Close the pipes */
 pclose(pipein_fp);
 pclose(pipeout_fp);
 return(0);
}

//popen3.c
#include <stdio.h>
int main(int argc, char *argv[])
{
 FILE *pipe_fp, *infile;
 char readbuf[80];
 if( argc != 3) {
  fprintf(stderr, "USAGE: popen3 [command] [filename]\n");
  exit(1);
 }
 /* Open up input file */
 if (( infile = fopen(argv[2], "rt")) == NULL)
 {
  perror("fopen");
  exit(1);
 }
 /* Create one way pipe line with call to popen() */
 if (( pipe_fp = popen(argv[1], "w")) == NULL)
 {
  perror("popen");
  exit(1);
 }
 /* Processing loop */
 do {
  fgets(readbuf, 80, infile);
  if(feof(infile)) break;
  fputs(readbuf, pipe_fp);
 } while(!feof(infile));
 fclose(infile);
 pclose(pipe_fp);
 return(0);
}

//fifoserver.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <linux/stat.h>
#define FIFO_FILE "MYFIFO"
int main(void)
{
 FILE *fp;
 char readbuf[80];
 /* Create the FIFO if it does not exist */
 umask(0);
 mknod(FIFO_FILE, S_IFIFO|0666, 0);
 while(1)
 {
  fp = fopen(FIFO_FILE, "r");
  fgets(readbuf, 80, fp);
  printf("Received string: %s\n", readbuf);
  fclose(fp);
 }
 return(0);
}

//fifoclient.c
#include <stdio.h>
#include <stdlib.h>
#define FIFO_FILE "MYFIFO"

int main(int argc, char *argv[])
{
 FILE *fp;
 if ( argc != 2 ) {
  printf("USAGE: fifoclient [string]\n");
  exit(1);
 }
 if((fp = fopen(FIFO_FILE, "w")) == NULL) {
  perror("fopen");
  exit(1);
 }
 fputs(argv[1], fp);
 fclose(fp);
 return(0);
}

//sharemem.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define SEGSIZE 100
main(int argc, char *argv[])
{
 key_t key;
 int shmid, cntr;
 char *segptr;
 if(argc == 1)
 usage();
 /* Create unique key via call to ftok() */
 key = ftok(".", ’S’);
 /* Open the shared memory segment - create if necessary */
 if((shmid = shmget(key, SEGSIZE, IPC_CREAT|IPC_EXCL|0666)) == -1)
 {
  printf("Shared memory segment exists - opening as client\n");
  /* Segment probably already exists - try as a client */
  if((shmid = shmget(key, SEGSIZE, 0)) == -1)
  {
   perror("shmget");
   exit(1);
  }
 }
 else
 {
  printf("Creating new shared memory segment\n");
 }
 /* Attach (map) the shared memory segment into the current process */
 if((segptr = shmat(shmid, 0, 0)) == -1)
 {
  perror("shmat");
  exit(1);
 }
 switch(tolower(argv[1][0]))
 {
  case ’w’: writeshm(shmid, segptr, argv[2]);
  break;
  case ’r’: readshm(shmid, segptr);
  break;
  case ’d’: removeshm(shmid);
  break;
  case ’m’: changemode(shmid, argv[2]);
  break;
  default: usage();
 }
}

writeshm(int shmid, char *segptr, char *text)
{
 strcpy(segptr, text);
 printf("Done...\n");
}

readshm(int shmid, char *segptr)
{
 printf("segptr: %s\n", segptr);
}

removeshm(int shmid)
{
 shmctl(shmid, IPC_RMID, 0);
 printf("Shared memory segment marked for deletion\n");
}

changemode(int shmid, char *mode)
{
 struct shmid_ds myshmds;
 /* Get current values for internal data structure */
 shmctl(shmid, IPC_STAT, &myshmds);
 /* Display old permissions */
 printf("Old permissions were: %o\n", myshmds.shm_perm.mode);
 /* Convert and load the mode */
 sscanf(mode, "%o", &myshmds.shm_perm.mode);
 /* Update the mode */
 shmctl(shmid, IPC_SET, &myshmds);
 printf("New permissions are : %o\n", myshmds.shm_perm.mode);
}

usage()
{
 fprintf(stderr, "shmtool - A utility for tinkering with shared memory\n");
 fprintf(stderr, "\nUSAGE: shmtool (w)rite <text>\n");
 fprintf(stderr, " (r)ead\n");
 fprintf(stderr, " (d)elete\n");
 fprintf(stderr, " (m)ode change <octal mode>\n");
 exit(1);
}

//semtool.c
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#define SEM_RESOURCE_MAX 1 /* Initial value of all semaphores */

//if sem.h already define following union, ignore it.
union semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */
ushort *array; /* array for GETALL & SETALL */
struct seminfo *__buf; /* buffer for IPC_INFO */
void *__pad;
};

void opensem(int *sid, key_t key);
void createsem(int *sid, key_t key, int members);
void locksem(int sid, int member);
void unlocksem(int sid, int member);
void removesem(int sid);
unsigned short get_member_count(int sid);
int getval(int sid, int member);
void dispval(int sid, int member);
void changemode(int sid, char *mode);
void usage(void);
int main(int argc, char *argv[])
{
 key_t key;
 int semset_id;
 if(argc == 1)
 usage();
 /* Create unique key via call to ftok() */
 key = ftok(".", ’s’);
 switch(tolower(argv[1][0]))
 {
  case ’c’: if(argc != 3)
   usage();
   createsem(&semset_id, key, atoi(argv[2]));
   break;
  case ’l’: if(argc != 3)
   usage();
   opensem(&semset_id, key);
   locksem(semset_id, atoi(argv[2]));
   break;
  case ’u’: if(argc != 3)
   usage();
   opensem(&semset_id, key);
   unlocksem(semset_id, atoi(argv[2]));
  break;
  case ’d’: opensem(&semset_id, key);
   removesem(semset_id);
   break;
  case ’m’: opensem(&semset_id, key);
   changemode(semset_id, argv[2]);
   break;
  default: usage();
 }
 return(0);
}

void opensem(int *sid, key_t key)
{
 /* Open the semaphore set - do not create! */
 if((*sid = semget(key, 0, 0666)) == -1)
 {
  printf("Semaphore set does not exist!\n");
  exit(1);
 }
}
void createsem(int *sid, key_t key, int members)
{
 int cntr;
 union semun semopts;
 if(members > SEMMSL) {
  printf("Sorry, max number of semaphores in a set is %d\n",SEMMSL);
  exit(1);
 }
 printf("Attempting to create new semaphore set with %d members\n",members);
 if((*sid = semget(key, members, IPC_CREAT|IPC_EXCL|0666))== -1)
 {
  fprintf(stderr, "Semaphore set already exists!\n");
  exit(1);
 }
 semopts.val = SEM_RESOURCE_MAX;
 /* Initialize all members (could be done with SETALL) */
 for(cntr=0; cntr<members; cntr++)
 semctl(*sid, cntr, SETVAL, semopts);
}

void locksem(int sid, int member)
{
 struct sembuf sem_lock={ 0, -1, IPC_NOWAIT};
 if( member<0 || member>(get_member_count(sid)-1))
 {
  fprintf(stderr, "semaphore member %d out of range\n", member);
  return;
 }
 /* Attempt to lock the semaphore set */
 if(!getval(sid, member))
 {
  fprintf(stderr, "Semaphore resources exhausted (no lock)!\n");
  exit(1);
 }
 sem_lock.sem_num = member;
 if((semop(sid, &sem_lock, 1)) == -1)
 {
  fprintf(stderr, "Lock failed\n");
  exit(1);
 }
 else
  printf("Semaphore resources decremented by one (locked)\n");
 dispval(sid, member);
}

void unlocksem(int sid, int member)
{
 struct sembuf sem_unlock={ member, 1, IPC_NOWAIT};
 int semval;
 if( member<0 || member>(get_member_count(sid)-1))
 {
  fprintf(stderr, "semaphore member %d out of range\n", member);
  return;
 }
 /* Is the semaphore set locked? */
 semval = getval(sid, member);
 if(semval == SEM_RESOURCE_MAX) {
  fprintf(stderr, "Semaphore not locked!\n");
  exit(1);
 }
 sem_unlock.sem_num = member;
 /* Attempt to lock the semaphore set */
 if((semop(sid, &sem_unlock, 1)) == -1)
 {
  fprintf(stderr, "Unlock failed\n");
  exit(1);
 }
 else
  printf("Semaphore resources incremented by one (unlocked)\n");
 dispval(sid, member);
}

void removesem(int sid)
{
 semctl(sid, 0, IPC_RMID, 0);
 printf("Semaphore removed\n");
}

unsigned short get_member_count(int sid)
{
 union semun semopts;
 struct semid_ds mysemds;
 semopts.buf = &mysemds;
 /* Return number of members in the semaphore set */
 return(semopts.buf->sem_nsems);
}

int getval(int sid, int member)
{
 int semval;
 semval = semctl(sid, member, GETVAL, 0);
 return(semval);
}
void changemode(int sid, char *mode)
{
 int rc;
 union semun semopts;
 struct semid_ds mysemds;
 /* Get current values for internal data structure */
 semopts.buf = &mysemds;
 rc = semctl(sid, 0, IPC_STAT, semopts);
 if (rc == -1) {
  perror("semctl");
  exit(1);
 }
 printf("Old permissions were %o\n", semopts.buf->sem_perm.mode);
 /* Change the permissions on the semaphore */
 sscanf(mode, "%ho", &semopts.buf->sem_perm.mode);
 /* Update the internal data structure */
 semctl(sid, 0, IPC_SET, semopts);
 printf("Updated...\n");
}

void dispval(int sid, int member)
{
 int semval;
 semval = semctl(sid, member, GETVAL, 0);
 printf("semval for member %d is %d\n", member, semval);
}

void usage(void)
{
 fprintf(stderr, "semtool - A utility for tinkering with semaphores\n");
 fprintf(stderr, "\nUSAGE: semtool4 (c)reate <semcount>\n");
 fprintf(stderr, " (l)ock <sem #>\n");
 fprintf(stderr, " (u)nlock <sem #>\n");
 fprintf(stderr, " (d)elete\n");
 fprintf(stderr, " (m)ode <mode>\n");
 exit(1);
}

//semstat.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
//if sem.h already define following union, ignore it.
union semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */
ushort *array; /* array for GETALL & SETALL */
struct seminfo *__buf; /* buffer for IPC_INFO */
void *__pad;
};
int get_sem_count(int sid);
void show_sem_usage(int sid);
int get_sem_count(int sid);
void dispval(int sid);
int main(int argc, char *argv[])
{
 key_t key;
 int semset_id;
 /* Create unique key via call to ftok() */
 key = ftok(".", ’s’);
 /* Open the semaphore set - do not create! */
 if((semset_id = semget(key, 1, 0666)) == -1)
 {
  printf("Semaphore set does not exist\n");
  exit(1);
 }
 show_sem_usage(semset_id);
 return(0);
}

void show_sem_usage(int sid)
{
 int cntr=0, maxsems, semval;
 maxsems = get_sem_count(sid);
 while(cntr < maxsems) {
  semval = semctl(sid, cntr, GETVAL, 0);
  printf("Semaphore #%d: --> %d\n", cntr, semval);
  cntr++;
 }
}

int get_sem_count(int sid)
{
 int rc;
 struct semid_ds mysemds;
 union semun semopts;
 /* Get current values for internal data structure */
 semopts.buf = &mysemds;
 if((rc = semctl(sid, 0, IPC_STAT, semopts)) == -1) {
  perror("semctl");
  exit(1);
 }
 /* return number of semaphores in set */
 return(semopts.buf->sem_nsems);
}

void dispval(int sid)
{
 int semval;
 semval = semctl(sid, 0, GETVAL, 0);
 printf("semval is %d\n", semval);
}

//msgtool.c
#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 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);
}