[TCP/IP] 制限付きマルチタスク

サーバが作成するプロセスの数を制限する
L あらかじめ設定された数だけプロセスを作成する

#include "TCPEchoServer.h" /* ヘッダーファイルをインクルード */

void ProcessMain(int servSock); /* プロセスのメインプログラム */

int main(int argc, char *argv[]) {
    int servSock;
    unsigned short echoServPort;
    pit_t processID;
    unsigned int processLimit;
    unsigned int processCt;

    if (argc != 3) {
        fprintf(stderr, "Usage: %s <Server Port> <FORK LIMIT>\n", argv[0]);
        exit(1);
    }

    echoServPort = atoi(argv[1]);
    processLimit = atoi(argv[2]);

    servSock = CreateTCPServerSocket(echoServPort);

    for(processCt=0; processCt < processLimit; processCt++)
        if((processID == fork()) < 0)
            DieWithError("fork() failed");
        else if(processID == 0)
            ProcessMain(servSock);

    exit(0);
}

void ProcessMain(int servSock) {

    int clntSock;

    for(;;) /* 処理を繰り返し実行 */
    {
        clntSock = AcceptTCPConnection(servSock);
        printf("with child process: %d\n", (unsigned int) getpid());
        HandleTCPClient(clntSock);
    }
}

指定されたプロセスしか生成しないため、スケジューリングによるオーバーヘッドを削減できる。

[TCP/IP] クライアントごとにスレッド作成

クライアントごとに新しいプロセスを生成するのはコストが高い
OSはプロセス作成の度にメモリ、スタック、ファイルなどを状態をコピーしなければならないため

#include "TCPEchoServer.h"
#include <pthread.h> /* posixスレッドに必要 */

void *ThreadMain(void *arg);

struct ThreadArgs {
    int clntSock;
};

int main(int argc, char *argv[]){

    int servSock;
    int clntSock;
    unsigned short echoServPort;
    pthread_t threadID;
    struct ThreadArgs *threadArgs; /* スレッドの引数構造体 */

    if(argc != 2) {
        fprintf(stderr, "Usage: %s <SERVER PORT>\n", argv[0]);
        exit(1);
    }

    echoServPort = atoi(argv);

    servSock = CreateTCPServerSocket(echoServPort);

    for(;;){
        clntSock = AcceptTCPConnection(servSock);

        /* クライアント引数用にメモリを確保 */
        if((threadArgs = (struct ThreadArgs *) malloc(sizeof(struct ThreadArgs)))==NULL)
            DieWithError("malloc() failed")
        threadArgs -> clntSock = clntSock;

        /* クライアントスレッド生成 */
        if(pthread_create(&threadID, NULL, ThreadMain, (void *) threadArgs) != 0)
            DieWithError("pthread_create() failed");
        printf("with thread %ld\n", (long int) threadID);
    }
}

void *TheadMain(void *threadArgs) {
    int clntSock;

    pthread_detach(pthread_self());

    clntSock = ((struct ThreadArgs *) threadArgs) -> clntSock;
    free(threadArgs);

    HandleTCPClient(clntSock);

    return (NULL);
}

[TCP/IP] ソケットのマルチタスク

プロセスやスレッドという仕組みを利用すれば、1つのクライアント処理を独立して動作するサーバのコピーに任せることができる。
=> clientごとにプロセス、スレッド、制限付きマルチタスクを作成する

### クライアントごとにプロセスを作成
Unixでは新しいプロセスの作成にはfork()を使用する
クライアントからの接続を受けるたびに自身のコピーを作成する

#include "TCPEchoServer.h" /* ヘッダーファイルをインクルード */
#include <sys/wait.h> /* waitpid()に必要 */

