int sock; /* 套接字 */
  socklen_t addr_len; /* 發(fā)送端的地址長度，用于 recvfrom */
  char mess[15];
  char get_mess[GET_MAX]; /* 后續(xù)版本使用 */
  struct sockaddr_in recv_host, send_host;

  /* 創(chuàng)建套接字 */
  sock = socket(PF_INET, SOCK_DGRAM, 0);

  /* 把IP 和 端口號信息綁定在套接字上 */
  memset(&recv_host, 0, sizeof(recv_host));
  recv_host.sin_family = AF_INET;
  recv_host.sin_addr.s_addr = htonl(INADDR_ANY);/* 接收任意的IP */
  recv_host.sin_port = htons(6000); /* 使用6000 端口號 */
  bind(sock, (struct sockaddr *)&recv_host, sizeof(recv_host));

  /* 進入接收信息的狀態(tài) */
  recvfrom(sock, mess, 15, 0, (struct sockaddr *)&send_host, &addr_len);

  /* 接收完成，關閉套接字 */
  close(sock);

  int sock;
  const char* mess = "Hello Server!";
  char get_mess[GET_MAX]; /* 后續(xù)版本使用 */
  struct sockaddr_in recv_host;
  socklen_t addr_len;
  /* 創(chuàng)建套接字 */
  sock = socket(PF_INET, SOCK_DGRAM, 0);
  /* 綁定 */
  memset(&recv_host, 0, sizeof(recv_host));
  recv_host.sin_family = AF_INET;
  recv_host.sin_addr.s_addr = inet_addr("127.0.0.1");
  recv_host.sin_port = htons(6000);
  /* 發(fā)送信息 */
  /* 在此處，發(fā)送端的IP地址和端口號等各類信息，隨著這個函數的調用，自動綁定在了套接字上 */
  sendto(sock, mess, strlen(mess), 0, (struct sockaddr *)&recv_host, sizeof(recv_host));
  /* 完成，關閉 */
  close(sock);

  /* 前方高度一致，將 bind函數替換為 */
  connect(sock, (struct sockaddr *)&recv_host, sizeof(recv_host); // 將對方的 IP地址和 端口號信息 注冊進UDP的套接字中)
  while(1) /* 循環(huán)的發(fā)送和接收信息 */
  {
   size_t read_len = 0;
   /* 原先使用的 sendto 函數，先擇改為使用 write 函數， Windows平臺為 send 函數 */
   write(sock, mess, strlen(mess));      /* send(sock, mess, strlen(mess), 0) FOR Windows Platform */
   read_len = read(sock, get_mess, GET_MAX-1); /* recv(sock, mess, strlen(mess)-1, 0) FOR Windows Platform */
   get_mess[read_len-1] = '\0';
   printf("In Client like Host Recvive From Other Host : %s\n", get_mess);
  }
  /* 后方高度一致 */

  /* 前方一致， 添加額外的 struct sockaddr_in send_host; 并添加循環(huán)，構造收發(fā)的現象*/
    while(1)
  {
   size_t read_len = 0;
   char sent_mess[15] = "Hello Sender!"; /* 用于發(fā)送的信息 */
   sendto(sock, mess, strlen(sent_mess), 0, (struct sockaddr *)&recv_host, sizeof(recv_host));
   read_len = recvfrom(sock, mess, 15, 0, (struct sockaddr *)&send_host, &addr_len)
   mess[read_len-1] = '\0';
   printf("In Sever like Host Recvive From other Host : %s\n", mess);
  }
  /* 后方高度一致 */
  /*
  * 之所以只在接收端使用 connect 的原因，便在于我們模擬的是 客戶端-服務器 的模型，而服務器的各項信息是不會隨意變更的
  * 但是 客戶端就不同了，可能由于 ISP(Internet Server Provider) 的原因，你的IP地址不可能總是固定的，所以只能
  * 保證 在客戶端 部分注冊了 服務器 的各類信息，而不能在 服務器端 注冊 客戶端 的信息。
  * 當然也有例外，例如你就想這個軟件作為私密軟件，僅供兩個人使用， 且你有固定的 IP地址，那么你可以兩邊都connect，但是
  * 一定要注意，只要有一點信息變動，這個軟件就可能無法正常的收發(fā)信息了。
  */

  /* 假設有一個 TCP 的連接，此為客戶端 */
  write(sock, "Thank you", 10);
  close(sock); // 寫完直接關閉通信

  /* 此為服務器 */
  /* 首先關閉寫流 */
  shutdown(sock_c, SHUT_WR);
  read(sock_c, get_mess, GET_MAX);
  printf("Message : %s\n", get_mess);
  close(sock_c);
  close(sock_s); // 關閉兩個套接字是因為 TCP 服務器端的需要，后續(xù)會記錄

int shutdown(int sock, int howto);

  int sock; /* 套接字 */
  socklen_t addr_len; /* 發(fā)送端的地址長度，用于 recvfrom */
  char mess[15];
  char get_mess[GET_MAX]; /* 后續(xù)版本使用 */
  struct sockaddr_in host_v4; /* IPv4 地址 */
  struct sockaddr_in6 host_v6; /* IPv6 地址 */
  struct addrinfo easy_to_use; /* 用于設定要獲取的信息以及如何獲取信息 */
  struct addrinfo *result;  /* 用于存儲得到的信息(需要注意內存泄露) */
  struct addrinfo * p;

  /* 準備信息 */
  memset(&easy_to_use, 0, sizeof easy_to_use);
  easy_to_use.ai_family = AF_UNSPEC; /* 告訴接口，我現在還不知道地址類型 */
  easy_to_use.ai_flags = AI_PASSIVE; /* 告訴接口，稍后“你”幫我填寫我沒明確指定的信息 */
  easy_to_use.ai_socktype = SOCK_DGRAM; /* UDP 的套接字 */
  /* 其余位都為 0 */

  /* 使用 getaddrinfo 接口 */
  getaddrinfo(NULL, argv[1], &easy_to_use, &result); /* argv[1] 中存放字符串形式的 端口號 */

  /* 創(chuàng)建套接字，此處會產生兩種寫法，但更保險，可靠的寫法是如此 */
  /* 舊式方法
  * sock = socket(PF_INET, SOCK_DGRAM, 0);
  */
  /* 把IP 和 端口號信息綁定在套接字上 */
  /* 舊式方法
  * memset(&recv_host, 0, sizeof(recv_host));
  * recv_host.sin_family = AF_INET;
  * recv_host.sin_addr.s_addr = htonl(INADDR_ANY);/* 接收任意的IP */
  * recv_host.sin_port = htons(6000); /* 使用6000 端口號 */
  * bind(sock, (struct sockaddr *)&recv_host, sizeof(recv_host));
  */

  for(p = result; p != NULL; p = p->ai_next) /* 該語法需要開啟 -std=gnu99 標準*/
  {
    sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol);
    if(sock == -1)
     continue;
    if(bind(sock, p->ai_addr, p->ai_addrlen) == -1)
    {
     close(sock);
     continue;
    }
    break; /* 如果能執(zhí)行到此，證明建立套接字成功，套接字綁定成功，故不必再嘗試。 */
  }

  /* 進入接收信息的狀態(tài) */
  //recvfrom(sock, mess, 15, 0, (struct sockaddr *)&send_host, &addr_len);
  switch(p->ai_socktype)
  {
   case AF_INET :
    addr_len = sizeof host_v4;
    recvfrom(sock, mess, 15, 0, (struct sockaddr *)&host_v4, &addr_len);
    break;
    case AF_INET6:
     addr_len = sizeof host_v6
     recvfrom(sock, mess, 15, 0, (struct sockaddr *)&host_v6, &addr_len);
     break;
    default:
     break;
  }
  freeaddrinfo(result); /* 釋放這個空間，由getaddrinfo分配的 */
  /* 接收完成，關閉套接字 */
  close(sock);

 struct addrinfo{
  int ai_flags;
  int ai_family;
  int ai_socktype;
  int ai_protocol;
  socklen_t ai_addrlen;
  struct sockaddr * ai_addr; /* 存放結果地址的地方 */
  char * ai_canonname; /* 忽略它吧，很長一段時間你無須關注它 */
  struct addrinfo * ai_next; /* 一個域名/IP地址可能解析出多個不同的 IP */
 };

  struct sockaddr_in6{
   u_int16_t sin6_family;
   u_int16_t sin6_port;
   u_int32_t sin6_flowinfo; /* 暫時忽略它 */
   struct in6_addr sin6_addr; /* IPv6 的地址存放在此結構體中 */
   u_int32_t sin_scope_id; /* 暫時忽略它 */
  };
  struct in6_addr{
   unsigned char s6_addr[16];
  }
  ------------------------------------------------------------
  struct sockaddr_storage{
   sa_family_t ss_family; /* 地址的種類 */
   char __ss_pad1[_SS_PAD1SIZE]; /* 從此處開始，不是實現者幾乎是沒辦法理解 */
   int64_t __ss_align;      /* 從名字上可以看出大概是為了兼容兩個不同 IP 類型而做出的妥協(xié) */
   char __ss_pad2[_SS_PAD2SIZE]; /* 隱藏了實際內容，除了 IP 的種類以外，無法直接獲取其他的任何信息。 */
   /* 在各個*nix 的具體實現中， 可能有不同的實現，例如 `__ss_pad1` ， `__ss_pad2` , 可能合并成一個 `pad` 。 */
  };

  /* 首先將多于的變量化簡 */
  // - struct sockaddr_in host_v4; /* IPv4 地址 */
  // - struct sockaddr_in6 host_v6; /* IPv6 地址
  struct sockaddr_storage host_ver_any; /* + 任意類型的 IP 地址 */
  ...
  /* 進入接收信息的狀態(tài)部分 */
  recvfrom(sock, mess, 15, 0, (struct sockaddr *)&host_ver_any, &addr_len); /* 像是又回到了只有 IPv4 的年代*/

  int sock;
  const char* mess = "Hello Server!";
  char get_mess[GET_MAX]; /* 后續(xù)版本使用 */
  struct sockaddr_storage recv_host; /* - struct sockaddr_in recv_host; */
  struct addrinfo tmp, *result;
  struct addrinfo *p;
  socklen_t addr_len;

  /* 獲取對端的信息 */
  memset(&tmp, 0, sizeof tmp);
  tmp.ai_family = AF_UNSPEC;
  tmp.ai_flags = AI_PASSIVE;
  tmp.ai_socktype = SOCK_DGRAM;
  getaddrinfo(argv[1], argv[2], &tmp, &result); /* argv[1] 代表對端的 IP地址， argv[2] 代表對端的 端口號 */

  /* 創(chuàng)建套接字 */
  for(p = result; p != NULL; p = p->ai_next)
  {
   sock = socket(p->ai_family, p->ai_socktype, p->ai_protocol); /* - sock = socket(PF_INET, SOCK_DGRAM, 0); */
   if(sock == -1)
    continue;
   /* 此處少了綁定 bind 函數，因為作為發(fā)送端不需要講對端的信息 綁定 到創(chuàng)建的套接字上。 */ 
   break; /* 找到就可以退出了，當然也有可能沒找到，那么此時 p 的值一定是 NULL */
  }
  if(p == NULL)
  {
   /* 錯誤處理 */
  }
  /* -// 設定對端信息
  memset(&recv_host, 0, sizeof(recv_host));
  recv_host.sin_family = AF_INET;
  recv_host.sin_addr.s_addr = inet_addr("127.0.0.1");
  recv_host.sin_port = htons(6000);
  */

  /* 發(fā)送信息 */
  /* 在此處，發(fā)送端的IP地址和端口號等各類信息，隨著這個函數的調用，自動綁定在了套接字上 */
  sendto(sock, mess, strlen(mess), 0, p->ai_addr, p->ai_addrlen);
  /* 完成，關閉 */
  freeaddrinfo(result); /* 實際上這個函數應該在使用完 result 的地方就予以調用 */
  close(sock);