PRACTICAL 1

Aim: Simulate the functioning of Lamport‟s Logical Clock in C

Algorithms:

1. A process increments its counter before each event in that process,When a process sends a message,
it includes its counter value with the message;

2. On receiving a message, the counter of the recipient is updated, if necessary, to the greater of its
current counter and the timestamp in the received message.

3. The counter is then incremented by 1 before the message is considered received.

Procedure:

#include<stdio.h>
#include<conio.h>
int max(int a,int b);
int main()
{
int i,j,k,p1[20],p2[20],e1,e2,dep[20][20];
printf("*** Lamport's Logical Clock ***\n");
printf("Enter the events : ");
scanf("%d %d",&e1,&e2);
for(i=0;i<e1;i++)
p1[i]=i+1;
for(i=0;i<e2;i++)
p2[i]=i+1;
printf("Enter the Dependency matrix:\n");
printf("\nEnter 1 if E1->E2 \nEnter -1, if E2->E1 \nElse Enter 0 \n\n");
printf(" ");
for(i=0;i<e2;i++)
printf(" e2%d",i+1);
for(i=0;i<e1;i++){
printf("\ne1%d ",i+1);
for(j=0;j<e2;j++){
scanf("%d",&dep[i][j]);
}
}
for(i=0;i<e1;i++){
for(j=0;j<e2;j++){
//change the Time stamp if dependency exist
if(dep[i][j]==1){
p2[j]=max(p2[j],p1[i]+1);
for(k=j;k<e2;k++)
p2[k+1]=p2[k]+1;
}
//change the Time stamp if dependency exist
if(dep[i][j]==-1){
 p1[i]=max(p1[i],p2[j]+1);
for(k=i;k<e1;k++)
p2[k+1]=p1[k]+1;
}
}
}
//to print the outcome of Lamport Logical Clock
printf("\nP1 : ");
for(i=0;i<e1;i++){
printf("%d",p1[i]);
}
printf("\nP2 : ");
for(j=0;j<e2;j++)
printf("%d",p2[j]);
getch();
return 0 ;
}
//to find the maximum timestamp between two events
int max(int a, int b)
{
if (a>b)
return a;
else
return b;

}
Output:
PRACTICAL 2:

Aim: Simulate the Distributed Mutual Exclusion in C

Distributed mutual exclusion algorithms must deal with unpredictable message delays and
incomplete knowledge of the system state. Three basic approaches for distributed mutual
exclusion:

1) Token based approach

2) Non-token based approach

3 )Quorum based approach Token-based approach

Algorithms :

1. Pushing its request in its own queue (ordered by time stamps)

2. Sending a request to every node.

3. Waiting for replies from all other nodes.

4. If own request is at the head of its queue and all replies have been received, enter critical
section.

5. Upon exiting the critical section, remove its request from the queue and send a release
message to every process.

#include <stdio.h>

#include<stdlib.h>

#include<pthread.h>

void *functionC();

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

int counter = 0;

main()

int rc1, rc2;

pthread_t thread1, thread2;

/* Create independent threads each of which will execute functionC */

if( (rc1=pthread_create( &thread1, NULL, &functionC, NULL)) )

{ printf("Thread creation failed: %d\n", rc1); }

if( (rc2=pthread_create( &thread2, NULL, &functionC, NULL)) )

{ printf("Thread creation failed: %d\n", rc2); }

/* Wait till threads are complete before main continues. Unless we */

/* wait we run the risk of executing an exit which will terminate */

/* the process and all threads before the threads have completed. */

pthread_join( thread1, NULL);

pthread_join( thread2, NULL);

exit(0); }

void *functionC()

pthread_mutex_lock( &mutex1 );

counter++;

printf("Counter value: %d\n",counter); pthread_mutex_unlock( &mutex1 ); }

Compile: cc -lpthread mutex1.c Run: ./a.out

Results:

Counter value: 1 Counter value: 2 join1.c

#include<stdio.h>

#include<pthread.h>

#define NTHREADS 10

void *thread_function(void *);

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;

int counter = 0;

main() {

pthread_t thread_id[NTHREADS];

int i, j;

for(i=0; i < NTHREADS; i++) {

pthread_create( &thread_id[i], NULL, thread_function, NULL );}

for(j=0; j < NTHREADS; j++) { pthread_join( thread_id[j], NULL); }

/* Now that all threads are complete I can print the final result. */

/* Without the join I could be printing a value before all the threads */

/* have been completed.*/ printf("Final counter value: %d\n", counter); }

void *thread_function(void *dummyPtr) {

printf("Thread number %ld\n", pthread_self());

pthread_mutex_lock( &mutex1 );

counter++; pthread_mutex_unlock( &mutex1 ); }

Compile:cc-lpthreadjoin1.c Run:./a.out

Results:
Thread number 1026

Thread number 2051

Thread number 3076

Thread number 4101

Thread number 5126

Thread number 6151

Thread number 7176

Thread number 8201

Thread number 9226

Thread number 10251

Final counter value: 10

cond1.c

#include<stdio.h>

#include<stdlib.h>

#include<pthread.h>

pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;

void *functionCount1();

void *functionCount2();
int count = 0;

#define COUNT_DONE 10 #define COUNT_HALT1 3

#define COUNT_HALT2 6 main()

{ pthread_t thread1, thread2; pthread_create( &thread1, NULL, &functionCount1, NULL);

pthread_create( &thread2, NULL, &functionCount2, NULL); pthread_join( thread1, NULL);

pthread_join( thread2, NULL); printf("Final count: %d\n",count);

exit(0);}

// Write numbers 1-3 and 8-10 as permitted by functionCount2()

void *functionCount1() {

for(;;) {

// Lock mutex and then wait for signal to relase mutex pthread_mutex_lock( &count_mutex );

// Wait while functionCount2() operates on count

// mutex unlocked if condition varialbe in functionCount2()

signaled. pthread_cond_wait( &condition_var, &count_mutex );

count++;

printf("Counter value functionCount1: %d\n",count); pthread_mutex_unlock( &count_mutex );

if(count >= COUNT_DONE) return(NULL); } }

// Write numbers 4-7

void *functionCount2() {

for(;;) {

pthread_mutex_lock( &count_mutex );

if( count < COUNT_HALT1 || count > COUNT_HALT2 ) {

// Condition of if statement has been met. // Signal to free waiting thread by freeing the
mutex. //

pthread_cond_signal( &condition_var ); }

else { count++; printf("Counter value functionCount2: %d\n",count); }

pthread_mutex_unlock( &count_mutex );

if(count >= COUNT_DONE) return(NULL); } }

Compile: cc -lpthread cond1.c Run: ./a.out Results:
Counter value functionCount1: 1

Counter value functionCount1: 2

Counter value functionCount1: 3

Counter value functionCount2: 4

Counter value functionCount2: 5

Counter value functionCount2: 6

Counter value functionCount2: 7

Counter value functionCount1: 8

Counter value functionCount1: 9

Counter value functionCount1: 10

Final count: 10 .
PRACTICAL 3:

Aim: Implement a Distributed Chat Server using TCP Sockets in C.

TCP is a connection-oriented protocol that provides a reliable. flow of data between two
computers. Example applications that. use such services are HTTP, FTP, and Telnet.

Program : ►SOURCE CODE

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#define PORT 5555

#define MAXMSG 512

Intread_from_client (int filedes)

char buffer[MAXMSG];

int nbytes;

nbytes = read (filedes, buffer, MAXMSG);

if (nbytes < 0){

perror ("read");

exit (EXIT_FAILURE);

else if (nbytes == 0)

return -1;

else

fprintf (stderr, "Server: got message: `%s'\n", buffer);

return 0;
}}

