I’ve resolved this problem by this way:
If i take a local variable pointer and malloc it and then pass it. when we malloc then it falls in heap segment and the it exist for the whole lifetime of program.

Please comment if any issue.

int main()
{
varfun(3, 7, -11.2, 0.66);
return 0;
}
void varfun(int n, …)
{
float *ptr;
int num;
va_start(ptr, n);
num = va_arg(ptr, int);
printf(“%d”, num);
}

1.5
date 2014.07.17.03.57.50; author root; state Exp;
branches;
next 1.4;

1.4
date 2014.07.16.13.55.28; author root; state Exp;
branches;
next 1.3;

1.3
date 2014.07.16.13.52.30; author root; state Exp;
branches;
next 1.2;

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

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

desc
@created main menu and give the choice
declare structure in which one data is info and another is next pointer
of structure type
set the top pointr to -1
@

1.5
log
@*** empty log message ***
@
text
@#include
#include
static int top=-1;
int size;
struct link
{
int info;
struct link *next;
};
struct link *create_node()
{
struct link *temp;
top++;
temp=(struct link *)malloc(sizeof(struct link));
printf(“please enter data :\n”);
scanf(“%d”,&temp->info);

temp->next=NULL;
return temp;

}
struct link *push(struct link *temp)
{
struct link *push=temp;

while(push->next!=NULL)
{
push=push->next;
}
push->next=create_node();
push=push->next;

}
pop(struct link *temp)
{
struct link *temp1=temp->next;
/*while(temp1)
{
temp->info=temp1->info;
if(temp1->next==NULL)
{

temp->next=NULL;
free(temp1);
break;

}
else
{ temp=temp1;
temp1=temp->next;
} }
// temp=NULL;*/
while(temp->next)
{
temp1=temp->next;
if(temp1->next==NULL)
{
temp->next=NULL;
free(temp1);
break;
}
temp=temp->next;

}
top–;
}

display(struct link *disp)
{
printf(“\n stack is :\n”);
while(disp)
{
printf(“%d \n”,disp->info);
disp=disp->next;
}

}
getchoice(int choice)
{
static int flag=0;
static struct link *start,*new;
switch(choice)
{
case 1:
if(top==-1 )
{
start=new=create_node();
flag=1;
}
else
printf(“push the data stack is already created\n”);
break;

case 2:if(top<size-1 && flag)
{
push(new);
}
else if(top-1)
pop(start);
else
printf(“stack is empty\n”);
break;
case 4:
if(top>-1)
display(start);
else
printf(“create stack first \n”);
break;
case 0:
exit(0);
break;
default:
printf(“enter right choice !!\n”);
}
return 0;
}

int main()
{
int choice;
printf(“enter the size of stack \n”);
scanf(“%d”,&size);
while(1)
{
printf(“____MAIN MENU___\n”);
printf(“____1.CREATE STACK__\n”);
printf(“____2.PUSH _____\n”);
printf(“____3.POP _____\n”);
printf(“____4.DISPLAY ____\n”);
printf(“____0.EXIT _____\n”);
printf(“enter choice :\n”);
scanf(“%d”,&choice);
getchoice(choice);
}
return 0;
}
@

1.4
log
@remove error
@
text
@d15 2
a16 1

