strncpy和snprintf

[| 不指定 2012/02/29 19:06]
    之前用strncpy总是感觉比较恶,老是要考虑最后\0的问题,今天仔细看了下,发现如果源串长度大于等于最大长度的话,strncpy会直接拷贝最大长度,不在后面加\0,也就是说在用一个字符串覆盖另一个字符串一部分的时候用strncpy是很不错的,但全覆盖的话比较麻烦,很容易出bug。
    而snprintf会拷贝最大长度-1的字符数,并在后面加\0,使用一个字符串覆盖另一个时很不错。
    看了一下资料,发现snprintf的效率也要高于strncpy。
    日常字符串拷贝还是推荐snprintf。
Tags: ,
    最近有一个困扰近两个月的bug终于解决了,心情愉快。503问题之前一直没找到头绪,压力一大就开始有,越大就越多。刚开始一直认为503是正常现象,后端负载能力不足的必然结果。加之之前后端用的自己写的模拟server,性能什么的没什么保证。所以一直在看是不是程序逻辑上有什么漏洞会导致封禁所有后端,一直找不到头绪。

    周五测试同学突然说:现在用的后端server肯定能力要强于前边这个啊,怎么可能会因为负载力不足导致503呢?一想确实啊,肯定是流量调度部分的问题。开gdb仔细一找,结果大跌眼镜,原来是跟后端的连接池的最大允许并发连接数开的太小了。。

    之前那个值设置的比较小是有道理的,因为php是每个进程处理一个请求的,所以并发数肯定不会超过启动的php进程数。但现在后端改用了lighttpd,lighttpd可以承载的并发数是很多的,这样的话在高并发请求的情况下后端连接池很容易就用完了。

    由此有两个感触,一是不同场景下配置项一定要仔细想想如何调优。二是bug并不都是逻辑错误导致的,还有可能是配置错了。。。。
Tags:
    今天qa说http请求host字段最后以"."结尾时会有问题,看了下发现lighttpd自动把点号去掉了,试了试nginx,也是这样。查了很多rfc,没找到为什么,跑到群里问,有人说是根域的问题,回想起来配dns的cname记录时,最后必须是有“点”结尾的,于是搜索了下。原来真正完整的域名最后是带点的,com、net、cn这都是顶级域名,点后面的“”是根域名。dns解析最顶部是找到根域,然后再找顶级域。之前以为com就是根域,由跟域名服务器解析。现在看是错的
Tags: , ,

lighttpd的超时参数详解

[| 不指定 2012/02/14 21:00]
Lighttpd配置中,关于超时的参数有如下几个(篇幅考虑,只写读超时,写超时参数同理):


server.max-keep-alive-idle = 5
server.max-read-idle = 60
server.read-timeout = 0
server.max-connection-idle = 360


这几个参数意思相近,配置的时候很容易搞混。




对于一个keep-alive连接上的连续请求,发送第一个请求内容的最大间隔由参数max-read-idle决定,从第二个请求起,发送请求内容的最大间隔由参数max-keep-alive-idle决定。请求间的间隔超时也由max-keep-alive-idle决定。发送请求内容的总时间超时由参数read-timeout决定。Lighttpd与后端交互数据的超时由max-connection-idle决定。



例子:


下面是模拟客户端代码:


$fp = fsockopen("127.0.0.1", 8902, $errno, $errstr, 30);

fwrite($fp, "GET / HTTP/1.1\r\n");
sleep(3);                                             //$1这个时间必须小于max-read-idle,否则会超时
fwrite($fp, "Host: a.com\r\n");
sleep(3);                                             //$2这个时间必须小于max-read-idle,否则会超时。且$1+$2时间之和必须小于read-timeout,否则超时
fwrite($fp, "Connection: Keep-Alive\r\n\r\n");
echo fread($fp, 1024);



sleep(7);                                             //$3 这个时间必须小于max-keep-alive-idle,否则超时



fwrite($fp, "GET / HTTP/1.1\r\n");
fwrite($fp, "Host: a.com\r\n");
sleep(15);                                           //$4  这个时间必须小于max-keep-alive-idle,否则超时,可以大于max-read-idle,但仍然不能超过read-timeout
fwrite($fp, "Connection: Keep-Alive\r\n\r\n");
echo fread($fp, 1024);
fclose($fp);

                                                  //以上时间均不受max-connection-idle限制


下面是模拟后端server代码:



$sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
if($sock == NULL)
{
    echo "can't create socket";
    exit;
}
if(!socket_bind($sock, "0.0.0.0", 8904))
{
    echo "can't bind socket";
    exit;
}
socket_listen($sock, 100);

while(1)
{
    if($new_conn = socket_accept($sock))
    {  
        $recv = socket_read($new_conn, 100000);
        //echo $recv;
        echo "begin sleep\n";
        sleep(10);                                                                                  //这个时间必须小于max-connection-idle,否则会超时
        echo "end sleep\n";
        socket_write($new_conn, "HTTP/1.1 200 OK\r\nDate: Tue, 01 Nov 2011 05:58:25 GMT\r\nServer: TestServer/1.0\r\nContent-Length: 1\r\nContent-Type: text/html;charset=gb2312\r\nConnection: Keep-Alive\r\n\r\na");
    }
    else
    {
        echo "accept failed!";
    }
}