int main(int argc, char *argv[]) {
    int servSock;
    int clntSock;
    unsigned short echoServPort;
    pit_t processID;
    unsigned int childProcCount = 0;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <Server Port>", argv[0]);
        exit(1);
    }

    echoServPort = atoi(argv[1]);

    servSock = CreateTCPServerSocket(echoServPort);

    for(;;) {
        clntSock = AcceptTCPConnection(servSock);
        if((processID = frok())< 0)
            DieWithError("fork() failed");
        else if (processID == 0) {
            close(servSock);
            HandleTCPClient(clntSock);

            exit(0);
        }

        printf("with child process: %d\n", (int) processID);
        close(clntSock);
        childProcCount++;

        while (childProcCount) {
            processID = waitpid((pid_t) - 1, NULL, WNOHANG);
            if(processID < 0)
                DieWithError("waitpid() failed");
            else if(processID == 0)
                break;
            else
                childProcCount--;
        }
    }
}
#include <stdio.h> /* printf(), fprintf() */
#include <sys/socket.h> /* socket(), bind(), connect() */
#include <arpa/inet.ht> /* sockaddr_in, inet_ntoa() */
#include <stdlib.h> /* atoi() */
#include <string.h> /* memset() */
#include <unistd.h> /* close() */

void DieWithError(char *errorMessage);
void HandleTCPClient(int clntSocket); /* TCPクライアント処理関数 */
int CreateTCPServerSocket(unsigned short port); /* TCPサーバソケット */
int AcceptTCPConnection(int servSock); /* TCP接続要求を受け付ける */
#include <sys/socket.h> /* socket(), bind(), connect() */
#include <arpa/inet.h> /* sockaddr_inとinet_ntoa() */
#include <string.h> /* memset() */

#define MAXPENDING 5 /* 未処理の接続要求の最大値 */

void DieWithError(char *errorMessage); /* エラー処理関数 */

