دوشنبه , 11 دسامبر 2017
سرخط خبرها
خانه - کامپیوتر - برنامه نویسی - پروژه فاینال استاد مهری یحیایی

پروژه فاینال استاد مهری یحیایی

tcp   udpبرنامه انتقال اطلاعات بین server و clint به وسیله دو پروتکل tcp , udp .این پروژه پروژه پایانی استاد مهری یحیایی مدرس شبکه های کامپیوتری در دانشگاه علمی کاربردی واحد سر دفتران و دفتر یاران در خرداد 91 بود در این قسمت قرار دادم تا اگر کسی بدردش خورد ازش استفاده کنه .ما را با نظرات سازنده خود یاری کنید.پیروز و موفق باشید .

برنامه  clint  در پروتکل  udp 

/****************udpclient.c********************/

/* Header files needed to use the sockets API. */

/*by                vahid ezati                teeteel.ir*/

/* File contain Macro, Data Type and Structure */

/* by definitions along with Function prototypes. */

/***********************************************/

#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 <netdb.h>

/* Host name of my system, change accordingly */

/* Put the server hostname that run the UDP server program */

/* This will be used as default UDP server for client connection */

#define SERVER "bakawali"

/* Server's port number */

#define SERVPORT 3333

/* Pass in 1 argument (argv[1]) which is either the */

/* address or host name of the server, or */

/* set the server name in the #define SERVER above. */

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

