Linux Notas de aprendizaje (V): programación de la red, QT señales y ranuras mecanismo

Los brotes de la enfermedad, pero no puede detener el ritmo de nuestro estudio, la actual epidemia mejor, la casa casi un mes fuera de su propia puede finalmente salir de con una máscara! ! !

Connect
Notas de aprendizaje Linux (a)
Linux notas de estudio (B)
Notas Linux aprendizaje (C): de función, archivo IO e hilo
Linux notas de aprendizaje (D): la cantidad de información, de sincronización, de exclusión mutua y programación de la red

revisión

Operación Operación P V

La siguiente principalmente en el servidor y la revisión del cliente Descripción:

1, el servidor: Servidor

//建立连接
（1）socket( );//创建套接字
	声明：int socket(int domain, int type,int protocol)
	int sock = socket（PF_INET,SOCK_STREAM,0）;
（2）bind( );//绑定自己的IP
	声明：int bind(int sockfd, struct sockaddr *my_addr, int addrlen)
	bind(sock,(struct sockaddr*)(&myaddr),sizeof(myaddr));
		sockfd:是由socket调用返回的文件描述符.
		addrlen:是sockaddr结构的长度.
		my_addr:是一个指向sockaddr的指针. 在中有 sockaddr的定义
（3）listen( );//监听是否有客户端向服务器发起连接
	声明：int listen(int sockfd,int backlog)
		sockfd:是bind后的文件描述符.
		backlog:设置请求排队的最大长度.当有多个客户端程序和服务端相连时, 使用这个表示可以介绍的排队长度. 函数将bind的文件描述符变为监听套接字.返回的情况和bind一样.
（4）accept( );//接受客户端的请求
	声明：int accept(int sockfd, struct sockaddr *addr,int *addrlen)
		sockfd:是listen后的文件描述符.
		addr,addrlen是用来给客户端的程序填写的,服务器端只要传递指针就可了. bind,listen和accept是服务器端用的函数, accept调用时,服务器端的程序会一直阻塞到有一个 客户程序发出了连接. accept成功时返回最后的服务器端的文件描述符, 这个时候服务器端可以向该描述符写信息了. 失败时返回-1。
//接收数据
（5）write( );//send( );
（6）read( );//recv( );
//关闭
（7）close( );

2, el cliente: el cliente

//建立连接
（1）socket( );
（2）connect( );//主动发起与服务器的连接
	声明：int connect(int sockfd, struct sockaddr * serv_addr,int addrlen)
		sockfd:socket返回的文件描述符.
		serv_addr:储存了服务器端的连接信息.其中sin_add是服务端的地址
		addrlen:serv_addr的长度
		connect函数是客户端用来同服务端连接的.成功时返回0,sockfd是同服务端通讯的文件描述符 失败时返回-1.
//接收数据
（3）read( );//recv();
（4）write( );//send();
//关闭 
（5）close( );

Programación (1) de red:

¿Qué es la red de programación que? ? ? ? ?
Es decir, los dos procesos, a través de la computadora, que necesitan para comunicarse, la culata necesidad a través de la red. Este es el papel de la toma de corriente. Analogía, dos procesos en dos ordenadores, es necesario tener un proceso para hacer el lado pasivo, denominado servidor. Otra iniciativa para hacer la fiesta, llamada el cliente. Están ubicados en un equipo, llamado el anfitrión, tener su propia dirección IP en la red. Puede haber varios procesos en un equipo como un servidor, pero sólo una ip por máquina, por lo que se distingue por diferentes números de puerto. Por lo tanto, el programa de servidor tiene que unirse a un número de puerto en la máquina. El cliente tiene que declarar que el puerto que se refieren a sus propias conexiones. Los dos procesos establecen canales de comunicación a través de la red y, a continuación, puede enviar y recibir información a través de un número de envío recv, la comunicación completa. Así que toma se refiere a la identificación de los recursos del sistema en nombre del portador de la presente comunicación.

Transferencia de palabras sencillas: https: //www.zhihu.com/question/29637351/answer/110219546

modo cliente / servidor TCP / aplicaciones de red IP, la comunicación entre dos procesos es el principal modo de interacción(Server, S Client / C /) modo cliente / servidor, Es decir, el cliente envía una solicitud de servicio al servidor, el servidor recibe la solicitud, el correspondiente servicio.
Construir modelo cliente / servidorSobre la base de los dos puntos siguientes:
(1) En primer lugar, para establecer la causa de una red de recursos de hardware y software, redes de poder de computación e información desiguales, la necesidad de compartir, creando así un host tiene muchos recursos para proporcionar servicios, menos recursos solicitudes de los clientes de servicios que no papel pares.
(2) En segundo lugar, el proceso de comunicación entre redes es completamente asíncrona, no hay ni una relación padre-hijo entre los procesos se comunican entre sí, búfer de memoria no compartida, por lo que la necesidad de un mecanismo para la esperanza comunicación entre procesos para establecer contactos, con el fin de tanto proporcionar el intercambio de datos síncronos, que se basa en una arquitectura cliente / servidor TCP / IP.

