Computer Science

1. 소켓 연결 종료의 문제점(이는 TCP기반을 말한다.)

TCP 기반에서 closesocket()함수를 호출하게 되면 연결을 완전 종료한다는 의미이다. 여기에 한 가지 문제점이 있다.

 

만약 Host A가 Host B에게 메시지를 보내고 Host A가 closesocket 함수를 호출해 연결을 종료 했다면, Host B에서 Host A로 전송되고 있는 메시지가 있을 때, 그 메시지는 전송을 완료하지 못하고 중간에 소멸되고 말것이다. (여기서 closesocket함수는 출력 스트림과 입력 스트림을 모두 종료하는 기능을 한다.)

이 문제를 해결하기 위해 소켓 스트림의 일부만 종료(half close)하는 방법에 대해 알아볼 것이다.

 

다음은 half close를 하는 함수이다.

 

int shutdown(SOCKET s, int how);

s : half-close를 할 소켓의 핸들이다.

How : 종료모드를 인자로 전달한다.

 

다음에 how에 들어갈 종료모드들이다.

상수 값	모드	정의
0	SD_RECEIVE	입력 스트림 종료
1	SD_SEND	출력 스트림 종료
2	SD_BOTH	입 / 출력 스트림 종료

 

다음과 같이 만약 출력 스트림만 종료를 하게 된다면, Host B에서 Host A로 전송중인 메시지는 입력 스트림이 아직 열려 있기 때문에 무사지 전송이 가능하게된다.

 

 

 

 

 

 

2. 출력 스트림의 종료의 필요성

“메시지가 모두 무사히 전송되고 나서 closesocket를 이용해 종료하면 되지 출력 스트림의 종료가 왜 필요한 것인가?”에 대해 알아보자.

 

출력 스트림을 종료하게 되면, 데이터 전송의 끝을 알려주는 EOF 메시지를 연결 되어 있는 호스트로 보내게 된다. 그리고 EOF 전송 시 상대 호스트의 데이터 수신함수(read, recv)는 0을 반환한다.

 

출력 스트림을 종료하는 방법에는 shutdown 함수를 이용하여 종료 할 수도 있고, closesocket를 이용해도 입력 스트림과 함께 출력 스트림 또한 종료 되므로 EOF메시지가 전송된다.

 

다음 그림을 보면, 파일을 모두 보내고 EOF 메시지를 전송하고 있다. Clinet에서는 EOF메시지를 받고 파일이 모두 전송되었다는 것을 알아차리고 Thank you메시지를 보내게 된다. 만약 입력 스트림과 출력 스트림 모두 종료하게 된다면 Thank you 메시지는 받지 못할 것이다. 또한 EOF메시지를 보내지 않는다고 한다면, Client는 파일 전송이 언제 끝나는지도 모르는 채 파일이 전송을 계속 기다리게 되고, 한편 Server측에서는 파일을 다 전송하고 확인 메시지를 계속 기다리게 되어 server / client 모두 무한 대기 상태에 빠지게 된다.
 

 

아톰에 대해서 알기전에 아톰테이블에 대해서 먼저 알아보자.

아톰 테이블이란?

- 시스템이 유지하는 문자열 테이블
- 아톰들을 저장하는 해쉬테이블

아톰테이블에 문자열을 보관하면 저장된 문자열을 대표하는 정수값을 돌려준다. 그 값이 아톰이다.

아톰.zip

 아톰 테이블의 종류

로컬 아톰테이블

- 지역아톰테이블에 저장
- 테이블을 만든 응용 프로그램 내에세만 사용가능
- 함수명 AddAtom, GetAtomName 등등

글로벌 아톰테이블

- 전역아톰테이블에 저장
- 시스템의 모든 응용 프로그램이 같이 사용
- 함수명 GlobalAddAtom, GloabalGetAtomName 등등

아톰함수정리

ATOM GlobalAddAtom(LPCTSTR lpString) <문자열 추가>

첫 번째 인자: 추가 하고자 하는 문자열
반환 값 : 아톰테이블에 추가된 문자열의 아톰을 준다.

ATOM GlobalDeleteAtom(ATOM nAtom) <문자열삭제>

첫 번째 인자: 삭제 하고자 하는 아톰
반환 값:  성공시 0 , 실패시 nAtom

UINT GlobalGetAtomName(ATOM nAtom, LPTSTR lpBuffer, int nSize)
 <아톰값으로부터 문자열 추출>

첫번재 인자: 헤당 아톰
두번째 인자: 아톰에서 찾은 문자열을 담을 버퍼공간
세 번째 인자: 버퍼공간 사이즈

