Linux Internals and TCP/IP Networking- Sample Programs

/*------------------------------------------------------------------------------ 
 *
 *   Author         : Emertxe (http://www.emertxe.com) 
 *   Date           : Tue 01 Mar 2016 16:18:10 IST
 *   File           : li_t014_ch4_ipc_fifo_receiver.c
 *   Title          : IPC mechanism - Usage of FIFO (Named pipe) - Receiver
 *   Description    : IPC mechanisms provide various ways and means to share 
 *                    information between multiple processes. FIFO is one of the 
 *                    simplest and effective way to establish IPC. Here is an
 *                    example of FIFO (receiver).
 *
 *----------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>

#define FIFO_NAME "/tmp/myfifo"
#define MAX_STRING_LEN 80

int main()
{
	int fd, pp;

	fd = open(FIFO_NAME, O_RDONLY);
	if (fd < 0)
	{
		perror("Open");
		exit(1);
	}
	else
	{
		/* As a unrelated process read from the FIFO and print */
		read(fd,&pp,sizeof(pp));
		printf("FIFO message received: %dn",pp);
		read(fd,&pp,sizeof(pp));
		printf("FIFO message received: %dn",pp);
		close(fd);
		exit(0);
	}
}

/*------------------------------------------------------------------------------ 
 *
 *   Author         : Emertxe (http://www.emertxe.com) 
 *   Date           : Tue 01 Mar 2016 16:18:10 IST
 *   File           : li_t014_ch4_ipc_fifo_sender.c
 *   Title          : IPC mechanism - Usage of FIFO (Named pipe) - Sender 
 *   Description    : IPC mechanisms provide various ways and means to share 
 *                    information between multiple processes. FIFO is one of the 
 *                    simplest and effective way to establish IPC. Here is an
 *                    example of FIFO (sender).
 *
 *----------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>

#define FIFO_NAME "/tmp/myfifo"
#define MAX_STRING_LEN 80

int main()
{
	int fd, pp;

	/* Create a pipe */
	mknod(FIFO_NAME,0666,0);

	/* TODO: After opening, check the type by doing ls -al,re-iterate VFS */

	fd = open(FIFO_NAME, O_WRONLY);
	if (fd < 0)
	{
		perror("Open");
		exit(1);
	}
	else
	{
		/* Send some hard coded value between two processes who are not related */
		pp = 100;
		write(fd,&pp,sizeof(pp));
		pp = 200;
		write(fd,&pp,sizeof(pp));
		printf("Value sent to FIFOn");
		close(fd);
		exit(0);
	}
}

/*------------------------------------------------------------------------------ 
 *
 *   Author         : Emertxe (http://www.emertxe.com) 
 *   Date           : Tue 01 Mar 2016 16:18:10 IST
 *   File           : li_t015_ch4_ipc_shared_memory_reader.c
 *   Title          : IPC mechanism - Usage of Shared memory - Reader 
 *   Description    : IPC mechanisms provide various ways and means to share 
 *                    information between multiple processes. Shared memory 
 *                    offers best performance in terms of speed as it avoids 
 *                    copying data un-necessarily. Here is an example of shared 
 *                    memory (reader) program that reads data. 
 *
 *----------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define SMSIZE 100

int main()
{
    int shmid;
    key_t key;
    int *shm;

    /* Use the same key as in writer */
 	key = 'B';

    /* Get the shared memory, creation is already done */
	shmid = shmget(key,SMSIZE, 0666);

    if (shmid < 0)
    {
    	perror("shmget");
    	exit(1);
    }

	/* Attach to shared memory */
    shm = shmat(shmid,NULL,0);
    if (shm < 0)
    {
    	perror("shmat");
    	exit(0);
    }
    else
    {
		/* Read the value from shared memory and print */
		printf("Value from shared memory: %dn",*shm);
	}
	
	/*
	 * TODO: 1. Detach & remove the shared memory. Confirm deletion by executing ipcs
	 *       2. Extend this program for assignment in order to exhange string
	 */
}

/*------------------------------------------------------------------------------ 
 *
 *   Author         : Emertxe (http://www.emertxe.com) 
 *   Date           : Tue 01 Mar 2016 16:18:10 IST
 *   File           : li_t015_ch4_ipc_shared_memory_writer.c
 *   Title          : IPC mechanism - Usage of Shared memory - Writer
 *   Description    : IPC mechanisms provide various ways and means to share 
 *                    information between multiple processes. Shared memory 
 *                    offers best performance in terms of speed as it avoids 
 *                    copying data un-necessarily. Here is an example of shared 
 *                    memory (writer) program that writes the data. 
 *
 *----------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

/* Define the shared memory size */
#define SMSIZE 100

int main()
{
    int shmid,num;
    int *shm;
    key_t key;

	/* Key can be hardcoded, but use the same in reader & writer */
    key = 'B';


    /* Create a shared memory */
	shmid = shmget(key,SMSIZE,IPC_CREAT | 0666);

    if (shmid < 0)
    {
    	perror("shmget");
    	exit(1);
    }
    else
	{
    	shm = shmat(shmid,NULL,0);
      /*
       * TODO: 1. Execute 'ipcs' command and verify shared memory is created 
       *       2. Take the value from the user which you want to write into shared memory 
       *       3. Perform Shared memory detach by reading the man pages 
      */
    	printf("Enter the numbern");
    	scanf("%d",&num);
     /* This is the reason why shared memory is the fastest form of IPC.
      * You are manipulating the shared memory as if it is a local pointer.
      * This avoids un-necessary copy with Kernel 
    */
		*shm = num;
	}
}