a24 9
int flag=0;
if(top==0&& !flag)
{
printf(“enter data :\n”);
scanf(“%d”,&push->info);
flag=1;
}
else
{
d26 1
a26 1
while(push)
d31 1
d33 32
a64 2
printf(“enter data :\n”);
scanf(“%d”,&push->next->info);
d66 12
a77 1

d81 2
a82 2
int flag=0;
struct link *start,*new;
d86 1
a86 1
if(top==-1 && !flag)
d91 2
d96 1
d98 3
d102 1
a102 1
printf(“stack is full or stack create first\n”);
d105 10
d133 1
a133 1
printf(“____1.CREATE STACK__”);
@

1.3
log
@declear size
@
text
@d27 1
a27 1
printf(“enter data :\n”)
d40 1
a40 1
printf(“enter data :\n”)
@

1.2
log
@making the getchoice function and then creat_node function
create node funtion create the data space
and then push fucntion write the data in created space
@
text
@d4 1
a4 1
int stack_size;
d79 1
a79 1
scanf(“%d”,&stack_size);
@

1.1
log
@Initial revision
@
text
@d10 64
a73 1

d83 4
a86 3
printf(“____1.PUSH _____\n”);
printf(“____2.POP _____\n”);
printf(“____3.DISPLAY ____\n”);
d90 1
@

//——-header file——
@#include
#include
struct link
{
int info;
struct link *next;
};
static int node_no=0;
struct link *creat_node();
struct link *delete_node(struct link *);
int delete_at_end(struct link *);
struct link* delete_at_beg(struct link *);
int delete_at_pos(struct link *);
struct link * delete_key(struct link *);
struct link *insert_node(struct link *);
struct link *node_at_beg(struct link *);
int node_at_pos(struct link *);
int node_at_end(struct link *);
int node_key(struct link *);
int traverse_ll(struct link *);
int getchoice(int );
int search_element(struct link *);
@

//—————link list main function——–
@#include”header.h”
struct link *create_node()
{

struct link *temp;
temp=(struct link *)malloc(sizeof(struct link));
printf(“\n enter the data :”);
scanf(“%d”,&temp->info);
temp->next=NULL;
node_no++;
return temp;
}
delete_at_end(struct link *temp)
{
struct link *end,*p;
end=temp;
while(end->next!=NULL)
{
p=end;
end=end->next;
}
p->next=NULL;
free(end);
return 0;
}

struct link* delete_at_beg(struct link *temp)
{
struct link *beg;
beg=temp;
temp=beg->next;
free(beg);

return temp;
}
delete_at_pos(struct link *temp)
{
int node,i;
struct link *nnode=temp,*pnode=temp,*r=NULL;
printf(“\n you have %d node”,node_no);
printf(“\n which node you want to delete”);
scanf(“%d”,&node);
if(node==2)
{

struct link *p,*q;

p=temp->next;
q=p->next;
temp->next=q;

free(p);
node_no–;

}
else
{
for(i=0;inext;

}

for(i=0;inext;

}
pnode->next=nnode;
node_no–;
}
return 0;

}
struct link *delete_key(struct link *temp)
{
int val,flag=0;
struct link *p=temp,*r;
printf(“\n enter the value whose node you want to delete :\n”);
scanf(“%d”,&val);
if(val==temp->info)
{
flag=1;
node_no–;
temp=temp->next;
free(p);
return temp;
}
else
{
while(p!=NULL)
{
if(p->info==val)
{
r->next=p->next;
flag=1;
node_no–;
free(p);
break;

}
r=p;
p=p->next;

}
}
if(flag==0)
{
printf(“\n entered data is not present in link list \n”);

}
return temp;
}
struct link*delete_node(struct link *temp)
{

printf(“\n\t 1.delete node at begining”);

printf(“\n\t 2. delete node at position”);
printf(“\n\t 3.delete node at end”);
printf(“\n\t 4.delete node at key value”);
int choice;
printf(“\n enter your choice :”);
scanf(“%d”,&choice);

switch(choice)
{
case 1:
temp=delete_at_beg(temp);
break;
case 2:
delete_at_pos(temp);
break;
case 3:
delete_at_end(temp);
break;
case 4:
temp=delete_key(temp);
break;
default:
printf(“\n \aenter right choice”);
}
return temp;
}

/*struct link *delete_node(struct link *temp)
{
int node,i;
struct link *nnode=temp,*pnode=temp,*r=NULL;
printf(“\n you have %d node”,node_no);
printf(“\n which node you want to delete”);
scanf(“%d”,&node);
if(node==1)
{
struct link *q;
//q=(struct link *)malloc(sizeof(struct link));
q=temp;
temp=temp->next;

free(q);

node_no–;
}
else if(node==2)
{
// nnode=temp->next;
// nnode=nnode->next;
struct link *p,*q;
p=(struct link *)malloc(sizeof(struct link));
p=temp->next;
q=temp->next;
q=q->next;
//temp->next=temp->next->next;

free(p);
node_no–;

}
else
{
for(i=0;inext;

}

for(i=0;inext;
}
pnode->next=nnode;
node_no–;
}
return temp;
}*/
struct link *node_at_beg(struct link *temp)
{
struct link *beg;
beg=create_node();
beg->next=temp;

return beg;
}
node_at_pos(struct link *temp)
{
int position,i;
struct link *new,*pos=temp;
printf(“\n no. of node in link list :%d”,node_no);
printf(“\n please enter the position where you want to insert node :”);
scanf(“%d”,&position);
if(position>node_no)
{
printf(“\n enter the position less than total node ..!!”);
goto out;
}
new=create_node();
for(i=1;inext;
}
new->next=pos;
for(i=1;inext;
}
temp->next=new;
return 0;
out:
return 0;
}
node_at_end(struct link *temp)
{
struct link *end;

end=create_node();
while(temp->next!=NULL)
{
temp=temp->next;
}

temp->next=end;
return 0;
}

node_key(struct link *temp)
{
int val,count=0;

struct link *key=temp,*insert;
printf(“\n enter the key value where you want to add node :”);
scanf(“%d”,&val);
while(key!=NULL)
{
if(val==key->info)
{
insert=create_node();
insert->next=key->next;
key->next=insert;
count++;
break;
}
key=key->next;
}
if(count==0)

printf(“\n key value is not present in link list”);
return 0;
}
struct link *insert_node(struct link *temp)
{
printf(“\n\t 1.insert node at begining”);

printf(“\n\t 2. insert node at position”);
printf(“\n\t 3.insert node at end”);
printf(“\n\t 4.insert node at key value”);
int choice;
printf(“\n enter choice:”);
scanf(“%d”,&choice);
switch(choice)
{
case 1:
temp=node_at_beg(temp);
break;
case 2:
node_at_pos(temp);
break;
case 3:
node_at_end(temp);
break;
case 4:
node_key(temp);
break;
default:
printf(“\n \aenter right choice”);
}

return temp;
}

traverse_llist(struct link *temp)
{
while(temp!=NULL)
{
printf(“\n node no.—> %d”,temp->info);
temp=temp->next;
}
return 0;
}
search_element(struct link *temp)
{
int no,count=0,flag=0;
printf(“\n enter the no. which you want to search :”);
scanf(“%d”,&no);
while(temp!=NULL)
{
count++;
if(no==temp->info)
{
flag=1;
printf(“\nyour search for %d found”,no);
break;
}
temp=temp->next;
}
if(flag==0)
{
printf(“\nyour searching no. is not present in link list”);
}
return 0;
}
getchoice(int choice)
{

static int flag=0;
struct link *new,*start;
switch(choice)
{

case 1:
if(flag==0)
{
new=start=create_node();
printf(“\n link list created”);
flag=1;
}
else
printf(“\n link list created already”);
break;

case 2:
if(flag==1)
new=insert_node(new);
else
printf(“\n create link list first”);
break;
case 3:
if(flag==1)
new=delete_node(new);
else
printf(“\n create link list first”);
break;
case 4:
if(flag==1)
traverse_llist(new);
else
printf(“\n create link list first”);
break;
case 5:
search_element(new);
break;
case 6:
// sorting_element();
break;
default:
printf(“enter right choice”);

case 0:
exit(0);

}
return 0;

}

int main()
{
int choice;
printf(“——-MAIN MENU———-”);
while(1)
{
printf(“\n 1.CREATE LINk LIST———”);
printf(“\n 2.INSERT NODE————–”);
printf(“\n 3.DELETE NODE————–”);
printf(“\n 4.TRAVERSE LINK LIST——-”);
printf(“\n 5.SEARCHING ELEMENT________”);
printf(“\n 6.SORTING ELEMENT__________”);
printf(“\n 0.EXIT LINKLIST___________”);
printf(“\n enter choice :”);
scanf(“%d”,&choice);
getchoice(choice);
}
return 0;
}

RCS file: ./server.c,v
Working file: ./server.c
head: 1.5
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 5; selected revisions: 5
description:
working for second client
created a pipe an
for communication between server and client2
—————————-
revision 1.5
date: 2014/07/06 12:05:00; author: root; state: Exp; lines: +110 -57
the server used three pipe for communication between three client
and single pipe for communication between process and server
for sync i’ve used signal sigusr
—————————-
revision 1.4
date: 2014/07/05 08:35:03; author: root; state: Exp; lines: +45 -7
make a new pipe for client3
recieve the data from client3 and proceed it to process 3
the process3 use the common pipe for all the three process
for sync i’ve used sleep
—————————-
revision 1.3
date: 2014/07/05 04:02:23; author: root; state: Exp; lines: +26 -5
in server for the client_2 i add a pipe between the client2 and server
by using the previous pipe which is between process1 and server
i used data communication between server and process2
to sync i used sleep as per requirement
—————————-
revision 1.2
date: 2014/07/04 18:58:33; author: root; state: Exp; lines: +7 -4
creating new pipe for process2
—————————-
revision 1.1
date: 2014/07/04 17:21:57; author: root; state: Exp;
Initial revision
=============================================================================
———–program for client—————–

RCS file: client1.c,v
Working file: client1.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
in client i’ve used if else condition
in the if condition it compare with the flag which has sent by server
for client1 i’ve sent message “client1″ to client when the if condition true then the client
receive the output
in else condition the client write the data to server
for sync i’ve used signal
—————————-
revision 1.1 locked by: root;
date: 2014/07/06 12:36:43; author: root; state: Exp;
Initial revision
============================================================================

***************process——————
RCS file: process1.c,v
Working file: process1.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
—————————-
revision 1.1 locked by: root;
date: 2014/07/06 13:03:08; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: server.c,v
Working file: server.c
head: 1.3
branch:
locks: strict
root: 1.3
access list:
symbolic names:
keyword substitution: kv
total revisions: 3; selected revisions: 3
description:
working for second client
created a pipe an
for communication between server and client2
—————————-
revision 1.3 locked by: root;
date: 2014/07/05 04:02:23; author: root; state: Exp; lines: +26 -5
in server for the client_2 i add a pipe between the client2 and server
by using the previous pipe which is between process1 and server
i used data communication between server and process2
to sync i used sleep as per requirement
—————————-
revision 1.2
date: 2014/07/04 18:58:33; author: root; state: Exp; lines: +7 -4
creating new pipe for process2
—————————-
revision 1.1
date: 2014/07/04 17:21:57; author: root; state: Exp;
Initial revision
=============================================================================

—-client—–

RCS file: ./client2.c,v
Working file: ./client2.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
created a client2.c function
which provides the data to server
by using pipe
and again after processing the data it receive the data from server by using same pipe
for the sync. i used sleep
as per needed
—————————-
revision 1.1 locked by: root;
date: 2014/07/05 04:06:40; author: root; state: Exp;
Initial revision
=============================================================================
——process—–

RCS file: ./process2.c,v
Working file: ./process2.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
in the process2 i used the same pipe which has been previously used
between process1 and server
in the process i perform the operation as per operator
after performing operation process2 return the result to the server
—————————-
revision 1.1 locked by: root;
date: 2014/07/05 04:08:53; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: ./orphan_using_wait.c,v
Working file: ./orphan_using_wait.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
when the parent process complete its execution
then the child becomes orphan process
in this case our prompt don’t came automatically
to handle this we use wait() function
—————————-
revision 1.1 locked by: root;
date: 2014/07/04 13:17:35; author: root; state: Exp;
Initial revision
=============================================================================

RCS file: server.c,v
Working file: server.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
it receive data from client
then read it and further it write the data into process
again it receive the processing data from process program
now sent the output to client by pipe
—————————-
revision 1.1 locked by: root;
date: 2014/07/04 12:22:14; author: root; state: Exp;
Initial revision
=============================================================================
———-client————-

RCS file: server.c,v
Working file: server.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
it receive data from client
then read it and further it write the data into process
again it receive the processing data from process program
now sent the output to client by pipe
—————————-
revision 1.1 locked by: root;
date: 2014/07/04 12:22:14; author: root; state: Exp;
Initial revision
=============================================================================
———process………………

RCS file: server.c,v
Working file: server.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1; selected revisions: 1
description:
it receive data from client
then read it and further it write the data into process
again it receive the processing data from process program
now sent the output to client by pipe
—————————-
revision 1.1 locked by: root;
date: 2014/07/04 12:22:14; author: root; state: Exp;
Initial revision
=============================================================================

1.47
date    2014.06.08.07.52.37;    author root;    state Exp;
branches;
next    1.46;

1.46
date    2014.06.07.16.31.29;    author root;    state Exp;
branches;
next    1.45;

1.45
date    2014.06.07.16.21.15;    author root;    state Exp;
branches
1.45.1.1;
next    1.44;

1.44
date    2014.06.07.16.06.07;    author root;    state Exp;
branches;
next    1.43;

1.43
date    2014.06.07.16.05.31;    author root;    state Exp;
branches;
next    1.42;

1.42
date    2014.06.07.16.04.35;    author root;    state Exp;
branches;
next    1.41;

1.41
date    2014.06.07.16.00.50;    author root;    state Exp;
branches;
next    1.40;

1.40
date    2014.06.07.09.48.05;    author root;    state Exp;
branches;
next    1.39;

1.39
date    2014.06.06.11.25.18;    author root;    state Exp;
branches;
next    1.38;

1.38
date    2014.06.06.11.00.51;    author root;    state Exp;
branches;
next    1.37;

1.37
date    2014.06.06.10.40.07;    author root;    state Exp;
branches;
next    1.36;

1.36
date    2014.06.06.10.36.52;    author root;    state Exp;
branches;
next    1.35;

1.35
date    2014.06.06.07.30.42;    author root;    state Exp;
branches;
next    1.34;

1.34
date    2014.06.06.07.29.14;    author root;    state Exp;
branches;
next    1.33;

1.33
date    2014.06.06.06.32.11;    author root;    state Exp;
branches;
next    1.32;

1.32
date    2014.06.06.06.29.27;    author root;    state Exp;
branches;
next    1.31;

1.31
date    2014.06.06.06.25.43;    author root;    state Exp;
branches;
next    1.30;

1.30
date    2014.06.06.06.25.02;    author root;    state Exp;
branches;
next    1.29;

1.29
date    2014.06.06.06.24.11;    author root;    state Exp;
branches;
next    1.28;

1.28
date    2014.06.06.06.21.01;    author root;    state Exp;
branches;
next    1.27;

1.27
date    2014.06.06.06.18.33;    author root;    state Exp;
branches;
next    1.26;

1.26
date    2014.06.06.06.11.46;    author root;    state Exp;
branches;
next    1.25;

1.25
date    2014.06.06.06.10.41;    author root;    state Exp;
branches;
next    1.24;

1.24
date    2014.06.06.06.08.21;    author root;    state Exp;
branches;
next    1.23;

1.23
date    2014.06.06.06.01.28;    author root;    state Exp;
branches;
next    1.22;

1.22
date    2014.06.06.05.56.12;    author root;    state Exp;
branches;
next    1.21;

1.21
date    2014.06.06.05.55.18;    author root;    state Exp;
branches;
next    1.20;

1.20
date    2014.06.06.05.53.59;    author root;    state Exp;
branches;
next    1.19;

1.19
date    2014.06.06.05.47.16;    author root;    state Exp;
branches;
next    1.18;

1.18
date    2014.06.06.05.41.57;    author root;    state Exp;
branches;
next    1.17;

1.17
date    2014.06.06.05.37.18;    author root;    state Exp;
branches;
next    1.16;

1.16
date    2014.06.03.09.37.34;    author root;    state Exp;
branches;
next    1.15;

1.15
date    2014.06.03.09.32.41;    author root;    state Exp;
branches;
next    1.14;

1.14
date    2014.06.03.09.32.10;    author root;    state Exp;
branches;
next    1.13;

1.13
date    2014.06.03.09.01.19;    author root;    state Exp;
branches;
next    1.12;

1.12
date    2014.06.03.09.00.33;    author root;    state Exp;
branches;
next    1.11;

1.11
date    2014.06.03.08.57.27;    author root;    state Exp;
branches;
next    1.10;

1.10
date    2014.06.03.08.55.36;    author root;    state Exp;
branches;
next    1.9;

1.9
date    2014.06.03.08.54.19;    author root;    state Exp;
branches;
next    1.8;

1.8
date    2014.06.03.08.53.22;    author root;    state Exp;
branches;
next    1.7;

1.7
date    2014.06.03.08.52.23;    author root;    state Exp;
branches;
next    1.6;

1.6
date    2014.06.03.08.51.19;    author root;    state Exp;
branches;
next    1.5;

1.5
date    2014.06.03.08.48.55;    author raman;    state Exp;
branches;
next    1.4;

1.4
date    2014.06.03.08.47.22;    author raman;    state Exp;
branches;
next    1.3;

1.3
date    2014.06.03.08.45.30;    author raman;    state Exp;
branches;
next    1.2;

1.2
date    2014.06.03.08.39.27;    author raman;    state Exp;
branches;
next    1.1;

1.1
date    2014.06.03.07.13.37;    author raman;    state Exp;
branches;
next    ;

1.45.1.1
date    2014.06.08.08.12.17;    author root;    state Exp;
branches;
next    ;

desc
@creation of main funcion and open_file
@

1.47
log
@*** empty log message ***
@
text
@#include”header.h”
int open_file(char *filename)
{
int fd;
fd=open(filename,O_RDONLY);
if(fd<0)
{    perror(“file not open”);
goto out;
}
return fd;
out:
return -1;
}
char *masterarray(int fd)
{
int i=0,nread;
char *masterarr;
char ch;
masterarr=(char *)malloc(sizeof(char));
while(1)
{
int j=0,flag=0;
nread=read(fd,&ch,1);
//    printf(“%c\n”,ch);

if(ch==10)
break;
//    *(masterarr+j)=ch;
//    masterarr=(char *)realloc(masterarr,1+i);

for(j=0;j<i;j++)
{
if(*(masterarr+j)==ch)
{
flag=1;
}
}
if(flag==0)
{
*(masterarr+i)=ch;
masterarr=realloc(masterarr,1+i);
i++;
}
flag=0;

}
printf(“\n masterarray is :%s”,masterarr);
return masterarr;

}
compression(char *p,int fd)
{
printf(“\n string is :%s”,p);
unsigned char ch,byt,byt1;
unsigned int loc=0;
int  count=0,nread,nwrite,i=0,j,fdw,count1=0,count2=0;
int no_of_char;
no_of_char=lseek(fd,0,SEEK_END);
printf(“\n no. of character is :%d”,no_of_char);
lseek(fd,0,SEEK_SET);
fdw=open(“comprsd_file”,O_RDWR |O_CREAT);
printf(“\n fdw=%d”,fdw);
while(1)
{
nread=read(fd,&ch,1);
//    printf(“%c”,ch);
i=0;
if(ch==10)
break;
for(i=0;*(p+i)!=ch;i++)
{

}
loc=i;
printf(“\n loc %d :%d”,count2,loc);
count2++;
// sprintf(&byt,”%d”,loc);
byt=loc;
if(count==0)
{
byt1=byt;
byt1<<=4;
count++;

}
else
{
byt<<=4;
byt>>=4;
byt=byt1|byt;
count=0;
nwrite=write(fdw,&byt,1);
printf(“\t char written :%c”,byt);
count1++;
byt^=byt;
byt1^=byt1;
}

}
close(fdw);
fdw=open(“encryption_key”,O_RDWR |O_CREAT);
nwrite=write(fdw,p,strlen(p));
printf(“\nno. of bytes write :%d”,count1);
return 0;
}
int main(int argc,char *argv[])
{
int fd;
char *masterarr;
masterarr=(char *)malloc(sizeof(char));
if(argc!=2)
{
printf(“argument error”);
goto out;
}
fd=open_file(argv[1]);
printf(“fd=%d”,fd);
masterarr=masterarray(fd);
printf(“length :%d”,strlen(masterarr));
compression(masterarr,fd);
//    printf(“\n masterarray is :%s \n”,masterarr);
return 0;
out:
return -1;
}
@

1.46
log
@*** empty log message ***
@
text
@d79 1
a79 6
if(count2%2!=0 && count2==no_of_char-1 && count==0)
{

write(fdw,&byt,1);
}
else if(count==0)
@

1.45
log
@to remove the problem of last character .
if the no. of char is odd
then put the last character in byte and write it
@
text
@d79 1
a79 1
if(count2%2==0 && count2==no_of_char-1 && count==0)
@

1.45.1.1
log
@work for the last character
when no. of character is odd
@
text
@d79 6
a84 1
if(count==0)
@

1.44
log
@*** empty log message ***
@
text
@d55 1
a55 1
unsigned loc=0;
d79 6
a84 1
if(count==0)
@

1.43
log
@*** empty log message ***
@
text
@d57 1
a57 1
int no_of _char;
@

1.42
log
@corecting the error
@
text
@d57 2
a58 1
int no_of _char=lseek(fd,0,SEEK_END);
@

1.41
log
@checking the number of character.is it even or odd
@
text
@d56 1
a56 1
int  count=0,nread,nwrite,i=0,j,fdw,count1=0,count2=0;i
@

1.40
log
@*** empty log message ***
@
text
@d56 3
a58 1
int  count=0,nread,nwrite,i=0,j,fdw,count1=0,count2=0;
@

1.39
log
@*** empty log message ***
@
text
@d116 1
@

1.38
log
@checking encrypted code
@
text
@d74 2
a75 1
sprintf(&byt,”%d”,loc);
@

1.37
log
@*** empty log message ***
@
text
@d89 1
@

1.36
log
@*** empty log message ***
@
text
@d55 2
a56 1
int  count=0,nread,nwrite,i=0,j,fdw,loc=0,count1=0,count2=0;
@

1.35
log
@*** empty log message ***
@
text
@d55 1
a55 1
int  count=0,nread,nwrite,i=0,j,fdw,loc=0,count1=0;
d71 2
a72 1
printf(“\n loc :%d”,loc);
@

1.34
log
@creating encryption_key file
@
text
@d95 1
a95 1
nwrite=write(fdw,masterarr,strlen(masterarr));
@

1.33
log
@*** empty log message ***
@
text
@d93 3
@

1.32
log
@*** empty log message ***
@
text
@a67 1
loc=i;
d70 1
@

1.31
log
@*** empty log message ***
@
text
@d55 1
a55 1
int  count=0,nread,nwrite,i=0,j,fdw,loc,count1=0;
@

1.30
log
@*** empty log message ***
@
text
@d69 1
a69 1
break;
@

1.29
log
@*** empty log message ***
@
text
@d66 1
a66 1
for(i=0;*(p+i)==ch;i++)
@

1.28
log
@checking location
@
text
@d69 1
a69 1

@

1.27
log
@*** empty log message ***
@
text
@d71 1
a71 1

@

1.26
log
@*** empty log message ***
@
text
@d77 1
d80 1
a80 1
if(count==1)
d91 1
a91 1
count++;
@

1.25
log
@*** empty log message ***
@
text
@d77 1
a77 1
count++;
d90 1
@

1.24
log
@*** empty log message ***
@
text
@d86 1
a86 1

d91 1
@

1.23
log
@*** empty log message ***
@
text
@d55 1
a55 1
int  count=0,nread,nwrite,i=0,j,fdw,loc;
d71 1
d79 1
a79 1
if(count=1)
d86 1
@

1.22
log
@*** empty log message ***
@
text
@d66 1
a66 1
while(p[i]==ch)
d69 1
a69 1
i++;
@

1.21
log
@*** empty log message ***
@
text
@d62 2
a63 1
printf(“%c”,ch);
@

1.20
log
@*** empty log message ***
@
text
@d62 1
@

1.19
log
@*** empty log message ***
@
text
@d53 1
d58 1
@

1.18
log
@resolve error msg
@
text
@d59 25
a83 25

nread=read(fd,&ch,1);
if(ch==10)
break;
while(p[i]==ch)
{
loc=i;
i++;
}
sprintf(&byt,”%d”,loc);
if(count==0)
{
byt1=byt;
byt1<<=4;
count++;
}
if(count=1)
{
byt<<=4;
byt>>=4;
byt=byt1|byt;
count=0;
nwrite=write(fdw,&byt,1);
byt^=byt;
byt1^=byt1;
@

1.17
log
@creating the compressed file using compress function
the comprsd_file contain the encryted data
@
text
@d54 1
a54 1
int  count=0,nread,nwrite,i=0,j,fdw;
d97 1
a97 1
fd=open_file(argerav[1]);
@

1.16
log
@*** empty log message ***
@
text
@d51 36
d97 1
a97 1
fd=open_file(argv[1]);
d100 1
@

1.15
log
@*** empty log message ***
@
text
@d28 2
a29 2
*(masterarr+i)=ch;
masterarr=(char *)realloc(masterarr,1+i);
d41 2
d44 2
a45 1
i++;
@

1.14
log
@*** empty log message ***
@
text
@d22 1
a22 1
int j=0;flag=0;
@

1.13
log
@*** empty log message ***
@
text
@d22 1
d30 12
d44 1
a44 1
//    printf(“\n masterarray is :%s”,masterarr);
d61 1
a61 1
printf(“\n masterarray is :%s \n”,masterarr);
@

1.12
log
@*** empty log message ***
@
text
@d48 1
a48 1
printf(“\n masterarray is %s :”,masterarr);
@

1.11
log
@*** empty log message ***
@
text
@d31 1
a31 1
printf(“\n masterarray is :%s”,masterarr);
d48 1
@

1.10
log
@*** empty log message ***
@
text
@d26 1
a26 1
goto out;
d33 1
a33 2
out:
return -1;
@

1.9
log
@*** empty log message ***
@
text
@d20 1
a20 1
while(nread)
@

1.8
log
@*** empty log message ***
@
text
@d25 2
a26 2
//if(ch==10)
//goto out;
@

1.7
log
@*** empty log message ***
@
text
@d27 1
a27 1
*masterarr=ch;
@

1.6
log
@*** empty log message ***
@
text
@d23 1
a23 1
printf(“%c\n”,ch);
@

1.5
log
@*** empty log message ***
@
text
@d16 1
a16 1
int i=0;
d20 1
a20 1
while(1)
d22 1
a22 1
read(fd,&ch,1);
@

1.4
log
@*** empty log message ***
@
text
@d25 2
a26 2
if(ch==10)
goto out;
@

1.3
log
@*** empty log message ***
@
text
@d23 2
@

1.2
log
@definition of masterarray()
@
text
@d17 1
a17 1
char *p;
d19 1
a19 1
p=(char *)malloc(sizeof(char));
d24 1
a24 1
goto out;
d30 1
a30 1
return 0;
@

1.1
log
@Initial revision
@
text
@d14 20
a33 1

d37 2
d46 1
a46 1

@