반환 값:  실패 시 0

ATOM GlobalFindAtom(LPCTSTR lpString)
<문자열로부터 아톰값을 구한다.>
 

첫 번째 인자: 해당 문자열
반환 값 : 실패 시 0

아톰의 사용용도

- 문자열을 '키'로 가지는 자료들을 관리 할 때
     중복문자열을 저장하지 않는다.(Add함수로 같은 문자열을 저장하면 참조카운트가 늘어난다 1,2,3....Delete 함수로 참조인수가 0이 될 때 시스템은 아톰테이블에서 문자열삭제한다.)


- 문자열을 통한 해쉬함수가 필요한 경우

#pragma comment(lib,"ws2_32")
#include <winsock2.h>
#include <iostream>

#define YOURIP "192.168.34.103"
#define YOURPORT 1100

struct App
{
 SOCKET sarr[WSA_MAXIMUM_WAIT_EVENTS];
 HANDLE hEarr[WSA_MAXIMUM_WAIT_EVENTS];
 HANDLE hFileArr[WSA_MAXIMUM_WAIT_EVENTS];
 int now;
};

void connectProc(int index);
void writeProc(int index);
void CloseProc(int index);
void DeleteSocket(int index);
void InitEvent(SOCKET sock);
void SendData(int index);

extern App app;




#include "event.h"

using namespace std;

App app; 

 

void main()
{
 WSADATA wsadata;
 WSAStartup(MAKEWORD(2,2),&wsadata);
 
 SOCKET sock;
 sock = socket(AF_INET, SOCK_STREAM, 0);

 SOCKADDR_IN client = {0,};

 client.sin_addr.s_addr = inet_addr(YOURIP);
 client.sin_family = AF_INET;
 client.sin_port = htons(YOURPORT);
 
 
 InitEvent(sock);
 
 WSAEventSelect(app.sarr[app.now],app.hEarr[app.now],FD_CONNECT);
 connect(sock,(SOCKADDR *)&client,sizeof(client));

 app.now++;

 WSANETWORKEVENTS ev;
 int index;
  
  

 while(1)
 {
  index = WSAWaitForMultipleEvents(app.now,app.hEarr,FALSE,WSA_INFINITE,FALSE);
  index -=  WSA_WAIT_EVENT_0;
  WSAEnumNetworkEvents(app.sarr[index],app.hEarr[index],&ev);

  switch(ev.lNetworkEvents)
  {
  case FD_CONNECT:
   connectProc(index);
   break;
  case FD_WRITE:
   writeProc(index);
   break;
  case FD_CLOSE:
   CloseProc(index);
   break;
  } 
 }
 

 WSACleanup();
}

void connectProc(int index)
{
 SOCKET sock = app.sarr[index];
 DeleteSocket(index);
 
 InitEvent(sock);
  
 WSAEventSelect(app.sarr[app.now], app.hEarr[app.now],FD_WRITE);
 app.now++;
}

void writeProc(int index)
{
 if(app.sarr[index])
 {
  while(1)
  {
   SendData(index);
  }
 }

}

void CloseProc(int index)
{
 WSACloseEvent(app.hEarr[index]);
 closesocket(app.sarr[index]);

 DeleteSocket(index);
}

void DeleteSocket(int index)
{
 app.now--;
 app.hEarr[index] = app.hEarr[app.now];
 app.sarr[index] = app.sarr[app.now];
}

void InitEvent(SOCKET sock)
{
 app.sarr[app.now] = sock;
 app.hEarr[app.now] = WSACreateEvent();
}

void SendData(int index)
{
 char str[100];
 printf("아무거나 입력해봐:\n");
 scanf("%s",str);

 SOCKET sock = app.sarr[index];
 send(sock,str,100,0);
}

#pragma comment(lib,"ws2_32")
#include <winsock2.h>
#include <iostream>

using namespace std;

struct App
{
 SOCKET sarr[WSA_MAXIMUM_WAIT_EVENTS];  //WSA_MAXIMUM_WAIT_EVENTS 는 64로 정의되어있다.
 HANDLE hEarr[WSA_MAXIMUM_WAIT_EVENTS];   //64는 한 소켓이 소유할 수 있는 이벤트 객체 핸들의 최대갯수
 HANDLE hFileArr[WSA_MAXIMUM_WAIT_EVENTS];
 int now; //신호상태인 이벤트객체의 갯수
};

App app;

void AcceptProc(int index);
void ReadProc(int index);
void CloseProc(int index);