Del lado del servidor: El proceso se inició primero primera del lado del servidor, y proporcionar servicios a petición:
(1) abrir un canal de comunicación e informar al host local, en particular, que está dispuesto a dirección reconocieron un puerto (tal como el puerto FTP 21 puede ser) recibir una solicitud de cliente;
(2) a la espera de una solicitud de cliente llega al puerto;
(3) que recibe una solicitud de servicio de un cliente, procesar la solicitud y envía una señal de respuesta. Recibido solicitud de servicio concurrente para activar un nuevo proceso para manejar las peticiones de los clientes (tales como sistemas UNIX utilizando tenedor, EXEC). Este nuevo proceso de solicitudes de los clientes de manejar, no tienen que responder a otras solicitudes. Después de que el servicio se haya completado, cierre la nueva conexión con el proceso y el cliente de comunicación, y termina.
(4) de retorno (2) paso, el cliente espera para otra primera petición.
(5) fuera del servidor

Server:
      int sock = socket(PF_INET,SOCK_STREAM,0);
      bind(sock,(struct sockaddr*)(&myaddr),sizeof(myaddr));
      struct sockaddr_in myaddr;
      myaddr.sin_family = PF_INET;
      myaddr.sin_port = htons(8888);
      myaddr.sin_addr.s_addr = inet_addr("192.168.13.119");
      listen(sock,7);
      int connfd = accept(sock,NULL,NULL);

cliente:
(1) abrir un canal de comunicación, y está conectado al servidor host es el puerto en particular;
(2) paquete de petición al servidor envía los servicios, espera y recibe una respuesta; continuar con la solicitud;
cerca del canal de comunicación después del final de (3) a la solicitud y terminar .

client:
      connect(sock,(struct sockaddr*)(&seraddr),sizeof(seraddr));
      send(sock,”hello”,10,0);
      recv(sock,buf,sizeof(buf),0);
      close(sock);

1, el servidor de recepción de servidor y la transmisión de datos

创建套接字：Int sock = socket(PF_INET,SOCK_STREAM,0);
绑定自己的IP：bind(sock,(struct sockaddr*)(&myaddr),sizeof(myaddr));
主动发起与服务器的连接：struct sockaddr_in myaddr;
                      myaddr.sin_family = PF_INET;
                      myaddr.sin_port = htons(8888);
                      myaddr.sin_addr.s_addr = inet_addr("192.168.13.119");
监听：listen(sock,7);
接受请求：int connfd = accept(sock,NULL,NULL);
发送数据：send(sock,”hello”,10,0);
接收数据：recv(sock,buf,sizeof(buf),0);

2, el cliente y el cliente recibe los datos transmitidos

发送数据：send(sock,”hello”,10,0);
接收数据：recv(sock,buf,sizeof(buf),0);

programa de estudio (2) QT

1, Cómo crear un proyecto

De particular interés es la instalación de la configuración del entorno Linux QT que se añade es
1, ejecutar el comando en el [Terminal]: sudo gedit /etc/profile
2, añada la siguiente:

Para la configuración del sistema de 32 bits:

export QTDIR=/wyj/Qt5.4.1/5.4
export PATH=$QTDIR/gcc/bin:$PATH
export LD_LIBRARY_PATH=$QTDIR/gcc/lib:$LD_LIBRARY_PATH

Para la configuración de sistema de 64 bits:

export QTDIR=/opt/Qt5.4.1/5.4
export PATH=$QTDIR/gcc_64/bin:$PATH
export LD_LIBRARY_PATH=$QTDIR/gcc_64/lib:$LD_LIBRARY_PATH

(1) Abrir Qt Creator, haga clic en Nuevo proyecto, crear un nuevo proyecto: Aplicación-> Qt Reproductores Appliccation;
(2) el nombre del proyecto y la ruta para crear sus propios ajustes;
(3) Selección Kit Seleccionar gcc compilador cruzado;
(4) si el sistema de cuando la biblioteca openGL no propia, hacer interfaz con efectos 3D se quejan, instalar manualmente openGL. En primer lugar, modificar la configuración del sistema y actualizaciones de software ---- ---- ---- de China descargado del servidor.

2, la forma de utilizar la función para crear una clave llevar QT ranura de contacto, visualización de texto

Señales y ranuras mecanismo es equivalente a la función de devolución de llamada. En este mecanismo, los programadores tienen la oportunidad de hacer frente a dos eventos:

