Implement TCP Client-Server

TCP Client.cpp

#include<stdio.h>
#include<sys/socket.h>
#include<iostream.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netbd.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<errno.h>
#define MAX 100

main(int argc.char*argv)
{
int sockfd,n;
char buff[100];
struct sockaddr_in serv;

if(argc!=3)
{
printf("\n Error ! usage:./a.out<IP ADDRESS><PORT>\n");
exit(0);
}

if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("\n Error ! Socket not created...\n");
exit(0);
}

bzero(&serv,sizeof(serv));
serv.sin_family=AF_INET;
serv.sin_port=htons(atoi9argv[2]));

if(inet_pton(AF_INET,argv[1],&serv.sin_addr)<0)
{
printf("\n Errorin conversion of IP address from string to num\n");
exit(0);
}

if(connect(sockfd,(struct sockaddr*)&serv,sizeof(serv))<0)
{
printf("\n Error ! can not established...\n");
exit (0);
}

printf("\n connected..\n");
strcpy(buff,"abc");





while(strcmp(buff,"bye")!=0)
{
cout<<"\n Client:";
gets(buff);
write(sockfd,buff,strlen(buff));
cout<<"\n Server:";
n=read(sockfd,buff,100);
buff[n]='\0';
cout<<buff;

if(n<0)
{
cout<<"\n Read Error";
exit (0);
}
}
cout<<"\n";
return 0;
}

TCP Server.cpp

#include<iostream.h>
#include<stdio.j>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<time.h>

int main()
{
int listenfd,connfd,n;
struct sockaddr_in serv;
char buff[100];
int port=1058;
listenfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&serv,sizeof(serv));
serv.sin_family=AF_INET;
serv.sin_addr.s_addr=htonl(INADDR_ANY);
serv.sin_port=htons(port);
bind(listenfd,(struct sockaddr*)&serv,sizeof(serv));
listen(listenfd,15);

while(1)
{
connfd=accept(listenfd,(struct sockaddr*)NULL,NULL);
cout<<"\nConx.Open!]n";
int child;

if((child=fork())<0)
{
cout<<"\nChild disaster!";
exit(1);
}




else if(child==0)
{
close(listenfd);
strcpy(buff,"abc");

while(strcmp(buff,"bye")!=0)
{
if(strcmp(buff,"bye")==0) break;
n=read(connfd,buff,100);
buff[n]='\0';
cout<<"\nClient:"<<buff;
cout<<"Server:";
gets(buff);
write(connfd,buff,strlen(buff));
}

cout<<"\n\n Conx closed!";
close(connfd);
exit(0);
}

close(connfd);
}
return 0;
}

OUTPUT SCREEN:-

Server side:

[cseb58@localhost cseb58]$ TCPserver.cpp
[cseb58@localhost cseb58]$ ./a.out
conx open!
Client : hai server!
cliebt : bye

Client side:

[cseb58@localhost cseb58]$ TCPclient.cpp
[cseb58@localhost cseb58]$ ./a.out 127.0.0.1 1858
connected
server:hai
server:see you

Implement UDP Client-Server

UDP Client.c

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<time.h>
#include<errno.h>
#define MAX 100