int

main (void){

extern int make_socket (uint16_t port);

int sock;

fd_set active_fd_set, read_fd_set;

int i;

struct sockaddr_in clientname;

size_t size;

sock = make_socket (PORT); if (listen (sock, 1) < 0)

perror ("listen");

exit (EXIT_FAILURE);

FD_ZERO (&active_fd_set);

FD_SET (sock, &active_fd_set);

while (1)

read_fd_set = active_fd_set;

if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)

perror ("select");

exit (EXIT_FAILURE);

for (i = 0; i < FD_SETSIZE; ++i)

if (FD_ISSET (i, &read_fd_set)){

if (i == sock){

int new;
size = sizeof (clientname);

new = accept (sock,

(struct sockaddr *) &clientname,

&size);

if (new < 0){

perror ("accept");

exit (EXIT_FAILURE);}

fprintf (stderr,

"Server: connect from host %s, port %hd.\n",

inet_ntoa (clientname.sin_addr),

ntohs (clientname.sin_port));

FD_SET (new, &active_fd_set);}

Else{

if (read_from_client (i) < 0) { close (i);

FD_CLR (i, &active_fd_set);

}}}}}
PRACTICAL 4:

Aim: Implement RPC mechanism for a file transfer across a network in ‘C’

//SERVER FILENAME: server.c

#include"rpc/rpc.h"
#include"square.h"
#include"stdio.h"
#include"stdlib.h"
#include"math.h"

square_out *squareproc_1_svc(square_in *inp,struct svc_req *rqstp)

{
static square_out out;
out.res1= inp->arg1 * inp->arg1;
return(&out);
}

// CLIENT FILENAME: client.c

#include"errno.h"
#include"rpc/rpc.h"
#include"square.h"
#include"stdio.h"
#include"stdlib.h"
#include"math.h"

int main(int argc,char **argv)

{
CLIENT *cl;
square_in in;
square_out *outp;
f(argc!=3)
{
printf("\n\n error:insufficient arguments!!!");
exit(-1);
 }

cl=clnt_create(argv[1],SQUARE_PROG,SQUARE_VERS,"tcp");
in.arg1=atol(argv[2]);

if(cl==NULL)
{
printf("\nerror:%s",strerror(errno));
exit(-1);
}

if((outp=squareproc_1(&in,cl))==NULL)
{
printf("\nerror :%s",clnt_sperror(cl,argv[1]));
exit(-1);
}

printf("\n\n result is : %ld",outp->res1);

exit(0);
}

// .h FILENAME: square.h

struct square_in
{
/*input arg*/
long arg1;
};

struct square_out
{
/*op result*/
long res1;
};
program SQUARE_PROG
{
version SQUARE_VERS
{
square_out SQUAREPROC(square_in)=1; /*proc no=1*/
}=1; /*version no*/
}=0x31230000;/*prog no*/

Output & Execution :

[root@localhost~]#rpcgen -C square.x
[root@localhost~]#cc -c client.c -o client.o
[root@localhost~]#cc -c square_clnt.c -o square_clnt.o
[root@localhost~]#cc -c square_xdr.c -o square.xdr.o
[root@localhost~]#cc -o client client.o square_clnt.o square_xdr.o
[root@localhost~]#cc -c client.c server.c square_xdr.c
[root@localhost~]#cc -c server.c -o server.o
[root@localhost~]#cc -c square_svc.c -o square_svc.o
[root@localhost~]#cc -o server server.o square_svc.o square_xdr.o
[root@localhost~]#./server &
[1] 2264
[root@localhost~]#./client localhost 4
result is: 16
PRACTICAL 5:

Aim: Implement Java RMI mechanism for accessing methods of remote

systems.

RMI stands for Remote Method Invocation. It is a mechanism that allows an object residing in
one system (JVM) to access/invoke an object running on another JVM.

