/*
	저작권
	http://ccl.korea.ac.kr - 리포트 소유권
	http://cakel.tistory.com - 프로그램 저작권

	교육용을 목적으로 자유롭게 쓰실수 있습니다.

	Thread_Client.cpp - 스레드를 활용한 멀티 채팅 서버의 클라이언트

	
	로컬 호스트 주소에 서버를 생성 / 복수의 클라이언트를 받은 후에
	클라이언트가 받은 메시지를 다른 클라언트들에게 전송하는 기능을 가지고 있습니다.

*/

#include <stdio.h>
#include <string.h>
#include <winsock.h>
#include <process.h>
#pragma comment(lib,"wsock32.lib")

#define PORT 5000			// 사용할 포트는 5000
#define IP "127.0.0.1"		// 접속할 서버는 로컬 호스트

void recv_thread(void*);	// 스레드 수행 함수의 프로토 타입

int ret = 0;				// 리턴 값
int s = 0;					// 소켓 값

HANDLE hMutex;				// 뮤텍스용

int main()
{
	// Welcome Screen
	printf("+---------------------------+\n");
	printf("+ 스레드를 이용한 멀티 채팅 +\n");
	printf("+ 클라이언트 부분           +\n");
	printf("+ http://cakel.tistory.com  +\n");
	printf("+ http://ccl.korea.ac.kr    +\n");
	printf("+---------------------------+\n");

	// 뮤택스 초기화
	hMutex = CreateMutex(NULL, FALSE, FALSE);
	if(!hMutex)

	{
		printf("Mutex 생성 오류\n");
		return 1;

	}

	// 윈속 초기화
	WSADATA wsd;
	char buff[1024];
	if(WSAStartup(MAKEWORD(1,1), &wsd) != 0)
	{
		printf("Winsock 오류\n");
		return 1;
	}

	// 서버로 접속하기 위한 소켓 생성
	sockaddr_in server;

	s = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	if (s == SOCKET_ERROR)
	{
		printf("socket() 오류\n");
		closesocket(s);
		WSACleanup();
		return 1;

	}

	server.sin_addr.s_addr = inet_addr(IP);
	server.sin_family = AF_INET;
	server.sin_port = htons(PORT);

	// 서버와 연결
	if( connect(s, (sockaddr*)&server, sizeof(server)) == SOCKET_ERROR)
	{
		printf("connect() 오류\n");
		closesocket(s);
		WSACleanup();
		return 1;

	}

	printf("서버와 연결이 되었음.\n");

	// 서버에서 우선 주는 Welcome 메시지 분석
	ret = recv(s, buff, 1024,0);
	printf("%s", buff);

	// 가득 찼다고 메시지가 왔다면
	if(!strcmp("가득찼습니다.\n",buff))
	{
		closesocket(s);
		WSACleanup();
		return 0;			// 접속을 종료
	}

	// 정상 접속이 되면 스레드 작동 - 받는 메시지를 스레드로 실시간 수행
	_beginthread(recv_thread, 0, NULL);

	// 보내는 메시지는 스레드로 넣을 필요가 없습니다.
	while(ret != INVALID_SOCKET || ret != SOCKET_ERROR)
	{
		
		// 딜레이 : CPU 점유율 감소용
		Sleep(10);
		printf("보낼 메시지 입력 : ");
		fgets(buff, 1024, stdin);
		
		// 전송 결과 잘못 된 결과를 얻었을때 탈출
		if(ret == INVALID_SOCKET || ret == SOCKET_ERROR) break;

		// 서버로 보내는 글은 fgets 을 받고 나서 순차적으로 보냄
		ret = send(s, buff, strlen(buff), 0);

		// 버퍼 초기화
		memset(buff, 0, 1024);

	}
	
	// 정상/비정상으로 서버와 통신 결과값이 틀린 값을 받았을 때
	printf("서버와 연결이 끊겼습니다.\n");
	closesocket(s);
	WSACleanup();

	return 0;
}

// 받는 스레드 부분
void recv_thread(void* pData)
{
		int ret_thread = 65535;
		char buff_thread[1024] = {0};
		
		// 스레드용 리턴 값이 우너하는 값이 아니면 받는 중에 서버와 통신이 끊겼다고 보고 나감
		while(ret_thread != INVALID_SOCKET || ret_thread != SOCKET_ERROR)
		{	
			Sleep(10);	// CPU 점유률 100% 방지용

			// 서버에서 주는 메시지를 실시간으로 기다렸다가 받습니다.
			ret_thread = recv(s, buff_thread, sizeof(buff_thread), 0);

			// 서버에서 받는 작업을 한 결과 비정상일 때 탈출
			if(ret_thread == INVALID_SOCKET || ret_thread == SOCKET_ERROR)
				break;
			
			// 정상적으로 받은 버퍼를 출력
			printf("\n%d 메시지 받음 : %s", strlen(buff_thread), buff_thread);
			memset(buff_thread,0,1024);	// 받은 버퍼를 초기와
		}

		// 작업이 끝난 소켓을 무효화시킴
		WaitForSingleObject(hMutex,100L);
		ret = INVALID_SOCKET;
		ReleaseMutex(hMutex);

		return;
}

/*
	저작권
	http://ccl.korea.ac.kr - 리포트 소유권
    http://cakel.tistory.com - 프로그램 저작권

	교육용을 목적으로 자유롭게 쓰실수 있습니다.

	로컬 호스트 주소에 서버를 생성 / 복수의 클라이언트를 받은 후에
	클라이언트가 받은 메시지를 다른 클라언트들에게 전송하는 기능을 가지고 있습니다.

*/

#include <stdio.h>
#include <process.h>
#include <winsock.h>
#include <windows.h>

#pragma comment(lib, "wsock32.lib")	
#define PORT 5000			// 사용포트는 5000
#define MAX_CLIENT 5		// 최대 허용 인원 수 5개
#define ALLOW 65535			// 최대 생성 가능 소켓 번호 65535

void recv_client(void *ns);	// 스레드 함수 프로토 타입
int client_num = 0;			// 점유 횟수 (클라이언트 갯수)
int seat = 0;				// 클라언트 번호
char welcome_ok[] = "번 클라이언트, 환영합니다.\n\0";	// Welcome 정상 초기 글
char welcome_full[] = "가득찼습니다.\n";				// Welcome 사용자 초가시 생기는 글
int client_sock[ALLOW];		// client_sock (클라이언트 Welcome Socket)
HANDLE hMutex = 0;			// 뮤택스

int main()
{
	// Welcome Screen
	printf("+---------------------------+\n");
	printf("+ 스레드를 이용한 멀티 채팅 +\n");
	printf("+ 서버 부분                 +\n");
	printf("+ http://cakel.tistory.com  +\n");
	printf("+ http://ccl.korea.ac.kr    +\n");
	printf("+---------------------------+\n");


	// 뮤택스 생성
	hMutex = CreateMutex(NULL, FALSE, NULL);	// 생성 실패시 오류
	if(!hMutex)
	{
		printf("Mutex 오류\n");
		CloseHandle(hMutex);
		return 1;
	}

	// 윈속 초기화
	WSADATA wsd;
	if(WSAStartup(MAKEWORD(1,1), &wsd) != 0)	// 사용 소켓 버전은 1.1
	{
		printf("Winsock 오류\n");
		WSACleanup();
		return 1;

	}

	// Listen 소켓 생성
	int s, addrsize, ret;
	sockaddr_in server, client;
	
	s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (s == SOCKET_ERROR)
	{
		printf("socket() 오류\n");
		closesocket(s);
		WSACleanup();
		return 1;
	}

	server.sin_addr.s_addr = htonl(INADDR_ANY);
	server.sin_family = AF_INET;
	server.sin_port = htons(PORT);

	// Bind 하기
	if( bind(s, (sockaddr*)&server, sizeof(server) ) == SOCKET_ERROR)
	{
		printf("bind() 오류\n");
		closesocket(s);
		WSACleanup();
		return 1;

	}

	printf("클라이언트를 기다립니다. %d 남음\n", MAX_CLIENT - client_num);
	listen(s,10);
	addrsize = sizeof(client);

	// 사용자의 접속을 기다립니다.
	while(1)
	{
		// Blocking 방식으로 Client 를 기다립니다.
		client_sock[seat] = accept(s, (sockaddr*)&client, &addrsize);

		// accept 시(중요, client_num 가 accept() 함수 수행중 에 변할수 있으므로
		// MAX_CLIENT 도달시랑 따로 accept() 시 문제 발생 가능성 있음
		if(client_num < MAX_CLIENT)		// 정상 맞이 하기
		{

			if(client_sock[seat] != INVALID_SOCKET || client_sock[seat] != SOCKET_ERROR){}
				_beginthread(recv_client, 0, &client_sock[seat]);
				Sleep(10);
				printf("%d번 클라이언트 %s:%d 에서 접속\n", seat, inet_ntoa(client.sin_addr), ntohs(client.sin_port));
				
		}

		else	// 가득 찾다.
		{
			addrsize = sizeof(client);
			if (client_sock[seat] == INVALID_SOCKET)
			{
				printf("accept() 오류\n");
				closesocket(client_sock[seat]);
				closesocket(s);
				WSACleanup();
				return 1;
			}

			ret = send(client_sock[seat], welcome_full, sizeof(welcome_full), 0);
			closesocket(client_sock[seat]);

			// 메시지 보내고 바로 끊는다.

		}
	}
	
	return 0;

}

void recv_client(void *ns)
{
	// 정상적으로 받아 드릴때, 스레드 실행
	// 클라이언트의 숫자를 늘림
	WaitForSingleObject(hMutex,INFINITE);
	client_num++;				// 클라이언트 갯수 증가
	seat++;						// 클라이언트 번호 증가
	printf("슬롯 %d개 남음\n", MAX_CLIENT - client_num);		// 갯수로 판단

	ReleaseMutex(hMutex);
	

	char welcome[100] = {0};		// accept 된 소켓에게 줄 버퍼 생성
	char buff[1024] = {0};
	int ret, i;
	

	itoa(seat,welcome,10);			// 클라이언트 번호
	strcat(welcome,welcome_ok);		// 정상 환영 메시지 환영
	ret = send(*(SOCKET*)ns, welcome, sizeof(welcome), 0);		// 전송

	while(ret != SOCKET_ERROR || ret != INVALID_SOCKET)
	{
		ret = recv(*(SOCKET*)ns, buff, 1024, 0);		// 클라이언트의 메시지를 받음

		// broadcast 부분
		for(i = 0; i < ALLOW; i++)
		{	
			// 받은 클라이언트 소켓의 메모리 주소와 보내는 클라이언트 소켓 메모리 주소가 다를때만 전송
			WaitForSingleObject(hMutex,INFINITE);		
			if( ((unsigned*)&client_sock[i] != (SOCKET*)ns))
			{
				send(client_sock[i], buff, strlen(buff), 0);
			}
				
			ReleaseMutex(hMutex);


		}

		// 서버 콘솔 창에 전송 기록 남김
		if(strlen(buff) != 0) printf("%d 메시지 보냄 : %s", strlen(buff), buff);

		memset(buff, 0, 1024);

	}

	// 접속된 소켓이 연결을 해제 시켰을때
	WaitForSingleObject(hMutex,INFINITE);
		client_num--;
		printf("%d 클라이언트 해제\n슬롯 %d개 남음\n", seat, MAX_CLIENT - client_num);
	ReleaseMutex(hMutex);

	closesocket(*(int*)ns);
	
	return;
}

/*
	저작권
	http://www.sockaddr.com/ExampleSourceCode.html
	http://cakel.tistory.com
	교육용을 전제로 자유롭게 사용할수 있습니다.

    PingI.cpp -- 마이크로소프트 ICMP API 를 사용한 간단한 ping 프로그램
	사용법 : pingi.exe [호스트 주소]	


*/

#include <windows.h>
#include <winsock.h>
#include <stdio.h>
#include <string.h>
#pragma comment(lib,"wsock32.lib")

typedef struct tagIPINFO
{	// IP 정보 태그 관련 구조체 입니다.
	u_char Ttl;				// Time To Live
	u_char Tos;				// Type Of Service
	u_char IPFlags;			// IP 플래그
	u_char OptSize;			// 옵션 데이터의 크기
	u_char FAR *Options;	// 옵션 데이터 버퍼

}IPINFO, *PIPINFO;

typedef struct tagICMPECHO
{	// 에코 요청 자료의 구조체
	u_long Source;		// 원본 주소
	u_long Status;		// IP 상태
	u_long RTTime;		// 순회 시간(Round Trip Time : RTT) ms
	u_short DataSize;	// 응답 데이터 크기
	u_short Reserved;	// 알수 없음
	void FAR* pData;	// 응답 데이터 버퍼
	IPINFO ipInfo;		// 응답 옵션

}ICMPECHO, *PICMPECHO;

// ICMP.DLL 출력 함수 포인터
HANDLE (WINAPI* pIcmpCreateFile)(VOID);
BOOL (WINAPI* pIcmpCloseHandle)(HANDLE);
DWORD (WINAPI* pIcmpSendEcho)
	(HANDLE, DWORD, LPVOID, WORD, PIPINFO, LPVOID, DWORD, DWORD);