int CreateTCPServerSocket(unsigned short port) {
    int sock; /* 作成するソケット */
    struct sockaddr_in echoServAddr; /* ローカルアドレス */

    /* 着信接続用のソケット作成 */
    if((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        DieWithError("socket() failed");

    /* ローカルアドレスの構造体作成 */
    memset(&echoServAddr, 0, seizeof(echoServAddr)); /* 構造体を0で埋める */
    echoServAddr.sin_family = AF_INET; /* インターネットアドレスファミリ */
    echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY); /* ワイルドカード */
    echoServAddr.sin_port = htons(port); /* ローカルポート */

    /* ローカルアドレスへバインド */
    if(bind(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
        DieWithError("bind() failed");

    /* 「接続要求をリスン中」というマークをソケットにつける */
    if(listen(sock, MAXPENDING) < 0)
        DieWithError("listen() failed");

    return sock;
}
#include <stdio.h> /* printf() */
#include <sys/socket.h> /* accept() */
#include <arpa/inet.h> /* sockaddr_in, inet_ntoa() */

void DieWithError(char *errorMessage); /* エラー処理関数 */

int AcceptTCPConnection(int servSock) {
    int clntSock; /* クライアントのソケットディクリプタ */
    struct sockaddr_in echoClntAddr; /* クライアントのアドレス */
    unsigned int clntLen; /* クライアントのアドレス構造体の長さ */

    /* 入出力のパラメータのサイズをセット */
    clnLen = sizeof(echoClntAddr);

    /* クライアントからの接続要求を待つ */
    if((clntSock = accept(servSock, (struct sockaddr *) &echoClntAddr, &clntLen)) < 0)

    /* clntSockはクライアントに接続済 */
    printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr));

    return clntSock;

}

[TCP/IP] タイムアウト

unsigned int arlarm(unsigned int secs)

alermはタイマーを開始する
タイマーが切れると、SIGALARMシグナルがプロセスに送られ、SIGALRMハンドラ関数がある場合はそれが実行される

#include <stdio.h> /* printf(), fprintf()に必要 */
#include <sys/socket.h> /* socket(), bind(), connect()に必要 */
#include <arpa/inet.h> /* sockaddr_in, inet_ntoaに必要 */
#include <stdlib.h> /* atoi()に必要 */
#include <string.h> /* memset()に必要 */
#include <unistd.h> /* close()に必要 */
#include <fcntl.h> /* fcntl()に必要 */
#include <sys/file.h> /* O_NONBLOCK, FASYNCに必要 */
#include <signal.h> /* signal(),SIGLRMに必要 */
#include <error.h> /* errnoに必要 */

#define ECHOMAX 255 /* エコー文字列の最大長 */
#define TIMEOUT_SECS 2 /* 再送信までの秒数 */
#define MAXTRIES 5 /* 最大試行回数 */

int tries=0; /* エコー文字列の最大長 */

void DieWithError(char *errorMessage); /* エラー処理関数 */
void CatchAlarm(int ignored);

int main(int argc, char *argv[]){
    int sock; /* ソケットディスクリプタ */
    struct sockaddr_in echoServAddr; /* エコーサーバアドレス */
    struct sockaddr_in fromAddr; /* エコー送信元のアドレス */
    unsigned short echoServPort; /* エコーサーバポート */
    unsigned int fromSize; /* recvfrom()アドレスの入出力サイズ */
    struct sigaction myAction; /* シグナルハンドラの設定用 */
    char *servIP;  /* サーバのIP */
    char *echoString; /* 送信する文字列 */
    char echoBuffer[ECHOMAX+1]; /* エコー文字列受信用バッファ */
    int echoStringLen; /* エコー文字列の長さ */
    int respStringLen; /* 受信した応答の長さ */

    /* 引数が正しいか確認 */
    if((argc < 3) || (argc > 4)){
        fprintf(stderr, "Usage: %s <Server IP><Echo Word>[<Echo Port>]\n", argv[0]);
        exit(1);
    }

    servIP = argv[1]; /* 1つ目の引数: サーバのIP */
    echoString = argv[2]; /* 2つ目の引数: エコー文字列 */

    if((echoStringLen = strlen(echoString)) > ECHOMAX) /* 入力した文字列の長さをチェック */
        DieWithError("Echo word too long");

    if (argc == 4)
        echoServPort = atoi(argv[3]); /* 指定ポートがあれば使用 */
    else
        echoServPort = 7; /* 7はエコーサービスのwellknown port */

    /* UDPデータグラムソケット作成 */
    if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
        DieWithError("socket() failed");

    /* アラームシグナル用シグナルハンドラのセット */
    myAction.sa_handler = CatchAlarm;
    if(sigfillset(&myAction.sa_mask) < 0) /* ハンドラ内では全てをブロック */
        DieWithError("sigfillset() failed");
    myAction.sa_flags = 0;

    if(sigaction(SIGALRM, &myAction, 0) < 0) /* ハンドラ内では全てをブロック */
        DieWithError("sigaction() failed for SIGALRM");

    /* サーバのアドレス構造体 */
    memset(&echoServAddr, 0, sizeof(echoServAddr)); /* 構造体に0埋め */
    echoServAddr.sin_family = AF_INET; /* インターネットアドレスファミリ */
    echoServAddr.sin_addr.s_addr = inet_addr(servIP); /* サーバIP */
    echoServAddr.sin_port = htons(echoServPort); /* サーバポート */

    /* 文字列をサーバに送信 */
    if (sendto(sock, echoString, echoStringLen, 0, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) != echoStringLen)
        DieWithError("sendto() sent a different number of bytes than expected");        

    /* 応答を受信 */
    fromSize = sizeof(fromAddr);
    alarm(TIMEOUT_SECS);
    while((respStringLen = recvfrom(sock, echoBuffer, ECHOMAX, 0,
        (struct sockaddr *) &fromAddr, &fromSize)) < 0)
        if (errno = EINTR){
            if (tries < MAXTRIES) {
                printf("timed out, %d more tries..\n", MATRIES - tries);
                if(sendto(sock, echoString, echoStringLen, 0, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) != echoStringLen)
                    DieWithError("sendto() failed");
                alarm(TIMEOUT_SECS);
            }
            else
                DieWithError("No Response");
        }
        else
            DieWithError("recvfrom() failed");
        alarm(0);

        /* 受信データをNULL文字で終端させる */
        echoBuffer[respStringLen] = '\0';
        printf("Received: %s\n", echoBuffer);

        close(sock);
        exit(0);
}

void CatchAlarm(int ignored) {
    tries += 1;
}

[TCP/IP] ノンブロッキングI/O

ソケットの呼び出しは、デフォルトでは要求されたアクションが完了するまでプログラムの実行をブロックする
ブロックされた関数のプロセスはOSによって一時停止の状態に置かれる
=> 望ましくないブロッキング動作を制御する仕組みが必要な時に使われるのがノンブロッキングソケット

int fcntl(int socket, int. command, long argument)
L commandにF_SETFLを指定し、argumentにフラグ名を指定する

### 非同期I/O
SIGIOシグナルを送信することで、ソケットで発生したI/O関連のイベントをプロセスに通知する

#include <stdio.h> /* printf(), fprintf()に必要 */
#include <sys/socket.h> /* socket(), bind(), connect()に必要 */
#include <arpa/inet.h> /* sockaddr_in, inet_ntoaに必要 */
#include <stdlib.h> /* atoi()に必要 */
#include <string.h> /* memset()に必要 */
#include <unistd.h> /* close()に必要 */
#include <fcntl.h> /* fcntl()に必要 */
#include <sys/file.h> /* O_NONBLOCK, FASYNCに必要 */
#include <signal.h> /* signal(),SIGLRMに必要 */
#include <error.h> /* errnoに必要 */

#define ECHOMAX 255 /* エコー文字列の最大長 */

void DieWithError(char *errorMessage); /* エラー処理関数 */
void UseIdleTime(); /* アイドル時間を利用する関数 */
void SIGIOHandler(int signalType); /* SIGIOのハンドラ関数 */

int sock; /* ソケット */

int main(int argc, char *argv[]){
    struct sockaddr_in echoServAddr; /* ローカルアドレス */
    unsigned short echoServPort; /* サーバのポート番号 */
    struct sigaction handler; /* シグナル処理のアクションを定義 */

    if(argc != 2) { /* 引数が正しいかの確認 */
        fprintf(stderr, "Usage: %s <Server Port\n>", argv[0]);
        exit(1);
    }

    echoServPort == atoi(argv[1]); /* ローカルポート */

    /* データグラムの送受信に使うソケットを作成 */
    if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
        DieWithError("socket() failed");

    /* サーバのアドレス構造体をセットアップ */
    memset(&echoServAddr, 0, sizeof(echoServAddr)); /* 構造体を0埋め */
    echoServAddr.sin_family = AF_INET; /* インターネットアドレスファミリ */
    echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY); /* ワイルドカードを使用 */
    echoServAddr.sin_port = htons(echoServPort); /* ローカルポート */

    /* ローカルアドレスへのインバインド */
    if(bind(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
        DieWithError("bind() failed");

    /* SIGIOのシグナルハンドラを設定 */
    handler.sa_handler = SIGIOHandler;
    /* 全シグナルをマスクするマスクを作成 */
    if(sigfillset(&handler.sa_mask) < 0)
        DieWithError("sigfillset() failed");

    /* フラグなし */
    handler.sa_flags = 0;

    if(sigaction(SIGIO, &handler, 0) < 0)
        DieWithError("sigaction() failed for SIGIO");

    /* ソケットを所有してSIGIOメッセージを受信させる */
    if (fcntl(sock, F_SETIWN, getpid()) < 0)
        DieWithError("Unable to set process owner to us");

    /* ノンブロッキングI/OとSIGIO送信をセットアップ */
    if (fcntl(sock, F_SETFL, O_NONBLOCK | FASYNC) < 0)
        DieWithError("Unable to put client sock into nonblocking/async mode");

    /* 処理を離れて他の仕事をする */

    for(;;)
        UseIdleTime();
}

void UseIdleTime() {
    printf(".\n");
    sleep(3);
}

void SIGIOHandler(int signalType) {
    struct sockaddr_in echoClntAddr; /* データグラムの送信元アドレス */
    unsigned int clntLen; /* アドレス長 */
    int recvMsgSize; /* データグラムのサイズ */
    char echoBuffer[ECHOMAX]; /* データグラムのバッファ */

    do {
        /* 入出力パラーメタのサイズを設定 */
        clntLen = sizeof(echoClntAddr);

        if((recvMsgSize = recvfrom(sock, echoBuffer, ECHOMAX, 0, (struct sockaddr *) &echoClntAddr, &clntLen)) < 0){
            /* recvfrom()がブロックしようとした場合(許容される唯一のエラー) */
            if(errno != EWOULDBLOCK)
                DieWithError("recvfrom() failed");
        } else {
            printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr));

            if(sendto(sock, echoBuffer,recvMsgSize, 0 (struct sockaddr *) &echoClntAddr, sizeof(echoClntAddr)) != recvMsgSize)
                DieWithError("sendto() failed");
        }

    } while (recvMsgSize >= 0);
    /* 全ての受信が完了 */
}

