MENU
  1. ホーム
  2. C言語
  3. C言語のソケットプログラミング入門：実装方法と応用例

C言語のソケットプログラミング入門：実装方法と応用例

C言語

C言語でのソケットプログラミングは、ネットワーク通信を実現するための基本技術です。インターネットを介したデータのやり取りや、ネットワークを利用したアプリケーションの開発において、ソケットプログラミングの知識は欠かせません。本記事では、C言語を用いてソケットプログラミングを行う際の基本的な実装方法と、実際の応用例について詳しく解説します。初学者向けにわかりやすく説明し、具体的なコード例や演習問題を通じて、実践的なスキルを身につけることができます。

目次

ソケットプログラミングとは

ソケットプログラミングは、コンピュータネットワークを通じてデータを送受信するための手法です。ソケットとは、ネットワーク上の異なるプロセス間で通信を行うためのエンドポイントです。これにより、クライアントとサーバーがデータをやり取りすることができます。ソケットプログラミングの基本概念を理解することで、ネットワークを介したアプリケーション開発が容易になります。以下に、ソケットプログラミングの重要なポイントを紹介します。

ソケットの基本概念

ソケットは、IPアドレスとポート番号の組み合わせで識別される通信のエンドポイントです。ソケットを使用することで、データの送受信が可能となり、ネットワークアプリケーションの基盤を形成します。具体的には、ソケットを作成し、接続を確立し、データを送受信し、接続を終了するという流れで通信が行われます。

クライアントとサーバー

ソケットプログラミングでは、通常クライアントとサーバーという2つの主要なコンポーネントが存在します。クライアントはサービスを要求する側であり、サーバーはその要求に応答する側です。クライアントはサーバーに接続し、データを送信したり受信したりします。サーバーはクライアントからの接続要求を待ち受け、接続が確立するとデータを処理します。

通信プロトコル

ソケットプログラミングでは、主にTCP（Transmission Control Protocol）とUDP（User Datagram Protocol）という2つの通信プロトコルが使用されます。TCPは信頼性の高い接続型通信を提供し、データの順序や整合性を保証します。UDPは接続レスで高速な通信を提供しますが、データの信頼性は保証されません。用途に応じて適切なプロトコルを選択することが重要です。

以上がソケットプログラミングの基本概念です。次に、実際にC言語を用いてソケットプログラミングを行うために必要な環境とツールについて解説します。

必要な環境とツール

C言語でソケットプログラミングを行うためには、適切な開発環境とツールが必要です。以下では、そのセットアップ方法を詳しく解説します。

開発環境の選択

ソケットプログラミングを始めるためには、C言語の開発環境を整える必要があります。以下のいずれかの環境を使用することを推奨します。

Windows

Windowsで開発を行う場合、Visual Studioが一般的な選択肢です。以下の手順でセットアップを行います。

  1. Visual Studioの公式サイトからインストーラーをダウンロードします。
  2. インストール中に「C++によるデスクトップ開発」ワークロードを選択します。
  3. インストール完了後、Visual Studioを起動し、新しいプロジェクトを作成します。

Linux

Linux環境では、GCCコンパイラを使用するのが一般的です。以下のコマンドでGCCをインストールします。

sudo apt-get update
sudo apt-get install build-essential

また、ソケットプログラミングに必要なライブラリもインストールします。

sudo apt-get install libc6-dev

macOS

macOSでは、Xcodeを使用するのが一般的です。以下の手順でセットアップを行います。

  1. App StoreからXcodeをダウンロードしてインストールします。
  2. Xcodeを起動し、新しいプロジェクトを作成します。

必要なツール

ソケットプログラミングに必要なツールとして、以下を準備します。

テキストエディタ

コードを書くためには、使いやすいテキストエディタが必要です。Visual Studio Code、Sublime Text、Vimなど、好みに応じて選択してください。

コンパイラ

C言語のコードをコンパイルするためには、適切なコンパイラが必要です。前述の通り、WindowsではVisual Studio、LinuxではGCC、macOSではXcodeを使用します。

ネットワークツール

ネットワークの動作を確認するためのツールも用意しておくと便利です。例えば、Wiresharkを使用すると、ネットワークパケットのキャプチャと解析ができます。

以上の開発環境とツールを準備することで、C言語によるソケットプログラミングの実装をスムーズに進めることができます。次に、具体的なソケットの作成方法について解説します。

基本的なソケットの作成方法

ソケットプログラミングの第一歩は、ソケットの作成です。ここでは、C言語を用いて基本的なソケットを作成する手順を紹介します。

