linux下http服务器开发
２）工作原理
１）客户端
一台客户机与服务器建立连接后，会发送一个请求给服务器，请求方式的格式为：统一资源定位符(URL)、协议版本号，后边是MIME信息，包括请求修饰符、客户机信息和可能的内容。
２）服务器端
１）服务器接收到客户机的请求后，首先解析请求信息，根据不同的请求模式给予相应的响应信息。HTTP中规定了6种请求格式，但最常用到的是GET和POST请求
２）任何服务器除了包括HTML文件以外，还有一个HTTP驻留程序，用于响应用户的请求。
３）服务器端驻留程序接收到请求后，在进行必要的操作后回送所要求的文件，在这一过程中，在网络上发送和接收的数据已经被分成一个或多个数据包（Packet），每个数据包包括：要传送的数据；控制信息，即告诉网络怎样处理数据包。
３）在HTTP请求格式中，最重要的信息有两个，一个是请求的内容，另一个是请求的方法。
４）数据对是由字段组成，其格式为：valuename=value；数据对与数据对之间由＆连接，这是HTTP中定义的请求规则。
５）在通常的WEB应用中，大数据量的提交一般选用POST方法，小数据量的提交，如查询操作，一般采用GET方法。
６）请求实体由实体名和实体值组成，它的格式为：Entity：value
２．HTTP服务器设计
１）实现功能１）在HTTP服务器中，经常要处理的请求是GET，MesteryServer中将要实现针对GET请求的处理
服务器并不支持CGI功能，所以针对GET中的CGI部分的请求处理，在本版本中不予支持。
２）利用Gtk编写可视化的界面，三个按钮用于启动、关闭和暂停服务，一个标签用于显示服务状态。
３）文件传输功能是本 服务器最基本的功能，负责可靠传送用户请求的资源文件。
４）具有日志功能，会将客户的请求信息存储到本地的日志文件里，以XML格式进行存储。
２）业务功能
１）针对GET请求功能，在这里只支持资源文件的下载，并且可以断点下载。
２）如果是请求资源，则予以响应；如果涉及CGI的请求，则不予以响应。
３）系统只支持GET请求，对于POST、HEAD、TRACE等请求，都予以忽略。
４）对于HTTP服务器，它的运行模式是基于请求、响应机制，而下面的文件传输功能，其实是请求的具体执行过程，当服务器端成功解析请求命令后，会针对请求的类型，生成相应的响应码，并传送相应的资源文件。
５）当请求工作执行完毕时，会形成一条日志记录，并插入到日志文件中。
６）考虑到服务的关联性，服务器将为每一个请求开启一个单独的线程进行服务，该线程实现客户端请求接受、请求分析、响应码生成与传输、响应文件查找与传输、客户套接字关闭、日志记录写入等功能
３）可视化界面
其设计与业务的逻辑采用松耦合，双方只是通过消息的方式，传递控制命令与状态信息。
４）主服务功能
提供端口绑定（HTTP默认端口是80）、服务侦听、客户端套接字维护、业务线程创建等。
５）界面模块
１）由两个子模块组成：界面显示子模块－＞绘出程序的运程界面；按钮事件处理子模块
２）界面模块与主服务模块之间的消息传递采用全局变量共享的方式。
６）主服务模块
１）以线程身份存在。
２）不断轮询全局变量gServerStatus，并通过这个状态来动态调整真实服务状态。
７）业务处理模块
１）程序核心部分。
２）由请求分析子模块、响应处理子模块、文件传输子模块、日志添加子模块等几个子模块组成。
３．测试效果
１）本地测试
３）下载数据预览
4．疑问解答
前几天群里有人在讨论TCP和UDP，然后又引出了HTTP服务器，于是我就给他们推荐了这篇文章，但是大家看过之后还是有很多疑问，这里我根据自己的理解简单描述下。
❶主服务模块的设计原理
可以看见，程序界面是用gtk写的，当点击“开始”按钮的时候，会动态创建该线程，其线程回调函数原型为
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
void
* server_process(
void
*p)
{
int
serverSocket;
struct
sockaddr_in server_addr;
struct
sockaddr_in clientAddr;
int
addr_len =
sizeof
(clientAddr);
if
((serverSocket = socket(AF_INET,SOCK_STREAM,0)) < 0)
{
perror
(
"error: create server socket!!!"
);
exit
(1);
}
bzero(&server_addr,
sizeof
(server_addr));
server_addr.sin_family =AF_INET;
server_addr.sin_port = htons(SERVER_PORT);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if
(bind(serverSocket,(
struct
sockaddr *)&server_addr,
sizeof
(server_addr)) < 0)
{
perror
(
"error: bind address !!!!"
);
exit
(1);
}
if
(listen(serverSocket,5)<0)
{
perror
(
"error: listen !!!!"
);
exit
(1);
}
gIsRun = 1;
printf
(
"MesteryServer is running.....\n"
);
while
(gIsRun)
{
int
clientsocket;
clientsocket = accept(serverSocket,(
struct
sockaddr *)&clientAddr,(socklen_t*)&addr_len);
if
(clientsocket < 0)
{
perror
(
"error: accept client socket !!!"
);
continue
;
}
if
(gServerStatus == 0)
{
close(clientsocket);
}
else
if
(gServerStatus == 1)
{
pthread_t threadid;
int
temp;
temp = pthread_create(&threadid, NULL, processthread, (
void
*)&clientsocket);
/*if(threadid !=0)
{
pthread_join(threadid,NULL);
}*/
}
}
close(serverSocket);
}
|
从程序中可以看见，当绑定本地服务地址和端口后，便调用listen()函数进行侦听，while(gIsRun)表示主服务模块已经启动；然后采用阻塞式等待用户连接的到来，在连接到来的时候，还需要判断gServerStatus的值，即系统是否允许提供服务，如果允许，则创建服务线程。
pthread_create(&threadid, NULL, processthread, (void *)&clientsocket);该线程的回调函数为processthread()，具体如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
void
* processthread(
void
*para)
{
int
clientsocket;
char
buffer[1024];
int
iDataNum =0;
int
recvnum=0;
clientsocket = *((
int
*)para);
printf
(
"<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<BEGIN [%d]>>>>>>>>>>>>>>>>>>>>>>>\n"
,clientsocket);
struct
HttpRequest httprequest;
httprequest.content = NULL;
httprequest.path = NULL;
httprequest.path = (
char
*)
malloc
(1024);
httprequest.rangeflag = 0;
httprequest.rangestart = 0;
while
(1)
{
iDataNum = recv(clientsocket,buffer+recvnum,
sizeof
(buffer)-recvnum-1,0);
if
(iDataNum <= 0)
{
close(clientsocket);
pthread_exit(NULL);
return
0;
}
recvnum += iDataNum;
buffer[recvnum]=
'\0'
;
if
(
strstr
(buffer,
"\r\n\r\n"
)!=NULL ||
strstr
(buffer,
"\n\n"
)!=NULL)
break
;
}
printf
(
"request: %s\n"
,buffer);
//解析请求信息并处理请求信息
switch
(getrequest(buffer,&httprequest))
{
case
GET_COMMON:
processgetcommon(clientsocket,&httprequest);
break
;
case
GET_CGI:
processgetcgi(clientsocket,&httprequest);
break
;
case
POST:
processpost(clientsocket,&httprequest);
break
;
case
HEAD:
processhead(clientsocket,&httprequest);
break
;
default
:
break
;
}
insertlognode(pfilelog,&httprequest);
if
(httprequest.path != NULL)
free
(httprequest.path);
if
(httprequest.content != NULL)
free
(httprequest.content);
close(clientsocket);
printf
(
"<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<END [%d]>>>>>>>>>>>>>>>>>>>>>>>\n"
,clientsocket);
pthread_exit(NULL);
}
|
可以看见，在这个线程里面，便开始对请求进行业务分析了。
❷协议解析
这个比较简单，因为HTTP协议的格式是固定的，所以只用对其按照HTTP的格式进行逐步解析就可以了。
❸文件传输
文件传输是归在GET_COMMON类的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
//解析请求信息并处理请求信息
switch
(getrequest(buffer,&httprequest))
{
case
GET_COMMON:
processgetcommon(clientsocket,&httprequest);
break
;
case
GET_CGI:
processgetcgi(clientsocket,&httprequest);
break
;
case
POST:
processpost(clientsocket,&httprequest);
break
;
case
HEAD:
processhead(clientsocket,&httprequest);
break
;
default
:
break
;
}
|
processgetcommon()函数实现如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
void
processgetcommon(
int
s,
struct
HttpRequest *prequest)
{
//先判断文件是否存在
FILE
*fp = isexistfile(prequest->path);
printf
(
"%s\n"
,prequest->path);
struct
stat finfo;
if
(fp == NULL)
{
responsecode(s,404,prequest);
}
else
{
if
(prequest->rangeflag == 0)
{
stat(prequest->path,&finfo);
prequest->rangetotal = finfo.st_size;
}
responsecode(s,200,prequest);
transferfile(s,fp,prequest->rangeflag,prequest->rangestart,prequest->rangetotal);
fclose
(fp);
}
}
|
它先会判断有没有这个文件，如果没有，就生成404响应码，如果有，就返回200响应码，然后首先对prequest->rangeflag进行一个判断，看是否是断点续传，然后便开始传输文件，传输文件函数transferfile()如下
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
int
transferfile(
int
s,
FILE
*fp,
int
type,
int
rangstart,
int
totallength)
{
if
(type == 1)
{
//为１，则表示当前从指定的位置传送文件
fseek
(fp,rangstart,0);
}
int
sendnum = 0;
int
segment = 1024;
while
(!
feof
(fp)&&sendnum < totallength)
{
char
buf[segment];
memset
(buf,0,1024);
int
i = 0;
while
(!
feof
(fp) && i < segment && sendnum+i < totallength)
{
buf[i++] =
fgetc
(fp);
}
if
(sendsegment(s,buf,i) == 0)
return
0;
sendnum += i;
}
return
1;
}
|
可以看见，具体的传输文件，是调用sendsegment()函数来实现的。
|
1
2
3
4
5
6
7
8
9
10
|
int
sendsegment(
int
s,
char
*buffer,
int
length)
{
if
(length <= 0)
return
0;
printf
(
"%s\n"
,buffer);
int
result = send(s,buffer,length,0);
if
(result < 0)
return
0;
return
1;
}
|
而在sendsegment()函数里面，就是用的socket里面的send()函数来实现的。
❹其它功能
对于其它的功能，比如日志操作的，就是属于文件类的了；响应码则是属于对返回信息的一个格式处理，只要按照HTTP协议来就可以了；界面则是用gtk绘制就行了，这个空间比较大，只有绑定相应按钮和处理函数就行了。
5．源代码
请到我原博客附件下载：http://infohacker.blog.51cto.com/6751239/1155176
【驱动】linux设备驱动·入门
linux设备驱动
驱动程序英文全称Device Driver，也称作设备驱动程序。驱动程序是用于计算机和外部设备通信的特殊程序，相当于软件和硬件的接口，通常只有操作系统能使用驱动程序。
在现代计算机体系结构中，操作系统并不直接于硬件打交道，而是通过驱动程序于硬件通信。
设备驱动介绍
驱动程序是附加到操作系统的一段程序，通常用于硬件通信。
每种硬件都有自己的驱动程序，其中包含了硬件设备的信息。操作系统通过驱动程序提供的硬件信息与硬件设备通信。由于驱动设备的重要性，在安装操作系统后需要安装驱动程序，外部设备才能正常工作。
Linux内核自带了相当多的设备驱动程序，几乎可以驱动目前主流的各种硬件设备。
在同一台计算机上，尽管设备是相同的，但是由于操作系统不同，驱动程序是有很大差别的。但是，无论什么系统驱动程序的功能都是相似的，可以归纳为下面三点：
-
初始化硬件设备。
这是驱动程序最基本的功能，初始化通过总线识别设备，访问设备寄存器，按照需求配置设备地端口，设置中断等。
-
向操作系统提供统一的软件接口。
设备驱动程序向操作系统提供了一类设备通用的软件接口，如硬盘设备向操作系统提供了读写磁盘块、寻址等接口，无论是哪种品牌的硬盘驱动向操作系统提供的接口都是一致的。
-
提供辅助功能。
现代计算机的处理能力越来越强，操作系统有一类虚拟设备驱动，可以模拟真实设备的操作，如虚拟打印机驱动向操作系统提供了打印机的接口，在系统没有打印机制情况下仍然可以执行打印操作。
Linux内核模块
Linux内核模块是一种可以被内核动态加载和卸载的可执行程序。
通过内核模块可以扩展内核的功能，通常内核模块被用于设备驱动、文件系统等。如果没有内核模块，需要向内核添加功能就需要修改代码、重新编译内核、安装新内核等步骤，不仅繁琐而且容易保出错，不易于调试。
内核模块简介
Linux内核是一个整体结构，可以把内核想象成一个巨大的程序，各种功能结合在一起。当修改和添加新功能的时候，需要重新生成内核，效率较低。
为了弥补整体式内核的缺点，Linux内核的开发者设计了内核模块机制。
从代码的角度看，内核模块是一组可以完成某种功能的函数集合。
从执行的角度看，内核模块可以看做是一个已经编译但是没有连接的程序。
内核模块是一个应用程序，但是与普通应用程序有所不同，区别在于：
-
运行环境不同。
内核模块运行在内核空间，可以访问系统的几乎所有的软硬件资源；普通应用程序运行在用户空间，可以访问的资源受到限制。这也是内核模块与普通应用程序最主要的区别。由于内核模块可以获得与操作系统内核相同的权限，因此在编程的时候应该格外注意，可能在用户空间看到的一点小错误在内核空间就会导致系统崩溃。
-
功能定位不同。
普通应用程序为了完成某个特定的目标，功能定位明确；内核模块是为其他的内核模块以及应用程序服务的，通常提供的是通用的功能。
-
函数调用方式不同。
内核模块只能调用内核提供的函数，访问其他的函数会导致运行异常；普通应用程序可能调用自身以外的函数，只要能正确连接就有运行。
内核模块的结构
内核编程与用户空间编程最大的区别就是程序的并发性。
在用户空间，除多线程应用程序外，大部分应用程序的运行是顺序执行的，在程序执行过程中不必担心被其他程序改变执行的环境。而内核的程序执行环境要复杂的多，即时最简单的内核模块也要考虑到并发执行的问题。
设计内核模块的数据结构要十分小心。由于代码的可重入特性，必须考虑到数据结构在多线程环境下不被其他线程破坏，对于共享数据更是应该采用加锁的方法保护。驱动程序员的通常错误是假定某段代码不会出现并发，导致数据被破坏而很难于调试。
linux内核模块使用物理内存，这点与应用程序不同。应用程序使用虚拟内存，有一个巨大的地址空间，在应用程序中可以分配大块的内存。内核模块可以供使用的内存非常小，最小可能小到一个内存页面（4096字节）。在编写内核模块代码的时候要注意内存的分配和使用。
内核模块至少支持加载和卸载两种操作。因此，一个内核模块至少包括加载和卸载两个函数。在linux 2.6系列内核中，通过module_init()宏可以在加载内核模块的时候调用内核模块的初始化函数，module_exit()宏可以在卸载内核模块的时候调用内核模块的卸载函数。
内核模块的初始化和卸载函数是有固定格式的。
|
1
2
|
static
int
__init init_func(
void
);
//初始化函数
static
void
__exit exit_func(
void
);
//清除函数
|
这两个函数的名称可以由用户自己定义，但是必须使用规定的返回值和参数格式。
-
static修饰符的作用是函数仅在当前文件有效，外部不可见；
-
__init关键字告诉编译器，该函数代码在初始化完毕后被忽略；
-
__exit关键字告诉编译器，该代码仅在卸载模块的时候被调用；
内核模块的加载
linux内核提供了一个kmod的模块用来管理内核模块。
kmod模块与用户态的kmodule模块通信，获取内核模块的信息。
通过insmod命令和modprobe命令都可以加载一个内核模块。
-
insmod命令加载内核模块的时候不检查内核模块的符号是否已经在内核中定义。
-
modprobe不仅检查内核模块符号表，而且还会检查模块的依赖关系。
另外，linux内核可以在需要加载某个模块的时候，通过kmod机制通知用户态的modprobe加载模块。
使用insmod加载内核模块的时候，首先使用特权级系统调用查找内核输出的符号。通常，内核输出符号被保存在内核模块列表第一个模块结构里。insmod命令把内核模块加载到虚拟内存，利用内核输出符号表来修改被加载模块中没有解析的内核函数的资源地址。
修改完内核模块中的函数和资源地址后，insmod使用特权指令申请存放内核模块的空间。因为内核模块是工作在内核态的，访问用户态的资源需要做地址转换。申请好空间后，insmod把内核模块复制到新空间，然后把模块加入到内核模块列表的尾部，并且设置模块标志为UNINTIALIZED，表示模块还没有被引用。insmod使用特权指令告诉内核新增加的模块初始化和清除函数的地址，供内核调用。
内核模块的卸载
卸载的过程相对于加载要简单，主要问题是对模块引用计数的判断。
一个内核模块被其他模块引用的时候，自身的引用计数器会增加1.当卸载模块的时候，需要判断模块引用计数器值是否为0，如果为0才能卸载模块，否则只能把模块计数减1.
超级用户使用rmmod命令可以卸载指定的模块。
此外，内核kmod机制会定期检查每个模块的引用计数器，如果某个模块的引用计数器值为0，kmod会卸载该模块。
编写一个基本的内核模块
还是以最经典的"Hello World ！"为例子吧。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/* 内核模块: ModuleHelloWorld.c */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
MODULE_LICENSE(
"GPL"
);
MODULE_AUTHOR(
"Mystety"
);
/* init function */
static
int
__init hello_init(
void
)
{
printk(KERN_ALERT
"(init)Hello,World!\n"
);
return
0;
}
/* exit function */
static
void
__exit hello_exit(
void
)
{
printk(KERN_ALERT
"(exit)Bye-bye,Mystery!\n"
);
}
module_init(hello_init);
module_exit(hello_exit);
|
编译内核模块
编译内核模块需要建立一个Makefile，主要目的是使用内核头文件，因为内核模块对内核版本有很强的依赖关系。
❶我用的系统是Ubuntu的，首先在系统命令行shell下安装当前版本的linux内核源代码
|
1
|
sudo
apt-get
install
linux-
source
|
编译内核模块不需要重新编译内核代码，但前提是需要使用当前内核版本相同的代码。
❷安装内核代码完毕后，在ModuleHelloWorld.c同一目录下编写Makefile
|
1
2
3
4
5
6
7
8
|
ifneq ($(KERNELRELEASE),)
obj-m := ModuleHelloWorld.o
else
KERNELDIR :=
/lib/modules/
$(shell
uname
-r)
/build
PWD := $(shell
pwd
)
default:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
endif
|
程序第1行检查是否定义了KERNELRELEASE环境变量，如果定义则表示该模块是内核代码的一部分，直接把模块名称添加到 obj-m环境变量即可；
如果未定义环境变量，表示在内核代码以外编译，通过设置KERNELDIR和PWD环境变量，然后通过内核脚本编译当前文件，生成内核模块文件。
❸Makefile建立完毕后，在shell下输入"make"回车编译内核模块。
❹编译结束后，生成ModuleHelloWorld.ko内核模块，通过modprobe或者insmod加载内核模块。
在加载过程中可以看到hello_init()函数的输出信息。
❺加载内核模块成功后，可以使用rmmod命令卸载内核模块。
卸载模块的时候，内核会调用内核的卸载函数，输出hello_exit()函数的内容。
模块卸载以后，使用lsmod命令查看模块列表，如果没有任何输出，表示HelloWorld内核模块已经被成功卸载。
|
1
|
lsmod |
grep
ModuleHelloWorld
|
为内核模块添加参数
驱动程序常需要在加载的时候提供一个或者多个参数，内模块提供了设置参数的能力。
通过module_param()宏可以为内核模块设置一个参数。
定义如下：module_param(参数名称，类型，属性)
其中，参数名称是加载内核模块时使用的参数名称，在内核模块中需要有一个同名的变量与之对应；类型是参数的类型，内核支持C语言常用的基本类型；属性是参数的访问权限。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
MODULE_LICENSE(
"GPL"
);
MODULE_AUTHOR(
"Mystety"
);
static
int
initValue = 0;
//模块参数 initValue = <int value>
static
char
*initName = NULL;
//模块参数 initName = <char*>
module_param(initValue,
int
, S_IRUGO);
module_param(initName, charp, S_IRUGO);
/* init function */
static
int
__init hello_init(
void
)
{
printk(KERN_ALERT
"initValue = %d initName = %s \n"
,initValue,initName);
//打印参数值
printk(KERN_ALERT
"(init)Hello,World!\n"
);
return
0;
}
/* exit function */
static
void
__exit hello_exit(
void
)
{
printk(KERN_ALERT
"(exit)Bye-bye,Mystery!\n"
);
}
module_init(hello_init);
module_exit(hello_exit);
|
在原来的代码中，增加了两个变量initValue和initName，分别是int类型和char*类型；然后在第8行设置initValue为int类型的参数，第9行设置initName为char*类型的参数。重新编译，带参数加载模块。
从输出结果可以看出，内核模块的参数被正确传递到了程序中。
总结
驱动其实也没有传说中的难，关键是需要动手去实践，相信自己，什么都可以！
本文出自 “成鹏致远” 博客，请务必保留此出处http://infohacker.blog.51cto.com/6751239/1218461