int main(int argc,char* argv[])
{
int sockfd;
char str[100];
struct sockaddr_in serv_addr;

if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
printf("client:can't open datagram socket");

bzero((char *) &serv_addr,sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=inet_addr(argv[1]);;
serv_addr.sin_port=htons(atoi(argv[2]));;

/*if(bind(sockfd,(struct sockaddr*) &cli_addr,sizeof(cli_addr))<0)
printf("client:can't bind the local address");*/

printf("enter message to server:");
gets(str);

if(sendto(sockfd,str,100,0,(struct sockaddr*) &serv_addr,sizeof(serv_addr))<0)
{
printf("\nError connection not established...\n");
exit(0);
  }
  printf("\nconnected\n");
close(sockfd);
exit(0);
return 0;
}

UDP Server.c

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<time.h>
#define MAX 100

int cwork(int);

int main()
{
int sockmain,sockclient,child,n;
struct sockaddr_in serv;
char str[100];
int port=4055;
if((sockmain=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("server cannot open main socket!");
exit(0);
}
bzero(&serv,sizeof(serv));
serv.sin_family=AF_INET;
serv.sin_addr.s_addr=htonl(INADDR_ANY);
serv.sin_port=htons(port);

for(;;)
{
n=sizeof(serv);
sockclient=recvfrom(sockmain,str,100,0,(struct sockaddr*)&serv,&n);
if(sockclient<0)
{
printf("bad client socket");
exit(0);
}
if((child=fork())<0)
{
printf("failed to create child");
exit(0);
}
else if (child==0)
{
close(sockmain);
n=cwork(sockclient);
close(sockclient);
exit(0);
}
close(sockclient);
}
return 0;
}






#define LEN 100

int cwork(int sockclient)
{
char buf[LEN];
int msglen;
bzero(buf,LEN);
if((msglen=recv(sockclient,buf,LEN,0))<0)
{
printf("Bad recv by child");
exit(1);
}
printf("\nsocket used: %d",sockclient);
buf[msglen]='\0';
printf("\nmessage : %s",buf);
strcpy(buf,"message received ...");
send(sockclient,buf,strlen(buf),0);
return 0;
}


OUTPUT SCREEN:-

cc UDPserver.c
./a.out

UDP socket created……...listening port 4001
Server received the message: hello
From client: hello
Server: hey
Server received the message: HowRU?
From client: HowRU?
Server: fine.
Server received the message: bye
From client: bye
Server: bye

Implement FTP Client-Server

FTP Client.c

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<time.h>
#define MAX 100;

main(int argc,char**argv)
{
int sockfd,n,connfd;
char str[100],str1[100],s[2];
struct sockaddr_in serv;
if(argc!=5)
{
exit(0);
}
if(sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("\n Error ! Socket not created...\n");
exit (0);
}
bzero(&serv,sizeof(serv));
serv.sin_family=AF_INET;
serv.sin_port=htons(atoi(argv[2]));
if(inet_pton(AF_INET,argv[1],&serv.sin_addr)<=0)
{
printf("\n error in conversion of IP address from string to num\n"),
exit(0);
}
if(connect(sockfd,(struct sockaddr*)&serv,sizeof(serv))<0)
{
printf("\n Error!Conx not established...\n);
exit(0);
}
printf("\n connected...sending file name%s\n",argv[3]);
write(sockfd,argv[],strlen(argv[3]));    read(sockfd,s,3);
write(sockfd,argv[4],strlen(argv[4]));
str1[0]='\0';
while((n=read(sockfd,str,100))>0)
{
str[n]='\0';
printf("%s\n",str);
write(sockfd,str,strlen(str));
}
if(n<0)
printf("\n Read error...\n");
exit (0);
}


FTP Server.c

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<time.h>
#define MAX 100;

int main ()
{
int listenfd,connfd,n,nl;
struct sockaddr_in serv;
char str1 [100],str2[100],fname[20],fname1[20],s[2],
int port=9999;
FILE*f1*f2;
listenfd=socket(AF_INET,SOCK_STREAM,0);
bzero(&serv,sizeof(serv);
serv.sin_family=AF_INET;
serv.sin_addr.s_addr=htonl(INADDR_ANY);
serv.sin_port=htons(port);
bind(listenfd,(struct sockaddr*)&serv,sizeof(serv));
"serftp4.cpp"54L, 1518C
listen(listenfd,5);
for(;;)
{
connfd=accept(listenfd,(struct sockaddr*)NULL,NULL);
printf("\nClient requesting");
n=read(connfd,fname,20);
fname(n)='\0';
printf("\n Received:%s\n",fname);
f1=fopen(fname)."r");
strcpy(s,"ab");
write(connfd,s,strlen(s));
n1=read(connfd,fname1,20);
fname1[n1]=;\0';
printf("stored in:%s\n"'fname 1);
f2=fopen(fname1,"w");
while(!feof(f1))
{
fgets(str1,50f1);
write(connfd,str,1,strlen(str1));
n=read(connfd,str,2,100);
str2[n]='\0';
fputs(str2,f2);
}
fclose(f1);
fclose(f2);
close(connfd);
}
return 0;
}


OUTPUT SCREEN:-

Server Side:

[cseb17@localhost cseb 17]$ cc FTPserver.c
[cseb17@localhost cseb 17]$.a/out
Client requesting
Received:new.c
Stored in : thanga.c

Client side:

[cseb17@localhost cseb 17]$cc FTPclient.c
[cseb17@localhost cseb 17]$./a.out 127.0.0.1 6142 new.c.thanga.c

connected...sending filename new.c
hai how are you?

Implement Multicast Communication

Sender.cpp

#include <iostream>
#include <sstream>
#include <string>
#include <boost/asio.hpp>
#include "boost/bind.hpp"
#include "boost/date_time/posix_time/posix_time_types.hpp"

const short multicast_port = 30001;
const int max_message_count = 10;

class sender
{
public:
  sender(boost::asio::io_service& io_service,
      const boost::asio::ip::address& multicast_address)
    : endpoint_(multicast_address, multicast_port),
      socket_(io_service, endpoint_.protocol()),
      timer_(io_service),
      message_count_(0)
  {
    std::ostringstream os;
    os << "Message " << message_count_++;
    message_ = os.str();

    socket_.async_send_to(
        boost::asio::buffer(message_), endpoint_,
        boost::bind(&sender::handle_send_to, this,
          boost::asio::placeholders::error));
  }

  void handle_send_to(const boost::system::error_code& error)
  {
    if (!error && message_count_ < max_message_count)
    {
      timer_.expires_from_now(boost::posix_time::seconds(1));
      timer_.async_wait(
          boost::bind(&sender::handle_timeout, this,
            boost::asio::placeholders::error));
    }
  }

  void handle_timeout(const boost::system::error_code& error)
  {
    if (!error)
    {
      std::ostringstream os;
      os << "Message " << message_count_++;
      message_ = os.str();

      socket_.async_send_to(
          boost::asio::buffer(message_), endpoint_,
          boost::bind(&sender::handle_send_to, this,
            boost::asio::placeholders::error));
    }
  }

private:
  boost::asio::ip::udp::endpoint endpoint_;
  boost::asio::ip::udp::socket socket_;
  boost::asio::deadline_timer timer_;
  int message_count_;
  std::string message_;
};

int main(int argc, char* argv[])
{
  try
  {
    if (argc != 2)
    {
      std::cerr << "Usage: sender <multicast_address>\n";
      std::cerr << "  For IPv4, try:\n";
      std::cerr << "    sender 239.255.0.1\n";
      std::cerr << "  For IPv6, try:\n";
      std::cerr << "    sender ff31::8000:1234\n";
      return 1;
    }

    boost::asio::io_service io_service;
    sender s(io_service, boost::asio::ip::address::from_string(argv[1]));
    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

Receiver.cpp

#include <iostream>
#include <string>
#include <boost/asio.hpp>
#include "boost/bind.hpp"

const short multicast_port = 30001;

class receiver
{
public:
  receiver(boost::asio::io_service& io_service,
      const boost::asio::ip::address& listen_address,
      const boost::asio::ip::address& multicast_address)
    : socket_(io_service)
  {
    // Create the socket so that multiple may be bound to the same address.
    boost::asio::ip::udp::endpoint listen_endpoint(
        listen_address, multicast_port);
    socket_.open(listen_endpoint.protocol());
    socket_.set_option(boost::asio::ip::udp::socket::reuse_address(true));
    socket_.bind(listen_endpoint);


    // Join the multicast group.
    socket_.set_option(
        boost::asio::ip::multicast::join_group(multicast_address));

    socket_.async_receive_from(
        boost::asio::buffer(data_, max_length), sender_endpoint_,
        boost::bind(&receiver::handle_receive_from, this,
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));
  }

  void handle_receive_from(const boost::system::error_code& error,
      size_t bytes_recvd)
  {
    if (!error)
    {
      std::cout.write(data_, bytes_recvd);
      std::cout << std::endl;

      socket_.async_receive_from(
          boost::asio::buffer(data_, max_length), sender_endpoint_,
          boost::bind(&receiver::handle_receive_from, this,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));
    }
  }

private:
  boost::asio::ip::udp::socket socket_;
  boost::asio::ip::udp::endpoint sender_endpoint_;
  enum { max_length = 1024 };
  char data_[max_length];
};

int main(int argc, char* argv[])
{
  try
  {
    if (argc != 3)
    {
      std::cerr << "Usage: receiver <listen_address> <multicast_address>\n";
      std::cerr << "  For IPv4, try:\n";
      std::cerr << "    receiver 0.0.0.0 239.255.0.1\n";
      std::cerr << "  For IPv6, try:\n";
      std::cerr << "    receiver 0::0 ff31::8000:1234\n";
      return 1;
    }

    boost::asio::io_service io_service;
    receiver r(io_service,
        boost::asio::ip::address::from_string(argv[1]),
        boost::asio::ip::address::from_string(argv[2]));
    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

Implement Producer-Consumer Problem

Producer.c

#include "shared.h"

void insert_item(int item, int semid, int *shared_buffer) {
  int index = get_buffer_size(shared_buffer);
  shared_buffer[index] = item;
}

int produce_item() {
  return 0xFF; // nothing dynamic just write a static integer a slot
}

int main(int argc, const char *argv[])
{
  int *shared_buffer = create_shared_mem_buffer();
  int semid = create_semaphore_set();

  clear_buffer(shared_buffer); // prepare buffer for jobs

  int item = 0;

  while(1) {
    item = produce_item();
    semop(semid, &downEmpty, 1);
    semop(semid, &downMutex, 1);
    insert_item(item, semid, shared_buffer);
    debug_buffer(shared_buffer);
    semop(semid, &upMutex, 1);
    semop(semid, &upFull, 1);
  }

  return EXIT_SUCCESS;
}

Consumer.c

#include "shared.h"

void consume_item(int item) {
  // do something with item
}

int remove_item(int semid, int *shared_buffer) {
  int index = get_buffer_size(shared_buffer) - 1;
  int item = shared_buffer[index];
  shared_buffer[index] = 0x00;
  return item;
}

int main(int argc, const char *argv[])
{
  int *shared_buffer = create_shared_mem_buffer();
  int semid = create_semaphore_set();



  int item = 0;

  while(1) {
    semop(semid, &downFull, 1);
    semop(semid, &downMutex, 1);
    item = remove_item(semid, shared_buffer);
    debug_buffer(shared_buffer);
    semop(semid, &upMutex, 1);
    semop(semid, &upEmpty, 1);
    consume_item(item);
  }

  return EXIT_SUCCESS;
}


Shared.h

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#define BUFFER_SIZE 5
#define EMPTY_ID 0
#define FULL_ID 1
#define MUTEX_ID 2
#define NSEM_SIZE 3

#define SHM_KEY 9
#define SEM_KEY "."

static struct sembuf downEmpty = { EMPTY_ID, -1, 0 };
static struct sembuf upEmpty = { EMPTY_ID, 1, 0 };
static struct sembuf upFull = { FULL_ID, 1, 0 };
static struct sembuf downFull = { FULL_ID, -1, 0 };
static struct sembuf downMutex = { MUTEX_ID, -1, 0 };
static struct sembuf upMutex = { MUTEX_ID, 1, 0 };

int *create_shared_mem_buffer();
int create_semaphore_set();
int get_buffer_size(int *sbuff);
void clear_buffer(int *sbuf);


Shared.c

#include "shared.h"

/**
 * returns current size of shared buffer
 */

int get_buffer_size(int *sbuff) {
  int i = 0;
  int counter = 0;



  for (i = 0; i < BUFFER_SIZE; ++i) {
    if (sbuff[i] == 0xFF) {
      counter++;
    }
  }
  return counter;
}

void debug_buffer(int *sbuff) {
  int i = 0;
  for (i = 0; i < BUFFER_SIZE; ++i) {
    if (sbuff[i] == 0xFF) printf("1");
  }
  printf("\n");
}

/**
 * returns a pointer to a shared memory buffer that the
 * producer can write to.
 */

int *create_shared_mem_buffer() {
  int *shmaddr = 0; /* buffer address */
  key_t key = SHM_KEY; /* use key to access a shared memory segment */

  int shmid = shmget(key, BUFFER_SIZE, IPC_CREAT | SHM_R | SHM_W); /* give create, read and write access */
  if (errno > 0) {
    perror("failed to create shared memory segment");
    exit (EXIT_FAILURE);
  }

  shmaddr = (int*)shmat(shmid, NULL, 0);
  if (errno > 0) {
    perror ("failed to attach to shared memory segment");
    exit (EXIT_FAILURE);
  }

  // clean out garbage memory in shared memory
  return shmaddr;
}

/**
 * only used in the producer to clean out garbage memory when
 * constructing initial buffer.
 */

void clear_buffer(int *sbuff) {
  int i = 0;
  for (i = 0; i < BUFFER_SIZE; ++i) sbuff[i] = 0x00;
}

/**
 * create FULL and EMPTY semaphores
 */

int create_semaphore_set() {
  key_t key = ftok(SEM_KEY, 'E');




  int semid = semget(key, NSEM_SIZE, 0600 | IPC_CREAT);
  if (errno > 0) {
    perror("failed to create semaphore array");
    exit (EXIT_FAILURE);
  }

  semctl(semid, FULL_ID, SETVAL, 0);
  if (errno > 0) {
    perror("failed to set FULL semaphore");
    exit (EXIT_FAILURE);
  }

  semctl(semid, EMPTY_ID, SETVAL, BUFFER_SIZE);
  if (errno > 0) {
    perror("failed to set EMPTY sempahore");
    exit (EXIT_FAILURE);
  }

  semctl(semid, MUTEX_ID, SETVAL, 1);
  if (errno > 0) {
    perror("failed to create mutex");
  }

  return semid;
}

Implement RMI using Java

ADDSERVERINTF.JAVA
import java.rmi.*;
public interface AddServerIntf extends Remote
{
public double add(double d1,double d2) throws RemoteException;
}

ADDSERVERIMP.JAVA
import java.rmi.*;
import java.rmi.server.*;
public class AddServerImp extends UnicastRemoteObject implements AddServerIntf
{
public AddServerImp() throws RemoteException
{
}
public double add(double d1,double d2) throws RemoteException
{
return d1+d2;
}
}
ADDSERVER.JAVA
import java.net.*;
import java.rmi.*;
public class AddServer
{
public static void main(String args[])
{
try
{
AddServerImp a1=new AddServerImp();
Naming.rebind("AddServer",a1);
}
catch(Exception e)
{
System.out.println(e);
}
}
}
ADDCLIENT.JAVA
import java.net.*;
import java.rmi.*;
public class AddClient
{
public static void main(String args[])
{
try
{
String u1="rmi://"+args[0]+"/AddServer";
AddServerIntf a1=(AddServerIntf)Naming.lookup(u1);
System.out.println("1st no."+args[1]);
System.out.println("2nd no."+args[2]);
double d1=Double.parseDouble(args[1]);
double d2=Double.parseDouble(args[2]);
System.out.println("the Sum is "+a1.add(d1,d2));
}
catch(Exception e)
{
System.out.println(e);
}
}
}