[TCP/IP] ソケットシグナル

シグナルとは、ユーザによる割り込み文字の入力やタイマーの期限切れといった特定イベントの発生をプログラムに伝える仕組み

### 実行中のプログラムのシグナルへの対処パターン
1. 無視、感知しない
2. OSにより強制終了
3. シグナル処理関数が実行される。メインスレッドとは別の制御スレッドで実行
4. シグナルをブロック ブロックの対象はマスクで決める

### unixのシグナル
SIGALRM, SIGCHLD, SISINT, SIGIO, SIGPIPE

シグナルのデフォルト動作を変更するにはsigaction()を実行する
int sigaction(int whichSignal, const struct sigaction *newAction, struct sigaction *oldAction)

sigaction構造体
struct sigaction {
void (*sa_handler)(int);
sigset_t sa_mask;
int sa_flags;
}

シグナルはネストできる
sa_maskはboolean型の集合
int sigemptyset(sigset_t *set)
int sigfillset(sigset_t *set)
int sigaddset(sigset_t *set, int whichSignal)
int sigdelset(sigset_t *set, int whichSignal)

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void DieWithError(char *errorMessage); /* エラー処理関数 */
void InterruptSignalHandler(int signalType); /* 割り込みシグナル処理関数 */

int main(int argc, char *argv[]) {
    struct sigaction handler; /* シグナルハンドラを指定する構造体 */

    /* InterruptSignalHandler()をハンドラ関数として設定 */
    handler.sa_handler = InterruptSignalHandler;
    /* 全シグナルをマスクするマスクを作成 */
    if (sigfillset(&handler.sa_mask) < 0)
        DieWithError("sigfillset() failed");
    /* フラグなし */
    handler.sa_flags = 0;

    /* 割り込みシグナルに対する処理を設定 */
    if(sigaction(SIGINT, &handler, 0) < 0) 
        DieWithError("sigaction() failed");

    for(;;)
        pause(); /* シグナルを受け取るまでプログラムを一時停止 */

    exit(0);
}

