RCS file: ./initialization.c,v
Working file: ./initialization.c
head: 1.8
branch:
locks: strict
root: 1.8
access list:
symbolic names:
keyword substitution: kv
total revisions: 8;    selected revisions: 8
description:
initialization function registering char driver.
—————————-
revision 1.8    locked by: root;
date: 2014/09/17 17:36:43;  author: root;  state: Exp;  lines: +1 -0
initialize the semapahore .
—————————-
revision 1.7
date: 2014/09/17 16:16:42;  author: root;  state: Exp;  lines: +10 -1
declared quantum_size,qset-size and device_size of sculldev.
—————————-
revision 1.6
date: 2014/09/04 08:12:28;  author: root;  state: Exp;  lines: +3 -3
replaced the priority in printk.
—————————-
revision 1.5
date: 2014/09/04 07:58:12;  author: root;  state: Exp;  lines: +6 -3
fixed some errors.
—————————-
revision 1.4
date: 2014/09/03 15:52:43;  author: root;  state: Exp;  lines: +21 -4
initialized the device with cdev_init.
added device using cdev_add.
only one device is mapped by scull.
—————————-
revision 1.3
date: 2014/09/03 05:23:55;  author: root;  state: Exp;  lines: +1 -0
gave moduleparam for nod.
—————————-
revision 1.2
date: 2014/09/03 05:14:50;  author: root;  state: Exp;  lines: +1 -0
gave decalartrions.h header
—————————-
revision 1.1
date: 2014/09/03 05:14:06;  author: root;  state: Exp;
Initial revision
=============================================================================
RCS FOR DEV_OPEN

RCS file: ./dev_open.c,v
Working file: ./dev_open.c
head: 1.2
branch:
locks: strict
root: 1.2
access list:
symbolic names:
keyword substitution: kv
total revisions: 2;    selected revisions: 2
description:
device open open call routine written.
—————————-
revision 1.2    locked by: root;
date: 2014/09/04 08:03:16;  author: root;  state: Exp;  lines: +1 -1
fixed some errors .
—————————-
revision 1.1
date: 2014/09/03 16:13:34;  author: root;  state: Exp;
Initial revision
=============================================================================
RCS FOR DEV_WRITE

RCS file: ./dev_write.c,v
Working file: ./dev_write.c
head: 1.14
branch:
locks: strict
root: 1.14
access list:
symbolic names:
keyword substitution: kv
total revisions: 14;    selected revisions: 14
description:
device wurite operation .
memory allocated to sculldev->scullqset.
noqsets depend on the sizeof block.
64 bytes block created.
—————————-
revision 1.14    locked by: root;
date: 2014/09/22 15:39:51;  author: root;  state: Exp;  lines: +9 -5
test for the dev trim condition .
—————————-
revision 1.13
date: 2014/09/22 12:09:54;  author: root;  state: Exp;  lines: +50 -38
included down semaphore.
—————————-
revision 1.12
date: 2014/09/18 18:25:12;  author: root;  state: Exp;  lines: +38 -35
modified code for dev_trim call.
—————————-
revision 1.11
date: 2014/09/17 17:37:47;  author: root;  state: Exp;  lines: +2 -1
applied semaphore as down interruptoble and up
—————————-
revision 1.10
date: 2014/09/17 16:17:59;  author: root;  state: Exp;  lines: +46 -47
removed the initialiaztion of variables qset_size,device_size and quantum_size
—————————-
revision 1.9
date: 2014/09/10 18:57:45;  author: root;  state: Exp;  lines: +1 -1
gave return corrected value
—————————-
revision 1.8
date: 2014/09/10 16:22:44;  author: root;  state: Exp;  lines: +2 -1
gave device_size.
—————————-
revision 1.7
date: 2014/09/10 11:24:56;  author: root;  state: Exp;  lines: +1 -1
declared device_size variable.
—————————-
revision 1.6
date: 2014/09/09 18:28:14;  author: root;  state: Exp;  lines: +4 -3
returned value of filep->f_pos .
—————————-
revision 1.5
date: 2014/09/09 18:21:50;  author: root;  state: Exp;  lines: +32 -15
copy from user with no of bytes less than quantum to increase accuracy of device.
—————————-
revision 1.4
date: 2014/09/09 17:42:03;  author: root;  state: Exp;  lines: +135 -6
changed quantum bytes allocation for last quantum .
—————————-
revision 1.3
date: 2014/09/04 08:03:48;  author: root;  state: Exp;  lines: +9 -7
fixed errors alot.
—————————-
revision 1.2
date: 2014/09/03 17:43:04;  author: root;  state: Exp;  lines: +1 -1
commented line to find user buff length.
—————————-
revision 1.1
date: 2014/09/03 17:34:23;  author: root;  state: Exp;
Initial revision
=============================================================================
RCS FOR DEV_SEEK

