When a process calls fork, it is deemed the parent process, and the newly created process, its child. After the fork, both processes not only run the same program, but they resume execution as though both had called the system call. They can then inspect the call’s return value to determine their status, child or parent, and act accordingly.
Communication
The child process inherits the standard streams from its parent, along with the rest of the environment. For interprocess communication, the parent process will often create a pipe or several pipes, and then after forking the processes will close the ends of the pipes that they don’t need.

A FIFO special file is similar to a pipe, but instead of being an anonymous, temporary connection, a FIFO has a name or names like any other file. Processes open the FIFO by name in order to communicate through it.

A pipe or FIFO has to be open at both ends simultaneously. If you read from a pipe or FIFO file that doesn’t have any processes writing to it (perhaps because they have all closed the file, or exited), the read returns end-of-file. Writing to a pipe or FIFO that doesn’t have a reading process is treated as an error condition; it generates a SIGPIPE signal, and fails with error code EPIPE if the signal is handled or blocked.

Neither pipes nor FIFO special files allow file positioning. Both reading and writing operations happen sequentially; reading from the beginning of the file and writing at the end.

Creating a Pipe

The primitive for creating a pipe is the pipe function. This creates both the reading and writing ends of the pipe. It is not very useful for a single process to use a pipe to talk to itself. In typical use, a process creates a pipe just before it forks one or more child processes. The pipe is then used for communication either between the parent or child processes, or between two sibling processes.