void InterruptSignalHandler(int signalType) {
    printf("Interrupt Received. Exiting program. \n");
    exit(1);
}

[TCP/IP] ソケットオプション

受信バッファのサイズなどソケットの動作を決める様々な特性は「ソケットオプション」の値を変更することで調整できる
getter, setterは以下の通り
int getsockopt(int socket, int level, int optName, void *optVal, unsigned int *optLen)
int setsockopt(int socket, int level, int optName, const void *optVal, unsigned int optLen)

ソケットの受信バッファサイズ(bytes)を取得し、それを2倍にする例

    int rcvBufferSize;
    int sockOptSize;

    /* デフォルトのバッファサイズを取得 */
    sockOptSize = sizeof(rcvBufferSize);
    if(getsockopt(sock, SOL_SOCKET, SO_RCVBUF, &rcvBufferSize, &sockOptSize) < 0)
        DieWithError("getsockopt() failed")
    printf("Initial Receive Buffer Size: %d\n", rcvBufferSize);

    /* デフォルトのバッファサイズを取得 */
    rcvBufferSize *= 2;
    if(setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &rcvBufferSize, sizeof(rcvBufferSize)) < 0)
        DieWithError("setsockopt() failed");

[TCP/IP] UDPサーバ

UDOの場合は、メッセージの境界を保持する。UDPはエラーから回復を行わないため、再送信に備えてバッファーを保持することがない。UDPソケットからsendto()を実行して処理が戻った時点で下位の送信チャンネルにメッセージが渡されるため、このタイミングでバッファからデータが出ていく。受信側ではバッファのサイズを十分に大きくして、データの破棄がなくなるようにしている。

#include <stdio.h> /* printf(), fprintf()に必要 */
#include <sys/socket.h> /* socket(), bind(), connect()に必要 */
#include <arpa/inet.h> /* sockaddr_in, inet_ntoaに必要 */
#include <stdlib.h> /* atoi()に必要 */
#include <string.h> /* memset()に必要 */
#include <unistd.h> /* close()に必要 */

#define ECHOMAX 255 /* エコー文字列の最大長 */