RMI is used to build distributed applications; it provides remote communication between Java
programs. It is provided in the package java.rmi.

Algorithm :

import java.rmi.*;

import java.rmi.server.*;

public class Hello extends UnicastRemoteObject implements HelloInterface {

private String message;

public Hello (String msg) throws RemoteException {

message = msg;

public String say() throws RemoteException {

return message;

}}

HelloClient.java

import java.rmi.Naming;

public class HelloClient

public static void main (String[] argv) {

try {

HelloInterface hello =(HelloInterface) Naming.lookup ("//192.168.10.201/Hello");

System.out.println (hello.say());

catch (Exception e){

System.out.println ("HelloClient exception: " + e);}

}}
HelloInterface.java

import java.rmi.*;

public interface HelloInterface extends Remote { public String say() throws RemoteException; }

HelloServer.java

import java.rmi.Naming;

public class HelloServer}

public static void main (String[] argv)

try {

Naming.rebind ("Hello", new Hello ("Hello,From Roseindia.net pvt ltd!"));

System.out.println ("Server is connected and ready for operation."); }
catch (Exception e)

System.out.println ("Server not connected: " + e);

}}}
PRACTICAL 6:

Aim: Simulate Balanced Sliding Window Protocol in C

Descriptions:

A sliding window protocol is a feature of packet-based data transmission protocols. Sliding

window protocols are used where reliable in-order delivery of packets is required, such as in

the Data Link Layer (OSI layer 2) as well as in the Transmission Control Protocol (TCP).

Conceptually, each portion of the transmission (packets in most data link layers, but bytes in

TCP) is assigned a unique consecutive sequence number, and the receiver uses the numbers to

place received packets in the correct order, discarding duplicate packets and identifying

missing ones. The problem with this is that there is no limit on the size of the sequence
number that can be required.

Program:

#include <STDIO.H>

#include <iostream.h>

#include <string>

#define THANKS -1

void main()

FILE *r_File1;

FILE *w_File2;

int m_framecount;

int frameCount = 0;

long currentP = 0;

long sentChar = 0;

long recvedChar = 0;

char s_name[100];

char d_name[100];

char *sp = s_name;

char *dp = d_name;

int slidingWin;

int frameSize;

int dataSize;

bool isEnd = false;

struct FRAME{

int s_flag;

intsequenceNo;

char data[90]

int n_flag;

};

FRAME frame;

frame.s_flag = 126;//set start flag

frame.n_flag = 126;//set end flag

memset(frame.data, 0, 91);//use 0 to fill full the member array in structure

frame. struct ACK{

int s_flag;

int nextSeq;

int n_flag;

}ack;

ack.s_flag = 126;

ack.n_flag = 126;

ack.nextSeq = NULL;

lable1 : cout <<"Please enter source file's name!"<<endl;

cin >> sp;

cout <<"Please enter destination file's

name!"<<endl; cin >> dp;

lable2: cout <<"Please chose size of sliding window 2--7"<<endl;

cin >> slidingWin;

if((slidingWin >7 )| (slidingWin < 2))

cout << "wrong enter"<<endl;

goto lable2;
}

lable3: cout<< "Please enter the size of frame 14--101 Only!" << endl;
cin >>frameSize;

if((frameSize > 101) | (frameSize < 14))