/*------------------------------------------------------------------------------ 
 *
 *   Author         : Emertxe (http://www.emertxe.com) 
 *   Date           : Tue 01 Mar 2016 16:18:10 IST
 *   File           : li_t016_ch4_ipc_signal_handling.c
 *   Title          : IPC mechanism - Usage of Signals - Simple usage 
 *   Description    : IPC mechanisms provide various ways and means to share 
 *                    information between multiple processes. Signals are used 
 *                    mainly intimate about events in the system and handle them
 *                    appropriately. This is a simple usage of signal() system
 *                    call for capturing signals via call-back function.
 *
 *----------------------------------------------------------------------------*/
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void my_signal_handler1(int signo); 
void my_signal_handler2(int signo); 

int main() 
{
	int mypid;

	/* Registering for SIGUSR1 & SIGUSR2 */

	/* Here my_signal_handler1 & my_signal_handler2 are callback functions */
	if(signal(SIGUSR1,my_signal_handler1) == SIG_ERR)
		printf("Cannot catch this signal-1n");
	if(signal(SIGUSR2,my_signal_handler2) == SIG_ERR)
		printf("Cannot catch this signal-2n");

	
	/* Now wait in a synchronous loop for the signals to arrive */
	while(1)
	{
		printf("Awaiting for signals. My PID is: %dn",getpid());
		sleep(2);
	}

	/*
	 * TODO: 1. Replace the synchronous while(1) loop with pause() 
	 *		 2. Use of raise() and creating self signals
	 */

	printf("Signal handled, I am exitingn");
}
	
/* Signal handler - Asynchronous handling & callback function */
void my_signal_handler1(int signo)
{
	/* These functions are called in the context of the Kernel. So minimal handling */
	if (signo == SIGUSR1)  
		printf("Received SIGUSR1n");
	else	    	
		printf("Error:Sorry, wrong signaln");
}

void my_signal_handler2(int signo)
{
	/* These functions are called in the context of the Kernel. So minimal handling */
	if (signo == SIGUSR2)  
		printf("Received SIGUSR2n");
	else	    	
		printf("Error:Sorry, wrong signaln");
}

/*------------------------------------------------------------------------------ 
 *
 *   Author         : Emertxe (http://www.emertxe.com) 
 *   Date           : Tue 01 Mar 2016 16:18:10 IST
 *   File           : li_t017_ch4_ipc_signal_alarm.c
 *   Title          : IPC mechanism - Usage of signals - Alarms usage 
 *   Description    : IPC mechanisms provide various ways and means to share 
 *                    information between multiple processes. Signals can be 
 *                    sent to the process itself, alarm() is one of them. This
 *                    example demonstrates alarm() usage and how it works. 
 *
 *----------------------------------------------------------------------------*/
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>

int main()
{

	/* Raise the ALARM, after 5 seconds */
	printf("Calling ALARM for 5 seconds, YOUR handlern");
	alarm(5);

	/* This loop is required for me to handle when the alarm happens */
	while (1);

	/* After alarm the process will terminate */
	printf("ALARM over...let me wake up nown");

	return 0;
}

/*------------------------------------------------------------------------------ 
 *
 *   Author         : Emertxe (https://www.emertxe.com) 
 *   Date           : Tue 01 Mar 2016 16:18:10 IST
 *   File           : li_t018_ch4_ipc_signal_advaned_handling.c
 *   Title          : IPC mechanism - Usage of Signals - Advanced handling 
 *   Description    : Apart from handling signals after they occur, the default
 *                    handling mechanism can be changed by using sigaction(). 
 *                    This example demonstrates the same for alarm() signal.
 *
 *----------------------------------------------------------------------------*/
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>

struct sigaction new_act, old_act;

void alarm_handler(int not_using)
{
	printf("Alarm occured, inside my handlern");
}

int main()
{

	/* Whenever ALARM comes call my handler, callback function */
	new_act.sa_sigaction = alarm_handler;
	sigaction(SIGALRM, &new_act,NULL);

	/* Raise the ALARM, after 5 seconds */
	printf("Calling ALARM for 5 seconds, YOUR handlern");
	alarm(5);

	/* Lets sleep 1 sec more than the set alarm time to keep the process alive */
	sleep(6); 

	printf("ALARM triggered .. Lets continuen");

	return 0;
}

/*------------------------------------------------------------------------------ 
 *
 *   Author         : Emertxe (https://www.emertxe.com) 
 *   Date           : Tue 01 Mar 2016 16:18:10 IST
 *   File           : li_t019_ch4_ipc_signal_advaned_handling.c
 *   Title          : IPC mechanism - Usage of Signals - Advanced handling 
 *   Description    : Apart from handling signals after they occur, the default
 *                    handling mechanism can be changed by using sigaction(). 
 *                    This example demonstrates the same for SEGV signal.
 *
 *----------------------------------------------------------------------------*/
#include <stdio.h>
#include <unistd.h>
#include <sys/signal.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>

void handler(int signum, siginfo_t *info, void *dummy)
{
	printf("Signal recieved with %dn", signum);
	printf("Signal send from %dn", info->si_pid);
}


int main()
{
	struct sigaction act, oldact;

	memset(&act, 0, sizeof(act));
	act.sa_sigaction = handler;
	act.sa_flags = SA_SIGINFO;
	sigaction(SIGSEGV, &act, &oldact);

	pause();
	return 0;
}