void DieWithError(char *errorMessage); /* エラー処理関数 */

int main(int argc, char *argv[]){
    int sock; /* ソケット */
    struct sockaddr_in echoServAddr; /* ローカルアドレス */
    struct sockaddr_in echoClntAddr; /* クライアントアドレス */
    unsigned int cliAddrLen; /* 着信メッセージの長さ */
    char echoBuffer[ECHOMAX]; /* エコー文字列用バッファ */
    unsigned short echoServPort; /* サーバのポート番号 */
    int recvMsgSize; /* 受信メッセージのサイズ */

    if(argc != 2) { /* 引数が正しいかの確認 */
        fprintf(stderr, "Usage: %s <Server Port\n>", argv[0]);
        exit(1);
    }

    echoServPort == atoi(argv[1]); /* ローカルポート */

    /* データグラムの送受信に使うソケットを作成 */
    if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
        DieWithError("socket() failed");

    /* ローカルアドレス構造体を作成 */
    memset(&echoServAddr, 0, sizeof(echoServAddr)); /* 構造体を0埋め */
    echoServAddr.sin_family = AF_INET; /* インターネットアドレスファミリ */
    echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY); /* ワイルドカードを使用 */
    echoServAddr.sin_port = htons(echoServPort); /* ローカルポート */

    /* ローカルアドレスへのインバインド */
    if(bind(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
        DieWithError("bind() failed");

    /* 無限ループ */
    for(;;) {
        /* 入出力パラメータのサイズをセット */
        clntLen = sizeof(echoClntAddr);

        /* クライアントからメッセージを受信するまでブロックする */
        if((recvMsgSize = recvfrom(sock, echoBuffer, ECHOMAX, 0, (struct sockaddr *) &echoClntAddr, &cliAddrLen)) < 0)
            DieWithError("recvfrom() failed");

        printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr));

        /* 受信したデータグラムをクライアントに返信する */
        if(sendto(sock, echoBuffer, recvMsgSize, 0, (struct sockaddr *) &echoClntAddr, sizeof(echoClntAddr)) != recvMsgSize)
            DieWithError("sendto() sent a different number of bytes than expected");

    }
}

[TCP/IP] UDPクライアント

UDP(User Datagram Protocol)は、end2end serviceを提供する
1. IPの層にもう一つ別のアドレッシング(ポート番号によるアドレッシング)の層を追加する
2. 転送中に発生し得るデータ破損を検出し、破損したデータグラムを破棄

UDPは接続を確立しなくても良い。送り先さえ指定すれば良い郵便のようなもの
複数のアドレスへ連続的に送ることができる
socket apiにはUDP用の送信関数sendto()が特別に用意されている

int sendto(int socket, const void *msg, unsigned int msgLength, int flags, struct socketaddr *destaddr, unsigned int addrLen)
int recvfrom(int socket, const void *msg, unsigned int msgLength, int flags, struct socketaddr *srcAddr, unsigned int addrLen)

UDPはconnect()を呼び出さない
UDPソケットはメッセージの境界を保持する
UDPクライアントはUDPサーバとのみ通信する

UDPEchoClient.c

#include <stdio.h> /* printf(), fprintf()に必要 */
#include <sys/socket.h> /* socket(), connect(), sendto(), recvfrom() */
#include <arpa/inet.h> /* sockaddr_in, inet_addr() */
#include <stdlib.h> /* atoi() */
#include <string.h> /* memset() */
#include <unistd.h> /* close() */

#define ECHOMAX 255 /* エコー文字列の最大長 */

void DieWithError(char *errorMessage); /* エラー処理関数 */

