クライアントはサーバーに対して情報やデータの要求を行い、
サーバーはクライアントからの要求に応じて、返答として、
該当する情報やデータを送る。

「こんな事もあろうかと」と言って、ドラえもんのポケットの如く
何でも発明品を出す時のセリフ。宇宙戦艦ヤマトの技師長・真田が起源らしい。

その後、アニメなどで発明好きのキャラのセリフで引用されているようだ。
赤ずきんチャチャの、やっこちゃんも使っている。

実は、シェルの本を読む前に、アルゴリズムの本を読んだりなど、
詰め込み作業だけでなく、頭を最大限に稼働させる日が何ヶ月も続いていた。
暗記だけでなく、頭の回転も要求されるとなると、かなり頭が疲れる。

だんだんと寝つきが悪くなるは、夜中に目が覚めるわ、
精神的に不安定になるわで、ノイローゼ気味になり、
ついには精神科へ通院する事になった。

オープンソースの開発者のような凄い実力の持ち主なら大丈夫な事でも
ただの事務員が無理をすると、精神的にやられてしまうのらー！！
通院のため医療費が1万円以上かかったのが痛い （ＴＴ）

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    pid_t pid ;
    char buffer[256];
    int pp[2];

    /*  パイプの作成 */
    pipe(pp);

    pid = fork();  /* 子のプロセスの生成 */

    /*  子プロセスの動き */
    if ( pid == 0 )
       {
       close(pp[0]);
       fgets(buffer,256,stdin);
       write(pp[1],buffer,strlen(buffer)+1); /* パイプへ書き込み */
       close(pp[1]);
       }
    /*  親プロセスの動き */
    else
       {
       close(pp[1]);
       read(pp[0],buffer,256); /* パイプから読み込み */
       printf("Message From Child : %s\n",buffer);
       close(pp[0]);
       }

return(0);
}

suga@jitaku[~/pipe]% ./pipe1
test message  ← 子プロセスで文字列を入力
Message From Child : test message ← 子プロセスから送られた文字列を親プロセスで出力

suga@jitaku[~/pipe]% 

プログラムを見て「エラー処理をしていないではないか」という
ツッコミをいただくかもしれません。

本来ならエラー処理をいれる必要があると思いますが、悩みました。
エラー処理を省いた方がソースが見やすくなるのではないかと考え、
敢えて、省く事にしました。

子プロセスから足し合わせたい数字を文字列の形にして親プロセスに送る。
親プロセスは、足し合わせた結果を文字列にして、子プロセスに送り
子プロセスは結果を表示させる。

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    pid_t pid ;
    char buffer[10],result[10];
    int pp[2] , qq[2];
    int a , b , c ;

    pipe(pp); /* 親へデータを送るためのパイプ */
    pipe(qq); /* 計算結果を子に送るためのパイプ */

    pid = fork();  /* 親子のプロセスの生成 */

    /*  子プロセスの動き */
    if ( pid == 0 )
       {
       close(pp[0]);
       close(qq[1]);

       /*  1つ目の変数の代入とパイプへの書き込み */
       printf("a = ");
       fgets(buffer,10,stdin);
       write(pp[1],buffer,strlen(buffer)+1);

       /*  2つ目の変数の代入とパイプへの書き込み */
       printf("b = ");
       fgets(buffer,10,stdin);
       write(pp[1],buffer,strlen(buffer)+1);

       /* 計算結果を読み込む */
       read(qq[0],result,10);

       printf("a + b = %s\n",result);
       close(qq[0]);
       close(pp[1]);
       }
    /*  親プロセスの動き */
    else
       {
       close(qq[0]);
       close(pp[1]);

       /* 1つ目の変数の読み込み */
       read(pp1[0],buffer,256);
       a = atoi(buffer);

      /* 2つ目の変数の読み込み */
       read(pp2[0],buffer,256);
       b = atoi(buffer);

       c = a + b ; /* 計算 */
       sprintf(buffer,"%d",c);

       /* 計算結果をパイプへ書き込む */
       write(qq[1],buffer,strlen(buffer)+1);

       close(pp[0]);
       close(qq[1]);
       }

