suppose

    fun(type var1,type var2,...)

is a function, then larg corresponds to var2

Now we need to declare the list using va_list
i.e.,

    va_list al

now initialize it using va_start

    va_start(al,larg);

Now to access each argument, we must know the expected type of the argument

     type var_name = va_arg(al,type);

When we have accessed all the variable arguments, we need to clean up

     va_end(al);

Using standard library, we can easily access the variable arguments

Take a simple example

#include <stdarg.h>
int print(int num_count,...)
/*num_count contains the number of integers passed*/
{
  int i;
  va_list al;
  va_start(al,num_count);
  for(i=1;i<=num_count;i++){
     int val=va_arg(al,int);
     printf("%d ",val);
  }

}

int print_str(const char *str,...)
/*str has the number of strings passed*/
{
  int i;
  va_list al;
  int num_count=atoi(str);
  va_start(al,str);
  int *num=&num_count;
  for(i=1;i<=num_count;i++){
     char *str=va_arg(al,char *);
     printf("%s ",str);
  }

}

int main()
{
   print(3,2,3,4);
   print_str("3","Hi","All","!!!");
}

OUTPUT

2 3 4 Hi All !!!

For more updates, check Programming Insights.

#include <stdio.h>

/*A program to see how diffent data types can be printed using printf
*See the conversion characters with % for the various data types
*/
int main()
{
    //Character strings
   char *message="Printing different data types";
   wchar_t *wmessage=L"Wide Character string";

   //Characters
   char ca='A';
   wchar_t wca=L'A';

   //Integer Data types
   unsigned short usa=65535; short ssb=-32768;
   unsigned int usi=4294967295; int ssi=-2147483648;
   unsigned long long int ulli=4294967295L;long long int lli=-2147483647L;

   //Floating point Data types
   float fa=1e+37,fb=1e-37;
   double da=1e+37,db=1e-37;
   long double lda=1e+37L,ldb=1e-37L;

   //Pointers
   int *p=&ssi;

   //Character strings
   printf("%s\n",message);
   printf("%ls\n\n",wmessage);

   //Character strings
   printf("%c\n",ca);
   printf("%lc\n\n",wca);

   printf("%hu %hi\n",usa,ssb); //short
   printf("%hx %hx\n\n",usa,ssb);

   printf("%u %i\n",usi,ssi); //integer/long integers
   printf("%x %x\n\n",usi,ssi);

   printf("%llu %lli\n",ulli,lli); //long long integers
   printf("%llx %llx\n\n",ulli,lli);

   printf("%f %f\n",fa,fb); //float

   printf("%f %f\n",da,db); //double
   printf("%e %e\n\n",da,db);

   printf("%llf %llf\n",lda,ldb); //long double
   printf("%lle %lle\n\n",lda,ldb);

   printf("%p\n\n",p); //pointer of any data type

}

Here’s the output

For more updates, check Programming Insights.

Let me show some aspects of #define
The general syntax of #define

    #define identifier(identifier,..., indentifier) token_sequence

1. It is not necessary that all the identifiers used in token sequence is already defined

#define A B+20
#define B 10

As you can see that B was not defined when A is being defined. So the only condition is that we need to define it somewhere.

2. Using gcc, you can define macros and decide the course of your programming. For example, if I wish to perform debugging. I will define __DEBUG__ through gcc.To define macros using gcc, compile using the D option of gcc

gcc -Dmacro[=defn]...]

The following code snippet depicts this

#include <stdio.h>

/*This program shows how to make the use of #define to define the course

*of programming

*/

#define A B+20 /B is not defined here, but will be defined later/

#define B 10

int main()

{

#ifdef __DEBUG__
    printf("__DEBUG__ DEFINED\n");

    printf("%d\n",A);

#else

   printf("__DEBUG__ not defined\n");

   printf("%d\n",B);

#endif

return 0;
}

If I compile

$gcc test.c

Output:

__DEBUG__ not defined

10

If I compile

$gcc -D __DEBUG__ test.c

Output:

__DEBUG__ defined

30

Thus we can see how the C Preprocessors also help in deciding the course of action of a program. The above is also called Conditional Compilation

For more updates, check Programming Insights.

For more updates, check Programming Insights.

    int fun2(int a, int b)

    fun2(2,3,4)

    int printf(const char *str,...)

int print(const char *str,...)

/*str has the number of integers passed*/

{

        int i;

        int num_count=atoi(str);

        int *num=(int *)&str;

        for(i=1;i<=num_count;i++)

                printf("%d ",*(num+i));}

int print_num(int num_count,...)

/*num_count contains the number of integers passed*/