RCS file: ./dev_seek.c,v
Working file: ./dev_seek.c
head: 1.6
branch:
locks: strict
root: 1.6
access list:
symbolic names:
keyword substitution: kv
total revisions: 6;    selected revisions: 6
description:
lseek routine.
—————————-
revision 1.6    locked by: root;
date: 2014/09/22 12:10:25;  author: root;  state: Exp;  lines: +12 -5
modified according to new device_size.
—————————-
revision 1.5
date: 2014/09/17 16:18:44;  author: root;  state: Exp;  lines: +38 -20
implemneted seek end properly with right notations
now the offset in the app will be positive for seek_end case.
—————————-
revision 1.4
date: 2014/09/12 16:04:23;  author: root;  state: Exp;  lines: +8 -2
modified cases for SEEK_CUR.
modified case for SEEK_END.
—————————-
revision 1.3
date: 2014/09/12 15:21:31;  author: root;  state: Exp;  lines: +9 -1
include case for seek end/.
—————————-
revision 1.2
date: 2014/09/12 08:48:53;  author: root;  state: Exp;  lines: +4 -1
gave  case for seek current.
—————————-
revision 1.1
date: 2014/09/10 11:26:10;  author: root;  state: Exp;
Initial revision
=============================================================================
RCS FOR DEV_READ

RCS file: ./dev_read.c,v
Working file: ./dev_read.c
head: 1.13
branch:
locks: strict
root: 1.13
access list:
symbolic names:
keyword substitution: kv
total revisions: 13;    selected revisions: 13
description:
dev_read operartion.
—————————-
revision 1.13    locked by: root;
date: 2014/09/22 12:10:13;  author: root;  state: Exp;  lines: +19 -4
included down and up semaphore .
—————————-
revision 1.12
date: 2014/09/18 18:25:26;  author: root;  state: Exp;  lines: +5 -3
detected and corrected a loophole.
—————————-
revision 1.11
date: 2014/09/17 17:38:12;  author: root;  state: Exp;  lines: +2 -0
applied semaphore as down interruptible and up/
—————————-
revision 1.10
date: 2014/09/17 16:18:32;  author: root;  state: Exp;  lines: +34 -21
*** empty log message ***
—————————-
revision 1.9
date: 2014/09/12 15:48:16;  author: root;  state: Exp;  lines: +2 -3
removed increment arrqset from one condition.
redundant code removed.
—————————-
revision 1.8
date: 2014/09/12 15:24:18;  author: root;  state: Exp;  lines: +0 -1
*** empty log message ***
—————————-
revision 1.7
date: 2014/09/12 15:20:23;  author: root;  state: Exp;  lines: +27 -11
include case for noctr < quatnum_size.
BUT greater than temp..
—————————-
revision 1.6
date: 2014/09/12 10:21:00;  author: root;  state: Exp;  lines: +4 -4
changed the file_>f_pos values for different clauses.
—————————-
revision 1.5
date: 2014/09/12 10:15:43;  author: root;  state: Exp;  lines: +30 -26
modified the code for complete seek_set process.
—————————-
revision 1.4
date: 2014/09/12 08:47:33;  author: root;  state: Exp;  lines: +78 -67
modified code for reading pupose.
modified if the offset is zero.
if start == offset case completely correct.
—————————-
revision 1.3
date: 2014/09/11 16:04:24;  author: root;  state: Exp;  lines: +6 -3
passed the file pointer to function copy to user to update the f_pos value.
—————————-
revision 1.2
date: 2014/09/10 18:58:21;  author: root;  state: Exp;  lines: +48 -34
completed function copy to user
copy to user can now read from a given offset and can read any no of charcacters from the any position even no of charcters to be read can be 1 byte