int main(int argc, char *argv[]){
    int sock; /* ソケットディスクリプタ */
    struct sockaddr_in echoServAddr; /* エコーサーバアドレス */
    struct sockaddr_in fromAddr; /* エコー送信元のアドレス */
    unsigned short echoServPort; /* エコーサーバポート */
    unsigned int fromSize; /* recvfrom()アドレスの入出力サイズ */
    char *servIP;  /* サーバのIP */
    char *echoString; /* 送信する文字列 */
    char echoBuffer[ECHOMAX+1]; /* エコー文字列受信用バッファ */
    unsigned int echoStringLen; /* エコーする文字列サイズ */
    int echoStringLen; /* エコー文字列の長さ */
    int respStringLen; /* 受信した応答の長さ */

    /* 引数が正しいか確認 */
    if((argc < 3) || (argc > 4)){
        fprintf(stderr, "Usage: %s <Server IP><Echo Word>[<Echo Port>]\n", argv[0]);
        exit(1);
    }

    servIP = argv[1]; /* 1つ目の引数: サーバのIP */
    echoString = argv[2]; /* 2つ目の引数: エコー文字列 */

    if((echoStringLen = strlen(echoString)) > ECHOMAX) /* 入力した文字列の長さをチェック */
        DieWithError("Echo word too long");

    if (argc == 4)
        echoServPort = atoi(argv[3]); /* 指定ポートがあれば使用 */
    else
        echoServPort = 7; /* 7はエコーサービスのwellknown port */

    /* UDPデータグラムソケット作成 */
    if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
        DieWithError("socket() failed");

    /* サーバのアドレス構造体 */
    memset(&echoServAddr, 0, sizeof(echoServAddr)); /* 構造体に0埋め */
    echoServAddr.sin_family = AF_INET; /* インターネットアドレスファミリ */
    echoServAddr.sin_addr.s_addr = inet_addr(servIP); /* サーバIP */
    echoServAddr.sin_port = htons(echoServPort); /* サーバポート */

    /* 文字列をサーバに送信 */
    if (sendto(sock, echoString, echoStringLen, 0, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) != echoStringLen)
        DieWithError("sendto() sent a different number of bytes than expected");        

    /* 応答を受信 */
    fromSize = sizeof(fromAddr);
    if((respStringLen = recvfrom(sock, echoBuffer, ECHOMAX, 0, (struct sockaddr *) &fromAddr, &fromSize)) != echoStringLen)
        DieWithError("recvfrom() failed");

    if(echoServAddr.sin_addr.s_addr != fromAddr.sin_addr.s_addr) {
        fprintf(stderr, "Error: received a packet from unknown source.\n");
        exit(1);
    }

    /* 受信データをNULL文字で終端させる */
    echoBuffer[respStringLen] = '\0':
    printf("Received: %s\n", echoBuffer); /* 引数のエコー文字列を表示 */

    close(sock);
    exit(0);
}

[TCP/IP] TCPサーバをCで実装

サーバは通信エンドポイントを用意して受動的にクライアントからの接続を待機

### TCPサーバの通信手順
1. socket()を実行してTCPソケットを作成する
2. bind()を実行してソケットにポート番号を割り当て
3. listen()を実行し、割り当てたポート番号へ接続を作成できることをシステムに伝える
4. 以下を繰り返し実行
– クライアントから接続要求を受けるたびにaccept()を呼び出してソケットを取得
– send()とrecv()を実行しながら、作成したソケットを介してクライアントとやり取りをする
– close()を実行してクライアントとの接続をクローズ

サーバはbind()により自分のアドレスを指定
int bind(int socket, struct sockaddr *localAddress, unsigned int addressLength)

クライアントからの接続要求を待ち受けるには listen()を呼び出す
int listen(int socket, int queueLimit)

サーバはクライアントからの接続要求を着信すると、accept()を呼び出してソケットを取得する
int accept(int socket, stuct sockaddr *clientAddress, unsigned int *addressLength)
L accept()は、クライアントを接続させた新しいソケットのディスクリプ他を返す

TCPEchoServer.c

#include <stdio.h> /* printf(), fprintf()に必要 */
#include <sys/socket.h> /* socket(), bind(), connect()に必要 */
#include <arpa/inet.h> /* sockaddr_in, inet_ntoaに必要 */
#include <stdlib.h> /* atoi()に必要 */
#include <string.h> /* memset()に必要 */
#include <unistd.h> /* close()に必要 */

#define MAXPENDING 5; /* 同時にキュー可能な接続要求の最大数 */

void DieWithError(char *errorMessage); /* エラー処理関数 */
void HandleTCPClient(int clntSocket); /* TCPクライアント処理 */