void main()
{
 WSADATA wsadata;
 WSAStartup(MAKEWORD(2,2),&wsadata);

 SOCKET sock;
 sock = socket(AF_INET,SOCK_STREAM,0);

 SOCKADDR_IN servaddr={0,};

 servaddr.sin_family = AF_INET;
 servaddr.sin_addr.s_addr = inet_addr("192.168.34.103");
 servaddr.sin_port = htons(1100);

 int re = bind(sock,(SOCKADDR *)&servaddr,sizeof(servaddr));
 re = listen(sock,5);
 app.sarr[app.now]=sock; //셋팅된 sock을 app.sarr[app.now]에 넣어준다.
 
 
 app.hEarr[app.now] = WSACreateEvent();  //이벤트객체를 생성
 WSAEventSelect(app.sarr[app.now],app.hEarr[app.now],FD_ACCEPT); 
 //app.sarr[app.now] 에서 FD_ACCEPT가 발생하면 app.hEarr[app.now]를 신호상태로 바꿔준다.

 app.now++; //생성됐으니 카운트 증가

 WSANETWORKEVENTS ev; //이벤트의 유형정보와 오류정보로 채워질 WSANETWORKEVENTS 구조체 변수

 int index;
 while(1)
 {
  index = WSAWaitForMultipleEvents(app.now,app.hEarr,FALSE,WSA_INFINITE,FALSE);
  index -= WSA_WAIT_EVENT_0;

//FALSE 이면 이벤트 객체중에서 하나라도 신호상태이면 index를 반환해준다.
//TRUE 이면 전부 신호상태이어야 반환된다.
//2개 이상 신호상태일시 인덱스 번호가 낮은 것이 반환된다.

  WSAEnumNetworkEvents(app.sarr[index],app.hEarr[index],&ev);
//이벤트가 발생한 소켓과 신호상태인 이벤트객체핸들에서 발생한이벤트의 유형정보와 오류정보가 WSANETWORKEVENTS 구조체의 주소값으로 전달된다.

  switch(ev.lNetworkEvents)
  {
  case FD_ACCEPT:
   AcceptProc(index);
   break;
  case FD_READ:
   ReadProc(index);
   break;
  case FD_CLOSE:
   CloseProc(index);
   break;
  }  
 }
 WSACleanup();
}

void AcceptProc(int index)
{
 SOCKADDR_IN clientaddr;
 int len = sizeof(clientaddr);
 SOCKET sock = app.sarr[index];
 app.sarr[app.now] = accept(sock,(SOCKADDR *)&clientaddr,&len);
 app.hEarr[app.now] = WSACreateEvent();
 WSAEventSelect(app.sarr[app.now],app.hEarr[app.now],FD_READ|FD_CLOSE);
 app.now++;
}

void ReadProc(int index)
{
 char buf[100];
 SOCKET sock = app.sarr[index];
 if(recv(sock,buf,100,0)<=0) //접속이 종료되었거나 에러가 나면 리턴
 {
  return;  
 }
 printf("%s\n", buf);
}

void CloseProc(int index)
{
 WSACloseEvent(app.hEarr[index]);
 closesocket(app.sarr[index]);

 app.now--;
 app.hEarr[index] = app.hEarr[app.now];
 app.sarr[index] = app.sarr[app.now];
}

1.Event Select모델 이란 ?

 

 : WSAEventSelect() 함수가 핵심적인 역할을 하는데 WSAAscyncSelect와 다르게 윈도우 메세지 형태  대신 이벤트 객체를 통해서 네트워크 이벤트를 감지 하고 이벤트 객체를 관찰함으로써 스레드를 사용하지 않고도 여러 개의 소켓을 처리 가능한 네트워크 모델.

 

 

2. 동작 원리

  : 소켓과 이벤트 객체를 연결 소켓 에 대한 이벤트를 처리하는데 ,연결 이유는 발생한 이벤트를 이벤트 객체를 통해서 감지하기 위함인데 네트워크 이벤트가 발생할 때마다 이벤트 객체의 신호 상태를 통해 네트워크 이벤트 발생을 감지할 수 있다.

 

 

 

 

 

3. 입출력 절차

 

 

①  WSACreateEvent() 함수를 이용하여 이벤트 객체를 생성한           다.

② WSAEventSelect() 함수를 이용하여 소켓에 이벤트 객체 연결 처리할 네트워크 연결

③ WSAWaitForMultipleEvents() 이벤트객체가 이벤트 발생유무를 확인 하기 위한 함수(신호 감지)

