注：只要利用openssl help就可以看到更多的安全算法了。

#追加id_rsa.pub的内容到serverB的authorized_keys
#如果只有一台主机要设置，也可以用如下的命令

scp /root/.ssh/id_rsa.pub serverB:/root/.ssh/authorized_keys
#over！

#执行任务定制
#crontab-e
#增加
#*/1 * * * * sh /opt/tjsync.sh
#
#
rsync -vzrtopg –rsh=ssh root@192.168.9.107:/home/tj_/home/tj
#
rsync -vzrtopg –rsh=ssh root@192.168.3.31:/usr/bj_app/news/$(date +%Y%m%d) /opt/news
#

具体如下：
RSA * rsa = RSA_new();
RSA_free( rsa );

产生内存泄漏：

Debug for memory leaks
Detected memory leaks!
Dumping objects ->
{140} normal block at 0×003B97A0, 12 bytes long.
Data: B8 96 3B 00 00 00 00 00 06 00 00 00
{139} normal block at 0×003B9750, 16 bytes long.
Data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
{138} normal block at 0×003B9700, 20 bytes long.
Data:

00 00 00 00 50 97 3B 00 00 00 00 00 04 00 00 00
{137} normal block at 0×003B96B8, 12 bytes long.
Data: 06 00 00 00 00 97 3B 00 00 00 00 00
{136} normal block at 0×003B9638, 64 bytes long.
Data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
{135} normal block at 0×003B9598, 96 bytes long.
Data: 38 96 3B 00 C0 FD 41 00 B0 FD 41 00 08 00 00 00
Object dump complete.

解决方法很简单：

调用OpenSSL的crypto库，在退出前需要调用API “CRYPTO_cleanup_all_ex_data”，清除管理CRYPTO_EX_DATA的全局hash表中的数据，避免内存泄漏。如下：

RSA * rsa = RSA_new();
RSA_free( rsa );
CRYPTO_cleanup_all_ex_data();

这样就没有内存泄漏了。

需要注意的是，CRYPTO_cleanup_all_ex_data()不能在potential race-conditions条件在调用（不太懂这个术语，我理解的意思是当函数外部存在RSA结构体的时候，在函数内部执行CRYPTO_cleanup_all_ex_data()将导致函数外的RSA结构体也被清理掉），因此最好在程序结束的时候才调用。

关于CRYPTO_cleanup_all_ex_data()的注释说明和代码如下：

/* Release all “ex_data” state to prevent memory leaks. This can’t be made
* thread-safe without overhauling a lot of stuff, and shouldn’t really be
* called under potential race-conditions anyway (it’s for program shutdown
* after all). */
void CRYPTO_cleanup_all_ex_data(void)
{
IMPL_CHECK
EX_IMPL(cleanup)();
}

同样，其他相应的模块也需要在使用后清理：

CONF_modules_unload(1); //for conf
EVP_cleanup(); //For EVP
ENGINE_cleanup(); //for engine
CRYPTO_cleanup_all_ex_data(); //generic
ERR_remove_state(0); //for ERR
ERR_free_strings(); //for ERR

From: http://www.cnblogs.com/moonset7/archive/2009/12/30/1635770.html 月落上弦

Linux下的异步TCP socket及实例

• 同步socket通讯时，程序会阻塞在诸如(connect、accept、recv、recvfrom)等操作上，直到有事件发生时才会继续。
• 而在异步通讯交互中，两方可以任意发送消息，当有数据要接收时，会收到系统消息提示来接收数据，而不会阻塞。
• 在Linux下基于socket的异步通讯可以有多种方式，比较常用的有select方式、epoll方式和异步消息的方式。

一、 select方式：

1. 设置放置socket句柄的集合变量
2. 把要判断的socket句柄放到集合
3. 设置超时时间
4. 执行select操作
5. 根据select操作返回值做相应处理（连接、读、写等）

例子：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MYPORT i        1234        // the port users will be connecting to
#define BACKLOG         5           // how many pending connections queue will hold
#define BUF_SIZE        200

int fd_A[BACKLOG];                  // accepted connection fd
int conn_amount;                    // current connection amount

void showclient()
{
    int i;
    printf("client amount: %d\n", conn_amount);
    for (i = 0; i < BACKLOG; i++) {
        printf("[%d]:%d  ", i, fd_A[i]);
    }
    printf("\n\n");
}

