自定義協議訊息體

*********msg.h*************

#ifndef _MSG_H_

#define _MSG_H_

struct msg

{

  char head[10]; //頭部

  char msg_chck; //效驗碼

  char buff[512];//體部

}Msg;

extern int write_msg(int socktf, char* buff, size_t len);

extern int read_msg(int socktf, char* buff, size_t len);

*****msg.c***************

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

#include "msg.h"

/*計算校驗碼
*/
static unsigned char msg_check(Msg* message)
{
  //將頭部和體部進行累加
  unsigned char s = 0;
  int i;
  for(i = 0; i < sizeof(message->head); ++i)
  {
    s += message->head[i];
  }
  for(i = 0; i < sizeof(message->buff); ++i)
  {
    s += message->buff[i];
  }
  return s;
}

/*
 * 傳送一個基於自定義協議的message
 * 傳送的資料存放在buff中*/
 
int write_msg(int socktf, char* buff, size_t len)
{
  Msg message;
  memset(&message, 0, sizeof(message));
  strcpy(message.head, "wc2017000");
  memcpy(message.buff, buff, len);
  message.checknum = msg_check(&message);
  //傳送一個message訊息
  if(write(socktf, &message, sizeof(message)) != sizeof(message))
  {
    return -1;
  }
}


/*
 * 讀取一個基於茲定於協議的message
 * 讀取的資料存在在buff中
 */
int read_msg(int socktf, char* buff, size_t len)
{
  Msg message;
  memset(&message, 0, sizeof(message));
  size_t size;
  if(( size = read(socktf,
          &message, sizeof(message))) < 0 )
  {
    return -1;
  }
  else if(size == 0) //資料讀光了
  {
    return 0;
  }
  //進行效驗碼驗證,判斷接受到message資料是否完整
  unsigned char s = msg_check(&message);
  if(s == (unsigned char)message.checknum
      && (!strcmp("wc2017000", message.head)))
  {
    memcpy(buff, message.buff, len);
    return sizeof(message);
  }
  return -1;
}
 

客戶端：

/*
 *  文 件 名：time_tcp_client.cpp
 *  作    者：wc
 *  郵    件：[email protected]
 *  版    權：Copyright (c) 完全自由
 *  意    圖：
 */


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


int main(int argc, char* argv[])
{
  if(argc < 3)
   printf("usage: %s ip port\n", argv[0]);
   exit(1);
  
   /*步驟1：建立socket套接字
    *
    * */
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if(sockfd < 0)
  {
    perror("socket error");
    exit(1);
  }

  /*往serveraddr中填入ip，port和地址族型別 ipv4
   *
   */
  struct sockaddr_in  serveraddr;
  memset(&serveraddr, 0, sizeof(serveraddr));
  serveraddr.sin_family = AF_INET;
  serveraddr.sin_port = htons(atoi(argv[2]));
  /*p地址轉換為網路位元組序後填入tuserveraddr中*/
  inet_pton(AF_INET, argv[1],  &serveraddr.sin_addr.s_addr);
  
  /*步驟2：客戶端呼叫connect函式連線到伺服器端
   * */
  if(connect(sockfd, (struct sockaddr*)&serveraddr, sizeof(serveraddr)) < 0)
  {
   // perror("connect error);
    exit(1);
  }

  /*步驟3：呼叫IO函式（read/write）和伺服器端進行雙向通訊
   * */
  char buff[512];
  size_t size;
  char* prompt = ">";
  while(1)
  {
    memset(buff, 0, sizeof(buff));
    write(STDOUT_FILENO, prompt, 1); //連線提示服
    size = read(STDIN_FILENO, buff, sizeof(buff));
    if(size < 0) continue;
    buff[size-1] = '\0';
    if(write_msg(sockfd, buff, sizeof(buff)) < 0 )
    {
      perror("write msg error");
      continue;
    }
    else if(read_msg(sockfd, buff, sizeof(buff)) < 0)
      {
       perror("read msg error");
      }
    else
    {
      printf("buff:%s", buff);
    }
    }
  }

  /*步驟4：
   *關閉套接字socket
   * */
   close(sockfd);



  return 0;
}
 

伺服器：

/*
 *  文 件 名：time_tcp_server.cpp
 *  作    者：wc
  *  版    權：Copyright (c) 完全自由
 *  意    圖:study
 */
#include <netdb.h>
#include <sys/socket.h> 
#include<netinet/in.h>
#include <sys/un.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <signal.h>
#include <time.h>
#include <arpa/inet.h>
#include "msg.h"
#include <errno.h>
#include <wait.h>
int sockfd; 