int main(int argc, char *argv[]){
    int servSock; /* サーバのソケットディスクリプタ */
    int clntSock; /* クライアントのソケットディスクリプタ */
    struct sockaddr_in echoServAddr; /* ローカルアドレス */
    struct sockaddr_in echoClntAddr; /* クライアントアドレス */
    unsigned short echoServPort; /* サーバポート */
    unsigned int clntLen; /* クライアントのアドレス構造体の長さ */

    if(argc != 2) { /* 引数が正しいかの確認 */
        fprintf(stderr, "Usage: %s <Server Port\n>", argv[0]);
        exit(1);
    }

    echoServPort == atoi(argv[1]); /* ローカルポート */

    /* 着信接続用のソケットを作成 */
    if((servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        DieWithError("socket() failed");

    /* ローカルアドレス構造体を作成 */
    memset(&echoServAddr, 0, sizeof(echoServAddr)); /* 構造体を0埋め */
    echoServAddr.sin_family = AF_INET; /* インターネットアドレスファミリ */
    echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY); /* ワイルドカードを使用 */
    echoServAddr.sin_port = htons(echoServPort); /* ローカルポート */

    /* ローカルアドレスへのインバインド */
    if(bind(servSock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
        DieWithEror("bind() failed");

    /* 接続要求をリスン中というマークをソケットにつける */
    if(listen(servSock, MAXPENDING) < 0)
        DieWithError("listen() failed");

    /* 無限ループ */
    for(;;) {
        /* 入出力パラメータのサイズをセット */
        clntLen = sizeof(echoClntAddr);

        /* クライアントからの接続要求を待機 */
        if((clntSock = accept(servSock, (struct sockaddr *) &echoClntAddr, &clntLen)) < 0)
            DieWithError("accept() failed");

        /* clntSockはクライアントに接続済 */
        printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr));

        HandleTCPClient(clntSock);
    }


}

HandleTCPClient.c

#include <stdio.h> /* printf(), fprintf()に必要 */
#include <sys/socket.h> /* socket(), bind(), connect()に必要 */
#include <arpa/inet.h> /* sockaddr_in, inet_ntoaに必要 */
#include <stdlib.h> /* atoi()に必要 */
#include <string.h> /* memset()に必要 */
#include <unistd.h> /* close()に必要 */

#define MAXPENDING 5 /* 同時にキュー可能な接続要求の最大数 */

void DieWithError(char *errorMessage); /* エラー処理関数 */
void HandleTCPClient(int clntSocket); /* TCPクライアント処理 */

int main(int argc, char *argv[]){
    int servSock; /* サーバのソケットディスクリプタ */
    int clntSock; /* クライアントのソケットディスクリプタ */
    struct sockaddr_in echoServAddr; /* ローカルアドレス */
    struct sockaddr_in echoClntAddr; /* クライアントアドレス */
    unsigned short echoServPort; /* サーバポート */
    unsigned int clntLen; /* クライアントのアドレス構造体の長さ */

    if(argc != 2) { /* 引数が正しいかの確認 */
        fprintf(stderr, "Usage: %s <Server Port\n>", argv[0]);
        exit(1);
    }

    echoServPort == atoi(argv[1]); /* ローカルポート */

    /* 着信接続用のソケットを作成 */
    if((servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
        DieWithError("socket() failed");

    /* ローカルアドレス構造体を作成 */
    memset(&echoServAddr, 0, sizeof(echoServAddr)); /* 構造体を0埋め */
    echoServAddr.sin_family = AF_INET; /* インターネットアドレスファミリ */
    echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY); /* ワイルドカードを使用 */
    echoServAddr.sin_port = htons(echoServPort); /* ローカルポート */

    /* ローカルアドレスへのインバインド */
    if(bind(servSock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
        DieWithError("bind() failed");

    /* 接続要求をリスン中というマークをソケットにつける */
    if(listen(servSock, MAXPENDING) < 0)
        DieWithError("listen() failed");

    /* 無限ループ */
    for(;;) {
        /* 入出力パラメータのサイズをセット */
        clntLen = sizeof(echoClntAddr);

        /* クライアントからの接続要求を待機 */
        if((clntSock = accept(servSock, (struct sockaddr *) &echoClntAddr, &clntLen)) < 0)
            DieWithError("accept() failed");

        /* clntSockはクライアントに接続済 */
        printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr));

        HandleTCPClient(clntSock);
    }
}