—————————-
revision 1.1
date: 2014/09/10 16:24:31;  author: root;  state: Exp;
Initial revision
=============================================================================
RCS FOR CLEANUP

RCS file: ./cleanup.c,v
Working file: ./cleanup.c
head: 1.4
branch:
locks: strict
root: 1.4
access list:
symbolic names:
keyword substitution: kv
total revisions: 4;    selected revisions: 4
description:
unregistering the character driver.
—————————-
revision 1.4    locked by: root;
date: 2014/09/04 07:59:01;  author: root;  state: Exp;  lines: +2 -6
removed return from unregistering character device
—————————-
revision 1.3
date: 2014/09/03 18:08:55;  author: root;  state: Exp;  lines: +2 -1
gave prototypes for different functions.
—————————-
revision 1.2
date: 2014/09/03 15:56:52;  author: root;  state: Exp;  lines: +2 -1
deleted device using cdev_del.
—————————-
revision 1.1
date: 2014/09/03 05:24:18;  author: root;  state: Exp;
Initial revision
=============================================================================

rcs for server.

RCS file: ./server.c,v
Working file: ./server.c
head: 1.10
branch:
locks: strict
root: 1.10
access list:
symbolic names:
keyword substitution: kv
total revisions: 10;    selected revisions: 10
description:
ftp server
—————————-
revision 1.10    locked by: root;
date: 2014/10/06 16:04:13;  author: root;  state: Exp;  lines: +4 -2
now server is printing .
—————————-
revision 1.9
date: 2014/10/01 13:47:44;  author: root;  state: Exp;  lines: +13 -16
while loop added .
—————————-
revision 1.8
date: 2014/10/01 13:19:07;  author: root;  state: Exp;  lines: +12 -2
now the size of file is transfered first .
—————————-
revision 1.7
date: 2014/10/01 12:02:49;  author: root;  state: Exp;  lines: +39 -6
server sends the file contents in small packets to the client.
af-inet implemented successdully for one client as multithread application.
—————————-
revision 1.6
date: 2014/10/01 07:03:02;  author: root;  state: Exp;  lines: +1 -1
successfully sent the list of files to the client.
—————————-
revision 1.5
date: 2014/10/01 05:59:58;  author: root;  state: Exp;  lines: +24 -22
removed silly errors .
—————————-
revision 1.4
date: 2014/09/30 16:20:38;  author: root;  state: Exp;  lines: +24 -23
sent the list of files to client.
—————————-
revision 1.3
date: 2014/09/30 13:31:05;  author: root;  state: Exp;  lines: +12 -4
done with get and put commaands to client.
—————————-
revision 1.2
date: 2014/09/30 12:11:37;  author: root;  state: Exp;  lines: +45 -5
created threads to get the list of files in the specified directory.
—————————-
revision 1.1
date: 2014/09/30 11:32:01;  author: root;  state: Exp;
Initial revision
=============================================================================

rcs for client..

RCS file: ./client1.c,v
Working file: ./client1.c
head: 1.9
branch:
locks: strict
root: 1.9
access list:
symbolic names:
keyword substitution: kv
total revisions: 9;    selected revisions: 9
description:
this is the client1
—————————-
revision 1.9    locked by: root;
date: 2014/10/06 16:52:56;  author: root;  state: Exp;  lines: +8 -3
client recieving the file in new folder.
—————————-
revision 1.8
date: 2014/10/06 16:35:22;  author: root;  state: Exp;  lines: +5 -4
file will be downloaded in another folder
—————————-
revision 1.7
date: 2014/10/01 13:19:29;  author: root;  state: Exp;  lines: +6 -6
file size is recieved as well
—————————
revision 1.6
date: 2014/10/01 12:04:42;  author: root;  state: Exp;  lines: +36 -4
client recieved the file from the server.
—————————-
revision 1.5
date: 2014/10/01 07:03:23;  author: root;  state: Exp;  lines: +22 -17
sucessfully read list of files to be downloaded from server.
—————————-
revision 1.4
date: 2014/10/01 06:00:18;  author: root;  state: Exp;  lines: +20 -11
modified code a bit.
—————————-
revision 1.3
date: 2014/09/30 16:20:52;  author: root;  state: Exp;  lines: +13 -8
recieved the list of files from the server.
—————————-
revision 1.2
date: 2014/09/30 13:31:40;  author: root;  state: Exp;  lines: +15 -1
read the put and get commands from user.
send user the response get/put.
—————————-
revision 1.1
date: 2014/09/30 11:32:01;  author: root;  state: Exp;
Initial revision
=============================================================================