//
// main 함수 부분입니다.
int main(int argc, char* *argv)
{
	WSADATA	wsaData;		// WinSock Applicatoin DATA
	ICMPECHO icmpEcho;		// Internet Control Message Protocol 에코 응답 버퍼
	HANDLE hndlIcmp;			// ICMP.DLL 를 다룰 LoadLibrary() 함수의 핸들
	HANDLE hndlFile;			// IcmpCreateFile() 함수의 핸들
	LPHOSTENT pHost;		// 호스트 객체 구조를 가리키는 포인터
	struct in_addr iaDest;	// 인터넷 주소 구조체
	DWORD *dwAddress;		// IP 주소
	IPINFO ipInfo;			// IP 옵션 구조
	int nRet;				// 일반적으로 응답 코드로 사용
	DWORD dwRet;			// DWORD(더블워드형) 응답 코드
	int x;

	// 인수 확인
	if(argc != 2)
	{
		fprintf(stderr,"\n사용법: pingi [호스트 또는 IP주소]\n");
		return -1;

	}

	// 동적으로 ICMP.DLL 을 코드 수행시 바로 불러옵니다.
	hndlIcmp = LoadLibrary("ICMP.DLL");
	if(hndlIcmp == NULL)
	{
		fprintf(stderr,"\nICMP.DLL 파일을 불러오지 못했습니다.\n");
		return -1;

	}

	// ICMP 함수 포인터를 반환 받습니다.
	pIcmpCreateFile = ( HANDLE (WINAPI*)(void) )GetProcAddress((HINSTANCE)hndlIcmp, "IcmpCreateFile");
	pIcmpCloseHandle = ( BOOL (WINAPI* )(HANDLE) )GetProcAddress((HINSTANCE)hndlIcmp, "IcmpCloseHandle");
	pIcmpSendEcho = (DWORD (WINAPI* )(HANDLE, DWORD, LPVOID, WORD, PIPINFO, LPVOID, DWORD, DWORD))
		GetProcAddress((HINSTANCE)hndlIcmp,"IcmpSendEcho");

	//모든 함수 포인터를 확인합니다.
	if(pIcmpCreateFile == NULL	|| pIcmpCloseHandle == NULL || pIcmpSendEcho == NULL)
	{
		fprintf(stderr,"\nICMP 프로시져 주소를 찾는데 문제가 생겼습니다.\n");
		FreeLibrary((HINSTANCE)hndlIcmp);
		return -1;
	}

	// 윈속을 시작 합니다.
	nRet = WSAStartup(0x0101, &wsaData);	// 귀찮아서 MAKEWORD(1,1)을 쓰지 않고 바로 0x0101 로 WORD 형 자료를 완성합니다.
	if(nRet)
	{
		fprintf(stderr,"\nWSAStartup() 오류 발생했습니다. 코드 번호 : %d\n", nRet);
		WSACleanup();
		FreeLibrary((HINSTANCE)hndlIcmp);
		return -1;

	}

	// 윈속 버전을 확인 합니다.
	if (0x0101 != wsaData.wVersion)
	{
		fprintf(stderr,"\n이 컴퓨터의 윈속이 버전 1.1을 지원하지 않습니다.\n");
		WSACleanup();
		FreeLibrary((HINSTANCE)hndlIcmp);
		return -1;
	}

	// 목적지를 검색합니다.
	// inet_addr() 함수로 호스트 명인지 호스트 주소인지 검사 합니다.
	iaDest.s_addr = inet_addr(argv[1]);
	if(iaDest.s_addr == INADDR_NONE)	// IP주소가 아닌 경우
		pHost = gethostbyname(argv[1]);

	else		// IP 주소인 경우
		pHost = gethostbyaddr( (const char*)&iaDest, sizeof(struct in_addr), AF_INET);

	if (pHost == NULL)	// 목적지 호스트에 도달하지 못한 경우
	{
		fprintf(stderr,"\n%s 호스트를 찾을수 없었습니다.\n", argv[1]);
		WSACleanup();
		FreeLibrary((HINSTANCE)hndlIcmp);
		return -1;
	}

	// 사용자에게 우리가 무얼 할지 가르쳐 줍니다.
	printf("%s [%s] 호스트 로 핑(Ping)합니다.", pHost->h_name, inet_ntoa( (*(LPIN_ADDR)pHost->h_addr_list[0])) );

	// IP 주소를 복사 합니다.
	dwAddress = (DWORD*) (*pHost->h_addr_list);

	// ICMP 에코 요청 핸들을 가집니다.
	hndlFile = pIcmpCreateFile();
	
	for(x = 0; x < 4; x++)	// 4번 재시도 합니다.
	{
		//	그럴싸한 기본 값을 설정합니다.
		ipInfo.Ttl = 255;
		ipInfo.Tos = 0;
		ipInfo.OptSize = 0;
		ipInfo.Options = NULL;

		// icmpEcho.ipInfo.Ttl = 256;
		// ICMP 에코 요청을 합니다.

		dwRet = pIcmpSendEcho(
				hndlFile,		// IcmpCreateFile() 함수에서 가저온 핸들
				*dwAddress,		// 목적지 IP 주소
				NULL,			// 보낼 버퍼를 가리키는 포인터
				0,				// 보낼 버퍼의 바이트 길이
				&ipInfo,		// 요구 옵션
				&icmpEcho,		// 응답 버퍼
				sizeof(struct tagICMPECHO), // 에코 보낼 자료의 주소 길이
				5000);			// 기타릴 시간 밀리초(천분의 1초 => 5초)
		
		// 결과를 출력합니다.
		iaDest.s_addr = icmpEcho.Source;
		printf("\n %s 에서 응답이 왔습니다. 시간 = %ldms TTL=%d",
			inet_ntoa(iaDest),
			icmpEcho.RTTime,
			icmpEcho.ipInfo.Ttl);

		if(icmpEcho.Status)
		{
			printf("\n오류 : icmpEcho.Status 상태코드 = %ld", icmpEcho.Status);
			break;

		}

	}

	printf("\n");
	// 요구 했던 파일 핸들을 닫습니다.
	pIcmpCloseHandle(hndlFile);
	FreeLibrary((HINSTANCE)hndlIcmp);
	WSACleanup();

	return 0;


}
 

 
// 저작권
// http://www.sockaddr.com/ExampleSourceCode.html
// http://cakel.tistory.com
// 교육용을 전제로 자유롭게 쓰실수 있습니다.
// 
// ping.h - RFC 규격에 맞게 ICMP 와 IP 헤더를 지정하는 파일입니다.
// 


// packing 용량 단위 설정하는 부분입니다. alignment 를 1 로 두어서 최소 자료 전송을 노립니다.
// 대신에 접근하는 속도가 떨어지므로 좋은 방법만은 아닙니다.
#pragma pack(1)

#define ICMP_ECHOREPLAY 0
#define ICMP_ECHOREQ	8

// IP 헤더 부분 -- RFC 791
// http://www.faqs.org/rfcs/rfc791.html
// http://blog.naver.com/after1007/50014330586 참고

typedef struct tagIPHDR
{
	u_char	VIHL;			// 버전과 IHL(Internet Header Length) 값
	u_char	TOS;			// Type of Service (서비스의 형태)
	short	TotLen;			// Total Length (전체 길이)
	short	ID;				// Identification (식별자)
	short	FlagOff;		// Fragment Offset (단편 좌표)
	u_char	TTL;			// Time to Live (생존 시간)
	u_char	Protocol;		// Protocol (프토토콜, 전송 규약)
	u_short	Checksum;		// 체크섬(값 비교)
	struct	in_addr iaSrc;	// Internet Address - Source (인터넷 주소 - 원본)
	struct	in_addr	iaDsc;	// Internet Address - Destination (인터넷 주소 - 대상)

}	IPHDR, *PIPHDR;

// ICMP 헤더 -- RFC 792
// http://www.faqs.org/rfcs/rfc792.html
// http://www.microsoft.com/korea/technet/deploy/tcpintro5.asp
// http://technet2.microsoft.com/WindowsServer/ko/Library/732438fe-70c5-4e68-9663-ecbd955d29ea1042.mspx?mfr=true
// http://blog.naver.com/isnta/20024953151 참고

typedef struct tagICMPHDR
{
	u_char	Type;			// 형식
	u_char	Code;			// 코드
	u_short	Checksum;		// 체크섬
	u_short	ID;				// 식별자
	u_short	Seq;			// 순서
	char	Data;			// 자료(데이터)

}	ICMPHDR, *PICMPHDR;

#define REQ_DATASIZE 32		// 에코(Echo) 요구 자료 길이

// ICMP Echo Request - 에코 자료 요구
typedef struct tagECHOREQUEST
{
	ICMPHDR	icmpHdr;
	DWORD	dwTime;
	char	cData[REQ_DATASIZE];
}	ECHOREQUEST, *PECHOREQUEST;

// ICMP Echo Reply			// 에코 응답
typedef struct tagECHOREPLY
{
	IPHDR		ipHdr;
	ECHOREQUEST	echoRequest;
	char		cFiller[256];
}	ECHOREPLY, *PECHOREPLY;

#pragma pack()		// packing 용량 단위 기본값으로 변경합니다.
 

 
//
//	저작권
//	http://www.sockaddr.com/ExampleSourceCode.html
//	http://cakel.tistory.com
//	교육용을 전제로 자유롭게 쓰실수 있습니다.
//
//	ping.cpp  -- ICMP 와 RAW 소켓을 사용하는 Ping 프로그램입니다.
//

#include <stdio.h>
#include <stdlib.h>
#include <winsock.h>
#include "ping.h"

#pragma comment(lib,"wsock32.lib")

// 내부 함수
void Ping(LPCSTR pstrHost);
void ReportError(LPCSTR pstrFrom);
int WaitForEchoReply(SOCKET s);
u_short in_cksum(u_short *addr, int Len);

// ICMP 에코 요구/응답 함수
int SendEchoRequest(SOCKET, LPSOCKADDR_IN);
DWORD RecvEchoReply(SOCKET, LPSOCKADDR_IN, u_char*);

// 시작
int main(int argc, char* *argv)
{
	WSADATA wsaData;
	WORD wVersionRequested = MAKEWORD(1,1);
	int nRet;

	// 인수 비교
	if(argc != 2)
	{
		fprintf(stderr,"\n사용법 : ping [호스트명]\n");
		return 1;

	}

	// 윈속 시작
	nRet = WSAStartup(wVersionRequested, &wsaData);
	if(nRet)
	{
		fprintf(stderr,"\n윈속을 시작하는데 오류 발생했습니다.\n");
		return 1;

	}
	
	// ping 작업을 합니다.
	Ping(argv[1]);

	// 윈속을 비웁니다.
	WSACleanup();

	return 0;
}

// Ping() 함수
// SendEchoRequest() 함수와 RecvEchoReply() 함수를 수행하고
// 결과를 출력합니다.

void Ping(LPCSTR pstrHost)
{
	SOCKET		rawSocket;
	LPHOSTENT	lpHost;
	struct		sockaddr_in saDest;
	struct		sockaddr_in saSrc;
	DWORD		dwTimeSent;
	DWORD		dwElapsed;
	u_char		cTTL;
	int			nLoop;
	int			nRet;

	// Raw 소켓을 생성합니다.
	rawSocket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
	if(rawSocket == SOCKET_ERROR)
	{
		ReportError("socket() 함수 문제 발생");
		return;

	}

	// 호스트를 찾아 봅니다(Lookup host)
	lpHost = gethostbyname(pstrHost);
	if(lpHost == NULL)
	{
		fprintf(stderr, "\n호스트를 찾을수가 없습니다 : %s\n", pstrHost);
		return;

	}
	
	// 목적지 소켓 주소로 연결을 시도 합니다.
	saDest.sin_addr.s_addr = *((u_long FAR *)(lpHost->h_addr));
	saDest.sin_family = AF_INET;
	saDest.sin_port = 0;

	// 사용자에게 프로그램이 할려고 하는 작업을 표시 합니다.
	printf("\n%s [%s] 호스트에게 %d 바이트의 자료를 핑합니다.\n",
		pstrHost,
		inet_ntoa(saDest.sin_addr),
		REQ_DATASIZE);

	// 몇번(4) 핑 작업을 합니다.
	for(nLoop = 0; nLoop < 4; nLoop++)
	{
		// ICMP 에코 요구(Echo request)를 보냅니다.
		SendEchoRequest(rawSocket, &saDest);

		// select() 함수로 자료가 받을때 까지 기다립니다.
		nRet = WaitForEchoReply(rawSocket);
		if(nRet == SOCKET_ERROR)
		{
			ReportError("select() 함수에서 문제 발생");
			break;

		}

		if(!nRet)
		{
			printf("\n시간 초과");
			break;
		}
		
		// 응답을 받습니다.
		dwTimeSent = RecvEchoReply(rawSocket, &saSrc, &cTTL);

		// 소요된 시간을 계산합니다.
		dwElapsed = GetTickCount() - dwTimeSent;
		printf("\n%s 에서 응답을 받았습니다. 바이트=%d 시간 %ldms TTL=%d",
			inet_ntoa(saSrc.sin_addr), REQ_DATASIZE,
			dwElapsed, cTTL);
		}
	printf("\n");
	nRet = closesocket(rawSocket);
	if(nRet == SOCKET_ERROR)
		ReportError("closesocket() 함수 수행중 오류 발생.");

}

// SendEchoRequest()
// 에고 요구 헤더 정보를 채우고 목적지로 보냅니다.
int SendEchoRequest(SOCKET s, LPSOCKADDR_IN lpstToAddr)
{
	static ECHOREQUEST echoReq;
	static nId = 1;
	static nSeq = 1;
	int nRet;

	// 에코 요구 정보를 채웁니다.
	echoReq.icmpHdr.Type		= ICMP_ECHOREQ;
	echoReq.icmpHdr.Code		= 0;
	echoReq.icmpHdr.Checksum	= 0;
	echoReq.icmpHdr.ID			= nId++;
	echoReq.icmpHdr.Seq			= nSeq++;

	// 보낼 정보를 채웁니다.
	for(nRet = 0; nRet < REQ_DATASIZE; nRet++)
		echoReq.cData[nRet] = ' '+nRet;

	// 보낼 때 틱 횟수(tick count, 시간) 저장합니다.
	echoReq.dwTime = GetTickCount();

	// 보낼 자료를 패킷에다 넣고 체크섬(비교값)을 계산합니다.
	echoReq.icmpHdr.Checksum = in_cksum( (u_short*)&echoReq, sizeof(ECHOREQUEST) );

	// 에코 요구 신호를 보냅니다.
	// sendto(소켓, 전송할 데이터, 데이터의 길이, 역할 나타내는 플래그, 원격 호스트 주소, 원격 호스트 주소의 크기)
	// 소켓이 접속의 유무와 관계 없이 일방적으로 전송하는 함수 입니다.
	// http://white.chungbuk.ac.kr/~jchern/sendto.html 참고

	nRet = sendto(s,					// 소켓
				(LPSTR)&echoReq,		// 버퍼
				sizeof(ECHOREQUEST),	// 버퍼 크기
				0,						// 플래그
				(LPSOCKADDR)lpstToAddr,	// 목적지
				sizeof(SOCKADDR_IN));	// 주소 길이

	if(nRet == SOCKET_ERROR)
		ReportError("sendto() 함수 수행중 문제가 발생했습니다.");

	return (nRet);

}