④ WSAEnumNetworkEvents() 함수를 호출하여 발생한 네트워크 이벤트 및 오류 를알아낸다

 

 

4.관련 함수 및 예제

 

1.    WSAEventSelect() 함수

 

#include <winsock2.h> int WSAEventSelect(SOCKET S, WSAEVENT hEventObject, long lNetworkEvents); 성공시 0, 실패시 SOCKET_ERROR 반환 SOCKET S   :   관찰대상인 소켓의 핸들 전달. WSAEVENT hEventObject  :  이벤트 발생유무의 확인을 위한 이벤트객체 핸들 long lNetworkEvents : 감시하고자하는 이벤트의 종류 등록

 

S 에 전달된 핸들의 소켓에서 lNetworkEvents 에 전달된 이벤트중 하나가 발생하면, hEventObject에 전달된 핸들의 커널 오브젝트를 signaled(신호) 상태로 바꾸는 함수이다.

.

이벤트는 WSAAsyncSelect 모델 하고 같다.

 

 

 

 

2.    이벤트 객체 생성과 제거: WSACreateEvent(),WSACloseEvent()

 

WSAEVENT   WSACreateEvent ( ) ;                                    성공: 이벤트 객체 핸들 리턴                                실패: WSA_INVALID_EVENT 리턴 BOOL  WSACloseEvent (WSAEVENT hEvent) ;                                        성공: TRUE, 실패: FALSE

 

 

 

예제 코드

 

void Doit(intindex) {    SOCKADDR_IN clientaddr;    intlen = sizeof(clientaddr);    SOCKETsock = sarr[index];    sarr[cnt] = accept(sock,(SOCKADDR*)&clientaddr,&len);    hEarr[cnt] = WSACreateEvent(); //이벤트 객체 생성    WSAEventSelect(sarr[cnt],hEarr[cnt],FD_READ|FD_CLOSE);//소켓 ,객체 연결    cnt++; }

 

 











3. 이벤트 객체의 신호 상태 감지하기 : WSAWaitForMultipleEvents() 함수

 

DWORD WSAWaitForMultipleEvents (    DWORD cEvents,    const WSAEVENT* lphEvents,    BOOL fWaitAll,    DWORD dwTimeout,    BOOL fAlertable ) ;

          

 

 

 

DWORD cEvents, : 이벤트 객체의 수 (하나의 소켓에 여러 개의이벤트 객체가능)

const WSAEVENT* lphEvents, : 이벤트 객체의 배열의 시작 주소(최대 64개가능)

BOOL fWaitAll,: 전체 신호 상태 / 단일 신호 상태에 따른 리턴시기를 구분

(TRUE 전달시 배열안의 이벤트 객체 가 전부 신호 상태이어야 리턴 가능)

(FALSE 전달시 배열안의 이벤트 객체가 하나라도 신호 상태이어도 리턴 가능)

DWORD dwTimeout,: 신호상태 감시할 시간 설정 (WSA_INFINITE : 무한대기)

BOOL fAlertable: 입출력 완료 시기

리턴 : 리턴값에서 WSA_WAIT_EVENT_0 인 상수를 빼면 이벤트 객체배열에서 이벤트가 발생한 이벤트핸들의 인덱스 값이 된다. 2개이상일경우 에는 인덱스가 작은 것부터 값을 얻는다.

 

 

 

 

 

4.구체적인 네트워크 이벤트 알아내기 :

int WSAEnumNetworkEvents (    SOCKET s,    WSAEVENT hEventObject,    LPWSANETWORKEVENTS lpNetworkEvents ) ;                        성공: 0, 실패: SOCKET_ERROR

 

 

  

 SOCKET s, : 이벤트가 발생한 소켓의 핸들 전달
WSAEVENT hEventObject, :  소켓과 연결된, 신호상태인 이벤트 객체핸들  LPWSANETWORKEVENTS lpNetworkEvents : 발생한 이벤트의 유형정보와 오류정보로 채워질 WSANETWORKEVENTS 구조체 변수의 주소 값 전달

 

  

 

 

예제 코드 (WSAWaitForMultipleEvents 함수,WSAEnumNetworkEvents함수)

WSANETWORKEVENTSev; intindex; while(1){    index = WSAWaitForMultipleEvents (cnt,hEarr,FALSE,WSA_INFINITE,FALSE);//이벤트유무확인    index  = index – WSA_WAIT_EVENT_0;    WSAEnumNetworkEvents(sarr[index],hEarr[index],&ev);//구체적인 이벤트 및 오류 알아내기    switch(ev.lNetworkEvents){    caseFD_ACCEPT:        //do it..    break;    caseFD_READ:        //do it..    break;    caseFD_CLOSE:        //do it.     break;

 

디자인패턴 정형화된 생각을 하지 말자.

GOF 디자인패턴 - 주관적인 생각

쪽지보내기

#pragma comment(lib,"Dll")
#include "Packet.h"
#include "resource.h"

#define WM_RECV (WM_APP+1)
#define WM_SEND (WM_APP+2)

#define MYIP "192.168.34.103"
#define MYPORT 1000

#define YOURIP "192.168.34.102"
#define YOURPORT 1000

char str[256];

BOOL CALLBACK DlgProc(HWND hDlg, UINT iMessage, WPARAM wParam, LPARAM lParam);

INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
 WSADATA wsadata;
 WSAStartup(MAKEWORD(2,0),&wsadata);

 DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG1), 0, DlgProc);
 
 WSACleanup();
 return 0;
}

 