int main(void)
{
    int sock_fd, new_fd;    // listen on sock_fd, new connection on new_fd
    struct sockaddr_in server_addr;     // server address information
    struct sockaddr_in client_addr;     // connector's address information
    socklen_t sin_size;
    int yes = 1;
    char buf[BUF_SIZE];
    int ret;
    int i;

    if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket");
        exit(1);
    }

    if (setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
        perror("setsockopt");
        exit(1);
    }

    server_addr.sin_family = AF_INET;         // host byte order
    server_addr.sin_port = htons(MYPORT);     // short, network byte order
    server_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
    memset(server_addr.sin_zero, '', sizeof(server_addr.sin_zero));
    if (bind(sock_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
        perror("bind");
        exit(1);
    }

    if (listen(sock_fd, BACKLOG) == -1) {
        perror("listen");
        exit(1);
    }

    printf("listen port %d\n", MYPORT);
    fd_set fdsr;
    int maxsock;
    struct timeval tv;
    conn_amount = 0;
    sin_size = sizeof(client_addr);
    maxsock = sock_fd;
    while (1) {
        // initialize file descriptor set
        FD_ZERO(&fdsr);
        FD_SET(sock_fd, &fdsr);
        // timeout setting
        tv.tv_sec = 30;
        tv.tv_usec = 0;
        // add active connection to fd set
        for (i = 0; i < BACKLOG; i++) {
            if (fd_A[i] != 0) {
                FD_SET(fd_A[i], &fdsr);
            }
        }

        ret = select(maxsock + 1, &fdsr, NULL, NULL, &tv);
        if (ret < 0) {
            perror("select");
            break;
        } else if (ret == 0) {
            printf("timeout\n");
            continue;
        }

        // check every fd in the set
        for (i = 0; i < conn_amount; i++) {
            if (FD_ISSET(fd_A[i], &fdsr)) {
                ret = recv(fd_A[i], buf, sizeof(buf), 0);
                if (ret <= 0) {        // client close
                    printf("client[%d] close\n", i);
                    close(fd_A[i]);
                    FD_CLR(fd_A[i], &fdsr);
                    fd_A[i] = 0;
                }
                else {        // receive data
                    if (ret < BUF_SIZE)
                        memset(&buf[ret], '', 1);
                    printf("client[%d] send:%s\n", i, buf);
                }
            }
        }

        // check whether a new connection comes
        if (FD_ISSET(sock_fd, &fdsr)) {
            new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &sin_size);
            if (new_fd <= 0) {
                perror("accept");
                continue;
            }

            // add to fd queue
            if (conn_amount < BACKLOG) {
                fd_A[conn_amount++] = new_fd;
                printf("new connection client[%d] %s:%d\n", conn_amount,inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                if (new_fd > maxsock)
                    maxsock = new_fd;
            }

            else {
                printf("max connections arrive, exit\n");
                send(new_fd, "bye", 4, 0);
                close(new_fd);
                break;
            }
        }
        showclient();
    }

    // close other connections
    for (i = 0; i < BACKLOG; i++) {
        if (fd_A[i] != 0) {
            close(fd_A[i]);
        }
    }
    return 0;
}

二、 epool方式

1. 用epoll_create建立epool句柄
2. 控制socket行为epoll_ctl
3. 等待socket状态处理epoll_wait

例子：

#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <iostream>

using namespace std;

#define MAX_EVENTS 500

struct myevent_s
{
    int fd;
    void (*call_back)(int fd, int events, void *arg);
    int events;
    void *arg;
    int status; // 1: in epoll wait list, 0 not in
    char buff[128]; // recv data buffer
    int len;
    long last_active; // last active time
};

// set event
void EventSet(myevent_s *ev, int fd, void (*call_back)(int, int, void*), void *arg)
{
    ev->fd = fd;
    ev->call_back = call_back;
    ev->events = 0;
    ev->arg = arg;
    ev->status = 0;
    ev->last_active = time(NULL);
}

// add/mod an event to epoll
void EventAdd(int epollFd, int events, myevent_s *ev)
{
    struct epoll_event epv = {0, {0}};
    int op;
    epv.data.ptr = ev;
    epv.events = ev->events = events;
    if(ev->status == 1){
        op = EPOLL_CTL_MOD;
    }
    else{
        op = EPOLL_CTL_ADD;
        ev->status = 1;
    }
    if(epoll_ctl(epollFd, op, ev->fd, &epv) < 0)
        printf("Event Add failed[fd=%d]\n", ev->fd);
    else
        printf("Event Add OK[fd=%d]\n", ev->fd);
}

// delete an event from epoll
void EventDel(int epollFd, myevent_s *ev)
{
    struct epoll_event epv = {0, {0}};
    if(ev->status != 1) return;
    epv.data.ptr = ev;
    ev->status = 0;
    epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv);
}

int g_epollFd;
myevent_s g_Events[MAX_EVENTS+1]; // g_Events[MAX_EVENTS] is used by listen fd
void RecvData(int fd, int events, void *arg);
void SendData(int fd, int events, void *arg);