ソケットの作成手順

ソケットを作成するためには、以下の手順を踏みます。

ソケットの初期化

ソケットを作成するには、まずsocket関数を使用します。この関数は、通信に使用するソケットのファイルディスクリプタを返します。socket関数の基本的なシンタックスは次のとおりです。

int socket(int domain, int type, int protocol);

ここで、domainはアドレスファミリを指定し、通常はAF_INETを使用します。typeはソケットのタイプを指定し、SOCK_STREAM（TCP）またはSOCK_DGRAM（UDP）を使用します。protocolはプロトコルを指定し、通常は0を指定します。

int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
    perror("socket");
    exit(EXIT_FAILURE);
}

ソケットアドレス構造体の設定

次に、通信に使用するアドレスとポート番号を設定します。sockaddr_in構造体を使用します。

struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080); // ポート番号を指定
server_addr.sin_addr.s_addr = INADDR_ANY; // すべてのローカルインターフェイスを使用

ソケットのバインド

ソケットを作成したら、それを特定のアドレスとポートにバインドします。bind関数を使用します。

if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    perror("bind");
    close(sockfd);
    exit(EXIT_FAILURE);
}

ソケットのリッスン

サーバーソケットの場合、接続を待ち受けるためにlisten関数を使用します。

if (listen(sockfd, 5) == -1) {
    perror("listen");
    close(sockfd);
    exit(EXIT_FAILURE);
}

ここで、5は接続待ちキューの長さを指定します。

基本的なソケット作成コード例

以下に、基本的なソケットの作成とバインド、リッスンを行うコード例を示します。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int sockfd;
    struct sockaddr_in server_addr;

    // ソケットの作成
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // アドレス構造体の設定
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    // ソケットのバインド
    if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // ソケットのリッスン
    if (listen(sockfd, 5) == -1) {
        perror("listen");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on port 8080...\n");

    // サーバーの動作を続けるための無限ループ
    while (1) {
        // 接続の受け入れなどの処理をここに追加
    }

    close(sockfd);
    return 0;
}

このコードは、基本的なサーバーソケットを作成し、ポート8080で接続を待ち受けるサンプルです。次に、サーバー側の詳細な実装方法について解説します。

サーバー側の実装

サーバー側のソケットプログラミングでは、クライアントからの接続を待ち受け、接続が確立したらデータを受信・送信する処理を行います。ここでは、その具体的な手順とコード例を解説します。

接続の受け入れ

クライアントからの接続要求を受け入れるためには、accept関数を使用します。この関数は、新しいソケットファイルディスクリプタを返し、クライアントとの通信に使用します。

int client_sockfd;
struct sockaddr_in client_addr;
socklen_t client_addr_len = sizeof(client_addr);

client_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_addr_len);
if (client_sockfd == -1) {
    perror("accept");
    close(sockfd);
    exit(EXIT_FAILURE);
}

データの受信

クライアントから送信されたデータを受信するためには、recv関数を使用します。

char buffer[1024];
ssize_t bytes_received;

bytes_received = recv(client_sockfd, buffer, sizeof(buffer) - 1, 0);
if (bytes_received == -1) {
    perror("recv");
    close(client_sockfd);
    close(sockfd);
    exit(EXIT_FAILURE);
}
buffer[bytes_received] = '\0'; // 受信したデータを文字列として扱うために終端文字を追加
printf("Received message: %s\n", buffer);

データの送信

クライアントにデータを送信するためには、send関数を使用します。

const char *message = "Hello from server!";
ssize_t bytes_sent;

bytes_sent = send(client_sockfd, message, strlen(message), 0);
if (bytes_sent == -1) {
    perror("send");
    close(client_sockfd);
    close(sockfd);
    exit(EXIT_FAILURE);
}

接続の終了

通信が終了したら、ソケットを閉じます。

close(client_sockfd);

サーバー側の完全な実装例

