[03주차] 네트워킹 - 1

 

 

 

한국공학대학교 정내훈 교수님 4-1 게임 서버 프로그래밍 수업 중 일부입니다.

 

---

 

 

- 네트워크 프로그래밍 (소켓 프로그래밍)

 : 프로세스들끼리 네트워크를 통해 데이터를 주고 받는 프로그래밍

 : 파일 I/O와 거의 비슷한 양상 → Open, Close, Read, Write

 : 네트워크 I/O → Connect(Accept), Close(CloseSocket0, Recv, Send, 버퍼를 통해 데이터를 주고 받으며, 파일 이름 대신 Socket이라는 단어 사용

 : 차이점은 → 파일 이름 대신 네트워크 주소 사용, 서버의 경우 어느 주소에서 연결 요청 올지 알 수 없는 경우가 多

 : Recv 호출 후 많이 기다리는 경우가 많으며 버퍼가 다 채워지지 않는 경우가 多

 

 

 

- 4계층

 : 인터넷은 4개의 레이어로 구현

 1) Application : 우리가 작성하는 프로그램,

 2) Transport : Application에 데이터를 전달해주는 API → TCP/UDP

 3) Network : 데이터를 목적지까지 안내하는 시스템 → IPv4, IPv6

 4) Data Link : 컴퓨터 사이를 연결하는 물리적 규격 → WiFi, Ethernet ...

 

 

 

- 패킷(Packet)

 : 인터넷 표준에서의 패킷 → 각 레이어에서 다루는 데이터 단위, 각 레이어에 필요한 정보가 추가됨(헤더), 패킷은 독립적.

 : Application에서의 패킷 →  MMO 패킷

 : MMO 패킷 →  종류가 많음, 다음 패킷 예측 불가, 패킷마다의 크기 다름 → 패킷 수신 시 패킷의 종류와 크기 알아야 함. 

 

 

 

- 프로토콜

 : 프로토콜 → 클라이언트와 서버 사이 데이터의 포맷과 순서를 정의

 : 정의 방식

  1) Binary Format : Byte 단위로 값 의미를 정의 → 관리 어려우나 언어, OS, 컴파일러에 영향을 받지 않음

  2) Structure Format :  C의 구조체 정의해서 공유 →관리가 쉬우나, 언어, OS, 컴파일러에 영향을 받음

  3) SDK : 프로토콜 정의와 해석을 도와줌

: 패킷 재 조립 → 인터넷 표준에서의 패킷과 APP에서의 패킷이 같지 않음, 수신 쪽에서 어떻게 패킷을 받았는지 알 수 없어서 재 조립이 필요함

 

 

 

- 소켓 프로그래밍

 : 파일 I/O와 비슷

 : Client → Socket - Connect - Recv/Send - Close

 : Server → Socket - Bind - listen - Accept - Recv/Send - Close

// Client

SOCKET s = socket(AF_INET, SOCK_STREAM, 0); // socket
sockaddr addr;
addr.sin_addr.s_addr = ...;
addr.sin_port = PORT;
connect(s, &addr, ...)   	// connect

...

sent = send(s, buf, size, flags);		// send
r_size = recv(s, buf, max_size, flags);		// recv

...

closesocket(s);			// closesocket




// Server
SOCKET s = socket(AF_INET, SOCK_STREAM, 0);	// socket
sockaddr c_addr;
c_addr.sin_port = PORT;
bind(s, &c_addr);		// bind
listen(s, 3);			// listen
sockaddr n_addr;							
SOCKET c = accept (s, &n_addr);		// accept

...

r_size = recv(c, buf, max_size, flags);		// recv
sent = send(c, buf, size, &sent, flags);	// send

...

closesocket(c);			// closesocket

 

 

 

 

- Windows Socket API

 : 고성능 네트워크 I/O를 위해서는 전용 API 필요 → WSASocket(), WSAConnect(), WSAAccept(), WSASend(), WSARecv()

 

// SOCKADDR 주소 구조체
// 네트워크 주소를 저장
// IP주소 + PORT 번호(IP 주소ㅠ-> 컴퓨터, PORT 번호 -> 프로세스)


// 선언
struct sockaddr addr;

addr.sin_family = AF_INET;
addr.sin_port = htons(SERVER_PORT);
inet_pton(AF_INET, SERVER_IP, &addr.sin_addr);
// SEVER_PORT는 short, SERVER_IP는 문자열

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

// WSABUF(gather/scatter I/O) :흩어진 데이터를 관리하는 구조
// − 데이터 복사(성능 저하 주범) 감소

typedef struct __WSABUF
{ 
 	u_long len; 
 	char FAR *buf; 
} WSABUF, *LPWSAVUF;


// WSABUF를 사용한 최적화

// Move_p, Attack_p, Chat_p -> 3개의 패킷을 보내야 한다

// 1. 기존 내가 아는 방식
// 여러 번의 시스템 호출이 필요하므로 오버헤드 발생
Send(s, &move_p. sizeof(move_p));
Send(s, &attack_p. sizeof(attack_p));
Send(s, &chat_p. sizeof(chat_p));