return(0);
}

suga@jitaku[~/pipe]% ./pipe2
a = 5 ← 子プロセスで文字列を入力
b = 3 ← 子プロセスで文字列を入力
suga@jitaku[~/pipe]% a + b = 8 ← 親プロセスでの計算結果を子プロセスが表示

上図のように、プロセスAはFIFOファイルに送りたいデータを書き込み
プロセスBは、受信データを取得するため、FIFOファイルを読み込む
という形をとる。

FIFOファイルに書き込むために、まずはファイルオープンを行う。
この場合、低水準関数のopen()を使う。

書き込む際には、低水準のwrite()関数を使うのだが、
既に、FIFOファイルにデータがある場合は、他のプロセスによって
FIFOのデータが読み込まれ、データがなくなるまで
書き込みを待つ仕組みになっている。

FIFOファイルに読み込むために、まずはファイルオープンを行う。
この場合も、低水準関数のopen()を使う。

読み込む際には、低水準のwrite()関数を使うのだが、
まだ、FIFOファイルにデータが書き込まれていない場合は、
FIFOファイルにデータが書き込まれるまで待つ仕組みになっている。

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    int fifodes ;
    char buffer[256];

    /*  FIFO ファイルをオープンにする */
    fifodes = open("my_fifo",O_WRONLY);

    fgets(buffer,256,stdin);

    /* データを送信する */
    write(fifodes,buffer,strlen(buffer)+1);

    close(fifodes);

return(0);
}

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    int fifodes ;
    char buffer[256];

    /*  「my_fifo」という名のFIFOファイルの作成 */
    mkfifo("my_fifo",0777);

    /*  FIFO ファイルをオープンにする */
    fifodes = open("my_fifo",O_RDONLY);

    /* データを受信する */
    read(fifodes,buffer,256);

    printf("Message: %s",buffer);

    close(fifodes);

return(0);
}

suga@jitaku[~/pipe]% ./fifo-cli1
Test data!  ← 送信した文字列   
suga@jitaku[~/pipe]% 

suga@jitaku[~/pipe]% ./fifo-ser1
Message: Test data!  ← 受信した文字列
suga@jitaku[~/pipe]% 

prwxr-xr-x    1 suga     users           0  1月  2日  13:05 my_fifo|

パーミッションの部分の「p」はパイプファイル(FIFO)を意味する。
そして、ファイル名の後ろに「|」もパイプファイル(FIFO)を意味する。

プロセスAから足し合わせたい数字を文字列の形にして、プロセスBに送る。
プロセスBは、足し合わせた結果を文字列にして、プロセスAに送り返し
プロセスAは結果を表示させる。

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    int des1,des2 ;
    int a , b ;
    char buffer[256], result[10];

    des1 = open("fifo1.dat",O_WRONLY);
    des2 = open("fifo2.dat",O_RDONLY);

    /* サーバーへ値を送信：その1 */
    printf("a = ");
    fgets(buffer,256,stdin);
    write(des1,buffer,strlen(buffer)+1);

    /* サーバーへ値を送信：その2 */
    printf("b = ");
    fgets(buffer,256,stdin);
    write(des1,buffer,strlen(buffer)+1);

    /* サーバーから計算結果を受信 */
    read(des2,result,10);
    printf("a + b = %s\n",result);

    close(des1);
    close(des2);

return(0);
}

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    int des1,des2 ;
    int a , b, c ;
    char buffer[256] , result[10] ;

    
    mkfifo("fifo1.dat",0777); /* サーバーへ送信用のFIFO */
    mkfifo("fifo2.dat",0777); /* クライアントへ送信用のFIFO */

    des1 = open("fifo1.dat",O_RDONLY);
    des2 = open("fifo2.dat",O_WRONLY);

    /* クライアントからの受信：その1 */
    read(des1,buffer,256);
    a = atoi(buffer);

    /* クライアントからの受信：その2 */
    read(des1,buffer,256);
    b = atoi(buffer);

    c = a + b ;
    sprintf(result,"%d",c);

    /* クライアントへ計算結果を送信 */
    write(des2,result,strlen(result)+1);

    close(des1);
    close(des2);

