끄적끄적

IPC별 특성 

예제를 보면 CreatePipe함수를 호출하는 프로세스가 파이프의 읽고 쓰는 핸들을 모두 가지고 있다. 

이름없는 파이프는 부모 자식 프로세스간 에만  통신이 가능하다고 위에 나왔다.

 부모 프로세스는 자식 프로세스에 핸들을 상속 할 수 있기에 자식프로세스에 핸들을 상속하여  통신이 가능하다.

이름있는 파이프 프로그래밍 모델

1. CreateNamedPipe 함수에 의해 생성

2. ConnectNamedPipe 함수에 의해 연결 대기 상태로 전환

3. Client의 CreateFile 함수 호출에 의한 파이프 오픈

예제 8-2

이름있는파이프 서버

#include <stdio.h>

#include <stdlib.h>

#include <windows.h> 

#define BUF_SIZE 1024

int CommToClient(HANDLE);

int _tmain(int argc, TCHAR* argv[]) 

{

LPTSTR pipeName = _T("\\\\.\\pipe\\simple_pipe"); 

HANDLE hPipe;

while(1)

{

  hPipe = CreateNamedPipe ( 

  pipeName,            // 파이프 이름

  PIPE_ACCESS_DUPLEX,       // 읽기,쓰기 모드 지정

  PIPE_TYPE_MESSAGE |

  PIPE_READMODE_MESSAGE | PIPE_WAIT,

  PIPE_UNLIMITED_INSTANCES, // 최대 인스턴스 개수.

  BUF_SIZE,                  // 출력버퍼 사이즈.

  BUF_SIZE,                  // 입력버퍼 사이즈 

  20000,                   // 클라이언트 타임-아웃  

  NULL                    // 디폴트 보안 속성

  );

  if (hPipe == INVALID_HANDLE_VALUE) 

  {

  _tprintf( _T("CreatePipe failed")); 

  return -1;

  }

  BOOL isSuccess; 

  isSuccess = ConnectNamedPipe(hPipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED); 

  if (isSuccess) 

  CommToClient(hPipe);

  else 

  CloseHandle(hPipe); 

}

return 1; 

} 

int CommToClient(HANDLE hPipe)

{ 

TCHAR fileName[MAX_PATH];

TCHAR dataBuf[BUF_SIZE];

BOOL isSuccess;

DWORD fileNameSize;

isSuccess = ReadFile ( 

hPipe,        // 파이프 핸들 

fileName,    // read 버퍼 지정.

MAX_PATH * sizeof(TCHAR), // read 버퍼 사이즈 

&fileNameSize,  // 수신한 데이터 크기

NULL);       

if (!isSuccess || fileNameSize == 0) 

{

_tprintf( _T("Pipe read message error! \n") );

return -1; 

}

FILE * filePtr = _tfopen(fileName, _T("r") );

if(filePtr == NULL)

{

_tprintf( _T("File open fault! \n") );

return -1; 

}

DWORD bytesWritten = 0;

DWORD bytesRead = 0;

while( !feof(filePtr) )

{

bytesRead = fread(dataBuf, 1, BUF_SIZE, filePtr);

WriteFile ( 

hPipe, // 파이프 핸들

dataBuf, // 전송할 데이터 버퍼  

bytesRead, // 전송할 데이터 크기 

&bytesWritten, // 전송된 데이터 크기 

NULL);

       if (bytesRead != bytesWritten)

{

   _tprintf( _T("Pipe write message error! \n") );

   break; 

}

}

FlushFileBuffers(hPipe); 

DisconnectNamedPipe(hPipe); 

CloseHandle(hPipe); 

return 1;

}

예제 8-3

이름있는 파이프 클라이언트

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

#define BUF_SIZE 1024

int _tmain(int argc, TCHAR *argv[]) 

