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

desc
@own driver .
@

1.1
log
@Initial revision
@
text
@#include”header.h”
static int initialization_fun(void)
{
printk(KERN_INFO”hello kernel”);
return 0;
}
static void cleanup_fun(void)
{
printk(KERN_INFO “BYE FOR NOW,I WILL BE BACK”);

}
module_init(initialization_fun);
module_exit(cleanup_fun);

@

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

desc
@creat reqclient for socket.
@

1.1
log
@Initial revision
@head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

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

desc
@server for socket impl.
@

1.1
log
@Initial revision
@
text

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

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

desc
@creat processing client for socket.
@

1.1
log
@Initial revision
@

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

desc
@client of threads.
@

1.1
log
@Initial revision
@
texthead    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

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

desc
@server of threads.
@

1.1
log
@Initial revision
@
texthead    1.1;
access;
symbols;
locks; strict;
comment    @ * @;

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

desc
@processing client of threads.
@

1.1
log
@Initial revision
@
text

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

desc
@simple program of thread.
@

1.1
log
@Initial revision
@

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

desc
@message rcv for comm..
@

1.1
log
@Initial revision
@
text

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

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

desc
@message queue impliment.
@

1.1
log
@Initial revision
@
text

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

desc
@the program of semafore .
@

1.1
log
@Initial revision
@
text
@#include<stdio.h>
#include<linux/sem.h>
#include<stdlib.h>
int main()
{
struct sembuf sem1;
sem1.sem_num=0;
sem1.sem_op=-1;
sem1.sem_flg=SEM_UNDO;
union semun u;
u.val=1;
int i,ret,kk;
kk=semget((key_t)123,1,IPC_CREAT|0777);
if(kk<0)
{
perror(“\nsemget failure”);
goto OUT;
}
ret=semctl(kk,0,SETVAL,u);
if(ret<0)
{
perror(“\n semctl is failure”);
goto OUT;
}
ret=semop(kk,&sem1,1);
for(i=1;i<4;i++)
{
printf(“\n i am raushan:::=%d”,getpid());
printf(“\n hi how are you:::=%d”,getpid());
printf(“\n who are you:::=%d”,getpid());
}
sem1.sem_num=0;
sem1.sem_op=1;
sem1.sem_flg=SEM_UNDO;
ret=semop(kk,&sem1,1);
return 0;
OUT:
return-1;
}
@

1.2
date    2014.05.15.11.19.59;    author root;    state Exp;
branches;
next    1.1;

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

desc
@server iof fifo is.
@

1.2
log
@*** empty log message ***
@
text
@#include”header.h”
int main()
{

struct data data1;
int len,len1,ret,ret1,count,mul,fd,fd1,fd2,fd3,result;
ret=access(“raushan”,F_OK);
if(ret==-1)
{
ret=mkfifo(“raushan”,777);
}
fd=open(“raushan”,O_RDONLY);
if(fd<0)
{
perror(“\n open is failure”);
goto OUT;
}
len=sizeof(struct data);
count=read(fd,&data1,len);
printf(“\n bytes is %d %d %d %c”,count,data1.a,data1.b,data1.opr);
ret=access(“raushan1″,F_OK);
if(ret==-1)
{
ret=mkfifo(“raushan1″,777);

}
fd1=open(“raushan1″,O_WRONLY);
if(fd1<0)
{
perror(“\n open is failure”);
goto OUT;
}
len1=sizeof(struct data);
count=write(fd1,&data1,len1);
printf(“\n bytes is %d”,count);
fd1=open(“raushan1″,O_RDONLY);
len=sizeof(result);
count=read(fd1,&result,len);
printf(“\n result=%d”,result);
close(fd1);
fd=open(“raushan”,O_WRONLY);
len=sizeof(result);
count=write(fd,&result,len);
printf(“\n result=%d”,result);

ret=access(“raushan2″,F_OK);
if(ret==-1)
{
ret=mkfifo(“raushan2″,777);
}
fd2=open(“raushan2″,O_RDONLY);
if(fd2<0)
{
perror(“\n open is failure”);
goto OUT;
}
len=sizeof(struct data);
count=read(fd2,&data1,len);
printf(“\n bytes is %d %d %d %c”,count,data1.a,data1.b,data1.opr);
ret=access(“raushan3″,F_OK);
if(ret==-1)
{
ret=mkfifo(“raushan3″,777);

}
fd3=open(“raushan3″,O_WRONLY);
if(fd3<0)
{
perror(“\n open is failure”);
goto OUT;
}
len1=sizeof(struct data);
count=write(fd3,&data1,len1);
printf(“\n bytes is %d”,count);
fd3=open(“raushan3″,O_RDONLY);
len=sizeof(result);
count=read(fd3,&result,len);
printf(“\n result=%d”,result);
close(fd3);
fd2=open(“raushan2″,O_WRONLY);
len=sizeof(result);
count=write(fd2,&result,len);
printf(“written result is %d\n”,result);
return 0;
OUT:
return-1;

}
@

1.1
log
@Initial revision
@
text
@d6 1
a6 1
int len,len1,ret,count,fd,fd1,result;
d24 2
a25 1
ret=mkfifo(“raushan1″,777);
d40 1
d46 20
d67 19
@

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

desc
@req client for pipe.
@

1.1
log
@In

server

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

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

desc
@server for ipc
@

1.1
log
@Initial revision
@
text

proc.client

head    1.1;
access;
symbols;
locks
root:1.1; strict;
comment    @ * @;

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

desc
@processing client .
@

1.1
log
@Initial revision
@

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

desc
@push and pop in stack .
@

1.1
log
@Initial revision
@
text
@#include<stdio.h>
#include<stdlib.h>
#define MAX 5
int push(void **,int *);
int pop(void **,int *);
void display(void **,int *);
int main()
{
void *astack;
int atop=-1;

int ch;
do
{
printf(“\n1:push”);
printf(“\n2:pop”);
printf(“\n3:display”);
printf(“\n enter the choice”);
scanf(“%d”,&ch);
switch(ch)
{
case 1:push(&astack,&atop);
break;
case 2:pop(&astack,&atop);
break;
case 3:display(&astack,&atop);
break;
default:printf(“\nwrong choice”);
break;

}
}while(ch!=4);
return 0;
}
int push(void **astack,int *atop)
{
static char ch=1;
if(*atop>=MAX-1)
{
printf(“\n overflow”);
return-1;
}
if(*atop==-1)
{
*astack= (char*)malloc(1);
(*atop)++;
*(char*)(*astack+*atop)=ch;
ch++;
return -1;
}
*astack=realloc(*astack,(*atop+2));
(*atop)++;
*(char*)(*astack+*atop)=ch;
ch++;
}
int pop(void **astack,int *atop)
{
if(*atop==-1)
{
printf(“stack underflow\n”);
}
printf(“\n %d element %d delete”,*atop,*(char*)(*astack+*atop));
(*atop)–;

}
void display(void **astack,int *atop)
{
int i=0;
for(i=(*atop);i>=0;i–)
{
printf(“\nstack at %d is %d\n”,i,*(char*)(*astack+i));
}
}
@

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<stdio.h>
#include<stdlib.h>
#include<string.h>
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;i<n;i++)
{
creat_node(temp);
temp=temp->next;
}

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<stdio.h>
#include<string.h>
#include<fcntl.h>
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(fd<0)
{
perror(“open”);
goto OUT;
}
printf(“fd=%d\n”,fd);

ret=read(fd,&arr[i],1);
for(i=1;ret>0;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;
}

@