/* Ajith - Syntax Higlighter - End ----------------------------------------------- */

## 9.22.2009

### Signals in Linux - Catching and Ignoring Signals - sigaction

The sigaction system call has the same basic effect as signal system call: to specify how a signal should be handled by the process.

But sigaction offers more control over the signal mechanism, at the expense of more complexity. In particular, sigaction allows you to specify additional flags to control when the signal is generated and how the handler is invoked.

Hence for reference we can say that sigaction is more like opensource Linux OS flavours more options, more control and complex for normal users than the proprietary stuff.
#include <signal.h>

int sigaction(int signum, const struct sigaction *action,struct sigaction *oldaction);

signum specifies the signal and can be any valid signal except SIGKILL and SIGSTOP.

The action argument is used to set up a new action for the signal signum, while the oldaction argument is used to return information about the action previously associated with this symbol. If action is non-null, the new action for signal signum is installed from action. If oldaction is non-null, the previous action is saved in oldaction.

struct sigaction { void     (*sa_handler)(int);   /*SIG_DFL, SIG_IGN, or                                a function pointer*/ void     (*sa_sigaction)(int, siginfo_t *, void *); sigset_t   sa_mask; int        sa_flags; void     (*sa_restorer)(void);};
Portability Note: The basic signal function is a feature of ISO C, while sigaction is part of the POSIX.1 standard. If you are concerned about portability to non-POSIX systems, then you should use the signal function instead.

## 9.08.2009

### Reading a string of length 'n' from Standard Input [STDIN]

We know how to read a string from STDIN in C by using library functions like scanf, fgets and so on. By using these functions there is a chance for memory corruption and strange behaviour. For example while using scanf if we try to save a string of length more than the variable size there is a chance of memory corruption.

So here in this post I am just trying to implement a function capable to read a string of length 'n' from STDIN without memory corruption and other bugs.

Do help me by checking the code if there is a chance for further improvements.
#include <stdio.h>#include <string.h>#define BUF_SIZE 6#define STRING_SIZE 4/* * void getStringStdin(char *, int , int ); * * 1: BUF        :Pointer to the array of characters where input string is to be stored. * 2: BUF_LEN    :Is the length of the array of characters where the string is stored.buffer where we save the string. * 3: STRING_LEN :Is the length of the string. * * NOTE: STRING_LEN < BUF_LEN **/getStringStdin(char *buf, int buf_len, int str_len){  int ch, len;  char *s;  if(str_len>=buf_len)  len=buf_len-1;  else  len=str_len;  printf ("\nEnter string of length %d(Remaining is ignored): ",len);  if( (fgets(buf, len+1, stdin)) != NULL )  {    s=my_strchr(buf,'\n');    if(s!=NULL)    {      *s='\0';    }    else    {       while ((ch = getchar()) != '\n' && ch != EOF);    }  }}int main(void){  int i=0;  char buf[BUF_SIZE];  do  {    getString(buf, BUF_SIZE, STRING_SIZE);    printf ("\nString : %s\n", buf);    i++;  }while(i<2);  return 0;}

### How to: Listing all users in a Linux machine

TO list all the users who can access a Linux machine we have to access the /etc/passwd file, which stores information about all registered users of that machine. But it is not really so easy as told above since the file contains many other fields & machine trust accounts & inbuilt accounts.

We'll start by
cat /etc/passwd

As we all know that by default all the users created will have their home directories in /home share so we'll modify our command a bit by using grep. Now it'll be
cat /etc/passwd | grep "/home"

Now we'll get all the user accounts which have their home share in /home.But the only output we need is the list of users & nothing else. So we'll modify our command again
cat /etc/passwd | grep "/home" |cut -d: -f1
Now what we have done is that we have piped the output of previous command to another variable "cut"

What we have done here is we have added cut -d: -f1
-d: means delimiter :
-f1 means display first field of line i.e. username.

So final command is
cat /etc/passwd | grep "/home" |cut -d: -f1
This works until all your users have their home share in /home. If you have defined their home share to some other destination. Modify the above command accordingly.

## 9.02.2009

### Signals in Linux - Generating Signals

Besides signals that are generated as a result of a hardware trap or interrupt, your program can explicitly send signals to itself or to another process.

The kill system call can be used to send any signal to any process group or process.
#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);

#include <signal.h>#include <stdio.h>#include <stdlib.h>static volatile sig_atomic_t doneflag = 10;static void setdoneflag(int signo) {    printf("\nIn SignalHandler - setdoneflag\n");    doneflag=0;}int main (void) {    signal(SIGINT, setdoneflag);    while(doneflag--)    {        printf("In While loop - %d\n",doneflag);        if(doneflag==5)        raise(2);        else        sleep(1);    }    printf("Program terminating ...\n");    return 0;}