void sig_handler(int signo)//訊號捕捉函式
{
  if(signo == SIGINT)
  {
   printf("server close\n");
   //關閉socket
   close(sockfd);
  // exit(1);
  }
  if(signo == SIGCHLD)
  {
      perror("sigchld deaed");
      wait(0);
  }

}

/*輸出連線上來的客戶端相關資訊
 *
 */
void out_addr(struct sockaddr_in* clientaddr)
{
  /*將埠從網路位元組序轉換成主機位元組序
   *
   */
  int port = ntohs(clientaddr->sin_port);
  char ip[16];
  memset(ip, 0, sizeof(ip));
  /*將ip地址從網路位元組序轉換成點分十進位制*/
  inet_ntop(AF_INET, &clientaddr->sin_addr.s_addr, ip, sizeof(ip));
  printf("client: %s(%d) connectd\n", ip, port);
}

void do_service(int fd)
{
  /*和客戶端進行讀寫操作（雙向通訊）
   */
  char buff[512];
  while(1)
  {
    memset(buff, 0, sizeof(buff));
    printf("start read and wirte...\n");
    size_t size;
    if((size = read_msg(fd, buff, sizeof(buff))) < 0)
    {
      perror("protocal erorr");
      break;
    }
    else if(size == 0)
    {
      break;
    }
    else
    {
      printf("%s\n", buff);
      if(write_msg(fd, buff, sizeof(buff)) < 0)
      {
            //if(error == EPIPE)
           // break;
      }
      perror("protacal error");
    }
  }
}

int main(int argc, char* argv[])
{
  if(argc < 2) //外部輸入引數監聽 埠
  {
  printf("usage  %s #port\n", argv[0]);
 // exit(1);
  }

  if(signal(SIGINT, sig_handler) == SIG_ERR) //訊號處理函式
  {
    perror("signal sigint error");
   // exit(1);
  }
   if(signal(SIGCHLD, sig_handler) == SIG_ERR) //訊號處理函式
  {
    perror("signal sigchld  error");
   // exit(1);
  }

  /*步驟1：建立socket（套接字）
  *socket建立在核心中，是一個結構體
  *AF_INET:  IPV4
  *SOCK_STREAM:  tcp協議
   */

  sockfd = socket(AF_INET, SOCK_STREAM, 0);


  /*步驟2：呼叫bind函式將socket和地址
   * （包括ip、port）進行繫結
   */

  struct sockaddr_in serveraddr;    //網路基本地址族
  memset(&serveraddr, 0, sizeof(serveraddr));
  serveraddr.sin_family = AF_INET; //ipv4
  serveraddr.sin_port = htons(atoi(argv[1]));//整數轉換為網路位元組序 prot
  serveraddr.sin_addr.s_addr = INADDR_ANY;  //獲取所有網絡卡客戶端對應連線的請求
  if(bind(sockfd, (struct sockaddr*)&serveraddr, sizeof(serveraddr)) < 0)
  {
    perror("bind error");
    exit(1);
  }


  /*步驟3：呼叫listen函式啟動監聽(指定port監聽)
   * 通知系統去接受來自客戶端的連線請求
   * 將接收到的客戶端連線請求放置到對應的佇列中
   * 第二個引數 客戶端佇列的長度
   */
  if(listen(sockfd, 10) < 0)
  {
    perror("lisen error");
    exit(1);
  }

  /*步驟4：呼叫accept函式從佇列(先進先出)中獲
   * 取一個客戶端的請求連線,並返回新的socket描述符
   * 注意：若沒有客戶端連線，呼叫此函式後阻塞，直到獲得一個客戶端的連線
   */
  struct sockaddr_in clientaddr;
  socklen_t clientlen = sizeof(clientaddr);
  while(1)
  {
    int fd = accept(sockfd, (struct sockaddr*)&clientaddr, &clientlen);//sockfd此時是新的客戶但套接字的描述符
    if(fd < 0)
    {
      perror("acdept error");
      continue;
    }

    /*步驟5：呼叫IO函式（read/write）和連線額度客戶端進行雙向的通訊
     *啟動子程序去呼叫IO函式（read/write）和連線的客戶端進行雙向的通訊
     (併發處理來自客戶端的請求啟動多程序  當一個新的客戶端父程序new出一個子程序，父程序繼續等待下個客戶端的連線  )
     */
    pid_t pid = fork(); //建立一個程序
    if(pid < 0)
      continue;
    else if(pid == 0)//子程序
    {
      out_addr(&clientaddr);
      do_service(fd);
      close(fd);//記憶體在有計數器的 根據close的數量達到2的時候記憶體會釋放的
      break;
    }
    else//父程序
      close(fd);
    }

  return 0;
}