root@mrinmoy-H310M-H-2-0:/home/mrinmoy/cnas2# netstat -atpn | grep sone

tcp 0 0 192.168.78.139:50001 0.0.0.0:* LISTEN

3314/./sone
tcp 0 0 192.168.78.139:50001 192.168.78.139:37484 ESTABLISHED
3314/./sone
root@mrinmoy-H310M-H-2-0:/home/mrinmoy/cnas2# netstat -atpn | grep stwo
root@mrinmoy-H310M-H-2-0:/home/mrinmoy/cnas2# netstat -axpn | grep stwo
root@mrinmoy-H310M-H-2-0:/home/mrinmoy/cnas2# netstat -aupn | grep stwo
udp 2304 0 0.0.0.0:50000 0.0.0.0:*
3423/./stwo
root@mrinmoy-H310M-H-2-0:/home/mrinmoy/cnas2# netstat -atpn | grep q3s
tcp 0 0 192.168.78.139:50001 0.0.0.0:* LISTEN
3601/./q3s
root@mrinmoy-H310M-H-2-0:/home/mrinmoy/cnas2# netstat -aupn | grep q4s
udp 0 0 0.0.0.0:50000 0.0.0.0:*
3680/./q4s
root@mrinmoy-H310M-H-2-0:/home/mrinmoy/cnas2#

q1>>>>

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

#define BUFFERSIZE 1024 // arbitrary

int main(int argc, char *argv[])

{
int sd; // to be used as socket descriptor
ssize_t i,j;
int n;
char buffer[BUFFERSIZE];
struct sockaddr_in server_addr; // An IPv4 address

if( argc != 3 )
{
printf("Usage: %s server-address server-port \n", argv[0] );
printf("Example: %s 172.16.4.11 12345 \n", argv[0] );
exit(1);
}

printf( "TCP-echo-client starting...\n" );

// A TCP (IPv4 stream) socket is created

sd = socket( PF_INET, SOCK_STREAM, IPPROTO_TCP );
if( sd == -1 ) { perror("socket-call"); exit( 1 ); }
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons( atoi(argv[2]) );
n = inet_aton( argv[1], &(server_addr.sin_addr) );
if( n == 0 ) { printf("inet_aton-Invalid address\n"); exit(1); }
 n = connect( sd, (struct sockaddr *) &server_addr,
sizeof(server_addr) );
if( n == -1 ) { perror("connect-call"); exit(1); }
write( STDOUT_FILENO, "Enter the string:", 17 );

// clear buffer before reading

memset( buffer, '\0', BUFFERSIZE );
i = read( STDIN_FILENO, buffer, BUFFERSIZE );
if( i == -1 ) { perror("read1"); exit(1); }
printf( "bytes read from keyboard=%lu\n", i );

// write contents of buffer on server's socket

j = write( sd, buffer, i );
if( j == -1 ) { perror("write1"); exit(1); }
printf("bytes written in server's socket=%lu\n",j);

// clear buffer before reading

memset( buffer, '\0', BUFFERSIZE );
// read from server's socket into buffer
i = read( sd, buffer, BUFFERSIZE );
if( i == -1 ) { perror("read2"); exit(1); }
printf("bytes read from server's socket=%lu\n", i );

write( STDOUT_FILENO,"Reply from echo server->", 24 );

j = write( STDOUT_FILENO, buffer, i );
if( j == -1 ) { perror("write2"); exit(1); }

// Shutdown the both-way ( duplex ) connection.

shutdown(sd, SHUT_RDWR);

return 0;
}

q2>>>>

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>

#define SIZE 512

//#define RECVFROM_FULL
//#define RECVFROM_STRIPPED
//#define RECV
//#define READ

int main( int argc, char *argv[])

