int main()
{
int retval;
int iPort = 19001;
WSADATA wsa;
if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
return -1;
SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock == INVALID_SOCKET) err_display("socket()");
BOOL bEnable = TRUE;
retval = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&bEnable, sizeof(bEnable));
if (retval == SOCKET_ERROR) err_display("setsockopt()");
SOCKADDR_IN sockaddr;
memset(&sockaddr, 0, sizeof(sockaddr));
sockaddr.sin_family = AF_INET;
sockaddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
char cDatagram[10] = { 0xff, 0xee, 0xdd, 0xaa, 0x00, 0x99, 0x77, 0x55, 0x33, 0x11 };
char buf[100];
while (1)
{
if (iPort > 19100) iPort = 19001;
sockaddr.sin_port = htons(iPort);
retval = sendto(sock, cDatagram, sizeof(cDatagram), 0, (SOCKADDR *)&sockaddr,
sizeof(sockaddr));
FD_SET ReadSet;
FD_ZERO(&ReadSet);
FD_SET(sock, &ReadSet);
TIMEVAL Timeval;
Timeval.tv_sec = 0;
Timeval.tv_usec = 2000;
retval = select(0, &ReadSet, NULL, NULL, &Timeval);
if (retval < 0) err_display("select()");
else if (retval > 0)
{
if (FD_ISSET(sock, &ReadSet))
{
int addrlen = sizeof(sockaddr);
retval = recvfrom(sock, buf, sizeof(buf), 0, (SOCKADDR *)&sockaddr,
&addrlen);
if (retval == SOCKET_ERROR) err_display("recvfrom()");
printf("%s\n", buf);
}
}
iPort++;
}
}
void recvthread(void* p)
{
SOCKET sock = (SOCKET)p;
int retval;
// 데이터 통신에 사용할 변수
SOCKADDR_IN peeraddr;
int addrlen;
char* buf = (char*)malloc(g_size);
// 멀티캐스트 데이터 받기
while(1)
{
// 데이터 받기
addrlen = sizeof(peeraddr);
retval = recvfrom(sock, buf, g_size, 0,
(SOCKADDR*)&peeraddr, &addrlen);
if(retval == SOCKET_ERROR)
{
err_display("recvfrom");
continue;
}
#ifndef MY_DEBUG
printf("%dbyte recv\n", retval);
#endif
g_recvfun(buf, g_size);
}
closesocket(sock);
}
void mysock_senddata(char* data, int length)
{
// 소켓 주소 구조체 초기화
SOCKADDR_IN remoteaddr;
int retval;
ZeroMemory(&remoteaddr, sizeof(remoteaddr));
remoteaddr.sin_family = AF_INET;
remoteaddr.sin_port = htons(g_port);
//-------------------------------------------------------
remoteaddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
//-------------------------------------------------------
// 데이터 보내기
retval = sendto(g_sendsock, data, length, 0,
(SOCKADDR*)&remoteaddr, sizeof(remoteaddr));
if( retval == SOCKET_ERROR)
{
err_display("sendto");
}
#ifndef MY_DEBUG
printf("%dbyte send\n", retval);
#endif
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// socket()
SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if(listen_sock == INVALID_SOCKET) err_quit("socket()");
// bind()
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
serveraddr.sin_port = htons(SERVERPORT);
retval = bind(listen_sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("bind()");
// listen()
retval = listen(listen_sock, SOMAXCONN);
if(retval == SOCKET_ERROR) err_quit("listen()");
// 데이터 통신에 사용할 변수
SOCKET client_sock;
SOCKADDR_IN clientaddr;
int addrlen;
HANDLE hThread;
while(1){
// accept()
addrlen = sizeof(clientaddr);
client_sock = accept(listen_sock, (SOCKADDR *)&clientaddr, &addrlen);
if(client_sock == INVALID_SOCKET){
err_display("accept()");
break;
}
// 접속한 클라이언트 정보 출력
printf("\n[TCP 서버] 클라이언트 접속: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
// 스레드 생성
hThread = CreateThread(NULL, 0, ProcessClient,
(LPVOID)client_sock, 0, NULL);
if(hThread == NULL) { closesocket(client_sock); }
else { CloseHandle(hThread); }
}
// closesocket()
closesocket(listen_sock);
// 윈속 종료
WSACleanup();
return 0;
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// connect() 호출에 사용할 변수
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = inet_addr(SERVERIP);
serveraddr.sin_port = htons(SERVERPORT);
// 데이터 통신에 사용할 변수
char buf[BUFSIZE];
char *testdata[] = {
"안녕하세요",
"반가워요",
"오늘따라 할 이야기가 많을 것 같네요",
"저도 그렇네요",
};
int len;
// 서버와 데이터 통신
for(int i=0; i<4; i++){
// socket()
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock == INVALID_SOCKET) err_quit("socket()");
// connect()
retval = connect(sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("connect()");
// 데이터 입력(시뮬레이션)
len = strlen(testdata[i]);
strncpy(buf, testdata[i], len);
// 데이터 보내기
retval = send(sock, buf, len, 0);
if(retval == SOCKET_ERROR){
err_display("send()");
break;
}
printf("[TCP 클라이언트] %d바이트를 보냈습니다.\n", retval);
// closesocket()
closesocket(sock);
}
// 윈속 종료
WSACleanup();
return 0;
}
// 클라이언트와 데이터 통신
DWORD WINAPI ProcessClient(LPVOID arg)
{
SOCKET client_sock = (SOCKET)arg;
int retval;
SOCKADDR_IN clientaddr;
int addrlen;
char buf[BUFSIZE+1];
// 클라이언트 정보 얻기
addrlen = sizeof(clientaddr);
getpeername(client_sock, (SOCKADDR *)&clientaddr, &addrlen);
while(1){
// 데이터 받기
retval = recv(client_sock, buf, BUFSIZE, 0);
if(retval == SOCKET_ERROR){
err_display("recv()");
break;
}
else if(retval == 0)
break;
// 받은 데이터 출력
buf[retval] = '\0';
printf("[TCP/%s:%d] %s\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port), buf);
// 데이터 보내기
retval = send(client_sock, buf, retval, 0);
if(retval == SOCKET_ERROR){
err_display("send()");
break;
}
}
// closesocket()
closesocket(client_sock);
printf("[TCP 서버] 클라이언트 종료: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
return 0;
}
DWORD WINAPI send_data(LPVOID arg) {
int retval;
char buf[BUFSIZE + 1];
while (1) {
ZeroMemory(buf, BUFSIZE);
gotoxy(1, 500);
fgets(buf, BUFSIZE, stdin);
if (strcmp(buf, ":exit\n") == 0) {
retval = send(sock, buf, BUFSIZE, 0);
rflag = 1;
return 0;
}
retval = send(sock, buf, BUFSIZE, 0);
if (retval == SOCKET_ERROR) err_display("send()");
}
return 0;
}
void Network::Run(void) {
while (true) {
// accept connection
SOCKADDR_IN saRemote;
int remoteLen = sizeof(saRemote);
SOCKET Accepted = m_ListenSocket.Accept(&saRemote, &remoteLen);
// LPPER_HANDLE_DATA perHandleData = MakeClientSession(Accepted, saRemote, remoteLen);
OverlappedIO* handleData = MakeClientSessionEx(Accepted, saRemote, remoteLen);
m_Iocp.BindSocket((HANDLE)(Accepted), static_cast<DWORD>(Accepted));
printf("[TCP 서버] 클라이언트 접속: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(saRemote.sin_addr), ntohs(saRemote.sin_port));
printf("Socket number %d connected\n", Accepted);
if (handleData->GetClientObject()->RecvAsync() != 0) {
err_display("RecvAsync() Error at main thread");
}
}
}
DWORD WINAPI receive_data(LPVOID arg) {
//receive data.
char buf[BUFSIZE + 1];
int retval;
while (1) {
if (rflag == 1) return 0;
retval = recv(sock, buf, BUFSIZE, 0);
if (retval == SOCKET_ERROR) {
err_display("recv()");
} else if (retval == 0) {
return 0;
}
//print rcv data.
buf[retval] = '\0';
printf("[Receive Message] :: > %s", buf);
}
return 0;
}
void Server::accept_set(){//accept���� Ŭ���̾�Ʈ ���� ���� �°� ���� ���Ϳ� ����
while (1){
// accept()
Socket_Cli SC;
SC.addrlen = sizeof(SC.get_sockaddr());
SC.set_sock(accept(server_sock, (SOCKADDR *)&(SC.get_sockaddr()), &SC.addrlen));
if (server_sock == INVALID_SOCKET){
err_display("accept()");
break;
}
// ������ Ŭ���̾�Ʈ ���� ���
/* printf("\n[TCP ����] Ŭ���̾�Ʈ ����: IP �ּ�=%s, ��Ʈ ��ȣ=%d\n",
inet_ntoa(SC.get_sockaddr().sin_addr), ntohs(SC.get_sockaddr().sin_port));*/
// ������ ����, ��¥�� ��� Ŭ�� ������ ����ϴ� Ư�� ��Ĺ�� ���ڷ� ���� �ʿ䰡�����Ű��ٴ� ���Ǵ��� �߸����.. �����ʹ� �ƾ���
hThread = CreateThread(NULL, 0, ProcessClient, (LPVOID)SC.get_sock(), 0, NULL);
if (hThread == NULL) { closesocket(server_sock); }
else { CloseHandle(hThread); }
}
}
// 비동기 입출력 처리 함수
DWORD WINAPI WorkerThread(LPVOID arg)
{
int retval;
while(1){
// 이벤트 객체 관찰
DWORD index = WSAWaitForMultipleEvents(nTotalSockets,
EventArray, FALSE, WSA_INFINITE, FALSE);
if(index == WSA_WAIT_FAILED) continue;
index -= WSA_WAIT_EVENT_0;
WSAResetEvent(EventArray[index]);
if(index == 0) continue;
// 클라이언트 정보 얻기
SOCKETINFO *ptr = SocketInfoArray[index];
SOCKADDR_IN clientaddr;
int addrlen = sizeof(clientaddr);
getpeername(ptr->sock, (SOCKADDR *)&clientaddr, &addrlen);
// 비동기 입출력 결과 확인
DWORD cbTransferred, flags;
retval = WSAGetOverlappedResult(ptr->sock, &ptr->overlapped,
&cbTransferred, FALSE, &flags);
if(retval == FALSE || cbTransferred == 0){
RemoveSocketInfo(index);
printf("[TCP 서버] 클라이언트 종료: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
continue;
}
// 데이터 전송량 갱신
if(ptr->recvbytes == 0){
ptr->recvbytes = cbTransferred;
ptr->sendbytes = 0;
// 받은 데이터 출력
ptr->buf[ptr->recvbytes] = '\0';
printf("[TCP/%s:%d] %s\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port), ptr->buf);
}
else{
ptr->sendbytes += cbTransferred;
}
if(ptr->recvbytes > ptr->sendbytes){
// 데이터 보내기
ZeroMemory(&ptr->overlapped, sizeof(ptr->overlapped));
ptr->overlapped.hEvent = EventArray[index];
ptr->wsabuf.buf = ptr->buf + ptr->sendbytes;
ptr->wsabuf.len = ptr->recvbytes - ptr->sendbytes;
DWORD sendbytes;
retval = WSASend(ptr->sock, &ptr->wsabuf, 1, &sendbytes,
0, &ptr->overlapped, NULL);
if(retval == SOCKET_ERROR){
if(WSAGetLastError() != WSA_IO_PENDING){
err_display("WSASend()");
}
continue;
}
}
else{
ptr->recvbytes = 0;
// 데이터 받기
ZeroMemory(&ptr->overlapped, sizeof(ptr->overlapped));
ptr->overlapped.hEvent = EventArray[index];
ptr->wsabuf.buf = ptr->buf;
ptr->wsabuf.len = BUFSIZE;
DWORD recvbytes;
flags = 0;
retval = WSARecv(ptr->sock, &ptr->wsabuf, 1, &recvbytes,
&flags, &ptr->overlapped, NULL);
if(retval == SOCKET_ERROR){
if(WSAGetLastError() != WSA_IO_PENDING){
err_display("WSARecv()");
}
continue;
}
}
}
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// socket()
SOCKET listen_sock = socket(AF_INET6, SOCK_STREAM, 0);
if(listen_sock == INVALID_SOCKET) err_quit("socket()");
// bind()
SOCKADDR_IN6 serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin6_family = AF_INET6;
serveraddr.sin6_addr = in6addr_any;
serveraddr.sin6_port = htons(SERVERPORT);
retval = bind(listen_sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("bind()");
// listen()
retval = listen(listen_sock, SOMAXCONN);
if(retval == SOCKET_ERROR) err_quit("listen()");
// 데이터 통신에 사용할 변수
SOCKET client_sock;
SOCKADDR_IN6 clientaddr;
int addrlen;
char buf[BUFSIZE+1];
while(1){
// accept()
addrlen = sizeof(clientaddr);
client_sock = accept(listen_sock, (SOCKADDR *)&clientaddr, &addrlen);
if(client_sock == INVALID_SOCKET){
err_display("accept()");
break;
}
// 접속한 클라이언트 정보 출력
char ipaddr[50];
DWORD ipaddrlen = sizeof(ipaddr);
WSAAddressToString((SOCKADDR *)&clientaddr, sizeof(clientaddr),
NULL, ipaddr, &ipaddrlen);
printf("\n[TCP 서버] 클라이언트 접속: %s\n", ipaddr);
// 클라이언트와 데이터 통신
while(1){
// 데이터 받기
retval = recv(client_sock, buf, BUFSIZE, 0);
if(retval == SOCKET_ERROR){
err_display("recv()");
break;
}
else if(retval == 0)
break;
// 받은 데이터 출력
buf[retval] = '\0';
printf("[TCP/%s] %s\n", ipaddr, buf);
// 데이터 보내기
retval = send(client_sock, buf, retval, 0);
if(retval == SOCKET_ERROR){
err_display("send()");
break;
}
}
// closesocket()
closesocket(client_sock);
printf("[TCP 서버] 클라이언트 종료: %s\n", ipaddr);
}
// closesocket()
closesocket(listen_sock);
// 윈속 종료
WSACleanup();
return 0;
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// socket()
SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if(listen_sock == INVALID_SOCKET) err_quit("socket()");
// bind()
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
serveraddr.sin_port = htons(SERVERPORT);
retval = bind(listen_sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("bind()");
// listen()
retval = listen(listen_sock, SOMAXCONN);
if(retval == SOCKET_ERROR) err_quit("listen()");
// 넌블로킹 소켓으로 전환
u_long on = 1;
retval = ioctlsocket(listen_sock, FIONBIO, &on);
if(retval == SOCKET_ERROR) err_display("ioctlsocket()");
// 데이터 통신에 사용할 변수
FD_SET rset, wset;
SOCKET client_sock;
SOCKADDR_IN clientaddr;
int addrlen, i;
while(1){
// 소켓 셋 초기화
FD_ZERO(&rset);
FD_ZERO(&wset);
FD_SET(listen_sock, &rset);
for(i=0; i<nTotalSockets; i++){
if(SocketInfoArray[i]->recvbytes > SocketInfoArray[i]->sendbytes)
FD_SET(SocketInfoArray[i]->sock, &wset);
else
FD_SET(SocketInfoArray[i]->sock, &rset);
}
// select()
retval = select(0, &rset, &wset, NULL, NULL);
if(retval == SOCKET_ERROR) err_quit("select()");
// 소켓 셋 검사(1): 클라이언트 접속 수용
if(FD_ISSET(listen_sock, &rset)){
addrlen = sizeof(clientaddr);
client_sock = accept(listen_sock, (SOCKADDR *)&clientaddr, &addrlen);
if(client_sock == INVALID_SOCKET){
err_display("accept()");
}
else{
printf("\n[TCP 서버] 클라이언트 접속: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
// 소켓 정보 추가
AddSocketInfo(client_sock);
}
}
// 소켓 셋 검사(2): 데이터 통신
for(i=0; i<nTotalSockets; i++){
SOCKETINFO *ptr = SocketInfoArray[i];
if(FD_ISSET(ptr->sock, &rset)){
// 데이터 받기
retval = recv(ptr->sock, ptr->buf, BUFSIZE, 0);
if(retval == SOCKET_ERROR){
err_display("recv()");
RemoveSocketInfo(i);
continue;
}
else if(retval == 0){
RemoveSocketInfo(i);
continue;
}
ptr->recvbytes = retval;
// 받은 데이터 출력
addrlen = sizeof(clientaddr);
getpeername(ptr->sock, (SOCKADDR *)&clientaddr, &addrlen);
ptr->buf[retval] = '\0';
printf("[TCP/%s:%d] %s\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port), ptr->buf);
}
if(FD_ISSET(ptr->sock, &wset)){
// 데이터 보내기
retval = send(ptr->sock, ptr->buf + ptr->sendbytes,
ptr->recvbytes - ptr->sendbytes, 0);
if(retval == SOCKET_ERROR){
err_display("send()");
RemoveSocketInfo(i);
continue;
}
ptr->sendbytes += retval;
if(ptr->recvbytes == ptr->sendbytes){
ptr->recvbytes = ptr->sendbytes = 0;
}
}
}
}
// 윈속 종료
WSACleanup();
return 0;
}
// 작업자 스레드 함수
DWORD WINAPI WorkerThread(LPVOID arg)
{
int retval;
HANDLE hcp = (HANDLE)arg;
while(1){
// 비동기 입출력 완료 기다리기
DWORD cbTransferred;
SOCKET client_sock;
SOCKETINFO *ptr;
retval = GetQueuedCompletionStatus(hcp, &cbTransferred,
(LPDWORD)&client_sock, (LPOVERLAPPED *)&ptr, INFINITE);
// 클라이언트 정보 얻기
SOCKADDR_IN clientaddr;
int addrlen = sizeof(clientaddr);
getpeername(ptr->sock, (SOCKADDR *)&clientaddr, &addrlen);
// 비동기 입출력 결과 확인
if(retval == 0 || cbTransferred == 0){
if(retval == 0){
DWORD temp1, temp2;
WSAGetOverlappedResult(ptr->sock, &ptr->overlapped,
&temp1, FALSE, &temp2);
err_display("WSAGetOverlappedResult()");
}
closesocket(ptr->sock);
printf("[TCP 서버] 클라이언트 종료: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
delete ptr;
continue;
}
// 데이터 전송량 갱신
if(ptr->recvbytes == 0){
ptr->recvbytes = cbTransferred;
ptr->sendbytes = 0;
// 받은 데이터 출력
ptr->buf[ptr->recvbytes] = '\0';
printf("[TCP/%s:%d] %s\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port), ptr->buf);
}
else{
ptr->sendbytes += cbTransferred;
}
if(ptr->recvbytes > ptr->sendbytes){
// 데이터 보내기
ZeroMemory(&ptr->overlapped, sizeof(ptr->overlapped));
ptr->wsabuf.buf = ptr->buf + ptr->sendbytes;
ptr->wsabuf.len = ptr->recvbytes - ptr->sendbytes;
DWORD sendbytes;
retval = WSASend(ptr->sock, &ptr->wsabuf, 1,
&sendbytes, 0, &ptr->overlapped, NULL);
if(retval == SOCKET_ERROR){
if(WSAGetLastError() != WSA_IO_PENDING){
err_display("WSASend()");
}
continue;
}
}
else{
ptr->recvbytes = 0;
// 데이터 받기
ZeroMemory(&ptr->overlapped, sizeof(ptr->overlapped));
ptr->wsabuf.buf = ptr->buf;
ptr->wsabuf.len = BUFSIZE;
DWORD recvbytes;
DWORD flags = 0;
retval = WSARecv(ptr->sock, &ptr->wsabuf, 1,
&recvbytes, &flags, &ptr->overlapped, NULL);
if(retval == SOCKET_ERROR){
if(WSAGetLastError() != WSA_IO_PENDING){
err_display("WSARecv()");
}
continue;
}
}
}
return 0;
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0) return 1;
// 입출력 완료 포트 생성
HANDLE hcp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
if(hcp == NULL) return 1;
// CPU 개수 확인
SYSTEM_INFO si;
GetSystemInfo(&si);
// (CPU 개수 * 2)개의 작업자 스레드 생성
HANDLE hThread;
for(int i=0; i<(int)si.dwNumberOfProcessors*2; i++){
hThread = CreateThread(NULL, 0, WorkerThread, hcp, 0, NULL);
if(hThread == NULL) return 1;
CloseHandle(hThread);
}
// socket()
SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if(listen_sock == INVALID_SOCKET) err_quit("socket()");
// bind()
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
serveraddr.sin_port = htons(SERVERPORT);
retval = bind(listen_sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("bind()");
// listen()
retval = listen(listen_sock, SOMAXCONN);
if(retval == SOCKET_ERROR) err_quit("listen()");
// 데이터 통신에 사용할 변수
SOCKET client_sock;
SOCKADDR_IN clientaddr;
int addrlen;
DWORD recvbytes, flags;
while(1){
// accept()
addrlen = sizeof(clientaddr);
client_sock = accept(listen_sock, (SOCKADDR *)&clientaddr, &addrlen);
if(client_sock == INVALID_SOCKET){
err_display("accept()");
break;
}
printf("[TCP 서버] 클라이언트 접속: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
// 소켓과 입출력 완료 포트 연결
CreateIoCompletionPort((HANDLE)client_sock, hcp, client_sock, 0);
// 소켓 정보 구조체 할당
SOCKETINFO *ptr = new SOCKETINFO;
if(ptr == NULL) break;
ZeroMemory(&ptr->overlapped, sizeof(ptr->overlapped));
ptr->sock = client_sock;
ptr->recvbytes = ptr->sendbytes = 0;
ptr->wsabuf.buf = ptr->buf;
ptr->wsabuf.len = BUFSIZE;
// 비동기 입출력 시작
flags = 0;
retval = WSARecv(client_sock, &ptr->wsabuf, 1, &recvbytes,
&flags, &ptr->overlapped, NULL);
if(retval == SOCKET_ERROR){
if(WSAGetLastError() != ERROR_IO_PENDING){
err_display("WSARecv()");
}
continue;
}
}
// 윈속 종료
WSACleanup();
return 0;
}
int main(int argc, char* argv[])
{
int retval;
if(argc < 2){
fprintf(stderr, "Usage: %s <FileName>\n", argv[0]);
return -1;
}
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return -1;
// socket()
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock == INVALID_SOCKET) err_quit("socket()");
// connect()
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(9000);
serveraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
retval = connect(sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("connect()");
// 파일 열기
FILE *fp = fopen(argv[1], "rb");
if(fp == NULL){ perror("파일 입출력 오류"); return -1; }
// 1. 파일 이름 보내기
char filename[256];
ZeroMemory(filename, 256);
sprintf(filename, argv[1]);
retval = send(sock, filename, 256, 0);
if(retval == SOCKET_ERROR) err_quit("send()");
// 2. 파일 크기 얻기
fseek(fp, 0, SEEK_END);
int totalbytes = ftell(fp);
// 파일 크기 보내기
retval = send(sock, (char *)&totalbytes, sizeof(totalbytes), 0);
if(retval == SOCKET_ERROR) err_quit("send()");
// 3. 파일 데이터 전송에 사용할 변수
char buf[BUFSIZE]; //4096byte
int numread;
int numtotal = 0;
// 파일 데이터 보내기
rewind(fp); // 파일 포인터를 제일 앞으로 이동
while(1){
numread = fread(buf, 1, BUFSIZE, fp);
if(numread > 0){
retval = send(sock, buf, numread, 0);
if(retval == SOCKET_ERROR){
err_display("send()"); break;
}
numtotal += numread;
}
else if(numread == 0 && numtotal == totalbytes){
printf("파일 전송 완료!: %d 바이트\n", numtotal); break;
}
else{
perror("파일 입출력 오류"); break;
}
}
fclose(fp);
// closesocket()
closesocket(sock);
// 윈속 종료
WSACleanup();
return 0;
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// socket()
SOCKET sock = socket(AF_INET6, SOCK_DGRAM, 0);
if(sock == INVALID_SOCKET) err_quit("socket()");
// SO_REUSEADDR 옵션 설정
BOOL optval = TRUE;
retval = setsockopt(sock, SOL_SOCKET,
SO_REUSEADDR, (char *)&optval, sizeof(optval));
if(retval == SOCKET_ERROR) err_quit("setsockopt()");
// bind()
SOCKADDR_IN6 localaddr;
ZeroMemory(&localaddr, sizeof(localaddr));
localaddr.sin6_family = AF_INET6;
localaddr.sin6_addr = in6addr_any;
localaddr.sin6_port = htons(LOCALPORT);
retval = bind(sock, (SOCKADDR *)&localaddr, sizeof(localaddr));
if(retval == SOCKET_ERROR) err_quit("bind()");
// 주소 변환(문자열 -> IPv6)
SOCKADDR_IN6 tmpaddr;
int addrlen = sizeof(tmpaddr);
WSAStringToAddress(MULTICASTIP, AF_INET6, NULL,
(SOCKADDR *)&tmpaddr, &addrlen);
// 멀티캐스트 그룹 가입
struct ipv6_mreq mreq;
mreq.ipv6mr_multiaddr = tmpaddr.sin6_addr;
mreq.ipv6mr_interface = 0;
retval = setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP,
(char *)&mreq, sizeof(mreq));
if(retval == SOCKET_ERROR) err_quit("setsockopt()");
// 데이터 통신에 사용할 변수
SOCKADDR_IN6 peeraddr;
char buf[BUFSIZE+1];
// 멀티캐스트 데이터 받기
while(1){
// 데이터 받기
addrlen = sizeof(peeraddr);
retval = recvfrom(sock, buf, BUFSIZE, 0,
(SOCKADDR *)&peeraddr, &addrlen);
if(retval == SOCKET_ERROR){
err_display("recvfrom()");
continue;
}
// 주소 변환(IPv6 -> 문자열)
char ipaddr[50];
DWORD ipaddrlen = sizeof(ipaddr);
WSAAddressToString((SOCKADDR *)&peeraddr, sizeof(peeraddr),
NULL, ipaddr, &ipaddrlen);
// 받은 데이터 출력
buf[retval] = '\0';
printf("[UDP/%s] %s\n", ipaddr, buf);
}
// 멀티캐스트 그룹 탈퇴
retval = setsockopt(sock, IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP,
(char *)&mreq, sizeof(mreq));
if(retval == SOCKET_ERROR) err_quit("setsockopt()");
// closesocket()
closesocket(sock);
// 윈속 종료
WSACleanup();
return 0;
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// socket()
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock == INVALID_SOCKET) err_quit("socket()");
// connect()
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
//serveraddr.sin_addr.s_addr = inet_addr(SERVERIP);
//serveraddr.sin_port = htons(SERVERPORT);
auto ret = inet_pton(AF_INET, SERVERIP, (void *)&serveraddr.sin_addr.s_addr);
serveraddr.sin_port = htons(SERVERPORT);
retval = connect(sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if (retval == SOCKET_ERROR) {
err_quit("connect()");
}
// 데이터 통신에 사용할 변수
char buf[BUFSIZE+1];
int len;
// 서버와 데이터 통신
while(1){
// 데이터 입력
printf("\n[보낼 데이터] ");
if(fgets(buf, BUFSIZE+1, stdin) == NULL)
break;
// '\n' 문자 제거
len = strlen(buf);
if(buf[len-1] == '\n')
buf[len-1] = '\0';
if(strlen(buf) == 0)
break;
// 데이터 보내기
retval = send(sock, buf, strlen(buf), 0);
if(retval == SOCKET_ERROR){
err_display("send()");
break;
}
printf("[TCP 클라이언트] %d바이트를 보냈습니다.\n", retval);
// 데이터 받기
retval = recvn(sock, buf, retval, 0);
if(retval == SOCKET_ERROR){
err_display("recv()");
break;
}
else if(retval == 0)
break;
// 받은 데이터 출력
buf[retval] = '\0';
printf("[TCP 클라이언트] %d바이트를 받았습니다.\n", retval);
printf("[받은 데이터] %s\n", buf);
}
// closesocket()
closesocket(sock);
// 윈속 종료
WSACleanup();
return 0;
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// socket()
SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if(listen_sock == INVALID_SOCKET) err_quit("socket()");
// bind()
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
serveraddr.sin_port = htons(SERVERPORT);
retval = bind(listen_sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("bind()");
// listen()
retval = listen(listen_sock, SOMAXCONN);
if(retval == SOCKET_ERROR) err_quit("listen()");
// 데이터 통신에 사용할 변수
SOCKET client_sock;
SOCKADDR_IN clientaddr;
int addrlen;
char buf[BUFSIZE+1];
while(1){
// accept()
addrlen = sizeof(clientaddr);
client_sock = accept(listen_sock, (SOCKADDR *)&clientaddr, &addrlen);
if(client_sock == INVALID_SOCKET){
err_display("accept()");
break;
}
// 접속한 클라이언트 정보 출력
printf("\n[TCP 서버] 클라이언트 접속: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
// 클라이언트와 데이터 통신
while(1){
// 데이터 받기
retval = recv(client_sock, buf, BUFSIZE, 0);
if(retval == SOCKET_ERROR){
err_display("recv()");
break;
}
else if(retval == 0)
break;
// 받은 데이터 출력
buf[retval] = '\0';
printf("[TCP/%s:%d] %s\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port), buf);
// 데이터 보내기
retval = send(client_sock, buf, retval, 0);
if(retval == SOCKET_ERROR){
err_display("send()");
break;
}
}
// closesocket()
closesocket(client_sock);
printf("[TCP 서버] 클라이언트 종료: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
}
// closesocket()
closesocket(listen_sock);
// 윈속 종료
WSACleanup();
return 0;
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// socket()
SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
if(sock == INVALID_SOCKET) err_quit("socket()");
// 브로드캐스팅 활성화
BOOL bEnable = TRUE;
retval = setsockopt(sock, SOL_SOCKET, SO_BROADCAST,
(char *)&bEnable, sizeof(bEnable));
if(retval == SOCKET_ERROR) err_quit("setsockopt()");
// 소켓 주소 구조체 초기화
SOCKADDR_IN remoteaddr;
ZeroMemory(&remoteaddr, sizeof(remoteaddr));
remoteaddr.sin_family = AF_INET;
remoteaddr.sin_addr.s_addr = inet_addr(REMOTEIP);
remoteaddr.sin_port = htons(REMOTEPORT);
// 데이터 통신에 사용할 변수
char buf[BUFSIZE+1];
int len;
// 브로드캐스트 데이터 보내기
while(1){
// 데이터 입력
printf("\n[보낼 데이터] ");
if(fgets(buf, BUFSIZE+1, stdin) == NULL)
break;
// '\n' 문자 제거
len = strlen(buf);
if(buf[len-1] == '\n')
buf[len-1] = '\0';
if(strlen(buf) == 0)
break;
// 데이터 보내기
retval = sendto(sock, buf, strlen(buf), 0,
(SOCKADDR *)&remoteaddr, sizeof(remoteaddr));
if(retval == SOCKET_ERROR){
err_display("sendto()");
continue;
}
printf("[UDP] %d바이트를 보냈습니다.\n", retval);
}
// closesocket()
closesocket(sock);
// 윈속 종료
WSACleanup();
return 0;
}
unsigned int __stdcall WorkerThread(LPVOID lpParam) {
// TODO: write down worker thread.
HANDLE handle = (HANDLE)lpParam;
int retval;
DWORD cbTransferred;
SOCKET client_socket = 0;
OverlappedIO* data = NULL;
while (TRUE) {
retval = ::GetQueuedCompletionStatus(
handle,
&cbTransferred,
(PULONG_PTR)&client_socket,
(LPOVERLAPPED *)(&data),
INFINITE);
// DWORD lastError = GetLastError();
//printf("-- [retval: %d, transfer: %d, socket: %d, Client: %X, Overlapped: %X]\n"
// , retval, cbTransferred, client_socket, data->GetClientObject(), data);
/*
if (retval > 0 &&
(PULONG_PTR)client_socket == (PULONG_PTR)(&m_ListenSocket) &&
data != NULL) {
err_display("Acceped is succeeded.");
printf("accepted socket %d\n", data->Socket.GetSocket());
// OnAccepted
// data->OnAcceped();
::ZeroMemory(&(data->Overlapped), sizeof(data->Overlapped));
m_Iocp.BindSocket((HANDLE)(data->Socket.GetSocket()), static_cast<DWORD>(data->Socket.GetSocket()));
if (data->Socket.RecvAsync(&(data->Buffer), &(data->Overlapped)) != 0) {
err_display("WSARecv() Error at WorkerThread.");
}
}
else
*/
if (retval == 0 || cbTransferred == 0) {
if (retval == 0)
{
DWORD temp1, temp2;
if (data != NULL)
{
::WSAGetOverlappedResult(
data->GetClientObject()->GetSocket(),
(LPWSAOVERLAPPED)&(data),
&temp1,
FALSE,
&temp2);
}
err_display("WSAGetOverlappedResult()");
}
SOCKADDR_IN clientaddr;
int addrlen = sizeof(clientaddr);
getpeername(data->GetClientObject()->GetSocket(), (SOCKADDR *)&clientaddr, &addrlen);
printf("[TCP 서버] 클라이언트 종료: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
CloseSession(data);
}
else if (data && data->GetClientObject() == NULL) {
printf("This session is already Expired. Overlapped: %X]\n", data);
}
else if (data &&
data->GetClientObject() != NULL &&
cbTransferred > 0) {
std::shared_ptr<TcpClient> clientSession = data->GetClientObject();
if (clientSession->GetRecvOverlapped() == data &&
clientSession->GetRecvIoState() == IO_PENDING) {
// TODO: 나중에 델리게이트 처리
clientSession->OnReceived(cbTransferred);
if (clientSession->IsValid()) {
if (clientSession->RecvAsync() != 0) {
err_display("WSARecv() Error at WorkerThread.");
}
}
else {
printf("RecvContext: Close Client invalid [Client: %X, Overlapped: %X]\n", data->GetClientObject(), data);
CloseSession(data);
}
}
if (clientSession->GetSendOverlapped() == data &&
clientSession->GetSendIoState() == IO_PENDING) {
clientSession->OnSend(cbTransferred);
if (clientSession->IsValid()) {
if (clientSession->FlushSendBuffer() != 0) {
err_display("WSASend() Error at WorkerThread.");
}
}
else {
printf("SendContext: Close Client invalid [Client: %X, Overlapped: %X]\n", data->GetClientObject(), data);
CloseSession(data);
}
}
}
else {
printf("Unhandled case is occurred.\n");
if (data != NULL) {
CloseSession(data);
}
}
}
return 0;
}
int main(int argc, char *argv[])
{
int retval;
WSADATA wsa;
SOCKET sock, client_sock;
SOCKADDR_IN serveraddr, clientaddr;
int addrlen;
char buffer[BUFSIZE+1];
if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
return -1;
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET)
err_quit("socket()");
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(9000);
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
retval = bind(sock, (SOCKADDR*)&serveraddr, sizeof(serveraddr));
if (retval == SOCKET_ERROR)
err_quit("bind()");
retval = listen(sock, SOMAXCONN);
if (retval == SOCKET_ERROR)
err_quit("listen()");
while (1) {
addrlen = sizeof(clientaddr);
client_sock = accept(sock, (SOCKADDR*)&clientaddr, &addrlen);
if (client_sock == INVALID_SOCKET) {
err_display("accept()");
continue;
}
printf("\n[TCP 서버] 클라이언트 접속: IP 주소 = %s, 포트번호 = %d\n",
inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
while (1) {
retval = recv(client_sock, buffer, BUFSIZE, 0);
if (retval == SOCKET_ERROR) {
err_display("recv()");
continue;
}
else if (retval == 0) {
break;
}
else {
buffer[retval] = 0x00;
printf("%s", buffer);
}
}
closesocket(client_sock);
printf("\n[TCP 서버] 클라이언트 종료: IP 주소 = %s, 포트번호 = %d\n",
inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
}
closesocket(sock);
WSACleanup();
return 0;
}
int main(int argc, char *argv[])
{
int retval;
InitializeCriticalSection(&cs);
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0) return 1;
// socket()
SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if(listen_sock == INVALID_SOCKET) err_quit("socket()");
// bind()
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
serveraddr.sin_port = htons(SERVERPORT);
retval = bind(listen_sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR) err_quit("bind()");
// listen()
retval = listen(listen_sock, SOMAXCONN);
if(retval == SOCKET_ERROR) err_quit("listen()");
// 더미(dummy) 이벤트 객체 생성
WSAEVENT hEvent = WSACreateEvent();
if(hEvent == WSA_INVALID_EVENT)
err_quit("WSACreateEvent()");
EventArray[nTotalSockets++] = hEvent;
// 스레드 생성
HANDLE hThread = CreateThread(NULL, 0, WorkerThread, NULL, 0, NULL);
if(hThread == NULL) return 1;
CloseHandle(hThread);
// 데이터 통신에 사용할 변수
SOCKET client_sock;
SOCKADDR_IN clientaddr;
int addrlen;
DWORD recvbytes, flags;
while(1){
// accept()
addrlen = sizeof(clientaddr);
client_sock = accept(listen_sock, (SOCKADDR *)&clientaddr, &addrlen);
if(client_sock == INVALID_SOCKET){
err_display("accept()");
break;
}
printf("\n[TCP 서버] 클라이언트 접속: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
// 소켓 정보 추가
if(AddSocketInfo(client_sock) == FALSE){
closesocket(client_sock);
printf("[TCP 서버] 클라이언트 종료: IP 주소=%s, 포트 번호=%d\n",
inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
continue;
}
// 비동기 입출력 시작
SOCKETINFO *ptr = SocketInfoArray[nTotalSockets-1];
flags = 0;
retval = WSARecv(ptr->sock, &ptr->wsabuf, 1, &recvbytes,
&flags, &ptr->overlapped, NULL);
if(retval == SOCKET_ERROR){
if(WSAGetLastError() != WSA_IO_PENDING){
err_display("WSARecv()");
RemoveSocketInfo(nTotalSockets-1);
continue;
}
}
// 소켓의 개수(nTotalSockets) 변화를 알림
WSASetEvent(EventArray[0]);
}
// 윈속 종료
WSACleanup();
DeleteCriticalSection(&cs);
return 0;
}
int main(int argc, char *argv[])
{
int retval;
// 윈속 초기화
WSADATA wsa;
if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
return 1;
// socket()
SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
if(sock == INVALID_SOCKET) err_quit("socket()");
// 소켓 주소 구조체 초기화
SOCKADDR_IN serveraddr;
ZeroMemory(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_addr.s_addr = inet_addr(SERVERIP);
serveraddr.sin_port = htons(SERVERPORT);
// 데이터 통신에 사용할 변수
SOCKADDR_IN peeraddr;
int addrlen;
char buf[BUFSIZE+1];
int len;
// 서버와 데이터 통신
while(1){
// 데이터 입력
printf("\n[보낼 데이터] ");
if(fgets(buf, BUFSIZE+1, stdin) == NULL)
break;
// '\n' 문자 제거
len = strlen(buf);
if(buf[len-1] == '\n')
buf[len-1] = '\0';
if(strlen(buf) == 0)
break;
// 데이터 보내기
retval = sendto(sock, buf, strlen(buf), 0,
(SOCKADDR *)&serveraddr, sizeof(serveraddr));
if(retval == SOCKET_ERROR){
err_display("sendto()");
continue;
}
printf("[UDP 클라이언트] %d바이트를 보냈습니다.\n", retval);
// 데이터 받기
addrlen = sizeof(peeraddr);
retval = recvfrom(sock, buf, BUFSIZE, 0,
(SOCKADDR *)&peeraddr, &addrlen);
if(retval == SOCKET_ERROR){
err_display("recvfrom()");
continue;
}
// 송신자의 IP 주소 체크
if(memcmp(&peeraddr, &serveraddr, sizeof(peeraddr))){
printf("[오류] 잘못된 데이터입니다!\n");
continue;
}
// 받은 데이터 출력
buf[retval] = '\0';
printf("[UDP 클라이언트] %d바이트를 받았습니다.\n", retval);
printf("[받은 데이터] %s\n", buf);
}
// closesocket()
closesocket(sock);
// 윈속 종료
WSACleanup();
return 0;
}