{

/* Variable and structure definitions. */

int sd, rc;

struct sockaddr_in serveraddr, clientaddr;

int serveraddrlen = sizeof(serveraddr);

char server[255];

char buffer[100];

char *bufptr = buffer;

int buflen = sizeof(buffer);

struct hostent *hostp;

memset(buffer, 0x00, sizeof(buffer));

/* 36 characters + terminating NULL */

memcpy(buffer, "Hello! A client request message lol!", 37);

/* The socket() function returns a socket */

/* descriptor representing an endpoint. */

/* The statement also identifies that the */

/* INET (Internet Protocol) address family */

/* with the UDP transport (SOCK_DGRAM) will */

/* be used for this socket. */

/******************************************/

/* get a socket descriptor */

if((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)

{

perror("UDP Client - socket() error");

/* Just exit lol! */

exit(-1);

}

else

printf("UDP Client - socket() is OK!\n");

/* If the hostname/IP of the server is supplied */

/* Or if(argc = 2) */

if(argc > 1)

strcpy(server, argv[1]);

else

{

/*Use default hostname or IP*/

printf("UDP Client - Usage %s <Server hostname or IP>\n", argv[0]);

printf("UDP Client - Using default hostname/IP!\n");

strcpy(server, SERVER);

}

memset(&serveraddr, 0x00, sizeof(struct sockaddr_in));

serveraddr.sin_family = AF_INET;

serveraddr.sin_port = htons(SERVPORT);

if((serveraddr.sin_addr.s_addr = inet_addr(server)) == (unsigned long)INADDR_NONE)

{

/* Use the gethostbyname() function to retrieve */

/* the address of the host server if the system */

/* passed the host name of the server as a parameter. */

/************************************************/

/* get server address */

hostp = gethostbyname(server);

if(hostp == (struct hostent *)NULL)

{

printf("HOST NOT FOUND --> ");

/* h_errno is usually defined */

/* in netdb.h */

printf("h_errno = %d\n", h_errno);

exit(-1);

}

else

{

printf("UDP Client - gethostname() of the server is OK... \n");

printf("Connected to UDP server %s on port %d.\n", server, SERVPORT);

}

memcpy(&serveraddr.sin_addr, hostp->h_addr, sizeof(serveraddr.sin_addr));

}

/* Use the sendto() function to send the data */

/* to the server. */

/************************************************/

/* This example does not use flags that control */

/* the transmission of the data. */

/************************************************/

/* send request to server */

rc = sendto(sd, bufptr, buflen, 0, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

if(rc < 0)

{

perror("UDP Client - sendto() error");

close(sd);

exit(-1);

}

else

printf("UDP Client - sendto() is OK!\n");

printf("Waiting a reply from UDP server...\n");

/* Use the recvfrom() function to receive the */

/* data back from the server. */

/************************************************/

/* This example does not use flags that control */

/* the reception of the data. */

/************************************************/

/* Read server reply. */

/* Note: serveraddr is reset on the recvfrom() function. */

rc = recvfrom(sd, bufptr, buflen, 0, (struct sockaddr *)&serveraddr, &serveraddrlen);

if(rc < 0)

{

perror("UDP Client - recvfrom() error");

close(sd);

exit(-1);

}

else

{

printf("UDP client received the following: \"%s\" message\n", bufptr);

printf(" from port %d, address %s\n", ntohs(serveraddr.sin_port), inet_ntoa(serveraddr.sin_addr));

}

/* When the data has been received, close() */

/* the socket descriptor. */

/********************************************/

/* close() the socket descriptor. */

close(sd);

exit(0);

 

//////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////

برنامه  server  در پروتکل udp

/*******************udpserver.c*****************/
/* Header files needed to use the sockets API. */

/*by                vahid ezati                teeteel.ir*/

/* File contain Macro, Data Type and Structure */

/* definitions along with Function prototypes. */

/* header files */

#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>

/* Server's port number, listen at 3333 */

#define SERVPORT 3333

/* Run the server without argument */

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

{

/* Variable and structure definitions. */

int sd, rc;

struct sockaddr_in serveraddr, clientaddr;

int clientaddrlen = sizeof(clientaddr);

int serveraddrlen = sizeof(serveraddr);

char buffer[100];

char *bufptr = buffer;

int buflen = sizeof(buffer);

/* The socket() function returns a socket */

/* descriptor representing an endpoint. */

/* The statement also identifies that the */

/* INET (Internet Protocol) address family */

/* with the UDP transport (SOCK_DGRAM) will */

/* be used for this socket. */

/******************************************/

/* get a socket descriptor */

if((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)

{

perror("UDP server - socket() error");

exit(-1);

}

else

printf("UDP server - socket() is OK\n");

printf("UDP server - try to bind...\n");

/* After the socket descriptor is received, */

/* a bind() is done to assign a unique name */

/* to the socket. In this example, the user */

/* set the s_addr to zero. This allows the */

/* system to connect to any client that uses */

/* port 3333. */

/********************************************/

/* bind to address */

memset(&serveraddr, 0x00, serveraddrlen);

serveraddr.sin_family = AF_INET;

serveraddr.sin_port = htons(SERVPORT);

serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);

if((rc = bind(sd, (struct sockaddr *)&serveraddr, serveraddrlen)) < 0)

{

perror("UDP server - bind() error");

close(sd);

/* If something wrong with socket(), just exit lol */

exit(-1);

}

else

printf("UDP server - bind() is OK\n");

printf("Using IP %s and port %d\n", inet_ntoa(serveraddr.sin_addr), SERVPORT);

printf("UDP server - Listening...\n");

/* Use the recvfrom() function to receive the */

/* data. The recvfrom() function waits */

/* indefinitely for data to arrive. */

/************************************************/

/* This example does not use flags that control */

/* the reception of the data. */

/************************************************/

/* Wait on client requests. */

rc = recvfrom(sd, bufptr, buflen, 0, (struct sockaddr *)&clientaddr, &clientaddrlen);

if(rc < 0)

{

perror("UDP Server - recvfrom() error");

close(sd);

exit(-1);

}

else

printf("UDP Server - recvfrom() is OK...\n");

printf("UDP Server received the following:\n \"%s\" message\n", bufptr);

printf("from port %d and address %s.\n", ntohs(clientaddr.sin_port),

inet_ntoa(clientaddr.sin_addr));

/* Send a reply by using the sendto() function. */

/* In this example, the system echoes the received */

/* data back to the client. */

/************************************************/

/* This example does not use flags that control */

/* the transmission of the data */

/************************************************/

/* Send a reply, just echo the request */

printf("UDP Server replying to the stupid UDP client...\n");

rc = sendto(sd, bufptr, buflen, 0, (struct sockaddr *)&clientaddr, clientaddrlen);

if(rc < 0)

{

perror("UDP server - sendto() error");

close(sd);

exit(-1);

}

else

printf("UDP Server - sendto() is OK...\n");

/* When the data has been sent, close() the */

/* socket descriptor. */

/********************************************/

/* close() the socket descriptor. */

close(sd);

exit(0);
    }

///////////////////////////////////////////////////////////////////////////

udp

/////////////////////////////////////////////////////////////////////////////////////

برنامه clint  در پروتکل  tcp

/************tcpclient.c************************/
/* Header files needed to use the sockets API. */

/*by                vahid ezati                teeteel.ir*/

/* File contains Macro, Data Type and */

/* Structure definitions along with Function */

/* prototypes. */

#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 <netdb.h>

#include <unistd.h>

#include <errno.h>

/* BufferLength is 100 bytes */

#define BufferLength 100

/* Default host name of server system. Change it to your default */

/* server hostname or IP.  If the user do not supply the hostname */

/* as an argument, the_server_name_or_IP will be used as default*/

#define SERVER "The_server_name_or_IP"

/* Server's port number */

#define SERVPORT 3111

/* Pass in 1 parameter which is either the */

/* address or host name of the server, or */

/* set the server name in the #define SERVER ... */

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

{

/* Variable and structure definitions. */

int sd, rc, length = sizeof(int);

struct sockaddr_in serveraddr;

char buffer[BufferLength];

char server[255];

char temp;

int totalcnt = 0;

struct hostent *hostp;

char data[100] = "This is a test string from client lol!!! ";

/* The socket() function returns a socket */

/* descriptor representing an endpoint. */

/* The statement also identifies that the */

/* INET (Internet Protocol) address family */

/* with the TCP transport (SOCK_STREAM) */

/* will be used for this socket. */

/******************************************/

/* get a socket descriptor */

if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)

{

perror("Client-socket() error");

exit(-1);

}

else

printf("Client-socket() OK\n");

/*If the server hostname is supplied*/

if(argc > 1)

{

/*Use the supplied argument*/

strcpy(server, argv[1]);

printf("Connecting to the f***ing %s, port %d ...\n", server, SERVPORT);

}

else

/*Use the default server name or IP*/

strcpy(server, SERVER);

memset(&serveraddr, 0x00, sizeof(struct sockaddr_in));

serveraddr.sin_family = AF_INET;

serveraddr.sin_port = htons(SERVPORT);

if((serveraddr.sin_addr.s_addr = inet_addr(server)) == (unsigned long)INADDR_NONE)

{

/* When passing the host name of the server as a */

/* parameter to this program, use the gethostbyname() */

/* function to retrieve the address of the host server. */

/***************************************************/

/* get host address */

hostp = gethostbyname(server);

if(hostp == (struct hostent *)NULL)

{

printf("HOST NOT FOUND --> ");

/* h_errno is usually defined */

/* in netdb.h */

printf("h_errno = %d\n",h_errno);

printf("---This is a client program---\n");

printf("Command usage: %s <server name or IP>\n", argv[0]);

close(sd);

exit(-1);

}

memcpy(&serveraddr.sin_addr, hostp->h_addr, sizeof(serveraddr.sin_addr));

}

/* After the socket descriptor is received, the */

/* connect() function is used to establish a */

/* connection to the server. */

/***********************************************/

/* connect() to server. */

if((rc = connect(sd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))) < 0)

{

perror("Client-connect() error");

close(sd);

exit(-1);

}

else

printf("Connection established...\n");

/* Send string to the server using */

/* the write() function. */

/*********************************************/

/* Write() some string to the server. */

printf("Sending some string to the f***ing %s...\n", server);

rc = write(sd, data, sizeof(data));

if(rc < 0)

{

perror("Client-write() error");

rc = getsockopt(sd, SOL_SOCKET, SO_ERROR, &temp, &length);

if(rc == 0)

{

/* Print out the asynchronously received error. */

errno = temp;

perror("SO_ERROR was");

}

close(sd);

exit(-1);

}

else

{

printf("Client-write() is OK\n");

printf("String successfully sent lol!\n");

printf("Waiting the %s to echo back...\n", server);

}

totalcnt = 0;

while(totalcnt < BufferLength)

{

/* Wait for the server to echo the */

/* string by using the read() function. */

/***************************************/

/* Read data from the server. */

rc = read(sd, &buffer[totalcnt], BufferLength-totalcnt);

if(rc < 0)

{

perror("Client-read() error");

close(sd);

exit(-1);

}

else if (rc == 0)

{

printf("Server program has issued a close()\n");

close(sd);

exit(-1);

}

else

totalcnt += rc;

}

printf("Client-read() is OK\n");

printf("Echoed data from the f***ing server: %s\n", buffer);

/* When the data has been read, close() */

/* the socket descriptor. */

/****************************************/

/* Close socket descriptor from client side. */

close(sd);

exit(0);

return 0;

}

//////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////

برنامه  server  در پروتکل  tcp

/************tcpserver.c************************/

/*by                vahid ezati                teeteel.ir*/

/* header files needed to use the sockets API */

/* File contain Macro, Data Type and Structure */

/***********************************************/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/time.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <errno.h>

#include <unistd.h>

/* BufferLength is 100 bytes */

#define BufferLength 100

/* Server port number */

#define SERVPORT 3111

int main()

{

/* Variable and structure definitions. */

int sd, sd2, rc, length = sizeof(int);

int totalcnt = 0, on = 1;

char temp;

char buffer[BufferLength];

struct sockaddr_in serveraddr;

struct sockaddr_in their_addr;

fd_set read_fd;

struct timeval timeout;

timeout.tv_sec = 15;

timeout.tv_usec = 0;

/* The socket() function returns a socket descriptor */

/* representing an endpoint. The statement also */

/* identifies that the INET (Internet Protocol) */

/* address family with the TCP transport (SOCK_STREAM) */

/* will be used for this socket. */

/************************************************/

/* Get a socket descriptor */

if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)

{

perror("Server-socket() error");

/* Just exit */

exit (-1);

}

else

printf("Server-socket() is OK\n");

/* The setsockopt() function is used to allow */

/* the local address to be reused when the server */

/* is restarted before the required wait time */

/* expires. */

/***********************************************/

/* Allow socket descriptor to be reusable */

if((rc = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on))) < 0)