{
int sd; // to be used as socket descriptor
int n;
ssize_t i;
char buffer[SIZE];
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;

#ifdef RECVFROM_FULL
 struct sockaddr_in remote_addr;
socklen_t remote_addr_length;
unsigned long nbo;
unsigned long hbo;
char *host_addr;
#endif

if( argc != 3 )
{
printf("usage -> prog-name server-address server-port \n");
printf("example -> %s 192.168.5.58 7 \n", argv[0] );
exit(1);
}

// an IPv4 datagram socket (UDP socket) is created

sd = socket( PF_INET, SOCK_DGRAM, IPPROTO_UDP );

if( sd == -1 ) { perror("socket-call"); exit(1); }

client_addr.sin_family = AF_INET;
client_addr.sin_addr.s_addr = htonl( INADDR_ANY ); // all interfaces
client_addr.sin_port = htons(0); // any free port

n = bind( sd, (struct sockaddr *) &client_addr,

sizeof(client_addr) );
if( n == -1 ) { perror("bind-call"); exit(1); }

write( STDOUT_FILENO,"Enter a string: ", 16 );

memset( buffer, '\0', SIZE );
i = read( STDIN_FILENO, buffer, SIZE );

server_addr.sin_family = AF_INET;
n = inet_aton( argv[1], &(server_addr.sin_addr) );
if( n == 0 ) { perror("invalid-address"); exit(1); }
server_addr.sin_port = htons( atoi(argv[2]) );

n = sendto( sd, buffer, i, 0, ( struct sockaddr *) &server_addr,

sizeof( server_addr) );
if( n == -1 ) { perror("sendto-call"); exit(1); }

printf("%s: Sent %u bytes to server \n", argv[0], n);

n = 0;

memset( buffer, '\0', SIZE );

#ifdef RECVFROM_FULL
printf("%s: Using recvfrom() call in full form \n", argv[0] );
remote_addr_length = sizeof(remote_addr);
n = recvfrom( sd, buffer,SIZE, MSG_PEEK,
(struct sockaddr *) &remote_addr,
&remote_addr_length );
 if( n == -1 ) { perror("recvfrom-call-full"); exit(1); }

printf("AF_INET = %u \n", AF_INET);

printf("rf-full: remote address family = %u\n",

remote_addr.sin_family );

nbo = remote_addr.sin_addr.s_addr;
printf("rf-full: remote address in network byte order ");
printf("= %lX Hex \n", nbo );

hbo = ntohl(remote_addr.sin_addr.s_addr);
printf("rf-full: remote address in host byte order = %lX Hex \n",
hbo );

host_addr = inet_ntoa(remote_addr.sin_addr);

printf("rf-full: remote address in dotted decimal quad = %s \n",

host_addr );
printf("rf-full: remote port in network byte order = %X Hex \n",
remote_addr.sin_port );

printf("rf-full: remote port in host byte order = %X Hex\n",

ntohs(remote_addr.sin_port) );

printf("rf-full: remote address length = %u bytes\n",

remote_addr_length );
#endif

#ifdef RECVFROM_STRIPPED
printf("%s: Using recvfrom() call in stripped form\n", argv[0]);

n = recvfrom( sd, buffer,SIZE, 0, NULL, 0 );

if( n == -1 ) { perror("recvfrom-call-stripped"); exit(1); }
#endif

#ifdef RECV
printf("%s: Using recv() call \n", argv[0]);

n = recv( sd, buffer, SIZE, MSG_PEEK );

if( n == -1 ) { perror("recvfrom-call-stripped"); exit(1); }
#endif
#ifdef READ
printf("%s: Using read() call \n", argv[0] );

n = read( sd, buffer, SIZE);

if( n == -1 ) { perror("read-call"); exit(1); }
#endif

printf("%s: Received %u bytes from server \n", argv[0], n );

write( STDOUT_FILENO, "From server->", 13 );
write( STDOUT_FILENO, buffer, n );

shutdown( sd, SHUT_RDWR );

return 0;
}

q3>>>

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

#define ETH0 "192.168.78.139"

#define SERVER_PORT 50001