// RecvEchoReply() 함수
// 들어오는 자료를 받고 받은 항목들을 분석합니다.
DWORD RecvEchoReply(SOCKET s, LPSOCKADDR_IN lpsaFrom, u_char* pTTL)
{
	ECHOREPLY echoReply;
	int nRet;
	int nAddrLen = sizeof(struct sockaddr_in);

	// 에코 응답을 받습니다.
	// recvform(소켓 식별자, 수신된 데이터를 받을 버퍼, 버퍼의 길이, 역할을 나타내는 플래그, 준 곳의 주소를
	// 리턴 받기 위한 버퍼 포인터, 버퍼 사이즈를 지정한 포인터)
	// 소켓으로 부터 데이터그램을 받고, 송신자의 주소와 포트를 반환하는 함수 입니다.
	// http://white.chungbuk.ac.kr/~jchern/recvfrom.html 참고
	nRet = recvfrom(s,					// 소켓
				(LPSTR)&echoReply,		// 버퍼
				sizeof(ECHOREPLY),		// 버퍼의 크기
				0,						// 플래그
				(LPSOCKADDR)lpsaFrom,	// 받는 주소
				&nAddrLen);				// 주소 길의를 담는 자료를 가리키는 포인터

	// 되돌아 오는 값을 검사합니다.
	if(nRet == SOCKET_ERROR)
		ReportError("recvfrom() 함수 수행중 문제가 발생했습니다.");

	// 보낸 시간 값과 IP TTL 값을 받습니다.
	*pTTL = echoReply.ipHdr.TTL;
	return(echoReply.echoRequest.dwTime);

}

// ReportError() 함수
// 무슨 일 있습니까?
void ReportError(LPCSTR pWhere)
{
	fprintf(stderr,"\n%s WSAGetLastError 오류 코드 번호 : %d\n", WSAGetLastError());
}

// WaitforEchoReply() 함수
// select() 함수를 사용하여 언제 자료가 읽혀 질지 결정합니다.
int WaitForEchoReply(SOCKET s)
{
	struct timeval Timeout;
	fd_set readfds;

	readfds.fd_count = 1;
	readfds.fd_array[0] = s;
	Timeout.tv_sec = 5;
	Timeout.tv_usec = 0;

	// select(I/O 변화를 감지하는 소켓의 갯수, 읽기 상태 변화 감지할 소켓, 쓰기 상태 변화 감지할 소켓
	// 예외 상태 변화 감지할 소켓, 기다리기 위한 시간)
	// http://white.chungbuk.ac.kr/~jchern/select.html 참고
	return( select(1, &readfds, NULL, NULL, &Timeout) );

}

// 마이크 무유스(Mike Muuss) 의 in_cksum() 함수
// 원래 핑(ping) 코드와 그의 설명입니다.
// 참고 http://myhome.shinbiro.com/~eaglelee/rawsocket.txt
//
//* 저자 -
//* 마이크 무유스(Mike Muuss)
//* 미 육군 탄도 연구소(U. S. Army Ballistic Research Laboratory)
//* 1983년 12월
/*
 *		I N _ C K S U M
 *
 *
 *	인터넷 프로토콜 계열 헤더를 위한 체크섬 계산 루틴(C 버전)
 *

*/

u_short in_cksum(u_short *addr, int len)
{
	register int nleft = len;
	register u_short *w = addr;
	register u_short answer;
	register int sum = 0;

	/*
	 * 우리의 원래 알고리듬은 간단합니다. 32 비트 누산기(덧셈)를 써서,
	 * 우리는 16비트 단어를 순차적으로 더한 후 마지막에,
	 * 상위 16비트를 뒤로 접어 하위 16비트로 내립니다.
	 *
	 */

	while(nleft > 1){
		sum += *w++;
		nleft -= 2;

	}

	/* 필요하다면, 홀수 바이트 부분을 정리 합니다. */
	if(nleft == 1) {
		u_short u = 0;
		*(u_char*)(&u) = *(u_char*)w;
		sum += u;

	}

	/*
	 *	상위 16비트를 하위 16비트로 더합니다.
	 */

	sum = (sum >> 16) + (sum &0xffff); /* 상위 16비트를 하위 16비트로 더하기 */
	sum += (sum >> 16);					/* 자리 올림수를 더합니다. */
	answer = ~sum;						/* 16 비트로 자릅니다. */
	return (answer);

}
 

/*
	tcp_server_ref.cpp
	저작권
	http://ccl.korea.ac.kr
	http://cakel.tistory.com
	교육용을 전제로 자유롭게 사용하실수 있습니다.

	5000 번 포트를 쓰는 로컬호스트용 애코 서버 입니다.
	되도록이면 머리 속에서 나오는 것을 쳐 낼려고 했습니다.

*/

#include <winsock2.h>
#include <stdio.h>
#include <string.h>

#pragma comment (lib,"ws2_32.lib")
#define PORT 5000

int main()
{
	// 윈속 초기화
	WSADATA wsd;
	if(WSAStartup(MAKEWORD(2,2), &wsd) != 0)
	{
		printf("winsock 오류\n");
		return 1;
	}

	// 서버 주소, 받을 클라이언트 주소
	int s, ns, addrsize;
	sockaddr_in client, server;
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = INADDR_ANY;		// 로컬 서버(localhost)를 나타냄. 혼자 놀이용.
	server.sin_port = htons(PORT);

	// bind() - 새로 오는 클라이언트를 받을 welcome 소켓
	s = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	if(bind(s, (sockaddr *)&server, sizeof(server)) == SOCKET_ERROR)
	{
		printf("bind() 오류\n");
		WSACleanup();
		return 1;

	}

	// listen 포트를 열어 두어 떡밥을 기다리는 중
	listen(s,2);
	printf("클라이언트를 기다리는 중\n");

	addrsize = sizeof(client);
	char buff[1024] = {0};

	// accept 물었다. 소켓을 할당 한다.
	ns = accept(s, (sockaddr*)&client, &addrsize);

	if(ns == INVALID_SOCKET)
	{
		printf("accept() 오류\n");
		WSACleanup();
		return 1;
	}

	// inet_ntoa 랑 ntohs 를 주의
	printf("%s:%d로 접속\n", inet_ntoa(client.sin_addr),ntohs(client.sin_port));

	int ret;

	// 값을 주고 받는데 메시지 값이 SOCKET_ERROR 이면 가차없이 종료
	while(ret != SOCKET_ERROR)
	{
		ret = recv(ns, buff, 1024, 0);
		printf("받은 메시지의 크기 : %d\n", ret);

		if(ret == SOCKET_ERROR) break;

		ret = send(ns, buff, ret, 0);
		printf("보낸 메시지의 내용 : %s\n", buff);
		memset(buff, 0, 1024);

	}

	printf("접속을 종료\n");
	closesocket(ns);
	closesocket(s);
	WSACleanup();




	return 0;
}

/*
	tcp_client_ref.cpp
	저작권
	http://ccl.korea.ac.kr
	http://cakel.tistory.com
	교육용을 전제로 자유롭게 사용하실수 있습니다.

	5000 번 포트를 쓰는 로컬호스트용 애코 클라이언트 입니다.
	되도록이면 머리 속에서 나오는 것을 쳐 낼려고 했습니다.

*/

#include <winsock2.h>
#include <stdio.h>
#include <string.h>

#pragma comment (lib,"ws2_32.lib")
#define PORT 5000
#define IP "127.0.0.1"		// 로컬 접속용 즉 혼자놀이용

int main(void)
{
	// 윈속을 설정
	WSADATA wsd;
	if(WSAStartup(MAKEWORD(2,2), &wsd) != 0)
	{
		fprintf(stderr,"틀린 윈속 버전\n");
		return 1;
	}

	int s = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	if ( s == SOCKET_ERROR)
	{
		fprintf(stderr,"socket() 함수 오류\n");
		WSACleanup();
		return 1;
	}

	// 서버 주소 설정
	sockaddr_in server;
	server.sin_addr.s_addr = inet_addr(IP);
	server.sin_port = htons(PORT);
	server.sin_family = AF_INET;

	// connect() 떡밥을 물으러 간다.
	if(connect(s, (sockaddr* )&server, sizeof(server)) == SOCKET_ERROR)
	{
		printf("connect() 오류\n");
		closesocket(s);
		WSACleanup();
		return 1;

	}

	// 물었다.
	char buff[1024] = {0};
	int ret;

	// SOCKET_ERROR 되기 전까진 무조건 자료 전송
	while(ret != SOCKET_ERROR)
	{
		printf("출력할 글자 입력 : ");
		fgets(buff,1024,stdin);
		ret = send(s, buff, strlen(buff),0);
		
		memset(buff,0,1024);

		if(ret == 0) break;
		ret = recv(s, buff, 1024,0);
		printf("받은 문자열 : %s", buff);
		
	}

	printf("연결을 종료\n");
	closesocket(s);
	WSACleanup();

	return 0;
}

----시작(STARTUP)----
WSAStartup() 함수 성공

---- FINDHOST(호스트 찾기) ----
WSAAsyncGetHostByName() 함수를 써서 서버를 찾습니다.
SM_GETHOST 메시지를 받았습니다.
WSAAsyncGetHostByName() 함수 수행중 31 밀리초(ms)가 완료 하는데 소요되었습니다.
서버를 찾았습니다.

---- 호스트에 접속합니다.(Connect to host) ----

socket(AF_INET, SOCK_STREAM, 0); 을 호출 합니다.
WSAASyncSelete() 함수를 호출 합니다
getservbyname() 함수 수행으로 0밀리초(ms)가 소요 되었습니다.
connect() 함수를 호출합니다.

 ---- 처리 메시지(Process Messages) ----
FD_CONNECT 알림을 받았습니다.
FD_WRITE 알림을 받았습니다.
FD_READ 알림을 받았습니다.
recv() 함수를 호출합니다.
서버로 부터의 응답입니다 :
+OK NMQpopper NaverMail Team 2004 base Qpopper (version Naver1.0) at i4l043.nhncorp.com starting. 

AppState = CONNECTING, senging USER
FD_READ 알림을 받았습니다.
recv() 함수를 호출합니다.
서버로 부터의 응답입니다 :
+OK Password required for cakel.

AppState = SEND, 패스워드를 전송합니다.
FD_READ 알림을 받았습니다.
recv() 함수를 호출합니다.
서버로 부터의 응답입니다 :
+OK cakel has 16 visible messages in 2312723 octets.

AppState = PASS, STAT 를 보냅니다.
FD_READ 알림을 받았습니다.
recv() 함수를 호출합니다.
서버로 부터의 응답입니다 :
+OK 16 2312723

AppState = STAT, 응답을 읽습니다.
---- 결과(Result)----
16 메시지 2312723 바이트
QUIT 명령를 전송합니다.
FD_READ 알림을 받았습니다.
recv() 함수를 호출합니다.
서버로 부터의 응답입니다 :
+OK Pop server at i4l043.nhncorp.com signing off.

호스트 QUIT OK
소켓을 닫습니다.
FD_CLOSE 통보를 받았습니다.

/*
	저작권 공지
	http://www.sockaddr.com/ExampleSourceCode.html
	http://cakel.tistory.com

    교육용을 전제로 자유롭게 배포 가능합니다.

	winapi_checkmail
	간단하게 POP3 를 이용한 통신을 통해 전자우편 서버와 통신을 하는 내용입니다.
	Windows API 를 쓰기 때문에 윈도우 상에서 교신 내용이 나옵니다.

	아래 5개 파일로 구성되어 있습니다.
	resource.h - GUI 구성과 C++ 코드와 연동을 위한 헤더 파일
	checkpop3.rc - GUI 실제 구성하는 틀(Frame)
	winapi_checkmail.dsw - MSDEV : Visual Studio 6용 작업 공간
	winapi_checkmail.dsp - MSDEV : 작업용 Project 설정 File
	checkpop3.cpp - 구동을 맏는 핵심 C++

*/

/*
	CheckMail.h Header 부분입니다.
	내용이 작아서 checkpop3.cpp 에 내장(embedded) 시켰습니다.

	전자우편을 확인하기 위해 POP3 서버를 기다립니다.

*/

// 16-bit 윈도우즈 에서 MAKEWORD 를 정의 합니다.
// MAKEWORD (a, b) - 상위 8비트(BYTE) a OR 하위 8비트(BYTE) b = 16비트(WORD 형)로 받음

#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <winsock.h>
#include "resource.h"

#ifndef WIN32
#define MAKEWORD(a, b) ( (WORD) ( ((BYTE)(A)) | ( (WORD) ( (BYTE)(b)) ) << 8) )
#endif

// Winsock 을 Link 시키고 윈도우즈용 시스템이라는 것을 명시 합니다.
// 안 쓰면 컴파일러시 옵션을 주시 않으면 WinMain 링크 오류가 생깁니다.
// 원인 모르는 Link 오류해결시 참고 하시기 바랍니다.
#pragma comment (lib,"wsock32.lib")
#pragma comment( linker, "/subsystem:windows" ) 


// WINAPI 관련 함수 정의는 아직 모르겠습니다.
// 도우미 매크로
#define Display(s) SendDlgItemMessage(hwndDlg, IDC_EDIT1, EM_REPLACESEL, 0, (LPARAM) ((LPSTR)s) )
#define EnableOneButton(id, flag) EnableWindow( GetDlgItem(hwndDlg, id), flag)
#define EnableButtons(flag) EnableOneButton(IDC_CHECKMAIL, flag)

// 비동기 통지(Asynchronous notificatio)를 위한 메시지 정의
#define SM_GETHOST	WM_USER+1
#define SM_ASYNC	WM_USER+2

// 함수 프로토타입(Prototypes)
BOOL CALLBACK MainDialogProc(HWND, UINT, WPARAM, LPARAM);
void HandleGetHostMsg(HWND, WPARAM, LPARAM);
void HandleAsyncMsg(HWND, WPARAM, LPARAM);
void ProcessData(HWND, LPSTR, int);
void ProcessData(HWND, LPSTR, int);
void ProcessLine(HWND, LPSTR);
void CloseSocket(SOCKET);

// 전역(Global) 변수 부분 입니다.
/////////////////////////////////
// POP3 호스트 이름
char			gszServerName[255];

// 사용자 ID
char			gszUserID[80];

// 비밀번호
char			gszPassword[80];

// WSAAsyncHostByName() 함수를 위한 핸들(Handle) - 자원을 접근(Access) 할수 있는 포인터(Pointer)
HANDLE			hndGetHost;

// WSAAsyncGetHostByName() 함수를 위한 HostEnt 버퍼(Buffer)
char			bufHostEnt[MAXGETHOSTSTRUCT];

// 소켓
SOCKET			socketPOP;

// wsprintf() 함수를 위한 스크래치 버퍼(Scratch buffer - 임시 저장 공간)
char			gszTemp[255];

// 타이밍을 위한 변수들
// 이 예제에세만(For example only) 쓰입니다 -- 실제로는 필요하지 않습니다.
DWORD			gdwTicks;
DWORD			gdwElapsed;

// recv() 데이터 버퍼 입니다.
char			gbufRecv[256];

// 응용프로그램 작동 상태(Application State)를 정의 합니다.
int				gnAppState;
#define			STATE_CONNECTING	1	// 접속중
#define			STATE_USER			2	// 사용자
#define			STATE_PASS			3	// 비밀번호
#define			STATE_STAT			4	// 상태
#define			STATE_QUIT			5	// 나가기

