Chapitre 1 de la programmation du réseau TCP / IP

Yxqq378287007 2022-01-15 02:54:04 阅读数:239

chapitre la programmation du seau

Socket

Fonction de corrélation

  • Créer une Socket
#include <sys/socket.h>
//Descripteur de fichier retourné avec succès,Échec retourné-1
int socket(int domain, int type, int protocol);
  • BINDIPEtPort
#include <sys/socket.h>
//Retour réussi0,Échec retourné-1
int bind(int sockfd, struct sockaddr *myaddr, socklen_t addrlen);
  • Écouter
#include <sys/socket.h>
//Retour réussi0,Échec retourné-1
int listen(int sockfd, int backlog);
  • Obtenir la connexion
#include <sys/socket.h>
//Descripteur de fichier retourné avec succès,Échec retourné-1
int accept(int sockfd, struct sockaddr *myaddr, socklen_t addrlen);
  • Demande de connexion
#include <sys/socket.h>
//Retour réussi0,Échec retourné-1
int connect(int sockfd, struct sockaddr *serv_addr, socklen_t addrlen);

Côté serveur

hello_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);
int main(int argc, char *argv[]) {

int serv_sock;
int clnt_sock;
struct sockaddr_in serv_addr;
socklen_t serv_addr_size;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size;
char message[] = "Hello World!";
if(argc!=2) {

printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
if(serv_sock==-1)
error_handling("socket() error");
serv_addr_size = sizeof(serv_addr);
memset(&serv_addr, 0, serv_addr_size);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*)&serv_addr, serv_addr_size)==-1)
error_handling("bind() error");
if(listen(serv_sock, 5)==-1)
error_handling("listen() error");
clnt_addr_size = sizeof(clnt_addr);
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size );
if(clnt_sock==-1)
error_handling("accept() error");
write(clnt_sock, message, sizeof(message));
close(clnt_sock);
close(serv_sock);
return 0;
}
void error_handling(char *message) {

fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}

Client

