WSAData wsaData;

int nError;

nError = WSAStartup( MAKEWORD( 2, 2 ), &wsaData );

if( nError != 0 )

// error 

소켓 초기화 시키기

보통 WSAStartup -> socket -> closesocket -> WSACleanup 순으로 이뤄진다.

서버 WSAStartup -> socket -> bind -> listen ->  accept -> closesocket -> WSACleanup

클라 WSAStartup -> socket -> connect -> closesocket -> WSACleanup

WSADATA wsaData;

SOCKET sock;

SOCKADDR_IN addr;

WSAStartup( MAKEWORD( 2, 2 ), &wsaData );

sock = socket( AF_INET, SOCK_STREAM, 0 );

memset( ( void * )&addr, 0, sizeof( SOCKADDR_IN ) );

addr.sin_family = AF_INET;

addr.sin_addr.s_addr = inet_addr( IP_ADDRESS );

addr.sin_port = htons( PORT_NUMBER );

closesocket( sock );

WSACleanup();

바로 쓸수 있는 건 아니고... 이런 식으로 만들면 된다. 앞에 있는 예제는 api 에서는 저렇게 하고 C++ 문법으로는 이렇게 한다.

나는 Exception Class를 직접 만들어서 사용했으며 그 예외를 호출쪽에서 처리할 수 있도록 제작하였다.

기존 api 방식의 문법은 눈에 잘 들어오지 않는 단점이 있으며 위의 방법은 눈에 잘 들어오고 구조적이라는 장점이 있다.

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

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

void main()
{
    SOCKET s;
    SOCKADDR_IN sin;
    WSADATA wsaData;
    if(WSAStartup(MAKEWORD(2,0),&wsaData) != NO_ERROR)
    {
        printf("WSAStartup failed, error code : %d\n",WSAGetLastError());
        return ;
    }

    s = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

    if(s == INVALID_SOCKET)
    {
        printf("make socket failed, error code : %d\n",WSAGetLastError());
        WSACleanup();
        return ;
    }

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = inet_addr("127.0.0.1");
    sin.sin_port = htons(912);

    if(connect(s,(struct sockaddr*)&sin,sizeof(sin)) != NO_ERROR)
    {
        printf("connect failed, error code = %u \n",WSAGetLastError());
        closesocket(s);
        WSACleanup();
        return ;
    }

    if(closesocket(s) != NO_ERROR)
    {
        printf("remove socket failed, error code : %u\n",WSAGetLastError());
        WSACleanup();
        return ;
    }

    if(WSACleanup() != NO_ERROR)
    {
        printf("WSACleanup failed, error code = &u\n",WSAGetLastError());
        return ;
    }

    printf("127.0.0.1의 912번 포트에 접속을 성공하셨습니다.\n");
}

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

void main()
{

    // Initialize Winsock.
    WSADATA wsaData;
    int iResult = WSAStartup( MAKEWORD(2,2), &wsaData );
    if ( iResult != NO_ERROR )
        printf("Error at WSAStartup()\n");

    // Create a socket.
    SOCKET m_socket;
    m_socket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );

    if ( m_socket == INVALID_SOCKET )
    {
        printf( "Error at socket(): %ld\n", WSAGetLastError() );
        WSACleanup();
        return;
    }

    // Bind the socket.
    sockaddr_in service;

    service.sin_family = AF_INET;
    service.sin_addr.s_addr = inet_addr( "127.0.0.1" );
    service.sin_port = htons( 27015 );

    if ( bind( m_socket, (SOCKADDR*) &service, sizeof(service) ) == SOCKET_ERROR )
    {
        printf( "bind() failed.\n" );
        closesocket(m_socket);
        return;
    }

    // Listen on the socket.
    if ( listen( m_socket, 1 ) == SOCKET_ERROR )
        printf( "Error listening on socket.\n");

    // Accept connections.
    SOCKET AcceptSocket;

    printf( "Waiting for a client to connect...\n" );
    while (1)
    {
        AcceptSocket = SOCKET_ERROR;
        while ( AcceptSocket == SOCKET_ERROR )
        {
            AcceptSocket = accept( m_socket, NULL, NULL );
        }
        printf( "Client Connected.\n");
        m_socket = AcceptSocket;
        break;
    }

    // Send and receive data.
    int bytesSent;
    int bytesRecv = SOCKET_ERROR;
    char sendbuf[32] = "조산 서버";
    char recvbuf[32] = "";

    bytesRecv = recv( m_socket, recvbuf, 32, 0 );
    printf( "Bytes Recv: %ld\n", bytesRecv );

    bytesSent = send( m_socket, sendbuf, strlen(sendbuf), 0 );
    printf( "Bytes Sent: %ld\n", bytesSent );

    printf("Recv Buf: %s\n", recvbuf);

    return;
}