以下に、サーバー側のソケットプログラムの完全な実装例を示します。この例では、クライアントからの接続を受け入れ、メッセージを受信して応答を返す簡単なサーバーを実装しています。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int sockfd, client_sockfd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    char buffer[1024];
    ssize_t bytes_received, bytes_sent;

    // ソケットの作成
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // アドレス構造体の設定
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    // ソケットのバインド
    if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // ソケットのリッスン
    if (listen(sockfd, 5) == -1) {
        perror("listen");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on port 8080...\n");

    // 接続の受け入れ
    client_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_addr_len);
    if (client_sockfd == -1) {
        perror("accept");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // データの受信
    bytes_received = recv(client_sockfd, buffer, sizeof(buffer) - 1, 0);
    if (bytes_received == -1) {
        perror("recv");
        close(client_sockfd);
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    buffer[bytes_received] = '\0';
    printf("Received message: %s\n", buffer);

    // データの送信
    const char *message = "Hello from server!";
    bytes_sent = send(client_sockfd, message, strlen(message), 0);
    if (bytes_sent == -1) {
        perror("send");
        close(client_sockfd);
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // 接続の終了
    close(client_sockfd);
    close(sockfd);

    return 0;
}

このコードは、基本的なサーバーソケットを作成し、クライアントからの接続を待ち受け、メッセージを受信して応答を返す一連の処理を行っています。次に、クライアント側の実装方法について解説します。

クライアント側の実装

クライアント側のソケットプログラミングでは、サーバーに接続し、データを送信・受信する処理を行います。ここでは、その具体的な手順とコード例を解説します。

サーバーへの接続

クライアントは、サーバーに接続するためにconnect関数を使用します。まず、ソケットを作成し、サーバーのアドレス構造体を設定します。

int sockfd;
struct sockaddr_in server_addr;

// ソケットの作成
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
    perror("socket");
    exit(EXIT_FAILURE);
}

// サーバーアドレス構造体の設定
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080);
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

// サーバーへの接続
if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    perror("connect");
    close(sockfd);
    exit(EXIT_FAILURE);
}

データの送信

サーバーにデータを送信するためにsend関数を使用します。

const char *message = "Hello from client!";
ssize_t bytes_sent;

bytes_sent = send(sockfd, message, strlen(message), 0);
if (bytes_sent == -1) {
    perror("send");
    close(sockfd);
    exit(EXIT_FAILURE);
}

データの受信

サーバーからのデータを受信するためにrecv関数を使用します。

char buffer[1024];
ssize_t bytes_received;

bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
if (bytes_received == -1) {
    perror("recv");
    close(sockfd);
    exit(EXIT_FAILURE);
}
buffer[bytes_received] = '\0';
printf("Received message: %s\n", buffer);

接続の終了

通信が終了したら、ソケットを閉じます。

close(sockfd);

クライアント側の完全な実装例

