一个简单的HTTP服务器(多线程)

为了更好的了解HTTP协议, 特意谢了一个简单HTTP服务器, 代码只有400行. 因为很简单, 所以效率也不怎么高, 而且支持的特性也不多, 不过也可以运行, 性能跟Apache差不多.

=============================================================================================

#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);
}

喜欢

赠金笔

一个简单的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 ...

随机推荐

Entity - 使用EF框架进行增删改查 - 模型先行
模型先行:先创建数据库实体模型,然后再进行数据库的增删改查. 基本步骤是不变的,可参照 <Entity - 使用EF框架进行增删改查 - 数据库先行> 其中的不同是,在创建数据库实体模型的 ...
编译x64的应用，要在pro文件里配置
在pro中使用:contains(QMAKE_TARGET.arch, x86_64) { TYPE = 64 QTDIR = C:/Qt/5.5/msvc2013_64} else { ...
c# in depth之泛型的实现
1.默认值表达式如果已经明确了要处理的类型,也就知道了它的“默认”值.不知道要引用的类型,就不能直接指定默认值.不能使用null,因为它可能不是一个引用类型,不能使用0,因为它可能不是数值类型.虽然 ...
基于visual Studio2013解决面试题之0403串联字符串
题目
基于visual Studio2013解决面试题之0207单词翻转
题目
ios23-文件上传
1.上传图片 3. // // ios23_uploadViewController.h // ios23-upload // // Created by on 13-6-17. // Co ...
轻量级工具网站SimpleTools
[解释]本来这篇文章是在前天发出来的,可是当时是刚申请的域名,现在都要域名实名认证,导致我发的项目网址打不开,惹来了很多博友的吐槽,在此说声抱歉,今天一大早就把实名认证提交了,现在网站已经可以正常访问 ...
Android中ProgressDialog的应用
下面通过实现点击按钮来显示加载框,2秒后自动消失. 1.首先在layout的xml中添加一个按钮: <Button android:id="@+id/button1" and ...
NIO框架之MINA源码解析（转）
http://blog.csdn.net/column/details/nio-mina-source.html http://blog.csdn.net/chaofanwei/article/det ...
android电池充电以及电量检测驱动分析
前段时间比较烦躁,各种不想学习不想工作,于是休息了几天.这几天又下来任务了--调试充电电路和电池电量检测电路,于是又开始工作,顺便把调试过程记录下来. 平台: cpu 飞思卡尔imx6q ...

一个简单的HTTP服务器(多线程)

一个简单的HTTP服务器(多线程)的更多相关文章

随机推荐

热门专题