"Todo Socket"! ! ! !
El principio fundamental es crear una toma de conexiones de socket y enviar y recibir datos.
servidor de socket y el cliente se divide en dos partes en la realización del proceso:
Del lado del servidor:
Cómo funciona: llamar a la función de socket para crear una toma de corriente; struct sockaddr_in entidad declaración de la estructura; socket número después de una llamada a obligar a la entidad y que se unen; escuchar la llamada función crea un juego de tubos a la escucha pasiva (la denominada vigilancia pasiva, es cuando no hay medios que cuando un cliente solicita un socket en un estado de "reposo", sólo cuando se recibe una petición del cliente, la toma será "despertar" para responder a la solicitud), y luego aceptar la llamada función de puerto para el monitoreo. Una vez que recibe el mensaje enviado por el cliente, toma será devuelto al número de zócalo de unión cliente IP + puerto, esta vez para establecer una conexión entre los dos procesos. Operación del documento se puede leer / escribir o similar (ya que, independientemente del archivo de socket en Linux y archivos generales). Tras el final de la llamada de función transceptor para cerrar la operación.
Nota: listen () dejar que la toma en el estado de escucha, en realidad no se recibirán solicitudes de los clientes, escuchar () detrás del código continuará ejecutándose hasta que aceptar (). accept () bloqueará la ejecución (después de que el código no puede ser ejecutado), hasta que una nueva petición llega.
cliente:
Cómo funciona: llamar a la función de socket para crear una toma de corriente, y luego ip número de socket y el servidor + port vinculante, entonces se puede manipular el archivo de lectura / escritura y similares, llamar a la función de cierre para cerrar la toma después del final de la operación.
Descripción de la función:
int socket (int af, de tipo int, int protocolo);
1. af dirección de grupo (Dirección de la familia), es decir, el tipo de dirección IP, de uso común y AF_INET AF_INET6. AF es la abreviatura "Dirección de la familia", INET es la abreviatura "Inetnet". AF_INET dirección indica IPv4, por ejemplo, 127.0.0.1; AF_INET6 una dirección IPv6, tal como 1030 :: C9B4: FF12: 48AA: 1A2B.
Debemos recordar 127.0.0.1, que es una dirección IP especial, la representación de direcciones local, que serán utilizados con frecuencia más adelante en el tutorial.
2. tipo de transmisión de datos, y de uso común SOCK_STREAM SOCK_DGRAM
Protocolo 3. Representa protocolo de transmisión, utilizada IPPROTO_TCP y IPPTOTO_UDP, respectivamente protocolo de transporte TCP y el protocolo de transporte UDP
int bind (int calcetín, struct sockaddr * addr, socklen_t addrlen);
int connect (int calcetín, struct sockaddr * serv_addr, socklen_t addrlen);
1. calcetín para el descriptor de archivo de socket
2. direc es una estructura variable de puntero sockaddr
3. addrlen derivados como un tamaño variable addr, por el sizeof () se calcula
int listen (calcetín, int atraso);
1. Se requiere calcetín para entrar en el estado de vigilancia de la toma
2. Cartera para la longitud máxima de la cola de solicitudes.
int aceptar (int calcetín, struct sockaddr * addr, socklen_t * addrlen)
aceptar () devuelve un nuevo socket para comunicarse con los clientes
1. calcetín es un enchufe del lado del servidor
2. addr Guardar dirección y número de puerto IP del cliente
3. addrlen es la longitud en bytes de addr
Tenga en cuenta la distinción. Cuando las comunicaciones posterior y el cliente, para utilizar la nueva generación de tomas de corriente, socket en vez del servidor original.
Código de ejemplo:
Del lado del servidor:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
# include <errno.h>
#include <sys / types.h>
#include <sys / socket.h>
#include <netinet / in.h>
# include <unistd.h>
MAXLINE #define 4096
int main (int argc, char ** argv) {
int listenfd, connfd;
struct sockaddr_in servaddr;
Char buff [4096];
int n;
if ((listenfd = socket (AF_INET, SOCK_STREAM, 0)) == -1) {
printf ( "crear error de socket:% s (errno:% d) \ n", strerror (errno), errno);
return 0;
}
memset (y servaddr, 0, sizeof (servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl (INADDR_ANY);
servaddr.sin_port = htons (6666);
si (bind (listenfd, (struct sockaddr *) y servaddr, sizeof (servaddr)) == -1) {
printf ( "bind error socket:% s (errno:% d) \ n", strerror (errno), errno);
return 0;
}
si (LISTEN (listenfd, 10) == -1) {
printf ( "escuchar error socket:% s (errno:% d) \ n", strerror (errno), errno);
return 0;
}
printf ( "====== espera de la petición del cliente ====== \ n");
while (1) {
if ((= connfd aceptan (listenfd, (struct sockaddr *) NULL, NULL)) == -1) {
printf ( "aceptar socket error:% s (errno:% d)", strerror (errno), errno);
Seguir;
}
n = recv (connfd, piel de ante, MAXLINE, 0);
buff [n] = '\ 0';
printf ( "msg recv de cliente:% s \ n", piel de ante);
cerrar (connfd);
}
cerrar (listenfd);
return 0;
}
cliente:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
# include <errno.h>
#include <sys / types.h>
#include <sys / socket.h>
#include <netinet / in.h>
#include <arpa / inet.h>
# include <unistd.h>
MAXLINE #define 4096
int main (int argc, char ** argv) {
int sockfd, n;
Char recvline [4096], sendline [4096];
struct sockaddr_in servaddr;
si (argc! = 2) {
printf ( "Uso: ./client <ipaddress> \ n");
return 0;
}
if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) <0) {
printf ( "crear error de socket:% s (errno:% d) \ n", strerror (errno), errno);
return 0;
}
memset (y servaddr, 0, sizeof (servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons (6666);
si (inet_pton (AF_INET, argv [1], y servaddr.sin_addr) <= 0) {
printf ( "inet_pton error para% s \ n", argv [1]);
return 0;
}
si (connect (sockfd, (struct sockaddr *) y servaddr, sizeof (servaddr)) <0) {
printf ( "error de conexión:% s (errno:% d) \ n", strerror (errno), errno);
return 0;
}
printf ( "Enviar mensaje de servidor a: \ n");
fgets (sendline, 4096, stdin);
si (send (sockfd, sendline, strlen (sendline), 0) <0) {
printf ( "error Enviar msg:% s (errno:% d) \ n", strerror (errno), errno);
return 0;
}
cerrar (sockfd);
return 0;
}
el makefile:
todo: cliente del servidor
servidor: server.o
g ++ -g -o server.o servidor
Cliente: client.o
g ++ -g -o client.o cliente
server.o: server.cpp
g ++ -g -c server.cpp
client.o: client.cpp
g ++ -g -c client.cpp
Limpiar todo
rm todo
Después de que el comando make para generar servidor y cliente dos archivos ejecutables. Respectivamente, dos ventanas de terminal abierto, un comando de ejecución ./server, ejecución de un comando ./client 127.0.0.1, puerto 6666 representa una primera realización de la máquina, conectado en ./server ejecución del comando. Después de ejecutar comandos ./client 127.0.0.1, se le pedirá que decir al servidor de contenido, e introducir "Hola", finalizó cliente cliente, a continuación, se puede ver la ventana del servidor de salida del terminal de "msg recibir del cliente: hola ".
TCP comunicación de protocolo proceso de interacción:
nota:
capa de red "dirección IP + puerto" puede identificar de manera única un proceso;
Comunicación de la sensación de que la "dirección de IP + puerto + protocolo" para completar la comunicación entre procesos; // propósito del acuerdo es el número de puerto almacenada en diferentes formas debido al protocolo utilizado puede ser diferente.