{

    HANDLE hPipe;

    TCHAR readDataBuf[BUF_SIZE + 1];

    LPTSTR pipeName = _T("\\\\.\\pipe\\simple_pipe"); 

    while(1)

    {

      hPipe = CreateFile( 

      pipeName,             // 파이프 이름 

      GENERIC_READ | GENERIC_WRITE, // 읽기, 쓰기 모드 동                         

                                                                                                               시 지정 

      0,

      NULL,

      OPEN_EXISTING,

      0,

      NULL

      );

      if (hPipe != INVALID_HANDLE_VALUE)

         break;

      if (GetLastError() != ERROR_PIPE_BUSY)

      {

         _tprintf( _T("Could not open pipe \n") );        

         return 0;

      }

      if (!WaitNamedPipe(pipeName, 20000))

      {

         _tprintf( _T("Could not open pipe \n") );

         return 0;

      }

    }

    DWORD pipeMode = PIPE_READMODE_MESSAGE|PIPE_WAIT; // 메시지 기반으로 모드 변경.

    BOOL isSuccess = SetNamedPipeHandleState (

                       hPipe,      // 파이프 핸들

                       &pipeMode,  // 변경할 모드 정보.  

                       NULL,     // 설정하지 않는다. 

                       NULL);    // 설정하지 않는다. 

    if (!isSuccess)

    {

        _tprintf( _T("SetNamedPipeHandleState failed") ); 

        return 0;

    }

    LPCTSTR fileName = _T("news.txt");

    DWORD bytesWritten = 0;

    isSuccess = WriteFile (

                    hPipe,                // 파이프 핸들

                    fileName,             // 전송할 메시지 

                    (lstrlen(fileName)+1) * sizeof(TCHAR), // 메시지 길이 

                    &bytesWritten,             // 전송된 바이트 수

                    NULL);

    if (!isSuccess) 

    {

      _tprintf( _T("WriteFile failed") ); 

      return 0;

    }

    DWORD bytesRead = 0;

    while(1) 

    {

        isSuccess = ReadFile(

                        hPipe, // 파이프 핸들

                        readDataBuf, // 데이터 수신할 버퍼

                        BUF_SIZE * sizeof(TCHAR),  // 버퍼 사이즈

                        &bytesRead, // 수신한 바이트 수

                        NULL);      

        if (! isSuccess && GetLastError() != ERROR_MORE_DATA) 

            break; 

        readDataBuf[bytesRead] = 0; 

        _tprintf( _T("%s \n"), readDataBuf ); 

    }

    CloseHandle(hPipe); 

    return 0; 

}

핸들 테이블의 상속

BOOL CreateProcess(

LPCTSTR lpApplicationName , 

LPTSTR lpCommandLine ,                                                                                    

LPSECURITY_ATTRIBUTES lpProcessAttributes ,

LPSECURITY_ATTRIBUTES lpTreadAttributes ,

BOOL binheritHandles , // 핸들테이블의 상속여부

DWORD dwCreationFlags ,

LPVOID lpEnvironment ,

LPCTSTR lpCurrentDirectory ,

LPSTARTUPINFO lpstrartupInfo ,

LPPROCESS_INFORMATION lpProcessInformation

);

핸들의 상속과 UC

Pseudo 핸들과 핸들의 중복

 Signaled vs Non-Signaled

커널 오브젝트의 상태

이곳은 프로세스 기준이다.

커널오브젝트의 구성멤버 변수중에 커널오브젝의 상태정보 변수가있는데 이 변수는

프로세스가 실행중이면 프로세스의 커널오브젝트가 Non-signaled 상태 이고

                실행 종료되면  프로세스의 커널오브젝트가 signaled 상태가 된다.  

프로세스가 실행되면 그 프로세스의 커널 오브젝트는 바로  Non-signaled 가 된다.

커널 오브젝트의 상태가 필요한 이유는 프로세스의 핸들을 가지고 있는 무언가가 프로세스의 실행 여부를 판단하기 위해서이다.

윈속을 위한 헤더 및 라이브러리 설정

winsock2.h 헤더 파일을 포함 한다.

ws2_32.lib 라이브러리를 링크 시킨다.

윈속 사용을 위한 라이브러리 초기화 및 해제

윈속 프로그램 코드 Template

윈속 기반의 소켓 관련 함수

윈속 기반의 데이터 입출력 함수

데이터 출력함수 

데이터 입력함수

예제

서버

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<winsock2.h>

void ErrorHandling(char *message);

int main(int argc, char **argv)