{

perror("Server-setsockopt() error");

close(sd);

exit (-1);

}

else

printf("Server-setsockopt() is OK\n");

/* bind to an address */

memset(&serveraddr, 0x00, sizeof(struct sockaddr_in));

serveraddr.sin_family = AF_INET;

serveraddr.sin_port = htons(SERVPORT);

serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);

printf("Using %s, listening at %d\n", inet_ntoa(serveraddr.sin_addr), SERVPORT);

/* After the socket descriptor is created, a bind() */

/* function gets a unique name for the socket. */

/* In this example, the user sets the */

/* s_addr to zero, which allows the system to */

/* connect to any client that used port 3005. */

if((rc = bind(sd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))) < 0)

{

perror("Server-bind() error");

/* Close the socket descriptor */

close(sd);

/* and just exit */

exit(-1);

}

else

printf("Server-bind() is OK\n");

/* The listen() function allows the server to accept */

/* incoming client connections. In this example, */

/* the backlog is set to 10. This means that the */

/* system can queue up to 10 connection requests before */

/* the system starts rejecting incoming requests.*/

/*************************************************/

/* Up to 10 clients can be queued */

if((rc = listen(sd, 10)) < 0)

{

perror("Server-listen() error");

close(sd);

exit (-1);

}

else

printf("Server-Ready for client connection...\n");

