一个简单的HTTP服务器(多线程)
=============================================================================================
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BUFFER_INIT_SIZE 512
enum {
mickey_reading_header_stage,
mickey_writing_header_stage,
mickey_writing_body_stage,
mickey_closing_stage
};
enum {
mickey_http_ok,
mickey_http_notfound,
mickey_http_error
};
enum {
mickey_method_get,
mickey_method_head,
mickey_method_unknow
};
typedef struct {
char
*buff;
int
size;
int
free;
} mickey_buffer_t;
typedef struct {
int
sock;
mickey_buffer_t *request;
mickey_buffer_t *response;
int
keepalive;
int
method;
mickey_buffer_t *uri;
int
status;
int
stage;
FILE
*handle;
} mickey_connection_t;
static int srv_sock;
mickey_buffer_t *mickey_buffer_new() {
mickey_buffer_t *object;
object =
malloc(sizeof(*object));
if (object)
{
object->buff = malloc(BUFFER_INIT_SIZE + 1);
if (!object->buff) {
free(object);
return NULL;
}
object->size = BUFFER_INIT_SIZE;
object->free = BUFFER_INIT_SIZE;
}
return
object;
}
int mickey_buffer_append_length(mickey_buffer_t *buf, void
*data, int length) {
int lack,
need = 0;
char
*temp;
if (length
> buf->free) {
lack = length - buf->free;
while (need < lack)
need += BUFFER_INIT_SIZE;
temp = realloc(buf->buff, buf->size +
need + 1);
if (!temp)
return -1;
buf->buff = temp;
buf->size += need;
buf->free += need;
}
memcpy(buf->buff + (buf->size -
buf->free), data, length);
buf->free -= length;
buf->buff[buf->size -
buf->free] = '\0';
return
0;
}
int mickey_buffer_append(mickey_buffer_t *buf, void *data)
{
return
mickey_buffer_append_length(buf, data, strlen((char *)data));
}
int mickey_buffer_find_string(mickey_buffer_t *buf, char *str)
{
int idx =
buf->size - buf->free;
int slen =
strlen(str);
int i;
for (i = 0;
i < idx; i++) {
if (idx - i >= slen) {
if (!memcmp(buf->buff + i, str, slen)) return
1;
} else {
break;
}
}
return
0;
}
int mickey_buffer_length(mickey_buffer_t *buf) {
return
buf->size - buf->free;
}
void mickey_buffer_print(mickey_buffer_t *buf) {
fprintf(stderr, "%s", buf->buff);
}
void mickey_buffer_clean(mickey_buffer_t *buf) {
buf->free = buf->size;
}
void mickey_buffer_free(mickey_buffer_t *buf) {
if
(!buf)
return;
if
(buf->buff)
free(buf->buff);
free(buf);
}
int mickey_header_finish(mickey_connection_t *conn) {
int end =
conn->request->size -
conn->request->free;
if
(conn->request->buff[end - 1] == '\n'
&&
conn->request->buff[end - 2] == '\r'
&&
conn->request->buff[end - 3] == '\n'
&&
conn->request->buff[end - 4] ==
'\r')
return 1;
return
0;
}
void mickey_parse_header(mickey_connection_t *conn) {
char
*eol;
char
method[16], uri[256], protocol[32];
eol =
strchr(conn->request->buff,
'\n');
if (eol ==
NULL) {
conn->stage = mickey_closing_stage;
return;
}
if (*(eol-1)
== '\r')
*(eol-1) = '\0';
*eol =
'\0';
sscanf(conn->request->buff, "s %6s
2s", method, uri, protocol);
if
(!strcmp(method, "GET")) {
conn->method = mickey_method_get;
} else if
(!strcmp(method, "HEAD")) {
conn->method = mickey_method_head;
} else
{
conn->method = mickey_method_unknow;
}
mickey_buffer_append(conn->uri, ".");
mickey_buffer_append(conn->uri, uri);
if
(mickey_buffer_find_string(conn->uri, "..")) {
fprintf(stderr, "[x] mickey found connection header exists
(..)\n");
conn->stage = mickey_closing_stage;
}
}
void connection_reading_header(mickey_connection_t *conn)
{
char
buff[1024];
int
nrecv;
nrecv =
read(conn->sock, buff, 1024);
if (nrecv
> 0) {
mickey_buffer_append_length(conn->request, buff,
nrecv);
if (mickey_header_finish(conn)) {
mickey_parse_header(conn);
conn->stage = mickey_writing_header_stage;
}
} else
{
fprintf(stderr, "[x] mickey cannot read data from
connection.\n");
conn->stage = mickey_closing_stage;
}
}
void connection_make_header(mickey_connection_t *conn) {
struct stat
stat_buf;
if
(stat(conn->uri->buff,
&stat_buf) == -1) {
conn->status = mickey_http_notfound;
mickey_buffer_append(conn->response, "HTTP/1.0 404
Not Found\r\n");
} else
{
if (S_ISDIR(stat_buf.st_mode)) {
mickey_buffer_append(conn->uri, "index.html");
if (stat(conn->uri->buff,
&stat_buf) == -1) {
conn->status = mickey_http_notfound;
mickey_buffer_append(conn->response, "HTTP/1.0 404
Not Found\r\n");
} else {
char content_length[256];
conn->handle =
fopen(conn->uri->buff, "r");
if (!conn->handle) {
mickey_buffer_append(conn->response, "HTTP/1.0 500
Internal Server Error\r\n");
} else {
mickey_buffer_append(conn->response, "HTTP/1.0 200
OK\r\n");
sprintf(content_length, "Content-Length: %d\r\n",
stat_buf.st_size);
mickey_buffer_append(conn->response,
content_length);
}
}
} else if (S_ISREG(stat_buf.st_mode)) {
char content_length[256];
conn->handle =
fopen(conn->uri->buff, "r");
if (!conn->handle) {
mickey_buffer_append(conn->response, "HTTP/1.0 500
Internal Server Error\r\n");
} else {
mickey_buffer_append(conn->response, "HTTP/1.0 200
OK\r\n");
sprintf(content_length, "Content-Length: %d\r\n",
stat_buf.st_size);
mickey_buffer_append(conn->response,
content_length);
}
} else {
mickey_buffer_append(conn->response, "HTTP/1.0 500
Internal Server Error\r\n");
}
}
mickey_buffer_append(conn->response, "\r\n");
//mickey_buffer_print(conn->response);
}
void connection_send_header(mickey_connection_t *conn) {
int bytes =
mickey_buffer_length(conn->response);
int nsend, i
= 0;
while (i
< bytes) {
nsend = write(conn->sock,
conn->response->buff + i, bytes -
i);
if (nsend > 0) {
i += nsend;
} else {
sleep(1);
continue;
}
}
conn->stage = mickey_writing_body_stage;
}
void connection_send_body(mickey_connection_t *conn) {
char
buff[1024];
int
bytes;
if
(!conn->handle) {
conn->stage = mickey_closing_stage;
return;
}
while
(!feof(conn->handle)) {
int ws = 0;
int hs = 0;
fread(buff, 1024, 1, conn->handle);
bytes = strlen(buff);
while (ws < bytes) {
hs = write(conn->sock, buff + ws, bytes - ws);
if (hs > 0) {
ws += hs;
} else {
sleep(1);
continue;
}
}
}
fclose(conn->handle);
conn->stage = mickey_closing_stage;
}
mickey_connection_t *connection_new(int sock) {
mickey_connection_t *conn;
conn =
malloc(sizeof(*conn));
if (conn)
{
conn->sock
= sock;
conn->keepalive = 0;
conn->stage
= mickey_reading_header_stage;
conn->status
= mickey_http_ok;
conn->request =
mickey_buffer_new();
conn->response =
mickey_buffer_new();
conn->uri
= mickey_buffer_new();
if (!conn->request || !conn->response
|| !conn->uri) {
mickey_buffer_free(conn->request);
mickey_buffer_free(conn->response);
mickey_buffer_free(conn->uri);
free(conn);
return NULL;
}
return conn;
}
return
NULL;
}
void connection_exit(mickey_connection_t *conn) {
if
(conn->request)
mickey_buffer_free(conn->request);
if
(conn->response)
mickey_buffer_free(conn->response);
if
(conn->uri)
mickey_buffer_free(conn->uri);
free(conn);
}
void *connection_thread_entrance(void *arg) {
mickey_connection_t *conn = (mickey_connection_t *)arg;
pthread_detach(pthread_self());
fprintf(stderr, "[+] === mickey thread working ===\n");
while (1)
{
switch (conn->stage) {
case mickey_reading_header_stage:
connection_reading_header(conn);
break;
case mickey_writing_header_stage:
connection_make_header(conn);
connection_send_header(conn);
break;
case mickey_writing_body_stage:
connection_send_body(conn);
break;
case mickey_closing_stage:
close(conn->sock);
connection_exit(conn);
goto THREAD_CLOSING;
break;
}
}
THREAD_CLOSING:
fprintf(stderr, "[-] === mickey thread closing ===\n");
pthread_exit(NULL);
}
int initialize_server() {
struct
sockaddr_in addr;
struct
linger ling = {0, 0};
int flags =
1;
srv_sock =
socket(AF_INET, SOCK_STREAM, 0);
if (srv_sock
== -1)
return -1;
setsockopt(srv_sock, SOL_SOCKET, SO_REUSEADDR,
&flags, sizeof(flags));
setsockopt(srv_sock, SOL_SOCKET, SO_KEEPALIVE,
&flags, sizeof(flags));
setsockopt(srv_sock, SOL_SOCKET, SO_LINGER, &ling,
sizeof(ling));
#if !defined(TCP_NOPUSH)
setsockopt(srv_sock, IPPROTO_TCP, TCP_NODELAY,
&flags, sizeof(flags));
#endif
addr.sin_family = AF_INET;
addr.sin_port = htons(8080);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if
(bind(srv_sock, (struct sockaddr *) &addr,
sizeof(addr)) == -1)
return -1;
if
(listen(srv_sock, 1024) == -1)
return -1;
return
srv_sock;
}
void socket_accept_connection() {
int
new_sock;
socklen_t
len;
struct
sockaddr addr;
mickey_connection_t *new_conn;
pthread_t
tid;
while (1)
{
new_sock = accept(srv_sock, &addr,
&len);
if (new_sock == -1) {
if (errno != EAGAIN && errno !=
EWOULDBLOCK) {
continue;
}
goto ERROR_FLAG;
}
new_conn = connection_new(new_sock);
if (!new_conn) {
fprintf(stderr, "[x] mickey not enough momery.\n");
close(new_sock);
goto ERROR_FLAG;
}
pthread_create(&tid, NULL,
connection_thread_entrance, new_conn);
}
ERROR_FLAG:
fprintf(stderr, "[x] mickey cannot accept client
connection.\n");
return;
}
int main(int argc, char **argv) {
chdir("./");
if
(initialize_server() == -1) {
fprintf(stderr, "[x] mickey initialize failed.\n");
exit(1);
}
socket_accept_connection();
exit(0);
}
0
喜欢
0
赠金笔
一个简单的HTTP服务器(多线程)的更多相关文章
- 自己动手模拟开发一个简单的Web服务器
开篇:每当我们将开发好的ASP.NET网站部署到IIS服务器中,在浏览器正常浏览页面时,可曾想过Web服务器是怎么工作的,其原理是什么?“纸上得来终觉浅,绝知此事要躬行”,于是我们自己模拟一个简单的W ...
- 响应式编程笔记三：一个简单的HTTP服务器
# 响应式编程笔记三:一个简单的HTTP服务器 本文我们将继续前面的学习,但将更多的注意力放在用例和编写实际能用的代码上面,而非基本的APIs学习. 我们会看到Reactive是一个有用的抽象 - 对 ...
- 使用纯php构建一个简单的PHP服务器
使用原生PHP构建一个简单的PHPWeb服务器 1.目录机构 webserver --src -- Response.php -- Server.php -- Request.php -- vendo ...
- 一个简单的web服务器
写在前面 新的一年了,新的开始,打算重新看一遍asp.net本质论这本书,再重新认识一下,查漏补缺,认认真真的过一遍. 一个简单的web服务器 首先需要引入命名空间: System.Net,关于网络编 ...
- [置顶] 在Ubuntu下实现一个简单的Web服务器
要求: 实现一个简单的Web服务器,当服务器启动时要读取配置文件的路径.如果浏览器请求的文件是可执行的则称为CGI程序,服务器并不是将这个文件发给浏览器,而是在服务器端执行这个程序,将它的标准输出发给 ...
- Tomcat剖析（二）：一个简单的Servlet服务器
Tomcat剖析(二):一个简单的Servlet服务器 1. Tomcat剖析(一):一个简单的Web服务器 2. Tomcat剖析(二):一个简单的Servlet服务器 3. Tomcat剖析(三) ...
- Tomcat剖析（一）：一个简单的Web服务器
Tomcat剖析(一):一个简单的Web服务器 1. Tomcat剖析(一):一个简单的Web服务器 2. Tomcat剖析(二):一个简单的Servlet服务器 3. Tomcat剖析(三):连接器 ...
- 自己模拟的一个简单的web服务器
首先我为大家推荐一本书:How Tomcat Works.这本书讲的很详细的,虽然实际开发中我们并不会自己去写一个tomcat,但是对于了解Tomcat是如何工作的还是很有必要的. Servlet容器 ...
- java实现一个简单的Web服务器
注:本段内容来源于<JAVA 实现 简单的 HTTP服务器> 1. HTTP所有状态码 状态码 状态码英文名称 中文描述 100 Continue 继续.客户端应继续其请求 101 Swi ...
随机推荐
- poj 1018 Communication System 枚举 VS 贪心
Communication System Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 21631 Accepted: ...
- 终于懂了：TWinControl.DefaultHandler里的CallWindowProc(FDefWndProc)还挺有深意的，TButton对WM_PAINT消息的处理就是靠它来处理的（以前不明白为什么总是要调用inherited，其实就是没有明白TWinControl.DefaultHandler的真正用处）
我忽然发现:TButton既没有处理WM_PAINT,又没有Paint()或者PaintWindow(),那么它是什么时候被绘制的? Form1上放2个TButton,然后设置代码: procedur ...
- VS关闭Browser Link
原文:VS关闭Browser Link 这是VS2013的一个新功能,叫Browser Link,基于SignalR. 它可以实现VS IDE和你的程序的双向通讯,在IDE编辑代码即刻将修改发送到浏览 ...
- Qt调用Delphi编写的COM组件
这个问题捣鼓了两天,现在终于解决了,做个笔记分享给大家,以免走弯路 起初,我的想法是在DLL中写一个interface并从函数中导出这个interface,像这样的代码 ICom1 = interfa ...
- 14.2.5.2 Clustered and Secondary Indexes
14.2.5.2 Clustered and Secondary Indexes : 每个InnoDB 表 有一个特别的索引称为clustered index 行数据存储的地方. 典型的,cluste ...
- Velocity教程-脚本语法详解(转)
Velocity是一个基于java的模板引擎(template engine).它允许任何人仅仅简单的使用模板语言(template language)来引用由java代码定义的对象. 当Veloci ...
- python中的中文编码
我现在编写python代码,有一些内容需要用中文编写,例如注释,一些其它的东西 默认python是不支持中文的,包括两个方面不支持,一是文件编码默认是ansi的,二是虚拟机运行解析脚本时也是非utf的 ...
- Tengine中的proxy_upstream_tries
upsream xxx { server 192.168.100.100; server 192.168.100.101; server 192.168.100.102; } server { loc ...
- Swift - 类型属性（类静态属性）和类方法（类静态方法）
1,结构体struct和枚举enum的静态属性,静态方法使用static关键字 1 2 3 4 5 6 7 8 9 10 struct Account { var amount : Doub ...
- Android：通知栏的使用
非常久没有使用Android的通知功能了,今天把两年前的代码搬出来一看.发现非常多方法都废弃了,代码中各种删除线看的十分不爽.于是乎,打开Google,查看官方文档.学习最新的发送通知栏消息的方法. ...