{

        int i;

        int *num=&num_count;

        for(i=1;i<=num_count;i++)

                printf("%d ",*(num+i));

}

int main()

{

        print_num(3,2,3,4);

        print("3",2,3,4);

}

For more updates, check Programming Insights.

There is one more way by which we can initialize structures. These way utilizes the benefits of both the ways of structure initialization described here. That is we are able to initialize the elements of the structure using the set notation and also we need not remember the order of the elements of the structure.
Suppose consider the structure ‘student‘ we already used

struct student {

     int roll;

     int class;

     char name[50];

};

Now let’s declare a variable st3 and initialize using the third method

student st3={

           .name = "Mark", //Notice the equal to and the comma

           .class  = 10,

           .roll  = 1038

};

As you can see the way by which the variable st3 has been initialized. It has used the set notation and also see the order is not the same as in the case of the structure ‘student‘

The following program demonstrates this. Note the different ways by which the array of structures has been initialized

/*

*Different Ways of structure initialization

*/#include < stdio.h>

#include < string.h>

#define NAME_LEN 25

typedef unsigned short age_t;

typedef unsigned int roll_t;

typedef struct student{

    char name[NAME_LEN];

    roll_t rno;

    age_t age;

}student;

int main()

{

/* Method 3a: Just like the Method 2a, but here you do not

* need to know order of the elements in the declaration

*/

student st3={

.name = "Mark",//Notice the equal to and comma

.age  = 23,
.rno  = 1038
};

printf("%s %hi %u\n\n",st3.name,st3.age,st3.rno);

/*

* Method 3b: For Initializing an array of structures

*/

student st4[]={
{

.name = "Neil",

.age  = 23,

.rno  = 1039      },

{

.name = "Peter",

.age  = 23,

.rno  = 1040

}
};

printf("%s %hi %u\n%s %hi %u\n\n",st4[0].name,st4[0].age,

st4[0].rno, st4[1].name,st4[1].age,st4[1].rno);

/*

* Method 3c : Change the order of initialization of the

* elements of the array. Normally as seen in Method 2b,

* the 0th array element is initialized  then 1st, then

* 2nd and so on. So by using a variation  of Method 3b,

* we  can initialize the array elements in any order

*/

student st5[5]={

  [3]={

              .name = "Titus",

              .age  = 22,

              .rno  = 1041      },

[2]={

              .name = "Stephen",

              .age  = 23,

              .rno  = 1042

      }

      /*As you can see only 2nd and 3rd array elements has

       * been initialized and that too not in order. Such

       * an initialization is useful, if we wish to allocate

       * some fixed size array but only initialize some element

       */
};

printf("%s %hi %u\n%s %hi %u\n\n",st5[2].name,st5[2].age,

st5[2].rno, st5[3].name,st5[3].age,st5[3].rno);

}

There are several ways by which a structure can be initialized. In the first way, we first declare the structure variable and initialize the fields of the structure with its name along with the variable name.
i.e., Suppose consider a structure ‘student‘

structure student {

   int roll;

   int class;

   char name[25];

};

Now we declare variable for the structure student st1
Now to initialize this variable, we access the elements of the structure using the variable
i.e.,

      st1.roll  = 21;

      strncpy (st1.name, "Albert", 10);

There can be case in which we do not initialize some elements of the structure, like in the above case, we did not initialize the element class for the variable st1. This can be considered as a big disadvantage. Because we may forget initializing some fields.

In the second way, we initialize the structure elements using the set notation.
like the variable st2 can be initialized as

     struct student st2 = {22, 10, "Alan"};

Unlike the first way, where we can initialize the elements of the structure in any order, here we must remember the order of the elements in the structure. But chances of not initializing a particular element is very less.

The following program demonstrates these two ways of structure initialization. Also check the way an array of structures is initialized.

/*Different Ways of structure initialization*/#include <stdio.h>

#include <string.h>

#define NAME_LEN 25

typedef unsigned short age_t;

typedef unsigned int roll_t;

typedef struct student{

char name[NAME_LEN];

roll_t rno;

age_t age;

}student;

int main()