#include”header.h”

int main()
{
int choice,n=0;
struct node *start;
start=NULL;
printf(“\n ENTER THE SIZE OF CIRCULAR QUEUE\n”);
scanf(“%d”,&n);
while(1)
{
choice=getchoice();
operation(choice,&start,n);

}
return 0;
}

FUNCTION DEFINITIONS..

#include”header.h”
struct node *front,*rear=NULL;
struct node *temp =NULL;
int count=-1,flag=0,num=0;

int getchoice()
{
int choice;
printf(“\n1. CREATE “);
printf(“\n2. ENQUEUE”);
printf(“\n3. DEQUEUE “);
printf(“\n4. DISPLAY”);
printf(“\n0. EXIT\n”);
printf(“\n\n Enter your choice\n”);
scanf(” %d”,&choice);
return choice;
}
int operation(int choice ,struct node **start,int n)
{
switch(choice)
{
case 1 :  create(start);
break;
case 2 :  enqueue(start,n,choice);
break;
case 3 :  dequeue(start);
break;
case 4 :  display(start);
break;
case 0 : exit(0);
break;
default : printf(“\ninvalid operation”);
}
}

int create(struct node **start)
{
if(flag)
{
printf(“\n THE CIRCULAR QUEUE IS ALREADY CREATED!!”);
return -1;
}
if(!flag)
{
(*start)=NULL;
printf(“\n THE QUEUE CREATED SUCESSFULLY”);
flag=1;
}
}
int enqueue(struct node **start,int n,int choice)
{
if(flag)
{
if(num==0)
{
(*start)=(struct node *)malloc(sizeof(struct node));
printf(“\n ENTER THE VERY FIRST ELEMENT\n”);
scanf(“%d”,&((*start)->info));
(*start)->next=NULL;
rear=(*start);
front=(*start);
count++;
num=1;
return 0;
}
if(count==(n-1))
{
printf(“\n THE QUEUE IS FULL\n”);
return 0;
}
else
{
rear->next=malloc(sizeof(struct node));
rear=rear->next;
printf(“\n ENTER THE INFO : \n”);
scanf(“%d”,&(rear->info));
count++;
}
}
}

int dequeue(struct node **start)
{
if(flag)
{
if(front==rear)
{
if(count==(-1))
{
printf(“\n THE QUEUE IS EMPTY”);
return 0;
}
printf(“\n THE ELEMENT REMOVED IS %d”,front->info);
front=NULL;
rear=NULL;
num=0;
//    flag=0;
count–;

}

else if(front!=rear)
{
printf(“\n THE ELEMENT REMOVED IS %d”,front->info);
front = front->next;
count–;
}
}
if(!flag)
printf(“\nTHE QUEUE IS EMPTY….!!”);
}
int display(struct node **start)
{
if(flag)
{
if(front==NULL)
{
printf(“\n THE QUEUE IS EMPTY”);
return 0;
}
temp=front;
printf(“THE ELEMENTS ARE”);
while(temp!=rear)
{
printf(“–>  %d”,temp->info);
temp = temp->next;
}
if(temp==rear)
printf(“–> %d”,temp->info);
return 0;
}
if(!flag)
{    printf(“\n THE QUEUE IS EMPTY…!! NOTHING TO SHOW”);
}
}

#include”header.h”
int main()
{
int choice;
struct node *start;
start = (struct node *)malloc(sizeof(struct node));
start->next = NULL;
start->prev = NULL;
while(1)
{    choice = get_choice();
operation(choice,&start);
}
return 0;

}

FUNCTIONS DEFINITIONS

