 |
| Figure 1: Singly Linked List |
 |
| Figure-1: Singly Linked List |
cur_ptr = HEAD->NEXT prev_ptr = NULL forever: if cur_ptr == NULL break tmp_ptr = prev_ptr prev_ptr = cur_ptr cur_ptr = cur_ptr->NEXT prev_ptr->NEXT = tmp_ptr HEAD->NEXT = prev_ptrComplexity:
 |
| Figure-2: After reversing the Singly Linked List |
 |
| Robert Floyd |
./a.outWhen a process runs as background process then it runs by itself without any user interaction. The user can check its status but he doesn't (need to) know what it is doing. To run a.out in background we execute as shown below.
$ ./a.out & [1] 3665As shown above when we run a process with & at the end then the process runs in background and returns the process id (3665 in above example).
pid=fork(); if (pid<0) exit(1); /* fork error */ if (pid>0) exit(0); /* parent exits */ /* child (daemon) continues */
#include <stdio.h>
int main()
{
return 0;
}
$ gcc test.c
$ size a.out
text data bss dec hex filename
836 260 8 1104 450 a.out
Now add a global variable as shown below#include <stdio.h>
int global; /* Uninitialized variable stored in bss*/
int main()
{
return 0;
}
$ gcc test.c
$ size a.out
text data bss dec hex filename
836 260 12 1108 454 a.out
As you can see BSS is incremented by 4 bytes. |
| Figure 1: Memory layout |
 |
| Figure 1: Current Doubly Linked List |
HEAD->FIRST = HEAD->FIRST->NEXT NODE-2->PREV = NULL decrement(HEAD->LENGTH)Output:
 |
| Figure 2: After deleting the First Node in the List. |
 |
| Figure 1: Empty List and the newNode we want to add |
HEAD->FIRST = newNode newNode->PREV = NULL newNode->NEXT = NULL increment(HEAD->LENGTH)
 |