{

/*

* Method 1a:Commonly seen initialization of a structure
*/student st;strcpy(st.name,"Albert");

st.age=23;

st.rno=1034;

printf("%s %hi %u\n\n",st.name,st.age,st.rno);

/*

* Method 1b: For initialing an array of structures

*Commonly seen initialization of a structure

*/
   student st1 [2];strcpy(st1[0].name,"Albert");st1[0].age=23;

st1[0].rno=1034;

strcpy(st1[1].name,"Alvin");

st1[1].age=24;

st1[1].rno=1035;

printf("%s %hi %u\n%s %hi %u\n\n",st1[0].name,st1[0].age,

st1[0].rno,st1[1].name,st1[1].age,st1[1].rno);

/*

* Method 2a:Initializing like a set, the only requirement is

* that the order by which these elements are entered

* should be as in the declaration

*/
 student st2={"Alvin",1035,22};printf("%s %hi %u\n\n",st2.name,st2.age,st2.rno);

/*

* Method 2b: For Initializing an array of structures

*/
   student st2b[2]={                 {"Alan",1036,23},         {"Eric",1037,22}};

printf("%s %hi %u\n%s %hi %u\n\n",st2b[0].name,st2b[0].age,

st2b[0].rno, st2b[1].name,st2b[1].age,st2b[1].rno);

}

For more updates, check Programming Insights.

Creating a FIFO

1. mknod

Syntax

int mknod(const char *pathname, mode_t mode, dev_t dev);

where pathname corresponds to the fifo name, mode corresponds to the file permissions. Since mknod can be used to create a regular file, block or charcter special files and fifo. We have to specify the file type. Corresponding to FIFO: the file type is S_IFIFO.

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[]){
     int result;
     if (argc != 2) {
             fprintf(stderr, "Usage: ./a.out fifoname\n");
             exit (1);
     }

     result = mknod (argv[1], S_IRUSR| S_IWUSR|S_IFIFO, 0);
     if (result < 0) {
          perror ("mknod");
          exit (2);
       }
  }

Here we wish to give both read and write permissions to the user. So we specified S_IRUSR | S_IWUSR| S_IFIFO in the mode. If the file type is S_IFCHR or S_IFBLK then dev is checked; otherwise it is ignored. So we passed 0 as the argument.

2. mkfifo

Syntax

int mkfifo(const char *pathname, mode_t mode);

where pathname correspnds to fifo name and mode corresponds to file mode.

 # include <stdio.h>
 # include <stdlib.h>
 # include <sys/types.h>
 # include <sys/stat.h>

int main(int argc, char *argv[]){
     int result;

     if (argc != 2) {
          fprintf(stderr, "Usage: ./a.out fifoname\n");
          exit (1);
     }

    result = mkfifo (argv[1], S_IRUSR| S_IWUSR);
     if (result < 0) {
          perror ("mkfifo");
          exit (2);
      }
  }

Here we need not explicitly specify the file type S_IFIFO. You can (if you wish) specify S_IFIFO in the mode.

Also refer the Use of Constants in C Programming

For more updates, check Programming Insights.

A sample program to demonstrate how pipes are used in Linux Processes

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#define MSGLEN  64

int main(){
    int     fd[2];
    pid_t pid;
    int     result;

    //Creating a pipe
    result = pipe (fd);
    if (result < 0) {
        //failure in creating a pipe
        perror("pipe");
        exit (1);
    }

    //Creating a child process
    pid = fork();
    if (pid < 0) {
         //failure in creating a child
         perror ("fork");
         exit(2);
    }

    if (pid == 0) {
        //Child process
         char message[MSGLEN];

          while(1) {
                    //Clearing the message
                    memset (message, 0, sizeof(message));
                    printf ("Enter a message: ");
                    scanf ("%s",message);

                    //Writing message to the pipe
                    write(fd[1], message, strlen(message));
            }
            exit (0);
    }
    else {
        //Parent Process
         char message[MSGLEN];

         while (1) {
                    //Clearing the message buffer
                    memset (message, 0, sizeof(message));

                    //Reading message from the pipe
                   read (fd[0], message, sizeof(message));
                    printf("Message entered %s\n",message);
            }

            exit(0);
     }
}

Note here that the pipe() system call was called before the system call fork(). The buffer allocated to the pipe is accessible to both the processes.

For more updates, check Programming Insights.

mkfifo

creates fifo- the named pipes

Syntax

mkfifo [options] fifo_name

Example

$ mkfifo fifo

There is one more way by which we can FIFO using mknod. mknod is used to create block or character special files.

$ mknod [OPTION]... NAME TYPE

To create a FIFO fifo1

$ mknod fifo1 p

where p coressponds to file type : pipe (remember FIFO is a named pipe).

Reading/ Writing data from/to a FIFO
Let’s open two terminals
In the first terminal

$ cat > fifo

we are experimenting with the FIFOThis is second line. After opening the fifo in the second terminal for readingusing cat, you will notice the above two lines displayed there.
Now open the second terminal and go to the directory containing the FIFO ‘fifo’

$ cat fifo