#include”header.h”
struct node *top=NULL;

int flag=0,count=0;
int get_choice()                                            //getchoice from user
{
int choice;
printf(“\n————STACK MENU————”);
printf(“\n 1. CREATE NODE”);
printf(“\n 2. PUSH”);
printf(“\n 3. POP”);
printf(“\n 4. DISPLAY”);
printf(“\n 0. EXIT”);
printf(“\n\n ENTER TOUR CHOICE\n”);
scanf(” %d”,&choice);
return choice;
}

int operation(int choice, struct node **start)                                //operations
{
switch(choice)
{    case 1 : create_node(start);
break;
case 2 : push(start);
break;
case 3 : pop(start);
break;
case 4 : display(start);
break;
case 0 : exit(0);
break;
default : printf(“\nENTER VALID OPTION”);
}

}

int create_node(struct node **start)                                    //create first node(first PUSH)
{

if(flag)
{    printf(“\n The Stack is already created.”);
}
if(flag==0)
{
struct node * new;
new=(struct node*)malloc(sizeof(struct node));
new->next=NULL;
new->prev = (*start);
(*start)->next = new;
top = new;
printf(“\nEnter the element in the node\n”);
scanf(“%d”,&(new-> info));
flag=1;
printf(“\nFirst element is pushed sucessfully”);
count=1;

}

}

int push(struct node **start)                                        //PUSH
{
if(count<10)
{    struct node *new;
new=(struct node *)malloc(sizeof(struct node));
new->next=NULL;
new->prev=top;
top->next=new;
top=top->next;
printf(“\nEnter the value of node\n”);
scanf(“%d”,&(top->info));
count++;
printf(“\n\nElement pushed successfully”);
}
else
{printf(“\nThe Stack is FULL..”);}

}

int pop(struct node **start)                                        //POP
{
int num;
if(top==(*start))
printf(“The Stack is Empty!!!”);
else
{
num=top->info;
top=top->prev;
top->next->prev=NULL;
top->next=NULL;
count–;
printf(“\nThe element popped is %d”,num);
}

}

int display(struct node **start)                                    //display
{
if(count==0)
printf(“\nThe Stack is empty”);
else
{    struct node *temp;
temp=top;
printf(“\nThe stack is –>”);
while(temp!=(*start))
{
printf(“->  %d”,temp->info);
temp=temp->prev;
}

}
}

#include<stdio.h>
#include<stdlib.h>
struct node
{
int info;
struct node * next;

};
int get_choice();
struct node * operation(int, struct node *);
struct node * create_node(struct node *);
struct node * insert_node(struct node*);
struct node * insert_beg(struct node*);
struct node * insert_end(struct node*);
struct node * insert_nth(struct node*);
struct node * insert_key(struct node*);
struct node * delete_node(struct node*);
struct node * del_beg(struct node *);
struct node * del_end(struct node *);
struct node * del_nth(struct node *);
struct node * del_key(struct node *);
struct node * display(struct node*);
struct node * sorting(struct node *);
struct node * sort_ascend(struct node *);
struct node * sort_descend(struct node *);
struct node * destroy(struct node *);

MAIN

#include”header.h”
int main()
{
struct node  * start;
start =  NULL;
int choice;
while(1)
{        choice = get_choice();
start=operation(choice,start);
}

}

FUNCTON DEFINITIONS

#include”header.h”
int flag=0;
int get_choice()                                        //getchoice from user
{
int choice;
printf(“\n—————_MENU————–\n”);
printf(”  1. CREATE LINK LIST\n”);
printf(”  2. INSERT\n”);
printf(”  3. DELETE\n”);
printf(”  4. SORT\n”);
printf(”  5. DISPLAY\n”);
printf(”  6. DESTROY\n”);
printf(”  0. Exit\n”);
printf(“\n\n  Enter your choice…\n”);

scanf(“%d”,&choice);
return choice;
}

struct node * operation(int choice,struct node *start )                    //operations
{

struct node * temp;
switch(choice)
{
case 1: temp=create_node(start);
break;
case 2: temp=insert_node(start);
break;
case 3: temp=delete_node(start);
break;
case 4: temp = sorting(start);
break;
case 5: temp=display(start);
break;
case 6: temp = destroy(start);
free(temp);
break;
case 0: exit(0);
default:printf(“\nINVALID OPTION”);

}return temp;

}