/* The server will accept a connection request */

/* with this accept() function, provided the */

/* connection request does the following: */

/* - Is part of the same address family */

/* - Uses streams sockets (TCP) */

/* - Attempts to connect to the specified port */

/***********************************************/

/* accept() the incoming connection request. */

int sin_size = sizeof(struct sockaddr_in);

if((sd2 = accept(sd, (struct sockaddr *)&their_addr, &sin_size)) < 0)

{

perror("Server-accept() error");

close(sd);

exit (-1);

}

else

printf("Server-accept() is OK\n");

/*client IP*/

printf("Server-new socket, sd2 is OK...\n");

printf("Got connection from the f***ing client: %s\n", inet_ntoa(their_addr.sin_addr));

/* The select() function allows the process to */

/* wait for an event to occur and to wake up */

/* the process when the event occurs. In this */

/* example, the system notifies the process */

/* only when data is available to read. */

/***********************************************/

/* Wait for up to 15 seconds on */

/* select() for data to be read. */

FD_ZERO(&read_fd);

FD_SET(sd2, &read_fd);

rc = select(sd2+1, &read_fd, NULL, NULL, &timeout);

if((rc == 1) && (FD_ISSET(sd2, &read_fd)))

{

/* Read data from the client. */

totalcnt = 0;

while(totalcnt < BufferLength)

{

/* When select() indicates that there is data */

/* available, use the read() function to read */

/* 100 bytes of the string that the */

/* client sent. */

/***********************************************/

/* read() from client */

rc = read(sd2, &buffer[totalcnt], (BufferLength - totalcnt));

if(rc < 0)

{

perror("Server-read() error");

close(sd);

close(sd2);

exit (-1);

}

else if (rc == 0)

{

printf("Client program has issued a close()\n");

close(sd);

close(sd2);

exit(-1);

}

else

{

totalcnt += rc;

printf("Server-read() is OK\n");

}

}

}