以下に、クライアント側のソケットプログラムの完全な実装例を示します。この例では、サーバーに接続し、メッセージを送信して応答を受信する簡単なクライアントを実装しています。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int sockfd;
    struct sockaddr_in server_addr;
    char buffer[1024];
    ssize_t bytes_sent, bytes_received;

    // ソケットの作成
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // サーバーアドレス構造体の設定
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    // サーバーへの接続
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("connect");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // データの送信
    const char *message = "Hello from client!";
    bytes_sent = send(sockfd, message, strlen(message), 0);
    if (bytes_sent == -1) {
        perror("send");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // データの受信
    bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
    if (bytes_received == -1) {
        perror("recv");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    buffer[bytes_received] = '\0';
    printf("Received message: %s\n", buffer);

    // 接続の終了
    close(sockfd);

    return 0;
}

このコードは、基本的なクライアントソケットを作成し、サーバーに接続してメッセージを送信し、サーバーからの応答を受信する一連の処理を行っています。次に、ソケットを使用したデータ送受信の詳細な実装方法について解説します。

データ送受信の実装

ソケットプログラミングでは、データの送受信が最も重要な部分です。ここでは、ソケットを使用してデータを送受信する方法について詳しく解説します。

データ送信の実装

データを送信するためには、サーバー側とクライアント側の両方でsend関数を使用します。この関数は、送信するデータのバイト数を返します。

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

例えば、クライアント側からサーバー側に文字列を送信する場合のコードは以下の通りです。

const char *message = "Hello from client!";
ssize_t bytes_sent;

bytes_sent = send(sockfd, message, strlen(message), 0);
if (bytes_sent == -1) {
    perror("send");
    close(sockfd);
    exit(EXIT_FAILURE);
}

データ受信の実装

データを受信するためには、サーバー側とクライアント側の両方でrecv関数を使用します。この関数は、受信したデータのバイト数を返します。

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

例えば、サーバー側がクライアントから送信されたデータを受信する場合のコードは以下の通りです。

char buffer[1024];
ssize_t bytes_received;

bytes_received = recv(client_sockfd, buffer, sizeof(buffer) - 1, 0);
if (bytes_received == -1) {
    perror("recv");
    close(client_sockfd);
    close(sockfd);
    exit(EXIT_FAILURE);
}
buffer[bytes_received] = '\0';
printf("Received message: %s\n", buffer);

実際のデータ送受信の流れ

ここでは、サーバーとクライアント間でメッセージをやり取りする具体的な例を示します。

サーバー側

サーバー側では、クライアントからメッセージを受信し、それに応答する形でメッセージを送信します。

// データの受信
bytes_received = recv(client_sockfd, buffer, sizeof(buffer) - 1, 0);
if (bytes_received == -1) {
    perror("recv");
    close(client_sockfd);
    close(sockfd);
    exit(EXIT_FAILURE);
}
buffer[bytes_received] = '\0';
printf("Received message: %s\n", buffer);

// データの送信
const char *response = "Hello from server!";
bytes_sent = send(client_sockfd, response, strlen(response), 0);
if (bytes_sent == -1) {
    perror("send");
    close(client_sockfd);
    close(sockfd);
    exit(EXIT_FAILURE);
}

クライアント側

クライアント側では、サーバーにメッセージを送信し、サーバーからの応答を受信します。

// データの送信
const char *message = "Hello from client!";
bytes_sent = send(sockfd, message, strlen(message), 0);
if (bytes_sent == -1) {
    perror("send");
    close(sockfd);
    exit(EXIT_FAILURE);
}

// データの受信
bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
if (bytes_received == -1) {
    perror("recv");
    close(sockfd);
    exit(EXIT_FAILURE);
}
buffer[bytes_received] = '\0';
printf("Received message: %s\n", buffer);

これで、基本的なデータ送受信の実装方法が理解できたと思います。次に、ソケットプログラミングにおけるエラーハンドリングの重要性とその方法について解説します。

エラーハンドリング

ソケットプログラミングでは、エラーハンドリングが非常に重要です。ネットワーク通信は予期しないエラーが発生する可能性が高いため、適切なエラーハンドリングを行うことで、アプリケーションの信頼性と安定性を向上させることができます。ここでは、ソケットプログラミングでよく発生するエラーとその対処方法について解説します。

ソケット作成時のエラー

ソケットの作成時には、socket関数が失敗することがあります。この場合、戻り値として-1が返され、errno変数にエラーの詳細が設定されます。

int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
    perror("socket");
    exit(EXIT_FAILURE);
}

perror関数は、errnoに基づいてエラーメッセージを表示します。この例では、ソケット作成に失敗した場合、エラーメッセージが表示され、プログラムが終了します。

バインド時のエラー

ソケットを特定のアドレスとポートにバインドする際にbind関数が失敗することがあります。この場合も、-1が返され、errnoにエラーの詳細が設定されます。

if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    perror("bind");
    close(sockfd);
    exit(EXIT_FAILURE);
}

接続時のエラー

クライアントがサーバーに接続する際にconnect関数が失敗することがあります。この場合も同様にエラーハンドリングを行います。

if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    perror("connect");
    close(sockfd);
    exit(EXIT_FAILURE);
}

データ送信・受信時のエラー

データ送信や受信時には、send関数やrecv関数が失敗することがあります。これらの関数が-1を返した場合、エラーが発生したことを意味します。

ssize_t bytes_sent = send(sockfd, message, strlen(message), 0);
if (bytes_sent == -1) {
    perror("send");
    close(sockfd);
    exit(EXIT_FAILURE);
}

ssize_t bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0);
if (bytes_received == -1) {
    perror("recv");
    close(sockfd);
    exit(EXIT_FAILURE);
}

一般的なエラーハンドリングの例

以下に、エラーハンドリングを含む一般的なソケットプログラムの例を示します。この例では、各ステップでエラーが発生した場合に適切な処理を行います。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