char lHostName[ 255 ];

PHOSTENT lHostInfo;

char *IpBuffer;

WSADATA wsaData;

if( WSAStartup( MAKEWORD( 2,0 ), &wsaData ) == 0 )

{

if( gethostname( lHostName, 255 ) == 0 )

{

if( ( lHostInfo = gethostbyname( lHostName ) ) != NULL )

{

IpBuffer = inet_ntoa( *( struct in_addr * )*lHostInfo->h_addr_list );

}

}

}

CString LocalAdap;
 CString LocalMac;
 CString LocalIP;
 CString LocalSub;
 CString LocalGate;

 PIP_ADAPTER_INFO pAdapterInfo;
 PIP_ADAPTER_INFO pAdapter = NULL;

 DWORD dwRetVal = 0;
 BOOL m_bBreak = FALSE;

 pAdapterInfo = (IP_ADAPTER_INFO *)malloc(sizeof(IP_ADAPTER_INFO));
 unsigned long ulOutBufLen = sizeof(IP_ADAPTER_INFO);

 UpdateData(true);

 if(GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) != ERROR_SUCCESS)
 {
  GlobalFree(pAdapterInfo);
  pAdapterInfo = (IP_ADAPTER_INFO*)malloc(ulOutBufLen);
 }

 if((dwRetVal=GetAdaptersInfo(pAdapterInfo, &ulOutBufLen)) == NO_ERROR)
 {
  pAdapter = pAdapterInfo;
  while(pAdapter)
  {
   LocalAdap.Format (_T("%s"), (CA2W)pAdapter->Description);
   m_listbox.AddString(LocalAdap);

   LocalMac.Format (_T("MAC : %02X-%02X-%02X-%02X-%02X-%02X"),pAdapter->Address[0],pAdapter->Address[1], 
    pAdapter->Address[2], pAdapter->Address[3], pAdapter->Address[4], pAdapter->Address[5]);
   m_listbox.AddString((_T("MAC :"), LocalMac));

   LocalIP.Format (_T("IP : %s"), (CA2W)pAdapter->IpAddressList.IpAddress.String);
   m_listbox.AddString(LocalIP);

   LocalSub.Format (_T("Local : %s"), (CA2W)pAdapter->IpAddressList.IpMask.String);
   m_listbox.AddString(LocalSub);

   if(pAdapter->Next == NULL)
   {
    m_bBreak = TRUE;
    break;
   }
   pAdapter = pAdapter->Next;
  }
 }

클라이언트의 접속을 받아 드릴때 accept 함수를 사용하게 된다.

이때 accept 함수에 인자를 세개를 넣게 되는데 두번째 인자에 클라이언트에 대한 정보를 넣을 수 있다.

이때 세번째 인자에는 받아야할 데이터 크기에 대한 변수를 넣어야 한다. 데이터 크기가 다르면

뻑날 수도 있다. ㅋ

sockaddr_in clientInfo = { 0 };

int addrsize= sizeof( sockaddr_in );
client = accept( m_Socket, ( sockaddr * )&clientInfo, &addrsize );

printf( "ip = %s  port = %d\n", inet_ntoa( clientInfo.sin_addr ),  ntohs( ( short )clientInfo.sin_port ) );

IPHLPAPI(IP Helper API) functions

Headers

#include <winsock2.h>
#include <iphlpapi.h>

Library

• WS2_32.lib
  
• IPHLPAPI.lib

Adapter Configuration

DWORD
GetAdapterIndex(
  LPWSTR AdapterName,
  PULONG IfIndex
);

DWORD WINAPI
GetAdaptersAddresses(
  ULONG Family,
  DWORD Flags,
  PVOID Reserved,
  PIP_ADAPTER_ADDRESSES pAdapterAddresses,
  PULONG pOutBufLen
);

DWORD
GetAdaptersInfo(
  PIP_ADAPTER_INFO pAdapterInfo,
  PULONG pOutBufLen
);

DWORD
GetPerAdapterInfo(
  ULONG IfIndex,
  PIP_PER_ADAPTER_INFO pPerAdapterInfo,
  PULONG pOutBufLen
);

DWORD
GetUniDirectionalAdapterInfo(
  PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo,
  PULONG dwOutBufLen
);

ARP

DWORD
CreateIpNetEntry(
  PMIB_IPNETROW pArpEntry
);

DWORD
CreateProxyArpEntry(
  DWORD dwAddress,
  DWORD dwMask,
  DWORD dwIfIndex
);

DWORD
DeleteIpNetEntry(
  PMIB_IPNETROW pArpEntry
);

DWORD
DeleteProxyArpEntry(
  DWORD dwAddress,
  DWORD dwMask,
  DWORD dwIfIndex
);

DWORD
FlushIpNetTable(
  DWORD dwIfIndex
);

DWORD
GetIpNetTable(
  PMIB_IPNETTABLE pIpNetTable,
  PULONG pdwSize,
  BOOL bOrder
);

DWORD
SendARP(
  IPAddr DestIP,
  IPAddr SrcIP,
  PULONG pMacAddr,
  PULONG PhyAddrLen
);

DWORD
SetIpNetEntry(
  PMIB_IPNETROW pArpEntry
);

Network Interface

DWORD
GetFriendlyIfIndex(
  DWORD IfIndex
);

DWORD
GetIfEntry(
  PMIB_IFROW pIfRow
);

DWORD
GetIfTable(
  PMIB_IFTABLE pIfTable,
  PULONG pdwSize,
  BOOL bOrder
);

DWORD
GetInterfaceInfo(
  PIP_INTERFACE_INFO pIfTable,
  PULONG dwOutBufLen
);

DWORD
GetNumberOfInterfaces(
  PDWORD pdwNumIf
);

DWORD
SetIfEntry(
  PMIB_IFROW pIfRow
);

IP, ICMP

DWORD
GetIcmpStatistics(
  PMIB_ICMP pStats
);

DWORD
GetIpStatistics(
  PMIB_IPSTATS pStats
);

BOOL
IcmpCloseHandle(
  HANDLE IcmpHandle
);

HANDLE
IcmpCreateFile(void);

DWORD
IcmpParseReplies(
  LPVOID ReplyBuffer,
  DWORD ReplySize
);

DWORD
IcmpSendEcho(
  HANDLE IcmpHandle,
  IPAddr DestinationAddress,
  LPVOID RequestData,
  WORD RequestSize,
  PIP_OPTION_INFORMATION RequestOptions,
  LPVOID ReplyBuffer,
  DWORD ReplySize,
  DWORD Timeout
);

DWORD
IcmpSendEcho2(
  HANDLE IcmpHandle,
  HANDLE Event,
  FARPROC ApcRoutine,
  PVOID ApcContext,
  IPAddr DestinationAddress,
  LPVOID RequestData,
  WORD RequestSize,
  PIP_OPTION_INFORMATION RequestOptions,
  LPVOID ReplyBuffer,
  DWORD ReplySize,
  DWORD Timeout
);

DWORD
SetIpStatistics(
  PMIB_IPSTATS pIpStats
);

DWORD
SetIpTTL(
  UINT nTTL
);

IP address configuration

DWORD
AddIPAddress(
  IPAddr Address,
  IPMask IpMask,
  DWORD IfIndex,
  PULONG NTEContext,
  PULONG NTEInstance
);

DWORD
DeleteIPAddress(
  ULONG NTEContext
);

DWORD
GetIpAddrTable(
  PMIB_IPADDRTABLE pIpAddrTable,
  PULONG pdwSize,
  BOOL bOrder
);

DWORD
IpReleaseAddress(
  PIP_ADAPTER_INDEX_MAP AdapterInfo
);

DWORD
IpRenewAddress(
  PIP_ADAPTER_INDEX_MAP AdapterInfo
);

Network configuration

DWORD
GetNetworkParams(
  PFIXED_INFO pFixedInfo,
  PULONG pOutBufLen
);

Notification

DWORD
NotifyAddrChange(
  PHANDLE Handle,
  LPOVERLAPPED overlapped
);

DWORD
NotifyRouteChange(
  PHANDLE Handle,
  LPOVERLAPPED overlapped
);

Routing

DWORD
CreateIpForwardEntry(
  PMIB_IPFORWARDROW pRoute
);

DWORD
DeleteIpForwardEntry(
  PMIB_IPFORWARDROW pRoute
);

DWORD WINAPI
EnableRouter(
  HANDLE* pHandle,
  OVERLAPPED* pOverlapped
);

DWORD
GetBestInterface(
  IPAddr dwDestAddr,
  PDWORD pdwBestIfIndex
);

DWORD
GetBestRoute(
  DWORD dwDestAddr,
  DWORD dwSourceAddr,
  PMIB_IPFORWARDROW pBestRoute
);

DWORD
GetIpForwardTable(
  PMIB_IPFORWARDTABLE pIpForwardTable,
  PULONG pdwSize,
  BOOL bOrder
);

BOOL
GetRTTAndHopCount(
  IPAddr DestIpAddress,
  PULONG HopCount,
  ULONG MaxHops,
  PULONG RTT
);

DWORD
SetIpForwardEntry(
  PMIB_IPFORWARDROW pRoute
);

DWORD WINAPI
UnenableRouter(
  OVERLAPPED* pOverlapped,
  LPDWORD lpdwEnableCount
);

TCP, UDP

DWORD
GetExtendedTcpTable(
  PVOID pTcpTable,
  PDWORD pdwSize,
  BOOL bOrder,
  ULONG ulAf,
  TCP_TABLE_CLASS TableClass,
  ULONG Reserved
);

DWORD
GetExtendedUdpTable(
  PVOID pUdpTable,
  PDWORD pdwSize,
  BOOL bOrder,
  ULONG ulAf,
  UDP_TABLE_CLASS TableClass,
  ULONG Reserved
);

DWORD
GetOwnerModuleFromTcpEntry(
  PMIB_TCPROW_OWNER_MODULE pTcpEntry,
  TCPIP_OWNER_MODULE_INFO_CLASS Class,
  PVOID Buffer,
  PDWORD pdwSize
);

DWORD
GetOwnerModuleFromTcp6Entry(
  PMIB_TCP6ROW_OWNER_MODULE pTcpEntry,
  TCPIP_OWNER_MODULE_INFO_CLASS Class,
  PVOID Buffer,
  PDWORD pdwSize
);

DWORD
GetOwnerModuleFromUdpEntry(
  PMIB_UDPROW_OWNER_MODULE pUdpEntry,
  TCPIP_OWNER_MODULE_INFO_CLASS Class,
  PVOID Buffer,
  PDWORD pdwSize
);

DWORD
GetOwnerModuleFromUdp6Entry(
  PMIB_UDP6ROW_OWNER_MODULE pUdpEntry,
  TCPIP_OWNER_MODULE_INFO_CLASS Class,
  PVOID Buffer,
  PDWORD pdwSize
);

DWORD
GetTcpStatistics(
  PMIB_TCPSTATS pStats
);

DWORD
GetTcpTable(
  PMIB_TCPTABLE pTcpTable,
  PDWORD pdwSize,
  BOOL bOrder
);

DWORD
SetTcpEntry(
  PMIB_TCPROW pTcpRow
);

DWORD
GetUdpStatistics(
  PMIB_UDPSTATS pStats
);

DWORD
GetUdpTable(
  PMIB_UDPTABLE pUdpTable,
  PDWORD pdwSize,
  BOOL bOrder
);

1.요약

CSocket / CAsyncSocket을 생성한 곳이 아닌 다른 Thread로 넘겨 처리할 경우 CSocket이 가진 Thread state가 변해 에러가 발생합니다.

예를들어 한쪽에서는 Listen을 하여 클라이언트 Socket을 Accept하고, Thread를 생성시켜 Socket전송을 맡길 경우에 Thread문제를 해결하는 방법을 소개하겠습니다.


2.본문

방법은 간단합니다.
Accept한 Socket을 Deatch시키고 거기에서 나온 handle을 Thread로 넘김니다.
그리고 Thread에서 handle을 Attach시켜 CSocket / CAsyncSocket 개체 인스턴스를 만들어 사용하면 됩니다. 

MFC Source HTTP_소스_긁어오기.zip

#include "AFXINET.H"

CInternetSession* pSession = NULL;
CStdioFile* pFile = NULL;
TCHAR szError[1024] = {0};

TRY 
{
  pSession = new CInternetSession;
  pFile = pSession->OpenURL( "http://www.devpia.com" );
}
CATCH( CInternetException, pEx )
{
  pEx->GetErrorMessage( szError, 1024 );
}

END_CATCH

if( pFile != NULL )
{
  //여기서 웹페이지 내용을 가지고 처리
  //HTTP를 호출했을 시
  CHttpFile* pHttpFile = (CHttpFile*)pFile;
  
  /*원하는 코드를 실행한다.*/
  // pHttpFile->ReadString(CString DataType);
  
  delete pHttpFile;
  pHttpFile = NULL;
  pFile = NULL;
}

if( pSession != NULL )
{
  //pSession->Close(); //CInternetSession 소멸자가 알아서 호출함
  delete pSession;
  pSession = NULL;
}

/*
  파라미터를 GET 방식으로 넘기시려면 ...

  CInternetSession::OpenURL()로 접속할 URL과 파라미터 넘겨주면,
  CStdioFile 포인터를 넘겨 주거든요. 그냥 파일 처럼 처리하시면 되겠네요.

  OpenURL("http://localhost/test.asp?name=하나")
  이런 식으로 처리하실 수 있습니다


  파라미터를 POST 방식으로 넘기시려면 ...
  CInternetSession::GetHttpConnection()으로 HTTP 커넥션 맺어 주시고,
  CHttpConnection::OpenRequest()로 URL에 접속해서,
  CHttpFile::AddRequestHeaders()로 헤더와 POST 정보를 추가해서 ...
  CHttpFile::SendRequest()로 데이터 날려 주시면 됩니다.
*/

   옆의 소스는 https 에서 페이지 정보를 얻어오는 함수이다. wininet 을 이용해서 https 의 소스를 얻어올 수 있다곤 하는데 잘 모르겠더라. 계속 검색중 우연히 찾은 사이트에서 얻은 소스이다. 그 홈페이지는 자체 개발한 라이브러리를 이용해서 쉽게 구현하고 있었다.

// Any string unlock the component for the 1st 30-days.이 부분은 뭘 나타내는지 잘 모르겠다.

인터넷에서 mfc https 를 검색하다 우연히 찾아낸 홈페이지.

유용한 정보가 굉장히 많이 들어있다. ㅋㅋ

http://www.example-code.com/mfc/https_get_with_cert.asp

굉장히 좋더라 일단 가보자ㅋㅋ

개 이상의 프로세스가 각각의 공유 자원을 사용하고 있으면서 다른 자원을 요구하여 무한정 대기하는 상태를 교착상태라 하는데 이는 4가지 반드시 필요한 조건이 있다. 다음의 정리 내용을 확인하자.

교착상태가 일어나기 위한 네 가지 조건(하나라도 만족하지 않으면 일어나지 않음)

Critical Section

크리티컬 섹션을 사용하는 이유.

속도가 뮤텍스나 세마포어보다 빠르다.

동기화시 가장 주의할 점은 DeadLock이다

한 프로세스 안에서만 사용이 가능하다.

CRITICAL_SECTION m_CriticalSection;

InitializeCriticalSection( &m_CriticalSection );

DeleteCriticalSection( &m_CriticalSection );

EnterCriticalSection( &m_CriticalSection );

LeaveCriticalSection( &m_CriticalSection );

Mutex

뮤텍스는 크리티컬 섹션과 비슷해서 크리티컬 섹션이 쓰이는 곳에 대신 사용할 수 있다.

그리고 이름을 갖고 있으므로 다른 프로세스에서도 사용이 가능하다.

하지만 속도는 더 느리다.

HANDLE hMutex;

hMutex = CreateMutex( NULL, FALSE, NULL );

ReleaseMutext( hMutex );

WaitForSingleObject( hMutex, INFINITE );

Semaphore

세마포어는 뮤텍스와 유사한 동기화 객체이다. 물론 차이점이 있다. 뮤텍스는 하나의 공유 자원을 보호하기 위해 사용하지만 세모포어는 제한된 일정 개수를 가지는 자원을 보호하고 관리한다. 여기서 자원이라 함은 상당히 추상적이지만 그것이 하드웨어일 수도 윈도우 프로세스, 스레드와 같은 소페트웨어적인 것을 수도 있다.

HANDLE hSemaphore = ( HANDLE )CreateSemaphore( NULL, 3, 3, NULL );

WaitForSingleObject( hSemaphore, INFINITE );

ReleaseSemaphore( hSemaphore, 1, NULL );

HANDLE CreateSemaphore( LPSECURTY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName );

lMaximumCount 는 최대 사용 개수 lInitialCount = 초기값

HANDLE OpenSemaphore( DWORD dwDesiredAccess, BOOL bInheritHandle, LPCTSTR lpName );

OpenSemaphore 함수로 세마포어의 핸들을 구할 수 있다.

OpenSemaphore(SYNCHRONIZE, FALSE, "MySemaphore");

BOOL ReleaseSemaphore( HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount );

자원의 사용이 끝난 스레드는 이 함수를 호출하여 사용 종료를 세마포어에 알려야 한다. lReleaseCount 로 자신이 사용한 자원의 개수를 알리는데 하나만 사용했으면 이 값은 1이고 만약 여러개를 사용했으면 사용한 만큼 자원을 풀어줘야 한다. 세번째 함수는 이전 카운트를 리턴받기 위한 참조 인수이다.

파괴 void CloseHandle( HANDLE );

// 세마포어의 카운트를 조사하는 함수

int RetSemaCount( HANDLE hSema )

{   

int result;

int count;

result = WaitForSingleObject( hSema, 0 );

if( result == WAIT_TIMEOUT )

return 0;

ReleaseSemaphore( hSema, 1, &count );

return count +1;

}