BOOL OnInit(HWND hDlg);
BOOL OnCommand(HWND hDlg, WORD cid, WORD cmsg, HWND cWnd);
BOOL OnSend(HWND hDlg, SOCKET sock, WORD msg, WORD eid);
BOOL OnRecv(HWND hDlg, SOCKET sock, WORD msg, WORD eid);
void SendStart(HWND hDlg);

 

BOOL CALLBACK DlgProc(HWND hDlg, UINT iMessage, WPARAM wParam, LPARAM lParam)
{
 switch(iMessage)
 {
 case WM_INITDIALOG: return OnInit(hDlg);

 case WM_COMMAND: return OnCommand(hDlg, LOWORD(wParam), HIWORD(wParam), (HWND)lParam);

 case WM_SEND: return OnSend(hDlg, (SOCKET)wParam,  LOWORD(lParam),  HIWORD(lParam));

 case WM_RECV: return OnRecv(hDlg, (SOCKET)wParam,  LOWORD(lParam),  HIWORD(lParam));
 }

 return FALSE;
}

 

BOOL OnInit(HWND hDlg)
{
 SOCKET sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

 SOCKADDR_IN servaddr={0,};
 servaddr.sin_addr.s_addr = inet_addr(MYIP);
 servaddr.sin_port = htons(MYPORT);
 servaddr.sin_family = PF_INET;

 bind(sock,(SOCKADDR *)&servaddr,sizeof(servaddr));

 listen(sock,5);

 WSAAsyncSelect(sock,hDlg,WM_RECV,FD_ACCEPT|FD_CLOSE);
//sock에 accept준비가 되거나 closesocket을 해야 할 상태가 오면
//hDlg윈도우에 WM_RECV 메시지를 보내 주세요.
 return TRUE;
} 

 

BOOL OnCommand(HWND hDlg, WORD cid, WORD cmsg, HWND cWnd)
{
 

 switch(cid)
 {
 case IDOK:
  GetDlgItemText(hDlg, IDC_EDIT1, str , 256);
  SendStart(hDlg);
  
  break;
 case IDCANCEL: EndDialog(hDlg, IDCANCEL);
 break;
 }

 return TRUE;
}

void SendStart(HWND hDlg)
{
 SOCKET sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

 SOCKADDR_IN servaddr={0,};
 servaddr.sin_addr.s_addr = inet_addr(YOURIP);
 servaddr.sin_port = htons(YOURPORT);
 servaddr.sin_family = PF_INET;

 WSAAsyncSelect(sock,hDlg,WM_SEND,FD_CONNECT);
 connect(sock,(SOCKADDR *)&servaddr,sizeof(servaddr));

//WSAAsyncSelect 함수가 호출되고 나서, 접속요청 작업의 완료가 있었던 경우.
//connect 함수가 호출되고 난 후에 접속 작업이 완료되었을 때.

}

void OnConnect(HWND hDlg, SOCKET sock, WORD eid);
void OnWrite(HWND hDlg, SOCKET sock, WORD eid);
void OnClose2(HWND hDlg,SOCKET sock,WORD eid);

 

BOOL OnSend(HWND hDlg, SOCKET sock, WORD msg, WORD eid)
{
 switch(msg)
 {
 case FD_CONNECT: OnConnect(hDlg, sock, eid); break;
 case FD_WRITE:  OnWrite(hDlg, sock, eid); break;
 case FD_CLOSE:  OnClose2(hDlg, sock, eid); break;
 }
 return TRUE;
}