{ cout << "please enter right number!"<< endl;

goto lable3;

dataSize = frameSize - 12;

//dynamic generate a frame array with user enter's size of sliding

window FRAME *pf = new FRAME[slidingWin]; int seqNo = 0;

//strat loop for transmission.

while (ack.nextSeq != THANKS){

cout << "THE PROCESS ON SENDER SIDER..."<<endl;

//open a source file by read mode.

if((r_File1 = fopen(sp, "rb")) == NULL)

cout << "source file could not be opened please check it and re-start!" <<endl;

goto lable1;

else

cout<<"Opening a file for read...";

cout <<endl;

cout <<endl;

//after open the file, use fseek to resume the last position of a file pointer.

//Then start to read from that position.

fseek(r_File1,currentP,SEEK_SET);

//start loop for create frame array

for (int i = 0; i < slidingWin ; i++)// i is the frame array's index

frame.sequenceNo = seqNo;

if ((seqNo >= 7) == true)

{

seqNo = 0;//set sequencce number

else

seqNo = seqNo +1;

//This loop is used to fill the characters read from opened file to char array data
which //is a memeber of structure frame.

//we have to reseve a byte for \0 which is used to identify the end of the data array.

//that means each time we only read datasize -1 characters to the data array.

for (int j = 0; j < dataSize -1; j++)

{ //if it is not end of file read a character from file then save it into
data //field in frame structure.

frame.data[j]= fgetc(r_File1);

sentChar++;//calculate how many characters will be

sent.*/

if (frame.data[j]{

cout<< "There is the end of file"<<endl;

isEnd = true;

//sentChar++;

break;}

}if (isEnd == true)

pf[i] = frame; //save a frame into frame array.

//frameCount = i;

frameCount++;

m_framecount = i +1;

cout <<endl;
cout << "The squence number is " << pf[i].sequenceNo <<endl;
cout << "The start flag is " << pf[i].s_flag <<endl;

cout << "The Data is---->" << pf[i].data <<endl;

cout << "The end flag is " << pf[i].n_flag <<endl;

cout << "There are " <<frameCount <<" frames has been created!"<<endl;

cout << "frame " << pf[i].sequenceNo <<" has been transported!";

cout<< endl;

fclose(r_File1);

break;

pf[i] = frame;//sava current frame to frame

buffer. //display some informaiton of frame
buffer. frameCount++;

m_framecount = i +1;

cout <<endl;

cout << "The squence number is " << pf[i].sequenceNo <<endl;

cout << "The start flag is " << pf[i].s_flag <<endl;

cout << "The Data is---->" << pf[i].data <<endl;

cout << "The end flag is " << pf[i].n_flag <<endl;

cout << "There are total " <<frameCount <<" frames has been created!"<<endl;

//cout << "frame " << pf[i].sequenceNo <<" has been

transported!"; cout<< endl;

currentP = ftell(r_File1);//to record the current position of a file pointer

fflush(r_File1);//refresh

//print out some information.

cout <<endl;

cout <<"Total " << sentChar << " characters have been sent on this session!"<<endl;
cout <<endl;

cout << "waiting for ACK!" <<endl;

cout <<endl;

cout <<endl;
int nextNoRecord = 0;

cout<<"THE PROCESS ON RECEIVER SIDE..."<<endl;

//open a file for write

if((w_File2 = fopen(dp, "ab")) != NULL)

cout<<"opening a file for write..."<<endl;

for (int m = 0; m < m_framecount ; m++){

for (int n = 0; n < dataSize -1; n++)

{//check whether islast character.

if(pf[m].data[n]

ack.nextSeq = THANKS;

//fputc(pf[m].data[n],w_File2);

recvedChar++;

break;

//write the character from current frame 's which in t index of data flied.

fputc(pf[m].data[n],w_File2);

recvedChar++;}

cout << "The string ---->" << pf[m].data <<" written succeed"<<endl;

fflush(w_File2);//refresh

if(ack.nextSeq == THANKS)

fclose(w_File2);

break;}

nextNoRecord= pf[m].sequenceNo;

cout <<endl;

cout <<"Total "<<recvedChar << " characters have been received on this session"<<endl;
cout <<endl;

cout << "send acknowledgement!" <<endl;

cout <<endl;

cout <<endl;

if (ack.nextSeq != THANKS)

cout<<"CheckACK"<<endl;

if (nextNoRecord

ack.nextSeq =0 ;

Else{

ack.nextSeq = nextNoRecord +1;

cout << "The next expect frame is " << ack.nextSeq <<endl;

else

{ cout<<"CheckACK"<<endl;

cout << "The acknowledgement is thanks. The transmission complete..."<<endl;

//delete the frame buffer array .

delete []pf;

}}

else

{cout << "File could not be opened" << endl;}

cout <<endl;

cout <<endl;

/*can be used to check how many bytes in the specified fill

numRead = 0;

fseek(r_File1,0,SEEK_END);

numRead = ftell(r_File1);

cout << "There are " << numRead <<" Bytes in the file" << endl;*/ }
►OUTPUT
1: use fixed source file name and fixed destination file name and fixed sliding

window size (5) to test program.

Read file successfully.

Create frames successfully.

Save frames into frame buffer which is size 5 successfully.

Write data from frames successfully.

Returns to ACK successfully.

Re-create new frames successfully.

Search the end of source file successfully.

2: use keyboard to input the “source file name”, “destination file name”,
“sliding windows size”, and “frame size” to test program
Read file successfully.
Create frames successfully.

Save frames into frame buffer which is size 5 successfully.

Write data from frames successfully.

Returns to ACK successfully. Re-

create new frames successfully.
Search the end of source
successfully.
PRACTICAL 7:

Aim: Implement CORBA mechanism by using „C++‟ program at one end

and „Java‟ program on the other.

Description:

CORBA is essentially a design specification for an Object Request Broker (ORB), where an ORB
provides the mechanism required for distributed objects to communicate with one another,
whether locally or on remote devices, written in different languages, or at different locations
on a network.

Program:

Creating the Server

#include <iostream>

#include "OB/CORBA.h"

#include <OB/Cosnaming.h>

#include "crypt.h"

#include "cryptimpl.h"

using namespace std;

int main(int argc, char** argv)

// Declare ORB and servant object

CORBA::ORB_var orb;
CryptographicImpl* CrypImpl = NULL;
try {

//Initialize the ORB.

orb = CORBA::ORB_init(argc, argv);

// Get a reference to the root POA

CORBA::Object_var rootPOAObj = orb-
>resolve_initial_references("RootPOA");

// Narrow it to the correct type

PortableServer::POA_var rootPOA =
PortableServer::POA::_narrow(rootPOAObj.in());
//Create POA policies
CORBA::PolicyList policies;

policies.length(1);

policies[0] =

rootPOA->create_thread_policy

(PortableServer::SINGLE_THREAD_MODEL);

// Get the POA manager object

PortableServer::POAManager_var manager = rootPOA->the_POAManager();

// Create a new POA with specified policies

PortableServer::POA_var myPOA = rootPOA->create_POA
("myPOA", manager, policies);

//Free policies
CORBA::ULong len = policies.length();

for (CORBA::ULong i = 0; i < len; i++)

policies[i]->destroy();

// Get a reference to the Naming Service

root_context CORBA::Object_var rootContextObj =
orb->resolve_initial_references("NameService");

// Narrow to the correct type

CosNaming::NamingContext_var nc =
CosNaming::NamingContext::_narrow(rootContextObj.in());

//Create a reference to the servant

CrypImpl = new CryptographicImpl(orb);

// Activate object

PortableServer::ObjectId_var myObjID =myPOA->activate_object(CrypImpl);

// Get a CORBA reference with the POA through the servant

CORBA::Object_var o = myPOA->servant_to_reference(CrypImpl);// The reference is

converted to a character string

CORBA::String_var s = orb->object_to_string(o);

cout << "The IOR of the object is: " << s.in() << endl;

CosNaming::Name name;

name.length(1);
name[0].id = (const char *) "CryptographicService";
name[0].kind = (const char *) "";

// Bind the object into the name

service nc->rebind(name,o);

//Activate the POA

manager->activate();

cout << "The server is ready.

Awaiting for incoming requests..." << endl;

// Start the ORB

orb->run();

} catch(const CORBA::Exception& e) {

//Handles CORBA exceptions

cerr << e << endl;

// Decrement reference
count if (CrypImpl)
CrypImpl->_remove_ref();

//End CORBA
if (!CORBA::is_nil(orb)){

try{

orb->destroy();

cout << "Ending CORBA..." << endl;

} catch (const CORBA::Exception& e)

{cout << "orb->destroy() failed:" << e << endl; return 1;

return 0;

Implementing the Client

#include <iostream>

#include <string>

#include "OB/CORBA.h"
#include "OB/Cosnaming.h"

#include "crypt.h"

using namespace std;

int main(int argc, char** argv)

// Declare ORB
CORBA::ORB_var orb;
try {

//Initialize the ORB

orb = CORBA::ORB_init(argc, argv);

// Get a reference to the Naming Service CORBA::Object_var

rootContextObj = orb-
>resolve_initial_references("NameService");
CosNaming::NamingContext_var nc =
CosNaming::NamingContext::_narrow(rootContextObj.in());
CosNaming::Name name;

name.length(1);

name[0].id = (const char *) "CryptographicService";

name[0].kind = (const char *) "";

// Invoke the root context to retrieve the object

reference CORBA::Object_var managerObj = nc-
>resolve(name);

// Narrow the previous object to obtain the correct

type ::CaesarAlgorithm_var manager =
::CaesarAlgorithm::_narrow(managerObj.in()); string
info_in,exit,dummy;

CORBA::String_var info_out;
::CaesarAlgorithm::charsequence_var
inseq; unsigned long key,shift;

try{

do{

cout << "\nCryptographic service client" << endl;

cout << "----------------------------" << endl;

do{ // Get the cryptographic

key if (cin.fail())

{
cin.clear();

cin >> dummy;

cout << "Enter encryption key: ";

cin >> key;

} while (cin.fail());
do{ // Get the shift

if (cin.fail())

cin.clear();

cin >> dummy;

cout << "Enter a shift: ";

cin >> shift;

} while (cin.fail());

// Used for debug

pourposes //key =
9876453;

//shift = 938372;

getline(cin,dummy); // Get the text to encrypt

cout << "Enter a plain text to encrypt: ";

getline(cin,info_in);

// Invoke first remote

method inseq = manager-
>encrypt
(info_in.c_str(),key,shift);

cout << "------------------------------------------" <<

endl;

cout << "Encrypted text is: " <<

inseq->get_buffer() << endl;

//Invoke second remote method

info_out = manager->decrypt(inseq.in(),key,shift);
cout << "Decrypted text is: "

<< info_out.in() << endl;

cout << "-------------------------------------------"

<< endl;

cout << "Exit? (y/n): ";

cin >> exit;

} while (exit!="y");

// Shutdown server message

manager->shutdown()

} catch(const std::exception& std_e){

cerr << std_e.what() << endl;

}catch(const CORBA::Exception& e) {

// Handles CORBA exceptions

cerr << e << endl;}
//End CORBA
if (!CORBA::is_nil(orb)){

try{

orb->destroy();

cout << "Ending CORBA..." << endl;

} catch(const CORBA::Exception& e)

{cout << "orb->destroy failed:" << e << endl; return 1;

}}

return 0;}

►OUTPUT
Running the Client-server Application Once we have implemented the client and the server,
it‟s time to connect them. Because our demonstration client and server exchange object
references via the naming service, we must ensure that the naming service (which is called
nameserv in Orbacus) is running. We use some command-line options to tell the naming
service the host and port on which it should listen. nameserv -OAhost localhost -OAport 8140
After this, we can start the server with a command-line option to tell it how to contact the
naming service. server -ORBInitRef NameService=corbaloc:iiop:localhost:8140/NameService
Finally we can start the client, again with a command-line option to tell it how to contact the
naming service. client -ORBInitRef NameService=corbaloc:iiop:localhost:8140/NameService