| Figure 2: After adding newNode in Empty List. (Changes in BLUE) |
typedef struct node
{
struct node *prev;
void *data;
struct node *next;
}NODE;
typedef struct head
{
unsigned int length;
struct node *first;
}HEAD;
<kernel/notifier.c>
58 static int __kprobes notifier_call_chain(struct notifier_block **nl,
59 unsigned long val, void *v,
60 int nr_to_call, int *nr_calls)
61 {
62 int ret = NOTIFY_DONE;
63 struct notifier_block *nb, *next_nb;
64
65 nb = rcu_dereference(*nl);
66
67 while (nb && nr_to_call) {
68 next_nb = rcu_dereference(nb->next);
69 ret = nb->notifier_call(nb, val, v);
.
76 nb = next_nb;
77 nr_to_call--;
78 }
79 return ret;
80 }
<kernel/notifier.c>
186 int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
187 struct notifier_block *n)
188 {
.
199 down_write(&nh->rwsem);
200 ret = notifier_chain_register(&nh->head, n);
201 up_write(&nh->rwsem);
202 return ret;
203 }
204 EXPORT_SYMBOL_GPL(blocking_notifier_chain_register)
.
216 int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
217 struct notifier_block *n)
218 {
.
229 down_write(&nh->rwsem);
230 ret = notifier_chain_unregister(&nh->head, n);
231 up_write(&nh->rwsem);
232 return ret;
233 }
234 EXPORT_SYMBOL_GPL(blocking_notifier_chain_unregister);
<include/linux/notifier.h>
50 struct notifier_block {
51 int (*notifier_call)
(struct notifier_block *, unsigned long, void *);
52 struct notifier_block *next;
53 int priority;
54 };
A stack is a last in, first out (LIFO) abstract data type and data structure.Basic usage of stack at the Architecture level is as a means of allocating and accessing memory.
strace program-nameFor example let us trace ls command.
$ strace ls
execve("/bin/ls", ["ls"], [/* 39 vars */]) = 0
brk(0) = 0x82d4000
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7787000
access("/etc/ld.so.preload", R_OK) = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY) = 3
fstat64(3, {st_mode=S_IFREG|0644, st_size=76503, ...}) = 0
mmap2(NULL, 76503, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7774000
close(3) = 0
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
access("/etc/ld.so.nohwcap", F_OK) = -1 ENOENT (No such file or directory)
open("/lib/libselinux.so.1", O_RDONLY) = 3
read(3, "177ELF111���������3�3�1���@G��004���"..., 512) = 512
fstat64(3, {st_mode=S_IFREG|0644, st_size=104148, ...}) = 0
mmap2(NULL, 109432, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x41d000
mmap2(0x436000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x18) = 0x436000
close(3) = 0
.
.
fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7613000
write(1, "01.c a.outn", 1201.c a.out
) = 12
close(1) = 0
munmap(0xb7613000, 4096) = 0
close(2) = 0
exit_group(0) = ?
In the above example we are not displaying the complete output of strace command. Even though output from strace looks very complicated, this is only due to many system calls made when loading shared libraries. However, once we have found which system calls are the important ones (mainly open, read, write and the like), the results will look fairly intuitive to us.strace –p <pid-of-the-application>For e.g
#include <stdio.h>
#include <unistd.h>
int main()
{
sleep(20);
return 0;
}
We will compile the above code and run it as a background process. Then we try to monitor the program using its process id as shown below.$ gcc main.c $ ./a.out & [1] 1885 $ strace -p 1885 Process 1885 attached - interrupt to quit restart_syscall(<... resuming interrupted call ...>) = 0 exit_group(0) = ? Process 1885 detached [1]+ Done ./a.outIn contrast to a debugger, strace does not need a program's source code to produce human-readable output.
#include <stdio.h>
int main(void)
{
FILE *fd = NULL;
if(fd = fopen("test","rw"))
{
printf("TEST file openedn");
fclose(fd);
}
else
{
printf("Failed to open the filen");
}
return 0;
}
$ strace -c ./a.out Failed to open the file % time seconds usecs/call calls errors syscall ------ ----------- ----------- --------- --------- ---------------- 91.47 0.004000 4000 1 execve 8.53 0.000373 124 3 3 access 0.00 0.000000 0 1 read 0.00 0.000000 0 1 write 0.00 0.000000 0 3 1 open 0.00 0.000000 0 2 close 0.00 0.000000 0 3 brk 0.00 0.000000 0 1 munmap 0.00 0.000000 0 3 mprotect 0.00 0.000000 0 7 mmap2 0.00 0.000000 0 3 fstat64 0.00 0.000000 0 1 set_thread_area ------ ----------- ----------- --------- --------- ---------------- 100.00 0.004373 29 4 total
$ strace -o <output-file-name> <program-name>
$ strace -T ./a.out
execve("./a.out", ["./a.out"], [/* 39 vars */]) = 0 <0.003256>
.
brk(0x9db0000) = 0x9db0000 <0.000123>
open("test", O_RDONLY) = -1 ENOENT (No such file or directory) <0.000154>
fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0 <0.000125>
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb77d4000 <0.000121>
write(1, "Failed to open the filen", 24Failed to open the file
) = 24 <0.000258>
exit_group(0) = ?
$ strace -t ./a.out
execve("./a.out", ["./a.out"], [/* 39 vars */]) = 0 <0.003256>
.
brk(0x9db0000) = 0x9db0000 <0.000123>
open("test", O_RDONLY) = -1 ENOENT (No such file or directory) <0.000154>
fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0 <0.000125>
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb77d4000 <0.000121>
write(1, "Failed to open the filen", 24Failed to open the file
) = 24 <0.000258>
exit_group(0) = ?
$ strace –e trace=’open,close’ <program-name>Similarly we can also use negation option to not trace specific system calls. If we don’t want to trace open() system call in previous example we can give the below command
$ strace -e trace='!open,close' ./a.outCheck the man page of strace for other options.
Functions that are visible only to other functions in the same file are known as static functions.
#include "header.h"func.c
int main()
{
hello();
return 0;
}
#include "header.h"header.h
void hello()
{
printf("HELLO WORLD\n");
}
#include <stdio.h>If we compile above code it fails as shown below
static void hello();
$gcc main.c func.cIt fails in Linking since function hello() is declared as static and its definition is accessible only within func.c file but not for main.c file. All the functions within func.c can access hello() function but not by functions outside func.c file.
header.h:4: warning: "hello" used but never defined
/tmp/ccaHx5Ic.o: In function `main':
main.c:(.text+0x12): undefined reference to `hello'
collect2: ld returned 1 exit status
#include <stdio.h>
#include <stdlib.h>
//Structure containing a Data part & a
//Link part to the next node in the List
struct Node
{
int Data;
struct Node *Next;
}*Head;
// Counting number of elements in the List
int length()
{
struct Node *cur_ptr;
int count=0;
cur_ptr=Head;
while(cur_ptr != NULL)
{
cur_ptr=cur_ptr->Next;
count++;
}
return(count);
}
// Deleting a node from List depending upon the data in the node.
int delNodeData(int num)
{
struct Node *prev_ptr, *cur_ptr;
cur_ptr=Head;
while(cur_ptr != NULL)
{
if(cur_ptr->Data == num)
{
if(cur_ptr==Head)
{
Head=cur_ptr->Next;
free(cur_ptr);
return 0;
}
else
{
prev_ptr->Next=cur_ptr->Next;
free(cur_ptr);
return 0;
}
}
else
{
prev_ptr=cur_ptr;
cur_ptr=cur_ptr->Next;
}
}
printf("\nElement %d is not found in the List", num);
return 1;
}
// Deleting a node from List depending upon the location in the list.
int delNodeLoc(int loc)
{
struct Node *prev_ptr, *cur_ptr;
int i;
cur_ptr=Head;
if(loc > (length()) || loc <= 0)
{
printf("\nDeletion of Node at given location is not possible\n ");
}
else
{
// If the location is starting of the list
if (loc == 1)
{
Head=cur_ptr->Next;
free(cur_ptr);
return 0;
}
else
{
for(i=1;i<loc;i++)
{
prev_ptr=cur_ptr;
cur_ptr=cur_ptr->Next;
}
prev_ptr->Next=cur_ptr->Next;
free(cur_ptr);
}
}
return 1;
}
//Adding a Node at the end of the list
void addEnd(int num)
{
struct Node *temp1, *temp2;
temp1=(struct Node *)malloc(sizeof(struct Node));
temp1->Data=num;
// Copying the Head location into another node.
temp2=Head;
if(Head == NULL)
{
// If List is empty we create First Node.
Head=temp1;
Head->Next=NULL;
}
else
{
// Traverse down to end of the list.
while(temp2->Next != NULL)
temp2=temp2->Next;
// Append at the end of the list.
temp1->Next=NULL;
temp2->Next=temp1;
}
}
// Adding a Node at the Beginning of the List
void addBeg(int num)
{
struct Node *temp;
temp=(struct Node *)malloc(sizeof(struct Node));
temp->Data = num;
if (Head == NULL)
{
//List is Empty
Head=temp;
Head->Next=NULL;
}
else
{
temp->Next=Head;
Head=temp;
}
}
// Adding a new Node at specified position
void addAt(int num, int loc)
{
int i;
struct Node *temp, *prev_ptr, *cur_ptr;
cur_ptr=Head;
if(loc > (length()+1) || loc <= 0)
{
printf("\nInsertion at given location is not possible\n ");
}
else
{
// If the location is starting of the list
if (loc == 1)
{
addBeg(num);
}
else
{
for(i=1;i<loc;i++)
{
prev_ptr=cur_ptr;
cur_ptr=cur_ptr->Next;
}
temp=(struct Node *)malloc(sizeof(struct Node));
temp->Data=num;
prev_ptr->Next=temp;
temp->Next=cur_ptr;
}
}
}
// Displaying list contents
void display()
{
struct Node *cur_ptr;
cur_ptr=Head;
if(cur_ptr==NULL)
{
printf("\nList is Empty");
}
else
{
printf("\nElements in the List: ");
//traverse the entire linked list
while(cur_ptr!=NULL)
{
printf(" -> %d ",cur_ptr->Data);
cur_ptr=cur_ptr->Next;
}
printf("\n");
}
}
//Reversesing a Linked List
void reverse()
{
struct Node *prev_ptr, *cur_ptr, *temp;
cur_ptr=Head;
prev_ptr=NULL;
while(cur_ptr != NULL)
{
temp=prev_ptr;
prev_ptr=cur_ptr;
cur_ptr=cur_ptr->Next;
prev_ptr->Next=temp;
}
Head=prev_ptr;
}
int main(int argc, char *argv[])
{
int i=0;
//Set HEAD as NULL
Head=NULL;
while(1)
{
printf("\n####################################################\n");
printf("MAIN MENU\n");
printf("####################################################\n");
printf(" \nInsert a number \n1. At the Beginning");
printf(" \n2. At the End");
printf(" \n3. At a Particular Location in the List");
printf(" \n\n4. Print the Elements in the List");
printf(" \n5. Print number of elements in the List");
printf(" \n6. Reverse the linked List");
printf(" \n\nDelete a Node in the List");
printf(" \n7. Delete a node based on Value");
printf(" \n8. Delete a node based on Location\n");
printf(" \n\n9. Exit\n");
printf(" \nChoose Option: ");
scanf("%d",&i);
switch(i)
{
case 1:
{
int num;
printf(" \nEnter a Number to insert in the List: ");
scanf("%d",&num);
addBeg(num);
display();
break;
}
case 2:
{
int num;
printf(" \nEnter the Number to insert: ");
scanf("%d",&num);
addEnd(num);
display();
break;
}
case 3:
{
int num, loc;
printf("\nEnter the Number to insert: ");
scanf("%d",&num);
printf("\nEnter the location Number in List at which \
the Number is inserted: ");
scanf("%d",&loc);
addAt(num,loc);
display();
break;
}
case 4:
{
display();
break;
}
case 5:
{
display();
printf(" \nTotal number of nodes in the List: %d",length());
break;
}
case 6:
{
reverse();
display();
break;
}
case 7:
{
int num;
printf(" \nEnter the number to be deleted from List: ");
scanf("%d",&num);
delNodeData(num);
display();
break;
}
case 8:
{
int num;
printf(" \nEnter the location of the node to \
be deleted from List: ");
scanf("%d",&num);
delNodeLoc(num);
display();
break;
}
case 9:
{
struct Node *temp;
while(Head!=NULL)
{
temp = Head->Next;
free(Head);
Head=temp;
}
exit(0);
}
default:
{
printf("\nWrong Option choosen");
}
}/* end if switch */
}/* end of while */
}/* end of main */
iptables -I INPUT -p tcp --dport 22 -m state --state NEW \
-m recent --set
iptables -I INPUT -p tcp --dport 22 -m state --state NEW \
-m recent --update --seconds 60 --hitcount 3 -j DROP
"--state NEW" – To make sure that only new connections are managed.iptables -I INPUT -p icmp --icmp-type echo-request \ -m recent --set iptables -I INPUT -p icmp --icmp-type echo-request \ -m recent --update --seconds 60 --hitcount 30 -j DROPIn above rules we dont use "--state NEW" since it is not needed in rate limiting number of ICMP echo requests.
iptables -I INPUT -p icmp --icmp-type echo-request \ -m limit !--limit 3/s -j ACCEPTWhen tuned correctly, this feature allows us to filter unusually high volumes of traffic that characterize denial of service (DOS) attacks and Internet worms.
double mean(double a, double b)
{
return (a+b) / 2;
}
calc_mean.hdouble mean(double, double);main.c - We are including our static library in this application.
#include <stdio.h>
#include "calc_mean.h"
int main(int argc, char* argv[]) {
double v1, v2, m;
v1 = 5.2;
v2 = 7.9;
m = mean(v1, v2);
printf("The mean of %3.2f and %3.2f is %3.2f\n", v1, v2, m);
return 0;
}
Creating the static librarygcc -c calc_mean.c -o calc_mean.oThen, using archiver (ar) we produce a static library (named libmean.a) out of the object file calc_mean.o.
ar rcs libmean.a calc_mean.oNOTE: A static library must start with the three letters 'lib' and have the suffix '.a'.
gcc -static main.c -L. -lmean -o mainNow run the executable program 'main'
$./main