下面是lighttpd中关于这几个参数实现的代码:

if (con->recv->is_closed) {                                                                        
                                                                 if (srv->cur_ts - con->read_idle_ts > con->conf.max_connection_idle) {                                              //对于客户端已经发送完请求数据的情况下,超时时间max-connection-idle
                                                                           /* time - out */
#if 1
                                                                           WARNING("(connection process timeout) [%s]", SAFE_BUF_STR(con->dst_addr_buf));
#endif
                                                                           connection_set_state(srv, con, CON_STATE_ERROR);
                                                                           changed = 1;
                                                                 }
                                                        }
                                                        else {

                                                                 if (con->request_count == 1) {                  
                                                                           if (srv->cur_ts - con->read_idle_ts > con->conf.max_read_idle) {                                              //对于第一个请求,发送的数据最大时间间隔:max_read_idle
                                                                                    /* time - out */
#if 1
                                                                                    if (con->conf.log_timeouts) {
                                                                                             WARNING("(initial read timeout) [%s]", SAFE_BUF_STR(con->dst_addr_buf));
                                                                                    }
#endif
                                                                                    connection_set_state(srv, con, CON_STATE_ERROR);
                                                                                    changed = 1;
                                                                           }
                                                                 } else {                                                                                               //从第二个请求开始,发送的数据最大时间间隔:keep_alive_idle
                                                                           if (srv->cur_ts - con->read_idle_ts > con->keep_alive_idle) {
                                                                                    /* time - out */
#if 1
                                                                                    if (con->conf.log_timeouts) {
                                                                                             DEBUG("(keep-alive read timeout) [%s]", SAFE_BUF_STR(con->dst_addr_buf));
                                                                                    }
#endif
                                                                                    connection_set_state(srv, con, CON_STATE_ERROR);
                                                                                    changed = 1;
                                                                           }
                                                                 }

                                                                 if (con->conf.read_timeout > 0 && con->read_start_ts > 0)                                                    //在read_timeout设置不为0的情况下,发送数据的最大总时间:read_timeout
                                                                 {
                                                                           used_time = srv->cur_ts - con->read_start_ts;
                                                                           if (used_time > con->conf.read_timeout)
                                                                           {
                                                                                    WARNING ("read timeout, client[%s], time=%lu",
                                                                                             SAFE_BUF_STR(con->dst_addr_buf), used_time);
                                                                                    connection_set_state(srv, con, CON_STATE_ERROR);
                                                                                    changed = 1;
                                                                           }
                                                                 }
                                                        }
    今天程序出了一个core,是strcmp的时候有一个参数没有判断为NULL导致的,当我编写了一个小程序:

引用
#include
int main()
{
strcmp(NULL, "“);
return 1;
}

测试的时候发现程序跑的毫无问题。
编译参数是gcc -g -O0,没有开任何优化。

gdb进去后发现strcmp根本没有被执行,改成int a = strcmp(NULL, "");后,出core了。

看来编译器默认还是提供一定优化的。

另外需要注意strcmp不会检查参数(效率考虑),所以需要自己检查。

run-parts命令的用法及原理

[| 不指定 2012/02/01 22:10]
    在很多系统中,用户目录下都有cron.daily之类的文件夹,里面的可执行文件每天都会被执行一次。也就是说如果想添加一个每天都被执行的任务的话,在目录下放置该任务的脚本即可。使用很方便,原理是什么呢,就是run-parts命令。

    在centos5下,run-parts命令位于/usr/bin/run-parts,内容是很简单的一个shell脚本,就是遍历目标文件夹,执行第一层目录下的可执行权限的文件。
    

#!/bin/bash

# run-parts - concept taken from Debian

# keep going when something fails
set +e

if [ $# -lt 1 ]; then
    echo "Usage: run-parts <dir>"
    exit 1
fi

if [ ! -d $1 ]; then
    echo "Not a directory: $1"
    exit 1
fi

# Ignore *~ and *, scripts
for i in $1/*[^~,] ; do
    [ -d $i ] && continue
    # Don't run *.{rpmsave,rpmorig,rpmnew,swp} scripts
    [ "${i%.rpmsave}" != "${i}" ] && continue
        [ "${i%.rpmorig}" != "${i}" ] && continue
        [ "${i%.rpmnew}" != "${i}" ] && continue
        [ "${i%.swp}" != "${i}" ] && continue
    [ "${i%,v}" != "${i}" ] && continue

    if [ -x $i ]; then
        $i 2>&1 | awk -v "progname=$i" \
                  'progname {
                   print progname ":\n"
                   progname="";
                   }
                   { print; }'
    fi
done

exit 0

     在ubuntu下,该文件位于/bin/run-parts,是个二进制文件,功能更为强大,支持--test等参数。
Tags:
分页: 1/1 第一页 1 最后页 [ 显示模式: 摘要 | 列表 ]