{

WSADATA wsaData;

SOCKET hServSock;

SOCKET hClntSock;

SOCKADDR_IN servAddr;

SOCKADDR_IN clntAddr;

int szClntAddr;

char message[]="hello World\n";

if(argc!=2){

printf("Usage : %s <port>\n",argv[0]);

}

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

ErrorHandling("WSAStartup() error!");

hServSock=socket(PF_INET, SOCK_STREAM, 0); //서버 소켓 생성

if(hServSock==INVALID_SOCKET)

ErrorHandling("socket() error");

memset(&servAddr, 0 ,sizeof(servAddr));

servAddr.sin_family=AF_INET;

servAddr.sin_addr.s_addr=htonl(INADDR_ANY);

servAddr.sin_port=htons(atoi(argv[1]));

if(bind(hServSock, (SOCKADDR*) &servAddr,sizeof(servAddr))==SOCKET_ERROR)

ErrorHandling("bind() error");

if(listen(hServSock,5)==SOCKET_ERROR)

ErrorHandling("listen() error");                  //연결 요청 대기

szClntAddr=sizeof(clntAddr);

hClntSock=accept(hServSock, (SOCKADDR*)&clntAddr, &szClntAddr); //연결요청수락

if(hClntSock==INVALID_SOCKET)

ErrorHandling("accept() error");

send(hClntSock, message, sizof(message), 0);

closesocket(hClntSock);

WASCleanup();

클라이언트

#include<stdio,h>

#include<stdlib.h>

#incldue<string.h>

#incldue<winsock2.h>

void ErrorHandling(char *message);

int main(int argc, char **argv)

{

WSADATA wsaData;

SOCKET hSocket;

char message[30];

int strLen;

SOCKADDR_IN servAddr;

if(argc!=3){

printf("Usage : %s <IP> <port> \n",argv[0]);

exit(1);

}

if(WSAStartup(MAKEWORD(2,2), &wsadata) !=0)

ErrorHandling(WSAStartup() error!");

hSocket=socket(PF_INET, SOCK_STREAM, 0);

if(hSocket==INVALID_SOCKET)

ErrorHandling("hSocketet() error");

memset(&servAddr, 0, sizeof(servAddr));

servAddr.sin_family=AF_INET;

servAddr.sin_addr,s_addr=inet_addr(argv[1]);

servaddr.sin_port=htons(atoi(argv[2]));

if(connect(hSocket,  (SOCKADDR*)&servAddr, sizeof(servAddr))==SOCKET_ERROR)

Erroerhandling(:connect() error!);

strLen=recv(hSocket, message, sizeof(message)-1,0);

if(strLen==-1)

ErrorHandling("read() error!");

message[strLen]=0;

printf("Message from server : %s \n", message);

closesocket(hSocket);

WSACleanup();

return 0;

}

void ErrorHandling(char *message)

{

fputs(message, stderr);

fputc('\n',stderr);

exit(1);

}

저 수준 파일 입출력 (Low-Level File Access)

리눅스 혹은 윈도우즈 자체에서 제공해 주는 파일 입출력 함수를 사용하여 파일을 관리

(파일의 생성 및 삭제, 데이터 입력 및 출력) 하는것을 의미함.

리눅스에서는 모든 것을 파일로 관리한다.

-파일,소켓,표준 입력(키보드),표준 출력(모니터)

※흔히 표준 입출력 함수라 함은 ANSI 표준에서 제공하는 함수를 말한다.

파일에 파일 디스크립터를 할당해서 관리(파일 디스크립터는 정수)

※여기서 파일은 단순 파일 뿐아니라 소켓,표준 입출력을 포함한 의미이다.

파일 디스크립터(File Descriptor)

파일을 관리하기 위해서 모든 파일(파일,소켓,표준 입력,표준 출력)에 파일 디스크립터를 할당 해 준다.

기본적으로  파일디스크립터는 정수형으로 이루어지면 0~2까지는 위 표처럼 기본적으로 할당 되어있다.

      Program                            Operating System

File open 및 close

Data read & write

서버 소켓 구현의 이해

일단 소켓통신을 위한 함수들은 간단하게 살펴보자.

클라이언트 소켓 구현의 이해

전화를 거는 사람도 전화기와 전화번호가 필요한 것 처럼 

서버 뿐만아니라 클라이어트도 소켓이 필요하다.

IPC(interprocessor communication)

하나의 프로그램에서 여러게의 프로세스를 형성 할 수있다.

프로세스간 통신

프로세스간 데이터 송 수신→메모리 공유 

메일슬롯(Mail Slot)

Receiver process<----- Receiver's Mail slot <------- Sender process

Process A <--------  A Mail slot    <------------

Process B <--------  A Mail slot    <------------            Sender Process

Process C <--------  A Mail slot    <------------

네트워크의 이해

네트워크란 End-System 들을 연결하는 하나의 System을 의미한다.

End-System : "호스트"라 한다.

ex)PC,프린터,핸드폰 등등등

Internet의 이해

멀리 떨어진 둘 이상의 네트워크가 연결되어 이뤄지는 거대한 네트워크를 의미한다.

인터넷의 구축을 위해서는 서로 다른 네트워크를 연결하는 장비가 필요한다.

이를 두고 라우터(Router)라 한다.

Client / Server 모델

Server와 Client는 프로그램이다.(서버 장비를 말하는 것이 아니다)

Server는 Client의 연결요청을 기다린다.

Client는 Server에 요청을 하고 응답을 기다리는 호스트를 의미한다.

Server의 종류

Server는 일반적으로 Client에 비해 복잡하다.

두 가지 종류의 서버

Iterative Server : 한 순간에 하나의 클라이언트에게 응답한다.

Concurrent Server : 동시에 여러 클라이언트에게 응답한다.

네트워크 프로그래밍의 이해

네트워크로 연결되어 있는 두 호스트간의 데이터 송수신.

파일 입출력과의 차이점은 데이터를 주고 받는 대상에 있다.

소켓(soket)이라는 장치를 사용하여 프로그래밍 한다.

소켓이란 원격에 존재하는 두 호스트를 연결시켜 주는 매개체 역할을 한다.

커널 오브젝트와 핸들의 관계

예제

#include <stdio.h>

#include <windows.h>

#include <tchar.h>

int _tmain(int argc, TCHAR* argv[])

{

STARTUPINFO si={0,};

PROCESS_INFORMATION pi;

si.cb=sizeof(si);

TCHAR command[]=_T("Operation2.exe");

CreateProcess(NULL,     // 프로세스 생성.

     command,

 NULL,

 NULL, 

 TRUE, 

 0, 

 NULL, 

 NULL, 

 &si, 

 &pi

);  //CreateProcess

while(1)

{

for(DWORD i=0; i<10000; i++)

for(DWORD i=0; i<10000; i++); //Busy Waiting!!

_fputts(_T("Operation1.exe \n"), stdout); 

timing+=1;

if(timing==2)

 SetPriorityClass(pi.hProcess,

 NORMAL_PRIORITY_CLASS);   //우선순위를 다시 낮춘다.

}

return 0;

}

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

Operation2.exe

#include <stdio.h>

#include <windows.h>

#include <tchar.h>

int _tmain(int argc, TCHAR* argv[])

{

SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);

while(1)

{

for(DWORD i=0; i<10000; i++)

for(DWORD i=0; i<10000; i++); //Busy Waiting!!

_fputts(_T("Operation2.exe \n"), stdout); 

}

return 0;

}