hello_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);
int main(int argc, char *argv[]) {

int sock;
struct sockaddr_in addr;
socklen_t addr_size;
char message[30];
int str_len;
if(argc!=3) {

printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
if(sock==-1)
error_handling("socket() error");
addr_size = sizeof(addr);
memset(&addr, 0, addr_size);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(argv[1]);
addr.sin_port = htons(atoi(argv[2]));
if(connect(sock, (struct sockaddr*)&addr, addr_size)==-1)
error_handling("connect() error");
str_len = read(sock, message, sizeof(message)-1);
if(str_len==-1)
error_handling("read() error");
message[str_len] = '\0';
printf("Message from server : %s \n", message);
close(sock);
return 0;
}
void error_handling(char *message) {

fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}

Exécution de la compilation

gcc hello_server.c -o hserver
./hserver 9190
gcc hello_client.c -o hclient
./hclient 127.0.0.1 9190

LinuxOpérations de fichiers

Descripteur de fichier

0,Entrée standardStandard Input
1,Sortie standardStandard Output
2,Erreur standardStandard Error

Ouvrir le fichier

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
//Descripteur de fichier retourné avec succès,Échec retourné-1
int open(const char *path, int flag);
//flagBits ou opérations
//O_CREAT,Créer lorsqu'il n'existe pas
//O_TRUNC,Supprimer
//O_APPEND,Annexe
//O_RDONLY,Lire seulement
//O_WRONLY,Écris seulement
//O_RDWR,Lire et écrire

Fermer le fichier

#include <unistd.h>
//Retour réussi0,Échec retourné-1
int close(int fd);

Écrire un fichier

#include <unistd.h>
// Nombre d'octets écrits retournés avec succès ,Échec retourné-1
ssize_t write(int fd, const void *buf, size_t nbytes);
//size_t, unsigned int
//ssize_t, signed int
// Définition du système d'exploitation type de données ajouter un suffixe _t

low_open.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
void error_handling(char *message);
int main(int argc, char *argv[]) {

int fd;
char buf[] = "Let's go!\n";
fd = open("data.txt", O_CREAT|O_WRONLY|O_TRUNC);
if(fd==-1)
error_handling("open() error");
printf("file descriptor: %d \n", fd);
if(write(fd, buf, sizeof(buf))==-1)
error_handling("write() error");
close(fd);
return 0;
}
void error_handling(char *message) {

fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
gcc low_open.c -o lopen
./lopen
cat data.txt

Lire le fichier

#include <unistd.h>
// Nombre d'octets reçus retournés avec succès ( Retour prévu à la fin 0),Échec retourné-1
ssize_t read(int fd, const void *buf, size_t nbytes);

low_read.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#define BUF_SIZE 128
void error_handling(char *message);
int main(int argc, char *argv[]) {

int fd;
char buf[BUF_SIZE];
fd = open("data.txt", O_RDONLY);
if(fd==-1)
error_handling("open() error");
printf("file descriptor: %d \n", fd);
if(read(fd, buf, sizeof(buf))==-1)
error_handling("read() error");
printf("file data: %s \n", buf);
close(fd);
return 0;
}
void error_handling(char *message) {

fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
gcc low_read.c -o lread
./lread

Descripteurs de fichiers et sockets

fd_seri.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
int main(int argc, char *argv[]) {

int fd1, fd2, fd3;
fd1 = socket(PF_INET, SOCK_STREAM, 0);
fd2 = open("test.dat", O_CREAT|O_WRONLY|O_TRUNC);
fd3 = socket(PF_INET, SOCK_STREAM, 0);
printf("file descriptor 1: %d \n", fd1);
printf("file descriptor 2: %d \n", fd2);
printf("file descriptor 3: %d \n", fd3);
close(fd1);
close(fd2);
close(fd3);
return 0;
}
void error_handling(char *message) {

fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
gcc fd_seri.c -o fds
./lfds

WindowsSocket

winsock2.h
ws2_32.lib

vs2019Compilation en ligne de commande

Develop Command Prompt for VS2019

cl /help
/Fe:main.exe DésignationexeNom
/std:c11
/LD /Fo:out.DLL Générer une bibliothèque dynamique
/I includeTable des matières
cl /EHsc main.cpp /Fe:main.exe
cl /EHsc main2.cpp func.cpp /link
cl /EHsc hello.c /Fe:hello.exe /link ws2_32.lib
Fichier exécutable
cl src1.cpp src2.cpp /ID:\opencv\include /Fe:out.exe
/I Ajouter un répertoire de fichiers d'en - tête,
/Fe Indiquer la sortieexeNom
Bibliothèque de liens dynamiques
cl /LD src1.cpp src2.cpp /ID:\opencv\include /link /Fo::out.dll
lib.exe Compilable Static linked State Library 、Bibliothèque de liens dynamiques
cl /c src1.cpp src2.cpp # Compiler seulement objDocumentation,Pas de lien
LIB.EXE /OUT:MYLIB.LIB FILE1.OBJ FILE2.OBJ
LINK.EXE /DLL /OUT:MYLIB.DLL FILE3.OBJ FILE4.OBJ

Fonction de corrélation

  • WinsockInitialisation
#include <winsock2.h>
//Succès0
//WORD, unsigned short
//MAKEWORD(1, 2); //Version principale1,Sous - version2,Retour0x0201
//MAKEWORD(2, 2); //Version principale2,Sous - version2,Retour0x0202
//LPWSADATA, WSADATAPointeur 
int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
  • WinsockDestruction
#include <winsock2.h>
//Succès0,ÉchecSOCKET_ERROR
int WSACleanup(void);
  • socket
#include <winsock2.h>
// Poignée de socket retournée avec succès ,ÉchecINVALID_SOCKET
SOCKET socket(int af, int type, int protocol);
  • bind
#include <winsock2.h>
//Succès0,ÉchecSOCKET_ERROR
int bind(SOCKET s, const struct sockaddr *name, int namelen);
  • listen
#include <winsock2.h>
//Succès0,ÉchecSOCKET_ERROR
int listen(SOCKET s, int backlog);
  • accept
#include <winsock2.h>
// Poignée de socket retournée avec succès ,ÉchecINVALID_SOCKET
SOCKET accept(SOCKET s, struct sockaddr *addr, int addrlen);
  • connect
#include <winsock2.h>
// Poignée de socket retournée avec succès ,ÉchecINVALID_SOCKET
SOCKET connect(SOCKET s, const struct sockaddr *name, int namelen);
  • closesocket
#include <winsock2.h>
//Succès0,ÉchecSOCKET_ERROR
int closesocket(SOCKET s);
  • send
#include <winsock2.h>
// Octets réussis ,ÉchecSOCKET_ERROR
int send(SOCKET s, const char *buf, int len, int flags);
  • recv
#include <winsock2.h>
// Octets réussis (Bien reçu.EOFPour0),ÉchecSOCKET_ERROR
int recv(SOCKET s, const char *buf, int len, int flags);

Côté serveur

hello_server_win.c

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
void ErrorHanding(char *message);
int main(int argc, char *argv[]) {

WSADATA wsaData;
SOCKET hServSock, hClntSock;
SOCKADDR_IN servAddr, clntAddr;
int szAddr;
char message[] = "Hello World!";
if(argc!=2) {

printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0)
ErrorHanding("WSAStartup() error!");
hServSock = socket(PF_INET, SOCK_STREAM, 0);
if(hServSock==INVALID_SOCKET)
ErrorHanding("socket() error");
szAddr = sizeof(SOCKADDR_IN);
memset(&servAddr, 0, szAddr);
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
servAddr.sin_port = htons(atoi(argv[1]));
if(bind(hServSock, (SOCKADDR *)&servAddr, szAddr)==SOCKET_ERROR)
ErrorHanding("bind() error");
if(listen(hServSock, 5)==SOCKET_ERROR)
ErrorHanding("listen() error");
hClntSock = accept(hServSock, (SOCKADDR *)&clntAddr, &szAddr);
if(hClntSock==INVALID_SOCKET)
ErrorHanding("accept() error");
send(hClntSock, message, sizeof(message), 0);
closesocket(hClntSock);
closesocket(hServSock);
WSACleanup();
return 0;
}
void ErrorHanding(char *message) {

fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}

Client

hello_client_win.c

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
void ErrorHanding(char *message);
int main(int argc, char *argv[]) {

WSADATA wsaData;
SOCKET hSock;
SOCKADDR_IN servAddr;
char message[30];
int strLen;
if(argc!=3) {

printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
}
if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0)
ErrorHanding("WSAStartup() error!");
hSock = socket(PF_INET, SOCK_STREAM, 0);
if(hSock==INVALID_SOCKET)
ErrorHanding("socket() error");
memset(&servAddr, 0, sizeof(SOCKADDR_IN));
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = inet_addr(argv[1]);
servAddr.sin_port = htons(atoi(argv[2]));
if(connect(hSock, (SOCKADDR *)&servAddr, sizeof(SOCKADDR_IN))==SOCKET_ERROR)
ErrorHanding("connect() error");
strLen = recv(hSock, message, sizeof(message)-1, 0);
if(strLen ==-1)
ErrorHanding("read() error");
message[strLen] = '\0';
printf("Message from server: %s \n", message);
closesocket(hSock);
WSACleanup();
return 0;
}
void ErrorHanding(char *message) {

fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}

Exécution de la compilation

cl /EHsc hello_server_win.c /Fe:hServerWin.exe /link ws2_32.lib
hServerWin 9190
cl /EHsc hello_client_win.c /Fe:hClientWin.exe /link ws2_32.lib
hClientWin 127.0.0.1 9190
版权声明:本文为[Yxqq378287007]所创,转载请带上原文链接,感谢。 https://javamana.com/2022/01/202201080603388969.html