else if (rc < 0)

{

perror("Server-select() error");

close(sd);

close(sd2);

exit(-1);

}

/* rc == 0 */

else

{

printf("Server-select() timed out.\n");

close(sd);

close(sd2);

exit(-1);

}

/* Shows the data */

printf("Received data from the f***ing client: %s\n", buffer);

/* Echo some bytes of string, back */

/* to the client by using the write() */

/* function. */

/************************************/

/* write() some bytes of string, */

/* back to the client. */

printf("Server-Echoing back to client...\n");

rc = write(sd2, buffer, totalcnt);

if(rc != totalcnt)

{

perror("Server-write() error");

/* Get the error number. */

rc = getsockopt(sd2, SOL_SOCKET, SO_ERROR, &temp, &length);

if(rc == 0)

{

/* Print out the asynchronously */

/* received error. */

errno = temp;

perror("SO_ERROR was: ");

}

else

printf("Server-write() is OK\n");

close(sd);

close(sd2);

exit(-1);

}

/* When the data has been sent, close() */

/* the socket descriptor that was returned */

/* from the accept() verb and close() the */

/* original socket descriptor. */

/*****************************************/

/* Close the connection to the client and */

/* close the server listening socket. */

/******************************************/

close(sd2);

close(sd);

exit(0);

return 0;

}

 

////////////////////////////////////////////////////////////////////////////////////////////////////

 

////////////////////////////////////////////////////////////////////////////////////////////////////

توضیح اینکه هر برنامه را در یک فایل نت پد ذخیره کنید و فایل را با پسوند دات سی ذخیره کنید این برنامه ها را در فدورا که کامپایلر gcc را داشته باشند اجرا کنید .

کامپایل کردن

پروژه   TCP   UDP   CLINT  SERVER

پروژه فاینال استاد مهری یحیایی
به این مطلب امتیاز دهید
نت های پیانو نت های ویولن نت های سنتور نت های گیتار

همچنین ببینید

طراحی سایت موسیقی

طراحی سایت برای آموزشگاه های موسیقی

طراحی سایت آموزشگاه های موسیقی یکی از خدمات طراحی وب سایت گروه نرم افزار تی …

2 دیدگاه

  1. رامین یزدان نجات

    سلام – استاد مهری یحیایی استاد اینجانب در درس مهندسی اینترنت در دانشگاه جامع علمی کاربردی واحد 34 بودند که ما این پروژه را برای ایشان اجرا کردیم
    ایشان استاد بسیار خوبی هستند .

پاسخ دهید

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *