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;
}

클라이언트의 접속을 받아 드릴때 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
);

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

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

TcpListener 생성 및 Start

• IPAddress ipAddress = Dns.GetHostEntry("localhost").AddressList[0];
• TcpListener tcp_Listener = new TcpListener(ipAddress, 3000);
• Tcp_Listener.Start();

• TcpListener 클라이언트 대기

  • TcpClient client = tcp_Listener.AcceptTcpClient();

• 클라이언트가 접속했을 때 NetworkStream으로부터 스트림 얻어내기

  • NetworkStream ns = client.GetStream();
  • StreamReader reader = new StreamReader(ns);
    

• 스트림으로부터 데이터 읽기

  • string msg = reader.ReadLine();

• NetworkStream 으로부터 출력 스트림 생성 및 데이터 기록하기

  • StreamWriter writer = new StreamWriter(ns);
  • writer.WriteLine(msg);
  • writer.Flush();
  • writer.WriteLine(msg);
  • wirter.Flush();

• 스트림 닫기

  • writer.Close();
  • reader.Close();
  • client.Close();

1. TCP/IP 소켓 프로그래밍 with C#
2. 1. 기본 용어 해석
   2. 중요 클래스
   3. 1. IPAddress
      2. IPHostEntry
      3. DNS
      4. TcpClient
      5. EndPoint
         
      6. IPEndPoint
      7. TcpListener
      8. NetworkStream
      9. UdpClient
      10. .Net Socket
      11. SocketException
   4. .NET 입출력 클래스
   5. 넌 블로킹 입출력
   6. 멀티 플렉싱
   7. 스레드
   8. 비동기 입출력
   9. 다중 수신자
   10. 1. 브로드 캐스트
       2. 멀티 캐스트
   11. 연결 종료
   12. 버퍼 교착상태
   13. TCP 소켓 생존 주기
   14. TCP 연결 종료
   15. 디 멀티 플렉스
3. 실무자를 위한 C# 네트워크 프로그래밍
4. 1. C# 프로그램 컴파일및 실행
   2. C# 프로그램 디버깅
   3. 네트워크 트래픽 관리
   4. 1. WinPcap 드라이버
      2. WinDump
      3. Analyzer
   5. 네트워크 패킷 분석
   6. 1. 이더넷 계층
      2. IP 계층
      3. TCP 계층
      4. UDP 계층
   7. IP 주소 정보 찾기
   8. 네트워크 상에서의 데이터 이동
   9. 프로세스
   10. 스레드
   11. 스레드 풀

TCP/IP 소켓 프로그래밍 with C#

기본 용어 해석

컴퓨터 네트워크는 통신 채널로 연결된 많은 기기들로 이루어진다. 이러한 기기들을 호스트(hosts)와 라우터(routers)라 한다.
프로토콜(protocol)이란 통신하는 프로그램 간에 주고받는 패킷의 내용과 방법에 대한 규약.
호스트 간에만 데이터를 전달하는 IP와는 달리 한 프로그램으로부터 다른 프로그램까지의 데이터 전송 전 과정을 관리하므로 TCP와 UDP는 단말간 전송 프로토콜(end-to-end transport protocol)이라고 한다.
TCP는 신뢰 가능한 바이트 스트림 채널(reliable byte-stream channel)을 제공하고 연결 기반(connection-oriented) 프로토콜이기 때문에 통신하는 두 컴퓨터의 TCP 연결이 확립되어야 한다. 이러한 연결의 확립은 통신하는 두 컴퓨터의 TCP 프로토콜 구현간에 핸드쉐이크 메시지(handshake message)를 주고 받는 것으로 이루어진다.

UDP는 이와 반대로 IP에서 발생한 문제들을 복구하려 하지 않는다. 오히려 단순한 IP의 최선형(best-effort) 데이터그램 서비스를 확장하여 어플리케이션 프로그램 간에서도 이 서비스를 이용할 수 있도록 만든다.

이름 해석 서비스(name-resolution service)는 여러 소스로부터 정보를 취합한다. 이러한 소스들 중에는 DNS(domain name system)와 로컬 설정 데이터베이스(local configuration database)가 대표적이다. DNS는 도메인 네임(domain name)을 인터넷 주소와 기타 다른 정보로 매핑하는 분산 데이터 베이스. 로컬 설정 데이터베이스는 일반적으로 운영체제 자체 시스템으로 도메인 네임과 인터넷 주소의 매핑 작업을 로컬에서 수행한다. 윈도우는 hosts텍스트 파일에 unix기반 시스템은 /etc/hosts 파일이 존재한다.

URL(universal resource locator)은 이름을 해석하여 인터넷 주소를 확인한다.
포트(port)는 IANA(Internet Assigned Number Authority)가 잘 알려진 포트(well-known port)를 지정한다.

디렉터리 서비스(directory service)는 클라이언트가 디렉터리 구조를 통해 서버가 제공하는 서비스와 서버 내부의 장소들을 열람하는 서비스.

소켓(socket)란 어플리케이션이 데이터를 주고 받을 수 있는 하나의 추상적인 통로이다. 각 소켓은 프로토콜 집합(protocol suite)과 이 집합내의 여러개의 서로 다른 프로토콜 스택(stack)을 참조하게 된다. 오늘날 TCP/IP에서 사용하는 주요 소켓은 스트림소켓(stream socket)과 데이터그램 소켓(datagram socket)이다. 스트림 소켓은 IP를 근본으로 단말간 프로토콜(end-to-end protocol)로 사용하기 때문에 안정적인 바이트 스트림 서비스를 제공한다. 데이터 그램 소켓은 역시 IP를 근본으로 한 UDP소켓을 단말간 프로토콜로 이용하기 때문에 어플리케이션에서 단일 메시지당 65,500 바이트 길이의 메시지까지 전송할 수 있는 최선형(best-effort) 데이터그램 서비스를 제공한다.

빅엔디언(big-endian)은 최상위 바이트가 가장 먼저 전송되고 최하위 바이트가 가장 나중에 전송되는 순서이다.
대부분의 네트워크 프로토콜에 쓰이는데 네트워크 바이트 오더(network byte order)라고도 한다. 그외 자바(java)와 같은 언어에도 쓰인다.
리틀엔디언(little-endian)은 최상위 바이트가 가장 나중에 전송되고 최하위 바이트가 가장 먼저 전송되는 순서이다.
윈도우 운영체제의 주요 아키텍처인 인텔, AMD, 알파 기반의 컴퓨터는 리틀 엔디언을 사용한다.

중요 클래스

IPAddress

// IP네트워크가 갖는 하나의 인터페이스에 대한 주소를 반환
public IPAddress(long address);

public static short HostToNetworkOrder?(short);
public static int HostToNetworkOrder?(int);
public static long HostToNetworkOrder?(long);
public static short NetworkToHostOrder?(short);
public static int NetworkToHostOrder?(int);
public static long NetworkToHostOrder?(long);

public static IPAddress Parse(string address);
// 도트 표기로 된 스트링 형태의 IP주소를 IPAddress인스턴스로 변환

public static readonly IPAddress Any; // 0.0.0.0
public static readonly IPAddress Broadcast; // 255.255.255.255
public static readonly IPAddress Loopback; // 127.0.0.1

IPHostEntry?

// Dns 클래스의 GetHostByName?(), GetHostByAddress?(), GetHostEntry?()로 반환되는 컨테이너 클래스
public string HostName? { get; set; }
public string[] Aliases { get; set; }
public IPAddress[] AddressList? { get; set; }

DNS

// DNS로 부터 호스트명 또는 IP주소와 관련된 정보를 수집할 수 있는 여러 정적 메소드
public static IPHostEntry? GetHostByAddress?(IPAddress address);
public static IPHostEntry? GetHostByAddress?(string address);
public static IPHostEntry? GetHostByName?(string hostname);
public static string GetHostName?();
public static IPHostEntry? GetHostEntry?(IPAddress address);
public static IPHostEntry? GetHostEntry?(string hostname);

TcpClient?

// 소켓 하위클래스, TCP연결을 통해 다른 호스트와 접속하고, 데이터를 전송하고 수신하는데 사용되는 여러 메소드를 제공
public TcpClient?();
public TcpClient?(IPEndPoint? localEP);
public TcpClient?(string hostname, int port);

public void Close();
public void Connect(IPEndPoint? endpoint);
public void Connect(IPAddress address, int port);
public void Connect(string hostname, int port);
public NetworkStream? GetStream?();

protected Socket Client { get; set; }

public 속성으로 설정 가능한 소켓 옵션
LingerState? // 소켓의 지연시간 설정
NoDelay? // 전송이나 수신 버퍼가 꽉 차지 않을 경우 지연을 방지하는 변수값을 설정
ReceiveBufferSize? // 수신 버퍼의 크기 설정
ReceiveTimeout? // 읽기 작업시 데이터를 수신하기까지 기다리는 시간 설정
SendBufferSize? // 전송 버퍼의 크기 설정
SendTimeout? // 쓰기 작업 시작시 데이터를 송신완료까지 기다리는 시간 설정

EndPoint?

// IPEndPoint?의 추상 클래스

IPEndPoint?

// IP주소와 포트번호 형태로 TCP/IP 엔드 포인트를 나타낸다.
public IPEndPoint?(long address, int port);
public IPEndPoint?(IPAddress address, int port);

public IPAddress Address { get; set; }
public int Port { get; set; }

TcpListener?

// TCP네트워크 클라이언트로부터 들어오는 연결 요청을 대기한다.
public TcpListener?(IPEndPoint? localEP);
public TCpListener?(IPAddress address, int port);

public Socket AcceptSocket?();
public TcpClient? AccepTcpClient?();
public bool Pending(); // 수락 가능한 연결 요청 있을 경우 true
public void Start();
public void Stop();

public EndPoint? LocalEndpoint? { get; }
protected Socket Server { get; }

NetworkStream?

// Stream 클래스의 하위 클래스
public virtual void Close();
public abstract int Read(byte[] buffer, int offset, int length);
public abstract void Write(byte[] buffer, int offset, int length);

public virtual bool DataAvailable? { get; } // 스트림으로부터 읽어들일 데이터가 존재하는 경우 true

UdpClient?

public UdpClient?();
public UdpClient?(int port);
public UdpClient?(IPEndPoint? localEP);
public UdpClient?(string hostname, int port);

public void Close();
public void Connect(IPEndPoint? endpoint);
public void Connect(IPAddress addr, int port);
public void Connect(string hostname, int port);

public byte[] Receive(ref IPEndPoint? remoteEP);

public int Send(byte[] dgram, int length);
public int Send(byte[] dgram, int length, IPEndPoint? endPoint);
public int Send(byte[] dgram, int length, string honstname, int port);

protected Socket Client { get; set; }

.Net Socket

public Socket(AddressFamily?, SocketType?, ProtocolType?);
// TCP 사용시 (Address.Family.InterNetwork?, SocketType?.Stream, ProtocolType?.Tcp)

public Bind(EndPoint? localEP); // 소켓을 결합한다. IPAddress.Any(0,0,0,0)객체와 명시된 포트번호로 구성된 IPEndPoint?인스턴스를 파라미터로 받아서 로컬주소와 포트에 결합한다.
public void Close();
public Connect(EndPoint? remoteEP);
public object GetSocketOption?(SocketOptionLevel?, SocketOptionName?);
public void GetSocketOption?(SocketOptionLevel?, SocketOptionName?, byte[]);
public byte[] GetSocketOption?(SocketOptionLevel?, SocketOptionName?, int);
public void Listen(int backlog); // 연결 요청 큐의 최대 길이
public bool Poll(int microsecond, SelectMode? mode);
// 객체의 상태 확인. SelectMode?.SelectWrite? 쓰기 가능한지 확인, SelectMode?.SelectRead? 읽기 가능한지 확인, SelectMode?.SelectError? 오류 존재 여부 확인

public int Receive(byte[] buffer);
public int Receive(byte[] buffer, SocketFlags? flags);
public int Receive(byte[] buffer, int length, SocketFlags? flags);
public int Receive(byte[] buffer, int offset, int length, SocketFlags? flags);

public int ReceiveFrom?(byte[] buffer, ref EndPoint? remoteEP);
public int ReceiveFrom?(byte[] buffer, SocketFlags? flags, ref EndPoint? remoteEP);
public int ReceiveFrom?(byte[] buffer, int length, SocketFlags? flags, ref EndPoint? remoteEP);
public int ReceiveFrom?(byte[] buffer, int offset, int length, SocketFlags? flags, ref EndPoint? remoteEP);

public static void Select(IList readableList, IList writeableList, IList errorList, int microseconds);

public int Send(byte[] buffer);
public int Send(byte[] buffer, SocketFlags? flags);
public int Send(byte[] buffer, int length, SocketFlags? flags);
public int Send(byte[] buffer, int offset, int length, SocketFlags? flags);

public int SendTo?(byte[] buffer, ref EndPoint? remoteEP);
public int SendTo?(byte[] buffer, SocketFlags? flags, ref EndPoint? remoteEP);
public int SendTo?(byte[] buffer, int length, SocketFlags? flags, ref EndPoint? remoteEP);
public int SendTo?(byte[] buffer, int offset, int length, SocketFlags? flags, ref EndPoint? remoteEP);

public void SetSocketOption?(SocketOptionLevel? optionLevel, SocketOptionName? optionName, byte[] optionValue);
public void SetSocketOption?(SocketOptionLevel? optionLevel, SocketOptionName? optionName, int optionValue);
public void SetSocketOption?(SocketOptionLevel? optionLevel, SocketOptionName? optionName, object optionValue);
/*
SocketOptionLeve? 열거체
옵션이 적용될 계층을 정한다.
IP
Socket
Tcp
Udp

SocketOptionName?
http://dotgnu.org/pnetlib-doc/System/Net/Sockets/SocketOptionName.html

SocketFlags?
DontRoute? 라우팅 테이블을 사용하지 않고 전송한다.
MaxIOVectorLength? 데이터를 전송하고 수신하는데 사용할 WSABUF 구조의 개수에 대한 표준수치를 제공한다.
None
OutOfBand? 대역외(out-of-band) 데이터를 처리한다.
Partial 메시지의 일부를 전송하고 수신할 수 있다.
Peek 현재 수신중인 메시지를 확인한다.
*/

public void Shutedown(SocketShutdown? how);
// 데이터를 전송하고 수신하는 기능을 중단시킨다. SocketShutdown?.Send, SocketShutdown?.Receive, SocketShutdown?.Both

public bool Connected { get; } // 가장 최근 입출력 작업후 객체가 원격 리소스에 연결되어 있는지 나타낸다.
public EndPoint? LocalEndPoint? { get; } // 로컬 엔드 포인트를 가져온다.
public EndPoint? RemoveEndPoint? { get; } // 원격 엔드 포인트를 가져온다.

SocketException?

public override int ErrorCode? { get; } // WinSock? 2.0 에러코드와 일치한다.
public virtual string Message { get; } // 사용자가 읽을 수 있는 오류 메시지

.NET 입출력 클래스

BufferedStream? // 입출력 최적화를 위한 버퍼링을 시행
BinaryReader?/BinaryWriter? // 기본 데이터 타입의 읽기/쓰기를 처리
MemoryStream? // 메모리를 백킹 스토어(backing store)로 하는 스트림을 생성하고, 임시 버퍼와 파일 대용으로 사용할 수 있다.
Stream // 모든 스트림에 대한 기본 추상 클래스
StreamReader?/StreamWriter? // 특정 인코딩을 캐릭터 입출력을 스트림에 대해서 처리
StringReader?/StringWriter? // 특정 인코딩을 캐릭터 입출력을 스트림에 대해서 처리
TextReader?/TextWriter? // 캐릭터 입출력에 대한 기본 추상 클래스로서 StreamReader?/StreamWriter?클래스와 StringReader?/StringWriter?클래스들의 부모클래스이다.

넌 블로킹 입출력

(1) 입출력 상태를 사전에 점검
TcpClient?클래스로부터 데이터를 읽어들이는 과정에서 NetStream?의 DataAvailable?속성이 true이면 읽을 데이터가 존재하는 것
TcpListener? 클래스로부터 Pending()메쏘드 사용하여 AcceptTcpClient?()메소드 또는 AcceptSocket?() 메소드를 호출하기 전에 연결 요청이 있는지를 점검 있으면 true.
Socket 클래스의 int타입의 Available속성을 통해 읽어들일 데이터의 존재 여부 확인. 네트워크로 부터 수신 했지만, 아직 읽어들이지 않은 데이터량을 바이트 단위의 정수로 기억. 즉 Available 속성이 0보다 클 경우 읽기 동작은 블록을 걸지 않는다.

(2) 블로킹 타임아웃 콜
Socket 클래스의 Poll()메소드. 메소드 인자의 시간 만큼 블록하여 요청을 대기한다.
Socket 클래스의 SetSocketOption?()메소드로 타임아웃(timeout)을 설정한다. TcpClient도? ReceiveTimeout? 속성을 통해 타임아웃을 설정할 수 있다.

(3) 넌 블로킹 소켓
Socket 클래스의 Blocking 속성을 false로 변경한다.

멀티 플렉싱

Socket클래스의 Select()메소드
하나이상의 입출력을 대기하는 소켓 목록을 검색한다.
IList 인터페이스형의 소켓목록중 하나 이상의 입출력이 요청되면, 실행시 소켓 목록은 입출력이 준비된 Socket으로 재구성 된다.

스레드

클라이언트 단위 스레드
스레드 풀

비동기 입출력

(1) 작업이 완료된 시점에서 호출할 콜백(callback)메소드를 지정
(2) 주기적으로 폴링(polling)하면서 메소드가 완료했는지를 확인
(3) 비동기 작업을 완료한 이후 전체가 완료되기까지 블록을 걸어 대기

.NET 프레임워크는 매우 유연한 비동기 API를 제공한다.
프레임워크 라이브러리 뿐 아니라 네트워크 입출력, 스트림 입출력, 파일 입출력, DNS룩업 메소드까지 넌 블로킹 형태로 제공한다.
사용자 메소드를 포함해 어떠한 메소드도 비동기 형태로 재구성할 수 있다. !! 이책의 점위를 넘는다-_-

비동기 입출력은
시작 콜(begin call)과 콜의 결과를 취득하기위한 완료 콜(end call)이 있다.
시작및 완료 동작은 대칭 구조를 이루고 있어 각 시작 메소드는 어디에선가 완료 메소드로 대응해야 한다. 이러한 조치를 취하지 않으면 오랫동안 실행하는 프로그램에서 마무리되지 않는 비동기 콜에 대한 상태 관리가 매우 어려워진다. 메모리 릭이나 CPU 독점과 같은 경우가 생긴다는 이야기..

NetworkStream? 클래스의 비동기 형태 Write, Read
public override IAsynResult? BeginRead?(byte[] buffer, int offset, int size, AsyncCallback? callback, object state);
public override IAsynResult? BeginWrite?(byte[] buffer, int offset, int size, AsyncCallback? callback, object state);

public override int EndRead?(IAsyncResult? asyncResult);
public override void EndWrite?(IAsyncResult? asyncResult);

AsyncCallback? ac = new ASyncCallback?(myMethodToCall?);
...
public static void myMethodToCall?(IAsyncResult? result);
{

}

이런 콜백외의 비동기 콜작업은 효용이 없다.

다중 수신자

일대일(one-to-one) 통신을 유니캐스트(unicast)라 한다.
일대다(one-to-many) 서비스에는 브로드캐스트(braodcast)와 멀티캐스트(multicast) 두가지가 있다.
브로드 캐스트는 모든(로컬) 네트워크 호스트가 동일한 메시지를 수신한다.
멀티 캐스트에서는 메시지가 멀티 캐스트 주소(multicast address)로 전송되고 이 메시지를 수신하고자 하는 호스트만이 네트워크를 통해 이 메시지를 수신하게 된다. 일반적으로 브로드캐스트 혹은 멀티캐스트 동작에는 UDP소켓만이 사용가능하다.

브로드 캐스트

로컬 브로드캐스트(local broadcast)주소 (255.255.255.255)는 동일한 네트워크상의 모든 호스트에 메시지를 전달한다.
이더넷(Ethernet) 네트워크 상의 한 호스트는 동일한 이너넷 상의 모든 호스트에게 메시지를 전달할 수 있지만, 메시지는 라우터에 의해서 전달되지는 않는다. IP주소 또는 직접 브로드 캐스트 주소(Direct boradcast address) 를 명시하는데 이는 해당 네트워크상의 모든 호스트에 메시지를 브로드캐스트하지만, 대부분의 인터넷 라우터는 효율의 이유로 브로드캐스트 메시지를 전송하지 않는다.

사용법은 유니캐스트와 같으며 목적지 주소를 브로드캐스트 주소로 변경하면 된다.

멀티 캐스트

멀티 캐스트는 IP설계시부터 지정된 일전 구간(224.0.0.0 ~ 239.255.255.255)의 멀티캐스트 전용구간이 있다.
유니 캐스트와 차이는 해당 주소가 멀티캐스트용이라는 점과 초기 멀티캐스트 데이터그램에 대해서 TTL(Time to Live)값을 설정해야 한다는 점 뿐이다. TTL값은 데이터가 라우터를 지날때 마다 주로 1씩 감소하며 TTL 값이 0이되면 패킷은 제거된다.

SocketOptionName?.MuilticastTimeToLive?옵션에서 TTL을 설정하며
SocketOptionName?.AddMembership?옵션과 SocketOptionName?.DropMembership?옵션과
UdpClient?의 JoinMulticastGroup?()메소드나 DropMulticastGroup?()메소드로 그룹을 가입하거나 탈퇴하여 멀티캐스트 메시지 수신이 가능하다.

그리고 SocketOptionName?.ReuseAddress?을 적용해야 호스트로부터 동시에 두 개이상의 멀티캐스트 메시지를 수신할수 있다.

연결 종료

Close()메소드를 사용해 연결을 종료할 경우 송,수신 버퍼에 남아있는 내용은 전송이 더 이상 불가하고 Exception을 발생시킨다. Shutdown()메소드를 통해 송,수신버퍼 종료 예약을 하고 송수신이 완료됨을 확인후 Close()메소드를 통해 소켓을 종료시키는게 옳다.

버퍼 교착상태

전송및 수신 큐버퍼는 자신이 동작할 수 있는 용량에 제한이 있다.
서로 Send나 Receive상태로 들어가는 경우 데드락 상태로 들어갈수 있지만...
또한 너무 큰 데이터를 순간적으로 주고 받으려 하는 경우 송, 수빈 버퍼 이상의 데이터를 가지게 되면 전송이 완료되기 전까지 블록 상태가 된다.
만약 서버와 클라이언트가 모두 이런 경우가 생긴다면 역시 서로 데드락의 경우가 발생한다.
가장 간단한 해결방법은 송 수신을 하나의 스레드가 아닌 다른 스레드를 통해 송신과 수신을 분리하여 블록 상태가 들어갔을경우 한방향으로 해결이 되도록 유도해야한다.
처음 네트워크 프로토콜을 정의할 때 부터 고려해서 설계 해야한다.

TCP 소켓 생존 주기

TCP 핸드쉐이크는 3방향 핸드쉐이크가 사용된다. 클라이언트로부터 서버로 전송하는 연결요청과 서버가 클라이언트에게 보내는 확인 응답, 그리고 클리어언트가 다시 서버에 보내는 확인 응답이다.
클라이언트의 Connect()는 두번째 핸드쉐이크가 완료될 경우에 연결 확립이 된다. 서버의 Accept*()의 경우 원래 소켓과는 다른 새로운 소켓을 생성하여 세번의 핸드쉐이크가 완료되면 연결이 확립되고 원래의 소켓은 다시 클라이언트를 대기하게 된다.

TCP 연결 종료

전송 버퍼에 데이터가 남아있는데 그대로 프로그램을 종료할 경우 프로그램이 알지 못하는 상황에서 데이터 손실이 생긴다.
Shutdown()이나 Close()를 통해 종료 핸드쉐이크 교환후 종료해줘야한다.
프로토콜 설계시 Close()메소드를 먼저 호출하는 쪽에서 데이터 수신 여부를 확인후 종료 메소드를 호출하여 Shutdown(옵션)을 통해 Receive, Send를 하나씩 종료해주면 된다.

SocketOptionName?.Linger 은 Close()메소드가 종료 핸드쉐이크를 완료되기를 대기하면 반환하지 않는 시간을 제어한다. 타임아웃을 초단위로 설정한다.

TCP연결을 종료하는데 있어 시간 대기 상태(Time-Wait State)가 있다.
소켓 종료후 네트워크상 똑같은 소켓으로 다시 생성이 되어 전송을 하여 이전 소켓으로 전송된 데이터가 네트워크상 딜레이 있을 경우 어느 소켓에서 발생된 데이터인지 오인이 생길수 있다.
이 대기 시간(quiet time)은 구현에 따라 다르게 설정되는데 적게는 30초에서 4분까지가 된다.(패킷이 네트워크상 존재할 수 있는 최대 시간의 두배)
윈도우는 4분이 기본값이다.
문제는 같은 포트로 소켓을 생성할 수 없다는 점이다. ErrorCode? 값이 10048에 해당하는 Exception을 발생시킨다.

디 멀티 플렉스

실무자를 위한 C# 네트워크 프로그래밍

C# 프로그램 컴파일및 실행

C# 컴파일러
csc (C Sharp Compiler)
커맨드 옵션
/out:filename
/main:classname
/target:target(winexe, dll, module, ...)
/debug : type (실행중인 프로세스에 디버거를 붙이는 기본(full)형식 또는 디버깅 툴에서 접근할 수 있는 .pdb형식인 pdbonly
/resource : resource

C# 프로그램 디버깅

컴파일시 실행파일에 속성변수를 설정함으로 CLR JIT컴파일러로 하여금 코드를 추적하게 만들고, 이로써 디버거에서 참고할 추적 정보를 기록할 프로그래머 데이터베이스(PDB : Programmer DataBase?) 파일을 생성하게된다.
여기서 설정되는 속성 변수는 JITTracking 플래그라 부른다. 이 플래그는 컴파일러로부터 생성된 네이티브 코드를 MSIL명령어로, 또 이 명령어를 결국 원래의 소스 코드로 디컴파일해야 한다는 정보를 CLR JIT컴파일러에 전달한다. 이 모든 정보는 실행 파일에 대한 PDB 파일에 저장된다.

dbgclr (GUI 디버거)
visual studio와 유사한 형식

cordbg (커맨드라인 디버거)
s 소스 코드 한 개 라인을 실행
si 소스 코드 한 개 라인을 실행
so 소스 코드 한 개 라인을 건너뜀
ss 다음 네이티브 또는 IL 명령을 실행
p <arg> 변수 현재 값을 출력
pro 프로그램 실행에 대한 시스템 프로세스 정보를 출력
reg 현재 쓰레드에 대한 CPU 레지스터 정보 출력
run <prog> 디버거에서 prog 프로그램을 실행
break 소스에 브레이크지점 설정 또는 출력
sh 현재 실행중인 코드 라인과, 전후 5개 라인을 출력

IL DASM(Microsoft Intermediate Language Disassembler)

네트워크 트래픽 관리

WinPcap? 드라이버

Politecnico di Torino 의 NetGroup?팀이 개발한 모든 윈도우즈 시스템에서 네트워크 패킷을 수집할 수 있도록 설계.

WinDump?

커맨드 라인 옵션
-a 네트워크와 브로드캐스트 주소를 네임으로 변경
-B size 수신 버퍼 크기를 size로 수정
-c count 패킷을 count만큼만 수집
-D 시스템에서 사용가능한 모든 네트워크 인터페이스를 표시
-e 각 출력줄에 링크 레벨의 정보를 출력
-F file File 파일에 정의된 필터를 적용
-i interface interface네트워크를 모니터링 하는데, interface는 인터페이스 이름 혹은 ?D 명령어로 지정된 인터페이스 번호가 될 수 있다.
-n 주소를 이름으로 변화하지 않도록 설정
-N FQDN(Fully Qualified Domain Name)을 출력하지 않도록 설정
-q 간단한 형태로 패킷 정보를 출력
-r file 덤프 파일 file로부터 패킷을 읽어들임
-S 절대 TCP일련 번호를 출력
-s snaplen 패킷으로 부터 snaplen 만큼의 바이트를 수집. 기본 수치는 68이다.
-t 각 라인에 시간을 출력하지 않음
-w file 결과를 file에 출력
-X 각 패킷을 hex형태와 ASCII형태로 출력
-x 각 패킷을 hex형태로 출력

필터 조건문 적용
windump ip // 네트워크에 흐르는 ip패킷만을 수집
windump ip host 203.241.228.251 // 특정 ip주소로부터 오가는 네트워크 패킷 수집
windump ip src 203.241.228.251 // 특정 ip주소로부터 오는 네트워크 패킷 수집
windump ip host 203.241.228 // 특정 서브넷으로부터 오가는 패킷 수집

Analyzer

GUI사용. 사용 권유.

네트워크 패킷 분석

네트워크 패킷 구성

이더넷 계층

이더넷 헤더(Ethernet header)는 이더넷 802.2, 이더넷 802.3 그리고 이더넷 버전 2의 세가지 종류의 이더넷 패킷이 있따.
이더넷 802.2, 이더넷 802.3은 IEEE 표준 프로토콜로서 이더넷 계층의 트래픽을 위해서 정의되었다.
이더넷 버전 2는 표준 프로토콜은 아니지만, 이더넷 네트워크에서 가장 흔하게 쓰이는 레거시(legacy) 프로토콜이다. 원도우즈 시스템을 포함해서 거의 모든 장치들은 기본적으로 IP패킷을 전송하는데 이더넷 2프로토콜을 사용한다.

이더넷 헤더
6바이트 길이의 목적지 이더넷(혹은 MAC) 주소 // 3바이트의 벤더 식별자, 또는 OUIO(Orgranizationally Unique Identifier) 와 3바이트 길이의 벤더만의 고유 장치 일련 번호. IANA(Internet Assigned Numbers Authority)가 각 벤더의 MAC주소를 지정.
6바이트 길이의 소스 이더넷(혹은 MAC) 주소
2바이트 길이의 다음 계층 프로토콜 식별자 // IP는 0800
46에서 1500바이트 길이의 데이터 요약 정보(data payload) // 최소 46바이트야 최소 이더넷 의 길이가 64바이트로 맞춰진다.
4바이트 길이의 체크섬(checksum)

IP 계층

IP필드	비트	설명
Version	4	IP헤더 버전 형식(현재 버젼은 4)
Header Length	4	IP 패킷 헤더의 길이(단위 : octet)
Type of Service	8	패킷에 적절한 서비스 품질(Qulity of Service) 종류 (실시간 서비스가 많아 짐에 따라 높은 품질을 설정하기도 한다.)
Total Length	16	IP패킷 전체의 길이(단위 : octet)
Identification	16	IP패킷의 고유 식별 ID
Flags	3	패킷의 분할(fragmentation) 여부 및 추가 단편 존재 여부를 나타내는 플래그(항상0의값의 Reserved 플래그|IP패킷이 분할되지 않았다는 것을 나타내는 Don't Fragment(DF)플래그|IP패킷이 분할되었으며, 다른 분할된 단편들이 도착할 것임을 나태내는 More Fragment(MF)플래그)
Flagment offset	13	IP패킷 내의 분할/ 단편의 위치
Time to Live(TTL)	8	패킷이 네트워크 내에서 소멸하지 않고 유지될 수 있는 최고 시간(단위 : 초)
Protocol	8	다음 데이터 계층의 프로토콜 타입 (1:ICMP, 2:IGP, 6:TCP, 8:EGP, 9:CiscoIGP, 17:UDP, 99 CiscoEIGRP)
Header Checksum	16	IP헤더 데이터에 대한 체크섬
Source Address	32	소스 장치의 IP주소
Destination Address	32	목적지 장치의 IP주소
Options	가변	IP패킷 속성을 나타내는 기타 필드

주소 필드

DDN(Dotted Decimal Notaion)으로 표현하면

TCP 계층

중요한 기능
장치 간에 복수 연결 세션 추적 (소스포트와 목적지 포트)
패킷 오더(순서)의 추적과 잃어버린 패킷에 대한 재전송 요청(일련 번호및 승인 번호)
두 장치간의 연결 스트림을 열고 닫는 기능(TCP플래그)

TCP 세션은
Opening handshake

• 3 방향 핸드 쉐이크 (three-way handshake)
• 소스 호스트는 세션의 시작을 알리기 위해 Syn 플래그를 전송한다.
• 목적지의 호스트는 SYN플래그와 ACK플래그를 같은 플래그에 담아 세션의 시작에 동의 하겠다는 응답을 전송한다.
• 소스 호스트는 다시 ACK플래그를 전송하여 세션을 확립하고 패킷을 대기한다.

Session communication

Closing handshake

• 3 방향 핸드 쉐이크 (three-way handshake)
• 세션을 닫고자 하는 호스트 측에서 FIN플래그를 전송한다.
• 수신측의 호스트는 ACK플래그와 FIN플래그를 같은 패킷에 담아 세션의 종료에 동의하겠다는 응답을 전송한다.
• 처음의 호스트는 다시 ACK플래그를 전송하여 정식으로 세션을 종료한다.

TCP 연결 상태

UDP 계층

IP통신에 자주 사용되는 또 하나의 하이레벨 프로토콜이다. TCP와는 달리 UDP는 데이터를 전송하는 네트워크 장치간에 비연결(connectionless) 전송경로가 있어
세션 확립 플래그와 연결 상태 등과 관련된 오버헤드가 그다지 많지 않다. (TCP헤더 20바이트, UDP헤더 8바이트) 각 UDP세션은 일방향으로 전송되는 단 한개의 패킷에 지나지 않는다.

IP 주소 정보 찾기

1. IPConfig 사용
2. 레지스트리 사용
3. WMI 사용 (Windows Management Instrumentation)

마이크로소프트가 구현한 Web-Based Enterprise Management(WBEM)의 한종류 이다. WBEM은 Distributed Management Task Force. Inc(DMTF) 에서 개발한 것으로 네트워크 환경에서 시스템 정보를 접근하는 표준
윈도우 2000이후, 지원하고 이전 윈도우즈는 WMI Software Developers Kit 를 통해 WMI 시스템을 별도로 설치 할 수 있다. (http://www.microsoft.com/downloads/search.asp?로 부터 다운)

WMI 내에 있는 WMI Win32_NetworkAdapterConfiguration? 표는 시스템에서 설치된 네트워크 장치와 관련된 정보를 기록하고 있다.

using System.Management; 

... 

ManagementObjectSearcher query = new ManagementObjectSearcher("SELECT * FROM Win32_NetworkAdapterConfiguration WHERE IPEnabled = 'TRUE'"); 

ManagementObjectCollection queryCollection = query.Get(); 

foreach(ManagetmentObject mo in queryCollection) 

{ 

 ... 

 Console.WriteLine( (string[])mo["IPAddress"] ); 

}

네트워크 상에서의 데이터 이동

C# 바이너리 데이터 타입

BitConverter? Class

public static byte[] GetBytes([TYPE] value); // 특정 타입을 바이트 배열로 반환 

public static [TYPE] To[TYPE](byte[] value, int startIndex); // 바이트를 특정 타입으로 변환 

 

// string형은 Encoding 클래스의 Encoding.ASCII.GetString()함수 사용

Buffer Class // 기본 형식 배열을 조작

public static void SetByte(Array array, int index, byte value); // 배열 특정 위치의 값을 변경 

public static void BlockCopy(Array src, int srcOffset, Array dst, int dstOffset, int count); // 배열의 블록 단위 복수

프로세스

Process class

public static Process GetCurrentProcess(); 

 

public static Process[] GetProcesses(); // 실행중인 프로세스 전부를 찾는다. 

 

public static Process GetProcessById(int); // 실행중인 프로세스 찾기 

public static Process[] GetProcessesByName(string); // 실행중인 프로세스 찾기 

 

public static Process Start(string); // 오버로드 되어있음. 프로그램 이름으로 실행하는 방법외에 인자 넣을수도 있고 ProcessStartInfo 클래스에 정보 채워서 실행 가능. 

public void Kill(); // 프로세스 강제 종료 

public bool CloseMainWindow(); // 메인 윈도우에 닫기 메시지를 전송하여 종료를 권유. 메인 윈도우가 없거나 모달 대화상자일경우 실패하기도 한다. 

public void Close(); // 프로세스 종료. 강제 종료가 아니라 연결된 리소스 전부를 해제후 종료. 

스레드

Thread class

Process 클래스의 속성을 통해 Collection을 얻어온다. 

public ProcessThreadCollection Threads {get;} 

public Thread(ThreadStart start); //스레드 생성자 델리게이트형 ThreadStart를 요구한다. 

 

public delegate void ThreadStart(); // 실행할 스레드 메소드를 지정한다. 

 

public void Start(); 

public Thread(ParameterizedThreadStart start); // ParameterizedThreadStart로 등록하면  

 

[ComVisibleAttribute(false)]  

public delegate void ParameterizedThreadStart(Object obj); 

 

public void Start(Object state); // 스레드에 Object형 매개변수를 전달할 수 있다. 

스레드 풀

ThreadPool? class
작업 항목 게시, 비동기 I/O 처리, 다른 스레드 대신 기다리기 및 타이머 처리에 사용할 수 있는 스레드 풀을 제공합니다.

생성자가 없고 모든 메소드는 정적이다.
메소드가 호출되면 운영체제는 자동으로 스레드 풀을 생성하고 25개의 스레드가 등록 가능한 상태가 된다.
타이머 큐 타이머와 등록된 대기 작업도 스레드 풀을 사용된다.
타이머 큐 타이머와 등록된 대기 작업의 콜백 함수는 스레드 풀에 대기하게 된다.
스레드 풀에 있는 스레드에서 작업 항목을 처리하도록 요청하려면

public static bool QueueUserWorkItem(WaitCallback callBack); 

public static bool QueueUserWorkItem(WaitCallback callBack, Object state); 

 

[Serializable] 

public delegate void WaitCallback(object state); 

 

사용예) 

ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc)); 

ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc,state));

를 호출하여 사용하게된다. 작업항목을 큐에 대기시킨 후에는 취소할 수가 없다.

이하 시스템 프로그래밍 관련 부분...

// 제한 시간(밀리초)에 부호 있는 32비트 정수를 사용하여 WaitHandle을 기다리는 대리자를 등록합니다. 

public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle, WaitOrTimerCallback, object, int, bool); 

 

// WaitHandle 클래스 

공유 리소스에 대한 단독 액세스를 기다리는 운영 체제 관련 개체를 캡슐화합니다

 EditText of this page (last modified 2008-11-05 11:01:00)
FindPage by browsing, searching, or an index
Or try one of these actions: DeletePage, DeleteUploadedFile, LikePages, SpellCheck, UploadFile

Socket Programming

-------
소켓
-------
소 켓 이란? 두 프로그램이 네트워크를 통해 서로 통신을 수행 할 수 있도록 양쪽에 생성 되는 링크의 단자이다. 두 소켓이 연결되면 서로 다른 프로세스끼리(프로세스가 원격에 있든지 로컬에 있든지 상관 없다.) 데이터를 전달 할 수 있다. 결국 소켓이 구현됨으로써 네트워크 및 전송 계층의 캡슐화가 가능해 졌다.

소켓은 원래 캘리포니아 버클리 대학 분교에서 UNIX 용으로 개발 되었으며 유닉스에서의 입출력 메소드의 표준인 개방/읽기/쓰기/닫기 메커니즘을 따른다.

-------
소켓 형식
-------
1.        스트림 소켓
스 트림소켓은 양방향으로 바이트 스트림을 전송 할 수 있는 연결 지향형 소켓으로 양쪽 어플리케이션이 모두 데이터를 주고 받을 수 있다는 것을 의미 한다. 스트림소켓은 오류수정, 전송처리, 흐름제어 등을 보장 해 주며 송신된 순서에 따른 중복되지 않은 데이터를 수신 하게 된다. 이 소켓은 각 메시지를 보내기 위해 별도의 연결을 맺는 행위를 하므로 약간의 오버헤드가 존재 한다. 그러므로 소량의 데이터 보다는 대량의 데이터를 보내는 경우에 적당 하다. 스트림소켓은 이러한 품질의 통신을 수행 하기 위하여 TCP 프로토콜을 사용 한다.

2.        데이터그램 소켓
명시적으로 연결을 맺지 않으므로 비 연결형 소켓이라고 한다. 메시지는 대상 소켓으로 전송되며 대상 소켓은 메시지를 적절히 수신 한다. 스트림 소켓을 사용하는 것이 데이터그램 소켓을 사용 하는 것 보다 더 신뢰성이 높은 방법이지만 연결을 수립하는데 드는 오버헤드는 무시 할 수 없다. 데이터그램 소켓을 사용하려면 클라이언트에서 서버로 데이터를 전송 할 때 UDP를 사용 한다. 이 프로토콜에서는 메시지의 크기에 약간의 제한이 있으며 메시지의 확실 한 전달 역시 보장 하지 않으며 통신 중 데이터를 잃어 버리더라도 오류를 되돌리지 않는다.
3.        Raw 소켓
Raw 소켓은 패킷을 가져오면 TCP/IP 스택상의 TCP, UDP 계층을 우회하여 바로 애플리케이션으로 송신하는 소켓이다. 이런 소켓에서 패킷은 TCP/IP 필터를 통해 전달 되지 않으므로 원형 그대로의 패킷을 볼 수 있다. 이는 모든 데이터를 적절히 처리하거나 헤더를 제거하고 이를 파싱 하는 과정은 모두 수신 애플리케이션에서 담당해야 하는 것이다. 실제 Raw 소켓을 이용하여 프로그래밍을 하는 일은 거의 드물며 만약 시스템 소프트웨어나 패킷을 분석하는 프로그램을 개발 시에는 필요 할 수도 있다. 즉 Raw Socket은 저수준 프로토콜 애플리케이션을 작성 할 때 주로 사용 된다고 보면 된다.


---------
포트
---------
여 러 개의 애플리케이션들이 동시에 통신을 수행하기 위하여 포트가 정의 되는데 기본적으로 포트는 IP 주소 표기를 확장 하는 개념 이다. 네트워크에서 패킷을 수신하는 애플리케이션이 동시에 실행 되고 있는 컴퓨터로 연결을 맺을 때 송신자가 알고 있는 수신 애플리케이션의 고유 포트 번호를 이용하여 대상 프로세스를 식별 하는 것이다.

소켓 번호는 컴퓨터의 IP 주소와 TCP 애플리케이션에서 사용하는 포트 번호로 이루어져 있다. IP주소는 인터넷 상에서 유일 하고 포트 번호는 개별 컴퓨터에서 유일하기 때문에 전체 인터넷에서 소켓 번호 또한 유일 한 것이다.

-----------------------
.NET 에서 소켓 다루기
-----------------------
System.Net.Sockets 네임스페이스의 클래스들은 .NET에서 지원하는 소켓들을 제공 한다.

System.Net.Sockets.MulticastOption : IP 멀티캐스트 그룹에 참여 하거나 탈퇴하기 위한 IP 주소 값을 설정 한다.

System.Net.Sockets.NetworkStream : 데이터를 주고 받는 하위 스트림을 구현 한다. 이는 TCP/IP 통신 채널에 대한 연결을 나타내는 고수준 추상형이다. 이 클래스를 이용하여 네크워크 소켓을 통해 데이터를 주고 받을 수 있다. NetworkStream은 버퍼 기능이 지원되지 않으므로 BufferedStream을 중간 저장 매체로 함께 사용 하기도 한다.
System.Net.Sockets.TcpClient : Socket 클래스를 기반으로 하여 작성 되었으며 고수준 TCP 서비스를 제공하여 준다.

System.Net.Sockets.TcpListener : Socket 클래스를 기반으로 작성 되었으며 서버 애플리케이션에서 사용 한다.이 클래스는 들어오는 클라이언트의 연결을 리스닝 하며 애플리케이션에게 연결된 요청을 알려 준다.

System.Net.Sockets.UdpClient : UDP 서비스를 구현하기 위한 클래스

System.Net.Sockets.SocketException : 소켓에서 오류가 존재할 때 발생하는 예외

System.Net.Sockets.Socket : 소켓 애플리케이션의 기본 기능을 제공 한다.


------------------------
System.Net.Sockets.Socket
------------------------
Socket 클래스는 네트워크 프로그래밍에서 중요한 역할을 담당 하는데 클라이언트와 서버 사이의 모든 동작을 수행 한다.윈도우 소켓 API의 해당 하는 메소드로 매핑 된다.

아래는 몇 가지 속성 이다.

AddressFamily : 소켓의 주소 계열을 획득, Socket.AddressFamily 열거형의 값 이다.
Available : 읽을 수 있는 데이터 량을 Return
Blocking : 소켓이 블로킹 모드 인지 확인
Connected : 소켓이 원격 호스트에 연결 되어 있는 지
LocalEndPoint : 로컬 종점을 돌려 줌
ProtocolType : 소켓의 프로토콜 형식을 돌려 준다.
SocketType : 소켓의 타입을 돌려 준다.

아래는 몇 가지 메소드 이다.
Accept() : 들어오는 연결을 다루기 위한 새로운 소켓을 생성
Bind() : 들어오는 연결을 리스닝 하기 위하여 소켓을 로컬종점으로 연결
Close() : 소켓을 종료
Connect() : 원격 호스트에 연결을 맺는다.
Listen() : 리스닝 상탸로 만든다, 이것은 서버 소켓에서만 사용 된다.
Receive() : 연결된 소켓으로부터 데이터를 수신 한다.
Send() : 연결된 소켓으로 데이터를 송신 한다.
Shutdown() : 소켓에 대한 연결을 비 활성화 한다.

----------------------

Server Socket 작성 하기

----------------------

1. 소스 코드를 작성 하기 전에 우선 전체적인 코드를 개략적으로 이해 하기로 하자 .

우선 서버의 입장에서 로컬 종점을 생성 한다 . 리스닝을 위한 소켓을 열기 전에 로컬 종점 주소를 작성 해야 하며 서비스에 대한 종점을 생성 하기 위해 호스트의 IP 주소와 서비스의 포트 번호를 조합하여 TCP/IP 서비스의 고유 주소를 정의 한다 . Dns 클래스는 로컬네트워크 기기에서 지원하는 네트워크 주소에 대한 정보를 되돌려 주는 메소드를 제공 한다 . 로컬 네트워크 기기가 하나 이상의 네트워크 주소를 가지거나 로컬 시스템이 하나 이상의 네트워크 기기를 지원 한다면 Dns 클래스는 모든 네트워크 주소에 대한 정보를 되돌려 주며 애플리케이션은 아 배열에서 적절한 주소를 선택해야 한다 .

// 소켓에 사용할 종점을 설정

IPHostEntry ipHost = DNS.Resolve(“localhost”);

IPAddress ipAddr = ipHost.AddressList[0];

IPEndPoint ipEndPoint = new IPEndPoint(ipAddr, 11000);

2. 다음은 Socket 클래스의 새로운 인스턴스를 이용하여 스트림소켓을 생성 한다 . 이미 리스닝에 사용 할 로컬 종점을 작성 하였으므로 바로 소켓을 생성 할 수 있다 .

//TCP/IP 소켓을 생성

Socket sListener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

AddressFamily 열거형은 Socket 인스턴스가 주소를 해석 하기 위해 사용하는 주소 스키마를 나타낸다 . 몇 가지 값들은 아래와 같다 .

AddressFamily.InterNetwork : IP 버전 4 주소

AddressFamily.InterNetwork V6: IP 버전 6 주소

AddressFamily.Ipx : IPX/SPX 주소

AddressFamily.NetBios: NetBios 주소

SocketType 은 TCP 와 UDP 소켓을 구분 하는데 이용 가능한 값은 아래와 같다 .

SocketType.Dgram : 데이터그램을 지원 , Dgram 은 Udp ProtocolType 과 AddressFamily.InterNetwork 와 함께 사용되어야 한다 .

SocketType.Raw : Raw Socket

SocketType.Stream : 스트림 소켓을 지원 , Stream 은 Tcp ProtocolType 과 AddressFamily.InterNetwork 와 함께 사용되어야 한다 .

세번째 파라미터 , 네번째 파라미터는 소켓에 필요한 프로토콜 형식을 정의 한다 . 그 값은 아래와 같다 .

Raw : Raw 패킷 프로토콜

Tcp : TCP

Udp : UDP

Ip : Internet Protocol

•  다음 단계는 Bind() 메소드를 사용하여 소켓에 이름을 부여 한다 . 생성자를 이용하여 소켓을 개방하면 소켓에 아무런 이름도 할강되어 있지 않다 . 즉 Bind() 메소드를 통해 소켓을 Local 종점에 연결 시키는 것이다 .

try {

sListener.Bind(ipEndPoint);

•  이제 소켓이 생성 되었고 , 이름이 바인딩 되었으므로 Listen() 을 사용하여 들어오는 연결에 대해 리스닝을 수행 할 수 있다 . 이때 파라미터에는 큐에 대기중인 연결의 최대 개수를 지정 한다 .

sListener.Listen(10);

•  위에서 리스닝을 했으므로 이젠 Accept() 를 이용하여 클라이언트의 연결을 수신하여 클라이언트와 서버의 이름 연결을 완료 한다 . Accept() 메소드는 대기중인 요청 큐로 부터 먼저 들어온 연결을 가지고 와 이를 처리할 새로운 소켓을 생성 한다 . 새로운 소켓이 생성 되었다고 하더라도 원래 소켓은 계속 리스닝을 수행 하므로 복수의 클라이언트 요청을 처리하기 위해서는 멀티쓰레드를 사용 한다 .

while(true) {

...

Socket handler = sListener.Accept();

•  Send(), Receive() 메소드를 이용하여 데이터를 보내고 , 받는다 .

string data = null;

while(true) {

byte[] bytes = new byte[1024];

// 클라이언트로부터 수신된 데이터

int byteRes = handler.Receive(byte);

// 바이트를 문자열로 변환

data += Encoding.Default.GetString(bytes, 0, byteRec);

// 메시지의 끝인지 확인

if (data.IndexOf(“”) > -1) {

break;

}

}

•  루프를 빠져 나온 후 클라이언트에게 응답을 돌려주기 위해 새로운 바이트 배열을 준비 한다 . 변환을 마친 후 Send() 메소드를 이용하여 데이터를 보내자

string theReply = “Thank you for those ” + data.Length.ToString() + “ characters …”;

byte[] msg = Encoding.Default.GetBytes(theReply);

handler.Send();

•  서버와 클라이언트의 데이터 교환이 끝나면 Close() 를 이용하여 소켓을 종료 한다 . 항상 Close() 를 하기 전에 Shutdown() 을 이용하여 남아 있는 데이터를 확실히 제거 하자 . 각 소켓 인스턴스 마다 Close() 메소드를 호출 해야 한다 .

handler.Shutdown(SocketShutdown.Both);

handler.Close();

SocketShutdown 값은 열거형으로 아래와 같은 값을 취한다 .

Both : 송 . 수신용 소켓 모두

Receive : 수신용

Send : 송신용 소켓

소스 코드는 아래와 같다 .[SocketServer.cs]

using System;

using System.Net.Sockets;

using System.Net;

using System.Text;

public class SocketServer

{

public static void Main (string [] args)

{

// establish the local end point for the socket

IPHostEntry ipHost = Dns.Resolve("localhost");

IPAddress ipAddr = ipHost.AddressList[0];

IPEndPoint ipEndPoint = new IPEndPoint(ipAddr, 11000);

// create a Tcp/Ip Socket

Socket sListener = new Socket(AddressFamily.InterNetwork,

SocketType.Stream, ProtocolType.Tcp);

// bind the socket to the local endpoint and

// listen to the incoming sockets

try

{

sListener.Bind(ipEndPoint);

sListener.Listen(10);

// Start listening for connections

while (true)

{

Console.WriteLine("Waiting for a connection on port {0}",ipEndPoint);

// program is suspended while waiting for an incoming connection

Socket handler = sListener.Accept();

string data = null;

// we got the client attempting to connect

while(true)

{

byte[] bytes = new byte[1024];

int bytesRec = handler.Receive(bytes);

data += Encoding.ASCII.GetString(bytes,0,bytesRec);

if (data.IndexOf("") > -1)

{

break;

}

}

// show the data on the console

Console.WriteLine("Text Received: {0}",data);

string theReply = "Thank you for those " + data.Length.ToString()

+ " characters...";

byte[] msg = Encoding.ASCII.GetBytes(theReply);

handler.Send(msg);

handler.Shutdown(SocketShutdown.Both);

handler.Close();

}

}

catch(Exception e)

{

Console.WriteLine(e.ToString());

}

} // end of Main

}

----------------------

Client Socket 작성 하기

----------------------

1. 클라이언트 코드가 서버와 다른 점은 Connect() 메소드 부분이다 . 이것은 클라이언트가 원격의 서버에 연결 하고자 할 때 사용하는 메소드 이다 . 사용하기 위해서는 우선 원격 종점을 설정 해야 한다 .

// 소켓에 사용할 원격 종점을 설정

IPHostEntry ipHost = DNS.Resolve(“127.0.0.1”);

IPAddress ipAddr = ipHost.AddressList[0];

IPEndPoint ipEndPoint = new IPEndPoint(ipAddr, 11000);

Socket sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

sender.Connect(ipEndPoint);

Connect() 메소드로 소켓을 종점 파라미터로 지정된 원격 호스트와 연결을 맺는다 . 일단 연결이 이루어 지면 데이터를 보내고 받을 수 있다 .

string theMessage = “This is a test”;

byte[] msg = Encoding.Default.GetBytes(theMessage+””);

// 소켓을 이용하여 데이터를 보냄

int bytesSend = sender.Send(msg);

…

// 원격으로부터 ( 서버 ) 응답을 수신

int bytesRec = sender.Receive(bytes);

…

이젠 마지막으로 Shutdown() 을 호출하여 소켓을 해제 한다 . 그리고 Close() 하자

sender.Shutdown(SocketShutdown.Both);

sender.Close();

[ 아래는 SocketClient.cs 의 소스 파일 이다 .]

using System;

using System.Net.Sockets;

using System.Net;

using System.Text;

public class SocketClient

{

// If you specify any text as a command-line argument, it will be sent to the server.

// e.g. SocketClient "Send this text" will send that string

// If no command-line arguments are specified, a default string is sent

public static void Main (string [] args)

{

// data buffer for incoming data

byte[] bytes = new byte[1024];

// connect to a Remote device

try

{

// Establish the remote end point for the socket

IPHostEntry ipHost = Dns.Resolve("127.0.0.1");

IPAddress ipAddr = ipHost.AddressList[0];

IPEndPoint ipEndPoint = new IPEndPoint(ipAddr, 11000);

Socket sender = new Socket(AddressFamily.InterNetwork,

SocketType.Stream, ProtocolType.Tcp);

// Connect the socket to the remote endpoint. Catch any errors

sender.Connect(ipEndPoint);

Console.WriteLine("Socket connected to {0}",

sender.RemoteEndPoint.ToString());

//string theMessage=Console.ReadLine();

string theMessage;

if (args.Length==0)

theMessage = "This is a test";

else

theMessage = args[0];

byte[] msg = Encoding.ASCII.GetBytes(theMessage+"");

// Send the data through the socket

int bytesSent = sender.Send(msg);

// Receive the response from the remote device

int bytesRec = sender.Receive(bytes);

Console.WriteLine("The Server says : {0}",

Encoding.ASCII.GetString(bytes,0, bytesRec));

// Release the socket

sender.Shutdown(SocketShutdown.Both);

sender.Close();

}

catch(Exception e)

{

Console.WriteLine("Exception: {0}", e.ToString());

}

}

}