void OnConnect(HWND hDlg, SOCKET sock, WORD eid)
{
 WSAAsyncSelect(sock,hDlg,WM_SEND,FD_WRITE);
// connect 나  accept 함수가 호출되고 나서, 접속이 완료 되었을 때
}

void OnWrite(HWND hDlg, SOCKET sock, WORD eid)
{
 int slen = strlen(str);

 MsgHead msg(0);
 int bodylen = sizeof(slen) + slen;
 msg.SetBlen(bodylen);
 Packet *pack = new Packet();
 pack->Pack(&msg, sizeof(MsgHead));
 pack->Pack(&slen, sizeof(int));
 pack->Pack(str, slen);
 pack->Send(sock);
 
 WSAAsyncSelect(sock,hDlg,WM_SEND,FD_CLOSE);
}

void OnClose2(HWND hDlg,SOCKET sock,WORD eid)
{
 DWORD nrecv;
 if(ioctlsocket(sock,FIONREAD,&nrecv)==0)
 {
  if(nrecv)
  {
   PostMessage(hDlg,WM_SEND,sock,(eid>>16)|FD_CLOSE);
  }
  else
  {
   closesocket(sock);
  }
 }
}

 

void OnAccept(HWND hDlg, SOCKET sock, WORD eid);
void OnRead(HWND hDlg, SOCKET sock, WORD eid);

BOOL OnRecv(HWND hDlg, SOCKET sock, WORD msg, WORD eid)
{

 switch(msg)
 {
 case FD_ACCEPT: OnAccept(hDlg, sock, eid); break;
 case FD_READ: OnRead(hDlg, sock, eid); break;
 case FD_CLOSE: OnClose2(hDlg, sock, eid); break;
 }
 return TRUE;
}

void OnAccept(HWND hDlg, SOCKET sock, WORD eid)
{
 SOCKADDR_IN cliaddr = {0, };
 int len = sizeof(cliaddr);
 SOCKET dosock;

 dosock = accept(sock, (SOCKADDR*)&cliaddr, &len);
 WSAAsyncSelect(dosock, hDlg, WM_RECV, FD_READ|FD_CLOSE);

//Read
//WSAAsyncSelect 함수가 호출 되고나서, 수신할수 있는 데이터가 있을 때
//데이터가 로컬 호스트로 도착하고, FD_READ 가 아직 포스팅되지 않았을 때

//Close
Note : closesocket 함수를 호출하고 난 후에 FD_CLOSE 메시지는 포스팅 되지 않습니다.

}

void OnRead(HWND hDlg, SOCKET sock, WORD eid)
{
 int len;
 char r_str[256];
 
 memset(r_str,0, 256);

 MsgHead msg;

 if(recv(sock,(char *)&msg,sizeof(MsgHead),0)<=0)  //recv시 false 값에대한 예외처리
                                                             //안할경우 수신버퍼에 데이터가 남아있어서 OnRead가 또 실행될수있다.
{
  return;
 }
 
 Packet *pack = new Packet(sock, msg.Getblen());
 
 pack->UnPack(&len, sizeof(len));
 pack->UnPack(r_str, len);
 
 
 MessageBox(hDlg, r_str , "", MB_OK);
 
 //WSAAsyncSelect(sock, hDlg, WM_RECV, FD_CLOSE); 받을 때는 Close를 해주지 않는다.
}

 

사칙연산 예제

Dll 헤더파일

#ifndef __CAL_H
#define __CAL_H

#include <windows.h>

#ifdef DLLEXPORT
#define DLLTYPE __declspec(dllexport)
#define DLLTYPE2 extern "C" __declspec(dllexport)
#else
#define DLLTYPE __declspec(dllimport)
#define DLLTYPE2 extern "C" __declspec(dllimport)
#endif

class DLLTYPE Cal
{
 public:
 int Calplus(int Num1, int Num2);
 int Cal::CalMinus(int Num1, int Num2);
 int Cal::CalMul(int Num1, int Num2);
 int Cal::CalDiv(int Num1, int Num2);
 
};
#endif __CAL_H

DLL CPP파일

#define DLLEXPORT을 선언하였다. 헤더파일에도 정의되어있기때문에 조건문에서 export로 되어서 수출하게된다.


사용파일

여기서는 Cal.h 를 인클루드만해서 쓰게 됨으로 DLLEXPORT가 중복이 안되서 조건문에서 import로 빠지게된다.
즉, 사용하겠다는 뜻이다.

리스트뷰 -  ListBox가 발전된 형태로  좀 더 깔끔하고 다양한 기능을 사용할 수 있다.