return(0);
}

suga@jitaku[~/pipe]% ./fifo-cli11
a = 5 ← 送信した文字列   
b = 3 ← 送信した文字列   
a + b = 8 ← サーバーから返ってきた結果  
suga@jitaku[~/pipe]% 

suga@jitaku[~/pipe]% ./fifo-ser12
suga@jitaku[~/pipe]% 

ノンブロック(O_NONBLOCK)を付けると、FIFOファイルの中身がない場合、
データの取得を諦めて終わらせる働きをする。

ノンブロックなので、FIFOファイルに中身がなければ
FIFOファイルをブロックしないで読み込みを諦めるという話だ。

ノンブロック(O_NONBLOCK)を付けると、FIFOファイルの中身がある場合、
書き込みを諦めて終わらせる働きがある。

ノンブロックなので、FIFOファイルに中身があれば、
FIFOファイルをブロックしないで書き込みを諦めるという話だ。

まず最初に、共有メモリにアクセスするための共通キーを決める。
そして、その共通キーをshmget()関数に代入し、識別子を得る。
次に、その識別子をshmat()関数に代入して、確保した共有メモリの
先頭のアドレスを得る。

共有メモリを使い終えると、shmdt()関数で、使い終えたのを知らせる。

shmget()関数には、キー、確保するメモリの量、パーミッションの
3つの引数がある。

パーミッションの設定だが、chmodコマンドの時に使う数字の設定と同じだ。
ただ、新しく共有メモリを生成する場合は、「IPC_CREAT」を付ける必要がある。
もし、既に共有メモリがあった場合は、「IPC_CREAT」は無視されるため、
「IPC_CREAT」は、おまじないという感じで付けておくのが無難かも。

shmat()関数には、識別子と、残り2つの引数がある。
通常は、2つ目の引数の所はヌルポインタ、3つ目は「0」をいれる。

