以下是一个基于 Linux C 多线程的
HTTP 服务器示例，支持 GET、
POST 方法，并能够处理表单提交：
```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <ctype.h>
#define PORT 8080
#define MAX_CONNECTIONS 10
#define BUFFER_SIZE 1024
#define MAX_REQUEST_SIZE 8192
#define MAX_QUERY_PARAMS 16
#define MAX_HEADERS 32
#define MAX_
POST_PARAMS 16
typedef struct {
int conn_fd;
char method[8];
char uri[MAX_REQUEST_SIZE];
char query_params[MAX_QUERY_PARAMS][MAX_REQUEST_SIZE];
int num_query_params;
char headers[MAX_HEADERS][MAX_REQUEST_SIZE];
int num_headers;
char
post_params[MAX_
POST_PARAMS][MAX_REQUEST_SIZE];
int num_
post_params;
}
http_request;
void parse_request_line(char *line,
http_request *request) {
char *method, *uri, *query;
method = strtok(line, " ");
uri = strtok(NULL, " ");
query = strchr(uri, '?');
// parse method
if (method) {
strncpy(request->method, method, sizeof(request->method));
} else {
strncpy(request->method, "GET", sizeof(request->method));
}
// parse URI and query parameters
if (uri) {
if (query) {
strncpy(request->uri, uri, query-uri);
query++;
while (*query) {
char *next = strchr(query, '&');
if (next) {
strncpy(request->query_params[request->num_query_params], query, next-query);
request->query_params[request->num_query_params][next-query-query] = '\0';
request->num_query_params++;
query = next + 1;
} else {
strncpy(request->query_params[request->num_query_params], query, MAX_REQUEST_SIZE);
request->num_query_params++;
break;
}
}
} else {
strncpy(request->uri, uri, sizeof(request->uri));
}
}
}
void parse_header_line(char *line,
http_request *request) {
char *name, *value;
name = strtok(line, ": ");
value = strtok(NULL, "\r\n");
if (name && value) {
strncpy(request->headers[request->num_headers], line, sizeof(request->headers[0]));
request->num_headers++;
}
}
void parse_
post_params(char *data,
http_request *request) {
while (*data) {
char *next = strchr(data, '&');
if (next) {
strncpy(request->
post_params[request->num_
post_params], data, next-data);
request->
post_params[request->num_
post_params][next-data-data] = '\0';
request->num_
post_params++;
data = next + 1;
} else {
strncpy(request->
post_params[request->num_
post_params], data, MAX_REQUEST_SIZE);
request->num_
post_params++;
break;
}
}
}
void *handle_connection(void *arg) {
http_request *request = (
http_request*)arg;
char buffer[BUFFER_SIZE];
ssize_t n;
// read request message
memset(buffer, 0, sizeof(buffer));
n = read(request->conn_fd, buffer, sizeof(buffer)-1);
if (n <= 0) {
close(request->conn_fd);
free(request);
pthread_exit(NULL);
}
// parse request message
char *line = strtok(buffer, "\r\n");
if (line) {
parse_request_line(line, request);
}
while ((line = strtok(NULL, "\r\n"))) {
parse_header_line(line, request);
}
// handle request method
if (strcasecmp(request->method, "GET") == 0) {
// handle GET request
char *response = "
HTTP/1.1
200 OK\r\nContent-Type: text/html\r\n\r\nHello, world!";
write(request->conn_fd, response, strlen(response));
} else if (strcasecmp(request->method, "
POST") == 0) {
// handle
POST request
char *content_length_header = NULL;
for (int i = 0; i < request->num_headers; i++) {
if (strncasecmp(request->headers[i], "Content-Length:", 15) == 0) {
content_length_header = request->headers[i];
break;
}
}
if (content_length_header) {
int content_length = atoi(content_length_header+15);
char *data = buffer + strlen(buffer) + 2;
n = read(request->conn_fd, data, content_length);
if (n > 0) {
data[n] = '\0';
parse_
post_params(data, request);
}
}
char response[BUFFER_SIZE];
snprintf(response, sizeof(response), "
HTTP/1.1
200 OK\r\nContent-Type: text/html\r\n\r\n"
"<html><body><h1>
POST parameters:</h1><ul>");
for (int i = 0; i < request->num_
post_params; i++) {
char *param = request->
post_params[i];
for (int j = 0; j < strlen(param); j++) {
if (param[j] == '+') {
param[j] = ' ';
}
}
char *name = strtok(param, "=");
char *value = strtok(NULL, "=");
snprintf(response+strlen(response), sizeof(response)-strlen(response),
"<li>%s: %s</li>", name, value);
}
strncat(response, "</ul></body></html>", sizeof(response)-strlen(response)-1);
write(request->conn_fd, response, strlen(response));
}
close(request->conn_fd);
free(request);
pthread_exit(NULL);
}
int main() {
int sock_fd, conn_fd;
struct sockaddr_in serv_addr, client_addr;
socklen_t client_len;
pthread_t threads[MAX_CONNECTIONS];
// create socket
sock_fd = socket(AF_INET, SOCK_STREAM, 0);
if (sock_fd < 0) {
perror("Failed to create socket");
exit(EXIT_FAILURE);
}
// set server address
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(PORT);
// bind socket to server address
if (bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
perror("Failed to bind socket");
exit(EXIT_FAILURE);
}
// listen for connections
if (listen(sock_fd, MAX_CONNECTIONS) < 0) {
perror("Failed to listen for connections");
exit(EXIT_FAILURE);
}
printf("
HTTP server is listening on port %d\n", PORT);
// handle connections in separate threads
while (1) {
client_len = sizeof(client_addr);
conn_fd = accept(sock_fd, (struct sockaddr*)&client_addr, &client_len);
if (conn_fd < 0) {
perror("Failed to accept connection");
continue;
}
http_request *request = (
http_request*)malloc(sizeof(
http_request));
memset(request, 0, sizeof(
http_request));
request->conn_fd = conn_fd;
pthread_t thread;
if (pthread_create(&thread, NULL, handle_connection, request) < 0) {
perror("Failed to create thread");
close(conn_fd);
free(request);
continue;
}
pthread_detach(thread);
}
return 0;
}
```
上述代码创建了一个监听在 8080 端口的
HTTP 服务器，可以处理多个连接。在每个连接到来
时，都会创建一个新的线程来处理
请求。在处理
请求的线程中，首先读取
请求消息，然后解析
请求行、
请求头和
请求体中的参数，根据
请求方法的不同返回不同的响应消息。
需要注意的是，在处理
POST 请求时，需要首先读取
请求头中的 Content-Length 字段，然后读取相应长度的
请求体数据，最后解析
POST 参数。在本例中，使用了 URL
编码格式，因此需要将
POST 参数中的 + 号替换为
空格。
276
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