// accept new connections from clients
void AcceptConn(int fd, int events, void *arg)
{
    struct sockaddr_in sin;
    socklen_t len = sizeof(struct sockaddr_in);
    int nfd, i;
    // accept
    if((nfd = accept(fd, (struct sockaddr*)&sin, &len)) == -1)
    {
        if(errno != EAGAIN && errno != EINTR)
        {
            printf("%s: bad accept", __func__);
        }
        return;
    }
    do
    {
        for(i = 0; i < MAX_EVENTS; i++)
        {
            if(g_Events[i].status == 0)
            {
                break;
            }
        }
        if(i == MAX_EVENTS)
        {
            printf("%s:max connection limit[%d].", __func__, MAX_EVENTS);
            break;
        }
        // set nonblocking
        if(fcntl(nfd, F_SETFL, O_NONBLOCK) < 0) break;
        // add a read event for receive data
        EventSet(&g_Events[i], nfd, RecvData, &g_Events[i]);
        EventAdd(g_epollFd, EPOLLIN|EPOLLET, &g_Events[i]);
        printf("new conn[%s:%d][time:%d]\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), g_Events[i].last_active);
    }while(0);
}

// receive data
void RecvData(int fd, int events, void *arg)
{
    struct myevent_s *ev = (struct myevent_s*)arg;
    int len;
    // receive data
    len = recv(fd, ev->buff, sizeof(ev->buff)-1, 0);
    EventDel(g_epollFd, ev);
    if(len > 0)
    {
        ev->len = len;
        ev->buff[len] = '';
        printf("C[%d]:%s\n", fd, ev->buff);
        // change to send event
        EventSet(ev, fd, SendData, ev);
        EventAdd(g_epollFd, EPOLLOUT|EPOLLET, ev);
    }
    else if(len == 0)
    {
        close(ev->fd);
        printf("[fd=%d] closed gracefully.\n", fd);
    }
    else
    {
        close(ev->fd);
        printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
    }
}

// send data
void SendData(int fd, int events, void *arg)
{
    struct myevent_s *ev = (struct myevent_s*)arg;
    int len;
    // send data
    len = send(fd, ev->buff, ev->len, 0);
    ev->len = 0;
    EventDel(g_epollFd, ev);
    if(len > 0)
    {
        // change to receive event
        EventSet(ev, fd, RecvData, ev);
        EventAdd(g_epollFd, EPOLLIN|EPOLLET, ev);
    }
    else
    {
        close(ev->fd);
        printf("recv[fd=%d] error[%d]\n", fd, errno);
    }
}

void InitListenSocket(int epollFd, short port)
{
    int listenFd = socket(AF_INET, SOCK_STREAM, 0);
    fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking
    printf("server listen fd=%d\n", listenFd);
    EventSet(&g_Events[MAX_EVENTS], listenFd, AcceptConn, &g_Events[MAX_EVENTS]);
    // add listen socket
    EventAdd(epollFd, EPOLLIN|EPOLLET, &g_Events[MAX_EVENTS]);
    // bind & listen
    sockaddr_in sin;
    bzero(&sin, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = htons(port);
    bind(listenFd, (const sockaddr*)&sin, sizeof(sin));
    listen(listenFd, 5);
}

int main(int argc, char **argv)
{
    short port = 12345; // default port
    if(argc == 2){
        port = atoi(argv[1]);
    }
    // create epoll
    g_epollFd = epoll_create(MAX_EVENTS);
    if(g_epollFd <= 0) printf("create epoll failed.%d\n", g_epollFd);
    // create & bind listen socket, and add to epoll, set non-blocking
    InitListenSocket(g_epollFd, port);
    // event loop
    struct epoll_event events[MAX_EVENTS];
    printf("server running:port[%d]\n", port);
    int checkPos = 0;
    while(1){
        // a simple timeout check here, every time 100, better to use a mini-heap, and add timer event
        long now = time(NULL);
        for(int i = 0; i < 100; i++, checkPos++) // doesn't check listen fd
        {
            if(checkPos == MAX_EVENTS) checkPos = 0; // recycle
            if(g_Events[checkPos].status != 1) continue;
            long duration = now - g_Events[checkPos].last_active;
            if(duration >= 60) // 60s timeout
            {
                close(g_Events[checkPos].fd);
                printf("[fd=%d] timeout[%d--%d].\n", g_Events[checkPos].fd, g_Events[checkPos].last_active, now);
                EventDel(g_epollFd, &g_Events[checkPos]);
            }
        }
        // wait for events to happen
        int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, 1000);
        if(fds < 0){
            printf("epoll_wait error, exit\n");
            break;
        }
        for(int i = 0; i < fds; i++){
            myevent_s *ev = (struct myevent_s*)events[i].data.ptr;
            if((events[i].events&EPOLLIN)&&(ev->events&EPOLLIN)) // read event
            {
                ev->call_back(ev->fd, events[i].events, ev->arg);
            }
            if((events[i].events&EPOLLOUT)&&(ev->events&EPOLLOUT)) // write event
            {
                ev->call_back(ev->fd, events[i].events, ev->arg);
            }
        }
    }
    // free resource
    return 0;
}

三、 异步通知

1. 定义信号处理函数
2. 设置socket的消息进程id
3. 设置socket消息
4. 信号等待和处理

例子：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/ioctl.h>

#define MAX_LENTH 1500

#define SIG_FIFO_IO SIGRTMIN+1

static char recv_buf[MAX_LENTH] = {0};

int main(int argc, char *argv[])
{
    int sockfd, on = 1;
    struct sigaction action;
    sigset_t newmask, oldmask;
    struct sockaddr_in addr;

    memset(&addr, 0, sizeof(addr));
    addr.sin_family =  AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(50001);
    if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
        perror("Create socket failed");
        exit(-1);
    }
    if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
        perror("Bind socket failed");
        exit(-1);
    }

    if (fcntl(sockfd, F_SETOWN, getpid()) == -1) {
        perror("Fcntl F_SETOWN failed");
        exit(-1);
    }
    if (fcntl(sockfd, F_SETSIG, SIG_FIFO_IO) == -1) {
        perror("Fcntl F_SETSIG failed");
        exit(-1);
    }
    if (ioctl(sockfd, FIOASYNC, &on) == -1) {
        perror("Ioctl FIOASYNC failed");
        exit(-1);
    }

    int rcvd_sig, len;
    siginfo_t info;
    sigemptyset(&newmask);
    sigaddset(&newmask, SIG_FIFO_IO);
    sigprocmask(SIG_BLOCK, &newmask, &oldmask);

    while (1) {
        rcvd_sig = sigwaitinfo(&newmask, &info);//siginfo中的_sigpool{si_band, si_fd},其中si_fd为socket的文件描述符值

        if (rcvd_sig == -1) {
            perror("sigio: sigwaitinfo");
            exit(-1);
        }
        else {
            printf("Signal %d, socket fd %d  received from socket\n",
                    rcvd_sig, info.si_fd);
            len = recv(sockfd, recv_buf, MAX_LENTH, MSG_DONTWAIT);
            if( len>0)
                puts( recv_buf);
            exit(-1);
        }
    }
    exit(0);
}

    为了父母,你需要知道患了中风，脑部的微血管，会慢慢的破裂，遇到这种情形，千万别慌，患者无论在什么地方 (不管是浴室、卧房或客厅），千万不可搬动他。因为，如果移动，会加速微血管的破裂。所以要先原地把患者扶起坐稳以防止再摔倒，这时才开始（放血）。
    家中如有专为注射用的针，当然最好。如果没有，就拿缝衣用的钢针，就在患者的十个手指头尖儿（没有固定穴道，大约距离手指甲一分之处）刺上去，要刺出血来 (万一血不出来，可用手挤），等十个手指头都流出 血来(每指一滴)，大约几分钟之后，患者就会自然清醒。如果嘴也歪了，就拉他的耳朵，把耳朵拉红，在两耳的耳垂儿的部位，各刺两针，也各流两滴血，几分钟以后，嘴就恢复原状了。 等患者一切恢复正常感觉没有异状时再送医，就一定可以转危为安，否则，若是急着抬上救护车送医，经一路的颠跛震动恐怕还没到医院，他脑部微血管，差不多已经都破裂了。
    放血救命法，是住在新竹的中医师夏伯挺先生说的。且是经自己亲身实验，敢说百分之百有效。大概是民国六十八年一位在台中逢甲学院任教的教师，有天上午正在上课，一位老师跑到他的教室上气不接下气的说∶刘老师快来，主任中风了；他立刻跑到三楼， 看到陈幅添主任，气色不正，语意模糊，嘴也歪了，很明显的是中风了。立即请工读生到校门外的西药房，买来一支注射用的针头，就在陈主任十个手指头上直刺。等十个手指尖儿都见血了（豆粒似的一滴），大约几分钟以后，陈主任的气色就变过来了，两眼也有神了，只有嘴还歪着，他就拉搓陈主任的耳朵，使之充血，等把耳朵拉红，就在左右耳垂之处，各刺两针，待两耳垂都流出两滴血来，奇迹就出现了，大约不到三五分钟，他的嘴形，恢复正常了，说话也清清楚楚了。让陈主任坐一阵子，喝了一杯热茶，才扶他下楼，开车送到惠华医院，打一罐点滴，休息了一夜，第二天就出院回学校上课了。一切照常工作，毫无后遗症。反观一般脑中风患者，都是送医院治疗时，经过一路震荡血管急速破裂，以致多数患者一病不起，所以脑中风，在死因排行榜上高居第二位，其最幸运者，也仅能保住老命，而落得终身残废。这是一个多么可怕的病症。
    如果大家都能记住这（放血救命)的方法，立刻施救，在短短时间它能起死回生，而且保证百分之百的正常。
    这个急救法，希望大家告诉大家。
哪 些 食 物 能 杀 死 体 内 癌 细 胞

1）茄子：“霜打茄子”是好药
     中药许多方剂及民间验方中，时常使用“秋后老茄子”、“霜打茄子”。越来越多证据表明，茄子具有抗癌功能。曾有试验从茄子中提取的一种无毒物质，用于治疗胃癌、子宫颈癌等收到良效。另外，茄子中含有龙葵碱、葫芦素、水苏碱、胆碱、紫苏甙、茄色甙等多种生物碱物质，其中龙葵碱、葫芦素被证实具有抗癌能力，茄花、茄蒂、茄根、茄汁皆为良药，古代就有用茄根治疗肿瘤的记载。
     茄子还含有丰富的营养成分，除维生素A、C偏低外，其他维生素和矿物质几乎跟西红柿差不多，而蛋白质和钙甚至比西红柿高3倍。
2）苦瓜：李时珍称其为“一等瓜”
     苦瓜在民间受到的待遇两极分化严重，不少人很“好”这一口，也有人对其敬而远之。但真正给它“好身份”的却是明代大医学家李时珍，他称其为“一等瓜”，是不可多得的抗癌瓜。
     西医更证明，苦瓜的抗癌功效来自一种类奎宁蛋白，它是一种能激活免疫细胞的活性蛋白，通过免疫细胞做“二传手”，将癌细胞或其他不正常的细胞杀掉。苦瓜种子中含有一种蛋白酶抑制剂，能抑制肿瘤细胞分泌蛋白酶，从而抑制癌细胞的侵袭和转移。

3）海带：可预防乳腺癌和甲状腺肿瘤
     海带中药名为“昆布”，可预防乳腺癌和甲状腺肿瘤。海带富含碘，能防“大脖子”病在中国已经妇孺皆知，实际上，海带还有其他诸多“本领”，它含的海藻酸钠与具致癌作用的锶、镉有很强的结合能力，并将它们排出体外；海带可选择性杀灭或抑制肠道内能够产生致癌物的细菌，所含的纤维还能促进胆汁酸和胆固醇的排出；海带提取物对各种癌细胞有直接抑制作用。

4）地瓜：逐渐被淡忘的抗癌佳品
     小时候冬天捧着香喷喷的烤红薯边暖手边解馋的日子已经淡出不少年轻人的记忆，过去走街串巷的卖烤红薯摊现在几乎无迹可寻，随着经济条件的好转，有调查表明，我国城镇居民不少人已不再食用地瓜。
     地瓜：别名甘薯、红薯、白薯，被认为是祛病延年、减肥保健的绝佳食品。

其实地瓜也有强大的防癌功能。最近科技人员在地瓜中发现了一种去氢表雄酮的物质，它能预防肠癌和乳腺癌的发生。

5）南瓜：被誉为“神瓜”
     在某些国家它被誉为“神瓜”，因为它既可为粮，又可为菜。美国人在感恩节都要吃南瓜，以表示对南瓜的谢意。但是，在我国，现已很少种植。
     南瓜可预防肥胖、糖尿并高血脂和高胆固醇血症，对癌症预防有很好的效果，南瓜维生素A的含量之高，是常人无法想象的。另外含有丰富的维生素C、钙质和纤维素，还含有抑制致癌物色氨酸-P的不明成分。
6）麦麸：最好的防癌食物纤维
     别名麸子，小麦磨粉时脱下的种皮，用作饲料，不食用。用麦麸喂牲口，皮肤红润，毛发油亮，极显健康状，现麦麸日益受到人们的重视，为了健康，西方不少机构号召人们吃全谷食物、全麦食物。全麦食物即把小麦全粒磨成面粉丁再分出麦麸，用这种粉制成的食品。
     麦麸是小麦主要营养成分的“仓库”，B族维生素、硒、镁等矿物质及纤维素几乎都集中在它身上。它能预防并治疗结直肠癌、糖尿并高胆固醇血症、高脂血症、便秘、痔疮等。因此，不少专家认为，麦麸是最好的防癌食物纤维。
7）萝卜：根茎类蔬菜中的“健康保护神”
     萝卜别名莱菔，品种多，皆为抗癌能手，所以有农谚：“冬吃萝卜夏吃姜，一生不用跑药堂”以及“十月萝卜水人参”之说。荷兰人定胡萝卜为“国菜”，日本、美国认为它是根茎类蔬菜中的“健康保护神”。
     萝卜具抗癌、宽胸、化痰、利尿之功能。萝卜中含有多种酶，能消除亚硝胺的致癌作用，其中的本质素能刺激肌体免疫力，提高巨噬细胞的活性，增强其吞噬杀灭癌细胞的能力。萝卜的辣味来自芥子油，它可刺激肠蠕动，促进致癌物的排除，萝卜中还含有许多抑制致突变活性的不明成分。萝卜中维生素C含量比苹果、梨高出8–10倍。而胡萝卜因含丰富的胡萝卜素，也具有极好的防癌作用。
8）猕猴桃：维生素C含量居水果之冠
     棕色，形似土豆，其内碧绿如翡翠，甘酸可口，本是南方山区野果，现在已移栽到全国各地。其果实富含糖、蛋白质、类脂、维生素、有机酸及多种矿物质。维生素C含量居水果之冠，每100克果子含200毫克，几乎是柑橘的100倍，西红柿的30倍，是名副其实的“天然维生素C片”，另外还含有丰富的具有保护血管功能的维生素P，其营养价值甚高。
高血压单方－效果：永远断根，屡试屡效治疗高血压一方

一患高血压两年之久，高压一百八十四、低压九十左右，无法工作。後食用了一个偏方，谁知吃了一副就好了。

其方是∶精选山里红三斤、生地一两、白糖适量。山里红洗净去子放不锈钢锅内煮烂，放入白糖，煮熟凉後放冰箱储藏。每天不计时食用，就像吃零食。轻者一副重者三副。
高血压秘方

药方:白胡椒7粒,南杏仁4粒,糯米7粒,桃仁2两,枝子1两。

说明（１）将上列五物研成粉末。

（２）用鸡蛋的蛋白混合后，捏成饼状。

（３）晚上睡前贴在脚底心上。男左女右，用纱布包好。

（４）第二天早晨起床后除去。（一副只能用一次）

（５）如脚上发现有青色，乃正常现象。

（６）轻者三服，重者五服，连续使用，不可隔天。

注意：此方忌口服。

效果：永远断根，屡试屡效，患者受益甚多。
降血压奇圣方–5天降血压–安全不复发

　配方：取新鲜莲藕2.5斤切碎，生芝麻1斤压碎，加冰糖1斤压碎放锅内蒸熟。取出等晾时分5等份。每天服用一份，一般5天可以降到正常血压。较重者再服5天。安全可靠。

花生全草治疗高血压

花生全草（整棵草）一次５０克，切段煎水．干品一次５０克，鲜品一次１５０克．一它一剂．血压正后可改为不定期服用．巩固疗效．

主治：清热凉血，有降血压，降胆固醇作用，对治疗高血压有较理想的功效！
花生加醋治疗高血压

花生半碗（大碗，带红衣）加上好醋慢一碗．泡上７天，每天早晚各吃１０粒．

等血压降下来后可改为几天服用一次．巩固疗效．

主治：清热活血，用治高血压，对保护血管壁，阻止血栓形成有较好的作用（高血压）

本人系转载的 不知此方效果如何 请你咨询后再用 祝福您健康快乐！

减肥：红绿豆粥 2周减18斤
　　有人只坚持了两个星期，体重就从12月初的54公斤变成了现在的46公斤……

　　材料：红豆100克，绿豆100克，山楂30克，大枣10枚

　　做法：将所有材料共放在锅中，加1000毫升冷水，煎到豆烂即可。

　　(温馨提示：红豆和绿豆煮之前最好用冷水泡一个小时，会比较容易煮烂的)

　　食用方法：做好后，分两等份，一份趁热时，连汤带豆和山楂，枣一起吃下。另外一份就用保鲜膜包好放冰箱中冷藏。

　　温馨提示：具体的克数去买的时候请人家帮你称下，看看100克大概有多少，回来就好办了，有点误差不要紧的

　　注意：要趁热时吃，效果才最好。另外一份吃之前热下就可以了。

　　原理：红豆，绿豆都是排毒圣品，并且有高纤维低脂肪的特点。山楂健脾开胃，消食减脂。红枣调和胃气补血润燥。此方共用，有助各种单品的功效最大限度的发挥。

　　其实，每次食用只是这个半份的量（就是红豆50克，绿豆50克，生山楂15克，大枣5枚），但我自己为了省事，每天晚上煎好，分两等份，一份晚上吃，另外一份留第二天早上吃！

　　为了获得更好的效果，在减肥期间，您的生活要严格遵守如下日程安排：

　　首先：每天早上起床后的第一件事就是喝一杯蜜醋水，就是在250毫升的温开水中加入一汤匙蜂蜜和1/4汤匙的醋(最好是白醋)，搅拌均匀后喝下。蜜醋水可以充分清洗肠胃，加速胃肠的蠕动，将体内的毒素更快更完全的排除。早饭就是上面那个减肥汤。

　　其次：除了这个减肥粥，上下午的时光不吃任何零食。

　　最后：晚上也只是吃上面那个减肥粥，并且保证在7点之前吃完，吃完后睡觉前也绝不吃任何东西。

　　就这样，有人只坚持了两个星期，体重就从12月初的54公斤变成了现在的46公斤。还有一个好消息要告诉JMS，我用这个方减肥成功后，不仅没有因为迅速瘦下来皮肤变得暗淡无光泽，而且肌肤变的比以前好红润清透，青春痘也少了，真是一举多得！

　　最后的温馨提示：很多朋友都对午饭什么都不吃有点打怵。其实饮食控制是任何减肥方都需要，但怎么控制也是有讲究的。如何控制取决于你想要达到的效果，这个可以根据自己的实际情况灵活掌握和安排的，不是绝对的。

索性用VC写了几行代码，实现了批处理的功能，执行文件是一个命令行下的命令，32位windows系统用，用法是：

mv 旧文件名

例如：执行 “mv output.log” ，自动把output.log改名为output_201105181101.log，保留扩展名，在文件名后加上时间串。

下载地址：http://u.115.com/file/clwpo7g6#mv.rar

@echo off
set OLDFILE=aaa.txt
set FILENAME=%date:~0,4%%date:~5,2%%date:~8,2%_%time:~0,2%%time:~3,2%.txt
@echo on
echo %OLDFILE%
echo %FILENAME%
ren %OLDFILE% %FILENAME%

1. 前言:
有的程序可以通过编译, 但在运行时会出现Segment fault(段错误). 这通常都是指针错误引起的.
但这不像编译错误一样会提示到文件->行, 而是没有任何信息, 使得我们的调试变得困难起来.

2. gdb:
有一种办法是, 我们用gdb的step, 一步一步寻找.
这放在短小的代码中是可行的, 但要让你step一个上万行的代码, 我想你会从此厌恶程序员这个名字, 而把他叫做调试员.
我们还有更好的办法, 这就是core file.

3. ulimit:
如果想让系统在信号中断造成的错误时产生core文件, 我们需要在shell中按如下设置:
#设置core大小为无限
ulimit -c unlimited
#设置文件大小为无限
ulimit unlimited

这些需要有root权限, 在ubuntu下每次重新打开中断都需要重新输入上面的第一条命令, 来设置core大小为无限.

4. 用gdb查看core文件:
下面我们可以在发生运行时信号引起的错误时发生core dump了.
发生core dump之后, 用gdb进行查看core文件的内容, 以定位文件中引发core dump的行.
gdb [exec file] [core file]
如:
gdb ./test test.core
在进入gdb后, 用bt命令查看backtrace以检查发生程序运行到哪里, 来定位core dump的文件->行.

5. 用gdb实时观察某进程crash信息
启动进程
gdb -p PID
c
运行进程至crash
gdb会显示crash信息
bt

简而言之,产生段错误就是访问了错误的内存段，一般是你没有权限，或者根本就不存在对应的物理内存,尤其常见的是访问0地址.

一般来说,段错误就是指访问的内存超出了系统所给这个程序的内存空间，通常这个值是由gdtr来保存的，他是一个48位的寄存器，其中的32位是保存由它 指向的 gdt表，后13位保存相应于gdt的下标，最后3位包括了程序是否在内存中以及程序的在cpu中的运行级别,指向的gdt是由以64位为一个单位的表， 在这张表中就保存着程序运行的代码段以及数据段的起始地址以及与此相应的段限和页面交换还有程序运行级别还有内存粒度等等的信息。一旦一个程序发生了越界 访问，cpu就会产生相应的异常保护，于是segmentation fault就出现了.

在编程中以下几类做法容易导致段错误,基本是是错误地使用指针引起的

1)访问系统数据区，尤其是往 系统保护的内存地址写数据
最常见就是给一个指针以0地址
2)内存越界(数组越界，变量类型不一致等) 访问到不属于你的内存区域