// WinMain()	- 접근 점(Entry Point)
int PASCAL WinMain
(
	HINSTANCE	hinstCurrent,
	HINSTANCE	hinstPrevious,
	LPSTR		lpszCmdLine,
	int			nCmdShow)

{

	// 변수를 초기화 합니다.
	int nReturnCode;
	WSADATA wsaData;

	// 필요한 Winsock 의 Version 은 1.1
	#define MAJOR_VERSION_REQUIRED 1
	#define MINOR_VERSION_REQUIRED 1

	WORD wVersionRequired = MAKEWORD(MAJOR_VERSION_REQUIRED, MINOR_VERSION_REQUIRED);

	// WinSock DLL 을 시작합니다.
	nReturnCode = WSAStartup(wVersionRequired, &wsaData);
	if (nReturnCode !=0)
	{
		MessageBox(NULL, "WSAStartUp()함수를 수행하는데 문제가 생겼습니다", "CheckMail - winapi_checkmail", MB_OK);
		return 1;

	}

	// 원하는 Version 의 Winsock 이 없다고 표시합니다.
	if (wsaData.wVersion != wVersionRequired)
	{
		// 필요한 Version 이 없습니다.
		MessageBox(NULL, "틀린 WinSock Version 입니다", "Checkmail - winapi_checkmail", MB_OK);
		WSACleanup();		// 생성된 WinSock Application 을 지웁니다.
		return 1;

	}

	// 기본 윈도우로 쓰인 대화 상자를 염니다.
	DialogBox(
				hinstCurrent,
				MAKEINTRESOURCE(IDD_DIALOG_MAIN),
				NULL,
				MainDialogProc);

	WSACleanup();

	return 0;

}

// MainDialogProc() - 기본 윈도우 프로시저(Main Window Procedure) 입니다.
BOOL CALLBACK MainDialogProc(
								HWND	hwndDlg,
								UINT	msg,
								WPARAM	wParam,
								LPARAM	lParam
								
								)

{
	BOOL fRet = FALSE;

	switch(msg)
	{
		case WM_INITDIALOG:
				//	WSADATA 에서 오는  정보를 표시 합니다.
				Display("----시작(STARTUP)----\r\n");
				Display("WSAStartup() 함수 성공\r\n\r\n");
				break;

		case WM_COMMAND:
				switch(wParam)
				{
					// 메일 확인 버튼을 눌렀을때
					case IDC_CHECKMAIL:

					// POP 정보를 받습니다.
					// 서버 이름, 사용자 ID 와 비밀번호
					if(!GetDlgItemText(
										hwndDlg,
										IDC_SERVERNAME,
										gszServerName,
										sizeof(gszServerName)
										))

					{
						MessageBox(hwndDlg,
							"서버 이름을 넣어 주세요",
							"POP 알림", MB_OK);
						break;

					}

					if (!GetDlgItemText(hwndDlg, IDC_USERID,
										gszUserID, sizeof(gszUserID)) )
					{
						MessageBox(hwndDlg,
							"사용자 ID를 넣어 주세요",
							"POP 알림", MB_OK);
						break;

					}

					if (!GetDlgItemText(
										hwndDlg,
										IDC_PASSWORD,
										gszPassword,
										sizeof(gszPassword)
										))

					{
						MessageBox(hwndDlg,
							"비밀번호를 넣어 주세요",
							"POP 알림", MB_OK);
						break;

					}

					// 비동기 Version 의 gethostbyname() 함수로
					// 호스트 이름을 확인하는 요청을 합니다.
					// 작업이 완료 되면 SM_GETHOST 메시지가 표시 됩니다.
					Display("---- FINDHOST(호스트 찾기) ---- \r\n");
					Display("WSAAsyncGetHostByName() 함수를 써서 " "서버를 찾습니다. \r\n");

					// 이번 예제를 위해 WSAAsyncGetHostByName() 수행 시간을 잽니다.

					gdwTicks = GetTickCount();
					hndGetHost = WSAAsyncGetHostByName(
						hwndDlg, SM_GETHOST,
						gszServerName,
						bufHostEnt,
						MAXGETHOSTSTRUCT);

					if(hndGetHost == 0)
					{
						MessageBox(hwndDlg,
							"시작하는데 오류가 생겼습니다"
							"WSAAsyncGetHostByName() 함수 수행",
							"CheckMail - winapi_checkmail",
							MB_OK);

					}

					else
					{
						EnableButtons(FALSE);
						gnAppState = 0;

					}

					fRet = TRUE;
					break;

					// 취소 퍼든을 누르면 기본 윈도우(Main window)에서 나가게 합니다.
					case IDC_CANCEL:
						if(gnAppState)
							CloseSocket(socketPOP);
						PostQuitMessage(0);
						fRet = TRUE;
						break;

				}

				break;

				// 비동기 gethostbyname() 함수의 되돌림(return) 값을 다룹니다.
				case SM_GETHOST:
					HandleGetHostMsg(hwndDlg, wParam, lParam);
					fRet = TRUE;
					break;

				// 비동기 메시지를 처리 합니다.
				case SM_ASYNC:
					HandleAsyncMsg(hwndDlg, wParam, lParam);
					fRet = TRUE;
					break;

	}

	return fRet;

}

// HandleGetHost() 함수 정의
// WSAASyncGetHostByName() 함수가 완료 되었을때 불리어 집니다.
void HandleGetHostMsg(
					  HWND hwndDlg,
					  WPARAM wParam,
					  LPARAM lParam)

{
		SOCKADDR_IN		saServ;			// 인터넷을 위한 소켓 주소입니다.
		LPHOSTENT		lpHostEnt;		// 호스트 진입점(host entry) 을 가리키는 포인터 입니다.
		LPSERVENT		lpServEnt;		// 서버 진입점(sever entry) 을 가리키는 포인터 입니다.
		int nRet;						// 되돌림 값(return code)입니다.

		Display("SM_GETHOST 메시지를 받았습니다.\r\n");
		if( (HANDLE)wParam != hndGetHost)
			return;

		// 이번 예제에서 WSAGetHostByName() 함수의
		// 수행 중인 시간을 표시 합니다.
		gdwElapsed = ( GetTickCount() - gdwTicks );
		wsprintf( (LPSTR)gszTemp, (LPSTR) "WSAAsyncGetHostByName() 함수 수행중 %ld"
			" 밀리초(ms)가 완료 하는데 소요되었습니다.\r\n",
			gdwElapsed);

		Display(gszTemp);

		// 오류 코드를 확인합니다.
		nRet = WSAGETASYNCERROR(lParam);
		if (nRet)
		{
			wsprintf( (LPSTR)gszTemp,
				(LPSTR) "WSAAsyncGetHostByName() 함수 수행중 오류가 생겼습니다. : %d\r\n",
				nRet);

			Display(gszTemp);
			EnableButtons(FALSE);
			return;

		}

		// 서버를 찾았습니다(Server found OK).
		// bufHostEnt 에 서버의 정보를 담고 있습니다.

		Display("서버를 찾았습니다.\r\n\r\n");

		Display("---- 호스트에 접속합니다.(Connect to host) ----\r\n\r\n");

		// 소켓(Socket)을 생성합니다.
		Display("socket(AF_INET, SOCK_STREAM, 0); 을 호출 합니다.\r\n");

		// socket(인터넷 주소, TCP 소켓 스트림, 플래그)
		socketPOP = socket(AF_INET, SOCK_STREAM, 0);
		if (socketPOP == INVALID_SOCKET)
		{
			Display("소켓을 생성하지 못했습니다.\r\n");
			EnableButtons(TRUE);
			return;

		}

		// 비동기 통지(asynchronous notificatio)를 위해 소켓을 
		// non-blocking 으로 만들고 등록 합니다.

		Display("WSAASyncSelete() 함수를 호출 합니다\r\n");
		if(WSAAsyncSelect(socketPOP,
			hwndDlg,
			SM_ASYNC,
			FD_CONNECT|FD_READ|FD_WRITE|FD_CLOSE))

		{
			Display("WSAAsyncSelect() 함수 부르는 중에 문제가 생겼습니다.\r\n");
			EnableButtons(TRUE);
			return;

		}

		// getservbyname() 함수로 포트 번호를 찾습니다.
		// 간단한 동기화 버전(synchronous version)에서 사용 되었기 때문에
		// 거의 항상 빨리 이루어 집니다.
		// 이 예제를 위해 getgervbyname() 함수의 수행 시간을 확인합니다.

		gdwTicks = GetTickCount();

		// getservbyname(서비스,프토토콜)
		lpServEnt = getservbyname("pop3", "tcp");
		gdwElapsed = (GetTickCount() - gdwTicks);
		wsprintf( (LPSTR)gszTemp, (LPSTR) "getservbyname() 함수 수행으로 %ld"
			"밀리초(ms)가 소요 되었습니다.\r\n", gdwElapsed);

		Display(gszTemp);

		// 서비스 정보로 제공해주는 포트 번호 정보를 찾지 못했다면
		if (lpServEnt == NULL)
		{
			// 잘 알려진 포트(well-known)로 채웁니다.
			saServ.sin_port = htons(110);
			Display("getservbyent() 함수가 성공하지 못해서 110번 포트를 사용합니다.\r\n");

		}

		else
		{
			// 수행도우미(서번트 - servent)에서 받은 되돌림(return)값
			saServ.sin_port = lpServEnt->s_port;

		}

		// 서버 주소 구조체를 완성합니다.
		saServ.sin_family = AF_INET;		// 인터넷 주소 계열
		lpHostEnt = (LPHOSTENT)bufHostEnt;
		saServ.sin_addr = *( (LPIN_ADDR)*lpHostEnt->h_addr_list);

		// 소켓에 접속합니다.
		Display("connect() 함수를 호출합니다.\r\n");
		
		// connect(접속하여 연결될 소켓, 접속할 서버주소, 주소의 길이
		nRet = connect(socketPOP, (LPSOCKADDR)&saServ, sizeof(SOCKADDR_IN) );

		if(nRet == SOCKET_ERROR)
		{
			if(WSAGetLastError() != WSAEWOULDBLOCK)
			{
				Display("접속 중에 오류가 발생했습니다.\r\n");
				EnableButtons(TRUE);
				return;

			}

		}
		
		gnAppState = STATE_CONNECTING;
		Display("\r\n ---- 처리 메시지(Process Messages) ---- \r\n");


}

void HandleAsyncMsg(
					HWND	hwndDlg,
					WPARAM	wParam,
					LPARAM	lParam)

{
	int nBytesRead;

	switch(WSAGETSELECTEVENT(lParam))
	{
		case FD_CONNECT:
			Display("FD_CONNECT 알림을 받았습니다.\r\n");
			break;

		case FD_WRITE:
			Display("FD_WRITE 알림을 받았습니다.\r\n");
			break;

		case FD_READ:
			Display("FD_READ 알림을 받았습니다.\r\n");
			Display("recv() 함수를 호출합니다.\r\n");
			// 대기 자료를 받습니다.
			nBytesRead = recv(
								socketPOP,			// 소켓
								gbufRecv,				// 버퍼
								sizeof(gbufRecv),	// 최대로 받을 길이
								0);					// recv 함수의 플래그 값

			// recv() 함수의 되돌림 값을 받습니다.
			if(nBytesRead == 0)
			{
				// 연결이 끝어 졌습니다.
				MessageBox(
							hwndDlg,
							"연결에 예상치 못하게 끊어 졌습니다.",
							"recv() 함수 오류", MB_OK);
				break;

			}

			if(nBytesRead == SOCKET_ERROR)
			{
				wsprintf( (LPSTR)gszTemp,
							"recv() 오류 : %d", nBytesRead);
				MessageBox(
							hwndDlg,
							gszTemp,
							"recv() 함후 오류",
							MB_OK);

				break;

			}

			// 버퍼에 종단 문자(terminate)를 넣습니다.
			gbufRecv[nBytesRead] ='\0';

			// 해석 하기 위해서 넘겨 줍니다.
			ProcessData(hwndDlg, gbufRecv, nBytesRead);
			break;

			case FD_CLOSE:
				Display("FD_CLOSE 통보를 받았습니다.\r\n");
				EnableButtons(TRUE);
				break;
		}

	}

	// ProcessData() 함수
	// 들어오는 문서를 받아서 줄을 끊어서 저장합니다.
void ProcessData(HWND hwndDlg, LPSTR lpBuf, int nBytesRead)
{
	static char szResponse[512];
	static int nLen = 0;
	char *cp;

	// 새 자료를 저장할 공간이 있을까요?
	if ( (nLen + nBytesRead) > sizeof(szResponse) )
	{
		// 아니요~ , 공간이 없습니다.
		Display("!!!! 버퍼가 가득 찼습니다. 자료가 잘려(절삭)집니다.\r\n");
		nLen = 0;
		szResponse[0] = '\0';
		return;

	}

	// 공간 있어요~
	// 버퍼에 새 줄을 추가 합니다.
	strcat(szResponse, lpBuf);
	nLen = strlen(szResponse);

	// 저체 줄을 작업을 합니다.
	while(1)
	{
		// 버퍼에 새줄 값을 담고 있나요?
		cp = strchr(szResponse, '\n');
		if(cp == NULL)
			// 못 찾았습니다.
			break;

		// CR/LF (Carrage Return / Line Feed - 행갈이/줄끝) 쌍을 가지고 있습니다.
		// LF 을 NULL 값을 바꿉니다.
		*cp = '\0';

		// PrcessLine() 함수에 넣습니다.
		ProcessLine(hwndDlg, szResponse);

		// 버퍼에 남겨진 데이터를 앞으로 당겨 옵니다.
		cp++;

		if(strlen(cp))
			memmove(szResponse, cp, strlen(cp)+1);

		else
			szResponse[0] = '\0';

	}

}

// ProcessLine()
// 서버(Server)에게 명령줄에 대한 응답을 받고 다음에 뭘 할지 결정합니다.