struct node * create_node(struct node *start)                            //create first node
{

if(flag)
{ printf(“link list is already created\n”);
}
if(flag==0)
{
start=(struct node*)malloc (sizeof(struct node));
printf(“enter the info of link list \n”);
scanf(“%d”, &(start->info));
start->next = NULL;
flag = 1;
printf(“link list created successfully\n”);
printf(“first element is %d\n”, start->info);
return start;

}
}

struct node * insert_node(struct node *start)                            //insert node menu
{
struct node *temp1;

if(flag==0)
printf(“linked list not created!\n”);
else
{
int choice;
printf(“___________INSERT MENU_______________\n”);
printf(“1. INSERT AT BEGGINING\n”);
printf(“2. INSERT AT END\n”);
printf(“3. INSERT AT NTH\n”);
printf(“4. INSERT AFTER KEY VALUE\n”);
printf(“\n\nEnter your choice…\n”);
scanf(“%d”,&choice);
switch(choice)
{
case 1:temp1 = insert_beg(start);
break;

case 2:temp1 = insert_end(start);
break;

case 3:temp1 = insert_nth(start);
break;

case 4:temp1 = insert_key(start);
break;
default : printf(“\nINVALID”);
}
return temp1;
}
}
struct node * insert_beg(struct node *start)                                //insert at begining
{
struct  node *b;
b=(struct node *)malloc(sizeof(struct node));
printf(“enter the element of node\n”);
scanf(“%d”,&(b->info));
b->next = start;
start = b;
return start;

}

struct node * display(struct node *start)                                //display
{
int num=0;
struct node *new,*temp;
temp=start;
new = start;
if(flag==0)
{    printf(“\nlink list is empty!!!\n”);
}
while(temp)
{    temp=temp->next;
num++;
}
//    printf(“\nthe number of nodes are %d”,num);
if(flag)
{
if(num==0)
{    printf(“\nList is empty !!!!”);
return start;
}
else
{    printf(“the link list is —>>”);
do
{
printf(” %d “, new->info);
new = new -> next;
}while(new!=NULL);
return start;
}
}
}

struct node * insert_end(struct node *start)                                //insert at end
{
struct node *b, *n;
n = start;
b=(struct node *)malloc(sizeof(struct node));
printf(“enter the info of node\n”);
scanf(“%d”,&(b->info));
printf(“\nthe last element is %d”,b->info);

while(n->next)
{     n=n->next;
}
n->next = b;
b->next = NULL;
return start;
}

struct node * insert_nth(struct node *start)                                //insert at nth node
{
int pos,i;
struct node *temp,*new,*b;
new=(struct node *)malloc(sizeof(struct node));
temp = start;
printf(“enter the position you want to insert at \n”);
scanf(“%d”,&pos);
for(i=1;i<pos-1;i++)
{     temp    = temp ->next;
}
b=temp->next;
printf(“enter the info of node\n”);
scanf(“%d”,&(new->info));
temp->next=new;
new->next=b;

printf(“link added successfully\n”);
return start;
}

struct node * insert_key(struct node *start)                                //insert after key
{
int key;
struct node *new,*temp,*b;
temp=start;
new=(struct node *)malloc(sizeof(struct node));
printf(“enter the key value \n”);
scanf(“%d”,&key);
while(key!= (temp->info))
{    temp=temp->next;
}
printf(“enter the info of the node\n”);
scanf(“%d”,&(new->info));
b=temp->next;
temp->next=new;
new->next=b;
return start;
}

struct node * delete_node(struct node *start)                                //delete node menu
{
int choice;
struct node *temp;

if(flag==0)
printf(“linked list empty!!!\n”);
else
{
printf(“———-DELETE MENU———–\n”);
printf(“1. Delete from begining\n”);
printf(“2. Delete from end\n”);
printf(“3. Delete nth node \n”);
printf(“4. Delete after key value\n”);
printf(“\n\nEnter your choice\n”);
scanf(“%d”,&choice);
switch(choice)
{
case 1 : temp = del_beg(start);
break;
case 2 : temp = del_end(start);
break;
case 3 : temp = del_nth(start);
break;
case 4 : temp = del_key(start);
break;
default : printf(“\nINVALID”);
}
return temp;
}
}