解决方法

我 们在用C/C++语言写程序的时侯，内存管理的绝大部分工作都是需要我们来做的。实际上，内存管理是一个比较繁琐的工作，无论你多高明，经验多 丰富，难免会在此处犯些小错误，而通常这些错误又是那么的浅显而易于消除。但是手工“除虫”（debug），往往是效率低下且让人厌烦的，本文将就”段错 误”这个内存访问越界的错误谈谈如何快速定位这些”段错误”的语句。
下面将就以下的一个存在段错误的程序介绍几种调试方法：
1 dummy_function (void)
2 {
3 unsigned char *ptr = 0×00;
4 *ptr = 0×00;
5 }
6
7 int main (void)
8 {
9 dummy_function ();
10
11 return 0;
12 }
作为一个熟练的C/C++程序员，以上代码的bug应该是很清楚的，因为它尝试操作地址为0的内存区域，而这个内存区域通常是不可访问的禁区，当然就会出错了。我们尝试编译运行它:
xiaosuo@gentux test $ ./a.out
段错误
果然不出所料，它出错并退出了。
1.利用gdb逐步查找段错误:
这种方法也是被大众所熟知并广泛采用的方法，首先我们需要一个带有调试信息的可执行程序，所以我们加上“-g -rdynamic”的参数进行编译，然后用gdb调试运行这个新编译的程序,具体步骤如下:
xiaosuo@gentux test $ gcc -g -rdynamic d.c
xiaosuo@gentux test $ gdb ./a.out
GNU gdb 6.5
Copyright (C) 2006 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type “show copying” to see the conditions.
There is absolutely no warranty for GDB. Type “show warranty” for details.
This GDB was configured as “i686-pc-linux-gnu”…Using host libthread_db library “/lib/libthread_db.so.1″.