we are experimenting with the FIFOThis is second line. After opening the fifo in the second terminal for reading
Now keep on writing to the first terminal. You will notice that every time you press enter, the coressponding line appears in the second terminal.

Pressing CTRL+D in the first terminal terminates writing to the fifo. This also terminates the second process because reading from the fifo now generates a “BROKEN PIPE” signal. The default action for this is to terminate the process.

Let us now see the details of the file ‘fifo’

$ ls -l fifo
prw-r--r-- 1 user user 0 Feb 14 10:05 fifo

The p in the beginning denotes that it is a pipe.

Let’s see more details about the pipe using stat

$ stat fifo
File: `fifo'Size: 0               Blocks: 0          IO Block: 4096   fifo
Device: fd00h/64768d    Inode: 1145493     Links: 1
Access: (0644/prw-r--r--)  Uid: (    0/    user)   Gid: (    0/    user)
Access: 2008-02-14 10:05:49.000000000 +0530
Modify: 2008-02-14 10:05:49.000000000 +0530
Change: 2008-02-14 10:05:49.000000000 +0530

If you notice carefully, FIFOs just like a normal file possess all the details like inode number, the number of links to it, the access, modification times, size and the access permissions.

As in the case of pipes, there can be multiple readers and writers to a pipe. Try opening multiple terminals to read from and write to a pipe.

For more updates, check Programming Insights.
]]> http://linuxprograms.wordpress.com/2008/02/14/fifo-named-pipes-mkfifo-mknod/feed/ 3 johnsamuel http://linuxprograms.wordpress.com/2008/01/24/operations-on-pipe-advanced-pipe-usage/ http://linuxprograms.wordpress.com/2008/01/24/operations-on-pipe-advanced-pipe-usage/#comments Thu, 24 Jan 2008 12:05:00 +0000 John Samuel http://linuxprograms.wordpress.com/2008/01/24/operations-on-pipe-advanced-pipe-usage/ ]]> we discussed how we can work with pipe() system call, where it is used(Linux shell), how to use pipes in threads(processes).

Here we can discuss on the topic ‘Number of readers and writers accessing a pipe’
A pipe can have more than one reader and more than one writer. Only one thing that must be kept in mind is that writer writes into fd[1] and reader reads from fd[0], where fd is the filedescriptor passed for the pipe() call.

int pipe(int fd[2]);

The program below demonstrates this with two writers and one reader. The writer Writer_ABC writes the capital Alphabet and the Writer_abc writes the small alphabet into the pipe. The reader reads in the order of the letters written by the two writers

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>

int fd[2];//File descriptor for creating a pipe

//This function continously reads fd[0] for any input data byte
//If available, prints

void *reader()
{
    while(1){
       char    ch;
       int     result;

       result = read (fd[0],&ch,1);
       if (result != 1) {
            perror("read");
            exit(3);
    }    printf ("Reader: %c\n", ch);  }
}

//This function continously writes Capital Alphabet into fd[1]
//Waits if no more space is available

void *writer_ABC()
{
     int     result;
     char    ch='A';

     while(1){
           result = write (fd[1], &ch,1);
           if (result != 1){
               perror ("write");
               exit (2);
           }

           printf ("Writer_ABC: %c\n", ch);
           if(ch == 'Z')
              ch = 'A'-1;

           ch++;
      }
}

//This function continously writes small Alphabet into fd[1]
//Waits if no more space is available

void *writer_abc()
{
  int     result;  char    ch='a';

  while(1){
      result = write (fd[1], &ch,1);
      if (result != 1){
            perror ("write");
            exit (2);
      }

      printf ("Writer_abc: %c\n", ch);
      if(ch == 'z')
            ch = 'a'-1;

     ch++;
  }
}

int main()
{
   pthread_t       tid1,tid2,tid3;
   int             result;

   result = pipe (fd);
   if (result < 0){
       perror("pipe ");
       exit(1);
   }

 pthread_create(&tid1,NULL,reader,NULL);
 pthread_create(&tid2,NULL,writer_ABC,NULL);
 pthread_create(&tid3,NULL,writer_abc,NULL);

 pthread_join(tid1,NULL);
 pthread_join(tid2,NULL);
 pthread_join(tid3,NULL);
}

Output

Writer_abc: o
Writer_abc: p
Writer_abc: q
Writer_abc: r
Writer_abc: s
Writer_abc: t
Writer_abc: u
Reader: A
Reader: B
Reader: C
Reader: D
Reader: E
Reader: F
Reader: G
Reader: H
Reader: I
Reader: J
Reader: K
Reader: L
Reader: M
Reader: N
...
For more updates, check Programming Insights.