EmbLogic's Blog

created a communication medium between server and single client. client  sends request to the server to perform an operation.server after performing operations send the result back to the client .this result is again read by the client by using pipe.

simply opened file in server side and write the file.this file (file descriptor) is passed as argument through execl to the another program called client which than read the file using sscanf(and then lseek().

RCS file: 2.c,v
Working file: 2.c
head: 1.1
branch:
locks: strict
access list:
symbolic names:
keyword substitution: kv
total revisions: 1;     selected revisions: 1
description:
how a siglist work.
it contain all the 64 signals.
—————————-
revision 1.1
date: 2014/03/13 05:06:34;  author: root;  state: Exp;
Initial revision
=============================================================================

RCS file: ./sig_int.c,v
Working file: ./sig_int.c
head: 1.1
branch:
locks: strict
root: 1.1
access list:
symbolic names:
keyword substitution: kv
total revisions: 1;    selected revisions: 1
description:
signal 2 is called….
—————————-
revision 1.1    locked by: root;
date: 2014/03/11 04:58:38;  author: root;  state: Exp;
Initial revision

How to swap two numbers without using a temporary variable?

Given two variables, x and y, swap two variables without using a third variable.

Method 1 (Using Arithmetic Operators)
The idea is to get sum in one of the two given numbers. The numbers can then be swapped using the sum and subtraction from sum.

include <stdio.h>

int main()

{

  int x = 10, y = 5;

  // Code to swap 'x' and 'y'

  x = x + y;  // x now becomes 15

  y = x - y;  // y becomes 10

  x = x - y;  // x becomes 5

  printf("After Swapping: x = %d, y = %d", x, y);

  return 0;

}

Output:

After Swapping: x = 5, y = 10

Multiplication and division can also be used for swapping.

include <stdio.h>

int main()

{

  int x = 10, y = 5;

  // Code to swap 'x' and 'y'

  x = x * y;  // x now becomes 50

  y = x / y;  // y becomes 10

  x = x / y;  // x becomes 5

  printf("After Swapping: x = %d, y = %d", x, y);

  return 0;

}

Output:

After Swapping: x = 5, y = 10

Method 2 (Using Bitwise XOR)
The bitwise XOR operator can be used to swap two variables. The XOR of two numbers x and y returns a number which has all the bits as 1 wherever bits of x and y differ. For example XOR of 10 (In Binary 1010) and 5 (In Binary 0101) is 1111 and XOR of 7 (0111) and 5 (0101) is (0010).

#include <stdio.h>

int main()

{

  int x = 10, y = 5;

  // Code to swap 'x' (1010) and 'y' (0101)

  x = x ^ y;  // x now becomes 15 (1111)

  y = x ^ y;  // y becomes 10 (1010)

  x = x ^ y;  // x becomes 5 (0101)

  printf("After Swapping: x = %d, y = %d", x, y);

  return 0;

}

Output:

After Swapping: x = 5, y = 10

Problems with above methods
1) The multiplication and division based approach doesn’ work if one of the numbers is 0 as the product becomes 0 irrespective of the other number.

2) Both Arithmetic solutions may cause arithmetic overflow. If x and y are too large, addition and multiplication may go out of integer range.

3) When we use pointers to variable and make a function swap, all of the above methods fail when both pointers point to the same variable. Let’s take a look what will happen in this case if both are pointing to the same variable.

// Bitwise XOR based method
x = x ^ x; // x becomes 0
x = x ^ x; // x remains 0
x = x ^ x; // x remains 0

// Arithmetic based method
x = x + x; // x becomes 2x
x = x – x; // x becomes x

x = x – x; // x becomes 0

Let us see the following program.

#include <stdio.h>

void swap(int *xp, int *yp)

{

    *xp = *xp ^ *yp;

    *yp = *xp ^ *yp;

    *xp = *xp ^ *yp;

}

int main()

{

  int x = 10;

  swap(&x, &x);

  printf("After swap(&x, &x): x = %d", x);

  return 0;

}

Output:

After swap(&x, &x): x = 0

Swapping a variable with itself may needed in many standard algorithms. For example see this implementation of QuickSort where we may swap a variable with itself. The above problem can be avoided by putting a condition before the swapping.

#include <stdio.h>

void swap(int *xp, int *yp)

{

    if (xp == yp) // Check if the two addresses are same

      return;

    *xp = *xp + *yp;

    *yp = *xp - *yp;

    *xp = *xp - *yp;

}

int main()

{

  int x = 10;

  swap(&x, &x);

  printf("After swap(&x, &x): x = %d", x);

  return 0;

Output:

After swap(&x, &x): x = 10

RCS file: ser.c,v
Working file: ser.c
head: 1.9
branch:
locks: strict
akshat: 1.9
access list:
symbolic names:
keyword substitution: kv
total revisions: 9;    selected revisions: 9
description:
IPC- INTERPROCESS COMMUNICATION, communication btw two processes invoking a fork call and then hijacking that child process for one way communication.
—————————-
revision 1.9    locked by: akshat;
date: 2014/03/09 05:44:19;  author: akshat;  state: Exp;  lines: +18 -3
creation of another pipe on same server.
its working.
—————————-
revision 1.8
date: 2014/03/09 04:15:57;  author: akshat;  state: Exp;  lines: +12 -2
Creating another pipe for passing requests of client 1.
client 2 will process these requests.
server will then output the result to client 1.
—————————-
revision 1.7
date: 2014/03/07 21:51:57;  author: akshat;  state: Exp;  lines: +11 -7
read and write fd are sent simultaneously.
—————————-
revision 1.6
date: 2014/03/07 17:01:18;  author: akshat;  state: Exp;  lines: +1 -1
trying to pass both the arguments.
—————————-
revision 1.5
date: 2014/03/07 16:47:34;  author: akshat;  state: Exp;  lines: +6 -6
using wait statement for parent, process not hanged.
pipe created successfully.
—————————-
revision 1.4
date: 2014/03/07 16:43:15;  author: akshat;  state: Exp;  lines: +11 -7
its working, but process hangs.
checking for it.
—————————-
revision 1.3
date: 2014/03/07 16:31:13;  author: akshat;  state: Exp;  lines: +4 -2
lets see if its working
—————————-
revision 1.2
date: 2014/03/07 16:28:02;  author: akshat;  state: Exp;  lines: +9 -3
pipe is formed.
client is formed by hijacking the child.
—————————-
revision 1.1
date: 2014/03/07 15:21:25;  author: akshat;  state: Exp;
Initial revision
=============================================================================