red freecplus trama de comunicación TCP

Una descripción código fuente

freecplus es un marco de C / C ++ de código abierto bajo un sistema Linux, vaya al código fuente en lenguaje C Tecnología de red (www.freecplus.net) descarga.

Este artículo describe las funciones de comunicación TCP / IP basadas en el protocolo de red y el marco freecplus.

funciones y clases expediente de declaración son freecplus / _freecplus.h.

funciones y clases de archivos de definición son freecplus / _freecplus.cpp.

Ejemplo de programa en el directorio freecplus / Demo que se encuentra.

archivo de reglas compilado es freecplus / demo / makefile.

En segundo lugar, una visión general

marco freecplus paquete de comunicación socket como sigue:

CTcpClient categorías: clase cliente toma la comunicación.

CTcpServer clase: la comunicación socket de servidor de clase.

funciones TcpRead: recibir los datos enviados desde la toma hasta el final.

funciones TcpWrite: envía los datos al final de la toma de corriente.

función Readn: datos leídos de la toma ha sido preparado.

Escrito función: para escribir los datos se ha preparado en el zócalo.

Antes de leer este artículo, debe estar familiarizado con el protocolo TCP / IP y la comunicación zócalo, esto es una clase de introducción es el uso y funciones freecplus marco de la comunicación de red, no cubrirán los conceptos básicos de las comunicaciones de red.

En tercer lugar, el formato de mensaje de comunicación

comunicación socket freecplus formato de trama de mensaje es el siguiente:

La longitud del mensaje + contenido del mensaje

Longitud del paquete es un número entero de 4 bytes que indica el contenido del paquete de longitud, en lugar de toda la longitud del paquete TCP, toda la longitud del paquete TCP es la longitud del contenido del mensaje +4 .

Longitud del paquete es un número entero de 4 bytes, es decir, int, está escrito en socket, no el binario corriente ascii código de realización.

Uso de clase CTcpClient, clase CTcpServer, funciones TcpRead TcpWrite y funciones de comunicación zócalo, paquetes TCP puede evitarse paquete stick problemas.

Cuatro, cliente de comunicación zócalo

la comunicación el paquete de cliente toma la clase CTcpClient.

declaración de la clase:

// socket通信的客户端类
class CTcpClient
{
public:
  int  m_sockfd;    // 客户端的socket.
  char m_ip[21];    // 服务端的ip地址。
  int  m_port;      // 与服务端通信的端口。
  bool m_state;     // 与服务端的socket连接状态。
  bool m_btimeout;  // 调用Read和Write方法时，失败的原因是否是超时：true-未超时，false-已超时。
  int  m_buflen;    // 调用Read方法后，接收到的报文的大小，单位：字节。

  CTcpClient();  // 构造函数。

  // 向服务端发起连接请求。
  // ip：服务端的ip地址。
  // port：服务端监听的端口。
  // 返回值：true-成功；false-失败。
  bool ConnectToServer(const char *ip,const int port);

  // 接收服务端发送过来的数据。
  // buffer：接收数据缓冲区的地址，数据的长度存放在m_buflen成员变量中。
  // itimeout：等待数据的超时时间，单位：秒，缺省值是0-无限等待。
  // 返回值：true-成功；false-失败，失败有两种情况：1）等待超时，成员变量m_btimeout的值被设置为true；2）socket连接已不可用。
  bool Read(char *buffer,const int itimeout=0);

  // 向服务端发送数据。
  // buffer：待发送数据缓冲区的地址。
  // ibuflen：待发送数据的大小，单位：字节，缺省值为0，如果发送的是ascii字符串，ibuflen取0，如果是二进制流数据，ibuflen为二进制数据块的大小。
  // 返回值：true-成功；false-失败，如果失败，表示socket连接已不可用。
  bool Write(const char *buffer,const int ibuflen=0);

  // 断开与服务端的连接
  void Close();

  ~CTcpClient();  // 析构函数自动关闭socket，释放资源。
};

En quinto lugar, la comunicación socket del servidor

Toma de servidor de comunicaciones encapsulado en la clase CTcpServer.

declaración de la clase:

// socket通信的服务端类
class CTcpServer
{
private:
  int m_socklen;                    // 结构体struct sockaddr_in的大小。
  struct sockaddr_in m_clientaddr;  // 客户端的地址信息。
  struct sockaddr_in m_servaddr;    // 服务端的地址信息。
public:
  int  m_listenfd;   // 服务端用于监听的socket。
  int  m_connfd;     // 客户端连接上来的socket。
  bool m_btimeout;   // 调用Read和Write方法时，失败的原因是否是超时：true-未超时，false-已超时。
  int  m_buflen;     // 调用Read方法后，接收到的报文的大小，单位：字节。