struct node *del_beg(struct node *start)                                //delete menu
{
struct node *temp;
temp=start;
int num=0;
while(temp)
{    temp= temp->next;
num++;
}

if(num==0)
printf(“nothing to delete\n”);
else
{    start = start->next;
return start;
}
}

struct node *del_end(struct node *start)                                //delete from end
{
struct node *temp;
temp = start;
int num=0;
while(temp)
{    temp= temp->next;
num++;
}
temp=start;
if(num==0)
{    printf(“\nnothing to delete”);
}
else
{    while(temp->next->next)
{    temp=temp->next;
}
temp->next=NULL;
return start;
}
}

struct node * del_nth(struct node *start)                                //delete nth node
{
int pos,i;
struct node *temp,*b;
temp = start;
int num=0;
while(temp)
{    temp= temp->next;
num++;
}
temp=start;
if(num==0)
printf(“\nnothing to delete”);
else
{    printf(“enter the position\n”);
scanf(“%d”,&pos);
for(i=1;i<pos;i++)
{    temp = temp->next;
}
b = temp->next;
temp=start;
for(i=1;i<pos-1;i++)
{    temp = temp->next;
}
temp->next=b;
return start;
}
}

struct node * del_key(struct node *start)                                //delete at key value
{
int key,num=0;
struct node *temp,*b;
temp=start;
if(num==0)
printf(“\nnothing to delete”);
else
{    printf(“enter the node to delete\n”);
scanf(“%d”,&key);
while(temp->info != key)
{    temp = temp->next;
}
if(!temp)
{    printf(“\nthe entered key not found”);
return start;
}
b=temp->next;
temp=start;
while(temp->next->info != key)
{    temp=temp->next;
}
temp->next=b;
return start;
}

}
struct node * sorting(struct node * start)                                //sorting menu
{
int choice;
struct node *temp;
printf(“\n————-SORTING MENU————–”);
printf(“\n1. sort ascending”);
printf(“\n2. sort descending”);
printf(“\n\nenter your choice”);
scanf(“%d”,&choice);
switch(choice)
{    case 1 : temp = sort_ascend(start);
break;
case 2 : temp = sort_descend(start);
break;
default : printf(“\nINVALID”);
}
return temp;

}

struct node * sort_ascend(struct node *start)                                 //sorting ascending order(bubble sort)
{
int count=0,j,i;
struct node *temp,*b;
b=(struct node *)malloc(sizeof(struct node ));
b->next=NULL;
temp = start;
while(temp)
{    temp=temp->next;
count++;
}
temp=start;
printf(“\nthe no of nodes are %d”,count);
if(!count)
printf(“\nThe Link list is empty!!!”);
else
{
for(j=0;j<count;j++)
{
for(i=0;i<count-j-1;i++)
{    if((temp->info) > (temp->next->info) )
{    b->info = temp->info;
temp->info = temp->next->info;
temp->next->info = b->info;
temp=temp->next;

}
else
temp=temp->next;
}
temp=start;
}
return start;
}
}

struct node * sort_descend(struct node *start)                                //sorting descending order(bubble sort)
{

int count=0,j,i;
struct node *temp,*b;
b=(struct node *)malloc(sizeof(struct node ));
b->next=NULL;
temp = start;
while(temp)
{    temp=temp->next;
count++;
}
temp=start;
printf(“\nthe no of nodes are %d”,count);
if(!count)
printf(“The Link list is empty!!!!”);
else
{
for(j=0;j<count;j++)
{
for(i=0;i<count-j-1;i++)
{    if((temp->info) < (temp->next->info) )
{    b->info = temp->info;
temp->info = temp->next->info;
temp->next->info = b->info;
temp=temp->next;

}
else
temp=temp->next;
}
temp=start;
}
return start;
}
}

struct node * destroy(struct node * start)                                //destroy link list
{
start=NULL;
printf(“\nThe Link List has been Destroyed”);
return start;

}