なぜそうなのかと聞かれても、私も、わからない (^^;;
プログラマーでも何でもない、タダの事務員なので、許してね。

この関数の返り値は、共有メモリの先頭アドレス(void型)だ。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct transfer_data {
    int  no ;
    char name[10];
    int  flag ; /*  0:未入力 1:入力済み 2:サーバーで出力済み */
};  /* 共有メモリに渡すデータの構造 */

int main(void)
{
    char no[10] ; 
    int shmid ;
    void *shared_mem ;

    /* 共有メモリのアドレスを格納する変数の宣言 */
    struct transfer_data *mem ;

    shmid = shmget( (key_t)12345 , 100 , 0777 | IPC_CREAT );
    shared_mem = shmat(shmid,(void *)0 ,0 );

    /* 取得した共有メモリのアドレスを変数 mem へ代入 */
    mem = (struct transfer_data *)shared_mem ;

    mem->flag = 0 ;

    printf("No = ");
    fgets(no,10,stdin);
    mem->no = atoi(no);

    printf("name = ");
    fgets(mem->name,10,stdin);

    mem->flag = 1 ;
    while(1)
        {
        if ( mem->flag == 2 ) break ;
        }

    shmdt(shared_mem);

    return(0);
}

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct transfer_data {
    int  no ;
    char name[10];
    int  flag ; /*  0:未入力 1:入力済み 2:サーバーで出力済み */
};  /* 共有メモリに渡すデータの構造 */

int main(void)
{
    int shmid ;
    void *shared_mem ;

    /* 共有メモリのアドレスを格納する変数の宣言 */
    struct transfer_data *mem ;

    shmid = shmget( (key_t)12345 , 4096 , 0777 | IPC_CREAT );
    shared_mem = shmat(shmid,(void *)0 ,0 );

    /* 取得した共有メモリのアドレスを変数 mem へ代入 */
    mem = (struct transfer_data *)shared_mem ;

    while(1)
         {
         if ( mem->flag == 1 )
            {
            printf("No : %d\n",mem->no);
            printf("name : %s\n",mem->name);
            mem->flag = 2 ;
            }
         }

    return(0);
}

suga@jitaku[~/pipe]% ./mem-cli1
No = 10           ← 送信した数値  
name = ono-mayumi ← 送信した文字列  
suga@jitaku[~/pipe]% 

suga@jitaku[~/pipe]% ./mem-ser1
No : 10           ← 受信した数値 
name : ono-mayum  ← 受信した文字列

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct transfer_data {
    int a ;
    int b ;
    int c ;
    int flag ; /*  0:未入力 1:入力済み 2:サーバーで計算済み */
};  /* 共有メモリに渡すデータの構造 */

int main(void)
{
    char a[10] , b[10] ;
    int shmid ;
    void *shared_mem ;

    struct transfer_data *mem ;

    shmid = shmget( (key_t)12345 , 100 , 0777 | IPC_CREAT );
    shared_mem = shmat(shmid,(void *)0 ,0 );
    mem = (struct transfer_data *)shared_mem ;

    mem->flag = 0 ;

    printf("a = ");
    fgets(a,10,stdin);
    mem->a = atoi(a);

    printf("b = ");
    fgets(b,10,stdin);
    mem->b = atoi(b);

    mem->c = 0 ;

    mem->flag = 1 ;
    while(1)
        {
        if ( mem->flag == 2 ) break ;
        }

    printf("a + b = %d\n",mem->c);

    shmdt(shared_mem);

    return(0);
}

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct transfer_data {
    int a ;
    int b ;
    int c ;
    int flag ; /*  0:未入力 1:入力済み 2:サーバーで計算済み */
};  /* 共有メモリに渡すデータの構造 */

int main(void)
{
    int shmid ;
    void *shared_mem ;

    struct transfer_data *mem ;

    shmid = shmget( (key_t)12345 , 4096 , 0777 | IPC_CREAT );
    shared_mem = shmat(shmid,(void *)0 ,0 );
    mem = (struct transfer_data *)shared_mem ;

    while(1)
         {
         if ( mem->flag == 1 )
            {
            printf("a = %d\n",mem->a);
            printf("b = %d\n",mem->b);
            printf("只今 %d + %d を計算中\n",mem->a,mem->b);
            mem->c = mem->a + mem->b ; 
            mem->flag = 2 ;
            }
         }

    return(0);
}

suga@jitaku[~/pipe]% ./mem-cli2
a = 5  ← 送信した数値  
b = 3  ← 送信した数値  
a + b = 8  ← 受信した計算結果  
suga@jitaku[~/pipe]% 

suga@jitaku[~/pipe]% ./mem-ser2
a = 5
b = 3
只今 5 + 3 を計算中

#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>

int main(void)
{
  int sockfd ;
  int len ;
  struct sockaddr_un address ;
  int result ;
  char ch = 'A' ;

  sockfd = socket(AF_UNIX,SOCK_STREAM,0);

  address.sun_family = AF_UNIX ;
  strcpy(address.sun_path , "server_socket");
  len = sizeof(address);

  result = connect(sockfd , (struct sockaddr *)&address , len);

  if ( result == -1 ) {
    perror("oops: client1");
    exit(1);
  }

  write(sockfd,&ch,1);
  read(sockfd,&ch,1);
  printf("char from server = %c \n",ch);
  close(sockfd);
  exit(0);
}

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>

int main(void)
{
  int server_sockfd , client_sockfd ;
  int server_len , client_len ;
  struct sockaddr_un server_address ;
  struct sockaddr_un client_address ;

  unlink("server_socket");
  server_sockfd = socket(AF_UNIX,SOCK_STREAM,0);
  server_address.sun_family = AF_UNIX ;
  strcpy(server_address.sun_path , "server_socket");
  server_len = sizeof(server_address);
  bind(server_sockfd , (struct sockaddr *)&server_address , server_len);

  listen(server_sockfd , 5);
  while(1) {
    char ch ;

    printf("server waiting\n");

    client_sockfd = accept(server_sockfd ,
                    (struct sockaddr *)&client_address , &client_len);

    read(client_sockfd,&ch,1);
    ch++;
    write(client_sockfd,&ch,1);
    close(client_sockfd);
  }
}

suga@jitaku[~/pipe]% ./client1
char from server = B ← サーバーから受信した文字列  
suga@jitaku[~/pipe]% 

suga@jitaku[~/pipe]% ./server1
server waiting
server waiting

sockfd = socket(AF_UNIX,SOCK_STREAM,0);

sockfd = socket(AF_INET,SOCK_STREAM,0);

FIFOファイルと同様に、通信を仲介するためのファイルが生成される。
FIFOファイルとの違いは、FIFOの場合、一方通行だったのに対して
ソケットファイルは、1つのファイルで双方向の通信が可能だ。

srwxr-xr-x    1 suga     users           0  1月  2日  11:55 server_socket=

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(void)
{
  int sockfd ;
  int len ;
  struct sockaddr_in address ;
  int result ;
  char ch = 'A' ;

  sockfd = socket(AF_INET,SOCK_STREAM,0);

  address.sin_family = AF_INET ;
  address.sin_addr.s_addr = inet_addr("192.168.1.10");
  address.sin_port = 9734 ;
  len = sizeof(address);

  result = connect(sockfd , (struct sockaddr *)&address , len);

  if ( result == -1 ) {
    perror("oops: client2");
    exit(1);
  }

  write(sockfd,&ch,1);
  read(sockfd,&ch,1);
  printf("char from server = %c \n",ch);
  close(sockfd);
  exit(0);
}

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(void)
{
  int server_sockfd , client_sockfd ;
  int server_len , client_len ;
  struct sockaddr_in server_address ;
  struct sockaddr_in client_address ;

  server_sockfd = socket(AF_INET,SOCK_STREAM,0);
  server_address.sin_family = AF_INET ;
  server_address.sin_addr.s_addr = inet_addr("127.0.0.1");
  server_address.sin_port = 9734 ;

  server_len = sizeof(server_address);
  bind(server_sockfd , (struct sockaddr *)&server_address , server_len);

  listen(server_sockfd , 5);
  while(1) {
    char ch ;

    printf("server waiting\n");

    client_sockfd = accept(server_sockfd ,
                    (struct sockaddr *)&client_address , &client_len);

    read(client_sockfd,&ch,1);
    ch++;
    write(client_sockfd,&ch,1);
    close(client_sockfd);
  }
}

suga@jitaku[~/pipe]% ./client2
char from server = B ← サーバーから受信した文字列  
suga@jitaku[~/pipe]% 

suga@jitaku[~/pipe]% ./server2
server waiting
server waiting

コネクション型(TCP方式)の時の、プログラムの流れです。
コネクションレス型(UPD方式)の場合は、違う方法になります。

こういう図があると、全体の流れが見えるので、わかりやすい。

通常、使うのは、「AF_UNIX」、「AF_INET」の2種類。

AF_UNIXは、ソケットファイルを作成して
同じマシン同士での通信の時に選ぶ。

AF_INETは、異なるマシン同士の通信を行う時に選ぶ。

ドメインで「AF_INET」を選ばれた場合、
TCP通信の場合、SOCK_STREAMを指定する。
UDP通信の場合、SOCK_DGRAMを指定する。

ドメインで「AF_UNIX」を選ばれた場合は、
無条件でSOCK_STREAMを指定する。

クライアントのプロセスからサーバー側のソケットに接続するために
目印になるような名前をつけます。
この時、クライアントには何も設定しません。

引数に、ソケットディスクリプタ、アドレス構造体のポインタ、
アドレス構造体の長さがあります。

そして、ソケットに名前をつけるのに成功したら「0」を返します。
失敗の場合は「-1」を返します。

struct sockaddr_un
  {
    sa_family_t sun_family ;
    char sun_path[];         /* Path name.  */
  };

sun_familyのメンバには「AF_UNIX」を入れる
sun_path[]のメンバには、ソケットファイルのファイル名を入れる

この構造体は、sys/un.h のヘッダーで定義されているため、
AF_UNIXのソケット通信を行う際にはプログラムに 
#include <sys/un.h> をいれて、ヘッダーを取り込む必要がある。

struct sockaddr_in
  {
    short int  sin_family ;
    int        sin_port;                 /* Port number.  */
    struct in_addr sin_addr;            /* Internet address.  */
  };

sin_familyのメンバには「AF_INET」を入れる。
sin_portのメンバには、通信ポート番号を入れる。
sin_addrのメンバには、IPアドレス(32ビット)を入れる
IPを32ビットの数値に変換させる関数があります（後述しています）

ちなみに、このIPアドレスは、クライアント側の場合は接続先のIPを入れ
サーバー側の場合は、サーバー自身のIPを入れる。
サーバー側のIPについては、詳しい事は後述しています。

この構造体は、netinet/in.h のヘッダーで定義されているため、
AF_INETのソケット通信を行う際にはプログラムに 
#include <netinet/in.h> をいれて、ヘッダーを取り込む必要がある。

/* アドレス構造体の定義したヘッダー */
#include <sys/un.h>

/*  アドレス構造体の変数を宣言 */
struct sockaddr_un server_address ;

/* アドレス構造体に代入 */
server_address.sun_family = AF_UNIX ;
strcpy(server_address.sun_path , "server_socket");  /* ソケットファイル名 */

/* アドレス構造体の長さ */
server_len = sizeof(server_address);

/* bind()関数の使い方 */
bind(server_sockfd , (struct sockaddr *)&server_address , server_len);

/* アドレス構造体の定義したヘッダー */
#include <netinet/in.h>

/*  アドレス構造体の変数を宣言 */
struct sockaddr_in server_address ;

/* アドレス構造体に代入 */
server_address.sin_family = AF_INET ;
server_address.sin_addr.s_addr = inet_addr("127.0.0.1");  /* IPアドレス */
server_address.sin_port = 9734 ; /* ポート番号 */

/* アドレス構造体の長さ */
server_len = sizeof(server_address);

/* bind()関数の使い方 */
bind(server_sockfd , (struct sockaddr *)&server_address , server_len);

最大処理待ちの数を代入します。
本では「5」が一般的と書いていますので、ここではとりあえず「5」にします。
返り値は成功した場合は「0」、失敗の場合は「-1」です。
使い方は、そのまま代入するだけです。

listen(socket_d , 5);

2番目のアドレス構造体ですが、サーバー側のアドレス構造体ではありません。
connect()で接続要求してきたクライアントの情報が入ったアドレス構造体です。
アドレス構造体の長さも、クライアントのアドレス構造体の長さです。

返り値は、クライアントとの通信のためのディスクリプタです。

connetc()を使ってクライアントが接続要求を行います。
そして、サーバーがaccept()で受け入れを行った時、
サーバー側で通信用のソケットが生成され、通信用のソケットを使い
実際のデータ通信が行われます。

そして、前からあったソケットは、次の接続要求の待ち受けを行います。

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(void)
{
  int sockfd ;
  int len ;
  struct sockaddr_in address ;
  int result ;
  int ch[3] ;

  sockfd = socket(AF_INET,SOCK_STREAM,0);

  address.sin_family = AF_INET ;
  address.sin_addr.s_addr = inet_addr("192.168.1.10");
  address.sin_port = htons(9734) ;
  len = sizeof(address);

  result = connect(sockfd , (struct sockaddr *)&address , len);

  if ( result == -1 ) {
    perror("oops: client3");
    exit(1);
  }

  printf("A = ");
  scanf("%d",&ch[0]);

  printf("B = ");
  scanf("%d",&ch[1]);

  write(sockfd,ch,sizeof(ch));
  read(sockfd,ch,sizeof(ch));

  printf("A + B = %d \n",ch[2]); 

  close(sockfd);
  exit(0);
}

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(void)
{
  int server_sockfd , client_sockfd ;
  int server_len , client_len ;
  struct sockaddr_in server_address ;
  struct sockaddr_in client_address ;

  server_sockfd = socket(AF_INET,SOCK_STREAM,0);
  server_address.sin_family = AF_INET ;
  server_address.sin_addr.s_addr = INADDR_ANY ;
  server_address.sin_port = htons(9734) ;

  server_len = sizeof(server_address);
  bind(server_sockfd , (struct sockaddr *)&server_address , server_len);

  listen(server_sockfd , 5);
  while(1) {
    int ch[3] ;

    printf("server waiting\n");

    client_sockfd = accept(server_sockfd ,
                    (struct sockaddr *)&client_address , &client_len);

    read(client_sockfd,ch,sizeof(ch));
    ch[2] = ch[0] + ch[1] ;
    write(client_sockfd,ch,sizeof(ch));
    close(client_sockfd);
  }
}

suga@client[~/pro]% ./client3
A = 5      ← 送信した数値  
B = 3      ← 送信した数値  
A + B = 8  ← 受信した計算結果 
suga@client[~/pro]% 

suga@server[~/pipe]% ./server3
server waiting
server waiting

  server_address.sin_addr.s_addr = INADDR_ANY ;
  server_address.sin_port = htons(9734) ;

まずは下のポート番号を代入している部分で、htons()関数を使っています。
リトルエンディアンからビッグエンディアンに変換するための関数で、
標準的な通信では、ビッグエンディアンで行っているため、
インテルのCPUで扱う数値は、リトルエンディアンなので、
変換する必要があるためです。

次に、自分自身のIPアドレスの指定が「INADDR_ANY」になってます。
これは、自分自身が持っている、どのIP宛へも接続を許可するという意味です。
ここでは、IPアドレスは、32ビットの数値を代入します。

ちなみに、このIPアドレスも、実は、ビッグエンディアンなので、
本来ならhtons()関数を使って、htons(INADDR_ANY)が正しいのですが、
マクロを見ると「0」の事なので、htons()関数は省略しました。

上図のように、サーバー側で2枚指しのNIC(2つIPを持っている)状態で
接続許可のIPを、eth1側の「192.168.200.10」の許可だけとします。

クライアントが「192.168.1.10」宛に接続要求を行っても、
許可していないIP宛なので、クライアントの接続要求は拒否されます。

クライアントの接続があった場合、接続ソケットが生成され
今までのソケットは、他の接続の待ち受けを続けます。
そこで、接続ソケットが生成されたと同時に、fork()で親子を作り
クライアントの処理を子プロセスに任せるという。

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(void)
{
  int server_sockfd , client_sockfd ;
  int server_len , client_len ;
  struct sockaddr_in server_address ;
  struct sockaddr_in client_address ;

  server_sockfd = socket(AF_INET,SOCK_STREAM,0);
  server_address.sin_family = AF_INET ;
  server_address.sin_addr.s_addr = INADDR_ANY ;
  server_address.sin_port = htons(9734) ;

  server_len = sizeof(server_address);
  bind(server_sockfd , (struct sockaddr *)&server_address , server_len);

  listen(server_sockfd , 5);

  while(1) {
    int ch[3] ;

    printf("server waiting\n");

    client_sockfd = accept(server_sockfd ,
                    (struct sockaddr *)&client_address , &client_len);

    if ( fork() == 0 )
      {  
      /* 子プロセス */
      read(client_sockfd,ch,sizeof(ch));
      ch[2] = ch[0] + ch[1] ;
      write(client_sockfd,ch,sizeof(ch));
      close(client_sockfd);
      exit(0);
      }
    else /* 親プロセス */
      {
      close(client_sockfd);
      }
  }
}

コネクション通信の場合と違い、簡素化された感じがする。

コネクション通信の場合、接続要求を行い、接続が確立される。
お互いの通信が正常にできているか確かめながらデータ送信を行う。
しかし、コネクションレスの場合は、相手にデータを投げたら
投げっ放しなので、connect()、listen()、accept()といった関数が不要になる。

コネクション通信の場合、送信にはwrite()、受信にはread()を使ったが、
コネクションレスの場合、送信にはsendto()、受信にはrecvfrom()を使う。
ちなみに、sendto()、recvfrom()は、コネクション通信でも使える。

クライアントとサーバーの両方にソケットの名前をつける。

コネクション通信の場合、クライアントから接続要求を行うため、
サーバー側のソケットに名前をつければ、クライアントが認識でき、
しかも、サーバーは、接続確立をしているため、クライアント側のソケットの
名前を知らなくても通信ができる。

しかし、コネクションレス通信の場合、接続確立を行わなず、
お互いがデータを投げっ放しにするため、クライアント側にも名前をつけないと
サーバー側は、相手先がわからず、データが送信できないという。

アドレス構造体は、接続してきた所の情報を得るためにあるようだ。
アドレス構造体の長さのポインタだが、長さの値を入れる変数の
ポインタを意味する。

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(void)
{
  int sockfd ;
  int tolen , fromlen ;
  struct sockaddr_in to_address , from_address ;
  int result ;
  int ch[3] ;

  sockfd = socket(AF_INET,SOCK_DGRAM,0);

  to_address.sin_family = AF_INET ;
  to_address.sin_addr.s_addr = INADDR_ANY ;
  to_address.sin_port = htons(9734) ;
  tolen = sizeof(to_address);

  bind(sockfd , (struct sockaddr *)&to_address , tolen);

  printf("A = ");
  scanf("%d",&ch[0]);

  printf("B = ");
  scanf("%d",&ch[1]);

  sendto(sockfd , ch , sizeof(ch) , 0 , (struct sockaddr *)&to_address , tolen);

  recvfrom(sockfd , ch , sizeof(ch) , 0 , (struct sockaddr *)&from_address , &fromlen);

  printf("A + B = %d \n",ch[2]); 

  close(sockfd);
  exit(0);
}

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>

int main(void)
{
  int ch[3] ;
  int sockfd ;
  int tolen , fromlen ;
  struct sockaddr_in to_address ;
  struct sockaddr_in from_address ;

  sockfd = socket(AF_INET,SOCK_DGRAM,0);
  to_address.sin_family = AF_INET ;
  to_address.sin_addr.s_addr = INADDR_ANY ;
  to_address.sin_port = htons(9734) ;

  tolen = sizeof(to_address);
  bind(sockfd , (struct sockaddr *)&to_address , tolen);

  while(1) {
    printf("server waiting\n");

    recvfrom(sockfd , ch , sizeof(ch) , 0 , 
             (struct sockaddr *)&from_address , &fromlen);

    ch[2] = ch[0] + ch[1] ;

    sendto(sockfd , ch , sizeof(ch) , 0 , (struct sockaddr *)&from_address , fromlen);
  }
}

suga@client[~/pro]% ./udp-cli1
A = 5      ← 送信した数値  
B = 3      ← 送信した数値  

(結果が出ないので、CTRL+Dで一度、終わらせる)
suga@client[~/pro]% ./udp-cli1
A = 5      ← 送信した数値  
B = 3      ← 送信した数値  
A + B = 8  ← 受信した計算結果 
suga@client[~/pro]% 

suga@server[~/pipe]% ./udp-ser1
server waiting
server waiting
server waiting