리스트뷰 함수정리

LVCOLUMN 구조체  -  LVCOLUMN 구조체에 헤더의 정보를 채운 뒤 LVM_INSERTCOLUMN 메시지 전송

LVITEM 구조체 -  LVITEM 구조체에 항목의 정보를 채운 뒤 LVM_INSERTITEM  메시지 전송

 

#include <windows.h>
#include <commctrl.h>
#define IDC_LISTVIEW 150
#define LVIF_TEXT 151

LVCOLUMN COL; //열 구조체
LVITEM LI;          //항목 구조체
HWND hList;


void OnInitCOL(HWND hWnd)
{
 hList = CreateWindow(WC_LISTVIEW,NULL, WS_CHILD | WS_VISIBLE | WS_BORDER | LVS_REPORT, 150,18,240,60,hWnd,(HMENU)IDC_LISTVIEW,0,0);
 ListView_SetExtendedListViewStyle(hList,LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
//리스트뷰 스타일 초기화

 COL.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
 COL.fmt = LVCFMT_LEFT;
 
 COL.cx=80;
 COL.pszText="가";   
 COL.iSubItem=0;
 ListView_InsertColumn(hList,0,&COL);   

//첫번째 : 해당 리스트 핸들
//두번째 : 몇번째 열인지
//세번째 : 해당 열의 초기화상태
 
 COL.cx=80;
 COL.pszText="나";   
 COL.iSubItem=1;
 ListView_InsertColumn(hList,1,&COL);
 
 COL.cx=80;
 COL.pszText="다";  
 COL.iSubItem=2;
 ListView_InsertColumn(hList,2,&COL);
}

void OnInitITEM()
{
 LI.mask = LVIF_TEXT;
 LI.iItem = 1;         //행 (전체 화면 - 캡션포함)
 LI.iSubItem = 0;    //열
 LI.pszText = "1";  //문자열 값
 ListView_InsertItem(hList, &LI);
//초기화된 항목구조체 정보를 토대로 해당리스트에 삽입 

 ListView_SetItemText(hList, 0, 1, "2"); 
//첫번째: 해당 리스트 핸들
//두번째 : 행 (캡션 미 포함)
//세번째 : 열
//네번째 : 값
 ListView_SetItemText(hList, 0, 2, "3");
 
  
 LI.iItem = 2;
 LI.pszText = "4";
 ListView_InsertItem(hList, &LI);

 ListView_SetItemText(hList, 1, 1, "5");
 ListView_SetItemText(hList, 1, 2, "6");
 
 LI.iItem = 3;
 LI.pszText = "7";
 ListView_InsertItem(hList, &LI);

 ListView_SetItemText(hList, 2, 1, "8");
 ListView_SetItemText(hList, 2, 2, "9");
}



결과

윈도우 시스템은, 메시지구동 시스템으로 모든 이벤트는 메세지의 발생에 의해서 처리된다.


#define MY_USER 1000 
이렇게 선언할 경우 이미 1000이라는 값은 시스템이 내부적으로 예약해서 사용하는 상수일 수 있다.
그래서 이러한 현상을 막는 방법으로 WM_USER와 같은 사용자가 정의 할 수 있는 상수공간을 마련해두었다.


설명 - 이 메시지는 실제로 정의되어 있는 시스템 메시지가 아니며 사용자 정의 메시지의 시작 범위를 지정하는 상수값이다. 메시지는 정수값 하나로 표현되는데 윈도우즈는 메시지의 범위를 다음과 같이 정의하고 있다.



<범위 설명>

0~WM_USER-1
운영체제가 정의하는 시스템 메시지. WM_PAINT, WM_TIMER 등의 메시지들이 모두 이 범위에 속한다.

WM_USER~WM_APP-1
윈도우 클래스가 정의하는 사용자 정의 메시지
WM_APP~0xBFFF
응용 프로그램이 정의하는 사용자 정의 메시지

0xC000~0XFFFF
문자열로 등록되는 메시지

0x10000~ 이후의 사용을 위해 예약된 영역이며 현재는 사용되지 않는다.

WM_USER

WM_USER는 한 윈도우 클래스를 위한 고유의 메시지를 정의하기 위한 상수값이며 이 범위 이후부터 윈도우 클래스의 사용자 정의 메시지를 만들 수 있다. 이 값은 0x400으로 정의되어 있으며 보통 WM_USER+n으로 사용자 정의 메시지를 정의한다. 이때 n은 1보다 큰 정수이며 사용자 정의 메시지간의 구분을 위해 사용된다. 여러 개의 사용자 정의 메시지가 필요하다면 WM_USER+1, WM_USER+2, WM_USER+3,... 식으로 계속 n을 증가시켜 가며 메시지를 정의할 수 있다. 윈도우즈는 WM_USER이후 0x8000까지 사용자 정의 메시지 영역으로 정의하고 있으므로 n은 최대 0x7c00까지 가능하다. WM_USER+n을 곧바로 사용할 수도 있으며 자주 사용할 경우 다음과 같이 매크로를 정의하여 별도의 메시지를 만들 수 있다.

#define WM_MYMESSAGE WM_USER+1

이렇게 매크로를 정의해 놓고 이후부터 WM_MYMESSAGE라는 명칭을 대신 사용하면 된다.

주의
- 표준 컨트롤 중 일부는 자신만의 사용자 정의 메시지를 정의하여 사용하고 있다. 따라서 WM_USER+n은 가급적이면 한 윈도우 클래스내에서만 정의하여 사용해야 하며 응용 프로그램간의 통신에는 사용하지 않는 것이 바람직하다.
- 표준 컨트롤을 서브클래싱했을 경우 함부로 WM_USER+n을 사용하면 표준 컨트롤 고유의 메시지와 충돌이 발생할 수 있다.



예제
 
다음 예제는 사용자 정의 메시지로 윈도우를 이동시킨다.

LRESULT CALLBACK WndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam)
{
        HDC hdc;
        PAINTSTRUCT ps;
        RECT wrt;
        TCHAR Mes[]="왼쪽 마우스 버튼을 누르면 이동합니다";

        switch(iMessage) {
        case WM_USER+1:
                GetWindowRect(hWnd,&wrt);
                wrt.left+=wParam;
                wrt.right+=wParam;
                wrt.top+=lParam;
                wrt.bottom+=lParam;
                MoveWindow(hWnd,wrt.left,wrt.top,wrt.right-wrt.left,wrt.bottom-wrt.top,TRUE);
                return 0;
        case WM_LBUTTONDOWN:
                SendMessage(hWnd,WM_USER+1,(WPARAM)-3,(LPARAM)5);
                return 0;
        case WM_PAINT:
                hdc=BeginPaint(hWnd, &ps);
                TextOut(hdc,10,10,Mes,lstrlen(Mes));
                EndPaint(hWnd, &ps);
                return 0;
        case WM_DESTROY:
                PostQuitMessage(0);
                return 0;
        }
        return(DefWindowProc(hWnd,iMessage,wParam,lParam));
}