  CTcpServer();  // 构造函数。

  // 服务端初始化。
  // port：指定服务端用于监听的端口。
  // 返回值：true-成功；false-失败，一般情况下，只要port设置正确，没有被占用，初始化都会成功。
  bool InitServer(const unsigned int port); 

  // 阻塞等待客户端的连接请求。
  // 返回值：true-有新的客户端已连接上来，false-失败，Accept被中断，如果Accept失败，可以重新Accept。
  bool Accept();

  // 获取客户端的ip地址。
  // 返回值：客户端的ip地址，如"192.168.1.100"。
  char *GetIP();

  // 接收客户端发送过来的数据。
  // buffer：接收数据缓冲区的地址，数据的长度存放在m_buflen成员变量中。
  // itimeout：等待数据的超时时间，单位：秒，缺省值是0-无限等待。
  // 返回值：true-成功；false-失败，失败有两种情况：1）等待超时，成员变量m_btimeout的值被设置为true；2）socket连接已不可用。
  bool Read(char *buffer,const int itimeout);

  // 向客户端发送数据。
  // buffer：待发送数据缓冲区的地址。
  // ibuflen：待发送数据的大小，单位：字节，缺省值为0，如果发送的是ascii字符串，ibuflen取0，如果是二进制流数据，ibuflen为二进制数据块的大小。
  // 返回值：true-成功；false-失败，如果失败，表示socket连接已不可用。
  bool Write(const char *buffer,const int ibuflen=0);

  // 关闭监听的socket，即m_listenfd，常用于多进程服务程序的子进程代码中。
  void CloseListen();

  // 关闭客户端的socket，即m_connfd，常用于多进程服务程序的父进程代码中。
  void CloseClient();

  ~CTcpServer();  // 析构函数自动关闭socket，释放资源。
};

En sexto lugar, el programa de ejemplo

1, el cliente

Ejemplo (demo47.cpp)

/*
 *  程序名：demo47.cpp，此程序演示采用freecplus框架的CTcpClient类实现socket通信的客户端。
 *  作者：C语言技术网(www.freecplus.net) 日期：20190525
*/
#include "../_freecplus.h"

int main(int argc,char *argv[])
{
  CTcpClient TcpClient;   // 创建客户端的对象。
  
  if (TcpClient.ConnectToServer("172.16.0.15",5858)==false) // 向服务端发起连接请求。
  {
    printf("TcpClient.ConnectToServer(\"172.16.0.15\",5858) failed.\n"); return -1;
  }

  char strbuffer[1024];    // 存放数据的缓冲区。

  for (int ii=0;ii<5;ii++)   // 利用循环，与服务端进行5次交互。
  {
    memset(strbuffer,0,sizeof(strbuffer));
    snprintf(strbuffer,50,"这是第%d个超级女生，编号%03d。",ii+1,ii+1);
    printf("发送：%s\n",strbuffer);
    if (TcpClient.Write(strbuffer)==false) break;    // 向服务端发送请求报文。

    memset(strbuffer,0,sizeof(strbuffer));
    if (TcpClient.Read(strbuffer,20)==false) break;  // 接收服务端的回应报文。
    printf("接收：%s\n",strbuffer);

    sleep(1);
  }

  // 程序直接退出，析构函数会释放资源。
}

2, el servidor

Ejemplo (demo48.cpp)

/*
 *  程序名：demo48.cpp，此程序演示采用freecplus框架的CTcpServer类实现socket通信的服务端。
 *  作者：C语言技术网(www.freecplus.net) 日期：20190525
*/
#include "../_freecplus.h"

int main(int argc,char *argv[])
{
  CTcpServer TcpServer;   // 创建服务端对象。
  
  if (TcpServer.InitServer(5858)==false) // 初始化TcpServer的通信端口。
  {
    printf("TcpServer.InitServer(5858) failed.\n"); return -1;
  }
  
  if (TcpServer.Accept()==false)   // 等待客户端连接。
  {
    printf("TcpServer.Accept() failed.\n"); return -1;
  }

  printf("客户端(%s)已连接。\n",TcpServer.GetIP());

  char strbuffer[1024];  // 存放数据的缓冲区。

  while (true)
  {
    memset(strbuffer,0,sizeof(strbuffer));
    if (TcpServer.Read(strbuffer,300)==false) break; // 接收客户端发过来的请求报文。
    printf("接收：%s\n",strbuffer);

    strcat(strbuffer,"ok");      // 在客户端的报文后加上"ok"。
    printf("发送：%s\n",strbuffer);
    if (TcpServer.Write(strbuffer)==false) break;     // 向客户端回应报文。
  }

  printf("客户端已断开。\n");    // 程序直接退出，析构函数会释放资源。
}

