我嘗試創建一個簡單的應用程式，其中服務器同時為局域網中的多個客戶端提供服務，客戶端將資料發送到服務器。問題是服務器不知道如何同時與多個客戶端通信，它仍然只與最后連接的客戶端通信。
我在應用層部署了Salt通道加密協議，保證了傳輸資料的完整性和安全性。我用C語言編程，我使用Mingw編譯器，我使用select()函式和fd_set結構同時處理多個套接字。我寫了客戶端和服務端的代碼，這里握手成功，可以同時和所有客戶端交換資料。隨后，我嘗試在代碼中部署了鹽通道應用協議。但是，當我部署協議時，服務器只為最后登錄的客戶端提供服務。
我創建了客戶端的結構，我考慮它是否包含所有需要的東西。我無法弄清楚為什么服務器一次不能為多個客戶端提供服務的錯誤。我試圖測驗我是否將多個客戶端連接到服務器，但客戶端不發送任何訊息，因此服務器持有它們的套接字，當我關閉服務器時，所有客戶端 - 服務器連接都被關閉，但是一次客戶端發送訊息，當前只有一個客戶端-服務器連接。我有一個while回圈通信，我在fd_set結構中添加一個服務器套接字并呼叫select()函式，當套接字可用于握手時，我呼叫accept()并且回傳值是一個特定的客戶端套接字，然后我將其添加到fd_set 結構，回圈繼續，它會尋找可用的套接字，當它們檢查它是否適合握手時，如果不適合，則呼叫一個函式來接收來自客戶端的訊息并對其進行解密。
//Libraries for working with network tools in Windows
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif
#include <winsock2.h>
#include <ws2tcpip.h>
//pragma comment nie je potrebny, lebo vyuzivam v Makefile subore flag -lws2_32
//#pragma comment(lib, "ws2_32.lib")
//Constants for working with sockets in Windows
#define ISVALIDSOCKET(s) ((s) != INVALID_SOCKET)
#define CLOSESOCKET(s) closesocket(s)
#define GETSOCKETERRNO() (WSAGetLastError())
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
//Libraries of Salt channelv2
#include "salt.h"
#include "salt_io.h"
#include "salti_util.h"
#include <time.h>
//Function for reads encrypted message
salt_ret_t salt_read_begin_pom(salt_channel_t *p_channel,
uint8_t *p_buffer,
uint32_t buffer_size,
salt_msg_t *p_msg,
uint8_t *p_pom,
uint32_t *p_size);
//Ready sk_sec key for server
static uint8_t host_sk_sec[64] = {
0x7a, 0x77, 0x2f, 0xa9, 0x01, 0x4b, 0x42, 0x33,
0x00, 0x07, 0x6a, 0x2f, 0xf6, 0x46, 0x46, 0x39,
0x52, 0xf1, 0x41, 0xe2, 0xaa, 0x8d, 0x98, 0x26,
0x3c, 0x69, 0x0c, 0x0d, 0x72, 0xee, 0xd5, 0x2d,
0x07, 0xe2, 0x8d, 0x4e, 0xe3, 0x2b, 0xfd, 0xc4,
0xb0, 0x7d, 0x41, 0xc9, 0x21, 0x93, 0xc0, 0xc2,
0x5e, 0xe6, 0xb3, 0x09, 0x4c, 0x62, 0x96, 0xf3,
0x73, 0x41, 0x3b, 0x37, 0x3d, 0x36, 0x16, 0x8b
};
typedef struct{
SOCKET sock_fd;
salt_channel_t channel;
struct sockaddr_storage client_address;
socklen_t client_len;
} CLIENT;
void connection_and_servicing(CLIENT *p_client, SOCKET p_socket);
int main() {
#if defined(_WIN32)
//Variables
SOCKET socket_listen;;
CLIENT *client_info;
uint8_t rx_buffer[UINT16_MAX * 4];
uint8_t hndsk_buffer[SALT_HNDSHK_BUFFER_SIZE];
uint8_t pom_buffer[SALT_HNDSHK_BUFFER_SIZE];
salt_msg_t msg_in;
salt_protocols_t protocols;
salt_msg_t msg_out;
salt_ret_t ret_msg;
uint32_t verify = 0, decrypt_size;
//The MAKEWORD macro allows us to request Winsock version 2.2
WSADATA d;
if (WSAStartup(MAKEWORD(2, 2), &d)) { //inicializacia Winscok-u
fprintf(stderr, "Failed to initialize.\n");
return 1;
}
printf("Configuring local address...\n");
//Struct addrinfo hints
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
//Looking address IPv4
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM; //TCP connection
//We ask getaddrinfo () to set the address, for the availability of any network device
hints.ai_flags = AI_PASSIVE;
//Setting a pointer to a structure that contains return information from the getaddrinfo () function
struct addrinfo *bind_address;
getaddrinfo("192.168.100.8", "8080", &hints, &bind_address); //port 8080, generate an address suitable for the bind () function
//Creating socket
printf("Creating socket...\n");
socket_listen = socket(bind_address->ai_family,
bind_address->ai_socktype, bind_address->ai_protocol);
if (!ISVALIDSOCKET(socket_listen)) {
fprintf(stderr, "socket() failed. (%d)\n", GETSOCKETERRNO());
return 1;
}
//Binding socket to local address
printf("Binding socket to local address...\n");
if (bind(socket_listen,
bind_address->ai_addr, bind_address->ai_addrlen)) {
fprintf(stderr, "bind() failed. (%d)\n", GETSOCKETERRNO());
return 1;
}
//After we've called bind(), we use the freeaddrinfo() function to free the memory for bind_address
puts("Bind done");
freeaddrinfo(bind_address);
printf("Listening...\n");
if (listen(socket_listen, 5) < 0) {
fprintf(stderr, "listen() failed. (%d)\n", GETSOCKETERRNO());
return 1;
}
//Define fd_set structure master that stores all of the active sockets
fd_set master;
FD_ZERO(&master);
FD_SET(socket_listen, &master);
SOCKET max_socket = socket_listen;
printf("Waiting for connections...\n");
while(1) {
fd_set reads;
reads = master;
//The select function determines the status of one or more sockets, waiting if necessary, to perform synchronous I/O
if (select(max_socket 1, &reads, 0, 0, 0) < 0) {
fprintf(stderr, "select() failed. (%d)\n", GETSOCKETERRNO());
return 1;
}
SOCKET i;
//Loop through each possible socket
for(i = 1; i <= max_socket; i) {
if (FD_ISSET(i, &reads)) {
//If socket_listen, create TCP connection of accept() function
if (i == socket_listen) {
client_info = (CLIENT *) malloc(sizeof(CLIENT));
client_info->client_len = sizeof(client_info->client_address);
client_info->sock_fd = accept(socket_listen,
(struct sockaddr*) &client_info->client_address,
&client_info->client_len);
if (!ISVALIDSOCKET(client_info->sock_fd)) {
fprintf(stderr, "accept() failed. (%d)\n",
GETSOCKETERRNO());
return 1;
}
FD_SET(client_info->sock_fd, &master);
if (client_info->sock_fd > max_socket)
max_socket = client_info->sock_fd;
//Prints the client address using the getnameinfo() function
char address_buffer[100];
getnameinfo((struct sockaddr*)&client_info->client_address,
&client_info->client_len,
address_buffer, sizeof(address_buffer), 0, 0,
NI_NUMERICHOST);
printf("New connection %s\n", address_buffer);
printf("\nWaiting for succeses Salt handshake...\n");
connection_and_servicing(client_info, socket_listen);
printf("handshake\n");
} else {
ret_msg = SALT_ERROR;
memset(rx_buffer, 0, sizeof(hndsk_buffer));
ret_msg = salt_read_begin_pom(&client_info->channel, rx_buffer, sizeof(rx_buffer), &msg_in, pom_buffer, &decrypt_size);
continue;
}
} //if FD_ISSET
} //for i to max_socket
} //while(1)
printf("Closing listening socket...\n");
free(client_info);
CLOSESOCKET(socket_listen);
WSACleanup();
#endif
printf("Finished.\n");
return 0;
}
void connection_and_servicing(CLIENT *p_client, SOCKET p_socket)
{
//CLIENT *p_client = (context *);
//SOCKET sock = p_client->sock_fd;
uint8_t hndsk_buffer[SALT_HNDSHK_BUFFER_SIZE];
uint8_t rx_buffer[UINT16_MAX * 4];
uint8_t pom_buffer[SALT_HNDSHK_BUFFER_SIZE];
uint8_t tx_buffer[UINT16_MAX * 4];
uint8_t protocol_buffer[128];
uint32_t verify = 0, decrypt_size;
salt_msg_t msg_out;
salt_ret_t ret;
salt_ret_t ret_msg;
salt_msg_t msg_in;
salt_protocols_t protocols;
clock_t start_t, end_t;
ret = salt_create(&p_client->channel, SALT_SERVER, my_write, my_read, &my_time);
assert(ret == SALT_SUCCESS);
//Initiates to add information about supported protocols to host
ret = salt_protocols_init(&p_client->channel, &protocols, protocol_buffer, sizeof(protocol_buffer));
assert(ret == SALT_SUCCESS);
//Add a protocol to supported protocols
ret = salt_protocols_append(&protocols, "ECHO", 4);
assert(ret == SALT_SUCCESS);
//Sets the signature used for the salt channel
ret = salt_set_signature(&p_client->channel, host_sk_sec);
assert(ret == SALT_SUCCESS);
//New ephemeral key pair is generated and the read and write nonce is reseted
ret = salt_init_session(&p_client->channel, hndsk_buffer, sizeof(hndsk_buffer));
assert(ret == SALT_SUCCESS);
//Sets the context passed to the user injected read implementation
ret = salt_set_context(&p_client->channel, &p_client->sock_fd, &p_client->sock_fd);
assert(ret == SALT_SUCCESS);
//Set threshold for delay protection
salt_set_delay_threshold(&p_client->channel, 20000);
start_t = clock();
//Salt handshake
ret = salt_handshake(&p_client->channel, NULL);
end_t = clock();
printf("\n");
printf("\t\n***** SERVER:Salt channelv2 handshake lasted: %6.6f sec. *****\n", ((double) (end_t -
start_t) / (CLOCKS_PER_SEC)));
printf("\n");
//Testing success for Salt handshake
while (ret != SALT_SUCCESS) {
if (ret == SALT_ERROR) {
printf("Error during handshake:\r\n");
printf("Salt error: 0xx\r\n", p_client->channel.err_code);
printf("Salt error read: 0xx\r\n", p_client->channel.read_channel.err_code);
printf("Salt error write: 0xx\r\n", p_client->channel.write_channel.err_code);
printf("Connection closed.\r\n");
CLOSESOCKET(p_client->sock_fd);
free(p_client);
break;
}
ret = salt_handshake(&p_client->channel, NULL);
}
if (ret == SALT_SUCCESS) {
printf("\nSalt handshake successful\r\n");
printf("\n");
verify = 1;
}
這是服務器代碼，我創建了一個CLIENT包含套接字的結構（它表示accept()握手時函式的值，salt_channel_T在連接和service()函式中創建握手所需的結構）。
該salt_read_begin_pom()函式從客戶端接收加密訊息，對其進行驗證、解密，然后將其列印到螢屏上。
uj5u.com熱心網友回復：
問題channel在于您傳遞給salt_read_begin_pom().
您沒有將分配的CLIENT實體存盤在任何有用的地方。您只有一個client_info變數，每次修改新客戶端時都會更新該變數accept()。因此i，您的讀取回圈中的每個不是服務器套接字的套接字最終都會為最后一個'ed 客戶端呼叫salt_read_begin_pom()相同的CLIENT實體accept()。
您需要將您的CLIENT實體存盤在某處，例如在陣列或查找表中，然后對于i讀取回圈中具有等待讀取的資料的每個非服務器套接字，找到相應CLIENT的sock_fd匹配項i，然后使用找到的CLIENT來呼叫salt_read_begin_pom().
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/362105.html
上一篇：根據值聚合對行進行分組