void ProcessLine(HWND hwndDlg, LPSTR lpStr)
{
	int nRet;
	long lCount;
	long lSize;

	Display("서버로 부터의 응답입니다 : \r\n");
	Display(lpStr);
	Display("\r\n");

	// 오류에 대한 응답인지 확인합니다.
	if(lpStr[0] == '-')
	{
		Display("부정적인 응답입니다.(Negative response) :");
		switch(gnAppState)
		{
			case STATE_CONNECTING:
				Display("접속이 거부 당했습니다.\r\n");
				break;

			case STATE_USER:
				Display("알수 없는 사용자ID입니다.\r\n");
				break;

			case STATE_PASS:
				Display("틀린 비밀번호입니다.\r\n");
				break;

			case STATE_STAT:
				Display("STAT 명령이 지원하지 않습니다.\r\n");
				break;

			case STATE_QUIT:
				Display("QUIT 명령이 지원하지 않습니다.\r\n");
				break;

		}

		Display("Sending QUIT\r\n");
		wsprintf(gszTemp, "QUIT\r\n");
		Display(gszTemp);

		nRet = send(
					socketPOP,			// 소켓
					gszTemp,			// 데이터 버퍼
					strlen(gszTemp),	// 데이터의 길이
					0);					// 플래그
			
		gnAppState = STATE_QUIT;
		return;

	}

	// 긍정적인 응답을 받았습니다.
	switch(gnAppState)
	{
		case STATE_CONNECTING:
			// 로그인(LOGING) 부분에서 사용자(USER) 정보 부분을 전송하고
			// 프로그램 상태를 수정합니다.
			Display("AppState = CONNECTING, "
				"senging USER\r\n");

			wsprintf(gszTemp, "USER %s\r\n", gszUserID);
			nRet = send(
					socketPOP,			// 소켓
					gszTemp,			// 데이터 버퍼
					strlen(gszTemp),	// 데이터의 길이
					0);

			gnAppState = STATE_USER;
			break;

		case STATE_USER:
			// 로그인 부분에서 패스워드(PASSWORD) 부분을 전송하고
			// 프로그램 상태를 수정합니다.
			Display("AppState = SEND, 패스워드를 전송합니다.\r\n");
			wsprintf(gszTemp, "PASS %s\r\n", gszPassword);
			nRet = send(
						socketPOP,			// 소켓
						gszTemp,			// 데이터 버퍼
						strlen(gszTemp),	// 데이터의 길이
						0);

			gnAppState = STATE_PASS;
			break;

		case STATE_PASS:
			// STAT 명령어를 보내고,
			// 프로그램 상태를 수정합니다.
			Display("AppState = PASS, STAT 를 보냅니다.\r\n");
			wsprintf(gszTemp, "STAT\r\n");
			nRet = send(
						socketPOP,			// 소켓
						gszTemp,			// 데이터 버퍼
						strlen(gszTemp),	// 데이터의 길이
						0);

			gnAppState = STATE_STAT;
			break;

		case STATE_STAT:
			// STAT 응답을 읽습니다.
			// 결과를 출력합니다.
			Display("AppState = STAT, 응답을 읽습니다.\r\n");
				sscanf(lpStr, "%s %ld %ld", gszTemp, &lCount, &lSize);
			
			Display("---- 결과(Result)----\r\n");
			wsprintf(gszTemp, "%ld 메시지 %ld 바이트\r\n", lCount, lSize);
			Display(gszTemp);

			// QUIT 명령을 전송합니다.
			// 프로그램의 상태를 수정합니다.
			Display("QUIT 명령를 전송합니다.\r\n");
			wsprintf(gszTemp, "QUIT\r\n");
			nRet = send(
						socketPOP,			// 소켓
						gszTemp,			// 데이터 버퍼
						strlen(gszTemp),	// 데이터의 길이
						0);

			gnAppState = STATE_QUIT;
			break;

		case STATE_QUIT:
			Display("호스트 QUIT OK\r\n");
			Display("소켓을 닫습니다.\r\n");
			CloseSocket(socketPOP);

	}

}			

// CloseSocket()
// 프로토콜 스택에 있는 버퍼를 비우고 소켓을 닫습니다.
void CloseSocket(SOCKET sock)
{
	int nRet;
	char szBuf[255];

	// 원격지에게 우리는 자료를 보내지 않을 거라는 정보를 전송합니다.
	shutdown(sock, 1);
	while(1)
	{
		// 자료 받기를 시도 합니다.
		// 이는 아직 프로토콜에 남아 있을지 모르는 자료를 지우기 위해서 입니다.

		nRet = recv(
						sock,			// 소켓
						szBuf,			// 데이터 버퍼
						sizeof(szBuf),	// 버퍼의 길이
						0);				// revc 플래그

		// 연결이 끝났거나 어떤 다른 문제라도 생기면 받는걸 중단합니다.
		if (nRet == 0 || nRet == SOCKET_ERROR)
			break;

	}

	// 상대편에게 우리는 자료를 더 받지도 않을 거라고 알리니다.
	shutdown(sock,2);

	// 소켓을 닫습니다.
	closesocket(sock);

}

/* 저작권 공지
	http://www.sockaddr.com/ExampleSourceCode.html
	http://cakel.tistory.com

	sock_gethttp.cpp
	Hyper Text Transfer Protocol (HTTP : 하이터 텍스트 전송 프로토콜)
	을 이용하여 파일을 받아서 stdout(화면) 로 인쇄하는 내용입니다.
	서버 이름과 전체 경로를 명령줄 인수로 보내고 출력파력될 파일로 연결 됩니다.
	이 과정은 stderr 로 출력이 됩니다.

	예
	sock_gethttp.exe cakel.tistory.com /index.html
	index.html을 읽어 옵니다.

*/

#include <stdio.>
#include <io.h>
#include <fcnl.h>
#include <winsock.h>

#pragma comment(lib,"ws2_32.lib") // compile 시 ws2_32.lib 파일을 링크 시킵니다.

void GetHTTP(LPCSTR lpServerName, LPCSTR lpFileName);

// 오류를 출력하는 도우미 매크로 입니다.
#define PRINTERROR(s) fprintf(stderr,"\n%s 오류코드 : %d\n",s , WSAGetLastError())

int main(int argc, char* *argv)
{
	// WinSock Version 1.1 의 wsaData 형 자료 생성
	WORD wVersionRequested = MAKEWORD(1, 1);
	WSADATA wsaData;
	int nRet;

	// 인수 확인
	if (argc != 3)
	{
		fprintf(stderr, "\n사용법 : sock_gethttp.exe [서버 이름] [절대 경로]\n");
		return 0;

	}

	// WinSock.dll 시작하기
	nRet = WSAStartup(wVersionRequested, &wsaData);
	if(nRet)
	{
		fprintf(stderr,"\nWSAStartup() : %d\n", nRet);
		WSACleanup();
		return 0;

	}

	// WinSock 버전 확인
	if(wsaData.wVersion != wVersionRequested)
	{
		fprintf(stderr,"\nWinSock Version 이 지원하지 않습니다.\n");
		WSACleanup();
		return 0;

	}

	// "stdout" 스트림(외부로 통신하는 개체 - 보통 stdout은 화면)
	// 을  binary(이진) mode 로 하여 .jpg .gif 같은 그림 파일에게도 동작하게 만듭니다.
	_setmode(_fileno(stdout), _O_BINARY);

	// GetHTTP() 함수를 수행하여 작업을 개시 합니다.
	GetHTTP(argv[1], argv[2]);

	// WinSock 를 풉니다.
	WSACleanup();

	return 0;
}

void GetHTTP(LPCSTR lpServerName, LPCSTR lpFileName)
{

	// inet_addr() 함수로 서버 주소를 다루는지 아니면 IP 주소인지 확인 합니다.
	IN_ADDR		iaHost;
	LPHOSTENT	lpHostEntry;

	iaHost.s_addr = inet_addr(lpServerName);
	if(iaHost.s_addr == INADDR_NONE)
	{
		// IP 주소가 아니므로 도메인 이름으로 호스트 주소를 받습니다.
		lpHostEntry = gethostbyname(lpServerName);

	}
	else
	{
		// 유효한 IP 주소이므로 호스트 주소를 IP 주소를 통해 받습니다.
		lpHostEntry = gethostbyaddr( (const char *)&iaHost, sizeof(struct in_addr), AF_INET);

	}

	if (lpHostEntry == NULL)
	{
		PRINTERROR("함수 gethostbyname() 호출 하는 중에 문제가 발생했습니다.");
		return;

	}

	// TCP/IP stream socket (스트림 소켓 를 생성합니다.
	SOCKET Socket;

	// socket(인터넷 주소, 스트림 소켓 형식, TCP 인터넷 프로토콜)
	Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	if (Socket == INVALID_SOCKET)
	{
		PRINTERROR("socket() 함수를 호출 하는 중에 문제가 발생했습니다.");
		closesocket(Socket);
		return;

	}

	// TCP 를 통한 HTTP service 를 관장하는 포트 번호를 찾습니다.
	LPSERVENT lpServEnt;
	SOCKADDR_IN saServer;

	lpServEnt = getservbyname("http", "tcp");
	if(lpServEnt == NULL)
	// 찻질 못했으면 기본값인 80번을 받습니다.
		saServer.sin_port = htons(80);

	else
		saServer.sin_port = lpServEnt->s_port;

	// 서버의 남은 주소 구조체를 완성 합니다.
	saServer.sin_family = AF_INET;
	saServer.sin_addr = *( (LPIN_ADDR) *lpHostEntry->h_addr_list);

	// Socket(소켓)에 접속합니다.
	int nRet;

	// connect(접속할 소켓, 소켓에 해당하는 주소의 주소(구조체), 주소 구조체의 길이)
	nRet = connect(Socket, (LPSOCKADDR)&saServer, sizeof(SOCKADDR_IN) );
	if (nRet == SOCKET_ERROR)
	{
		PRINTERROR("connect() 함수를 호출하는데 문제가 발생했습니다.");
		closesocket(Socket);
		return;

	}

	// HTTP 요구를 하는 형식을 정합니다.
	char szBuffer[1024];

	// GET [파일명] : HTTP - 파일을 받습니다.
	sprintf(szBuffer, "GET %s\n", lpFileName);

	// send(소켓명, 전송할 버퍼, 버퍼의 길이, 플래그)
	nRet = send(Socket, szBuffer, strlen(szBuffer), 0);

	// 파일의 내용을 받아서 stdout 스트림으로 출력합니다.
	while(1)
	{
		// 받을때 까지 기다립니다.  nRet = 받은 바이트의 길이
		// recv(소켓명, 저장할 퍼버, 버퍼의 길이, 플래그)
		nRet = recv(Socket, szBuffer, sizeof(szBuffer), 0);
		if (nRet == SOCKET_ERROR)
		{
			PRINTERROR("recv() 함수를 호출하는데 문제가 발생했습니다.");
			break;

		}

		fprintf(stderr,"\nrecv() 함수를 수행하여 %d 바이트틑 보냅니다.\n",nRet);

		// 서버가 연결을 닫았습니까?
		if(nRet == 0)
			break;

		// stdout 스트림 개체로 출력합니다.

		fwrite(szBuffer, nRet, 1, stdout);

	}

	closesocket(Socket);

	return;

}

/*

  저작권 공지
  http://www.sockaddr.com/ExampleSourceCode.html
  http://cakel.tistory.com
  교육용을 목적으로 자유롭게 사용이 가능합니다.

  hostinfo.cpp
  WinSock gethostbyX 함수로 호스트 이름이나 IP 주소로
  hostent 구조체 를 받습니다.

  서버 주소를 IP 주소를 명령줄에서 받습니다.

  실행 예 :
  hostinfo.exe [IP 주소 또는 도메인 주소]

  예제)
    hostinfo www.naver.com (엔터)
    HOSTENT
    -----------------
    Host Name........: naver.com
    Host Aliases.....
    Address type.....: 2 (AF_INET)
    Address length...: 4
    IP Addresses.....: 222.122.84.250
                     : 222.122.84.200

    hostinfo cakel.tistory.com (엔터)
    HOSTENT
    -----------------
    Host Name........: cakel.tistory.com
    Host Aliases.....
    Address type.....: 2 (AF_INET)
    Address length...: 4
    IP Addresses.....: 211.172.252.15

*/

#include <stdio.h>
#include <winsock.h>

#pragma comment(lib,"ws2_32.lib")    // WinSock library 를 compile시 link 합니다.

int Printhostent(LPCSTR lpServerNameOrAddress);

int main(int argc, char* *argv)
{
    // 필요한 WinSock Version은 1.1 입니다.
    WORD wVersionRequested = MAKEWORD(1,1);
    WSADATA wsaData;
    int nRC;

    // 인수를 검사합니다.
    if (argc != 2)
    {
        fprintf(stderr, "\n사용법 : hostinfo.exe [서버 주소 또는 IP주소]\n");
        return 0;
    }

    // WinSock.dll 를 초기화합니다.
    nRC = WSAStartup(wVersionRequested, &wsaData);
    if (nRC)
    {
        fprintf(stderr, "\nWSAStartup() 오류 입니다 : %d\n", nRC);
        WSACleanup();    // 종료 합니다.
        return 0;

    }

    // WinSock 버전을 확인 합니다.
    if (wVersionRequested != wsaData.wVersion)
    {
        fprintf(stderr,"\nWinSock version 1.1 이 지원하지 않습니다.\n");
        WSACleanup();
        return 0;

    }

    // Printhostend() 함수로 작업을 합니다.
    nRC = Printhostent(argv[1]);
    if (nRC)
        fprintf(stderr, "\nPrinthostent 반환 코드 : %d\n", nRC);

    WSACleanup();    // WinSock Application 을 제거 합니다.
        
    return 0;
}