(gdb) r
Starting program: /home/xiaosuo/test/a.out

Program received signal SIGSEGV, Segmentation fault.
0×08048524 in dummy_function () at d.c:4
4 *ptr = 0×00;
(gdb)
哦？！好像不用一步步调试我们就找到了出错位置d.c文件的第4行，其实就是如此的简单。
从这里我们还发现进程是由于收到了SIGSEGV信号而结束的。通过进一步的查阅文档(man 7 signal)，我们知道SIGSEGV默认handler的动作是打印”段错误”的出错信息，并产生Core文件，由此我们又产生了方法二。
2.分析Core文件：
Core文件是什么呢？
The default action of certain signals is to cause a process to terminate and produce a core dump file, a disk file containing an image of the process’s memory at the time of termination. A list of the signals which cause a process to dump core can be found in signal(7).
以 上资料摘自man page(man 5 core)。不过奇怪了，我的系统上并没有找到core文件。后来，忆起为了渐少系统上的拉圾文件的数量（本人有些洁癖，这也是我喜欢Gentoo的原因 之一），禁止了core文件的生成，查看了以下果真如此，将系统的core文件的大小限制在512K大小，再试:
xiaosuo@gentux test $ ulimit -c
0
xiaosuo@gentux test $ ulimit -c 1000
xiaosuo@gentux test $ ulimit -c
1000
xiaosuo@gentux test $ ./a.out
段错误 (core dumped)
xiaosuo@gentux test $ ls
a.out core d.c f.c g.c pango.c test_iconv.c test_regex.c
core文件终于产生了，用gdb调试一下看看吧:
xiaosuo@gentux test $ gdb ./a.out core
GNU gdb 6.5
Copyright (C) 2006 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type “show copying” to see the conditions.
There is absolutely no warranty for GDB. Type “show warranty” for details.
This GDB was configured as “i686-pc-linux-gnu”…Using host libthread_db library “/lib/libthread_db.so.1″.