#define BUFFERSIZE 1024

int main( int argc, char *argv[] )
{
int ser_sd;

int tempsockfd, n ;

socklen_t clientlength;
ssize_t i, j ;
char buffer[BUFFERSIZE];
struct sockaddr_in server_addr, client_addr;

if( argc != 1 )
{
printf("usage: %s \n", argv[0] );
exit(1);
}

// a TCP socket( IPv4 stream socket ) is created

ser_sd = socket( PF_INET, SOCK_STREAM, IPPROTO_TCP );
if( ser_sd == -1 ) { perror("socket-call"); exit(1); }

server_addr.sin_family = AF_INET;

n = inet_aton( ETH0, &(server_addr.sin_addr) );

if( n == 0 ) { printf("inet_aton: Invalid address\n"); exit(1); }

server_addr.sin_port = htons(SERVER_PORT);

n = bind( ser_sd,
(struct sockaddr *) & server_addr,
sizeof(server_addr) );
if( n == -1) { perror("bind-call"); exit(1); }
 n = listen( ser_sd, 5 );
if( n == -1 ) { perror("listen-call"); exit(1); }

clientlength = sizeof(client_addr);

while ( 1 ) // endless loop

{
printf( "%s : waiting for client's request on port %u \n",
argv[0], SERVER_PORT );

tempsockfd = accept( ser_sd,

(struct sockaddr *)&client_addr,
&clientlength );
if( tempsockfd == -1 ) { perror("accept-call"); }

memset( buffer, '\0', BUFFERSIZE );

i = read( tempsockfd, buffer, BUFFERSIZE );

if( i == -1 ) { perror("socket-read"); exit(1); }

j = write( STDOUT_FILENO,"Received from client->", 22 );

if( j == -1 ) { perror("screen-write"); exit(1); }

printf("%s \n", buffer );

j = write( tempsockfd, buffer, i );

if( j == -1 ) { perror("socket-write"); exit(1); }

n = shutdown(tempsockfd,SHUT_RDWR);
if ( n == -1 ) { perror("shutdown"); exit(1); }

n = close(tempsockfd);
if( n == -1 ) { perror("close-tempsockfd"); exit(1); }
}

// close(ser_sd);
exit(0);
} // end of main

nc -t 192.168.78.139 50001
hi
hi
q4>>>>

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define SERVER_PORT 50000

#define BUFFERSIZE 512 // no more than this

extern int errno;

int main( int argc, char *argv[] )

{
int ser_sd;
struct sockaddr_in server_addr, client_addr;
socklen_t clientlength;
char buffer[BUFFERSIZE];
ssize_t i, j ;
int n;

// an IPv4 datagram socket ( UDP socket ) is created

ser_sd = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
if( ser_sd == -1 ) { perror("socket-call"); exit(1); }

server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(SERVER_PORT);

n = bind( ser_sd, (struct sockaddr *) & server_addr,

sizeof(server_addr) );

clientlength = sizeof(client_addr);
while( 1 ) // endless loop
{
printf("%s: using UDP port-%u \n", argv[0], SERVER_PORT );
memset( buffer, '\0', BUFFERSIZE );
i = recvfrom( ser_sd, buffer, BUFFERSIZE,0,
(struct sockaddr *) &client_addr, &clientlength );
if( i == -1 ) perror("recvfrom-call");

printf("client's IP address = %s \n",

inet_ntoa(client_addr.sin_addr) );
printf("client's port = %u \n",
ntohs(client_addr.sin_port) );
 j = write( STDOUT_FILENO, "received from client-> ", 23 );
if( j == -1 ) perror("write-stdout");

printf("%s \n", buffer );

j = sendto( ser_sd, buffer, i, 0,

(struct sockaddr *) &client_addr, clientlength);
if( j == -1 ) perror("sendto-call");
} // end of while block

close( ser_sd );
exit(0);
}

nc -u 192.168.78.139 50000
hi
hi