3, listo para ejecutar el programa antes de que finalice

Espero que hayan aprendido los conceptos básicos de las redes de ordenadores, antes de ejecutar el programa de ejemplo, asegúrese de que su sistema operativo Linux servidor de seguridad se ha abierto.

En demo47.cpp y el programa demo48.cpp, dirección IP y el puerto de comunicaciones del servidor está codificada en el programa, modificarlos de acuerdo a su situación, y luego volver a compilar.

4, ejecute el programa

En primer lugar empezar demo48, a continuación, iniciar demo47.

Demo47 resultados de operación son los siguientes:

Demo48 resultados de operación son los siguientes:

la comunicación toma la función de siete

Y el uso de CTcpClient CTcpServer implementa la clase toma una función de comunicación es muy conveniente, pero en el desarrollo real, ciertos escenarios no puede basarse en dos clases, por ejemplo, un multi-escena líneas de proceso y comunicaciones asíncronas, también debe combinar varias funciones que se describirán juntos usado.

1, la función TcpRead

Los datos enviados desde el extremo receptor de la toma.

declaración de la función:

bool TcpRead(const int sockfd,char *buffer,int *ibuflen,const int itimeout=0);

parámetros:

sockfd: Disponible conexión de socket.

Tampón: recibir datos del buffer de direcciones.

ibuflen: El número de bytes de datos recibido correctamente.

iTimeout: recepción de espera de tiempo de espera, unidad: el segundo valor predeterminado es de 0 a esperar indefinidamente.

Valor de retorno: verdadero éxito, falso fracaso, fracaso, hay dos casos: 1) Tiempo de espera, 2) la conexión de socket no está disponible.

Llame a la función TcpRead en la clase Leer método CTcpClient y CTcpServer.

2, la función TcpWrite

Enviar datos al final de la toma.

declaración de la función:

bool TcpWrite(const int sockfd,const char *buffer,const int ibuflen=0);

parámetros:

sockfd: Disponible conexión de socket.

buffer: buffer de los datos de dirección que ha de transmitirse.

ibuflen: el número de bytes de datos a transmitir, si la transmisión es una cadena ASCII, ibuflen ser 0, si el flujo de datos binarios, ibuflen es el tamaño del bloque de datos binarios.

Valor de retorno: cierto- éxito; falsos fracaso, si no funciona, que muestra la conexión de socket no ha estado disponible.

TcpRead función llama al método Write CTcpClient y CTcpServer clase.

3, la función Readn

Leer datos de la toma se ha preparado.

declaración de la función:

bool Readn(const int sockfd,char *buffer,const size_t n);

sockfd: conexión de socket se ha preparado.

Tampón: recibir datos del buffer de direcciones.

n: El número de bytes de datos recibidos.

Devuelve true reciben correctamente los datos de n bytes, conexión de socket no está disponible vuelve falsa: el valor de retorno.

nota:

1) ya está preparado conexión de socket sockfd, lo que ya estamos preparados toma? En esta toma, o inmediatamente tenemos un dato de n bytes llegarán.

Devuelve true después de 2) recibieron con éxito, n bytes de datos, cómo si no, n bytes de datos para hacer? No, 1) ha sido explicado, habrá n bytes de datos llegará.

3) Si los datos es mayor que n bytes cómo hacerlo? Readn n bytes de sólo lectura de datos, otros datos que pertenecen a otros paquetes.

4) del extremo de socket método Escrito es el uso de la escritura de datos.

En función de TcpRead, llamar a la función Readn.

4, la función Escrito

Ha sido preparado para escribir datos en el zócalo.

declaración de la función:

bool Writen(const int sockfd,const char *buffer,const size_t n);

sockfd: conexión de socket se ha preparado.

buffer: buffer de los datos de dirección que ha de transmitirse.

n: número de bytes a datos de transmisión.

Valor de retorno: true devuelve después de la finalización con éxito de la transmisión de datos de N bytes, conexión de socket es falsa vuelve no disponibles.

En función de TcpWrite, llamada función Escrito.

Ocho, aviso de copyright

C Tecnología de Red de Lenguaje artículo original, que se reproduce por favor indique el enlace de la fuente con el artículo, el autor y original.
Fuente: C Tecnología de red Idioma (www.freecplus.net)
Autor: Ética código de Agricultura

Si los errores tipográficos o errores de artículos, contenido, u otras sugerencias y comentarios, por favor mensaje yo correcta, muchas gracias! ! !