// 2
// 메모리 추가사용 및 메모리 복제-> 오버헤드
Char buf[1024]; int pos = 0;
Memcpy(buf, &move_p, sizeof(move_p)); pos+=sizeof(move_p);
Memcpy(buf + pos, &attack_p, sizeof(attack_p)); pos+=sizeof(attack_p);
Memcpy(buf + pos, &chat_p, sizeof(chat_p)); pos+=sizeof (chat_p);
Send(s, buf, pos);


// 3
WSABUF buf[3];
Buf[0].buf = &move_p;     buf[0].len = sizeof(move_p);
Buf[0].buf = &attack_p;   buf[0].len = sizeof(attack_p);
Buf[0].buf = &chat_p;     buf[0].len = sizeof(chat_p);
WSASend(s, buf, 3);

#include <iostream>
#include <WS2tcpip.h>   // header

// 1. Socket 만들기

SOCKET WSASocket(int af, int type, int protocol,
	LPWSAPROTOCOL_INFO lpProtocolInfo, GROUP g, DWORO dwFlags)
    
// af : address family -> AF_INET 사용
// type : socket type -> SOCK_STREAM(TCP)
// protocol : 사용할 프로토콜 종류 (IPPROTO_TCP/IPPROTO_UDP)
// lpProtocolInfo : protocol infomation (NULL)
// g : 예약
// dwFlags : 소켓 속성 (보통 0 or WSA_PROTOCOL_OVERLAPPED)



// 2. Socket 연결
// 대기하고 있는 상대 소켓에 자신의 소켓 연결

int WSAConnect(SOCKET s, const struct sockaddr* name,
	int namelen, LPWSABUF lpCallerData, LPWSABUF lpCalleeData,
    LPQOS lpSQOS, LPQOS lpGQOS)
    
// s : 소켓
// name, namelen : 상대 소켓 주소와 주소 길이 -> 보통 sockaddr_in 구조체 사용
// lpCallerData : 연결 요청 시에 전송할 데이터의 버퍼를 가리키는 포인터 -> 보통 sizeof(struct sockaddr)
// lpCalleeData : 연결 요청에 대한 응답으로 받은 데이터를 저장할 버퍼를 가리키는 포인터
// lpSQOS, lpGQOS : 품질 서비스(Quality of Service, QoS) 요구 사항 지정 포인터



// 3. Socket에서 데이터 받기