The pipe function is declared in the header file `unistd.h’.Function: int pipe (int filedes[2])

The pipe function creates a pipe and puts the file descriptors for the reading and writing ends of the pipe (respectively) into filedes[0] and filedes[1].

An easy way to remember that the input end comes first is that file descriptor 0 is standard input, and file descriptor 1 is standard output.

If successful, pipe returns a value of 0. On failure, -1 is returned.

For C File I/O you need to use a FILE pointer, which will let the program keep track of the file being accessed. (You can think of it as the memory address of the file or the location of the file).

For example:
FILE *fp;

fopen

To open a file you need to use the fopen function, which returns a FILE pointer. Once you’ve opened a file, you can use the FILE pointer to let the compiler perform input and output functions on the file.
FILE *fopen(const char *filename, const char *mode);
In the filename, if you use a string literal as the argument, you need to remember to use double backslashes rather than a single backslash as you otherwise risk an escape character such as \t. Using double backslashes \\ escapes the \ key, so the string works as it is expected.

fopen modes

The allowed modes for fopen are as follows:
r – open for reading
w – open for writing (file need not exist)
a – open for appending (file need not exist)
r+ – open for reading and writing, start at beginning
w+ – open for reading and writing (overwrite file)
a+ – open for reading and writing (append if file exists)
Note that it’s possible for fopen to fail even if your program is perfectly correct: you might try to open a file specified by the user, and that file might not exist (or it might be write-protected). In those cases, fopen will return 0, the NULL pointer.

Here’s a simple example of using fopen:

FILE *fp;
fp=fopen(“c:\\test.txt”, “r”);
This code will open test.txt for reading in text mode. To open a file in a binary mode you must add a b to the end of the mode string; for example, “rb” (for the reading and writing modes, you can add the b either after the plus sign – “r+b” – or before – “rb+”)

fclose

When you’re done working with a file, you should close it using the function
int fclose(FILE *a_file);
fclose returns zero if the file is closed successfully.

An example of fclose is
fclose(fp);
Reading and writing with fprintf, fscanf fputc, and fgetc

To work with text input and output, you use fprintf and fscanf, both of which are similar to their friends printf and scanf except that you must pass the FILE pointer as first argument. For example:
FILE *fp;
fp=fopen(“c:\\test.txt”, “w”);
fprintf(fp, “Testing…\n”);
It is also possible to read (or write) a single character at a time–this can be useful if you wish to perform character-by-character input (for instance, if you need to keep track of every piece of punctuation in a file it would make more sense to read in a single character than to read in a string at a time.) The fgetc function, which takes a file pointer, and returns an int, will let you read a single character from a file:
int fgetc (FILE *fp);
Notice that fgetc returns an int. What this actually means is that when it reads a normal character in the file, it will return a value suitable for storing in an unsigned char (basically, a number in the range 0 to 255). On the other hand, when you’re at the very end of the file, you can’t get a character value–in this case, fgetc will return “EOF”, which is a constant that indicates that you’ve reached the end of the file. To see a full example using fgetc in practice, take a look at the example here.

The fputc function allows you to write a character at a time–you might find this useful if you wanted to copy a file character by character. It looks like this:
int fputc( int c, FILE *fp );
Note that the first argument should be in the range of an unsigned char so that it is a valid character. The second argument is the file to write to. On success, fputc will return the value c, and on failure, it will return EOF.

1. rcs -i filename

this creates a rcs file with name filenamec,v.

2. ci filename

3 . co -l filename

this locks the previous version of file and allow you to do further changes into it.

1.1
date 2014.03.23.22.24.26; author root; state Exp;
branches;
next ;

desc
@create linklist .
@

1.1
log
@Initial revision
@
text
@#include
#include
#include
struct node
{
int roll;
char name[20];
struct node *next;
};
void creat_node(struct node * temp)
{
struct node *start;
temp->next=malloc(sizeof(struct node));
temp=temp->next;
printf(“\nentrer the roll”);
scanf(“%d”,&temp->roll);
printf(“enter the name \n”);
scanf(“%s”,temp->name);
temp->next=NULL;

}
void display_node(struct node *temp)
{
while(temp!=NULL)
{
printf(“roll is %d\n”,temp->roll);
printf(“name is %s\n”,temp->name);
temp=temp->next;
}
}
int main()
{
int i,n;

struct node *start,*temp;
start=malloc(sizeof(struct node));
temp=start;
printf(“\nentrer the roll”);
scanf(“%d”,&temp->roll);
printf(“enter the name \n”);
scanf(“%s”,temp->name);
printf(“enter the number of no. of node\n”);
scanf(“%d”,&n);
temp->next=NULL;
creat_node(temp);

for(i=0;inext;
}

display_node(start);
{
display_node(start);
}

}
@

1.1
date 2014.03.23.21.53.35; author root; state Exp;
branches;
next ;

desc
@master array with compression
@

1.1
log
@Initial revision
@
text
@#include
#include
#include
int main()
{
int i=0,j,len,maslen=1,fd,ret;
char arr[100]={0};
char masterarr[25]={0};
fd=open(“add.c”,O_RDONLY);
if(fd0;i++)
{
ret=read(fd,&arr[i],1);
printf(“\nret=%d,data is %c\n”,ret,arr[i]);
}

len=strlen(arr);
unsigned int ch1,ch2,comp,fd1;
for(i=0;i<len;i++)
{
for(j=0;j<maslen;j++)
{
if(j+1==maslen)
{
masterarr[j]=arr[i];
maslen++;
break;
}
else
{
if(masterarr[j]==arr[i])
break;
}
}
}
printf("masterarr=%s\n",masterarr);
fd1=open("compress",O_CREAT|O_RDWR,777);
if(fd<0)
{
perror("open");
goto OUT;
}

for(i=0;i<len;i++)
{
for(j=0;j<maslen;j++)
{
if(masterarr[j]==arr[i])
{
ch1=j;
break;
}
}
i++;
for(j=0;j<maslen;j++)
{
if(masterarr[j]==arr[i])
{
ch2=j;
break;
}
}
printf("value in ch1 %d\n and ch2 %d\n",ch1,ch2);

ch2=ch2<<4;
comp=ch1|ch2;
printf("comp=%d",comp);
write(fd1,&comp,1);
}
return 0;
OUT:
return-1;
}

@

1.1
date    2014.03.20.07.44.20;    author emblogic;    state Exp;
branches;
next    ;

desc
@this is program of pointer
@

1.1
log
@Initial revision
@
text

@