warning: Can’t read pathname for load map: 输入/输出错误.
Reading symbols from /lib/libc.so.6…done.
Loaded symbols for /lib/libc.so.6
Reading symbols from /lib/ld-linux.so.2…done.
Loaded symbols for /lib/ld-linux.so.2
Core was generated by `./a.out’.
Program terminated with signal 11, Segmentation fault.
#0 0×08048524 in dummy_function () at d.c:4
4 *ptr = 0×00;
哇，好历害，还是一步就定位到了错误所在地，佩服一下Linux/Unix系统的此类设计。
接着考虑下去，以前用windows系统下的ie的时侯，有时打开某些网页，会出现“运行时错误”，这个时侯如果恰好你的机器上又装有windows的编译器的话，他会弹出来一个对话框，问你是否进行调试，如果你选择是，编译器将被打开，并进入调试状态，开始调试。
Linux下如何做到这些呢？我的大脑飞速地旋转着，有了，让它在SIGSEGV的handler中调用gdb，于是第三个方法又诞生了:
3.段错误时启动调试:
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>

void dump(int signo)
{
char buf[1024];
char cmd[1024];
FILE *fh;

snprintf(buf, sizeof(buf), “/proc/%d/cmdline”, getpid());
if(!(fh = fopen(buf, “r”)))
exit(0);
if(!fgets(buf, sizeof(buf), fh))
exit(0);
fclose(fh);
if(buf[strlen(buf) - 1] == ‘\n’)
buf[strlen(buf) - 1] = ”;
snprintf(cmd, sizeof(cmd), “gdb %s %d”, buf, getpid());
system(cmd);

exit(0);
}

void
dummy_function (void)
{
unsigned char *ptr = 0×00;
*ptr = 0×00;
}

int
main (void)
{
signal(SIGSEGV, &dump);
dummy_function ();

return 0;
}
编译运行效果如下:
xiaosuo@gentux test $ gcc -g -rdynamic f.c
xiaosuo@gentux test $ ./a.out
GNU gdb 6.5
Copyright (C) 2006 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type “show copying” to see the conditions.
There is absolutely no warranty for GDB. Type “show warranty” for details.
This GDB was configured as “i686-pc-linux-gnu”…Using host libthread_db library “/lib/libthread_db.so.1″.

Attaching to program: /home/xiaosuo/test/a.out, process 9563
Reading symbols from /lib/libc.so.6…done.
Loaded symbols for /lib/libc.so.6
Reading symbols from /lib/ld-linux.so.2…done.
Loaded symbols for /lib/ld-linux.so.2
0xffffe410 in __kernel_vsyscall ()
(gdb) bt
#0 0xffffe410 in __kernel_vsyscall ()
#1 0xb7ee4b53 in waitpid () from /lib/libc.so.6
#2 0xb7e925c9 in strtold_l () from /lib/libc.so.6
#3 0×08048830 in dump (signo=11) at f.c:22
#4 <signal handler called>
#5 0×0804884c in dummy_function () at f.c:31
#6 0×08048886 in main () at f.c:38
怎么样？是不是依旧很酷？
以 上方法都是在系统上有gdb的前提下进行的，如果没有呢？其实glibc为我们提供了此类能够dump栈内容的函数簇，详见 /usr/include/execinfo.h（这些函数都没有提供man page，难怪我们找不到），另外你也可以通过gnu的手册进行学习。
4.利用backtrace和objdump进行分析:
重写的代码如下:
#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

/* A dummy function to make the backtrace more interesting. */
void
dummy_function (void)
{
unsigned char *ptr = 0×00;
*ptr = 0×00;
}

void dump(int signo)
{
void *array[10];
size_t size;
char **strings;
size_t i;

size = backtrace (array, 10);
strings = backtrace_symbols (array, size);

printf (“Obtained %zd stack frames.\n”, size);

for (i = 0; i < size; i++)
printf (“%s\n”, strings[i]);

free (strings);

exit(0);
}

int
main (void)
{
signal(SIGSEGV, &dump);
dummy_function ();

return 0;
}
编译运行结果如下：
xiaosuo@gentux test $ gcc -g -rdynamic g.c
xiaosuo@gentux test $ ./a.out
Obtained 5 stack frames.
./a.out(dump+0×19) [0x80486c2]
[0xffffe420]
./a.out(main+0×35) [0x804876f]
/lib/libc.so.6(__libc_start_main+0xe6) [0xb7e02866]
./a.out [0x8048601]
这次你可能有些失望,似乎没能给出足够的信息来标示错误,不急,先看看能分析出来什么吧,用objdump反汇编程序,找到地址0×804876f对应的代码位置:
xiaosuo@gentux test $ objdump -d a.out

8048765: e8 02 fe ff ff call 804856c <signal@plt>
804876a: e8 25 ff ff ff call 8048694 <dummy_function>
804876f: b8 00 00 00 00 mov $0×0,%eax
8048774: c9 leave
我们还是找到了在哪个函数(dummy_function)中出错的,信息虽然不是很完整,不过有总比没有好的啊!   ]]> http://blog.donews.com/miman/archive/2011/04/28/1565872.aspx/feed 1