이 예제에서 WM_USER+1은 윈도우를 이동하라는 뜻이며 wParam은 수평 이동 거리, lParam은 수직 이동 거리로 정의하였다. WM_USER+1을 받으면 이 인수들이 지정하는 거리만큼 윈도우를 이동시킨다.

WM_APP

#define WM_MYMESSAGE WM_APP+1

이렇게 매크로를 정의해 놓고 이후부터 WM_MYMESSAGE라는 명칭을 대신 사용하면 된다. WM_USER도 사용자 정의 메시지를 정의하는 용도로 사용되지만 표준 컨트롤중에 이미 WM_USER를 사용하는 컨트롤이 있으므로 중복될 위험성이 있다. 반면 WM_APP는 시스템이 전혀 이 영역을 사용하지 않고 있으므로 중복될 위험이 전혀 없으며 응용 프로그램간의 통신에 사용하기에 적합하다. 두 응용 프로그램의 약속에 의해 WM_APP+n 메시지를 정의하여 사용하면 된다.

WM_USER는 윈도우 클래스를 위한 사용자 정의 메시지이며 WM_APP는 응용 프로그램을 위한 사용자 정의 메시지라는 점이 다르다. 그러나 이 구분은 어디까지나 권장 사항일 뿐이지 강제 사항은 아니다. WM_USER를 응용 프로그램간의 통신에 사용하더라도 충돌이 없다는 확신만 있다면 가능하다. 다만 잠재적인 충돌 가능성이 있을 수 있다는 것을 고려할 때 바람직하지는 않다.

정리

 

리턴값의 의미는 정해져 있다. 응용 프로그램이 의미를 정해서 사용할 수 있다. 이 메시지로 어떤 질문을 하고자할 때는 리턴값을 정의하며 그렇지 않을 경우는 통상 리턴값을 사용하지 않는다.



출처 http://www.winapi.co.kr/reference/Message/WM_USER.htm