1. El tratamiento previo antes del evento de captura de señal de puesta en marcha (el evento no cumple con las expectativas no puede transmitir señales)
2. El procesamiento principal lleva a cabo en la función de la ranura

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QTcpSocket>
#include <QMovie>
#include <QLineEdit>
#include "JasonQt/JasonQt_Vop.h"

namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();

private slots:
	// 连接完成函数
    void connectDone();

    void recvdo();
	// 按钮的槽函数
    void on_pushButton_clicked();

    void on_pushButton_2_clicked();

    void on_pushButton_3_clicked();

    void on_pushButton_5_clicked();

    void on_pushButton_6_clicked();

    void on_pushButton_7_clicked();

    void on_pushButton_4_clicked();

    void on_pushButton_4_pressed();

    void on_pushButton_4_released();

private:
	// tcp连接函数
    void tcpConnect();
    bool Data_parsing(QByteArray);
private:
    Ui::Widget *ui;
    QTcpSocket tcpSocket,pic_socket;
    QMovie *movie;
    QLineEdit *line;
    JasonQt_Vop::BaiduVop m_baiduVop;
    unsigned int piclen;
    char picbuf[1024 * 1024 - 4];
};

#endif // WIDGET_H

2, crear botones y el texto sobre cómo utilizar la interfaz de usuario auto-manual

En mainwindow.ui interfaz, añadir un botón pulsador, de la siguiente manera

después de agregar el control textEdit se utiliza para mostrar el contenido del archivo para ser seleccionados en la nueva interfaz, se puede seleccionar el diseño después de la selección de diseño (clic en una parte en blanco de la ventana y, a continuación, selecciona la parte superior diseño de la pantalla).

(3) Estudio de caso

programación de la red: la comunicación entre cliente y servidor

Bajo ubuntu usar ifconfig para ver la dirección IP de la red actual.
Abra dos terminales, cada código del servidor y cliente que se ejecuta:

servidor:

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

int main(){
    /*1.创建套i接字*/
   int sock = socket(PF_INET,SOCK_STREAM,0);
    if(sock < 0){
        printf("socket error\n");
        return -1;
    }
    printf("socket success\n");
    /*2.绑定本地IP*/
    struct sockaddr_in myaddr;
    myaddr.sin_family = PF_INET;
    myaddr.sin_port = htons(8888);// 设置端口号，我这里设置的是8888
    myaddr.sin_addr.s_addr = inet_addr("xxx.xxx.xx.xxx");// 设置自己当前网端下的IP地址

    if(0 > bind(sock,(struct sockaddr*)(&myaddr),sizeof(myaddr))){
        printf("bind error\n");
        return -1;
    }
    printf("bind success\n");
    /*3.监听*/
    if(0 > listen(sock,10)){
        printf("listen error\n");
        return -1;
    }
    printf("listen success\n");
    /*4.接受链接请求*/
    int connfd = accept(sock,NULL,NULL);
    if(connfd < 0){
        printf("accept error\n");
        return -1;
    }
    printf("accept success\n");
    /*5.数据收发*/
    //send()/recv();
    char buf[20];
    gets(buf);
    int ret = send(connfd,buf,sizeof(buf),0);
    if(ret < 0){
        printf("send error\n");
        return -1;
    }
    printf("send success\n");
    /*6.关闭套接字*/
    close(connfd);
    close(sock);
return 0;
}

cliente:

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

int main(){
    /*1.创建套接字*/
   int sock = socket(PF_INET,SOCK_STREAM,0);
   if(sock < 0){
        printf("sock error\n");
        return -1;
    }
    printf("sock success\n");
    /*2.主动发起与服务器的连接*/
    struct sockaddr_in seraddr;
    seraddr.sin_family = PF_INET;
    seraddr.sin_port = htons(8888);
    seraddr.sin_addr.s_addr = inet_addr("xxx.xxx.xx.xxx");// 一定与服务器的IP地址一样
    if(0 > connect(sock,(struct sockaddr*)(&seraddr),sizeof(seraddr))){
        printf("connect errorr\n");
        return -1;
    }
    printf("connect success\n");

    /*3.数据收发*/
    char buf[20];
   int ret = recv(sock,buf,sizeof(buf),0);
    if(ret < 0){
        printf("recv error\n");
        return -1;
    }
    printf("recv:%s\n",buf);
    /*4.关闭套接字*/
    close(sock);
    return 0;
}

El resultado:

visible la comunicación entre el servidor y el cliente ha dado sus frutos! ! ! ! ! ! primavera

trifecta de todos es el mayor afirmación para mí! ! ! Esto no significa que el puntero del ratón o el dedo. . . . . .

Continuado en. . . . . .