int Printhostent(LPCSTR lpServerNameOrAddress)
{
    LPHOSTENT lpHostEntry;        // 호스트 단위 구조체를 가리키는 포인터 입니다.
    struct in_addr iaHost;        // 인터넷 주소 구조체 입니다.
    struct in_addr *pinAddr;    // 인터넷 주소를 가리키는 포인터 입니다.
    LPSTR    lpAlias;            // 별명(2차 이름)을 가리키는 문자열 포인터 입니다.
    int iNdx;

    //    inet_addr() 함수로 도메인 이름인지 아니면 주소인지 결정 합니다.

    iaHost.s_addr = inet_addr(lpServerNameOrAddress);
    if (iaHost.s_addr == INADDR_NONE)
    {
        // IP 주소가 아니였습니다, 이름으로 간주 합니다.
        lpHostEntry = gethostbyname(lpServerNameOrAddress);

    }

    else
    {
        // 유효한 IP 주소 문자열이라 확인 되었습니다.
        lpHostEntry = gethostbyaddr( (const char*) &iaHost, sizeof(struct in_addr), AF_INET);

    }

    // 되돌아 오는 값을 검사합니다.

    if(lpHostEntry == NULL)
    {
        fprintf(stderr, "\n호스트에서 문제가 생겼습니다 : %d", WSAGetLastError());
        return WSAGetLastError();

    }

    // 구조체를 출력합니다.
    printf("\n\nHOSTENT");
    printf("---------------");

    // 호스트 이름
    printf("\n호스트 이름(Host Name) .......... : %s", lpHostEntry->h_name);

    // 호스트의 별명들의 목록
    printf("\n\n호스트의 별명(aliase)............");
    for(iNdx = 0; ; iNdx++)
    {
        lpAlias = lpHostEntry->h_aliases[iNdx];
        if(lpAlias == NULL)
                break;

        printf(" : %s", lpAlias);
        printf("\n                           ");

    }

    // 주소 형식
    printf("\n주소 형식 ....................... : %d", lpHostEntry->h_addrtype);
    if(lpHostEntry->h_addrtype == AF_INET)
        printf("(AF_INET)");

    else
        printf("(알수 없는 형식)");

    // 주소 길이
    printf("\n주소 길이 ....................... : %d", lpHostEntry->h_length);

    // IP 주소의 목록
    printf("\nIP 주소 ........");
    for(iNdx = 0; ; iNdx++)
    {
        pinAddr = ( (LPIN_ADDR)lpHostEntry->h_addr_list[iNdx] );
        if(pinAddr == NULL)
            break;

        printf(" %s", inet_ntoa(*pinAddr) );
        printf("\n                ");

    }

    printf("\n");
    return 0;

/*
  출처 및 저작권 표기(Copyright)
  http://www.sockaddr.com/ExampleSourceCode.html
  http://cakel.tistory.com
  교육용을 목적으로 자유롭게 쓰실수 있습니다.

  tcp_client.cpp (Client.cpp)
  아주 간단한 스트림 클라이언트 예제 입니다.
  udp_server.cpp (Server.cpp)와 같이 작동합니다.

  이 프로그램은 명령줄에 있는 서버와 포트명에 접속을 시도합니다.
  서버 프로그램은 시작 되었을때 필요한 정포를 표시합니다.
  연결이 되면 서버에 접속해서 자료를 보내고 응답을 기다린후 종료 합니다.

  wsock32.lib 와 함께 링크하시고 컴파일 하세요

  서버명과 포트 번호를 명령줄에 넣어 주세요
  예 : udp_client 127.0.0.1 2000

*/

#include <stdio.h>
#include <winsock.h>

// 함수 프로토타입
void StreamClient(char* szServer, short nPort);

// 오류를 표기할 매크로 도우미
#define PRINTERROR(s) fprintf(stderr,"\n%: %d\n", s, WSAGetLastError())

int main(int argc, char* *argv)
{
    WORD wVersionRequested = MAKEWORD(1,1);
    WSADATA wsaData;
    int nRet;
    short nPort;

    // 호트명과 포트 번호를 확인합니다.

    if (argc != 3)
    {
        fprintf(stderr,"\n사용법 : udp_client [서버주소] [포트번호]\n");
        return 1;
    }

    nPort = atoi(argv[2]);

    // 윈속 버전을 확인 합니다.

    nRet = WSAStartup(wVersionRequested, &wsaData);
    if (wsaData.wVersion != wVersionRequested)
    {
        fprintf(stderr, "\n 윈속 버전이 틀립니다.\n");
        return 1;
    }

    // 스트림 클라이언트가 해야 할 일을 합니다.
    // 여기까지는 UDP 와 크게 차이가 없습니다.
    StreamClient(argv[1], nPort);

    WSACleanup();

    return 0;
}

//

void StreamClient(char* szServer, short nPort)
{
    printf("\n스트림 클라이언트가 서버 : %s 포트 : %d 에 접속합니다", szServer, nPort);

    // 서버를 찾습니다.

    LPHOSTENT lpHostEntry;

    lpHostEntry = gethostbyname(szServer);
    if(lpHostEntry == NULL)
    {
        PRINTERROR("gethostbyname()");
        return;

    }

    // TCP/IP 스트림 소켓을 생성합니다.
    SOCKET theSocket;
   
    // socket(주소 계열, 소켓 형태, 프로토콜
    theSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    if (theSocket == INVALID_SOCKET)
    {
        PRINTERROR("socket()");
        return;

    }

    // 주소 구조체를 채웁니다.
    SOCKADDR_IN saServer;

    saServer.sin_family = AF_INET;
    saServer.sin_addr = *((LPIN_ADDR)*lpHostEntry->h_addr_list); // 서버 주소
    saServer.sin_port = htons(nPort);    // 명령줄에서 포트 번호를 받습니다.

    // 서버로 접속합니다

    int nRet;

    // connect(소켓, 서버 주소, 서버 주소의 길이
    nRet = connect(theSocket, (LPSOCKADDR)&saServer, sizeof(struct sockaddr) );
   
    if(nRet == SOCKET_ERROR)
    {
        PRINTERROR("socket()");
        closesocket(theSocket);
        return;

    }

    // 서버로 자료를 보냅니다.

    char szBuf[256];
    strcpy(szBuf, "클라이언트에서 보내는 TCP 값입니다");

    // Windows 에서는 Unix 계열과 다르게 보낼때 write 대신에 send 를 씁니다.
    // send(연결된 소켓, 보낼 자료 버퍼, 자료의 길이, 상태값
    nRet = send(theSocket, szBuf, strlen(szBuf), 0);

    if (nRet == SOCKET_ERROR)
    {
        PRINTERROR("send()");
        closesocket(theSocket);
        return;

    }

    // 응답을 기다립니다
   
    // Windows 에서는 Unix 계열과 다르레 받을때는 read 대신에 recv 를 씁니다.
    // recv(연결된 소켓, 받은 자료를 저장할 버퍼, 버퍼의 길이, 상태값)
    nRet = recv(theSocket, szBuf, sizeof(szBuf), 0);
    if (nRet == SOCKET_ERROR)
    {
        PRINTERROR("recv()");
        closesocket(theSocket);
        return;
    }

    // 받은 값을 표시합니다.
    printf("\n값을 받았습니다 : %s", szBuf);

    closesocket(theSocket);
    return;

}

/*
    저작권 표기(Copyrights)
    http://www.sockaddr.com/ExampleSourceCode.html
    http://cakel.tistory.com

    교육용을 목적으로 자유롭게 쓰실수 있습니다.

    아주 간단한 스트림 서버 예제 입니다.
    udp_client (Client.cpp) 와 작동 합니다.

    이 프로그램은 TCP 프로토콜을 이용해서 서버를 만드는 일을 합니다.
    클라이언트에서 자료를 기다리고 들어온 값을 표기하며 클라이언트에게 값을
    되돌리고 종료를 합니다.

    wsock32.lib 를 링크 시키기고 컴파일 하세요

    bind() 함수를 사용하기 위해 명령줄에 포트 번호를 넣어 주세요. 이미 쓰고 있지
    않는다면 어떤 포트 번호도 쓸수 있습니다.

    예 : udp_server 2000

*/

#include <stdio.h>
#include <winsock.h>

// 프로토타입 함수
void StreamServer(short nPort);

// 오류를 표기하는 매크로 도우미
#define PRINTERROR(s) fprintf( stderr, "%d\n", s, WSAGetLastError() )

//

int main(int argc, char* *argv)
{
    WORD wVersionRequested = MAKEWORD(1, 1);
    WSADATA wsaData;
    int nRet;
    short nPort;

    // 포트 번호를 확인 합니다.
    if (argc !=2)
    {
        fprintf(stderr, "\n사용법 : udp_server [포트 번호]\n");
        return 1;

    }

    nPort = atoi(argv[1]);

    // 윈속을 시작하고 버전을 확인합니다
    nRet = WSAStartup(wVersionRequested, &wsaData);
    if(wsaData.wVersion != wVersionRequested)
    {
        fprintf(stderr, "\n 윈속 버전이 틀렸습니다.\n");
        return 1;

    }

    // 스트림 서버가 할일을 수행합니다.
    StreamServer(nPort);

    return 0;

    // 소켓을 풉니다.
    WSACleanup();

}

void StreamServer(short nPort)
{
    // TCP/IP 스트림 소켓을 "listen"으로 생성합니다.

    SOCKET listenSocket;

    // socket(주소계열, 소켓 형식, 프로토콜)
    listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   
    if(listenSocket == INVALID_SOCKET)
    {
        PRINTERROR("socket()");
        return;

    }

    // 주소 구조체를 채웁니다.
    SOCKADDR_IN saServer;

    saServer.sin_family = AF_INET;
    saServer.sin_addr.s_addr = INADDR_ANY;    // 윈속이 제공하게 둡니다.
    saServer.sin_port = htons(nPort);        // 명령줄에서 받은 포트를 넣습니다.

    // 소켓과 listensocket 을 bind(묶습) 합니다.
    int nRet;
   
    // bind(소켓, 서버 주소, 주소 구조체의 길이
    nRet = bind(listenSocket, (LPSOCKADDR)&saServer, sizeof(struct sockaddr) );
   
    if(nRet == SOCKET_ERROR)
    {
        PRINTERROR("bind()");
        closesocket(listenSocket);
        return;

    }

    /*
    이 부분은 잘 쓰이거나 요구되지 않습니다만, 이 예제에서 우리는 서버가 기다리고 있다는 것을
    표시해줘야지 클라이언트가 접속할수 있어서 표시합니다.
    */

    int nLen;
    nLen = sizeof(SOCKADDR);
    char szBuf[256];

    nRet = gethostname( szBuf, sizeof(szBuf) );
    if (nRet == SOCKET_ERROR)
    {
        PRINTERROR("gethostname()");
        closesocket(listenSocket);
        return;

    }

    // 서버 주소와 포트 번호를 표시 합니다.
    printf("\n %s 서버가 %d 포트에서 요청을 기다립니다. \n", szBuf, nPort);

    // 소켓에게 기다리게 합니다.

    printf("\nlisten()");

    // listen(오는 소켓, 요청 수용 가능한 용량)
    nRet = listen(listenSocket, SOMAXCONN);

    if(nRet == SOCKET_ERROR)
    {
        PRINTERROR("listen()");
        closesocket(listenSocket);
        return;

    }

    // 오는 요청을 기다립니다.
    SOCKET remoteSocket;

    printf("\naccept() 에서 막혔습니다.");

    // accept(요청을 받으 소켓, 선택 클라이언트 주소)
    remoteSocket = accept(listenSocket, NULL, NULL);

    if(remoteSocket == INVALID_SOCKET)
    {
        PRINTERROR("accept()");
        closesocket(listenSocket);
        return;

    }

    /*
   
       이제 클라이언트와 연결 했습니다.
       새로운 소켓 식별자가 준비 되었다고 클라이언트 주소를 되돌림
       값을 지고 왔습니다.

    */

    // 클라이언트에서 값을 받습니다.

    memset( szBuf, 0, sizeof(szBuf) );
    nRet = recv(remoteSocket, szBuf, sizeof(szBuf), 0);

    if (nRet == INVALID_SOCKET)
    {
        PRINTERROR("recv()");
        closesocket(listenSocket);
        closesocket(remoteSocket);
        return;

    }
   
    // 받은 값을 표시 합니다.
    printf("\n값을 받았습니다 : %s", szBuf);

    // 클라이언트에게 값을 되돌려 줍니다.
    strcpy(szBuf, "클라이언트로 값을 보냅니다. 잘받았습니다");

    // send(연결된 소켓, 보낼 버퍼, 버퍼의 길이, 상태값)
    nRet = send(remoteSocket, szBuf, sizeof(szBuf), 0);

    // 소켓 둘다 닫습니다
    closesocket(remoteSocket);
    closesocket(listenSocket);

    return;
}

/*

  저작권
  http://www.sockaddr.com/ExampleSourceCode.html
  http://cakel.tistory.com
  교육용을 목적으로 자유롭게 배포가 가능합니다.

  DClient.cpp (udp_client.cpp)

  완전 쉽고, 쓸모 없는 데이터그램 클라이언트 예제 입니다.
  DServer.cpp (udp_server.cpp) 와 같이 동작합니다.

  이 프로그램은 명령줄에서 명시한 서버와 포트에 접속을 시도합니다.
  DServer 프로그램은 시작할때 무슨 정보가 필요한지 표시합니다. 접속이 되면,
  이 프로그램은  서버에게 전송을 하고 응답을 기다립니다.

  wsock32.lib (ws2_32.lib) 와 같이 컴파일/링크 하세요

  서버이름과 포트번호를 명령 줄에 넣어 보내줘야 합니다.

  예제 : udp_client 127.0.0.1 2000
 

*/

#include <stdio.h>
#include <string.h>
#include <winsock.h>

// 프토타입 함수 선언
void DatagramClient(char* szServer, short nPort);

// 오류를 표시하기 위한 매크로 도우미 정의
#define PRINTERROR(s) fprintf(stderr, "\n%: &d\n", s, WSAGetLastError())

//

int main(int argc, char* *argv)
{
   
    WORD wVersionRequested = MAKEWORD(1,1); // 윈속 버전 1.1을 요구 참고 : http://blog.naver.com/dreamset?Redirect=Log&logNo=60010620996
    WSADATA wsaData;
    int nRet;
    short nPort;
   
    // 호스트와 포트 인수를 검사합니다.

    if (argc !=3)
    {
        fprintf(stderr, "\n문법 : udp_client [서버주소] [포트번호]\n");
        return 1;
    }

    nPort = atoi(argv[2]);

    // 윈속과 버전을 검사합니다.

    nRet = WSAStartup(wVersionRequested, &wsaData);
    if (wsaData.wVersion != wVersionRequested)
    {
        fprintf(stderr, "\n 틀린 윈속 버전입니다\n");
        return 1;

    }

    // 데이터그램 클라이언트가 해야 할 일을 이제 시작합니다.

    DatagramClient(argv[1], nPort);

    // 윈속을 풉니다.
    WSACleanup();

    return 0;
}

void DatagramClient(char* szServer, short nPort)
{
    printf("\n데이터그램 클라이언트는 지금 전송 중입니다. 서버 : %s 포트 : %d", szServer, nPort);

    // 서버를 찾습니다.

    LPHOSTENT lpHostEntry;

        lpHostEntry = gethostbyname(szServer);

    if (lpHostEntry == NULL)
    {
        PRINTERROR("gethostbyname()");
        return;

    }

    // UDP/IP 데이터그램 소켓을 생성합니다.

    SOCKET theSocket;

    // socket(주소계열, 소켓형식, 프토토콜)
    theSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
   
    if (theSocket == INVALID_SOCKET)
    {
        PRINTERROR("socket()");
        return;

    }

    // 서버에게 보낼 주소 구조체를 채웁니다.
    SOCKADDR_IN saServer;

    saServer.sin_family = AF_INET;
    saServer.sin_addr = *( (LPIN_ADDR)*lpHostEntry->h_addr_list); // 서버 주소
    saServer.sin_port = htons(nPort); // 명령줄에서 포트 번호를 받은 것입니다.

    // 서버에 자료를 전송합니다.

    char szBuf[256];
    int nRet;

    strcpy(szBuf, "클라이언트에서 보냅니다. 잘가죠?");

    //     sendto(소켓,자료버퍼,자료의 길이, 플래그 - 상태값, 서버주소, 주소의 길이
    nRet = sendto( theSocket, szBuf, strlen(szBuf), 0, (LPSOCKADDR)&saServer, sizeof(struct sockaddr) );

    if(nRet == SOCKET_ERROR)
    {
        PRINTERROR("sendto()");
        closesocket(theSocket);
        return;

    }

    // 응답을 기다립니다.

    memset(szBuf, 0, sizeof(szBuf));
    int nFromLen;

    nFromLen = sizeof(struct sockaddr);
   
    // recvfrom(소켓, 받는버퍼, 버퍼의 길이, 플래그 - 상태값, 송신자의 주소를 받을 버퍼, 주소버퍼의 길이
    recvfrom(theSocket, szBuf, sizeof(szBuf), 0, (LPSOCKADDR)&saServer, &nFromLen);

    if(nRet == SOCKET_ERROR)
    {
        PRINTERROR("recvfrom()");
        closesocket(theSocket);
        return;

    }

    // 받은 값을 표시 합니다
    printf("\nData received, 값을 받았습니다 : %s", szBuf);

    closesocket(theSocket);
    return;

}

/*
    저작권
    http://www.sockaddr.com/ExampleSourceCode.html
    http://cakel.tistory.com
    교육용을 목적으로 자유롭게 배포할수 있습니다.

    udp_server.cpp (DServer.cpp)

    아주 간단하고 쓸모 없는 데이터그램 서버 예지입니다.
    udp_client.cpp (DClient.cpp)와 함께 작동합니다.

    이 프로그램은 UDP 프로토콜을 이용하여 서버를 만듭니다. 그리고
    클라이언트를 기다리며 들어 오는 데이터를 화면에 표시하고,
    클라이언트에게 응답을 보내며 종료합니다.

    wsock32.lib (ws2_32.lib) 와 함께 링크 하고 컴파일 하세요

    bind() 함수를 쓰기 위해 명령줄에 포트 번호를 넣어 주세요.
    쓰지 않는 어떤 포트 번호로 가능합니다.

    예제 : udp_server 2000

*/

#include <stdio.h>
#include <winsock.h>

// 프로토타입 함수
void DatagramServer(short nPort);

// 오류를 표기하기 위한 매크로 도우미
#define PRINTERROR(s)    fprintf(stderr, "\n%: %d\n", s, WSAGetLastError())

//

int main(int argc, char** argv)
{
    WORD wVersionRequested = MAKEWORD(1, 1);
    WSADATA wsaData;
    int nRet;
    short nPort;

    // 인수를 점검합니다
    if (argc != 2)
    {
        fprintf(stderr, "\n사용법 : udp_server [포트번호]\n");
        return 1;

    }

    nPort = atoi(argv[1]);

    // 윈속의 버전을 확인
    nRet = WSAStartup(wVersionRequested, &wsaData);
    if (wsaData.wVersion != wVersionRequested)

    {
        fprintf(stderr,"\n틀린 윈속 버전입니다.\n");
        return 1;

    }

    // 이제 서버가 할 일을 실행합니다.
    DatagramServer(nPort);

    // 윈속을 풉니다.
    WSACleanup();

    return 0;
}

//

void DatagramServer(short nPort)
{
    // UDP/IP 데이터 소켓을 생성합니다.
    SOCKET theSocket;

    // socket(주소계열, 소켓형식, 프로토콜)
    theSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    if(theSocket == INVALID_SOCKET)
    {
        PRINTERROR("socket()");
        return;

    }

    // 주소 구조체를 채웁니다.
    SOCKADDR_IN saServer;

    saServer.sin_family = AF_INET;           
    saServer.sin_addr.s_addr = INADDR_ANY;    // 윈속이 정하게 해줍니다.
    saServer.sin_port = htons(nPort);        // 사용자에게서 포트 번호를 받습니다.

    // 소켓으로 묶습니다.
    int nRet;

    // bind(소켓 기술자, 묶을 주소, 주소의 길이
    nRet = bind( theSocket, (LPSOCKADDR)&saServer, sizeof(struct sockaddr) );

    if (nRet == SOCKET_ERROR)
    {
        PRINTERROR("bind()");
        closesocket(theSocket);
        return;

    }

    /*
   
    이 부분은 정상적으로 되지않거나 필요하지 않지만
    이 예제에서 우리는 서버가 예제 클라이언트로 접속하기 위해
    서버가 기다리고 있다는 것을 표시합니다.

    */

    int nLen;
    nLen = sizeof(SOCKADDR);
    char szBuf[256];

    nRet = gethostname(szBuf, sizeof(szBuf));
    if (nRet == SOCKET_ERROR)
    {
        PRINTERROR("getthehostname()");
        closesocket(theSocket);
        return;

    }

    // 서버이름과 포트 번호를 표기 합니다.
    printf("\n서버 이름이 %s 이(가) 포트번호 %d\n 에서 요청을 기다립니다.", szBuf, nPort);

    // 클라이언트에서 오는 자료를 기다립니다.
    SOCKADDR_IN saClient;

    memset(szBuf, 0, sizeof(szBuf));

    // recvfrom(응답할 소켓, 받은 버퍼, 버퍼의 바이트수, 플래그 - 상태값,
    // 클라이언트 주소에서 받는 버퍼, 클라이언트 주소 버퍼의 길이
    nRet = recvfrom(theSocket, szBuf, sizeof(szBuf), 0, (LPSOCKADDR)&saClient, &nLen);

    // 이제 어떤 자료를 받았습니다.
    printf("값을 받았습니다 : %s", szBuf);

    // 클라이언트로 값을 돌려 줍니다.
    strcpy(szBuf, "서버에서");
   
    // sendto(보낼 소켓, 보낼 버퍼, 버퍼의 바이트수, 플래그 - 상태값,
    // 자료를 보낼 주소, 주소의 길이
    sendto(theSocket, szBuf, strlen(szBuf), 0, (LPSOCKADDR)&saClient, nLen);

    /*
   
    일반적으로 서버는 계속 작동을 해야지 다른 클라이언트들의 요청을 받습니다.
    이 예제에서 하나의 요청(transaction, 트랜잭션, 거래)이 완료 되자 마자
    종료 합니다.

    */

    closesocket(theSocket);
    return;

}

/*
    소스 출처 및 저작권
    http://www.sockaddr.com/ExampleSourceCode.html
    http://cakel.tistory.com

    교육용을 목적으로 자유롭게 배포 가능합니다.

    WSVer.c
    WSAStartup() 함수에서 받는 정보를 출력합니다.

    WSA = Windows Socket Application : 윈도우즈 소켓 응용프로그램

    선택적으로 당신은 명령줄에서 해당 버전을 입력할수 있습니다.

    예
    Version 1.1 정보 WSVer 1 1
    Version 2.0 정보 WSVer 2 0

    version 을 입력하지 않는다면 기본적으로 1.1 version 을 요청합니다.

 */

#include <stdio.h>
#include <winsock.h>
#include "wsedesc.c"

// wsedesc.c 도구 함수
LPCSTR WSErrorDescription(int iErrorCode);

void PrintWSAData(LPWSADATA pWSAData);

int main(int argc, char* *argv)
{
    WORD wVersionRequested = MAKEWORD(1, 1);
    WSADATA wsaData;
    int rc;

    if (argc == 3)
            wVersionRequested = MAKEWORD( atol(argv[1]), atol(argv[2]) );

    rc = WSAStartup(wVersionRequested, &wsaData);
    if(!rc)
        PrintWSAData(&wsaData);
   
    else
        fprintf( stderr, "\nWSAStartup() error (%d) %s\n", rc, WSErrorDescription(rc) );

    WSACleanup();

    return 0;
}

void PrintWSAData(LPWSADATA pWSAData)
{
    printf("\nWSADATA");
    printf("\n---------------------");
    printf("\nVersion - 버전.............: %d.%d", LOBYTE(pWSAData->wVersion),
                HIBYTE(pWSAData->wHighVersion) );

    printf("\nHighVersion - 상위버전.....: %d.%d", LOBYTE(pWSAData->wHighVersion),
                HIBYTE(pWSAData->wHighVersion) );
    printf("\nDescription - 설명.........: %s", pWSAData->szDescription);
    printf("\nSystem Status - 시스템상태.: %s", pWSAData->szSystemStatus);
    printf("\nMax number of socket - 최대 소켓수 : %d", pWSAData->iMaxSockets);
    printf("\nMAX UDP datagram size - UDP 최대 데이터그램 크기: %d\n", pWSAData->iMaxUdpDg);

}

 /*

//  저작권
//    http://www.sockaddr.com/ExampleSourceCode.html
//  http://cakel.tistory.com
//  교육용을 목적으로 자유롭게 배포 가능합니다.
//    WSEDesc.c -- 윈속 오류 설명

*/

#include <winsock.h>

typedef struct tagWSAEDESCRIPTION
{
    int iErrorCode;
    char* szDescription;

}WSAEDESCRIPTION;

WSAEDESCRIPTION ErrorDescriptions[] = {
    WSAEINTR,
        "WSAEINTR : Interrupted function call, 함수 호출이 인터럽트(강제수행 되었습니다",
    WSAEBADF,
        "WSAEBADF : Bad file number, 잘못된 파일 번호 입니다.",
    WSAEACCES,
        "WSAEACCES : Permission denied, 허용되지 않았습니다.",
    WSAEFAULT,
        "WSAEFAULT : Address fault, 부르지 못했습니다.",
    WSAEINVAL,
        "WSAINVAL : Invaild argument, 값이 틀렸습니다.",
    WSAEMFILE,
        "WSAEMFILE : Too many open files, 파일이 너무 많이 열렀습니다.",
    WSAEWOULDBLOCK,
        "WSAEWOULDBLOCK : Resource temporarily unavailable (Would block), 자원이 없습니다.(아마 막혔을 겁니다.)",
    WSAEINPROGRESS,
        "WASEINPROGRESS : Operation now in progress, 작업중입니다.",
    WSAEALREADY,
        "WSAEREADY : Operation already in progress, 이미 수행중입니다.",
    WSAENOTSOCK,
        "WSANOTSOCK : Socket operation operation on non-socket, 소켓이 아닌 곳에서 소켓 작업중입니다",
    WSAEDESTADDRREQ,
        "WSAEDESTADDRREQ : Destination address required, 목적지 주소가 필요 합니다.",
    WSAEMSGSIZE,
        "WSAEMSGSIZE : Message too long, 메시지가 너무 깁니다.",
    WSAEPROTOTYPE,
        "WSAEPROTOTYPE : Protocol wrong type for socket, 소켓에 맞지 않은 프로토콜 입니다.",
    WSAENOPROTOOPT,
        "WSAENOPROTOOPT : Bad protocol option, 잘못된 프로토콜 옵션입니다.",
    WSAEPROTONOSUPPORT,
        "WSAEPROTONOSUPPORT : Protocol not supported, 지원하지 않는 프로토콜입니다.",
    WSAESOCKTNOSUPPORT,
        "WSAESOCKTNOSUPPORT : Socket type not supported, 지원하지 않는 소켓 형식입니다.",
    WSAEOPNOTSUPP,
        "WSAEOPNOSUPP : Operation not supported, 지원하지 않는 명령입니다.",
    WSAEPFNOSUPPORT,
        "WSAEPFNOSUPP : Protocol family not supported, 지원하지 않는 프로토콜 계열입니다.",
    WSAEAFNOSUPPORT,
        "WSAEAFNOSUPPORT : Address family not supported by protocol family, 프로토콜 계열에서 지원하지 않는 주소입니다.",
    WSAEADDRINUSE,
        "WAEADDRINUSE : Address already in use, 이미 사용 중인 주소 입니다.",
    WSAEADDRNOTAVAIL,
        "WSAEADDRNOTAVAIL : Cannot assign requested address, 요구한 주소를 할당할수 없습니다.",
    WSAENETDOWN,
        "WSAENETDOWN : Network is down, 네트워크가 작동하지 않습니다.",
    WSAENETUNREACH,
        "WSAENETUNREACH : Network is unreachable, 네트워크로 접근할수 없습니다.",
    WSAENETRESET,
        "WSAENETRESET : Network dropped connetion on reset, 네트워크가 초기화 되어 꾾어졌습니다.",
    WSAECONNABORTED,
        "WSAECONNABORTED : Software caused connection abort, 소프트웨어에 의해 연결을 중단되었습니다.",
    WSAECONNRESET,
        "WSAECONNRESET : Connection reset by peer, 상대방에 의해 연결이 초기화 되었습니다.",
    WSAENOBUFS,
        "WSAENOBUFS : No buffer space available, 버퍼 공간이 부족합니다",
    WSAEISCONN,
        "WSAEISCONN : Socket is already connected, 소켓이 이미 연결되었습니다.",
    WSAESHUTDOWN,
        "WSAESHUTDOWN : Cannot send after socket shutdown, 소켓이 닫힌 후에는 보낼 수가 없습니다.",
    WSAETOOMANYREFS,
        "WSAETOOMANYREFS : Too many references, 너무 많은 참조를 했습니다.",
    WSAETIMEDOUT,
        "WSAETIMEDOUT : Connection timed out, 연결 시간 초과 했습니다.",
    WSAELOOP,
        "WSAELOOP : Loop, 반복",
    WSAENAMETOOLONG,
        "WSAENAMETOOLONG : Name too long, 이름이 너무 깁니다.",
    WSAEHOSTDOWN,
        "WSAEHOSTDOWN : Host is down, 호스트가 꺼졌습니다.",
    WSAEHOSTUNREACH,
        "WSAEHOSTUNREACH : No route to host, 호스트로 접근할수가 없습니다.",
    WSAENOTEMPTY,
        "WSAENOTEMPTY : Directory not empty, 디렉토리가 안 비었습니다.",
    WSAEPROCLIM,
        "WSAEPROCLIM : Too many processes, 프로세스가 너무 많습니다.",
    WSAEUSERS,
        "WSAEUSERS : Too many users, 사용자가 너무 많습니다.",
    WSAEDQUOT,
        "WSAEDQUOT : Disk quota, 디스크 허용량 초과",
    WSAESTALE,
        "WSAESTALE : Stale, 오래됨",
    WSAEREMOTE,
        "WSAEREMOTE : Remote, 원격",
    WSASYSNOTREADY,
        "WSAESYSNOTREADY : Network subsystem is unavailable",
    WSAVERNOTSUPPORTED,
        "WSAEVERNOTSUPPROTED : WINSOCK.DLL version out of range, 윈속 버전이 맞지 않습니다.",
    WSANOTINITIALISED,
        "WSANOTINITIALISED : Successful WSAStartup() not yet performed, 성공적인 WSAStartup() 함수가 아직 수행되지 않았습니다.",
    WSAEDISCON,
        "WSAEDISCON : Graceful shutdown in progress, 우아한(?) 종료가 진행 중입니다.",
    WSAHOST_NOT_FOUND,
        "WSAHOST_NOT_FOUND : Host not found, 호스트를 발견하지 못했습니다.",
    WSATRY_AGAIN,
        "WSATRY_AGAIN : Non-authoritative host not found, 비인증 호스트를 발견하지 못했습니다.",
    WSANO_RECOVERY,
        "WSANO_RECOVERY : Non-recoverable error, 회복할수 없는 오류",
    WSANO_DATA,
        "WSANO_DATA : Vaild name, no data record of requested type, 유효한 이름이였으나 원하는 자료형을 받지 못했습니다.",
#ifdef    _WINSOCK2API_    // 윈속 2.0 이상에서 지원하는거 같습니다.
    WSAENOMORE,
        "WSAENOMORE : ",
    WSAECANCELLED,
        "WSAECANCELLED : Cancelled, 취소됨",
    WSAEINVAILDPROCTABLE,
        "WSAEINVAILDPROCTABLE : Invaild procedure table form service provider, 잘못된 프로지져 테이블 폼 서비스 제공자 입니다."
    WSAEPROVIDERFAILEDINIT,
        "WSAEPROVIDERFAILEDINIT : Unable to initialize a service provider, 서비스 제공자를 시작할수 없습니다.",
    WSASYSCALLFAILURE,
        "WSASYSCALLFAILURE, : System call Failure, 시스템 호출 실패",
    WSASERVICE_NOT_FOUND,
        "WSASERVICE_NOT_FOUND : Service not found, 서비스를 찾을수 없습니다.",
    WSATYPE_NOT_FOUND,
        "WSATYPE_NOT_FOUND : Type not found", 형식을 찾을수 없습니다.",
    WSA_E_NO_MORE,
        "WSA_E_NO_MORE : ",
    WSA_E_CANCELLED,
        "WSA_E_CANCELLED : ",
    WSAEREFUSED,
        "WSAREFUSED : Refused, 거부됨",

#endif

    };


//
//    WSErrorDesciption()
//

LPCSTR WSErrorDescription(int iErrorCode)
{
    #define NUMELEMENTS sizeof(ErrorDescriptions) / sizeof(ErrorDescriptions[0])
    int iNdx;

    for(iNdx = 0; iNdx < NUMELEMENTS; iNdx++)
    {
        if (ErrorDescriptions[iNdx].iErrorCode == iErrorCode)
                return(ErrorDescriptions[iNdx].szDescription);

    }

    return("Unknown error");
}

#include <stdio.h>
#include <winsock.h>

#define MAXBUF 256

// using namespace std;

int main()
{
    int ssock;
    int clen;
    int fflag = 0;
    struct sockaddr_in server_addr;
    char buf[MAXBUF];

    // 소켓 생성 실패시 오류
    if ( (ssock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0 )    {
        perror("socket error : ");
        exit(1);

    }

    clen = sizeof(server_addr);

    // 소켓이 접속할 주소 지정
    
    memset( &server_addr, 0, sizeof(server_addr) );
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    server_addr.sin_port = htons(3317);

    // 지정한 주소로 접속
    if( connect(ssock, (struct sockaddr* )&server_addr, clen) < 0 )    {
        perror("connect error :");
        exit(1);

    }

    memset(buf, 0, MAXBUF);
    if( recv(ssock, buf, MAXBUF, fflag) <= 0 )    {
        perror("read error :");
        exit(1);

    }
    
    // 소켓을 닫음
    closesocket(ssock);

    // 받아온 문자열을 화면에 출력
    printf("\nread : %d\n\n", buf);

    return 0;

}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock.h>

#define MAXBUF 256

int main()
{
    // 소켓 디스크립트, socket descript 정의
    int ssock, csock, clen;
    int fflag = 0;
    struct sockaddr_in client_addr, server_addr;    // 주소 구조체 정의
    char buf[MAXBUF] = "I like you!";    // 클라이언트에 보내줄 문자열

    // 서버 소켓 생성
    if( ssock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) < 0 )    {
        perror("socket error : ");
        exit(1);

    }

    clen = sizeof(client_addr);

    // 주소 구조체에 주소 지정
    memset( &server_addr, 0, sizeof(server_addr) );
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(3317);    // 사용할 포트로 3317번 포트 사용

    // bind 함수를 사용하여 서버 소켓의 주소 설정
    if( bind(ssock, (struct sockaddr* )&server_addr, sizeof(server_addr)) > 0 )    {
        perror("bind error : ");
        exit(1);

    }

    // 위에서 지정한 주소로 클라이언트 접속을 기다림
    if (listen(ssock, 8) > 0) {
        perror("listen error : ");
        exit(1);

    }

    while(1)
    {
            // 클라이언트가 접속하면 접속을 허용하고 클라이언트 소켓을 생성함
        csock = accept(ssock, (struct sockaddr *)&client_addr, &clen);

        // 클라이언트로 buf에 있는 "I like you!" 문자열 전송
        if( send(csock, buf, MAXBUF, fflag) > 0)
            perror("write error :");

        closesocket(csock);

    }

    return 0;

}

/*
    whois.c
    (c) feb 2000 by Gandalf
    다시 치기 http://cakel.tistory.com

*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <winsock.h>

#define WIN32_LEAN_AND_MEAN    // define win32 only

void handle_error(void);
void write_file(char* buf);

int main(int argc, char** argv)
{
    WORD wVersionRequested;            // 소켓 dll 버전 정보
    WSADATA wsaData;                // 소켓 lib 생성화를 위한 자료
    SOCKET sock;                    // 소켓 정보
    const int BUF_LEN = 10000;        // 전송을 위한 크기 설정
    struct sockaddr_in address;        // 소켓 주소
    struct hostent* host;            // 호스트
    int err;                        // 문제 코드 잡기
    float socklib_ver;                // 소켓 DLL 버전
    char File_Buf[BUF_LEN];            // 파일 버퍼
    char DomainName[100];            // 사용자 도메인 이름
    char HostName[100];                // 사용자 호스트 이름
    time_t now;                        // 날짜와 시간

    if (argc < 2)                    // 실행 옵션을 가지고 있는지 확인
    {
            printf("\n사용법 : whois 도메인명 [whois.server] \n");
            exit(0);

    }

    strcpy(DomainName, argv[1]);    // 실행줄에서 도메인 이름 얻기
    strcat(DomainName, "\r\n");        // 서버가 예상하는  Carrage Return , Line Feed 를 넣어 준다.

    if (argc == 3)
            strcpy(HostName, argv[2]);    // 명령줄에서 호스트명을 얻습니다.
    else
            strcpy(HostName, "whois.internic.net");

    wVersionRequested = MAKEWORD(1, 1);

    // 만약 Winsock dll 호출을 해야한다면 WSAStartup 루틴을 불러와야 합니다.

    if( WSAStartup( wVersionRequested, &wsaData ) != 0 )
        handle_error();

    // 소켓 DLL 이 1.1 또는 이상인지 확인 합니다.
    socklib_ver = (float)(HIBYTE( wsaData.wVersion ) / 10.0);
    socklib_ver += LOBYTE( wsaData.wVersion );

    if ( socklib_ver < 1.1 )
    {
        printf("\n오류 : 소켓 라이브러리 버전이 1.1 이상이여야 합니다.\n");
        WSACleanup(); // 나가기 전에 정리
        exit(0);

    }

    // 현재 시간과 날짜를 화면에 기록합니다

    time(&now);
    sprintf(File_Buf, "Whois 세션 시작 %.24s.\n\n", ctime(&now));
    write_file(File_Buf);

/*
    소켓을 엽니다. AF_INET 파라메터는 윈도우즈에게 우리가 인터넷 요구한다는 것을
    알려줍니다. 다른 파라메터는 서로 다른 네트워크가  선택되었을 때를 위함입니다.
    예) NetBIOS, IPX 등. SOCK_STREAM 파라메터는 윈도우즈에게 TCP 를 UDP 보다더 원한다
    는 것을 알려줍니다. 그리고 마지막 파라메터는 항상 0 으로 정해서 윈도우즈에게
    기본적으로 전송할 프로토콜이 어떤건지 알려 줍니다 (예 PPP, IP)

*/

    if( sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ) == INVALID_SOCKET )
        handle_error();