int WSARecv(SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, 
	LPDWORD lpNumberofBytesRecvd, LPDWORD lpFlags,
    LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
    
// s : 소켓
// lpBuffers : 받은 데이터를 저장할 버퍼
// dwBufferCount : 버퍼 개수
// lpFlags : 동작 옵션 (MSG_PEEK, MSG_OOB)
// - MSG_PEEK : 데이터를 수신할 때, 버퍼에서 데이터를 제거하지 않고 데이터를 확인 가능, 데이터가 버퍼에서 제거X
// - MSG_OOB : 긴급(out-of-band) 데이터를 소켓으로부터 읽거나 전송
// lpNumberofBytesRecvd : 받은 데이터 크기
// lpOverlapped, lpCompletionRoutine : 뒤에 설명



// 4. Socket 끊기

int closesocket(SOCKET s)

// s : 소켓
// return value : 0 (success)



// 5. PORT 묶기
// 포트를 선점해 다른 프로그램이 사용하지 못하도록 함

int bind(SOCKET s, const struct sockaddr* name, int namelen)

// s : 소켓
// name, namelen :  상대 소켓 주소와 주소 길이
//  - INADDR_ANY : 전체 주소로부터 접속 허용
//  - info.sin_affr.S_in.S_addr = htonl(INADDR_ANY)
//  - htonl : 호스트 바이트 순서를 네트워크 바이트 순서로 변환



// 6. Socket 접속 대기
// 소켓 접속을 받을 수 있는 상태

int listen(SOCKET s, int backlog)

// s : 소켓
// backlog : 접속 대기 큐의 최대 연결 가능 숫자 
//  - 서버에 도착 후 accept될 때까지 기다리고 있는 소켓 연결의 최대 수
//  - 싱글 스레드 프로그램에서는 5정도가 적당, 대용량 서버는 20-200 or SOMAXCONN



// 7. 연결 Socket 생성
// 연결된 소켓을 만듦

SOCKET WSAAccept(SOCKET s, struct sockaddr* name, LPINT addrlen,
				LPCONDITIONPROC lpfnCondition, DWORD dwCallbackData)

// s : listen을 하고 있는 소켓
// name, addrlen : 연결된 상대 소켓 주소
// lpfnCondition : 연결 거절을 판단하는 함수 (NULL)
// dwCallbackData : lpfnCondition에 들어갈 값
// Return value : 데이터 전송용 소켓



// 디버깅 tip
void error_display(const char *msg, int err_no )
{
	WCHAR *lpMsgBuf;
	FormatMessage(
		FORMAT_MESSAGE_ALLOCATE_BUFFER |
		FORMAT_MESSAGE_FROM_SYSTEM,
		NULL, err_no,
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		(LPTSTR)&lpMsgBuf, 0, NULL );
	std::cout << msg;
	std::wcout << L" 에러 " << lpMsgBuf << std::endl;
	while(true); // 디버깅
	LocalFree(lpMsgBuf);
}

// + 한글
std::wcout.imbue(std::locale("korean"));

 

 

 

- 간단한 실습 (Echo 1대1)

// Client

#include <iostream>
#include <WS2tcpip.h>

#pragma comment (lib, "WS2_32.LIB")

constexpr short PORT = 4000;
constexpr char SERVER_ADDR[] = "127.0.0.1";
constexpr int BUFSIZE = 256;

int main()
{
	std::wcout.imbue(std::locale("korean"));

	WSADATA WSAData;
	WSAStartup(MAKEWORD(2, 2), &WSAData);

	SOCKET server_s = WSASocket(AF_INET, SOCK_STREAM,
		IPPROTO_TCP, nullptr, 0, 0);

	SOCKADDR_IN server_a;
	server_a.sin_family = AF_INET;
	server_a.sin_port = htons(PORT);
	inet_pton(AF_INET, SERVER_ADDR, &server_a.sin_addr);

	connect(server_s, reinterpret_cast<sockaddr*>(&server_a), sizeof(server_a));

	// reinterpret_cast<type_id>(expression);
	//  type_id: 바꿀 타입 / expression : 대상
	// 포인터 -> 포인터, 포인터 -> 일반 변수, 일반 변수 -> 포인터, 자료형 -> 다른 자료형

	// connect 함수는 sockaddr 구조체를 요구하므로,
	// reinterpret_cast를 사용하여 server_a를 sockaddr* 타입으로 변환

	while (true) {
		char buf[BUFSIZE];
		std::cout << "Enter Message : ";
		std::cin.getline(buf, BUFSIZE);     // enter기준 getline

		WSABUF wsabuf[1];
		wsabuf[0].buf = buf;
		wsabuf[0].len = static_cast<int>(strlen(buf)) + 1;

		if (wsabuf[0].len == 0)
			break;

		DWORD sent_size;
		WSASend(server_s, wsabuf, 1, &sent_size, 0, nullptr, nullptr);

		wsabuf[0].len = BUFSIZE;  // 얼마나 올지 모르니 최대 사이즈
		DWORD recv_size;
		DWORD recv_flag = 0; // 초기화 필수
		WSARecv(server_s, wsabuf, 1, &recv_size, &recv_flag, nullptr, nullptr);

		for (DWORD i = 0; i < recv_size; ++i)
			std::cout << buf[i];

		std::cout << std::endl;
	}
	closesocket(server_s);
	WSACleanup();
}



// Server
#include <iostream>
#include <WS2tcpip.h>

#pragma comment (lib, "WS2_32.LIB")

constexpr short PORT = 4000;
constexpr int BUFSIZE = 256;

void print_error(const char* msg, int err_no)
{
	// 출력 메세지를 저장할 buf
	WCHAR* msg_buf;
	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
		NULL, err_no, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<LPWSTR>(&msg_buf), 0, NULL);
	std::cout << msg;
	std::wcout << L" : 에러 : " << msg_buf;
	while (true);   // 디버깅
	LocalFree(msg_buf);
}

int main()
{
	WSADATA WSAData;
	WSAStartup(MAKEWORD(2, 2), &WSAData);
	SOCKET server_s = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, nullptr, 0, 0);
	SOCKADDR_IN server_a;
	server_a.sin_family = AF_INET;
	server_a.sin_port = htons(PORT);
	server_a.sin_addr.S_un.S_addr = htons(INADDR_ANY);

	bind(server_s, reinterpret_cast<sockaddr*>(&server_a), sizeof(server_a));
	listen(server_s, SOMAXCONN);

	int addr_size = sizeof(server_a);
	SOCKET client_s = WSAAccept(server_s, reinterpret_cast<sockaddr*>(&server_a), &addr_size, nullptr, 0);
	std::cout << "성공 : " << server_a.sin_port << std::endl;

	while (true) {
		char buf[BUFSIZE];

		WSABUF wsabuf[1];
		wsabuf[0].buf = buf;
		wsabuf[0].len = BUFSIZE; // 서버로부터 얼마 올지 모르니 최대 사이즈
		DWORD recv_size;
		DWORD recv_flag = 0; //초기화 안하면 이상하게 받으려 함
		int res = WSARecv(client_s, wsabuf, 1, &recv_size, &recv_flag, nullptr, nullptr);

		if (res != 0) {
			print_error("WSARecv", WSAGetLastError());
		}

		if (recv_size == 1)
			break;

		std::cout << "Client Sent : ";
		for (DWORD i = 0; i < recv_size; ++i)
			std::cout << buf[i];

		std::cout << std::endl;

		wsabuf[0].len = recv_size;

		DWORD sent_size;
		WSASend(client_s, wsabuf, 1, &sent_size, 0, nullptr, nullptr);
	}

	closesocket(server_s);
	closesocket(client_s);
	WSACleanup();

}