int main() {
    int sockfd, client_sockfd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    char buffer[1024];
    ssize_t bytes_sent, bytes_received;

    // ソケットの作成
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // アドレス構造体の設定
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    // ソケットのバインド
    if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // ソケットのリッスン
    if (listen(sockfd, 5) == -1) {
        perror("listen");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on port 8080...\n");

    // 接続の受け入れ
    client_sockfd = accept(sockfd, (struct sockaddr *)&client_addr, &client_addr_len);
    if (client_sockfd == -1) {
        perror("accept");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // データの受信
    bytes_received = recv(client_sockfd, buffer, sizeof(buffer) - 1, 0);
    if (bytes_received == -1) {
        perror("recv");
        close(client_sockfd);
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    buffer[bytes_received] = '\0';
    printf("Received message: %s\n", buffer);

    // データの送信
    const char *response = "Hello from server!";
    bytes_sent = send(client_sockfd, response, strlen(response), 0);
    if (bytes_sent == -1) {
        perror("send");
        close(client_sockfd);
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // 接続の終了
    close(client_sockfd);
    close(sockfd);

    return 0;
}

このコード例では、各ステップでエラーハンドリングを行い、エラーが発生した場合に適切なメッセージを表示し、リソースを解放してプログラムを終了します。

次に、ソケットプログラミングを応用した簡易チャットアプリの作成方法について解説します。

応用例：簡易チャットアプリの作成

ソケットプログラミングの学習を応用して、簡易チャットアプリを作成します。このアプリは、サーバーと複数のクライアント間でメッセージを送受信することができます。

サーバー側の実装

サーバー側のプログラムでは、クライアントからの接続を受け入れ、各クライアントから送信されたメッセージを他の全クライアントに中継します。以下にサーバー側のコードを示します。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <pthread.h>

#define MAX_CLIENTS 10
#define BUFFER_SIZE 1024

int client_sockets[MAX_CLIENTS];
int client_count = 0;
pthread_mutex_t clients_mutex = PTHREAD_MUTEX_INITIALIZER;

void *handle_client(void *client_socket) {
    int sockfd = *(int *)client_socket;
    char buffer[BUFFER_SIZE];
    ssize_t bytes_received;

    while ((bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0)) > 0) {
        buffer[bytes_received] = '\0';
        printf("Received message: %s\n", buffer);

        // 他のクライアントにメッセージを中継
        pthread_mutex_lock(&clients_mutex);
        for (int i = 0; i < client_count; i++) {
            if (client_sockets[i] != sockfd) {
                send(client_sockets[i], buffer, bytes_received, 0);
            }
        }
        pthread_mutex_unlock(&clients_mutex);
    }

    // クライアントの接続終了
    close(sockfd);
    pthread_mutex_lock(&clients_mutex);
    for (int i = 0; i < client_count; i++) {
        if (client_sockets[i] == sockfd) {
            for (int j = i; j < client_count - 1; j++) {
                client_sockets[j] = client_sockets[j + 1];
            }
            client_count--;
            break;
        }
    }
    pthread_mutex_unlock(&clients_mutex);
    free(client_socket);
    return NULL;
}

int main() {
    int server_sockfd, *client_sockfd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    pthread_t tid;

    // ソケットの作成
    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // アドレス構造体の設定
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = INADDR_ANY;

    // ソケットのバインド
    if (bind(server_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        close(server_sockfd);
        exit(EXIT_FAILURE);
    }

    // ソケットのリッスン
    if (listen(server_sockfd, MAX_CLIENTS) == -1) {
        perror("listen");
        close(server_sockfd);
        exit(EXIT_FAILURE);
    }

    printf("Server is listening on port 8080...\n");

    // クライアントの接続受け入れ
    while (1) {
        client_sockfd = malloc(sizeof(int));
        *client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_addr, &client_addr_len);
        if (*client_sockfd == -1) {
            perror("accept");
            free(client_sockfd);
            continue;
        }

        pthread_mutex_lock(&clients_mutex);
        client_sockets[client_count++] = *client_sockfd;
        pthread_mutex_unlock(&clients_mutex);

        pthread_create(&tid, NULL, handle_client, client_sockfd);
        pthread_detach(tid);
    }

    close(server_sockfd);
    return 0;
}

クライアント側の実装

クライアント側のプログラムでは、サーバーに接続し、ユーザーが入力したメッセージをサーバーに送信し、サーバーからのメッセージを受信します。以下にクライアント側のコードを示します。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <pthread.h>

#define BUFFER_SIZE 1024

void *receive_messages(void *client_socket) {
    int sockfd = *(int *)client_socket;
    char buffer[BUFFER_SIZE];
    ssize_t bytes_received;

    while ((bytes_received = recv(sockfd, buffer, sizeof(buffer) - 1, 0)) > 0) {
        buffer[bytes_received] = '\0';
        printf("Received message: %s\n", buffer);
    }

    return NULL;
}

int main() {
    int sockfd;
    struct sockaddr_in server_addr;
    pthread_t tid;
    char message[BUFFER_SIZE];

    // ソケットの作成
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) {
        perror("socket");
        exit(EXIT_FAILURE);
    }

    // サーバーアドレス構造体の設定
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(8080);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    // サーバーへの接続
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("connect");
        close(sockfd);
        exit(EXIT_FAILURE);
    }

    // メッセージ受信スレッドの作成
    pthread_create(&tid, NULL, receive_messages, &sockfd);

    // ユーザー入力の送信
    while (fgets(message, sizeof(message), stdin) != NULL) {
        send(sockfd, message, strlen(message), 0);
    }

    close(sockfd);
    return 0;
}

この簡易チャットアプリケーションは、複数のクライアントがサーバーに接続し、リアルタイムでメッセージを交換することができます。サーバー側はスレッドを利用して複数のクライアントを同時に処理し、クライアント側は別のスレッドを使ってサーバーからのメッセージを受信します。

次に、ソケットプログラミングを学習するための演習問題について解説します。

演習問題

ソケットプログラミングの理解を深めるために、以下の演習問題に挑戦してみてください。各問題にはヒントとアプローチ方法も記載していますので、参考にしてください。

演習問題1：エコーサーバーの実装

クライアントから送信されたメッセージをそのまま返す「エコーサーバー」を実装してみましょう。エコーサーバーは、クライアントが送信したデータをそのままクライアントに返すサーバーです。

ヒント

  • サーバー側でクライアントからのデータを受信し、そのデータを再送信するだけです。
  • クライアント側でメッセージを送信し、サーバーからの応答を受信します。

アプローチ

  1. サーバー側でソケットを作成し、クライアントからの接続を受け入れる。
  2. クライアントからデータを受信し、そのデータをそのまま送信する。
  3. クライアント側でサーバーにメッセージを送信し、エコーメッセージを受信する。

演習問題2：ブロードキャストチャットサーバーの実装

複数のクライアントが参加できるチャットサーバーを実装してみましょう。各クライアントが送信したメッセージを他の全クライアントにブロードキャストします。

ヒント

  • 各クライアントをスレッドで処理し、メッセージを他のクライアントにブロードキャストします。
  • サーバー側で接続されたクライアントをリストで管理します。

アプローチ

  1. サーバー側でソケットを作成し、クライアントからの接続を受け入れる。
  2. 各クライアントをスレッドで処理し、メッセージを他の全クライアントに送信する。
  3. クライアント側でサーバーに接続し、メッセージを送信・受信する。

演習問題3：ファイル転送の実装

クライアントからサーバーにファイルを送信し、サーバーでそのファイルを保存するプログラムを実装してみましょう。

ヒント

  • ファイルの送信と受信には、ソケットの送受信関数を使用します。
  • バイナリデータを扱うため、適切なバッファサイズとエラーハンドリングを行います。

アプローチ

  1. クライアント側でファイルを読み込み、サーバーにデータを送信する。
  2. サーバー側でデータを受信し、ファイルとして保存する。
  3. クライアントとサーバーの間でデータの送受信が正しく行われるようにエラーハンドリングを実装する。

演習問題4：マルチスレッドHTTPサーバーの実装

基本的なHTTPサーバーを実装し、複数のクライアントからのリクエストに応答するプログラムを作成してみましょう。

ヒント

  • HTTPプロトコルに従い、GETリクエストに対してHTMLファイルを返します。
  • 各クライアントをスレッドで処理し、並行してリクエストに応答します。

アプローチ

  1. サーバー側でソケットを作成し、クライアントからの接続を受け入れる。
  2. 各クライアントをスレッドで処理し、GETリクエストに対してHTMLファイルを返す。
  3. クライアント側でブラウザやHTTPクライアントを使用してサーバーにリクエストを送信し、応答を確認する。

これらの演習問題を通じて、ソケットプログラミングの実践的なスキルを身につけることができます。ぜひ挑戦してみてください。

まとめ

C言語によるソケットプログラミングは、ネットワーク通信を実現するための基本技術であり、様々なネットワークアプリケーションの基盤となります。本記事では、ソケットプログラミングの基本的な概念から、実際のサーバー・クライアントの実装、データ送受信の方法、エラーハンドリング、そして応用例としての簡易チャットアプリの作成までを詳しく解説しました。

ソケットプログラミングを習得することで、ネットワークを介した様々な通信プロトコルの実装や、複雑なネットワークアプリケーションの開発が可能になります。また、演習問題を通じて実際に手を動かしながら学ぶことで、実践的なスキルを磨くことができます。

今後は、さらに高度なプロトコルやセキュリティ対策などを学び、より複雑で安全なネットワークプログラミングに挑戦してみてください。

C言語
ネットワーク通信 ソケットプログラミング C言語 プログラミング入門

コメント

コメントする

目次