/*
    우리는 이제 주소 구조에 있는 몇몇 변수들을 생성해야 합니다. 다시 한번 윈도우즈에게
    우리는 인터넷을 쓰고 우리가 원격지에 있는 컴퓨터와 접속시 쓸 포트 번호를 말해줍니다.
    이번 경우 43 포트가 쓰이는데 이는 whois 를 위한 표준 포트 입니다. htons 루틴은
    인텔 계열 칩의 메모리 저장 방식을 다른 컴퓨터들과 맞게 하기 위해서 변환하는데 쓰입니다.
    이 표준은 모토로라 형식에 근간합니다.

*/

    address.sin_family = AF_INET;        // 인터넷
    address.sin_port = htons(43);        // whois 를 위한 포트 43

    // 로그 파일과 화면에 기록

    sprintf(File_Buf, "%s 에 접속합니다\n", HostName);
    write_file(File_Buf);

/*
    host 는 hostent 형으로 미리 정의된 구조체의 포인터입니다. 우리는 gethostbyname 에
    DNS 주소를 써서 hostent 구조체의 주소를 받습니다. 이는 우리가 IP 주소를 ISP 네임서버
    에서 받아올 수 있게 하기 위해서 입니다.

*/
    if( (host = gethostbyname(HostName)) == NULL )
        handle_error();

    if( (connect(sock, (struct sockaddr*)&address, sizeof(address)) ) < 0)
            handle_error();

    // 우리는 받은 IP 주소로 주소 구조체를 시작합니다.

    address.sin_addr.s_addr = *((unsigned long*) host->h_addr_list);

    // 이제 우리는 실제 whois 서버 자체로 접속할 준비가 되었습니다.