커널 오브젝트(Kernel Object)에 대한 이해

밑의 예제는 커널 오브젝트에 접근하여 프로세스의 우선순위를 변경하는 예제이다.

예제6-1]

#include <stdio.h>

#include <windows.h>

#include <tchar.h>

int _tmain(int argc, TCHAR* argv[])

{

STARTUPINFO si={0,};

PROCESS_INFORMATION pi;

si.cb=sizeof(si);

TCHAR command[]=_T("Operation2.exe");

CreateProcess(NULL,     // 프로세스 생성.

     command,

 NULL,

 NULL, 

 TRUE, 

 0, 

 NULL, 

 NULL, 

 &si, 

 &pi

);  //CreateProcess

while(1)

{

for(DWORD i=0; i<10000; i++)

for(DWORD i=0; i<10000; i++); //Busy Waiting!!

_fputts(_T("Operation1.exe \n"), stdout); 

}

return 0;

}

예제6-2]

#include <stdio.h>

#include <windows.h>

#include <tchar.h>

int _tmain(int argc, TCHAR* argv[])

{

SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);

            //GetCurrentProcess함수는 프로세스자신의 핸들을 얻어오는 함수이다.

while(1)

{

for(DWORD i=0; i<10000; i++)

for(DWORD i=0; i<10000; i++); //Busy Waiting!!

_fputts(_T("Operation2.exe \n"), stdout); 

}

return 0;

}

실행결과 

Operation2.exe

OpOperation2.exe

Operation2.exe

Operation2.exe

Operation2.exe

Operation2.exe

Opraeration2.exe

Operation2.exe

Operation2.exe

Operation2.exe

Operation2.exe

Opertion1.eation2.exe

Operation2.exe

중략.....................