xioayue
/
jwebfs
1
0
Fork 0
Code Issues Pull Requests Projects Releases 3 Wiki Activity
Browse Source

变更代码

master
xyiege 2 months ago
parent
a8d003ad1c
commit
8e9ec43d1c
7 changed files with 1510 additions and 913 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      scalib/include/rpc_transport.h
  2. 215
      scalib/src/rpc_common.c
  3. 570
      scalib/src/rpc_message.c
  4. 885
      scalib/src/rpc_server.c
  5. 678
      scalib/src/rpc_transport.c
  6. 40
      scalib/test_cmake_config.cmd
  7. 33
      scalib/test_compile.cmd

2
scalib/include/rpc_transport.h
View File

@ -48,8 +48,8 @@ typedef struct {
typedef struct {
socket_t server_fd; // 服务器套接字文件描述符
struct sockaddr_in address; // 服务器地址信息
} rpc_server_t;
/* 传输层函数声明 */
// 初始化服务器

215
scalib/src/rpc_common.c
View File

@ -1,97 +1,120 @@
/*
* rpc_common.c
* 实现RPC框架的公共工具函数
*/
#include "rpc_common.h"
/*
* 初始化RPC参数
*/
void rpc_init_param(rpc_param_t* param, rpc_param_type_t type) {
if (!param) return;
param->type = type;
switch (type) {
case RPC_TYPE_INT:
param->value.int_val = 0;
break;
case RPC_TYPE_FLOAT:
param->value.float_val = 0.0f;
break;
case RPC_TYPE_DOUBLE:
param->value.double_val = 0.0;
break;
case RPC_TYPE_STRING:
param->value.string_val = NULL;
break;
case RPC_TYPE_BOOL:
param->value.bool_val = false;
break;
case RPC_TYPE_VOID:
default:
break;
}
}
/*
* 释放参数数组中动态分配的资源
*/
void rpc_free_params(rpc_param_t* params, int count) {
if (!params || count <= 0) return;
for (int i = 0; i < count; i++) {
if (params[i].type == RPC_TYPE_STRING && params[i].value.string_val) {
free((void*)params[i].value.string_val);
params[i].value.string_val = NULL;
}
}
}
/*
* 释放请求消息中动态分配的资源
*/
void rpc_free_request(rpc_request_t* request) {
if (!request) return;
rpc_free_params(request->args, request->args_count);
request->args_count = 0;
request->func_name[0] = '\0';
}
/*
* 释放响应消息中动态分配的资源
*/
void rpc_free_response(rpc_response_t* response) {
if (!response) return;
if (response->return_type == RPC_TYPE_STRING && response->return_value.string_val) {
free((void*)response->return_value.string_val);
response->return_value.string_val = NULL;
}
response->result_code = 0;
response->return_type = RPC_TYPE_VOID;
}
/*
* 将错误码转换为字符串
*/
const char* rpc_error_to_string(int error_code) {
switch (error_code) {
case RPC_SUCCESS:
return "Success";
case RPC_ERROR:
return "General error";
case RPC_NET_ERROR:
return "Network error";
case RPC_TIMEOUT:
return "Timeout error";
case RPC_INVALID_ARGS:
return "Invalid arguments";
case RPC_FUNC_NOT_FOUND:
return "Function not found";
default:
return "Unknown error";
}
/*
* rpc_common.c
* 实现RPC框架的公共工具函数
*/
#include "rpc_common.h"
/*
* 初始化RPC参数
*/
void rpc_init_param(rpc_param_t* param, rpc_param_type_t type) {
if (!param) return;
param->type = type;
switch (type) {
case RPC_TYPE_INT:
param->value.int_val = 0;
break;
case RPC_TYPE_FLOAT:
param->value.float_val = 0.0f;
break;
case RPC_TYPE_DOUBLE:
param->value.double_val = 0.0;
break;
case RPC_TYPE_STRING:
param->value.string_val = NULL;
break;
case RPC_TYPE_BOOL:
param->value.bool_val = false;
break;
case RPC_TYPE_VOID:
break;
default:
break;
}
}
/*
* 释放参数数组中动态分配的资源
*/
void rpc_free_params(rpc_param_t* params, int count) {
if (!params || count <= 0) return;
for (int i = 0; i < count; i++) {
if (params[i].type == RPC_TYPE_STRING && params[i].value.string_val) {
free((void*)params[i].value.string_val);
params[i].value.string_val = NULL;
}
}
}
/*
* 释放请求消息中动态分配的资源
*/
void rpc_free_request(rpc_request_t* request) {
if (!request) return;
rpc_free_params(request->args, request->args_count);
request->args_count = 0;
request->func_name[0] = '\0';
}
/*
* 释放响应消息中动态分配的资源
*/
void rpc_free_response(rpc_response_t* response) {
if (!response) return;
if (response->return_type == RPC_TYPE_STRING && response->return_value.string_val) {
free((void*)response->return_value.string_val);
response->return_value.string_val = NULL;
}
response->result_code = 0;
response->return_type = RPC_TYPE_VOID;
}
/*
* 将错误码转换为字符串
*/
const char* rpc_error_to_string(int error_code) {
switch (error_code) {
case RPC_SUCCESS:
return "Success";
case RPC_ERROR:
return "General error";
case RPC_NET_ERROR:
return "Network error";
case RPC_TIMEOUT:
return "Timeout error";
case RPC_INVALID_ARGS:
return "Invalid arguments";
case RPC_FUNC_NOT_FOUND:
return "Function not found";
default:
return "Unknown error";
}
}

570
scalib/src/rpc_message.c
View File

@ -1,191 +1,381 @@
/*
* rpc_message.c
* 实现RPC消息的序列化和反序列化功能
*/
#include "rpc_message.h"
#include "rpc_transport.h"
/*
* 序列化请求消息到缓冲区
*/
int rpc_serialize_request(const rpc_request_t* request, void* buffer, size_t buffer_size) {
if (!request || !buffer || buffer_size < sizeof(rpc_request_t)) {
return RPC_INVALID_ARGS;
}
// 复制请求消息到缓冲区
memcpy(buffer, request, sizeof(rpc_request_t));
// 注意：这里简化了字符串参数的序列化，实际上可能需要更复杂的处理
// 在实际应用中，可能需要计算字符串的总长度并动态分配足够的缓冲区
return RPC_SUCCESS;
}
/*
* 反序列化缓冲区到请求消息
*/
int rpc_deserialize_request(const void* buffer, size_t buffer_size, rpc_request_t* request) {
if (!buffer || !request || buffer_size < sizeof(rpc_request_t)) {
return RPC_INVALID_ARGS;
}
// 从缓冲区复制请求消息
memcpy(request, buffer, sizeof(rpc_request_t));
// 注意：这里简化了字符串参数的反序列化
// 在实际应用中，可能需要处理字符串的动态分配和复制
return RPC_SUCCESS;
}
/*
* 序列化响应消息到缓冲区
*/
int rpc_serialize_response(const rpc_response_t* response, void* buffer, size_t buffer_size) {
if (!response || !buffer || buffer_size < sizeof(rpc_response_t)) {
return RPC_INVALID_ARGS;
}
// 复制响应消息到缓冲区
memcpy(buffer, response, sizeof(rpc_response_t));
// 注意：这里简化了字符串返回值的序列化
return RPC_SUCCESS;
}
/*
* 反序列化缓冲区到响应消息
*/
int rpc_deserialize_response(const void* buffer, size_t buffer_size, rpc_response_t* response) {
if (!buffer || !response || buffer_size < sizeof(rpc_response_t)) {
return RPC_INVALID_ARGS;
}
// 从缓冲区复制响应消息
memcpy(response, buffer, sizeof(rpc_response_t));
// 注意：这里简化了字符串返回值的反序列化
return RPC_SUCCESS;
}
/*
* 发送请求消息
*/
int rpc_send_request(rpc_transport_t* transport, const rpc_request_t* request) {
if (!transport || !request) {
return RPC_INVALID_ARGS;
}
uint8_t buffer[MAX_MESSAGE_SIZE];
rpc_message_t message;
// 设置消息头部
message.header.type = RPC_MESSAGE_REQUEST;
message.header.payload_size = sizeof(rpc_request_t);
// 复制请求到消息负载
message.payload.request = *request;
// 序列化整个消息
size_t message_size = sizeof(rpc_message_header_t) + message.header.payload_size;
if (message_size > MAX_MESSAGE_SIZE) {
return RPC_ERROR;
}
memcpy(buffer, &message, message_size);
// 发送消息
return rpc_transport_send(transport, buffer, message_size);
}
/*
* 接收请求消息
*/
int rpc_recv_request(rpc_transport_t* transport, rpc_request_t* request) {
if (!transport || !request) {
return RPC_INVALID_ARGS;
}
uint8_t buffer[MAX_MESSAGE_SIZE];
rpc_message_header_t header;
// 接收消息头部
if (rpc_transport_recv(transport, &header, sizeof(rpc_message_header_t)) != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
// 检查消息类型和大小
if (header.type != RPC_MESSAGE_REQUEST || header.payload_size > MAX_MESSAGE_SIZE - sizeof(rpc_message_header_t)) {
return RPC_ERROR;
}
// 接收消息负载
if (rpc_transport_recv(transport, request, header.payload_size) != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
return RPC_SUCCESS;
}
/*
* 发送响应消息
*/
int rpc_send_response(rpc_transport_t* transport, const rpc_response_t* response) {
if (!transport || !response) {
return RPC_INVALID_ARGS;
}
uint8_t buffer[MAX_MESSAGE_SIZE];
rpc_message_t message;
// 设置消息头部
message.header.type = RPC_MESSAGE_RESPONSE;
message.header.payload_size = sizeof(rpc_response_t);
// 复制响应到消息负载
message.payload.response = *response;
// 序列化整个消息
size_t message_size = sizeof(rpc_message_header_t) + message.header.payload_size;
if (message_size > MAX_MESSAGE_SIZE) {
return RPC_ERROR;
}
memcpy(buffer, &message, message_size);
// 发送消息
return rpc_transport_send(transport, buffer, message_size);
}
/*
* 接收响应消息
*/
int rpc_recv_response(rpc_transport_t* transport, rpc_response_t* response) {
if (!transport || !response) {
return RPC_INVALID_ARGS;
}
uint8_t buffer[MAX_MESSAGE_SIZE];
rpc_message_header_t header;
// 接收消息头部
if (rpc_transport_recv(transport, &header, sizeof(rpc_message_header_t)) != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
// 检查消息类型和大小
if (header.type != RPC_MESSAGE_RESPONSE || header.payload_size > MAX_MESSAGE_SIZE - sizeof(rpc_message_header_t)) {
return RPC_ERROR;
}
// 接收消息负载
if (rpc_transport_recv(transport, response, header.payload_size) != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
return RPC_SUCCESS;
/*
* rpc_message.c
* 实现RPC消息的序列化和反序列化功能
*/
#include "rpc_message.h"
#include "rpc_transport.h"
/*
* 序列化请求消息到缓冲区
*/
int rpc_serialize_request(const rpc_request_t* request, void* buffer, size_t buffer_size) {
if (!request || !buffer || buffer_size < sizeof(rpc_request_t)) {
return RPC_INVALID_ARGS;
}
// 复制请求消息到缓冲区
memcpy(buffer, request, sizeof(rpc_request_t));
// 注意：这里简化了字符串参数的序列化，实际上可能需要更复杂的处理
// 在实际应用中，可能需要计算字符串的总长度并动态分配足够的缓冲区
return RPC_SUCCESS;
}
/*
* 反序列化缓冲区到请求消息
*/
int rpc_deserialize_request(const void* buffer, size_t buffer_size, rpc_request_t* request) {
if (!buffer || !request || buffer_size < sizeof(rpc_request_t)) {
return RPC_INVALID_ARGS;
}
// 从缓冲区复制请求消息
memcpy(request, buffer, sizeof(rpc_request_t));
// 注意：这里简化了字符串参数的反序列化
// 在实际应用中，可能需要处理字符串的动态分配和复制
return RPC_SUCCESS;
}
/*
* 序列化响应消息到缓冲区
*/
int rpc_serialize_response(const rpc_response_t* response, void* buffer, size_t buffer_size) {
if (!response || !buffer || buffer_size < sizeof(rpc_response_t)) {
return RPC_INVALID_ARGS;
}
// 复制响应消息到缓冲区
memcpy(buffer, response, sizeof(rpc_response_t));
// 注意：这里简化了字符串返回值的序列化
return RPC_SUCCESS;
}
/*
* 反序列化缓冲区到响应消息
*/
int rpc_deserialize_response(const void* buffer, size_t buffer_size, rpc_response_t* response) {
if (!buffer || !response || buffer_size < sizeof(rpc_response_t)) {
return RPC_INVALID_ARGS;
}
// 从缓冲区复制响应消息
memcpy(response, buffer, sizeof(rpc_response_t));
// 注意：这里简化了字符串返回值的反序列化
return RPC_SUCCESS;
}
/*
* 发送请求消息
*/
int rpc_send_request(rpc_transport_t* transport, const rpc_request_t* request) {
if (!transport || !request) {
return RPC_INVALID_ARGS;
}
uint8_t buffer[MAX_MESSAGE_SIZE];
rpc_message_t message;
// 设置消息头部
message.header.type = RPC_MESSAGE_REQUEST;
message.header.payload_size = sizeof(rpc_request_t);
// 复制请求到消息负载
message.payload.request = *request;
// 序列化整个消息
size_t message_size = sizeof(rpc_message_header_t) + message.header.payload_size;
if (message_size > MAX_MESSAGE_SIZE) {
return RPC_ERROR;
}
memcpy(buffer, &message, message_size);
// 发送消息
return rpc_transport_send(transport, buffer, message_size);
}
/*
* 接收请求消息
*/
int rpc_recv_request(rpc_transport_t* transport, rpc_request_t* request) {
if (!transport || !request) {
return RPC_INVALID_ARGS;
}
uint8_t buffer[MAX_MESSAGE_SIZE];
rpc_message_header_t header;
// 接收消息头部
if (rpc_transport_recv(transport, &header, sizeof(rpc_message_header_t)) != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
// 检查消息类型和大小
if (header.type != RPC_MESSAGE_REQUEST || header.payload_size > MAX_MESSAGE_SIZE - sizeof(rpc_message_header_t)) {
return RPC_ERROR;
}
// 接收消息负载
if (rpc_transport_recv(transport, request, header.payload_size) != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
return RPC_SUCCESS;
}
/*
* 发送响应消息
*/
int rpc_send_response(rpc_transport_t* transport, const rpc_response_t* response) {
if (!transport || !response) {
return RPC_INVALID_ARGS;
}
uint8_t buffer[MAX_MESSAGE_SIZE];
rpc_message_t message;
// 设置消息头部
message.header.type = RPC_MESSAGE_RESPONSE;
message.header.payload_size = sizeof(rpc_response_t);
// 复制响应到消息负载
message.payload.response = *response;
// 序列化整个消息
size_t message_size = sizeof(rpc_message_header_t) + message.header.payload_size;
if (message_size > MAX_MESSAGE_SIZE) {
return RPC_ERROR;
}
memcpy(buffer, &message, message_size);
// 发送消息
return rpc_transport_send(transport, buffer, message_size);
}
/*
* 接收响应消息
*/
int rpc_recv_response(rpc_transport_t* transport, rpc_response_t* response) {
if (!transport || !response) {
return RPC_INVALID_ARGS;
}
uint8_t buffer[MAX_MESSAGE_SIZE];
rpc_message_header_t header;
// 接收消息头部
if (rpc_transport_recv(transport, &header, sizeof(rpc_message_header_t)) != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
// 检查消息类型和大小
if (header.type != RPC_MESSAGE_RESPONSE || header.payload_size > MAX_MESSAGE_SIZE - sizeof(rpc_message_header_t)) {
return RPC_ERROR;
}
// 接收消息负载
if (rpc_transport_recv(transport, response, header.payload_size) != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
return RPC_SUCCESS;
}

885
scalib/src/rpc_server.c
View File

@ -1,296 +1,591 @@
/*
* rpc_server.c
* RPC服务器实现，处理客户端连接和执行远程函数调用
*/
#include "rpc_common.h"
#include "rpc_transport.h"
#include "rpc_message.h"
#ifdef _WIN32
#include <windows.h>
#else
#include <pthread.h>
#endif
/* 函数处理函数类型定义 */
typedef int (*rpc_handler_func_t)(rpc_param_t* params, int args_count, rpc_param_t* return_value);
/* 函数处理器结构 */
typedef struct {
char func_name[MAX_FUNC_NAME_LEN];
rpc_handler_func_t handler;
rpc_param_type_t return_type;
rpc_param_type_t param_types[MAX_ARGS_COUNT];
int param_count;
} rpc_handler_t;
/* 函数处理器表 */
static rpc_handler_t handlers[MAX_FUNC_NAME_LEN];
static int handler_count = 0;
/*
* 注册远程函数
*/
int rpc_register_function(const char* func_name, rpc_handler_func_t handler,
rpc_param_type_t return_type,
rpc_param_type_t* param_types, int param_count) {
if (!func_name || !handler || param_count < 0 || param_count > MAX_ARGS_COUNT) {
return RPC_INVALID_ARGS;
}
if (handler_count >= MAX_FUNC_NAME_LEN) {
return RPC_ERROR;
}
// 检查函数名是否已存在
for (int i = 0; i < handler_count; i++) {
if (strcmp(handlers[i].func_name, func_name) == 0) {
return RPC_ERROR;
}
}
// 添加新的函数处理器
strncpy(handlers[handler_count].func_name, func_name, MAX_FUNC_NAME_LEN - 1);
handlers[handler_count].func_name[MAX_FUNC_NAME_LEN - 1] = '\0';
handlers[handler_count].handler = handler;
handlers[handler_count].return_type = return_type;
handlers[handler_count].param_count = param_count;
// 复制参数类型
if (param_count > 0 && param_types) {
memcpy(handlers[handler_count].param_types, param_types,
sizeof(rpc_param_type_t) * param_count);
}
handler_count++;
printf("Registered function: %s\n", func_name);
return RPC_SUCCESS;
}
/*
* 查找函数处理器
*/
rpc_handler_t* rpc_find_handler(const char* func_name) {
for (int i = 0; i < handler_count; i++) {
if (strcmp(handlers[i].func_name, func_name) == 0) {
return &handlers[i];
}
}
return NULL;
}
/*
* 处理客户端请求
*/
#ifdef _WIN32
DWORD WINAPI handle_client(LPVOID arg) {
#else
void* handle_client(void* arg) {
#endif
rpc_transport_t* transport = (rpc_transport_t*)arg;
rpc_request_t request;
rpc_response_t response;
int ret;
while (1) {
// 接收请求
ret = rpc_recv_request(transport, &request);
if (ret != RPC_SUCCESS) {
printf("Failed to receive request: %s\n", rpc_error_to_string(ret));
break;
}
printf("Received request: %s with %d arguments\n", request.func_name, request.args_count);
// 查找函数处理器
rpc_handler_t* handler = rpc_find_handler(request.func_name);
if (!handler) {
printf("Function not found: %s\n", request.func_name);
response.result_code = RPC_FUNC_NOT_FOUND;
response.return_type = RPC_TYPE_VOID;
rpc_send_response(transport, &response);
rpc_free_request(&request);
continue;
}
// 检查参数数量
if (request.args_count != handler->param_count) {
printf("Invalid argument count for %s\n", request.func_name);
response.result_code = RPC_INVALID_ARGS;
response.return_type = RPC_TYPE_VOID;
rpc_send_response(transport, &response);
rpc_free_request(&request);
continue;
}
// 执行函数
rpc_param_t return_value;
rpc_init_param(&return_value, handler->return_type);
ret = handler->handler(request.args, request.args_count, &return_value);
// 设置响应
response.result_code = ret;
response.return_type = handler->return_type;
// 复制返回值
switch (handler->return_type) {
case RPC_TYPE_INT:
response.return_value.int_val = return_value.value.int_val;
break;
case RPC_TYPE_FLOAT:
response.return_value.float_val = return_value.value.float_val;
break;
case RPC_TYPE_DOUBLE:
response.return_value.double_val = return_value.value.double_val;
break;
case RPC_TYPE_STRING:
// 注意：这里需要复制字符串，避免内存问题
response.return_value.string_val = strdup(return_value.value.string_val);
break;
case RPC_TYPE_BOOL:
response.return_value.bool_val = return_value.value.bool_val;
break;
case RPC_TYPE_VOID:
default:
break;
}
// 发送响应
rpc_send_response(transport, &response);
// 释放资源
rpc_free_request(&request);
if (handler->return_type == RPC_TYPE_STRING && return_value.value.string_val) {
free((void*)return_value.value.string_val);
}
if (response.return_type == RPC_TYPE_STRING && response.return_value.string_val) {
free((void*)response.return_value.string_val);
}
}
// 关闭连接
rpc_transport_close(transport);
free(transport);
#ifdef _WIN32
return 0;
#else
return NULL;
#endif
}
/*
* 示例函数：加法
*/
int add_handler(rpc_param_t* params, int args_count, rpc_param_t* return_value) {
if (args_count < 2 || params[0].type != RPC_TYPE_INT || params[1].type != RPC_TYPE_INT) {
return RPC_INVALID_ARGS;
}
int a = params[0].value.int_val;
int b = params[1].value.int_val;
return_value->value.int_val = a + b;
printf("Executed add(%d, %d) = %d\n", a, b, return_value->value.int_val);
return RPC_SUCCESS;
}
/*
* 示例函数：获取服务器信息
*/
int get_server_info_handler(rpc_param_t* params, int args_count, rpc_param_t* return_value) {
const char* info = "RPC Server v1.0";
return_value->value.string_val = strdup(info);
printf("Executed get_server_info()\n");
return RPC_SUCCESS;
}
/*
* 主函数
*/
int main(int argc, char* argv[]) {
rpc_server_t server;
int port = 8080;
#ifdef _WIN32
// 初始化Windows套接字库
if (rpc_winsock_init() != RPC_SUCCESS) {
printf("Failed to initialize Winsock\n");
return 1;
}
#endif
// 注册示例函数
rpc_param_type_t add_params[] = {RPC_TYPE_INT, RPC_TYPE_INT};
rpc_register_function("add", add_handler, RPC_TYPE_INT, add_params, 2);
rpc_register_function("get_server_info", get_server_info_handler, RPC_TYPE_STRING, NULL, 0);
// 初始化服务器
if (rpc_server_init(&server, "0.0.0.0", port, 5) != RPC_SUCCESS) {
printf("Failed to initialize server\n");
return 1;
}
printf("RPC Server listening on port %d\n", port);
printf("Waiting for client connections...\n");
while (1) {
// 接受客户端连接
rpc_transport_t* client_transport = (rpc_transport_t*)malloc(sizeof(rpc_transport_t));
if (!client_transport) {
printf("Failed to allocate memory\n");
continue;
}
if (rpc_server_accept(&server, client_transport) != RPC_SUCCESS) {
free(client_transport);
continue;
}
// 创建线程处理客户端请求
#ifdef _WIN32
HANDLE thread_handle = CreateThread(
NULL, // 默认安全属性
0, // 默认堆栈大小
handle_client, // 线程函数
client_transport, // 线程参数
0, // 默认创建标志
NULL // 线程ID（不需要）
);
if (thread_handle == NULL) {
fprintf(stderr, "CreateThread failed with error code: %d\n", GetLastError());
rpc_transport_close(client_transport);
free(client_transport);
continue;
}
// 关闭线程句柄但不终止线程，让线程自动结束
CloseHandle(thread_handle);
#else
pthread_t thread_id;
if (pthread_create(&thread_id, NULL, handle_client, client_transport) != 0) {
perror("pthread_create failed");
rpc_transport_close(client_transport);
free(client_transport);
continue;
}
// 分离线程，自动回收资源
pthread_detach(thread_id);
#endif
}
// 关闭服务器
rpc_server_close(&server);
#ifdef _WIN32
// 清理Windows套接字库
rpc_winsock_cleanup();
#endif
return 0;
/*
* rpc_server.c
* RPC服务器实现，处理客户端连接和执行远程函数调用
*/
#include "rpc_common.h"
#include "rpc_transport.h"
#include "rpc_message.h"
#ifdef _WIN32
#include <windows.h>
#else
#include <pthread.h>
#endif
/* 函数处理函数类型定义 */
typedef int (*rpc_handler_func_t)(rpc_param_t* params, int args_count, rpc_param_t* return_value);
/* 函数处理器结构 */
typedef struct {
char func_name[MAX_FUNC_NAME_LEN];
rpc_handler_func_t handler;
rpc_param_type_t return_type;
rpc_param_type_t param_types[MAX_ARGS_COUNT];
int param_count;
} rpc_handler_t;
/* 函数处理器表 */
static rpc_handler_t handlers[MAX_FUNC_NAME_LEN];
static int handler_count = 0;
/*
* 注册远程函数
*/
int rpc_register_function(const char* func_name, rpc_handler_func_t handler,
rpc_param_type_t return_type,
rpc_param_type_t* param_types, int param_count) {
if (!func_name || !handler || param_count < 0 || param_count > MAX_ARGS_COUNT) {
return RPC_INVALID_ARGS;
}
if (handler_count >= MAX_FUNC_NAME_LEN) {
return RPC_ERROR;
}
// 检查函数名是否已存在
for (int i = 0; i < handler_count; i++) {
if (strcmp(handlers[i].func_name, func_name) == 0) {
return RPC_ERROR;
}
}
// 添加新的函数处理器
strncpy(handlers[handler_count].func_name, func_name, MAX_FUNC_NAME_LEN - 1);
handlers[handler_count].func_name[MAX_FUNC_NAME_LEN - 1] = '\0';
handlers[handler_count].handler = handler;
handlers[handler_count].return_type = return_type;
handlers[handler_count].param_count = param_count;
// 复制参数类型
if (param_count > 0 && param_types) {
memcpy(handlers[handler_count].param_types, param_types,
sizeof(rpc_param_type_t) * param_count);
}
handler_count++;
printf("Registered function: %s\n", func_name);
return RPC_SUCCESS;
}
/*
* 查找函数处理器
*/
rpc_handler_t* rpc_find_handler(const char* func_name) {
for (int i = 0; i < handler_count; i++) {
if (strcmp(handlers[i].func_name, func_name) == 0) {
return &handlers[i];
}
}
return NULL;
}
/*
* 处理客户端请求
*/
#ifdef _WIN32
DWORD WINAPI handle_client(LPVOID arg) {
#else
void* handle_client(void* arg) {
#endif
rpc_transport_t* transport = (rpc_transport_t*)arg;
rpc_request_t request;
rpc_response_t response;
int ret;
while (1) {
// 接收请求
ret = rpc_recv_request(transport, &request);
if (ret != RPC_SUCCESS) {
printf("Failed to receive request: %s\n", rpc_error_to_string(ret));
break;
}
printf("Received request: %s with %d arguments\n", request.func_name, request.args_count);
// 查找函数处理器
rpc_handler_t* handler = rpc_find_handler(request.func_name);
if (!handler) {
printf("Function not found: %s\n", request.func_name);
response.result_code = RPC_FUNC_NOT_FOUND;
response.return_type = RPC_TYPE_VOID;
rpc_send_response(transport, &response);
rpc_free_request(&request);
continue;
}
// 检查参数数量
if (request.args_count != handler->param_count) {
printf("Invalid argument count for %s\n", request.func_name);
response.result_code = RPC_INVALID_ARGS;
response.return_type = RPC_TYPE_VOID;
rpc_send_response(transport, &response);
rpc_free_request(&request);
continue;
}
// 执行函数
rpc_param_t return_value;
rpc_init_param(&return_value, handler->return_type);
ret = handler->handler(request.args, request.args_count, &return_value);
// 设置响应
response.result_code = ret;
response.return_type = handler->return_type;
// 复制返回值
switch (handler->return_type) {
case RPC_TYPE_INT:
response.return_value.int_val = return_value.value.int_val;
break;
case RPC_TYPE_FLOAT:
response.return_value.float_val = return_value.value.float_val;
break;
case RPC_TYPE_DOUBLE:
response.return_value.double_val = return_value.value.double_val;
break;
case RPC_TYPE_STRING:
// 注意：这里需要复制字符串，避免内存问题
response.return_value.string_val = strdup(return_value.value.string_val);
break;
case RPC_TYPE_BOOL:
response.return_value.bool_val = return_value.value.bool_val;
break;
case RPC_TYPE_VOID:
default:
break;
}
// 发送响应
rpc_send_response(transport, &response);
// 释放资源
rpc_free_request(&request);
if (handler->return_type == RPC_TYPE_STRING && return_value.value.string_val) {
free((void*)return_value.value.string_val);
}
if (response.return_type == RPC_TYPE_STRING && response.return_value.string_val) {
free((void*)response.return_value.string_val);
}
}
// 关闭连接
rpc_transport_close(transport);
free(transport);
#ifdef _WIN32
return 0;
#else
return NULL;
#endif
}
/*
* 示例函数：加法
*/
int add_handler(rpc_param_t* params, int args_count, rpc_param_t* return_value) {
if (args_count < 2 || params[0].type != RPC_TYPE_INT || params[1].type != RPC_TYPE_INT) {
return RPC_INVALID_ARGS;
}
int a = params[0].value.int_val;
int b = params[1].value.int_val;
return_value->value.int_val = a + b;
printf("Executed add(%d, %d) = %d\n", a, b, return_value->value.int_val);
return RPC_SUCCESS;
}
/*
* 示例函数：获取服务器信息
*/
int get_server_info_handler(rpc_param_t* params, int args_count, rpc_param_t* return_value) {
const char* info = "RPC Server v1.0";
return_value->value.string_val = strdup(info);
printf("Executed get_server_info()\n");
return RPC_SUCCESS;
}
/*
* 主函数
*/
int main(int argc, char* argv[]) {
rpc_server_t server;
int port = 8080;
#ifdef _WIN32
// 初始化Windows套接字库
if (rpc_winsock_init() != RPC_SUCCESS) {
printf("Failed to initialize Winsock\n");
return 1;
}
#endif
// 注册示例函数
rpc_param_type_t add_params[] = {RPC_TYPE_INT, RPC_TYPE_INT};
rpc_register_function("add", add_handler, RPC_TYPE_INT, add_params, 2);
rpc_register_function("get_server_info", get_server_info_handler, RPC_TYPE_STRING, NULL, 0);
// 初始化服务器
if (rpc_server_init(&server, "0.0.0.0", port, 5) != RPC_SUCCESS) {
printf("Failed to initialize server\n");
return 1;
}
printf("RPC Server listening on port %d\n", port);
printf("Waiting for client connections...\n");
while (1) {
// 接受客户端连接
rpc_transport_t* client_transport = (rpc_transport_t*)malloc(sizeof(rpc_transport_t));
if (!client_transport) {
printf("Failed to allocate memory\n");
continue;
}
if (rpc_server_accept(&server, client_transport) != RPC_SUCCESS) {
free(client_transport);
continue;
}
// 创建线程处理客户端请求
#ifdef _WIN32
HANDLE thread_handle = CreateThread(
NULL, // 默认安全属性
0, // 默认堆栈大小
handle_client, // 线程函数
client_transport, // 线程参数
0, // 默认创建标志
NULL // 线程ID（不需要）
);
if (thread_handle == NULL) {
fprintf(stderr, "CreateThread failed with error code: %d\n", GetLastError());
rpc_transport_close(client_transport);
free(client_transport);
continue;
}
// 关闭线程句柄但不终止线程，让线程自动结束
CloseHandle(thread_handle);
#else
pthread_t thread_id;
if (pthread_create(&thread_id, NULL, handle_client, client_transport) != 0) {
perror("pthread_create failed");
rpc_transport_close(client_transport);
free(client_transport);
continue;
}
// 分离线程，自动回收资源
pthread_detach(thread_id);
#endif
}
// 关闭服务器
rpc_server_close(&server);
#ifdef _WIN32
// 清理Windows套接字库
rpc_winsock_cleanup();
#endif
return 0;
}

678
scalib/src/rpc_transport.c
View File

@ -1,259 +1,421 @@
/*
* rpc_transport.c
* 实现RPC传输层的功能，处理网络通信
*/
#include "rpc_transport.h"
#ifdef _WIN32
/*
* 初始化Windows套接字库
*/
int rpc_winsock_init() {
WSADATA wsaData;
int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (result != 0) {
fprintf(stderr, "WSAStartup failed: %d\n", result);
return RPC_NET_ERROR;
}
return RPC_SUCCESS;
}
/*
* 清理Windows套接字库
*/
void rpc_winsock_cleanup() {
WSACleanup();
}
/*
* Windows平台的错误打印函数
*/
static void print_windows_error(const char* message) {
int error_code = WSAGetLastError();
char* error_text = NULL;
FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR)&error_text, 0, NULL);
if (error_text) {
fprintf(stderr, "%s: %s\n", message, error_text);
LocalFree(error_text);
} else {
fprintf(stderr, "%s: Error code %d\n", message, error_code);
}
}
#define PRINT_ERROR(msg) print_windows_error(msg)
#else
/*
* Linux/Unix平台的错误打印函数
*/
#define PRINT_ERROR(msg) perror(msg)
#endif
/*
* 初始化RPC服务器
*/
int rpc_server_init(rpc_server_t* server, const char* host, uint16_t port, int backlog) {
if (!server || !host) {
return RPC_INVALID_ARGS;
}
// 创建套接字
server->server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server->server_fd == INVALID_SOCKET_VALUE) {
PRINT_ERROR("socket creation failed");
return RPC_NET_ERROR;
}
// 设置套接字选项，允许地址重用
int opt = 1;
#ifdef _WIN32
// Windows不支持SO_REUSEPORT
if (setsockopt(server->server_fd, SOL_SOCKET, SO_REUSEADDR,
&opt, sizeof(opt)) != 0) {
#else
// Linux/Unix支持SO_REUSEPORT
if (setsockopt(server->server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,
&opt, sizeof(opt)) != 0) {
#endif
PRINT_ERROR("setsockopt failed");
CLOSE_SOCKET(server->server_fd);
return RPC_NET_ERROR;
}
// 设置服务器地址结构
memset(&server->address, 0, sizeof(server->address));
server->address.sin_family = AF_INET;
server->address.sin_addr.s_addr = inet_addr(host);
server->address.sin_port = htons(port);
// 绑定地址到套接字
if (bind(server->server_fd, (struct sockaddr*)&server->address, sizeof(server->address)) != 0) {
PRINT_ERROR("bind failed");
CLOSE_SOCKET(server->server_fd);
return RPC_NET_ERROR;
}
// 开始监听连接
if (listen(server->server_fd, backlog) != 0) {
PRINT_ERROR("listen failed");
CLOSE_SOCKET(server->server_fd);
return RPC_NET_ERROR;
}
printf("RPC Server started on %s:%d\n", host, port);
return RPC_SUCCESS;
}
/*
* 服务器接受客户端连接
*/
int rpc_server_accept(rpc_server_t* server, rpc_transport_t* transport) {
if (!server || !transport) {
return RPC_INVALID_ARGS;
}
socklen_t addrlen = sizeof(transport->address);
transport->socket_fd = accept(server->server_fd, (struct sockaddr*)&transport->address, &addrlen);
if (transport->socket_fd == INVALID_SOCKET_VALUE) {
PRINT_ERROR("accept failed");
return RPC_NET_ERROR;
}
printf("Client connected: %s:%d\n",
inet_ntoa(transport->address.sin_addr),
ntohs(transport->address.sin_port));
return RPC_SUCCESS;
}
/*
* 关闭RPC服务器
*/
void rpc_server_close(rpc_server_t* server) {
if (!server || server->server_fd == INVALID_SOCKET_VALUE) {
return;
}
CLOSE_SOCKET(server->server_fd);
server->server_fd = INVALID_SOCKET_VALUE;
printf("RPC Server closed\n");
}
/*
* 初始化RPC客户端传输
*/
int rpc_client_init(rpc_transport_t* transport, const char* server_host, uint16_t server_port) {
if (!transport || !server_host) {
return RPC_INVALID_ARGS;
}
// 创建套接字
transport->socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (transport->socket_fd == INVALID_SOCKET_VALUE) {
PRINT_ERROR("socket creation failed");
return RPC_NET_ERROR;
}
// 设置服务器地址结构
memset(&transport->address, 0, sizeof(transport->address));
transport->address.sin_family = AF_INET;
transport->address.sin_port = htons(server_port);
// 将主机名转换为IP地址
if (inet_pton(AF_INET, server_host, &transport->address.sin_addr) <= 0) {
PRINT_ERROR("invalid address");
CLOSE_SOCKET(transport->socket_fd);
return RPC_NET_ERROR;
}
// 连接到服务器
if (connect(transport->socket_fd, (struct sockaddr*)&transport->address, sizeof(transport->address)) != 0) {
PRINT_ERROR("connection failed");
CLOSE_SOCKET(transport->socket_fd);
return RPC_NET_ERROR;
}
printf("Connected to server %s:%d\n", server_host, server_port);
return RPC_SUCCESS;
}
/*
* 通过传输层发送数据
*/
int rpc_transport_send(rpc_transport_t* transport, const void* data, size_t data_size) {
if (!transport || !data || data_size == 0) {
return RPC_INVALID_ARGS;
}
// 发送所有数据
size_t sent_bytes = 0;
while (sent_bytes < data_size) {
#ifdef _WIN32
int bytes = send(transport->socket_fd, (const char*)data + sent_bytes, (
#ifdef _WIN64
int
#else
int
#endif
)(data_size - sent_bytes), 0);
#else
ssize_t bytes = send(transport->socket_fd, (const char*)data + sent_bytes, data_size - sent_bytes, 0);
#endif
if (bytes <= 0) {
PRINT_ERROR("send failed");
return RPC_NET_ERROR;
}
sent_bytes += bytes;
}
return RPC_SUCCESS;
}
/*
* 通过传输层接收数据
*/
int rpc_transport_recv(rpc_transport_t* transport, void* buffer, size_t buffer_size) {
if (!transport || !buffer || buffer_size == 0) {
return RPC_INVALID_ARGS;
}
// 接收所有数据
size_t recv_bytes = 0;
while (recv_bytes < buffer_size) {
#ifdef _WIN32
int bytes = recv(transport->socket_fd, (char*)buffer + recv_bytes, (
#ifdef _WIN64
int
#else
int
#endif
)(buffer_size - recv_bytes), 0);
#else
ssize_t bytes = recv(transport->socket_fd, (char*)buffer + recv_bytes, buffer_size - recv_bytes, 0);
#endif
if (bytes < 0) {
PRINT_ERROR("recv failed");
return RPC_NET_ERROR;
} else if (bytes == 0) {
// 连接关闭
return RPC_NET_ERROR;
}
recv_bytes += bytes;
}
return RPC_SUCCESS;
}
/*
* 关闭传输连接
*/
void rpc_transport_close(rpc_transport_t* transport) {
if (!transport || transport->socket_fd == INVALID_SOCKET_VALUE) {
return;
}
CLOSE_SOCKET(transport->socket_fd);
transport->socket_fd = INVALID_SOCKET_VALUE;
/*
* rpc_transport.c
* 实现RPC传输层的功能，处理网络通信
*/
#include "rpc_transport.h"
// 调试测试代码
void debug_test_struct_definition() {
rpc_server_t server;
server.address.sin_family = AF_INET; // 测试访问address成员
}
#ifdef _WIN32
/*
* 初始化Windows套接字库
*/
int rpc_winsock_init() {
WSADATA wsaData;
int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (result != 0) {
fprintf(stderr, "WSAStartup failed: %d\n", result);
return RPC_NET_ERROR;
}
return RPC_SUCCESS;
}
/*
* 清理Windows套接字库
*/
void rpc_winsock_cleanup() {
WSACleanup();
}
#endif
/*
* Windows平台的错误打印函数
*/
static void print_windows_error(const char* message) {
int error_code = WSAGetLastError();
char* error_text = NULL;
FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR)&error_text, 0, NULL);
if (error_text) {
fprintf(stderr, "%s: %s\n", message, error_text);
LocalFree(error_text);
} else {
fprintf(stderr, "%s: Error code %d\n", message, error_code);
}
}
#define PRINT_ERROR(msg) print_windows_error(msg)
#else
/*
* Linux/Unix平台的错误打印函数
*/
#define PRINT_ERROR(msg) perror(msg)
#endif
/*
* 初始化RPC服务器
*/
int rpc_server_init(rpc_server_t* server, const char* host, uint16_t port, int backlog) {
// 初始化Windows套接字库（如果需要）
if (rpc_winsock_init() != RPC_SUCCESS) {
return RPC_NET_ERROR;
}
// 创建套接字
server->server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server->server_fd == INVALID_SOCKET_VALUE) {
PRINT_ERROR("socket creation failed");
rpc_winsock_cleanup();
return RPC_NET_ERROR;
}
// 设置套接字选项，允许地址重用
int opt = 1;
#ifdef _WIN32
// Windows不支持SO_REUSEPORT
if (setsockopt(server->server_fd, SOL_SOCKET, SO_REUSEADDR,
&opt, sizeof(opt)) != 0) {
#else
// Linux/Unix支持SO_REUSEPORT
if (setsockopt(server->server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,
&opt, sizeof(opt)) != 0) {
#endif
PRINT_ERROR("setsockopt failed");
CLOSE_SOCKET(server->server_fd);
return RPC_NET_ERROR;
}
// 设置服务器地址结构
memset(&server->address, 0, sizeof(server->address));
server->address.sin_family = AF_INET;
server->address.sin_addr.s_addr = inet_addr(host);
server->address.sin_port = htons(port);
// 绑定地址到套接字
if (bind(server->server_fd, (struct sockaddr*)&server->address, sizeof(server->address)) != 0) {
PRINT_ERROR("bind failed");
CLOSE_SOCKET(server->server_fd);
return RPC_NET_ERROR;
}
// 开始监听连接
if (listen(server->server_fd, backlog) != 0) {
PRINT_ERROR("listen failed");
CLOSE_SOCKET(server->server_fd);
return RPC_NET_ERROR;
}
printf("RPC Server started on %s:%d\n", host, port);
return RPC_SUCCESS;
}
/*
* 服务器接受客户端连接
*/
int rpc_server_accept(rpc_server_t* server, rpc_transport_t* transport) {
if (!server || !transport) {
return RPC_INVALID_ARGS;
}
socklen_t addrlen = sizeof(transport->address);
transport->socket_fd = accept(server->server_fd, (struct sockaddr*)&transport->address, &addrlen);
if (transport->socket_fd == INVALID_SOCKET_VALUE) {
PRINT_ERROR("accept failed");
return RPC_NET_ERROR;
}
printf("Client connected: %s:%d\n",
inet_ntoa(transport->address.sin_addr),
ntohs(transport->address.sin_port));
return RPC_SUCCESS;
}
/*
* 关闭RPC服务器
*/
void rpc_server_close(rpc_server_t* server) {
if (!server || server->server_fd == INVALID_SOCKET_VALUE) {
return;
}
CLOSE_SOCKET(server->server_fd);
server->server_fd = INVALID_SOCKET_VALUE;
printf("RPC Server closed\n");
}
/*
* 初始化RPC客户端传输
*/
int rpc_client_init(rpc_transport_t* transport, const char* server_host, uint16_t server_port) {
if (!transport || !server_host) {
return RPC_INVALID_ARGS;
}
// 创建套接字
transport->socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (transport->socket_fd == INVALID_SOCKET_VALUE) {
PRINT_ERROR("socket creation failed");
return RPC_NET_ERROR;
}
// 设置服务器地址结构
memset(&transport->address, 0, sizeof(transport->address));
transport->address.sin_family = AF_INET;
transport->address.sin_port = htons(server_port);
// 将主机名转换为IP地址
if (inet_pton(AF_INET, server_host, &transport->address.sin_addr) <= 0) {
PRINT_ERROR("invalid address");
CLOSE_SOCKET(transport->socket_fd);
return RPC_NET_ERROR;
}
// 连接到服务器
if (connect(transport->socket_fd, (struct sockaddr*)&transport->address, sizeof(transport->address)) != 0) {
PRINT_ERROR("connection failed");
CLOSE_SOCKET(transport->socket_fd);
return RPC_NET_ERROR;
}
printf("Connected to server %s:%d\n", server_host, server_port);
return RPC_SUCCESS;
}
/*
* 通过传输层发送数据
*/
int rpc_transport_send(rpc_transport_t* transport, const void* data, size_t data_size) {
if (!transport || !data || data_size == 0) {
return RPC_INVALID_ARGS;
}
// 发送所有数据
size_t sent_bytes = 0;
while (sent_bytes < data_size) {
#ifdef _WIN32
int bytes = send(transport->socket_fd, (const char*)data + sent_bytes, (
#ifdef _WIN64
int
#else
int
#endif
)(data_size - sent_bytes), 0);
#else
ssize_t bytes = send(transport->socket_fd, (const char*)data + sent_bytes, data_size - sent_bytes, 0);
#endif
if (bytes <= 0) {
PRINT_ERROR("send failed");
return RPC_NET_ERROR;
}
sent_bytes += bytes;
}
return RPC_SUCCESS;
}
/*
* 通过传输层接收数据
*/
int rpc_transport_recv(rpc_transport_t* transport, void* buffer, size_t buffer_size) {
if (!transport || !buffer || buffer_size == 0) {
return RPC_INVALID_ARGS;
}
// 接收所有数据
size_t recv_bytes = 0;
while (recv_bytes < buffer_size) {
#ifdef _WIN32
int bytes = recv(transport->socket_fd, (char*)buffer + recv_bytes, (
#ifdef _WIN64
int
#else
int
#endif
)(buffer_size - recv_bytes), 0);
#else
ssize_t bytes = recv(transport->socket_fd, (char*)buffer + recv_bytes, buffer_size - recv_bytes, 0);
#endif
if (bytes < 0) {
PRINT_ERROR("recv failed");
return RPC_NET_ERROR;
} else if (bytes == 0) {
// 连接关闭
return RPC_NET_ERROR;
}
recv_bytes += bytes;
}
return RPC_SUCCESS;
}
/*
* 关闭传输连接
*/
void rpc_transport_close(rpc_transport_t* transport) {
if (!transport || transport->socket_fd == INVALID_SOCKET_VALUE) {
return;
}
CLOSE_SOCKET(transport->socket_fd);
transport->socket_fd = INVALID_SOCKET_VALUE;
}

40
scalib/test_cmake_config.cmd
View File

@ -1,40 +0,0 @@
@echo off
REM 测试CMake配置的脚本
REM 设置构建目录
set BUILD_DIR=build_test
REM 清理旧的构建目录
if exist %BUILD_DIR% rmdir /s /q %BUILD_DIR%
REM 创建构建目录
mkdir %BUILD_DIR%
REM 运行CMake配置
pushd %BUILD_DIR%
cmake ..
if %ERRORLEVEL% neq 0 (
echo CMake配置失败！
popd
exit /b 1
)
REM 构建项目
cmake --build . --config Release
if %ERRORLEVEL% neq 0 (
echo 构建失败！
popd
exit /b 1
)
popd
REM 检查bin目录是否存在
if exist bin (
echo bin目录已创建
dir bin
) else (
echo bin目录未创建
)
pause

33
scalib/test_compile.cmd
View File

@ -1,33 +0,0 @@
@echo off
REM 简单的测试编译脚本
REM 设置Visual Studio环境
REM 尝试检测Visual Studio安装路径
set VS170COMNTOOLS=
for /f "delims=" %%i in ('reg query "HKLM\SOFTWARE\Microsoft\VisualStudio\SxS\VS7" /v "17.0" 2^>nul') do (
for /f "tokens=2*" %%j in ("%%i") do set "VS170COMNTOOLS=%%kCommon7\Tools\"
)
REM 如果找不到Visual Studio 2022，尝试其他版本
if not exist "%VS170COMNTOOLS%vsdevcmd.bat" (
echo 无法找到Visual Studio 2022环境
pause
exit /b 1
)
REM 设置环境变量
call "%VS170COMNTOOLS%vsdevcmd.bat" -arch=x64
REM 设置编译选项
set INCLUDE_DIR=include
set SRC_DIR=src
REM 编译服务器
cl.exe /I%INCLUDE_DIR% %SRC_DIR%\rpc_server.c %SRC_DIR%\rpc_common.c %SRC_DIR%\rpc_transport.c %SRC_DIR%\rpc_message.c /link ws2_32.lib /out:rpc_server_test.exe
REM 检查编译结果
if %ERRORLEVEL% EQU 0 (
echo 编译成功！可执行文件: rpc_server_test.exe
) else (
echo 编译失败！
)
Write Preview
Loading…
Cancel
Save