/*    우리는 이 시점에서 whois 서버에 접속을 해야 합니다.  그리고 domain 이름을 보내고
    응답을 기다립니다. send 와 recv 루틴이 항상 TCP 와 함께 사용됩니다. 이들은 헨드셰이킹
    을 하는데 sendto 와 recvfrom 루틴을 쓰는 UDP 프로토콜(헨드세이킹을 하지 않습니다)
    과 같습니다.
   
*/

    strcpy(File_Buf, DomainName);
    err = send(sock, File_Buf, strlen(File_Buf), 0);    // 도메인 이름을 보냅니다.
    err = recv(sock, File_Buf, BUF_LEN, 0);                // 첫번째 응답을 버립니다.
    err = recv(sock, File_Buf, BUF_LEN, 0);                // 돌아오는 질의의 결과를 받습니다.
    write_file(File_Buf);

    // 항상 나가기 전에 WSACleanup 을 수행합니다

    WSACleanup();        // 나가기 전에 청소

    exit(0);

    return 0;
}


void handle_error(void)
{

/*
    Error 는 WSAGetLastError 루틴을 써서 받아 오는 최근의 오류를 받습니다.
    이 교제 배우면서 우리는 좀더 무엇 때문에 이 오류가 나는지 배우게 될 것입니다

*/

    switch( WSAGetLastError() )
    {
        case WSANOTINITIALISED :
            printf("소켓을 시작 할수가 없습니다. \n");
            break;

        case WSAEAFNOSUPPORT :
            printf("이 주소 계열은 지원하지 않습니다.\n");
            break;

        case WSAEADDRNOTAVAIL :
            printf("이 주소는 로컬 컴퓨터에서 할당 받을수 없습니다.\n");
            break;

        case WSAECONNREFUSED :
            printf("이 시도는 의도적으로 거절당했습니다.\n");
            break;

        case WSAEDESTADDRREQ :
            printf("목적지 주소가 필요합니다.\n");
            break;
           
        case WSAEFAULT :
            printf("namelen 인수가 틀립니다.\n");
            break;

        case WSAEINVAL :
            printf("소켓이 아직 그 주소로 가지(bound) 않았습니다.\n");
            break;

        case WSAEISCONN :
            printf("소켓이 이미 연결 되었습니다.\n");
            break;

        case WSAEADDRINUSE :
            printf("그 주소는 이미 사용 중입니다.\n");
            break;

        case WSAEMFILE :
            printf("더 이상 기술자 파일이 존재 하지 않습니다\n");
            break;

        case WSAENOBUFS :
            printf("더 이상 버퍼 공간이 있지 않습니다. 소켓이 만들어 질수 없습니다.\n");
            break;

        case WSAEPROTONOSUPPORT :
            printf("명시한 프로토콜은 지원하지 않습니다.\n");
            break;

        case WSAEPROTOTYPE :
            printf("명시한 프로토콜은 이 소켓과 맞지 않은 형식입니다.\n");
            break;

        case WSAENETUNREACH :
            printf("지금 시간에는 이 호스트에서 네트워크에 접근 할수가 없습니다.\n");
            break;

        case WSAENOTSOCK :
            printf("기술자가 소켓이 아닙니다.\n");
            break;

        case WSAETIMEDOUT :
            printf("접속이 되지 않은 시도의 시간이 초과되었습니다.\n");
            break;

        case WSAENETDOWN :
            printf("네트워크 하부시스템이 망가졌습니다.\n");
            break;

        case WSAHOST_NOT_FOUND:
            printf("인증 응답 호스트가 발견되지 않았습니다.\n");
            break;

        case WSATRY_AGAIN :
            printf("비-인증 호스트가 없거나 서버가 실패(SERVERFAIL)했습니다.\n");
            break;;

        case WSANO_RECOVERY :
            printf("되돌릴수 없는 에러 입니다. FORMERR, REFUSED, NOTIMP.\n");
            break;
   
        case WSANO_DATA :
            printf("유요한 이름이지만 요구된 형식의 자료가 없습니다.\n");
            break;

        case WSAEINPROGRESS :
            printf("주소 막기 윈도우즈 소켓 작업이 진행 중입니다.\n");
            break;

        case WSAEINTR :
            printf("(막힌) 호출이 WSACancelBlockingCall() 함수에 의해 취소 되었습니다.\n");
            break;

        default :
            printf("알수 없는 오류 입니다.\n");
            break;

    }
            WSACleanup();
            exit(0);

}

void write_file(char *buf)
{
    // 화면과 파일에 동시에 출력합니다.
    FILE *fp = fopen("whoislog.txt", "a+");
    fprintf(fp, "%s\n", buf);
    fclose(fp);
    printf("%s\n",buf);
}