正文
lighttpd+fastcgi模块分析
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
一开始不怎么明白fastcgi和cgi的区别，查了资料说，fastcgi多了一个进程池，不要每次都fork和退出
这个不是重点，还是对着代码看吧
怎样在lighttpd运行php呢，需要下面这样配置
把fastcig模块的前面井号去掉，然后在下面加上这个相关的配置就可以
fastcgi.debug = 1
fastcgi.server = ( ".php" =>
( "localhost" =>
(
"host"=>"127.0.0.1",
"port"=>4000,
#"socket" => "/tmp/php.socket",
"bin-path" => "/usr/bin/php-cgi"
)
)
)
重启lighttpd，然后就可以访问了
用命令看一下cgi进程
[root@fire-16-168 ~]# ps aux|grep cgi
root 21614 0.0 0.1 471616 18276 ? Ss 15:29 0:00 /usr/bin/php-cgi
root 21615 0.0 0.1 471616 18280 ? Ss 15:29 0:00 /usr/bin/php-cgi
root 21616 0.0 0.1 471616 18276 ? Ss 15:29 0:00 /usr/bin/php-cgi
root 21617 0.0 0.1 471616 18280 ? Ss 15:29 0:00 /usr/bin/php-cgi
root 21619 0.0 0.0 471616 6092 ? S 15:29 0:00 /usr/bin/php-cgi
root 21620 0.0 0.0 471616 6088 ? S 15:29 0:00 /usr/bin/php-cgi
root 21625 0.0 0.0 471616 6088 ? S 15:29 0:00 /usr/bin/php-cgi
root 21628 0.0 0.0 471616 6088 ? S 15:29 0:00 /usr/bin/php-cgi
呵呵，总共有8个进程，
S Interruptible sleep (waiting for an event to complete)
s is a session leader
仔细观察，你会发现这些php-cgi的状态不尽相同，有的是Ss，有的是S，通过man ps你能找到这些状态的含义：
也就是说，Ss状态的进程都是主进程（max-procs代表的那些进程），而S状态的进程都是子进程（PHP_FCGI_CHILDREN代表的那些进程）。如果不相信，你可以使用命令核实一下数量：
再看看网络连接是怎样的
[root@fire-16-168 ~]# netstat -anp|grep cgi
tcp 0 0 127.0.0.1:4000 0.0.0.0:* LISTEN 21614/php-cgi
tcp 0 0 127.0.0.1:4001 0.0.0.0:* LISTEN 21615/php-cgi
tcp 0 0 127.0.0.1:4002 0.0.0.0:* LISTEN 21616/php-cgi
tcp 0 0 127.0.0.1:4003 0.0.0.0:* LISTEN 21617/php-cgi
其中只有4个进程在监听，为什么会这样，还是看代码吧
for (n = ; n < da_ext->value->used; n++) {
data_array *da_host = (data_array *)da_ext->value->data[n];
fcgi_extension_host *host;
config_values_t fcv[] = {
{ "host", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 0 主机*/
{ "docroot", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 1 端口*/
{ "mode", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 2 */
{ "socket", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 3 可以用unix套接字域去连接*/
{ "bin-path", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 4 cgi的位置*/
{ "check-local", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 5 */
{ "port", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 6 */
{ "min-procs-not-working", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 7 this is broken for now */
{ "max-procs", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 8 最大cgi进程数*/
{ "max-load-per-proc", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 9 */
{ "idle-timeout", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 10 */
{ "disable-time", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 11 */
{ "bin-environment", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 12 这里是可以传给php-cgi的参数 */
{ "bin-copy-environment", NULL, T_CONFIG_ARRAY, T_CONFIG_SCOPE_CONNECTION }, /* 13 */
{ "broken-scriptfilename", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 14 */
{ "allow-x-send-file", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 15 */
{ "strip-request-uri", NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION }, /* 16 */
{ "kill-signal", NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION }, /* 17 */
{ "fix-root-scriptname", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION }, /* 18 */
{ NULL, NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
};
if (da_host->type != TYPE_ARRAY) {
log_error_write(srv, __FILE__, __LINE__, "ssSBS",
"unexpected type for key:",
"fastcgi.server",
"[", da_host->key, "](string)");
return HANDLER_ERROR;
}
#初始化host结构
host = fastcgi_host_init();
buffer_copy_string_buffer(host->id, da_host->key);
#host默认值
host->check_local = ;
host->min_procs = ;
host->max_procs = ;
host->max_load_per_proc = ;
host->idle_timeout = ;
host->mode = FCGI_RESPONDER;
host->disable_time = ;
host->break_scriptfilename_for_php = ;
host->allow_xsendfile = ; /* handle X-LIGHTTPD-send-file */
host->kill_signal = SIGTERM;
host->fix_root_path_name = ;
fcv[].destination = host->host;
fcv[].destination = host->docroot;
fcv[].destination = fcgi_mode;
fcv[].destination = host->unixsocket;
fcv[].destination = host->bin_path;
fcv[].destination = &(host->check_local);
fcv[].destination = &(host->port);
fcv[].destination = &(host->min_procs);
fcv[].destination = &(host->max_procs);
fcv[].destination = &(host->max_load_per_proc);
fcv[].destination = &(host->idle_timeout);
fcv[].destination = &(host->disable_time);
fcv[].destination = host->bin_env;
fcv[].destination = host->bin_env_copy;
fcv[].destination = &(host->break_scriptfilename_for_php);
fcv[].destination = &(host->allow_xsendfile);
fcv[].destination = host->strip_request_uri;
fcv[].destination = &(host->kill_signal);
fcv[].destination = &(host->fix_root_path_name);
#进行配置文件替换
if ( != config_insert_values_internal(srv, da_host->value, fcv)) {
return HANDLER_ERROR;
}
#判断有没有设置端口和socket
if ((!buffer_is_empty(host->host) || host->port) &&
!buffer_is_empty(host->unixsocket)) {
log_error_write(srv, __FILE__, __LINE__, "sbsbsbs",
"either host/port or socket have to be set in:",
da->key, "= (",
da_ext->key, " => (",
da_host->key, " ( ...");
return HANDLER_ERROR;
}
#使用unix domain socket
if (!buffer_is_empty(host->unixsocket)) {
/* unix domain socket */
struct sockaddr_un un;
if (host->unixsocket->used > sizeof(un.sun_path) - ) {
log_error_write(srv, __FILE__, __LINE__, "sbsbsbs",
"unixsocket is too long in:",
da->key, "= (",
da_ext->key, " => (",
da_host->key, " ( ...");
return HANDLER_ERROR;
}
} else {
/* tcp/ip */
if (buffer_is_empty(host->host) &&
buffer_is_empty(host->bin_path)) {
log_error_write(srv, __FILE__, __LINE__, "sbsbsbs",
"host or binpath have to be set in:",
da->key, "= (",
da_ext->key, " => (",
da_host->key, " ( ...");
return HANDLER_ERROR;
} else if (host->port == ) {
log_error_write(srv, __FILE__, __LINE__, "sbsbsbs",
"port has to be set in:",
da->key, "= (",
da_ext->key, " => (",
da_host->key, " ( ...");
return HANDLER_ERROR;
}
}
if (!buffer_is_empty(host->bin_path)) {
/* a local socket + self spawning */
size_t pno;
/* HACK: just to make sure the adaptive spawing is disabled */
host->min_procs = host->max_procs;
if (host->min_procs > host->max_procs) host->max_procs = host->min_procs;
if (host->max_load_per_proc < ) host->max_load_per_proc = ;
if (s->debug) {
log_error_write(srv, __FILE__, __LINE__, "ssbsdsbsdsd",
"--- fastcgi spawning local",
"\n\tproc:", host->bin_path,
"\n\tport:", host->port,
"\n\tsocket", host->unixsocket,
"\n\tmin-procs:", host->min_procs,
"\n\tmax-procs:", host->max_procs);
}
#开始创建进程
for (pno = ; pno < host->min_procs; pno++) {
fcgi_proc *proc;
proc = fastcgi_process_init();
proc->id = host->num_procs++;
host->max_id++;
if (buffer_is_empty(host->unixsocket)) {
proc->port = host->port + pno;
} else {
buffer_copy_string_buffer(proc->unixsocket, host->unixsocket);
buffer_append_string_len(proc->unixsocket, CONST_STR_LEN("-"));
buffer_append_long(proc->unixsocket, pno);
}
if (s->debug) {
log_error_write(srv, __FILE__, __LINE__, "ssdsbsdsd",
"--- fastcgi spawning",
"\n\tport:", host->port,
"\n\tsocket", host->unixsocket,
"\n\tcurrent:", pno, "/", host->min_procs);
}
#这个开始创建套接字
if (fcgi_spawn_connection(srv, p, host, proc)) {
log_error_write(srv, __FILE__, __LINE__, "s",
"[ERROR]: spawning fcgi failed.");
return HANDLER_ERROR;
}
fastcgi_status_init(srv, p->statuskey, host, proc);
proc->next = host->first;
if (host->first) host->first->prev = proc;
host->first = proc;
}
} else {
fcgi_proc *proc;
proc = fastcgi_process_init();
proc->id = host->num_procs++;
host->max_id++;
host->active_procs++;
proc->state = PROC_STATE_RUNNING;
if (buffer_is_empty(host->unixsocket)) {
proc->port = host->port;
} else {
buffer_copy_string_buffer(proc->unixsocket, host->unixsocket);
}
fastcgi_status_init(srv, p->statuskey, host, proc);
host->first = proc;
host->min_procs = ;
host->max_procs = ;
}
if (!buffer_is_empty(fcgi_mode)) {
if (strcmp(fcgi_mode->ptr, "responder") == ) {
host->mode = FCGI_RESPONDER;
} else if (strcmp(fcgi_mode->ptr, "authorizer") == ) {
host->mode = FCGI_AUTHORIZER;
if (buffer_is_empty(host->docroot)) {
log_error_write(srv, __FILE__, __LINE__, "s",
"ERROR: docroot is required for authorizer mode.");
return HANDLER_ERROR;
}
} else {
log_error_write(srv, __FILE__, __LINE__, "sbs",
"WARNING: unknown fastcgi mode:",
fcgi_mode, "(ignored, mode set to responder)");
}
}
/* if extension already exists, take it */
fastcgi_extension_insert(s->exts, da_ext->key, host);
}
ok,分析一下流程
1，读取配置文件
2，设置一下默认参数（如果我们某些属性没有设置的话，由系统参数去配置）例如 min-proc 系统默认为4个啊
3，创建套接字 根据fcgi_spawn_connection 这个函数
我们开始分析这个函数
static int fcgi_spawn_connection(server *srv,
plugin_data *p,
fcgi_extension_host *host,
fcgi_proc *proc) {
int fcgi_fd;
int socket_type, status;
struct timeval tv = { , * };
#ifdef HAVE_SYS_UN_H
struct sockaddr_un fcgi_addr_un;
#endif
struct sockaddr_in fcgi_addr_in;
struct sockaddr *fcgi_addr; socklen_t servlen; #ifndef HAVE_FORK
return -;
#endif if (p->conf.debug) {
log_error_write(srv, __FILE__, __LINE__, "sdb",
"new proc, socket:", proc->port, proc->unixsocket);
}
#如果unixsocket套接字不为空，也就是有设置啦
if (!buffer_is_empty(proc->unixsocket)) {
memset(&fcgi_addr, , sizeof(fcgi_addr)); #ifdef HAVE_SYS_UN_H
fcgi_addr_un.sun_family = AF_UNIX;
strcpy(fcgi_addr_un.sun_path, proc->unixsocket->ptr); #ifdef SUN_LEN
servlen = SUN_LEN(&fcgi_addr_un);
#else
/* stevens says: */
servlen = proc->unixsocket->used + sizeof(fcgi_addr_un.sun_family);
#endif
socket_type = AF_UNIX;
fcgi_addr = (struct sockaddr *) &fcgi_addr_un; buffer_copy_string_len(proc->connection_name, CONST_STR_LEN("unix:"));
buffer_append_string_buffer(proc->connection_name, proc->unixsocket); #else
log_error_write(srv, __FILE__, __LINE__, "s",
"ERROR: Unix Domain sockets are not supported.");
return -;
#endif
} else { #这里就是走tcp模式
fcgi_addr_in.sin_family = AF_INET; if (buffer_is_empty(host->host)) {
fcgi_addr_in.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
} else {
struct hostent *he; /* set a useful default */
fcgi_addr_in.sin_addr.s_addr = htonl(INADDR_LOOPBACK); #获取主机的真实地址
if (NULL == (he = gethostbyname(host->host->ptr))) {
log_error_write(srv, __FILE__, __LINE__,
"sdb", "gethostbyname failed: ",
h_errno, host->host);
return -;
} if (he->h_addrtype != AF_INET) {
log_error_write(srv, __FILE__, __LINE__, "sd", "addr-type != AF_INET: ", he->h_addrtype);
return -;
} if (he->h_length != sizeof(struct in_addr)) {
log_error_write(srv, __FILE__, __LINE__, "sd", "addr-length != sizeof(in_addr): ", he->h_length);
return -;
} memcpy(&(fcgi_addr_in.sin_addr.s_addr), he->h_addr_list[], he->h_length); }
#绑定端口
fcgi_addr_in.sin_port = htons(proc->port);
servlen = sizeof(fcgi_addr_in); socket_type = AF_INET;
fcgi_addr = (struct sockaddr *) &fcgi_addr_in; buffer_copy_string_len(proc->connection_name, CONST_STR_LEN("tcp:"));
if (!buffer_is_empty(host->host)) {
buffer_append_string_buffer(proc->connection_name, host->host);
} else {
buffer_append_string_len(proc->connection_name, CONST_STR_LEN("localhost"));
}
buffer_append_string_len(proc->connection_name, CONST_STR_LEN(":"));
buffer_append_long(proc->connection_name, proc->port);
}
#建立socket
if (- == (fcgi_fd = socket(socket_type, SOCK_STREAM, ))) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"failed:", strerror(errno));
return -;
}
#连接socket
if (- == connect(fcgi_fd, fcgi_addr, servlen)) {
/* server is not up, spawn it 连接失败，则说明服务器还没有起来 */
pid_t child;
int val; if (errno != ENOENT &&
!buffer_is_empty(proc->unixsocket)) {
unlink(proc->unixsocket->ptr);
} close(fcgi_fd); /* reopen socket 重新打开socket */
if (- == (fcgi_fd = socket(socket_type, SOCK_STREAM, ))) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"socket failed:", strerror(errno));
return -;
} val = ;
if (setsockopt(fcgi_fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < ) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"socketsockopt failed:", strerror(errno));
return -;
} /* create socket */
if (- == bind(fcgi_fd, fcgi_addr, servlen)) {
log_error_write(srv, __FILE__, __LINE__, "sbs",
"bind failed for:",
proc->connection_name,
strerror(errno));
return -;
}
#监听socket
if (- == listen(fcgi_fd, )) {
log_error_write(srv, __FILE__, __LINE__, "ss",
"listen failed:", strerror(errno));
return -;
} #ifdef HAVE_FORK 开始生产进程
switch ((child = fork())) {
case : {
size_t i = ;
char *c;
char_array env;
char_array arg; /* create environment */
env.ptr = NULL;
env.size = ;
env.used = ; arg.ptr = NULL;
arg.size = ;
arg.used = ; if(fcgi_fd != FCGI_LISTENSOCK_FILENO) {
close(FCGI_LISTENSOCK_FILENO);
dup2(fcgi_fd, FCGI_LISTENSOCK_FILENO);
close(fcgi_fd);
} openDevNull(STDERR_FILENO); /* we don't need the client socket */
for (i = ; i < ; i++) {
close(i);
} /* build clean environment */
if (host->bin_env_copy->used) {
for (i = ; i < host->bin_env_copy->used; i++) {
data_string *ds = (data_string *)host->bin_env_copy->data[i];
char *ge; if (NULL != (ge = getenv(ds->value->ptr))) {
env_add(&env, CONST_BUF_LEN(ds->value), ge, strlen(ge));
}
}
} else {
for (i = ; environ[i]; i++) {
char *eq; if (NULL != (eq = strchr(environ[i], '='))) {
env_add(&env, environ[i], eq - environ[i], eq+, strlen(eq+));
}
}
} /* create environment */
for (i = ; i < host->bin_env->used; i++) {
data_string *ds = (data_string *)host->bin_env->data[i]; env_add(&env, CONST_BUF_LEN(ds->key), CONST_BUF_LEN(ds->value));
} for (i = ; i < env.used; i++) {
/* search for PHP_FCGI_CHILDREN */
if ( == strncmp(env.ptr[i], "PHP_FCGI_CHILDREN=", sizeof("PHP_FCGI_CHILDREN=") - )) break;
} /* not found, add a default */
if (i == env.used) {
env_add(&env, CONST_STR_LEN("PHP_FCGI_CHILDREN"), CONST_STR_LEN(""));
} env.ptr[env.used] = NULL;
#处理cgi程序名字
parse_binpath(&arg, host->bin_path); /* chdir into the base of the bin-path,
* search for the last / */
if (NULL != (c = strrchr(arg.ptr[], '/'))) {
*c = '\0'; /* change to the physical directory */
if (- == chdir(arg.ptr[])) {
*c = '/';
log_error_write(srv, __FILE__, __LINE__, "sss", "chdir failed:", strerror(errno), arg.ptr[]);
}
*c = '/';
} /* exec the cgi 开始执行cgi */
execve(arg.ptr[], arg.ptr, env.ptr); /* log_error_write(srv, __FILE__, __LINE__, "sbs",
"execve failed for:", host->bin_path, strerror(errno)); */ exit(errno); break;
}
case -:
/* error */
break;
default:
/* father */ /* wait */
select(, NULL, NULL, NULL, &tv); switch (waitpid(child, &status, WNOHANG)) {
case :
/* child still running after timeout, good */
break;
case -:
/* no PID found ? should never happen */
log_error_write(srv, __FILE__, __LINE__, "ss",
"pid not found:", strerror(errno));
return -;
default:
log_error_write(srv, __FILE__, __LINE__, "sbs",
"the fastcgi-backend", host->bin_path, "failed to start:");
/* the child should not terminate at all */
if (WIFEXITED(status)) {
log_error_write(srv, __FILE__, __LINE__, "sdb",
"child exited with status",
WEXITSTATUS(status), host->bin_path);
log_error_write(srv, __FILE__, __LINE__, "s",
"If you're trying to run PHP as a FastCGI backend, make sure you're using the FastCGI-enabled version.\n"
"You can find out if it is the right one by executing 'php -v' and it should display '(cgi-fcgi)' "
"in the output, NOT '(cgi)' NOR '(cli)'.\n"
"For more information, check http://trac.lighttpd.net/trac/wiki/Docs%3AModFastCGI#preparing-php-as-a-fastcgi-program"
"If this is PHP on Gentoo, add 'fastcgi' to the USE flags.");
} else if (WIFSIGNALED(status)) {
log_error_write(srv, __FILE__, __LINE__, "sd",
"terminated by signal:",
WTERMSIG(status)); if (WTERMSIG(status) == ) {
log_error_write(srv, __FILE__, __LINE__, "s",
"to be exact: it segfaulted, crashed, died, ... you get the idea." );
log_error_write(srv, __FILE__, __LINE__, "s",
"If this is PHP, try removing the bytecode caches for now and try again.");
}
} else {
log_error_write(srv, __FILE__, __LINE__, "sd",
"child died somehow:",
status);
}
return -;
} /* register process */
proc->pid = child;
proc->last_used = srv->cur_ts;
proc->is_local = ; break;
}
#endif
} else {
proc->is_local = ;
proc->pid = ; if (p->conf.debug) {
log_error_write(srv, __FILE__, __LINE__, "sb",
"(debug) socket is already used; won't spawn:",
proc->connection_name);
}
} proc->state = PROC_STATE_RUNNING;
host->active_procs++; close(fcgi_fd); return ;
}
上面的流程是这样的
1根据配置文件判断用哪一种方式通讯，有tcp,有unix自身套接字（这个有个局限性，要cgi在同一台机器才能用的
2，连接服务端，如果失败的话则为服务端创建套接字
if(fcgi_fd != FCGI_LISTENSOCK_FILENO) {
close(FCGI_LISTENSOCK_FILENO);
dup2(fcgi_fd, FCGI_LISTENSOCK_FILENO);
close(fcgi_fd);
}
FCGI_LISTENSOCK_FILENO 这个是什么来的
根据fast-cgi协议是这样说的
当应用开始执行时，Web服务器留下一个打开的文件描述符，FCGI_LISTENSOCK_FILENO。该描述符引用Web服务器创建的一个正在监听的socket。
FCGI_LISTENSOCK_FILENO等于STDIN_FILENO。当应用开始执行时，标准的描述符STDOUT_FILENO和STDERR_FILENO被关闭。一个用于应用确定它是用CGI调用的还是用FastCGI调用的可靠方法是调用getpeername(FCGI_LISTENSOCK_FILENO)，对于FastCGI应用，它返回-1，并设置errno为ENOTCONN。
Web服务器对于可靠传输的选择，Unix流式管道（AF_UNIX）或TCP/IP（AF_INET），是内含于FCGI_LISTENSOCK_FILENO socket的内部状态中的
呵呵
我们可以看到， 代码把fcgi_fd重定向到FCGI_LISTENSOCK_FILENO 这个身上，这个值为0，巧妙的地方就在这里了
我一直很奇怪在这里找不到accept，实在太笨啦，lighttpd相对于cgi只不过是一个客户端而已，不可能在lighttpd自己身上accept
所以唯一的办法就是把刚刚的套接字传递给cgi
为了证明这个东西，我们翻看了php-cgi的代码
int fcgi_fd = ; fastcgi = fcgi_is_fastcgi();
if (bindpath) {
fcgi_fd = fcgi_listen(bindpath, );
if (fcgi_fd < ) {
fprintf(stderr, "Couldn't create FastCGI listen socket on port %s\n", bindpath);
#ifdef ZTS
tsrm_shutdown();
#endif
return FAILURE;
}
fastcgi = fcgi_is_fastcgi();
}
if (fastcgi) {
/* How many times to run PHP scripts before dying */
if (getenv("PHP_FCGI_MAX_REQUESTS")) {
max_requests = atoi(getenv("PHP_FCGI_MAX_REQUESTS"));
if (max_requests < ) {
fprintf(stderr, "PHP_FCGI_MAX_REQUESTS is not valid\n");
return FAILURE;
}
} /* make php call us to get _ENV vars */
php_php_import_environment_variables = php_import_environment_variables;
php_import_environment_variables = cgi_php_import_environment_variables; /* library is already initialized, now init our request */
request = fcgi_init_request(fcgi_fd);
ok,bindpath是何方神圣，通常我们是这样启动cgi的
php-cgi -b 127.0.0.1:9000，我们在上面根本没有传递这个参数给php-cgi,所以判断不成立
在看看fastcgi这个变量是怎样判断的，我们看看这个函数
int fcgi_is_fastcgi(void)
{
if (!is_initialized) {
return fcgi_init();
} else {
return is_fastcgi;
}
}
int fcgi_init(void)
{
if (!is_initialized) {
#ifndef _WIN32
sa_t sa;
socklen_t len = sizeof(sa);
#endif
zend_hash_init(&fcgi_mgmt_vars, , NULL, fcgi_free_mgmt_var_cb, );
fcgi_set_mgmt_var("FCGI_MPXS_CONNS", sizeof("FCGI_MPXS_CONNS")-, "", sizeof("")-); is_initialized = ;
#ifdef _WIN32
# if
/* TODO: Support for TCP sockets */
WSADATA wsaData; if (WSAStartup(MAKEWORD(,), &wsaData)) {
fprintf(stderr, "Error starting Windows Sockets. Error: %d", WSAGetLastError());
return ;
}
# endif
if ((GetStdHandle(STD_OUTPUT_HANDLE) == INVALID_HANDLE_VALUE) &&
(GetStdHandle(STD_ERROR_HANDLE) == INVALID_HANDLE_VALUE) &&
(GetStdHandle(STD_INPUT_HANDLE) != INVALID_HANDLE_VALUE)) {
char *str;
DWORD pipe_mode = PIPE_READMODE_BYTE | PIPE_WAIT;
HANDLE pipe = GetStdHandle(STD_INPUT_HANDLE); SetNamedPipeHandleState(pipe, &pipe_mode, NULL, NULL); str = getenv("_FCGI_SHUTDOWN_EVENT_");
if (str != NULL) {
HANDLE shutdown_event = (HANDLE) atoi(str);
if (!CreateThread(NULL, , fcgi_shutdown_thread,
shutdown_event, , NULL)) {
return -;
}
}
str = getenv("_FCGI_MUTEX_");
if (str != NULL) {
fcgi_accept_mutex = (HANDLE) atoi(str);
}
return is_fastcgi = ;
} else {
return is_fastcgi = ;
}
#else
errno = ;
if (getpeername(, (struct sockaddr *)&sa, &len) != && errno == ENOTCONN) {
fcgi_setup_signals();
return is_fastcgi = ;
} else {
return is_fastcgi = ;
}
#endif
}
return is_fastcgi;
}
呵呵，注意49行用getpeername这个函数，传进去的是套接字是0，还记得我们刚才执行cgi的时候dup2吗，呵呵巧妙就在这里
也就是说如果我们fastcgi的话就直接采用fcgi_fd=0 这个套接字，谜底解开了吧
我们再次看看php-cgi是怎样accept的
#ifndef PHP_WIN32
/* Pre-fork, if required */
if (getenv("PHP_FCGI_CHILDREN")) {
char * children_str = getenv("PHP_FCGI_CHILDREN");
children = atoi(children_str);
if (children < ) {
fprintf(stderr, "PHP_FCGI_CHILDREN is not valid\n");
return FAILURE;
}
fcgi_set_mgmt_var("FCGI_MAX_CONNS", sizeof("FCGI_MAX_CONNS")-, children_str, strlen(children_str));
/* This is the number of concurrent requests, equals FCGI_MAX_CONNS */
fcgi_set_mgmt_var("FCGI_MAX_REQS", sizeof("FCGI_MAX_REQS")-, children_str, strlen(children_str));
} else {
fcgi_set_mgmt_var("FCGI_MAX_CONNS", sizeof("FCGI_MAX_CONNS")-, "", sizeof("")-);
fcgi_set_mgmt_var("FCGI_MAX_REQS", sizeof("FCGI_MAX_REQS")-, "", sizeof("")-);
} if (children) {
int running = ;
pid_t pid; /* Create a process group for ourself & children */
setsid();
pgroup = getpgrp();
#ifdef DEBUG_FASTCGI
fprintf(stderr, "Process group %d\n", pgroup);
#endif /* Set up handler to kill children upon exit */
act.sa_flags = ;
act.sa_handler = fastcgi_cleanup;
if (sigaction(SIGTERM, &act, &old_term) ||
sigaction(SIGINT, &act, &old_int) ||
sigaction(SIGQUIT, &act, &old_quit)
) {
perror("Can't set signals");
exit();
} if (fcgi_in_shutdown()) {
goto parent_out;
} while (parent) {
do {
#ifdef DEBUG_FASTCGI
fprintf(stderr, "Forking, %d running\n", running);
#endif
pid = fork();
switch (pid) {
case :
/* One of the children.
* Make sure we don't go round the
* fork loop any more
*/
parent = ; /* don't catch our signals */
sigaction(SIGTERM, &old_term, );
sigaction(SIGQUIT, &old_quit, );
sigaction(SIGINT, &old_int, );
break;
case -:
perror("php (pre-forking)");
exit();
break;
default:
/* Fine */
running++;
break;
}
} while (parent && (running < children)); if (parent) {
#ifdef DEBUG_FASTCGI
fprintf(stderr, "Wait for kids, pid %d\n", getpid());
#endif
parent_waiting = ;
while () {
if (wait(&status) >= ) {
running--;
break;
} else if (exit_signal) {
break;
}
}
if (exit_signal) {
#if 0
while (running > ) {
while (wait(&status) < ) {
}
running--;
}
#endif
goto parent_out;
}
}
}
} else {
parent = ;
} #endif /* WIN32 */
}
呵呵cgi会先根据获取回来的 PHP_FCGI_CHILDREN 的设置去生成子进程，
/* not found, add a default */
if (i == env.used) {
env_add(&env, CONST_STR_LEN("PHP_FCGI_CHILDREN"), CONST_STR_LEN("1"));
}
lighttpd会默认设置一个啦
所谓的pre-fork模式啦
关于上次怎样区别父进程执行那些代码，子进程执行那些代码相信读者会很容易发现
父进程进行wait,然后做一个管理子进程的多小
子进程就开始accept啦
while (!fastcgi || fcgi_accept_request(request) >= ) {
SG(server_context) = fastcgi ? (void *) request : (void *) ;
init_request_info(request TSRMLS_CC);
CG(interactive) = ;
if (!cgi && !fastcgi) {
while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, , )) != -) {
switch (c) {
case 'a': /* interactive mode */
printf("Interactive mode enabled\n\n");
CG(interactive) = ;
break;
case 'C': /* don't chdir to the script directory */
SG(options) |= SAPI_OPTION_NO_CHDIR;
break;
case 'e': /* enable extended info output */
CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
break;
case 'f': /* parse file */
if (script_file) {
efree(script_file);
}
script_file = estrdup(php_optarg);
no_headers = ;
break;
case 'i': /* php info & quit */
if (script_file) {
efree(script_file);
}
if (php_request_startup(TSRMLS_C) == FAILURE) {
SG(server_context) = NULL;
php_module_shutdown(TSRMLS_C);
return FAILURE;
}
if (no_headers) {
SG(headers_sent) = ;
SG(request_info).no_headers = ;
}
php_print_info(0xFFFFFFFF TSRMLS_CC);
php_request_shutdown((void *) );
fcgi_shutdown();
exit_status = ;
goto out;
case 'l': /* syntax check mode */
no_headers = ;
behavior = PHP_MODE_LINT;
break;
case 'm': /* list compiled in modules */
if (script_file) {
efree(script_file);
}
SG(headers_sent) = ;
php_printf("[PHP Modules]\n");
print_modules(TSRMLS_C);
php_printf("\n[Zend Modules]\n");
print_extensions(TSRMLS_C);
php_printf("\n");
php_output_end_all(TSRMLS_C);
fcgi_shutdown();
exit_status = ;
goto out;
#if 0 /* not yet operational, see also below ... */
case '': /* generate indented source mode*/
behavior=PHP_MODE_INDENT;
break;
#endif
case 'q': /* do not generate HTTP headers */
no_headers = ;
break;
case 'v': /* show php version & quit */
if (script_file) {
efree(script_file);
}
no_headers = ;
if (php_request_startup(TSRMLS_C) == FAILURE) {
SG(server_context) = NULL;
php_module_shutdown(TSRMLS_C);
return FAILURE;
}
if (no_headers) {
SG(headers_sent) = ;
SG(request_info).no_headers = ;
}
#if ZEND_DEBUG
php_printf("PHP %s (%s) (built: %s %s) (DEBUG)\nCopyright (c) 1997-2013 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__, get_zend_version());
#else
php_printf("PHP %s (%s) (built: %s %s)\nCopyright (c) 1997-2013 The PHP Group\n%s", PHP_VERSION, sapi_module.name, __DATE__, __TIME__, get_zend_version());
#endif
php_request_shutdown((void *) );
fcgi_shutdown();
exit_status = ;
goto out;
case 'w':
behavior = PHP_MODE_STRIP;
break;
case 'z': /* load extension file */
zend_load_extension(php_optarg);
break;
default:
break;
}
}
if (script_file) {
/* override path_translated if -f on command line */
STR_FREE(SG(request_info).path_translated);
SG(request_info).path_translated = script_file;
/* before registering argv to module exchange the *new* argv[0] */
/* we can achieve this without allocating more memory */
SG(request_info).argc = argc - (php_optind - );
SG(request_info).argv = &argv[php_optind - ];
SG(request_info).argv[] = script_file;
} else if (argc > php_optind) {
/* file is on command line, but not in -f opt */
STR_FREE(SG(request_info).path_translated);
SG(request_info).path_translated = estrdup(argv[php_optind]);
/* arguments after the file are considered script args */
SG(request_info).argc = argc - php_optind;
SG(request_info).argv = &argv[php_optind];
}
if (no_headers) {
SG(headers_sent) = ;
SG(request_info).no_headers = ;
}
/* all remaining arguments are part of the query string
* this section of code concatenates all remaining arguments
* into a single string, seperating args with a &
* this allows command lines like:
*
* test.php v1=test v2=hello+world!
* test.php "v1=test&v2=hello world!"
* test.php v1=test "v2=hello world!"
*/
if (!SG(request_info).query_string && argc > php_optind) {
int slen = strlen(PG(arg_separator).input);
len = ;
for (i = php_optind; i < argc; i++) {
if (i < (argc - )) {
len += strlen(argv[i]) + slen;
} else {
len += strlen(argv[i]);
}
}
len += ;
s = malloc(len);
*s = '\0'; /* we are pretending it came from the environment */
for (i = php_optind; i < argc; i++) {
strlcat(s, argv[i], len);
if (i < (argc - )) {
strlcat(s, PG(arg_separator).input, len);
}
}
SG(request_info).query_string = s;
free_query_string = ;
}
} /* end !cgi && !fastcgi */
/*
we never take stdin if we're (f)cgi, always
rely on the web server giving us the info
we need in the environment.
*/
if (SG(request_info).path_translated || cgi || fastcgi) {
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.filename = SG(request_info).path_translated;
file_handle.handle.fp = NULL;
} else {
file_handle.filename = "-";
file_handle.type = ZEND_HANDLE_FP;
file_handle.handle.fp = stdin;
}
file_handle.opened_path = NULL;
file_handle.free_filename = ;
/* request startup only after we've done all we can to
* get path_translated */
if (php_request_startup(TSRMLS_C) == FAILURE) {
if (fastcgi) {
fcgi_finish_request(request, );
}
SG(server_context) = NULL;
php_module_shutdown(TSRMLS_C);
return FAILURE;
}
if (no_headers) {
SG(headers_sent) = ;
SG(request_info).no_headers = ;
}
/*
at this point path_translated will be set if:
1. we are running from shell and got filename was there
2. we are running as cgi or fastcgi
*/
if (cgi || fastcgi || SG(request_info).path_translated) {
if (php_fopen_primary_script(&file_handle TSRMLS_CC) == FAILURE) {
zend_try {
if (errno == EACCES) {
SG(sapi_headers).http_response_code = ;
PUTS("Access denied.\n");
} else {
SG(sapi_headers).http_response_code = ;
PUTS("No input file specified.\n");
}
} zend_catch {
} zend_end_try();
/* we want to serve more requests if this is fastcgi
* so cleanup and continue, request shutdown is
* handled later */
if (fastcgi) {
goto fastcgi_request_done;
}
STR_FREE(SG(request_info).path_translated);
if (free_query_string && SG(request_info).query_string) {
free(SG(request_info).query_string);
SG(request_info).query_string = NULL;
}
php_request_shutdown((void *) );
SG(server_context) = NULL;
php_module_shutdown(TSRMLS_C);
sapi_shutdown();
#ifdef ZTS
tsrm_shutdown();
#endif
return FAILURE;
}
}
if (CGIG(check_shebang_line)) {
/* #!php support */
switch (file_handle.type) {
case ZEND_HANDLE_FD:
if (file_handle.handle.fd < ) {
break;
}
file_handle.type = ZEND_HANDLE_FP;
file_handle.handle.fp = fdopen(file_handle.handle.fd, "rb");
/* break missing intentionally */
case ZEND_HANDLE_FP:
if (!file_handle.handle.fp ||
(file_handle.handle.fp == stdin)) {
break;
}
c = fgetc(file_handle.handle.fp);
if (c == '#') {
while (c != '\n' && c != '\r' && c != EOF) {
c = fgetc(file_handle.handle.fp); /* skip to end of line */
}
/* handle situations where line is terminated by \r\n */
if (c == '\r') {
if (fgetc(file_handle.handle.fp) != '\n') {
long pos = ftell(file_handle.handle.fp);
fseek(file_handle.handle.fp, pos - , SEEK_SET);
}
}
CG(start_lineno) = ;
} else {
rewind(file_handle.handle.fp);
}
break;
case ZEND_HANDLE_STREAM:
c = php_stream_getc((php_stream*)file_handle.handle.stream.handle);
if (c == '#') {
while (c != '\n' && c != '\r' && c != EOF) {
c = php_stream_getc((php_stream*)file_handle.handle.stream.handle); /* skip to end of line */
}
/* handle situations where line is terminated by \r\n */
if (c == '\r') {
if (php_stream_getc((php_stream*)file_handle.handle.stream.handle) != '\n') {
long pos = php_stream_tell((php_stream*)file_handle.handle.stream.handle);
php_stream_seek((php_stream*)file_handle.handle.stream.handle, pos - , SEEK_SET);
}
}
CG(start_lineno) = ;
} else {
php_stream_rewind((php_stream*)file_handle.handle.stream.handle);
}
break;
case ZEND_HANDLE_MAPPED:
if (file_handle.handle.stream.mmap.buf[] == '#') {
int i = ;
c = file_handle.handle.stream.mmap.buf[i++];
while (c != '\n' && c != '\r' && c != EOF) {
c = file_handle.handle.stream.mmap.buf[i++];
}
if (c == '\r') {
if (file_handle.handle.stream.mmap.buf[i] == '\n') {
i++;
}
}
file_handle.handle.stream.mmap.buf += i;
file_handle.handle.stream.mmap.len -= i;
}
break;
default:
break;
}
}
switch (behavior) {
case PHP_MODE_STANDARD:
php_execute_script(&file_handle TSRMLS_CC);
break;
case PHP_MODE_LINT:
PG(during_request_startup) = ;
exit_status = php_lint_script(&file_handle TSRMLS_CC);
if (exit_status == SUCCESS) {
zend_printf("No syntax errors detected in %s\n", file_handle.filename);
} else {
zend_printf("Errors parsing %s\n", file_handle.filename);
}
break;
case PHP_MODE_STRIP:
if (open_file_for_scanning(&file_handle TSRMLS_CC) == SUCCESS) {
zend_strip(TSRMLS_C);
zend_file_handle_dtor(&file_handle TSRMLS_CC);
php_output_teardown();
}
return SUCCESS;
break;
case PHP_MODE_HIGHLIGHT:
{
zend_syntax_highlighter_ini syntax_highlighter_ini;
if (open_file_for_scanning(&file_handle TSRMLS_CC) == SUCCESS) {
php_get_highlight_struct(&syntax_highlighter_ini);
zend_highlight(&syntax_highlighter_ini TSRMLS_CC);
if (fastcgi) {
goto fastcgi_request_done;
}
zend_file_handle_dtor(&file_handle TSRMLS_CC);
php_output_teardown();
}
return SUCCESS;
}
break;
#if 0
/* Zeev might want to do something with this one day */
case PHP_MODE_INDENT:
open_file_for_scanning(&file_handle TSRMLS_CC);
zend_indent();
zend_file_handle_dtor(&file_handle TSRMLS_CC);
php_output_teardown();
return SUCCESS;
break;
#endif
}
fastcgi_request_done:
{
STR_FREE(SG(request_info).path_translated);
php_request_shutdown((void *) );
if (exit_status == ) {
exit_status = EG(exit_status);
}
if (free_query_string && SG(request_info).query_string) {
free(SG(request_info).query_string);
SG(request_info).query_string = NULL;
}
}
if (!fastcgi) {
if (benchmark) {
repeats--;
if (repeats > ) {
script_file = NULL;
php_optind = orig_optind;
php_optarg = orig_optarg;
continue;
}
}
break;
}
/* only fastcgi will get here */
requests++;
if (max_requests && (requests == max_requests)) {
fcgi_finish_request(request, );
if (bindpath) {
free(bindpath);
}
if (max_requests != ) {
/* no need to return exit_status of the last request */
exit_status = ;
}
break;
}
/* end of fastcgi loop */
}
最终会通过 php_execute_script(&file_handle TSRMLS_CC); 这个函数执行php脚本，到了这里我们可以回答我们上面的那个问题
num-procs = max-procs * ( 1 + PHP_FCGI_CHILDREN ) = 8个
本文玩，大家有什么疑问可以留言啊
参考文章 http://www.360doc.com/content/12/1027/22/834950_244161021.shtml
http://www.cppblog.com/woaidongmao/archive/2011/06/21/149101.html fast-cgi协议
http://blog.csdn.net/springfieldking/article/details/8204210 fast-cgi工作原理
