BSD Socket Programming
1. Socket의 기본 개념
1-1. Socket의 정의
1-2. Socket Descript
2. 프로그램 동작 설명
2-1. TCP 통신
2-2. UDP 통신
3. Socket Programming의 구성요소
3-1. 소켓인터페이스에서 사용하는 데이터 타입
3-2. struct socketaddr_in
3-3. struct in_addr
3-4. htons()
3-5. socket()
3-6. bind()
3-7. connect()
3-8. listen()
3-9. accept()
3-10. sedn(), recv()
4. 프로그램 소스 설명
4-1. server.c
4-2. client.c
5. 실행 환경
6. CASE 연구
6-1. concurrent 서비스 방식에 의해 통신할 경우? (TCP)
6-2. interative 서비스 방식에 의해 통신할 경우? (TCP)
6-3. Bind 함수의 기능(TCP Socket)
1) Server는 반드시 Port Binding이 필요한가?
2) Client가 Port를 Binding 하면 어떠한가?
6-4. Listen 함수의 기능(TCP Socket)
1) Server가 listen()을 빠트린 경우?
2) listen 함수의 Queue size를 1로 지정하면?
6-5. Server가 accept를 하지 않은 경우? (TCP)
6-6. Blocking Operation에 대하여 알아보자 (TCP)
1) send()와 recv()는 어떤 mode로 동작하는가 ?
2) accept()와 connect()는 어떤 mode로 동작하는가 ?
6-7. 복수의 통신로를 열었을 때 ? (TCP)
6-8. UDP Socket 통신의 특징과 기본 절차를 알아보자
6-9. UDP Socket 통신에서 오류제어를 확인하기 위해 대용량의 data를 보내보자. - 82
6-10. Bind Error는 언제 발생하는가 ? (TCP)
1) close하지 않았을 때 Bind Error가 발생하는가 ?
2) exit하지 않았을 때 Bind Error가 발생하는가 ?
6-11. Server나 Client가 죽는 경우 ? (TCP)
1) Server의 Child Process가 죽는 경우 ?
2) Server의 Parent Process가 죽는 경우 ?
3) Client Process가 죽는 경우 ?
6-12. 표준 인터넷 서비스 등록 방법
1) 소스 파일 첨부 exhoex.c, exhoexd.c
1. Socket의 기본개념
1-1. 소켓의 정의
소켓은 1982년 BSD(Berkeley Software Distribution) UNIX 4.1에서 처음 소개되었으며 현재 널리 사용되는 것은 1986년 BSD UNIX 4.3에서 개정된 것이다.
소켓은 소프트웨어로 작성된 통신 접속점이라고 할 수 있다. 네트웍 응용 프로그램은 소켓을 통하여 통신망으로 데이터를 송수신 하게 된다. 그림1에 세 개의 응용 프로그램이 각각 소켓을 통하여 TCP/IP를 공유하고 있는 것을 나타냈다.
소켓은 응용 프로그램에서 TCP/IP를 이용하는 창구 역할을 하며 응용 프로그램과 소켓 사이의 인터페이스를 소켓 인터페이스라고 한다.
1-2. Socket Descriptor
UNIX에서 파일을 Open하면 int 타입의 정수를 return하는데 이와 같이 open이 return한 정수를 파일기술자(file descriptor)라고 하며 프로그램에서 open된 파일을 액세스할 때 이 파일기술자를 사용하게 된다.
파일기술자는 기술자 테이블(descriptor table)의 index 번호인데(그림 2 참조), 기술자 테이블이란 현재 open되어 있는 파일의 각종 정보를 포함하고 있는 구조체를 가리키는 포인터들로 구성된 테이블이다.
예를 들어 한 응용 프로그램 내에서 2개의 파일을 open하면 파일기술자는 3과 4가 배정된다.
프로그램에서 소켓을 개설하면 파일기술자와 똑같은 기능을 하는 소켓기술자(socket descriptor)가 return된다. 응용 프로그램에서 이 소켓을 통하여 목적지 호스트와 연결을 요구하거나 패킷을 송수신할 때 해당 소켓기술자를 사용하게 된다(소켓기술자를 소켓 번호라고 부른다). UNIX에서는 파일기술자와 소켓기술자가 같은 기술자 테이블의 index가 된다. 즉, 파일과 소켓이 기술자 테이블을 공유한다. 한 프로세스에서 파일 open시 return되는 파일기술자와 소켓 Open시 return되는 소켓기술자의 값은 서로 중복된 것이 없게 된다.
그림 2에는 두 개의 파일과 한 개의 소켓을 개설하였을 때의 기술자 테이블과 기술자 테이블이 가리키는 파일 또는 소켓 데이터 구조체를 나타내고 있다. 그림 2에 응용 프로그램과 소켓 그리고 TCP/IP의 관계를 구체적으로 나타냈다.
네 개의 응용 프로그램이 소켓번호로 각각 4, 3, 3, 3을 사용하고 있는 것을 나타냈다(응용 프로그램 1은 파일을 하나 먼저 열고 있으므로 소켓번호가 4가 된 것이다).
한편 소켓번호는 응용 프로그램 내에서 순서대로 배정되며 그 프로그램 내에서만 유일하게 구분되면 되는 것이므로 서로 다른 응용 프로그램에서 같은 소켓번호를 사용하는 것은 문제가 되지 않는다.
포트번호는 TCP/IP가 지원하는 상위 계층의 프로세스를 구분하기 위한 번호이므로 하나의 컴퓨터 내에 있는 응용 프로세스들은 반드시 서로 다른 포트번호를 사용하여야 한다.
그림 3에서는 네 개의 응용 프로그램이 3000번부터 3003 번의 포트번호를 사용하는 것을 가정하였다. 그림 3에서 연결형 서비스는 TCP가 그리고 비연결형 서비스는 UDP가 각각 처리하는 것을 보였다.
IP 주소 192.203.144.11은 이 컴퓨터에 배정된 IP 주소인데 예를 들어 목적지 IP 주소가 192.203.144.11인 IP 패킷은 모두 그림 3의 컴퓨터로 전달된다. 이 패킷을 수신할 응용 프로그램은 TCP(또는 UDP) 헤더에 있는 16비트의 포트번호를 참조하여 구분한다.
2. 프로그램 동작 설명
2-1. TCP 통신
2-1-1. 특징
- 양방향의 스트림 통신 서비스를 제공하는 연결위주의 신뢰성 있는 통신 프로토콜이다.
- 대부분의 인터넷 애플리케이션이 사용한다.
- IP 프로토콜의 비신뢰적인 서비스를 보완하기 위해, 가상의 회선을 설정한다.
- 응용 프로그램에게 신뢰성 있는 연결성 서비스를 제공한다.
2-1-2. TCP 프로토콜의 역할
- 프로세스간의 연결의 구축과 절단을 담당한다.
- 전송 받은 데이터를 순서대로 맞춘다.
- 양 끝점간의 흐름을 제어한다.
2-1-3. 클라이언트/서버의 동작
- Server
① socket() 시스템 콜에서 파일 디스크립터와 소켓 디스크립터를 할당받는다.
② bind()에서 자신의 주소와 포트를 소켓 디스크립터와 연결시킨다.
③ listen()을 이용해 서버가 동시에 받을 수 있는 클라이언트의 접속요청 수를 지정한다.
④ accept()에서 클라이언트의 request를 기다린다.
⑤ request가 들어오면 connect한 후 read()/write()를 통해 입출력을 수행한다.
- Client
① connect()에서 서버에게 접속 request를 보낸다.
② request가 받아들여져 접속이 확립된다.
③ read()와 write()를 통해 입출력을 수행한다.
④ 일반적인 경우 close()에서 접속 해제 요청을 서버에게 보낸 후 네트워크의 입출력을 끝낸다.
2-1-4. TCP connection의 상태 변이
2-1-5. TCP 연결에서의 packet 교환
2-2. UDP 통신
2-2-1. 특징
- 사용자 프로세스에게 비연결성 서비스를 제공한다.
- 신뢰성 있는 TCP와 달리 하나의 데이터그램이 원하는 목적지 호스트에 도달한다는 보장 이 없다.
2-2-2. 클라이언트/서버의 동작
① 접속 서버와 클라이언트간의 접속을 요청하고 받아들이는 부분이 없다.
② 네트워크 입출력은 sendto()와 recvfrom() 두개의 시스템 콜을 이용해 동작한다.
③ 접속이 이루어지지 않은 상태에서 데이터를 주고받는다.
④ 구조체를 사용하여 필요한 정보(IP, port number)를 데이터와 함께 보낸다.
3. Socket Programing의 구성요소
3-1. 소켓 인터페이스에서 사용하는 데이터 타입
3-1-1. struct sockaddr
이 구조체는 여러 가지 형태의 소켓 주소를 담게된다.
struct sockaddr
{
unsigned short sa_family; /* address family, AF_xxx */
char sa_data[14]; /* 14 bytes of protocol address */
};
- sa_family는 이 주소의 주소 포맷용 코드이다. 그것은 다음에 나오는 데이터의 포맷을 지 시한다.
- char sa_data[14]는 실제적인 소켓주소 데이터이다. 이것은 포맷에 의존한다. 그것의 길이 는 또한 포맷에 의존하고 14보다 크다. sa_data의 14라는 길이는 원래 변할 수 있다. 각 주소포맷은 AF_로 시작하는 기호이름으로 시작된다. 그것들은 각각 이름 공간에 대응되 는 'PF_' 기호에 맞춰져 있다.
AF_FILE - 이것은 파일 이름공간에 맞는 주소포맷이다. (PF_FILE은 이 이름공간의 이름 이다.)
AF_UNIX - 이것은 호환성을 위한 AF_FILE과 같은 말이다. (PF_UNIX는 PF_FILE과 동 의어이다.)
AF_INET - 이것은 인터넷 이름공간에 맞는 주소포맷이다. (PF_INET은 이 이름공간의 이 름이다.)
AF_UNSPEC - 이것은 특정한 주소포맷을 지정하지 않는다. 그것은 "연결된" 데이터그램 소켓의 기본(default)목적지 주소를 지우는 것 같은 드문 경우에만 사용된다.
3-2. struct sockaddr_in
sockaddr 구조체를 다루기 위한 parallel structure. ("in"은 인터넷을 의미.)
struct sockaddr_in {
short int sin_family; /* Address family */
unsigned short int sin_port; /* Port number */
struct in_addr sin_addr; /* Internet address */
unsigned char sin_zero[8]; /* Same size as struct sockaddr */
};
이 구조체는 각각의 항을 참조하기가 좀더 쉽다. 주의할 점은 sin_zero배열은 sockaddr과 구조체의 크기를 맞추기 위해서 넣어진 것이므로 bzero()나 memset()함수를 이용하여 모두 0으로 채워져야 한다.
또한 이 구조체는 sockaddr의 포인터를 이용하여 참조될 수 있고 그 반대도 가능하다는 것이다. 따라서 socket()함수가 struct sockaddr *를 원하더라도 struct sockaddr_in을 사용할 수 있고 바로 참조할 수도 있는 것이다.
또한 sin_family는 sa_family에 대응되는 것이며 물론 "AF_INET"로 지정되어야 하며sin_port, sin_addr은 네트워크 바이트 순서로 되어야 하는 점이 중요한 것이다.
3-3. struct in_addr
struct in_addr {
unsigned long s_addr;
};
3-4. htons()함수
"Host to Network Short" - short변수를 호스트 바이트 순서에서 네트워크 바이트 순서로
변환하는 경우
① htonl() - "Host to Network Long"
② ntohs() - "Network to Host Short"
③ ntohl() - "Network to Host Long"
④ inet_ntoa() - 값이 들어있는 struct in_add를 숫자와 점으로 표시하기 위해 쓰이는 함수
3-5. socket()함수
#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
domain은 struct sockaddr_in 에서처럼 AF_INET로 지정하면 된다.
. AF_UNSPEC
. AF_UNIX : 하나의 시스템 내
. AF_INET : 서로 다른 시스템 간
type은 socket의 형식을 지정하는 것으로 SOCK_STREAM이나 SOCK_DGRAM으로 지정하면 된다.
. SOCK_STREAM : TCP -> 오류제어 필요 없음
. SOCK_DGRAM : U에 -> 오류제어 필요시 application 계층에서 처리
protocol은 0으로 지정하면 된다. socket()은 바로 나중에 사용할 소켓 기술자인 정수 값을 돌려주며 에러 시에는 -1을 돌려주게 된다.
3-6. bind()함수
일단 소켓을 열게 되면 이 소켓을 현재 시스템의 포트에 연결시켜 주어야 한다. (이 작업은 보통 listen()함수를 이용해서 외부의 접속을 대기할 때 시행되며 일반적으로 머드게임 사이트들이 telnet *.*.*.* 6969로 접속하라고 할 때도 이 작업을 시행했다는 의미이다) 만약에 그저 다른 호스트에 연결하기만 할 예정이라면 그냥 connect()를 사용하여 연결만 하면 되고 이 작업은 필요가 없다.
bind() 시스템 호출의 선언
#include <sys/types.h>
#include <sys/socket.h>
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);
sockfd는 socket()함수에서 얻은 소켓 기술자이며 my_addr은 IP 주소에 관한 정보(즉, IP 주소와 포트번호)를 담고 있는 struct sockaddr에 대한 포인터이고 addrlen은 그 구조체의 size(sizeof(struct sockaddr))이다.
bind()가 에러가 났을 때 -1을 돌려주며 errno에 에러의 코드가 남게 된다.
bind()를 호출할 때 주의할 점 : 절대 제한선 아래로 포트번호를 내려서는 안 된다. 1024 아래의 번호는 모두 예약되어 있다. 그 위로는 65535까지 원하는 대로 쓸 수가 있다. (다른 프로그램이 쓰고 있지 않은 경우에 한해서)
bind()를 호출하지 않아도 되는 경우가 있다. 만일 다른 호스트에 연결 (connect())하고 자 하는 경우에는 자신의 포트에는 (텔넷의 경우처럼)전혀 신경 쓸 필요가 없다. 단지 connect()를 호출하기만 하면 알아서 bind가 되어 있는지를 체크해서 비어있는 포트에 bind를 해준다.
3-7. connect()함수
#include <sys/types.h>
#include <sys/socket.h>
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
sockfd는 소켓 기술자이며 serv_addr은 연결하고자 하는 목적지인 서버의 주소와 포트 에 관한 정보를 담고 있는 struct sockaddr이며 addrlen은 앞에서 이야기한 것과 같이 그 구조체의 크기이다.
3-8. listen()함수
외부로부터의 접속을 대기해서 접속이 올 경우 처리 시 먼저 listen()을 해야 되고 그 다음에 accept()를 해야 된다.
int listen(int sockfd, int backlog);
sockfd는 보통의 소켓 기술자이며 backlog는 접속대기 큐의 최대 연결 가능 숫자이다. 외부로부터의 연결은 이 대기 큐에서 accept()가 호출될 때까지 기다려야 한다는 것이며 숫자는 바로 얼마나 많은 접속이 이 큐에 쌓여질 수 있는가 하는 것이다. 대부분의 시스템은 이 숫자를 20정도에서 제한하고 있으며 보통은 5에서 10 사이로 지정한다.
listen()도 에러의 경우 -1을 돌려주며 errno를 세팅한다.
여기서 listen()보다 앞서서 bind()를 호출해야 하며 만약에 bind()가 되지 않으면 우리는 랜덤 하게 지정된 포트에서 외부의 접속을 기다려야 한다. (포트를 모르고서는 접속할 수 없다.) 따라서 외부의 접속을 기다리는 경우라면 다음 순서대로 작업이 진행되어야 하는 것이다.
socket();
bind();
listen();
/* accept() goes here */
3-9. accept() 함수
Connect는 accept()가 호출되기까지 Queue에서 accept()를 호출하여 그 연결을 지속하라고 명령할 때까지 대기하게 된다. 그러면 이 함수는 오로지 이 연결을 위한 소켓 파일 기술자를 돌려주게 된다. 하나 값으로 두개의 소켓 기술자를 갖게 되는 것이다. 원래의 것은 아직도 그 포트에서 연결을 listen()하고 있다. 또 하나는 새로 만들어져서 send()와 recv() 할 준비가 되도록 하는 것이다. 선언은 아래와 같다.
#include <sys/socket.h>
int accept(int sockfd, void *addr, int *addrlen);
sockfd는 listen()하고 있는 소켓 기술자이다. addr은 로컬 struct sockaddr_in의 포인터이다. 여기에 들어온 접속에 관한 정보가 담겨지게 되고 이를 이용해서 어느 Host에서 어느 port를 이용해서 접속이 들어왔는지를 알 수 있게 된다.
addrlen은 로컬 정수 변수이며 이 정수에는 struct sockaddr_in의 크기가 미리 지정되어 있어야 한다. 이 숫자보다 더 많은 바이트의 정보가 들어오면 accept()는 받아들이지 않을 것이며 적데 들어온다면 addrlen의 값을 줄여 줄 것이다.
accept() 는 에러가 났을 경우에 -1을 돌려주고 errno를 세팅한다.
3-10. send(), recv() - data교환
int send(int sockfd, const void *msg, int len, int flags);
sockfd는 socket()를 통해서 얻었거나 accept()를 통해서 새로 구한, 데이터를 보낼 소켓의
기술자이며, msg는 보낼 데이터를 가리키는 포인터, len은 보낼 데이터의 바이트 수이며 flags는 그냥 0으로 해야 한다.
int recv(int sockfd, void *buf, int len, unsigned int flags);
sockfd는 읽어올 소켓의 기술자이며 buf는 정보를 담을 버퍼이다. len은 버퍼의 최대 크기이다.
4. 프로그램 소스 설명
4-1. server.c
/* --------------------------------------------------------------------- */
/* server.c */
/* TCP Socket을 이용한 통신 (기본예제) */
/* 최종 수정일 : 2002.02.22 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h> // 여러 가지 정의된 자료형 들을 사용하기 위해
#include <sys/socket.h> // socket과 관련된 구조체와 자료형 들을 사용하기 위해
#include <netdb.h> // socket과 관련된 함수와 구조체를 사용하기 위해
#include <netinet/in.h> // socketaddr_in 구조체를 사용하기 위해
#include <arpa/inet.h> // ALPA internet protocol과 관련 된 구조체를 사용하기 위해
#define ServicePort 8001
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr; /*Updated for Client Addr Info : struct sockaddr ClientAddr */
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
// server name display
printf("\n[Server] server name: %s\n", ServerName);
// rendezvous socket create
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
// socket create display
printf("[Server] Socket created.\n");
// socket struct 초기화
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
// rendezvous socket bind
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
// bind display
printf("[Server] Socket binded.\n");
// listen
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
// listened display
printf("[Server] Socket listened.\n");
while (1)
{
// Waiting for connection request.
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
// accept
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr,
&ClientAddrLen)) < 0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
// client IP와 함께 접속이 되었다는 메시지를 화면에 표시
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
// child process를 생성하겠다는 메시지 표시
printf("[Server] Create child process.\n");
// process fork
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
// process fork 후 client로부터 데이터가 오길 기다림
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
// client IP와 Port 그리고 데이터를 화면에 표시
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
// 잘 받았다는 메시지 Send
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { /* Parent Process */
close(Csock);
}
}
}
4-2. client.c
/* --------------------------------------------------------------------- */
/* client.c */
/* TCP Socket을 이용한 통신 (기본예제) */
/* 최종 수정일 : 2002.02.22 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#define MAXSIZE 512
#define ServicePort 8001
int main(int argc, char *argv[])
{
int sd;
struct in_addr *InetAddr;
struct sockaddr_in ServerSockAddr;
struct hostent *ServerInfo;
char SndBuf[MAXSIZE], RcvBuf[MAXSIZE];
// server의 이름으로 IP address를 얻는다.
if ((ServerInfo = gethostbyname(argv[1])) == NULL) {
printf("Client Error! gethostbyname() error\n");
exit(-1);
}
InetAddr = (struct in_addr *) *(ServerInfo->h_addr_list);
//Server address display
printf("[Client] sever address %s \n", inet_ntoa(*InetAddr));
if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
printf("Client Error! socket() error \n");
exit(-1);
}
// socket create display
printf("[Client] Socket created.\n");
// socket struct 초기화
bzero((char*) &ServerSockAddr, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr.sin_port = htons(ServicePort);
printf("[Client] Clint send connection request.\n");
if (connect(sd, (struct sockaddr *) &ServerSockAddr, sizeof(ServerSockAddr)) < 0) {
printf("Client Error! connect() error\n");
exit(-1);
}
// connect display
printf("[Client] Clint and server connected.\n");
printf("[Client] Input Data ? ");
gets(SndBuf);
send(sd, SndBuf, (sizeof(SndBuf)), 0);
printf("[Client] Client sent Data.\n");
recv(sd, RcvBuf, (sizeof(RcvBuf)), 0);
printf("[Client] Client received Data.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf);
close(sd);
printf("[Client] Client Exit.\n");
}
5. 실행 환경
5-1. 사용 machine
- SunOS 5.7
- WOW Linux 7.0
- ALZZA Linux 6.1
5-2. 사용 계정
- Server address : seed.ks.ac.kr
- User ID : XXXXXXXX
- Password : XXXXXXXX
6. CASE 연구
6-1. 각 client의 요청을 독립적인 child process가 client와 접속하여 통신하는 concurrent 서비스 방식에 의해 통신하는 경우 ?
① 동작 환경(source code)
rendezvous socket을 fork하여 만든 communication socket이 client process와 통신하게 만든다. 또한 여러 client가 접속한다는 가정에 의해 client에서는 넘겨줄 데이터를 먼저 받고 connect를 한다. server.c는 기본예제와 같고 client.c에서 데이터를 입력받는 부분만 아래와 같이 소스를 수정한다. Service Port는 8002번이다.
/* --------------------------------------------------------------------- */
/* client.c */
/* Case 6-1) : TCP Socket을 이용한 통신 (Concurrent Service) */
/* 최종 수정일 : 2002.02.22 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#define MAXSIZE 512
#define ServicePort 8002
int main(int argc, char *argv[])
{
int sd;
struct in_addr *InetAddr;
struct sockaddr_in ServerSockAddr;
struct hostent *ServerInfo;
char SndBuf[MAXSIZE], RcvBuf[MAXSIZE];
printf("[Client] Input Data ? "); // Updated! for checking concurrent service
gets(SndBuf);
if ((ServerInfo = gethostbyname(argv[1])) == NULL) {
printf("Client Error! gethostbyname() error\n");
exit(-1);
}
InetAddr = (struct in_addr *) *(ServerInfo->h_addr_list);
printf("[Client] sever address %s \n", inet_ntoa(*InetAddr));
if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
printf("Client Error! socket() error \n");
exit(-1);
}
printf("[Client] Socket created.\n");
bzero((char*) &ServerSockAddr, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr.sin_port = htons(ServicePort);
printf("[Client] Clint sent connection request.\n");
if (connect(sd, (struct sockaddr *) &ServerSockAddr, sizeof(ServerSockAddr)) < 0) {
printf("Client Error! connect() error\n");
exit(-1);
}
printf("[Client] Clint and server connected.\n");
// printf("[Client] Input Data ? ");
// gets(SndBuf);
send(sd, SndBuf, (sizeof(SndBuf)), 0);
printf("[Client] Client sent Data.\n");
recv(sd, RcvBuf, (sizeof(RcvBuf)), 0);
printf("[Client] Client received Data.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf);
close(sd);
printf("[Client] Client Exit.\n");
}
② 실행 결과
server를 실행시키고 connection request를 기다리고 있다.
netatat : server를 실행시키고 네트뚺 상태를 확인
client : client 3개를 동시에 열어 데이터를 전달한다. 첫 번째는 11111111을, 두 번째는 2222222222, 세 번째는 33333333333을 동시에 보냈다.
server : 3개의 client로부터 데이터를 전달받았다.
netstat : 데이터를 모두 전달받은 후의 네트뚺 상태이다.
③ 결과 분석
Client가 connect후 세 번 fork과정을 거처 세 개의 process가 각각 data를 전달하는 과정을 확인 할 수 있다.
실질적으로 아주 정확한 테스트는 되지 못했다. 데이터를 보내는 그 순간 세 개의 process가 생성되어 동시에 처리되어야 하는데, 위의 경우는 하나의 데이터를 받고 process가 종료 후 또 하나의 데이터를 받는 형식으로 순차적으로 이루어진다.
6-2. 각 client의 요청을 parent process가 한번에 하나씩 통신하는 interative 서비스 방 식에 의해 child process가 client와 통신하는 경우 ?
① 동작 환경(source code)
rendezvous socket을 fork하지 않고 client process와 직접 통신하게 만든다. server.c는 fork하는 부분을 주석처리 하여 아래와 같고, client.c는 기본예제와 동일하다. Service Port는 8002번이다.
/* --------------------------------------------------------------------- */
/* server.c */
/* Case 6-2) : TCP Socket을 이용한 통신 (Iterative Service) */
/* 최종 수정일 : 2002.02.22 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 8002
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr; // struct sockaddr ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
while (1)
{
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen))< 0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
/*
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { //* Child Process
close(Rsock);
*/
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
/*
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { // Parent Process
*/
close(Csock);
/*
}
*/
}
}
② 실행 결과
server : server.c를 실행시키고 3개의 client로부터 데이터를 전달받을 것이다.
client : 3개의 client가 server로 접속을 해서 각 data를 전달하기 바로 전 화면이다. 가장 먼저 접속한 client가 11111111111111이란 data를 두 번째 접속한 client가 22222222222222라는 data를 세 번째 접속한 client가 333333333333333이라는 데이터를 입력받아 보내는데 제일 마지막에 접속한 세 번째 client부터 데이터를 보낼 것이다.
netstat : 3개의 client가 각 각 차례대로 접속을 하고 데이터는 보내지 않았다. listen 대기 queue에 나머지 두 개의 client가 들어 있음을 알 수 있다.
server : 3개의 client로부터 접속한 순서 반대로 data를 전달받았으나 접속한 순서대로 data 가 도착한 것을 볼 수 있다.
③ 결과 분석
child process를 만들지 않고 parent process가 모든 client와 직접 통신을 하였다. 접속한 순서의 반대로 data를 보냈는데 server에서는 접속한 순서대로 data가 도착했음을 볼 수 있다. 이는 먼저 접속한 client가 server로부터 service를 받았음을 알 수 있다.
6-3. Bind 함수의 기능 (TCP Socket)
1) Server는 반드시 Port의 Binding이 필요한가 (server에 bind 하지 않을 경우) ?
① 동작 환경
client.c는 기본 예제 그대로 이고 server.c는 아래와 같이 bind 부분만 주석 처리하면 된다. service port는 8004번이다.
/* --------------------------------------------------------------------- */
/* server.c */
/* Case 6-3) : Port Binding 문제 (TCP Socket) */
/* 1) Server는 반드시 Port의 Binding이 필요한가? */
/* 최종 수정일 : 2002.02.22 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 8004
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock;
char ServerName[20];
int ClientAddrLen;
char buf[80];
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
/*
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
*/
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
while (1)
{
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen)) < 0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { /* Parent Process */
close(Csock);
}
}
}
② 실행 결과
server : 정상적인 컴파일과 실행이 된다.
client : 실행 시 connect error가 발생한다.
③ 결과 분석
Server는 꼭 bind를 해야 한다. server 프로그램을 실행 시에는 아무런 문제가 없으나 client 프로그램이 server로 접속 시점에 connect에러가 난다.
2) Client가 Port를 Binding하면 어떠한가?
① 동작 환경
server프로그램은 기본예제와 같고, client프로그램에서는 sockaddr_in 구조체를 다시 하나 선언하고 구조체를 초기화 한 후 bind하면 되고 프로그램 수정 부분은 아래와 같다. server의 service port는 8005, client의 service port는 9000이다.
/* -------------------------------------------------------------------- */
/* client.c */
/* Case 6-3) : Port Binding 문제 (TCP Socket) */
/* 2) Client가 Port를 Binding하면 어떠한가? */
/* client는 9000번 port로 bind한다. */
/* 최종 수정일 : 2002.02.22 */
/* ------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#define MAXSIZE 512
#define ServicePort 8005
int main(int argc, char *argv[])
{
int sd;
struct in_addr *InetAddr;
struct sockaddr_in ServerSockAddr;
struct sockaddr_in ClientSockAddr; // Updated! Inserted for Port Binding
struct hostent *ServerInfo;
char SndBuf[MAXSIZE], RcvBuf[MAXSIZE];
if ((ServerInfo = gethostbyname(argv[1])) == NULL) {
printf("Client Error! gethostbyname() error\n");
exit(-1);
}
InetAddr = (struct in_addr *) *(ServerInfo->h_addr_list);
printf("[Client] sever address %s \n", inet_ntoa(*InetAddr));
if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
printf("Client Error! socket() error \n");
exit(-1);
}
printf("[Client] Socket created.\n");
bzero((char*) &ServerSockAddr, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr.sin_port = htons(ServicePort);
// Updated! Inserted for Port Client's Port Binding
bzero((char*) &ClientSockAddr, sizeof(ClientSockAddr));
ClientSockAddr.sin_family = AF_INET;
ClientSockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
ClientSockAddr.sin_port = htons(9000);
if (bind(sd, (struct sockaddr *) &ClientSockAddr, sizeof(ClientSockAddr))) {
printf("Client Error! bind() error");
exit(-1);
}
printf("[Client] Socket binded.\n");
// End of Insertion
printf("[Client] Clint sent connection request.\n");
if (connect(sd, (struct sockaddr *) &ServerSockAddr, sizeof(ServerSockAddr)) < 0) {
printf("Client Error! connect() error\n");
exit(-1);
}
printf("[Client] Clint and server connected.\n");
printf("[Client] Input Data ? ");
gets(SndBuf);
send(sd, SndBuf, (sizeof(SndBuf)), 0);
printf("[Client] Client sent Data.\n");
recv(sd, RcvBuf, (sizeof(RcvBuf)), 0);
printf("[Client] Client received Data.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf);
close(sd);
printf("[Client] Client Exit.\n");
}
② 실행 결과
server : server를 실행한 화면
netstat : server가 8005번 port로 listen상태임을 알 수 있다.
client : client를 실행하면 9000 port로 bind할 것이다.
netstat : client가 접속 후 네트뚺 상태를 보면 server는 8005에 bind 되었고, client는 9000 번에 bind된 것을 확인 할 수 있다.
③ 결과 분석
server는 꼭 bind를 해야 된다. 하지만 client는 bind를 해도 상관이 없고 하지 않아도 상관이 없다. 하지만 client가 bind를 하지 않는 것을 원칙으로 하는 것은 다음과 같은 이유이다.
client가 bind를 하지 않으면 자신의 port는 다른 통신로와 중복되지 않는 port를 할당해서 통신을 한다. 그러나 임의의 포트가 아닌 하나의 특정 port를 bind하게 되면 그 포트로 하나의 client는 접속이 된다. 하지만 또 다른 client에서 같은 port로 통신을 시도하게 되면 bind error가 나기 때문이다.
6-4. Listen 함수의 기능 (TCP Socket)
1) Server가 listen()을 빠트린 경우 어떻게 되나 ?
① 동작 환경
server.c는 listen 부분을 아래와 같이 주석 처리하였고, client.c는 기본예제 그대로이다. service port는 9000번이다.
/* --------------------------------------------------------------------- */
/* server.c */
/* Case 6-4 : Listen 함수의 기능 (TCP Socket) */
/* 1) Server가 listen()을 빠트린 경우 어떻게 되나 ? */
/* 최종 수정일 : 2002.02.22 */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 9000
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr; // struct sockaddr ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
/* Updated! Deleted for checking listen()
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
*/
while (1)
{
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen)) <
0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { /* Parent Process */
close(Csock);
}
}
}
② 실행 결과
server : runtime시 accept error가 발생한다.
③ 결과 분석
BSD Socket에서는 listen은 client와 connect를 하기 위해 꼭 필요하다.
2) listen() 함수로 Queue의 크기를 1로 지정하면 ?
① 동작 환경.
listen은 server에 동시 연결 될 수 있는 client의 수를 지정한다. listen 함수의 인자 값을 1로 지정해서 프로그램을 실행시키면 확인 할 수 있다. 무한 루프를 돌기 전에(client와 접속이 이루어지기 전) 임의의 숫자를 입력받도록 하였다. server.c는 아래와 같이 소스 수정을 하면 되고, client.c는 기본 예제이다. service port는 9001이다.
/* -------------------------------------------------------------------- */
/* server.c */
/* Case 6-4) : Listen 함수의 기능 (TCP Socket) */
/* 2) listen() 함수로 Queue의 크기를 1로 지정하면 ? */
/* 최종 수정일 : 2002.02.22 */
/* ------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 9001
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr; // struct sockaddr ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
if (listen(Rsock, 1)) { // Updated! Queue size = 0 || 1
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
printf("If continue, enter any number. "); scanf("%d", &num);// Updated
while (1)
{
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen)) <
0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { /* Parent Process */
close(Csock);
}
}
}
② 실행 결과
server : accept를 하기 전 동시에 3개의 client의 접속을 받기 위해 대기 중이다.
client 1,2 : 두 개의 client는 위와 같은 화면처럼 접속이 이루어 졌다.
client 3 : 세 번째 client는 위와 같은 화면처럼 접속 요청을 보냈지만 접속이 되지 않았다.
server : client 1,2에서 data를 보내자 data를 전달받았다.
server : client 1, 2의 data를 전달받고 10초 정도 시간이 지나자 3번째 client도 접속이 이 루어 졌다.
client 3 : client 1, 2가 server로 data를 전달 후 약 10초 뒤 client 3이 server와 connect되 었다.
③ 결과 분석
listen 함수는 server에 동시에 접속될 수 있는 client의 수이다. 즉 Queue size인 것이다. listen이 1이면 server와 접속하기 위해 지정된 Queue의 size이다. 첫 번째 client는 Queue에 대기 할 필요 없이 server와 바로 connect가 이루어지고, 두 번째 client는 Queue에 들어가게 된다. 세 번째 client는 Queue에 들어 갈 수 없기에 connect가 될 수 없다. 그러나 첫 번째 와 두 번째 client가 data를 보내고 접속 종료하였을 때 세 번째 client가 connect가 된 것은 첫 번째 client가 접속 종료후 두 번째 client가 connect되고 Queue가 비워지자 세 번째 client가 Queue로 들어가서 connect된 것이다.
6-5. server가 accept를 하지 않은 경우?
① 동작 환경
server가 accept를 하게 되면 client의 data를 Csock에 저장하고 recv, send시에 client의 정보를 알려준다. server.c는 아래와 같이 accept 부분을 주석 처리한다. client.c는 connect되기 전에 보낼 data를 입력받는다. server port는 8007번이다.
/* -------------------------------------------------------------------- */
/* Case 6-5) : Accept 함수의 기능 (TCP Socket) */
/* 1) Server가 accept()를 하지 않은 경우 어떻게 되나 ? */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 8007
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr; // struct sockaddr ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
printf("If continue, enter any number. "); scanf("%d", &num);
/*
while (1)
{
*/
printf("[Server] Waiting for connection request.\n\n");
/* Updated! for checking accept()
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen)) <
0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
*/
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { /* Parent Process */
// close(Csock);
}
/*
}
*/
}
② 실행 결과
server : server 프로그램을 실행. 정수를 입력하게 되면 accept를 수행하지 않고 client와 connect 요청을 받는다.
server : client로부터 data를 전송 받자 Receive Error가 난다.
③ 결과 분석
server가 accept를 하지 않을 경우 컴파일 시 에러는 나지 않으나 runtime시 Receive Error가 난다. 이는 accept가 connect하는 과정의 하나가 아니라 data를 주고받을 때 server의 정보를 가지고 서로의 통신로를 확립해 주는 일을 하기 때문이다.
6-6. Blocking Operation에 대하여 알아보자(TCP).
1) send(), recv()는 어떤 모드로 동작하는가 ?
① 동작 설명
send()가 어떤 모드인지 확인하기 위해서는 client가 data를 보내고 server가 data를 받지 않고 대기하고 있을 client의 상태를 파악한다. recv()는 기본예제로 살펴보자.
/* --------------------------------------------------------------------- */
/* server.c */
/* Case 6-6) : send는 어떤 모드 인가 ? */
/* 최종 수정일 : 2002.03.10 */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h> // 여러 가지 정의된 자료형 들을 사용하기 위해
#include <sys/socket.h> // socket과 관련된 구조체와 자료형 들을 사용하기 위해
#include <netdb.h> // socket과 관련된 함수와 구조체를 사용하기 위해
#include <netinet/in.h> // socketaddr_in 구조체를 사용하기 위해
#include <arpa/inet.h> // ALPA internet protocol과 관련 된 구조체를 사용하기 위해
#define ServicePort 8001
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr; // Updated! for Client Addr if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
while (1)
{
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen)) <
0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
printf("[Child] Waiting for client data.\n");
// Update ! send가 blocking 인지를 Test.
printf("If continue, enter any number. "); scanf("%d", &num);
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { /* Parent Process */
close(Csock);
}
}
}
/* --------------------------------------------------------------------- */
/* client.c */
/* Case 6-6) : send는 어떤 모드인가 ? */
/* 최종 수정일 : 2002.03.10 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#define MAXSIZE 512
#define ServicePort 8001
int main(int argc, char *argv[])
{
int sd;
struct in_addr *InetAddr;
struct sockaddr_in ServerSockAddr;
struct hostent *ServerInfo;
char SndBuf[MAXSIZE], RcvBuf[MAXSIZE];
if ((ServerInfo = gethostbyname(argv[1])) == NULL) {
printf("Client Error! gethostbyname() error\n");
exit(-1);
}
InetAddr = (struct in_addr *) *(ServerInfo->h_addr_list);
printf("[Client] sever address %s \n", inet_ntoa(*InetAddr));
if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
printf("Client Error! socket() error \n");
exit(-1);
}
printf("[Client] Socket created.\n");
bzero((char*) &ServerSockAddr, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr.sin_port = htons(ServicePort);
printf("[Client] Clint sent connection request.\n");
if (connect(sd, (struct sockaddr *) &ServerSockAddr, sizeof(ServerSockAddr)) < 0) {
printf("Client Error! connect() error\n");
exit(-1);
}
printf("[Client] Clint and server connected.\n");
printf("[Client] Input Data ? ");
gets(SndBuf);
send(sd, SndBuf, (sizeof(SndBuf)), 0);
//send() mode를 Test -- Updated
printf("send() is nonblocking");
recv(sd, RcvBuf, (sizeof(RcvBuf)), 0);
printf("[Client] Client received Data.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf);
close(sd);
printf("[Client] Client Exit.\n");
}
② 실행 결과
server : server를 실행시키고 임의의 수를 입력받을 때까지 대기한다.
client : data를 보냈으나 server측에서 recv() 수행하지 않자 client는 계속 대기하고 있다.
③ 결과 분석
send()는 blocking mode로 동작한다. client에서 data를 보내고 server에서 recv()가 수행될 때까지 block 상태로 대기한다. recv()도 blocking mode로 동작한다. 기본예제 수행 결과를 보고 알 수 있는데 server와 client가 접속이 이루어진 상태에서 server는 client로부터 data를 전달받을 때까지 block 상태로 대기한다.
2) accept와 connect는 어떤 mode로 동작하는가?
① 동작 설명
accept가 어떤 모드인지는 기본예제에서 확인 할 수 있다. connect가 어떤 모드인지를 알기 위해서는 client가 connect request를 server에게 보냈을 때 server가 connect request를 받지 않을 때를 확인하면 알 수 있다.
/* --------------------------------------------------------------------- */
/* server.c */
/* Case 6-6) : connect()는 어떤 mode로 동작하는가 */
/* 최종 수정일 : 2002.03.10 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 8001
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
while (1)
{
//Updata - connect가 어떤 모드인지 확인
printf("If continue, enter any number. "); scanf("%d", &num);
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen)) <
0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { /* Parent Process */
close(Csock);
}
}
}
/* --------------------------------------------------------------------- */
/* client.c */
/* Case 6-6) : connect()는 어떤 mode로 동작하는가 */
/* 최종 수정일 : 2002.03.10 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#define MAXSIZE 512
#define ServicePort 8001
int main(int argc, char *argv[])
{
int sd;
struct in_addr *InetAddr;
struct sockaddr_in ServerSockAddr;
struct hostent *ServerInfo;
char SndBuf[MAXSIZE], RcvBuf[MAXSIZE];
if ((ServerInfo = gethostbyname(argv[1])) == NULL) {
printf("Client Error! gethostbyname() error\n");
exit(-1);
}
InetAddr = (struct in_addr *) *(ServerInfo->h_addr_list);
printf("[Client] sever address %s \n", inet_ntoa(*InetAddr));
if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
printf("Client Error! socket() error \n");
exit(-1);
}
printf("[Client] Socket created.\n");
bzero((char*) &ServerSockAddr, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr.sin_port = htons(ServicePort);
printf("[Client] Clint sent connection request.\n");
if (connect(sd, (struct sockaddr *) &ServerSockAddr, sizeof(ServerSockAddr)) < 0) {
printf("Client Error! connect() error\n");
exit(-1);
}
printf("[Client] connect is nonblocking.\n");
printf("[Client] Input Data ? ");
gets(SndBuf);
send(sd, SndBuf, (sizeof(SndBuf)), 0);
printf("[Client] Client sent Data.\n");
recv(sd, RcvBuf, (sizeof(RcvBuf)), 0);
printf("[Client] Client received Data.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf);
close(sd);
printf("[Client] Client Exit.\n");
}
② 실행 결과
server : accept() 바로 앞에서 프로그램을 멈추게 하였다.
client : server로 connect 요청을 하였다. server가 accept를 하지 않고 대기만 하였지만 client는 다음 명령을 수행하는 모습을 볼 수 있다.
③ 결과 분석
accept는 기본예제에서 보듯이 client가 connect request를 보낼 때까지 blocking mode로 대기하고 있음을 알 수 있다. connect는 위의 실행 결과처럼 client가 connect를 요청하고 server는 accept를 하지 않고 멈춰져 있었다. 그러나 client는 connect request를 받아들여지는 것과 상관없이 다음 명령을 수행함으로서 nonblocking임을 알 수 있다.
6-7. 복수의 통신로를 열었을 때?
① 동작 설명
생성된 하나의 Socket에 두 개의 port를 binding해야 되지만 하나의 Socket에 두 개의 port를 binding 할 수 없어 각 각 socket을 생성, binding, listen, send, recv를 한다. 그러기 위해 server.c와 client.c를 각각 아래와 같이 수정한다. service port는 9005, 9006번이다.
/* --------------------------------------------------------------------- */
/* server.c */
/* Case6-7) : 복수채널을 이용한 통신 (Server 2 : Client 2) */
/* 최종 수정일 : 2002.02.22 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort1 9005 // Updated!! Chanel 1 Port
#define ServicePort2 9006 // Updated!! Chanel 2 Port
#define MSG "Server processed successfully according your requests."
//Updated!! Add to Function Loop
void Loop(int Rsock, int Csock, struct sockaddr_in C_addr, int i);
int main()
{
int pid;
int Rsock1, Rsock2, Csock1, Csock2; // Updated!! Two Socket Descriptor
char ServerName[20]; // Server Domain Name
struct sockaddr_in SockAddr1, SockAddr2; // Updated! for Server Address struct
struct sockaddr_in ClientAddr1, ClientAddr2; // Updated! for Client
if (gethostname(ServerName, sizeof(ServerName)))
{
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock1 = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
printf("Server 1 Error! socket() error");
exit(-1);
}
printf("[Server 1] Socket created.\n");
//Updated!! Created Chanel 2 Socket
if ((Rsock2 = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
printf("Server 2 Error! socket() error");
exit(-1);
}
printf("[Server 2] Socket created.\n");
bzero((char*) &SockAddr1, sizeof(SockAddr1));
SockAddr1.sin_family = AF_INET;
SockAddr1.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr1.sin_port = htons(ServicePort1);
bzero((char*) &SockAddr2, sizeof(SockAddr2)); //Updated! Adderess Chanel 2
SockAddr2.sin_family = AF_INET;
SockAddr2.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr2.sin_port = htons(ServicePort2);
if (bind(Rsock1, (struct sockaddr *) &SockAddr1, sizeof(SockAddr1)))
{
printf("Server 1 Error! bind() error");
exit(-1);
}
printf("[Server 1] Socket binded.\n");
// Updated! Binded Chanel 2
if (bind(Rsock2, (struct sockaddr *) &SockAddr2, sizeof(SockAddr2)))
{
printf("Server 2 Error! bind() error");
exit(-1);
}
printf("[Server 2] Socket binded.\n");
if (listen(Rsock1, 5))
{
printf("Server 1 Error! listen() error");
exit(-1);
}
printf("[Server 1] Socket listened.\n");
if (listen(Rsock2, 5))
{
printf("Server 2 Error! listen() error");
exit(-1);
}
printf("[Server 2] Socket listened.\n"); // Updated!! listened Chanel 2
if ((pid = fork()) < 0 ) // Updated!! for each chanel process
{
printf("Server fork() error !! ");
exit(-1);
}
else if (pid == 0)
{
close(Rsock2);
Loop(Rsock1,Csock1,ClientAddr1,1);
}
else if (pid > 0)
{
close(Rsock1);
Loop(Rsock2,Csock2,ClientAddr2,2);
}
}
void Loop(int Rsock, int Csock, struct sockaddr_in C_addr, int i)
{
char buf[80];
int num;
int ClientAddrLen;
int pid;
while(1)
{
ClientAddrLen = sizeof(C_addr);
if ((Csock = accept(Rsock, (struct sockaddr *) &C_addr,
&ClientAddrLen)) < 0 )
{
printf("Server %d Error! accept() error\n",i);
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server %d] Client (%s:%d) and server Connected.\n",i,
inet_ntoa(C_addr.sin_addr),C_addr.sin_port);
printf("[Server %d] Created child process.\n",i);
if ((pid=fork()) < 0)
{
printf("Server Error! fork() error");
exit(-1);
}
else if (pid == 0)
{
close(Rsock);
printf("[Server %d:Child] Waiting for client data.\n",i);
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0)
{
printf("[Server %d:Child] Receive Error!\n",i);
exit(-1);
}
printf("[Server %d:Child] Data from Client(%s:%d)
[%s]\n",i,inet_ntoa(C_addr.sin_addr), C_addr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Server %d:Child] Sent response message to client.\n",i);
printf("[Server %d:Child] Exit.\n",i);
exit(0);
}
else if (pid > 0)
{
close(Csock);
}
}
}
/* -------------------------------------------------------------------- */
/* client.c */
/* Case6-7) : 복수채널을 이용한 통신 (Server 2 : Client 2) */
/* 최종 수정일 : 2002.02.22 */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#define MAXSIZE 512
#define ServicePort1 9005
#define ServicePort2 9006
int main(int argc, char *argv[])
{
int sd, pid;
struct in_addr *InetAddr;
struct sockaddr_in ServerSockAddr1, ServerSockAddr2;
struct hostent *ServerInfo;
char SndBuf1[MAXSIZE], RcvBuf1[MAXSIZE];
char SndBuf2[MAXSIZE], RcvBuf2[MAXSIZE];
if ((ServerInfo = gethostbyname(argv[1])) == NULL)
{
printf("Client Error! gethostbyname() error\n");
exit(-1);
}
InetAddr = (struct in_addr *) *(ServerInfo->h_addr_list);
printf("[Client] sever address %s \n", inet_ntoa(*InetAddr));
printf("[Client] Input Data to send to Server 1 ? ");
gets(SndBuf1);
printf("[Client] Input Data to send to Server 2 ? ");
gets(SndBuf2);
if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
{
printf("Client Error! socket() error \n");
exit(-1);
}
printf("[Client] Socket created.\n");
bzero((char*) &ServerSockAddr1, sizeof(ServerSockAddr1));
ServerSockAddr1.sin_family = AF_INET;
ServerSockAddr1.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr1.sin_port = htons(ServicePort1);
bzero((char*) &ServerSockAddr2, sizeof(ServerSockAddr2));
ServerSockAddr2.sin_family = AF_INET;
ServerSockAddr2.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr2.sin_port = htons(ServicePort2);
printf("[Client] Clint sent connection request.\n\n");
if ((pid=fork()) <0 )
{
printf("Client error !! fork() error\n");
exit(-1);
}
else if (pid == 0)
{
if (connect(sd, (struct sockaddr *) &ServerSockAddr1,
sizeof(ServerSockAddr1)) < 0)
{
printf("Client Error! connect() Server 1 error\n");
exit(-1);
}
printf("[Client] Client and server 1 connected.\n");
send(sd, SndBuf1, (sizeof(SndBuf1)), 0);
printf("[Client] Client sent Data to server 1.\n");
recv(sd, RcvBuf1, (sizeof(RcvBuf1)), 0);
printf("[Client] Client received Data from server 1.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf1);
close(sd);
printf("[Client] Client Exit - server 1.\n");
}
else if (pid > 0)
{
if (connect(sd, (struct sockaddr *) &ServerSockAddr2,
sizeof(ServerSockAddr2)) < 0)
{
printf("Client Error! connect() Server 2 error\n");
exit(-1);
}
printf("[Client] Client and server 2 connected.\n");
send(sd, SndBuf2, (sizeof(SndBuf2)), 0);
printf("[Client] Client sent Data to server 2.\n");
recv(sd, RcvBuf2, (sizeof(RcvBuf2)), 0);
printf("[Client] Client received Data from server 2.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf2);
close(sd);
printf("[Client] Client Exit - server 2.\n");
}
exit(0);
}
② 실행 결과
server : server 프로그램을 실행시킨다.
netstat : 각 각 socket이 binding한 것을 볼 수 있다.
client : 각 data를 server로 전송했다.
server : 각 data를 전달받고 응답 메시지를 보냈다.
③ 결과 분석
생성된 하나의 socket에 두 개의 port를 bind 할 수 없다. 따라서 위와 같이 Test하였다. 또한 하나의 Process는 한번만 accept되며, 한번만 connect 되고, 하나의 통신 채널만을 가진다.
6-8. UDP Socket 통신의 특징과 기본 절차를 알아보자.
① 동작 환경.
기본 형식을 TCP의 기본예제를 바탕으로 만들었으며, UDP 특성상 listen과 accept등을 사용하지 않았으므로 Process를 fork할 필요도 없었다. server의 service port는 5800이고 client의 service port는 5801이다.
/* --------------------------------------------------------------------- */
/* server.c */
/* Case 6-8) : UDP Socket의 특징과 기본 절차를 알아보자 (UDP Socket) */
/* 최종 수정일 : 2002.02.22 */
/* --------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 5800
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
while (1)
{
printf("[Child] Waiting for client data.\n");
if ((num = recvfrom(Rsock, buf, sizeof(buf), 0,(struct sockaddr
*)&ClientAddr,&ClientAddrLen)) < 0) {
printf("[Server] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
sendto(Rsock, MSG, (sizeof(MSG)), 0,(struct sockaddr
*)&ClientAddr,sizeof(struct sockaddr));
printf("[Child] Sent response message to client.\n");
}
}
/* -------------------------------------------------------------------- */
/* client.c */
/* Case 6-8) : UDP Socket의 특징과 기본 절차를 알아보자 (UDP Socket) */
/* 최종 수정일 : 2002.02.22 */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#define MAXSIZE 512
#define ServerPort 5800
#define ClientPort 5801
int main(int argc, char *argv[])
{
int sd,num,addr_len;
struct in_addr *InetAddr;
struct sockaddr_in ServerSockAddr;
struct sockaddr_in ClientSockAddr;
struct hostent *ServerInfo;
char SndBuf[MAXSIZE], RcvBuf[MAXSIZE],SndBu[20];
if ((ServerInfo = gethostbyname(argv[1])) == NULL) {
printf("Client Error! gethostbyname() error\n");
exit(-1);
}
InetAddr = (struct in_addr *) *(ServerInfo->h_addr_list);
printf("[Client] sever address %s \n", inet_ntoa(*InetAddr));
if ((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {
printf("Client Error! socket() error \n");
exit(-1);
}
printf("[Client] Socket created.\n");
bzero((char*) &ServerSockAddr, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr.sin_port = htons(ServerPort);
bzero((char*) &ClientSockAddr, sizeof(ClientSockAddr));
ClientSockAddr.sin_family = AF_INET;
ClientSockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
ClientSockAddr.sin_port = htons(ClientPort);
if (bind(sd,(struct sockaddr *)&ClientSockAddr,sizeof(struct sockaddr)))
{
printf("Client Error! bind() error");
exit(1);
}
printf("[Client] Input Data ? ");
gets(SndBuf);
sendto(sd, SndBuf, sizeof(SndBuf), 0,(struct sockaddr
*)&ServerSockAddr,sizeof(struct sockaddr));
printf("[Client] Client sent Data.\n");
recvfrom(sd, RcvBuf, sizeof(RcvBuf), 0,(struct
sockaddr*)&ServerSockAddr,&addr_len);
printf("[Client] Client received Data.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf);
close(sd);
printf("[Client]Client Exit.\n");
return 0;
}
② 실행 환경
server : server 프로그램을 실행한 화면
client : 전달받을 data를 가지고 server로 접속하려고 한다.
netstat : server와 client의 모습을 확인 할 수 있다
netstat : data를 전달받고 client는 종료 된 화면이다..
③ 결과 분석
TCP와 UDP는 조금의 차이점을 가지고 있다. 먼저 TCP는 오류제어, 흐름제어, 시퀀스 제어를 하기 때문에 데이터의 안정성이 보장되나 UDP는 data 제어 없이 보내기 때문에 안정성을 보장받을 수 없다. UDP data 제어를 하지 않기 때문에 TCP 통신보다 속도가 훨씬 빠르다는 것을 알 수 있다.
Source의 흐름상 다른 점은 UDP는 client도 bind를 한다는 점이다. 비연결지향적이기 때문이다. 그리고 listen과 accept를 하지 않아도 된다는 것이다. 이 또한 비연결지향적이기 때문이다.
6-9. UDP Socket 통신에서 오류제어를 확인하기 위해 대용량 data를 보내면?
① 동작 환경
client가 server로 우리 나라 우편번호를 모두 수록한 zipcode.txt를 보낼 때 정확하게 data를 모두 전달받는지 확인한다. server.c와 client.c는 아래와 같다. server의 service port는 5800이고, client의 service port는 5801이다.
/* ------------------------------------------------------------------- */
/* server.c */
/* Case 6-9) : UDP Socket을 이용한 통신 */
/* 오류제어를 확인하기 위해 대용량 data 전달 */
/* 최종 수정일 : 2002.02.22 */
/* ------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#define ServicePort 5800
#define BUFFERSIZE 4096
#define MSG "Server processed successfully according your requests."
main()
{
int sock, i;
int addr_len, bytes;
char ServerName[20];
char buf[BUFFERSIZE];
struct sockaddr_in SockAddr; /* my address information */
struct sockaddr_in ClientAddr; /* connector's address information */
if(gethostname(ServerName, sizeof(ServerName))){
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name:%s\n", ServerName);
//Updated : 소켓의 유형지정(UDP)
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind (sock,(struct sockaddr *)&SockAddr, sizeof(struct sockaddr))) {
printf("Server Error! bind() error");
exit(1);
}
printf("[Server] Socket binded.\n");
addr_len = sizeof(struct sockaddr);
while(1){
printf("[Child] Waiting for client data.\n");
//Updated : recvfrom으로 client측에서 sendto로 보낸 내용을 버퍼단위
만큼 읽은 데이터의 바이트수 반환
if ((bytes=recvfrom(sock, buf, BUFFERSIZE, 0,(struct sockaddr
*)&ClientAddr, &addr_len)) == -1){
printf("Server Error! recvfrom() error");
exit(1);
}
buf[bytes] = '\0';
printf("Data from Client(%s:%d)\n[%s]\n", inet_ntoa(ClientAddr.sin_addr),
ClientAddr.sin_port,buf);
for(i=0; i<BUFFERSIZE; i++)
buf[i]=NULL;
//Updated : sendto로 클라이언트측으로 MSG의 메세지를 보낸다.
if ((bytes=sendto(sock, MSG, strlen(MSG), 0, (struct sockaddr
*)&ClientAddr, sizeof(struct sockaddr))) == -1){
printf("Client Error! sendto() error");
exit(1);
}
printf("Sent response message to client.\n");
}
close(sock);
}
/* -------------------------------------------------------------------- */
/* client.c */
/* Case 6-9) : UDP Socket을 이용한 통신 */
/* 오류제어를 확인하기 위해 대용량 data 전달 */
/* 최종 수정일 : 2002.02.22 */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
//Updated : 파일관련 include문
#include <unistd.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <sys/stat.h>
#define ServerPort 5800
#define ClientPort 5801
#define MAXSIZE 512
#define BUFFERSIZE 4096
int main(int argc, char *argv[])
{
int sock, addr_len;
int fd, bytes=0,numbytes, i;
char buffer[BUFFERSIZE];
char RcvFromBuf[MAXSIZE];
struct sockaddr_in ServerSockAddr; /* connector's address information */
struct sockaddr_in ClientSockAddr; /* my address information */
struct in_addr *InetAddr;
struct hostent *ServerInfo;
if ((ServerInfo=gethostbyname(argv[1])) == NULL){ /* get the host info */
printf("Client Error! gethostbyname() error\n");
exit(1);
}
//Updated : 파일을 읽기 모드로 연다(저수준 입출력)
if((fd=open(argv[2],O_RDONLY))<0){
printf("Cannot open the file!");
exit(1);
}
InetAddr=(struct in_addr *) *(ServerInfo->h_addr_list);
printf("[Client] server address %s \n",inet_ntoa(*InetAddr));
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1){
printf("Client Error! socket() error\n");
exit(1);
}
printf("[Client] Socket created.\n");
bzero((char*) &ServerSockAddr, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_port = htons(ServerPort);
ServerSockAddr.sin_addr.s_addr = InetAddr->s_addr;
//Updated : 서버측에서의 sendto를 받기 위해 client구조체 설정
bzero((char*) &ClientSockAddr, sizeof(ClientSockAddr));
ClientSockAddr.sin_family = AF_INET;
ClientSockAddr.sin_port = htons(ClientPort);
ClientSockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind (sock,(struct sockaddr *)&ClientSockAddr, sizeof(struct sockaddr))) {
printf("Server Error! bind() error");
exit(1);
}
printf("[Server] Socket binded.\n");
for(i=0; i<BUFFERSIZE; I++)
buffer[i]=NULL;
//Updated : 파일에서 read로 버퍼단위만큼 읽어서 sendto로 서버측으로 보내는 while문
while((numbytes=read(fd,buffer,BUFFERSIZE))>0){
if ((bytes=sendto(sock, buffer, strlen(buffer), 0, (struct sockaddr
*)&ServerSockAddr, sizeof(struct sockaddr))) == -1){
printf("Client Error! sendto() error");
exit(1);
}
for(i=0; i<BUFFERSIZE; I++)
buffer[i]=NULL;
printf("sent %d bytes to %s\n",bytes,inet_ntoa(ServerSockAddr.sin_addr));
}
close(fd);
addr_len = sizeof(struct sockaddr);
//Updated : server측에서 sendto로 보낸 메제지를 recvfrom으로 받는 구문
if ((bytes=recvfrom(sock, RcvFromBuf, MAXSIZE, 0,(struct sockaddr
*)&ServerSockAddr, &addr_len)) == -1){
printf("Client Error! recvfrom() error");
exit(1);
}
printf("%s\n",RcvFromBuf);
close(sock);
printf("[Client] Client Exit.\n");
return 0;
}
② 실행 결과
server : server 프로그램을 실행시킨 하면
netstat : data를 전달받기 위해 대기하고 있는 화면
client : zicode.txt를 모두 server로 보냈다.
server : client에서는 zipcode.txt를 모두 보냈으나 일부만 받은 화면
③ 결과 분석
UDP에서 매 실행 시 결과가 틀리며 data의 손실이 있다. UDP에서는 TCP에서와 같은 제어를 하지 않기 때문에 실행 결과에서 보는 바와 같이 많은 데이터의 손실이 있다. 또한 같은 data(zipcode.txt)를 TCP 통신으로 보낼 때와는 아주 많은 속도 차이를 보인다. 이 이유로 UDP는 흐름제어, 오류제어, 시퀀스제어를 하지 않고 data를 보내기 때문이다.
6-10. Bind Error는 언제 발생하는가?
1) Close하지 않았을 때 bind error가 발생하는가 ?
① 동작 설명
client.c는 기본예제이고, server.c는 close() 부분만 주석 처리하였다. service port는 8038이다.
/* -------------------------------------------------------------------- */
/* server.c */
/* Case 6-10) : bind error는 언제 발생하는가 ? */
/* close를 하지 않았을 때 */
/* 최종 수정일 : 2002.02.22 */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 8038
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr; // struct sockaddr ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
while (1)
{
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr,
&ClientAddrLen)) < 0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
//close(Csock); // Be Careful!
exit(0);
} else if (pid > 0) { /* Parent Process */
close(Csock);
}
}
}
② 실행 결과
server : 정상적으로 data를 전달받은 화면
client : 정상적으로 data를 전달한 모습
netstat : data 전달 후 네트뚺 상태
server : CTRL + C 후 다시 server를 실행시킨 화면
③ 결과 분석
close()를 하지 않더라도 프로그램이 종료되면서 Process가 점유하고 있던 Port를 반환하므로 다시 server program을 실행 시켜도 bind error 가 발생하지 않는다.
서버 프로그램에서 close()부분을 주석처리 하였기 때문에 client에서 먼저 close 요청을 보내게 된다. 그러므로 client프로세서가 TIME_WAIT상태에 빠지게 되고 서버 프로그램을 다시 실행시켜도 bind error가 생기는 경우는 발생하지 않는다.
2) exit를 하지 않을 경우 bind error가 발생하는가 ?
① 동작 환경
client.c는 기본예제이고 server.c는 exit(0) 부분만 주석 처리하여 실행한다. service port는 8038이다.
/* ------------------------------------------------------------------- */
/* server.c */
/* Case 6-10) : Port Binding 문제 (TCP Socket) */
/* exit()를 하지 않은 경우 */
/* 최종 수정일 : 2002.02.22 */
/* ------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define ServicePort 8038
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock; // Socket Descriptor
char ServerName[20]; // Server Domain Name
int ClientAddrLen; // Client Address Length
char buf[80]; // Receiving Buffer
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr; // struct sockaddr ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
while (1)
{
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen)) <
0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) { /* Child Process */
close(Rsock);
printf("[Child] Waiting for client data.\n");
if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) {
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock); // Be Careful!
// exit(0);
} else if (pid > 0) { /* Parent Process */
close(Csock);
}
}
}
② 실행 결과
server : 정상적으로 실행한다.
client : 정상적으로 실행한다.
netstat : server와 client 간의 접속이 확립되었다.
server : client로부터 data를 받고 바로 accept error가 발생한다.
server : server를 죽이고 다시 실행하자 bind error가 발생한다.
③ 결과 분석
accept error가 발생하는 것은 communication 소켓이 exit를 하지 않아 죽지 않고 그대로 살아있기 때문에 발생한다.
close, exit로 프로그램을 종료 시에서 bind error가 발생할 가능성이 있다. server측에서 TIME_WAIT 상태가 되면 bind error가 발생하기 때문이다. client측에서 TIME_WAIT 상태에 놓이면 bind error는 나지 않는다. 이는 client가 bind를 하지 않기 때문이다. bind를 하지 않으면 충돌이 나지 않는 임의의 포트를 사용하기 때문이다.
Process kill, CTRL + C로 종료 할 경우는 bind error가 나지 않는다. 이는 프로세스가 강제 종료 시 모든 자원을 OS나 커널이 강제로 뺏어 버리기 때문이다.
< 참고 > TIME_WAIT
TIME_WAIT 상태에 머무는 시간은 MSL(최대 세그먼트 수명)의 두 배이다. 버클리 소켓에서의 시간은 전통적으로 30초를 사용한다. 이는 TIME_WAIT 상태에 머무는 시간이 1분에서 4분 사이임을 뜻한다. MSL은 어느 IP의 Datagram이 인터넷에 살아있는 최대 시간이다.
우리가 일반적으로 bind error가 났을 때 일정시간이 지나면 다시 프로그램이 실행되는 이유가 바로 일정시간이 지나면 TIME_WAIT 상태로 프로세서가 점유하고 있던 리소스를 OS가 반환 받기 때문이다.
6-11. Server나 Client가 죽는 경우 ?
1) Server의 child process가 죽는 경우 ?
① 동작 환경
concurrent 방식을 사용할 것이며 server.c와 client.c는 소스 수정 없이 기본예제로 진행한다. server port는 8001번이다.
② 실행 결과
server : server 프로그램을 실행하였다.
ps : server process가 활성화되어 있는 화면, parend process는 22885번이다.
client : client가 접속한다.
ps : client가 접속 후 child process가 생성되었다.
ps : child process를 kill했다.
client : server의 child process를 kill후 data를 보냈다.
ps : kill된 child process가 좀비 process로 남아 있다.
③ 결과 분석
server의 child process를 kill한 후 client에서 server로 data를 보냈으나 응답 메시지를 받지 못했다.
이는 server의 child process와 client가 connect되어 있는 상태였는데 server쪽의 process를 죽이니까 둘 간의 연결이 끊어져 버렸다. kill된 child process는 좀비 process로 남아있으며, parent process가 죽지 않는 한 계속 유지된다.
2) server의 parent process가 죽는 경우
① 동작 환경
concurrent 방식을 사용할 것이며 server.c와 client.c는 소스 수정 없이 기본예제로 진행한다. server port는 8001번이다.
② 실행 결과
server : server 프로그램을 실행한다.
ps : server의 parent process를 확인한다.
ps : client가 접속하고, server는 child process를 생성했다.
ps : server의 parent process를 kill 했다.
server : parent process가 죽은 후에도 child process는 client로부터 data를 전달받았다.
③ 결과 분석
server의 parent process가 죽어도 child procss는 client와 정상적으로 data를 주고받는다.
이는 parent proces는 client로부터 connect만 만들어지고 data 전달과정은 child process와 이루어지기 때문이다.
3) client process가 통신 중 죽는 경우.
① 동작 환경
data를 보내는 중 client가 죽는 경우이므로 buffer의 크기를 늘인다. data가 전달되는 과정을 화면에 나타내기 위해 file open부분이 필요하다. 또한 한번만 recv않고 계속적으로 받기 위해 소스를 아래와 같이 server.c와 client.c를 수정한다.
/* -------------------------------------------------------------------- */
/* server.c */
/* Case 6-11) : server나 client process를 강제로 죽일 경우 */
/* 3) 데이터 전송도중 client가 죽을 경우 ? */
/* 최종 수정일 : 2002.02.22 */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define BUFFERSIZE 4096 // updated !
#define ServicePort 8001
#define MSG "Server processed successfully according your requests."
int main()
{
int pid, num;
int Rsock, Csock;
char ServerName[20];
int ClientAddrLen;
char buf[BUFFERSIZE]; // updated !
struct sockaddr_in SockAddr;
struct sockaddr_in ClientAddr;
if (gethostname(ServerName, sizeof(ServerName))) {
printf("Server Error! gethostname() error\n");
exit(-1);
}
printf("\n[Server] server name: %s\n", ServerName);
if ((Rsock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
printf("Server Error! socket() error");
exit(-1);
}
printf("[Server] Socket created.\n");
bzero((char*) &SockAddr, sizeof(SockAddr));
SockAddr.sin_family = AF_INET;
SockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
SockAddr.sin_port = htons(ServicePort);
if (bind(Rsock, (struct sockaddr *) &SockAddr, sizeof(SockAddr))) {
printf("Server Error! bind() error");
exit(-1);
}
printf("[Server] Socket binded.\n");
if (listen(Rsock, 5)) {
printf("Server Error! listen() error");
exit(-1);
}
printf("[Server] Socket listened.\n");
while (1)
{
printf("[Server] Waiting for connection request.\n\n");
ClientAddrLen = sizeof(ClientAddr);
if ((Csock = accept(Rsock, (struct sockaddr *) &ClientAddr, &ClientAddrLen)) <
0) {
printf("Server Error! accept() error\n");
printf("Rsock = %d Csock = %d\n", Rsock, Csock);
exit(-1);
}
printf("[Server] Client(%s) and Server Connected.\n",
inet_ntoa(ClientAddr.sin_addr));
printf("[Server] Created child process.\n");
if ((pid = fork()) < 0 ) {
printf("Server Error! fork() error");
exit(-1);
} else if (pid == 0) {
close(Rsock);
printf("[Child] Waiting for client data.\n");
/* if ((num = recv(Csock, buf, sizeof(buf), 0)) < 0) { // Updated !
printf("[Child] Receive Error!\n");
exit(-1);
}
printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf); */
while((num = recv(Csock, buf, sizeof(buf), 0)) > 0){ // Updated ! if(num<0){
printf("[Child] Receive Error!\n");
exit(-1);
}
else printf("[Child] Data from Client(%s:%d) [%s]\n",
inet_ntoa(ClientAddr.sin_addr), ClientAddr.sin_port, buf);
}
send(Csock, MSG, (sizeof(MSG)), 0);
printf("[Child] Sent response message to client.\n");
printf("[Child] Exit.\n");
close(Csock);
exit(0);
} else if (pid > 0) {
close(Csock);
}
}
}
/* --------------------------------------------------------------------- */
/* client.c */
/* Case 6-11) : server나 client process를 강제로 죽일 경우 */
/* 3) 데이터 전송도중 client가 죽을 경우 ? */
/* 최종 수정일 : 2002.02.22 */
/* -------------------------------------------------------------------- */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <sys/stat.h>
#define BUFFERSIZE 4096 // update !
#define MAXSIZE 512
#define ServicePort 8001
int main(int argc, char *argv[])
{
int sd;
int numbytes,infd,outfd,bytes,i; // update !
char buffer[BUFFERSIZE]; // update !
struct in_addr *InetAddr;
struct sockaddr_in ServerSockAddr;
struct hostent *ServerInfo;
char SndBuf[MAXSIZE], RcvBuf[MAXSIZE];
if ((ServerInfo = gethostbyname(argv[1])) == NULL) {
printf("Client Error! gethostbyname() error\n");
exit(-1);
}
InetAddr = (struct in_addr *) *(ServerInfo->h_addr_list);
printf("[Client] sever address %s \n", inet_ntoa(*InetAddr));
if ((infd=open(argv[2],O_RDONLY))<0){ // update !
printf("File not open Error!");
exit(1);
}
if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0 ) {
printf("Client Error! socket() error \n");
exit(-1);
}
printf("[Client] Socket created.\n");
bzero((char*) &ServerSockAddr, sizeof(ServerSockAddr));
ServerSockAddr.sin_family = AF_INET;
ServerSockAddr.sin_addr.s_addr = InetAddr->s_addr;
ServerSockAddr.sin_port = htons(ServicePort);
printf("[Client] Clint sent connection request.\n");
if (connect(sd, (struct sockaddr *) &ServerSockAddr, sizeof(ServerSockAddr)) < 0) {
printf("Client Error! connect() error\n");
exit(-1);
}
printf("[Client] Clint and server connected.\n");
/* printf("[Client] Input Data ? "); // update !
gets(SndBuf);
send(sd, SndBuf, (sizeof(SndBuf)), 0);
printf("[Client] Client sent Data.\n");
recv(sd, RcvBuf, (sizeof(RcvBuf)), 0);
printf("[Client] Client received Data.\n");
printf("[Client] Data from Server [%s]\n", RcvBuf); */
while((bytes=read(infd,buffer,BUFFERSIZE))>0){ // update !
send(sd,buffer,(sizeof(buffer)),0);
printf("sent %d bytes to %s\n",bytes,inet_ntoa(ServerSockAddr.sin_addr));
}
close(infd); // update !
close(outfd); // update !
close(sd);
printf("[Client] Client Exit.\n");
}
② 실행 결과
server : server 프로그램을 실행한다.
ps : server의 parent process를 확인한다.
client : zipcode.txt라는 1.8MByte data를 전송한다.
ps : server로 data를 전송하는 동안 process 상태 표시
ps : server로 data를 전송하는 동안 client process를 kill 했다.
client : kill하는 순간 data 전달이 끊겼다.
③ 결과 분석
server로 data를 전달하는 client를 강제로 kill할 경우 위와 같이 kill한 순간 data 전달이 끊겨진다.
6-12. 표준 인터넷 등록 서비스
1) 소스 파일 첨부.
/*******************************************************************************/
/* ECHOC.C */
/* 표준 인터넷 등록 서비스 */
/*******************************************************************************/
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#define MAXLINE 512
int main(int argc, char *argv[])
{
int sd;
struct in_addr *ptr1;
struct sockaddr_in server;
char buf[80] ;
char sendline[MAXLINE], recvline[MAXLINE+1];
struct hostent *host;
struct servent *serv;
FILE *fp;
if ((host = gethostbyname(argv[1])) == NULL) {
printf("server-side : error gethostbyname\n");
exit(1);
} else ptr1 = (struct in_addr *) *(host->h_addr_list);
if ((serv = getservbyname("echoex", "tcp"))== NULL) {
printf("server : getservbyname error");
exit(2);
} else printf("\nechoex server port : %d\n", serv->s_port);
bzero((char*)&server, sizeof(server));
server.sin_family = AF_INET;
server.sin_addr.s_addr = ptr1->s_addr;
server.sin_port = htons(serv->s_port);
if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
printf("client:socket error \n");
printf("sever address %s \n", inet_ntoa(*ptr1));
if(connect(sd, (struct sockaddr *)&server, sizeof(server))< 0)
printf("client:bind error \n");
gets(sendline);
send(sd, sendline, (sizeof(sendline)),0);
recv(sd, recvline, (sizeof(recvline)),0);
printf(" recv : %s \n",recvline);
close(sd);
exit(0);
}
/*******************************************************************************/
/* ECHOCD.C */
/* 표준 인터넷 등록 서비스 */
/*******************************************************************************/
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define MS "Server processed successfully."
#define MS1 "Server cannot process due to fork error."
main()
{
int rs, cs, fromlen, childpid, num ;
char name[20], buf[80];
struct sockaddr_in sin;
struct sockaddr from;
struct hostent *host;
struct servent *serv;
fromlen = sizeof(struct sockaddr);
if (gethostname(name, sizeof(name)))
printf("server: gethostname error");
else
printf("\nserver name : %s\n", name);
if ((host = gethostbyname(name)) == NULL)
printf("server : gethostbyname error");
if ((serv = getservbyname("echoex", "tcp"))== NULL )
printf("server : getservbyname error");
else
printf("\nechoex server port : %d\n", serv->s_port);
bzero((char*)&sin, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.sin_port = htons(serv->s_port);
if ((rs = socket(AF_INET, SOCK_STREAM, 0)) == -1)
printf("server: socket error");
if (bind(rs, (struct sockaddr *)&sin, sizeof(sin)))
printf("server: bind error");
if (listen(rs, 5))
printf("server: listen error");
for (;;)
{
cs = accept(rs, &from, &fromlen);
if (cs < 0)
printf("server: accept error");
if ((childpid = fork()) < 0 ) {
printf("server: fork error");
send(cs, MS1, (sizeof(MS1)), 0);
} else if (childpid == 0 ) {
close(rs);
num = recv(cs, buf, sizeof(buf), 0);
buf[num-1] = 0x00;
printf("server received [%s]\n", buf);
send(cs, MS, (sizeof(MS)), 0);
exit( 0 );
}
close (cs);
}
}