C++博客-天下-随笔分类-Linux编程

linux pipe的缓冲区大小限制测试

天下 — Mon, 24 Mar 2014 07:45:00 GMT

linux pipe的缓冲区大小限制测试
pipe()创建管道、采用默认方式的方式，即默认阻塞模式。
平台：
uname -a
Linux develop 2.6.25-14.fc9.i686 #1 SMP Thu May 1 06:28:41 EDT 2008 i686 i686 i386 GNU/Linux
三个概念：
1、页缓冲区大小：4K
2、总缓冲区大小：64K

1、<4K的数据立即发送，以页为单位
2、>4K的数据，将会分成多个页的数据，分批发送。

函数 write要么阻塞，要么成功（copy全部数据到内核缓冲区，不存在只copy部分数据的情况），异常换回-1

天下 2014-03-24 15:45 发表评论

socket服务端select模式+管道+多线程，select可以替换为epoll

天下 — Mon, 24 Mar 2014 02:35:00 GMT

#include "stdafx.h"

using namespace std;

#define PORT 5006   /* Port that will be opened */
#define BACKLOG 5   /* Number of allowed connections */
#define MAXDATASIZE 4096

typedef map<unsigned int,sockaddr_in> socket_maptable_t;
bool process_client(int sockfd,sockaddr_in addr,char* recvbuf, int len);

socket_maptable_t socket_maptable;
int fds[2];

void* dispatch_thread(void *arg)
{
    char buf[MAXDATASIZE];
    arg = NULL;
    pr_debug("fds[0]:%d,fds[1]:%d",fds[0],fds[1]);
    while (1)
    {
        int readed = read(fds[0],buf,MAXDATASIZE);
        pr_debug("readed:%d\r\n%s",readed,buf);
    }
}

int main()
{
    int sock_fd;
    ssize_t recv_size;
    fd_set read_set;
    fd_set all_set;
    int listen_fd;
    int connect_fd;
    int ready_size;
    socklen_t addr_size;
    sockaddr_in srv_addr;
    sockaddr_in addr;
    unsigned int max_fd = 0;
    int errcode;

    char recv_buf[MAXDATASIZE];

    if ((listen_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        pr_debug("Creating socket failed.");
        exit(1);
    }

    int opt = SO_REUSEADDR;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    bzero(&srv_addr,sizeof(srv_addr));
    srv_addr.sin_family=AF_INET;
    srv_addr.sin_port=htons(PORT);
    srv_addr.sin_addr.s_addr = htonl (INADDR_ANY);
    if (bind(listen_fd, (struct sockaddr *)&srv_addr, sizeof(struct sockaddr)) == -1)
    {
        pr_debug("Bind error.");
        exit(1);
    }

    if(listen(listen_fd,BACKLOG) == -1)
    {
        pr_debug("listen() error\n");
        exit(1);
    }

    //创建管道
    errcode = pipe(fds);
    if (errcode < 0)
    {
        pr_debug("pipe() error");
        return -1;
    }
    pr_debug("pipe() succeed,fds[0]:%d,fds[1]:%d",fds[0],fds[1]);

    //创建接收连接线程
    pthread_t dispatch_tid;
    if (pthread_create(&dispatch_tid, NULL, dispatch_thread, (void*)NULL))
    {
        pr_debug("pthread_create() dispatch_thread error");
        return -1;
    }
    pr_debug("pthread_create() dispatch_thread succeed");

    max_fd = listen_fd;
    addr_size=sizeof(sockaddr_in);

    FD_ZERO(&all_set);
    FD_SET(listen_fd, &all_set);

    socket_maptable_t::iterator iter;


    while(1)
    {
        read_set = all_set;
        ready_size = select(max_fd+1, &read_set, NULL, NULL, NULL);
        if ( FD_ISSET(listen_fd,&read_set) ) {
            connect_fd = accept(listen_fd,(struct sockaddr *)&addr,&addr_size);
            if (connect_fd ==-1 ) {
                pr_debug("accept() error\n");
                continue;
            }
            socket_maptable[connect_fd]  = addr;
            max_fd = connect_fd;
            FD_SET(connect_fd, &all_set);
            pr_debug("(%u) %s:%d connected,socket:%u",socket_maptable.size(),inet_ntoa(addr.sin_addr),ntohs(addr.sin_port),connect_fd);
        }

        for ( iter = socket_maptable.begin(); iter!=socket_maptable.end(); iter++)
        {
            sock_fd = iter->first;
            addr = iter->second;
            if ( FD_ISSET(sock_fd,&read_set) )
            {
                recv_size = recv(sock_fd, recv_buf, MAXDATASIZE,0);
                bool bRet = (recv_size > 0);
                bRet = bRet && process_client(sock_fd,addr,recv_buf,recv_size);
                if ( !bRet)
                {
                    close(sock_fd);
                    FD_CLR(sock_fd, &all_set);
                    socket_maptable.erase(sock_fd);
                    pr_debug("%s:%d disconnected\n",inet_ntoa(addr.sin_addr),ntohs(addr.sin_port) );
                }
            }
        }
    }
    close(listen_fd);
}

bool process_client(int sockfd,sockaddr_in addr,char* recvbuf, int len)
{
    int writed = write(fds[1],recvbuf,len);
    pr_debug("datalen:%d,writed:%d",len,writed);
    return (writed==len);
    return true;
}

天下 2014-03-24 10:35 发表评论

epoll中的LT和ET

天下 — Fri, 21 Mar 2014 09:24:00 GMT

LT让我想起了linux内核的中断处理，设置中断触发标志

电平触发，就是只有高电平（或者低电平）的时候才做指定的事，
边沿触发，就是有高电平向低电平转换，或者翻过来转换，这个转换过程触发一个动作。

电平就是逻辑上的0，1触发，
而边沿就是脉冲突变触发，逻辑上就是0－1或是1－0  也就是上楼的那位表示的

通俗点讲吧
电平就是电压，高电平就是高电压，低电平就是低电压
高电平触发就是当电压为高时触发
边沿触发就是当电压由高变低或由低变高时触发
上升沿触发  就是当电压从低变高时触发
下降沿触发  就是当电压从高变低时触发


转个epoll的例子
http://www.cppblog.com/API/archive/2013/12/01/204535.html

#include <iostream>
#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 <pthread.h>

#include <errno.h>

#define MAXLINE 10
#define OPEN_MAX 100
#define LISTENQ 20
#define SERV_PORT 8006
#define INFTIM 1000

//线程池任务队列结构体

struct task{
  int fd; //需要读写的文件描述符

  struct task *next; //下一个任务

};

//用于读写两个的两个方面传递参数

struct user_data{
  int fd;
  unsigned int n_size;
  char line[MAXLINE];
};

//线程的任务函数

void * readtask(void *args);
void * writetask(void *args);

//声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件

struct epoll_event ev,events[20];
int epfd;
pthread_mutex_t mutex;
pthread_cond_t cond1;
struct task *readhead=NULL,*readtail=NULL,*writehead=NULL;

void setnonblocking(int sock)
{
     int opts;
     opts=fcntl(sock,F_GETFL);
     if(opts<0)
     {
          perror("fcntl(sock,GETFL)");
          exit(1);
     }
    opts = opts|O_NONBLOCK;
     if(fcntl(sock,F_SETFL,opts)<0)
     {
          perror("fcntl(sock,SETFL,opts)");
          exit(1);
     }
}

int main()
{
     int i, maxi, listenfd, connfd, sockfd,nfds;
     pthread_t tid1,tid2;

     struct task *new_task=NULL;
     struct user_data *rdata=NULL;
     socklen_t clilen;

     pthread_mutex_init(&mutex,NULL);
     pthread_cond_init(&cond1,NULL);
     //初始化用于读线程池的线程

     pthread_create(&tid1,NULL,readtask,NULL);
     pthread_create(&tid2,NULL,readtask,NULL);

     //生成用于处理accept的epoll专用的文件描述符

     epfd=epoll_create(256);

     struct sockaddr_in clientaddr;
     struct sockaddr_in serveraddr;
     listenfd = socket(AF_INET, SOCK_STREAM, 0);
     //把socket设置为非阻塞方式

     setnonblocking(listenfd);
     //设置与要处理的事件相关的文件描述符

     ev.data.fd=listenfd;
     //设置要处理的事件类型

     ev.events=EPOLLIN|EPOLLET;
     //注册epoll事件

     epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);

     bzero(&serveraddr, sizeof(serveraddr));
     serveraddr.sin_family = AF_INET;
     serveraddr.sin_port=htons(SERV_PORT);
     serveraddr.sin_addr.s_addr = INADDR_ANY;
     bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));
     listen(listenfd, LISTENQ);

     maxi = 0;
     for ( ; ; ) {
          //等待epoll事件的发生

          nfds=epoll_wait(epfd,events,20,500);
          //处理所发生的所有事件

        for(i=0;i<nfds;++i)
        {
               if(events[i].data.fd==listenfd)
               {

                    connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);
                    if(connfd<0){
                      perror("connfd<0");
                      exit(1);
                   }
                    setnonblocking(connfd);

                    char *str = inet_ntoa(clientaddr.sin_addr);
                    //std::cout<<"connec_ from >>"<
                    //设置用于读操作的文件描述符

                    ev.data.fd=connfd;
                    //设置用于注测的读操作事件

                 ev.events=EPOLLIN|EPOLLET;
                    //注册ev

                 epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
               }
            else if(events[i].events&EPOLLIN)
            {
                    //printf("reading!/n");

                    if ( (sockfd = events[i].data.fd) < 0) continue;
                    new_task=new task();
                    new_task->fd=sockfd;
                    new_task->next=NULL;
                    //添加新的读任务

                    pthread_mutex_lock(&mutex);
                    if(readhead==NULL)
                    {
                      readhead=new_task;
                      readtail=new_task;
                    }
                    else
                    {
                     readtail->next=new_task;
                      readtail=new_task;
                    }
                   //唤醒所有等待cond1条件的线程

                    pthread_cond_broadcast(&cond1);
                    pthread_mutex_unlock(&mutex);
              }
               else if(events[i].events&EPOLLOUT)
               {
                 /*
              rdata=(struct user_data *)events[i].data.ptr;
                 sockfd = rdata->fd;
                 write(sockfd, rdata->line, rdata->n_size);
                 delete rdata;
                 //设置用于读操作的文件描述符
                 ev.data.fd=sockfd;
                 //设置用于注测的读操作事件
               ev.events=EPOLLIN|EPOLLET;
                 //修改sockfd上要处理的事件为EPOLIN
               epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
             */
               }

          }

     }
}

static int count111 = 0;
static time_t oldtime = 0, nowtime = 0;
void * readtask(void *args)
{

   int fd=-1;
   unsigned int n;
   //用于把读出来的数据传递出去

   struct user_data *data = NULL;
   while(1){

        pthread_mutex_lock(&mutex);
        //等待到任务队列不为空

        while(readhead==NULL)
             pthread_cond_wait(&cond1,&mutex);

        fd=readhead->fd;
        //从任务队列取出一个读任务

        struct task *tmp=readhead;
        readhead = readhead->next;
        delete tmp;
        pthread_mutex_unlock(&mutex);
        data = new user_data();
        data->fd=fd;

        char recvBuf[1024] = {0};
        int ret = 999;
        int rs = 1;

        while(rs)
        {
            ret = recv(fd,recvBuf,1024,0);// 接受客户端消息

            if(ret < 0)
            {
                //由于是非阻塞的模式,所以当errno为EAGAIN时,表示当前缓冲区已无数据可//读在这里就当作是该次事件已处理过。

                if(errno == EAGAIN)
                {
                    printf("EAGAIN\n");
                    break;
                }
                else{
                    printf("recv error!\n");

                    close(fd);
                    break;
                }
            }
            else if(ret == 0)
            {
                // 这里表示对端的socket已正常关闭.

                rs = 0;
            }
            if(ret == sizeof(recvBuf))
                rs = 1; // 需要再次读取

            else
                rs = 0;
        }
        if(ret>0){

        //-------------------------------------------------------------------------------

            data->n_size=n;

            count111 ++;

            struct tm *today;
            time_t ltime;
            time( &nowtime );

            if(nowtime != oldtime){
                printf("%d\n", count111);
                oldtime = nowtime;
                count111 = 0;
            }

            char buf[1000] = {0};
            sprintf(buf,"HTTP/1.0 200 OK\r\nContent-type: text/plain\r\n\r\n%s","Hello world!\n");
            send(fd,buf,strlen(buf),0);
            close(fd);

       }
   }
}

天下 2014-03-21 17:24 发表评论

epoll使用

天下 — Fri, 21 Mar 2014 08:56:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->epoll使用在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听... 阅读全文

天下 2014-03-21 16:56 发表评论

arm-none-linux-gnueabi

天下 — Mon, 27 May 2013 07:51:00 GMT

arm-none-linux-gnueabi
链接工具命名：
arch-vendor-(os-)abi

1、arm-none-linux-gnueabi (ARM architecture, no vendor, linux OS, and the gnueabi ABI)
        用于编译ARM架构的u-boot、linux内核、linux应用等
2、arm-none-eabi
        用于编译ARM架构的裸机系统(包括linux的 boot、kernel)
3、arm-eabi
        Android ARM 编译器

arm-none-linux-gnueabi交叉编译器是codesourcery公司推出的，基于GCC，但是进行过优化的编译器。官方网站
http://www.codesourcery.com/
codesourcery推出的产品叫Sourcery G++ Lite Edition，其中基于command-line的编译器是免费的，在官网上可以下载，而其中包含的IDE和debug 工具是收费的，当然也有30天试用版本的。
arm-none-linux-gnueabi-xxx用它的最大理由我想应该是浮点运算。

结果测试发现: int backtrace(void **buffer,int size) 在实际使用过程中,只能打印出空的调用堆栈
而arm-linux-gcc可以!

天下 2013-05-27 15:51 发表评论

Linux下利用backtrace追踪函数调用堆栈以及定位段错误

天下 — Wed, 17 Apr 2013 07:40:00 GMT

#include
#include
#include
#include
#include

//连接必须使用 LDFLAGS=-rdynamic
//$(CC) $(LDFLAGS) -o $@ $^
/*
Linux下利用backtrace追踪函数调用堆栈以及定位段错误

有些时候为了分析程序的BUG,(主要针对长时间运行程序的分析),在程序出错时打印出函数的调用堆栈是非常有用的。

在glibc头文件"execinfo.h"中声明了三个函数用于获取当前线程的函数调用堆栈。

int backtrace(void **buffer,int size)

该函数用于获取当前线程的调用堆栈,获取的信息将会被存放在buffer中,它是一个指针列表。参数 size 用来指定buffer中可以保存多少个void* 元素。函数返回值是实际获取的指针个数,最大不超过size大小

在buffer中的指针实际是从堆栈中获取的返回地址,每一个堆栈框架有一个返回地址

注意:某些编译器的优化选项对获取正确的调用堆栈有干扰,另外内联函数没有堆栈框架;删除框架指针也会导致无法正确解析堆栈内容

char ** backtrace_symbols (void *const *buffer, int size)

backtrace_symbols将从backtrace函数获取的信息转化为一个字符串数组. 参数buffer应该是从backtrace函数获取的指针数组,size是该数组中的元素个数(backtrace的返回值)

函数返回值是一个指向字符串数组的指针,它的大小同buffer相同.每个字符串包含了一个相对于buffer中对应元素的可打印信息.它包括函数名，函数的偏移地址,和实际的返回地址

现在,只有使用ELF二进制格式的程序才能获取函数名称和偏移地址.在其他系统,只有16进制的返回地址能被获取.另外,你可能需要传递相应的符号给链接器,以能支持函数名功能(比如,在使用GNU ld链接器的系统中,你需要传递(-rdynamic)， -rdynamic可用来通知链接器将所有符号添加到动态符号表中，如果你的链接器支持-rdynamic的话，建议将其加上！)

该函数的返回值是通过malloc函数申请的空间,因此调用者必须使用free函数来释放指针.

注意:如果不能为字符串获取足够的空间函数的返回值将会为NULL

void backtrace_symbols_fd (void *const *buffer, int size, int fd)

backtrace_symbols_fd与backtrace_symbols 函数具有相同的功能,不同的是它不会给调用者返回字符串数组,而是将结果写入文件描述符为fd的文件中,每个函数对应一行.它不需要调用malloc函数,因此适用于有可能调用该函数会失败的情况
*/

void C(int c)
{
    char* p = (char*)c;
    *p = 'A';
    printf("function C run after,*p='%c'\r\n",*p);
}

void B(int b)
{
    printf("%d: B call C \r\n",b);
    C(b+1);
}

void A(int a)
{
    printf("%d: A call B \r\n",a);
    B(2);
}

void debug_backtrace(int dunno)
{

#define SIZE 256
    void* array[SIZE];
    int size,i;
    char** strings;

    if (dunno==SIGSEGV)
    {
        fprintf(stderr,"\r\nSegmentation faul \r\n");
        size = backtrace(array,SIZE);
        fprintf(stderr,"\r\nBacktrace (%d deep):\r\n",size);
        strings = backtrace_symbols(array,size);
        for (i=0;i        {
            fprintf(stderr,"%d:%s\n",i,strings[i]);
        }
        free(strings);
        exit(-1);
    }
}

int main(int argc,char **argv)
{
    char a = 'T';
    signal(SIGSEGV,debug_backtrace);

    C((int)&a);
    A(1);
    return 0;
}

天下 2013-04-17 15:40 发表评论

linux分析命令行参数getopt

天下 — Tue, 16 Apr 2013 07:40:00 GMT

getopt
getopt（分析命令行参数）
相关函数
表头文件
#include
定义函数:
int getopt(int argc,char * const argv[ ],const char * optstring);
extern char *optarg;
extern int optind, opterr, optopt;
函数说明 getopt()用来分析命令行参数。参数argc和argv是由main()传递的参数个数和内容。
参数optstring为选项字符串，告知 getopt()可以处理哪个选项以及哪个选项需要参数，如果选项字符串里的字母后接着冒号“:”，则表示还有相关的参数，
全域变量optarg 即会指向此额外参数。如果在处理期间遇到了不符合optstring指定的其他选项getopt()将显示一个错误消息，并将全域变量optarg设为“?”字符，如果不希望getopt()打印出错信息，则只要将全域变量opterr设为0即可。
getopt() 所设置的全局变量包括：
optarg——指向当前选项参数（如果有）的指针。
optind——再次调用 getopt() 时的下一个 argv 指针的索引。
optopt——最后一个已知选项。
补充说明下optstring中的指定的内容的意义（例如getopt(argc, argv, "ab:c:de::");
1.单个字符，表示选项，（如上例中的abcde各为一个选项）
2.单个字符后接一个冒号：表示该选项后必须跟一个参数。参数紧跟在选项后或者以空格隔开。该参数的指针赋给optarg。（如上例中的b:c:）
3 单个字符后跟两个冒号，表示该选项后必须跟一个参数。参数必须紧跟在选项后不能以空格隔开。该参数的指针赋给optarg。(如上例中的e::)

天下 2013-04-16 15:40 发表评论

win32下使用getopt,从qt中弄了个getop.c

天下 — Tue, 16 Apr 2013 07:24:00 GMT

//getopt.h
#pragma once
#ifdef __cplusplus
extern "C" {
#endif

extern int opterr;        /* if error message should be printed */
extern int optind;        /* index into parent argv vector */
extern int optopt;            /* character checked for validity */
extern int optreset;        /* reset getopt */
extern char    *optarg;        /* argument associated with option */
int getopt(int argc, char * const argv[], const char *optstring);

#ifdef __cplusplus
}
#endif

getopt.c 从qt中弄的,一行都没改

//getopt.c 从qt中弄的,一行都没改

/* $Id: getopt.c,v 1.2 2005/07/07 16:34:06 dron Exp $ */

/*
* Copyright (c) 1987, 1993, 1994
*    The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#if 0
static char sccsid[] = "@(#)getopt.c    8.3 (Berkeley) 4/27/95";
__RCSID("$NetBSD: getopt.c,v 1.26 2003/08/07 16:43:40 agc Exp $");
#endif

#include
#include <string.h>

int    opterr = 1,        /* if error message should be printed */
    optind = 1,        /* index into parent argv vector */
    optopt,            /* character checked for validity */
    optreset;        /* reset getopt */
char    *optarg;        /* argument associated with option */

#define    BADCH    (int)'?'
#define    BADARG    (int)':'
#define    EMSG    ""

/*
* getopt --
*    Parse argc/argv argument vector.
*/
int getopt(int argc, char * const argv[], const char *optstring)
{
    static char *place = EMSG;        /* option letter processing */
    char *oli;                /* option letter list index */

    if (optreset || *place == 0) {        /* update scanning pointer */
        optreset = 0;
        place = argv[optind];
        if (optind >= argc || *place++ != '-') {
            /* Argument is absent or is not an option */
            place = EMSG;
            return (-1);
        }
        optopt = *place++;
        if (optopt == '-' && *place == 0) {
            /* "--" => end of options */
            ++optind;
            place = EMSG;
            return (-1);
        }
        if (optopt == 0) {
            /* Solitary '-', treat as a '-' option
               if the program (eg su) is looking for it. */
            place = EMSG;
            if (strchr(optstring, '-') == NULL)
                return -1;
            optopt = '-';
        }
    } else
        optopt = *place++;

    /* See if option letter is one the caller wanted */
    if (optopt == ':' || (oli = strchr(optstring, optopt)) == NULL) {
        if (*place == 0)
            ++optind;
        if (opterr && *optstring != ':')
            (void)fprintf(stderr,
                                      "unknown option -- %c\n", optopt);
        return (BADCH);
    }

    /* Does this option need an argument? */
    if (oli[1] != ':') {
        /* don't need argument */
        optarg = NULL;
        if (*place == 0)
            ++optind;
    } else {
        /* Option-argument is either the rest of this argument or the
           entire next argument. */
        if (*place)
            optarg = place;
        else if (argc > ++optind)
            optarg = argv[optind];
        else {
            /* option-argument absent */
            place = EMSG;
            if (*optstring == ':')
                return (BADARG);
            if (opterr)
                (void)fprintf(stderr,
                                        "option requires an argument -- %c\n",
                                        optopt);
            return (BADCH);
        }
        place = EMSG;
        ++optind;
    }
    return (optopt);            /* return option letter */
}

gnu getopt的使用:

//main.c
#include
#ifdef WIN32
    #include "getopt.h"
#else
    #include
#endif

int main(int argc,char **argv)
{
    int ch;
    opterr = 1;
    while((ch = getopt(argc,argv,"a:bcde"))!= -1)
    {
        switch(ch)
        {
            case 'a': printf("option a:'%s'\n",optarg); break;
            case 'b': printf("option b :b\n"); break;
            default:  printf("other option :%c\n",ch);
        }
    }

    printf("optopt +%c\n",optopt);
    //system("pause");
    return 0;

}

天下 2013-04-16 15:24 发表评论

Linux 信号signal处理机制(1)

天下 — Mon, 15 Apr 2013 02:43:00 GMT

#include
#include
#include
void sigroutine(int dunno)
{
/*信号处理例程，其中dunno将会得到信号的值 */
switch (dunno) {
    case 1:
        printf("Get a signal -- SIGHUP \r\n");
        break;
    case 2:
        printf("Get a signal -- SIGINT \r\n");
        break;
    case 3:
        printf("Get a signal -- SIGQUIT \r\n");
        break;
}
return;
}

int main()
{
    printf("process id is %d \r\n",getpid());
    signal(SIGHUP, sigroutine); //* 下面设置三个信号的处理方法
    signal(SIGINT, sigroutine);
    signal(SIGQUIT, sigroutine);
    for (;;) ;
}

/*
# /sb3000t/enroll/sig_demo &
933
# process id is 933

# kill -2 933
# Get a signal -- SIGINT

# Get a signal -- SIGINT
# kill -1 933
# Get a signal -- SIGHUP

#
# kill -3 933
# Get a signal -- SIGQUIT

*/

天下 2013-04-15 10:43 发表评论

crc32 For Linux 存档

天下 — Mon, 25 Mar 2013 03:49:00 GMT

//编译:/usr/local/arm/4.3.1/bin/arm-linux-g++
#include
#include
#include
#include

typedef unsigned int DWORD;
typedef unsigned char BYTE;

unsigned int GetTickCount(void)
{
    struct timeval tv;
    if (gettimeofday(&tv, NULL)!=0)
        return 0;
    return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}

void PrintCrcTable()
{
    //Poly = 0xedb88320 WinRAR Poly
    DWORD Val;
    for (DWORD i = 0; i < 256; i++)
    {
        Val = i;
        for (DWORD k = 0; k < 8; k++)
        {
            if (Val & 1)
                Val = 0xedb88320L ^ (Val >> 1);
            else
                Val = Val >> 1;
        }
        printf ("0x%08x, ", Val);
        if (0 == ((i+1)%6))
            printf ("\n");
    }
}

const DWORD Crc32Table[] =
{
    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};

DWORD GenerateCrc32(DWORD PartialCrc,BYTE* Buffer,DWORD Length)
{
    DWORD crc;
    DWORD i;

    // Generate the CRC32 checksum.
    crc = PartialCrc ^ 0xffffffffL;

    for (i = 0; i < Length; i++)
    {
        crc = Crc32Table[(crc ^ Buffer[i]) & 0xff] ^ (crc >> 8);
    }

    return (crc ^ 0xffffffffL);
}

//测试程序
int main(int argc,char* argv[])
{
    char* szFileName = NULL;
    if (argc<2)
    {
        printf("Usage:%s  \r\n",argv[0]);
        return -1;
    }
    szFileName = argv[1];
    FILE *fp = fopen(szFileName,"rb");
    if(NULL == fp)
    {
        printf("Open %s error:%d \r\n",szFileName);
        return 0;
    }

    DWORD dwStartTime = GetTickCount();
    printf("dwStartTime:%u \r\n",dwStartTime);
    DWORD crc32 = 0;
    BYTE c = 0;
    while(1 == fread(&c,1,1,fp))
        crc32 = GenerateCrc32(crc32,&c,1);

    fclose(fp);
    DWORD dwEndTime = GetTickCount();
    printf("dwEndTime:%u \r\n",dwEndTime);
    printf("calc_crc32(%s) = 0x%08X ,elapsed %u (ms) \r\n",szFileName,crc32,dwEndTime - dwStartTime);
    return 0;
}

天下 2013-03-25 11:49 发表评论

用volatile实现状态机的一点想法

天下 — Tue, 26 Feb 2013 09:03:00 GMT

线程A:运行在主界面,可以进入管理界面,进行日常的操作,
比如说登记用户,导入导出用户,产生验证记录!恢复出厂设置!

线程B:运行一个socket客户端任务,
1.将A线程产生的数据上传至服务器!
2.接受并处理来自服务端的命令/请求!,如,设置用户,清除数据,清除验证记录等.

典型的思路,在处理用户数据的时候,就用Mutex锁就可以!

在这里尝试用两个volatile变量处理,处理各种状态机!

volatile bool bDeviceBusy = false; //设备是否忙!
volatile bool bInManagerMenu = false; //是否在管理菜单中

void SetDeviceBusy(bool bBusy);
void SetInManagerMenu(bool bBusy);

场景1:
1.线程B如要设置用户数据,可以先锁定设备SetDeviceBusy(true),视情况可考虑并sleep(n)一下.
2.线程A在主界面的循环中,判断bDeviceBusy的值,如果为true,则在主界面上显示"工作中...",并且锁定设备,不能进入其他任何操作!
3.线程B设置用户数据完成之后,调用SetDeviceBusy(false),
4.线程A在主界面的循环中,判断bDeviceBusy的值,如果为false,解锁设备,使设备正常工作!

场景2:
1.线程A进入了管理菜单,进行用户数据的设置,如,恢复出厂设置时,可以先SetInManagerMenu(true)
2.线程B在线程的循环中,判断bInManagerMenu的值,如果为true,则不处理大部分的事务,如果有网络命令,直接应答设备忙.
3.线程A操作完成之后,调用SetInManagerMenu(false),
4.线程B在线程的循环中,判断bInManagerMenu的值,如果为false,继续处理来自服务端的命令/请求!

优化方案:
通过一个变量的状态来实现.
//volatile int device_status = -1;

天下 2013-02-26 17:03 发表评论

loop cp 代码

天下 — Thu, 06 Dec 2012 06:37:00 GMT

//测试工具
#include <unistd.h>
#include <cstring>
#include <cstdlib>
#include <string>
#include <sys/socket.h>
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <dirent.h>
#include <sys/time.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>

using namespace std;

void Path_AddSlash(char* pszPath)
{
    assert(pszPath!=NULL);
#ifdef WIN32
    PathAddBackslash(pszPath);
#else
    int nLen = strlen(pszPath);
    if (pszPath[nLen-1]!='/')
    {
        pszPath[nLen] = '/';
        pszPath[nLen+1] = '\0';
    }
#endif
}

#ifndef WIN32
unsigned int GetTickCount()
{
    struct timeval tv;
    if(gettimeofday(&tv, NULL)!= 0)
        return 0;
    return (tv.tv_sec * 1000)+(tv.tv_usec/1000);
}
#endif

string Path_GetBaseName(const string& strPath)
{
    const char* pszPath = strPath.c_str();
#ifdef WIN32
    char name[256];
    char ext[256];
    _splitpath(pszPath,NULL,NULL,name,ext);
    strcat(name,ext);
    return string(name);
#else
    return string(basename(pszPath));
#endif
}

// 目录是否存在
bool IsDirectory(char *p_dir)
{
    DIR *dir = NULL;

    dir = opendir(p_dir);
    if( NULL == dir )
    {
        return false;
    }
    else
    {
        closedir(dir);
        return true;
    }
}

long GetLocalFileSize(const char* szFileName)
{
    struct stat f_stat;
    if (stat(szFileName, &f_stat) == -1) {
        return -1;
    }
    return (long)f_stat.st_size;
}

int main(int argc,char* argv[])
{
    char szCmd[512];
    char szDstFileName[256];
    char szDir[256];

    if (argc!=5)
    {
        printf("Usage:%s     \r\n",argv[0]);
        return 255;
    }

    char* pszFileName = argv[1];
    int nBegin    = atoi(argv[3]);
    int nEnd    = atoi(argv[4]);

    strcpy(szDir,argv[2]);

    if (GetLocalFileSize(pszFileName) < 0)
    {
        printf("error:<%s> is not exist \r\n",pszFileName);
        return 255;
    }

    if (!IsDirectory(szDir))
    {
        printf("error:<%s> is not directory \r\n",szDir);
        return 255;
    }

    unsigned int dwBeginTime = GetTickCount();

    Path_AddSlash(szDir);
    char* pszExtName = strchr(pszFileName,'.');
    if (pszExtName==NULL)
    {
        pszExtName = (char*)"";
    }

    int ret = 0;
    int i = 0;
    for (i=nBegin;i<nEnd;i++)
    {
        sprintf(szCmd,"cp %s %s%06d%s",pszFileName,szDir,i,pszExtName);
        puts(szCmd);
        ret = system(szCmd);
        if (ret!=0)
        {
            break;
        }
    }
    unsigned int dwEndTime = GetTickCount();
    puts("\r\n-------------------------------------------------------------------");
    printf("from:%d,to:%d \r\n",nBegin,nEnd);
    printf("begin time:%u,end time:%u \r\n",dwBeginTime,dwEndTime);
    printf("elapse ms:%u \r\n",dwEndTime - dwBeginTime);
    return 0;
}

天下 2012-12-06 14:37 发表评论

linux pexec函数

天下 — Fri, 10 Aug 2012 01:23:00 GMT

#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>

int pexec(const char* command,int* result)
{
    int pid;
    int fds[2] = {-1,-1};
    int status = -1;

    if(pipe(fds) < 0)
    {
        return -1;
    }

    if( (pid=vfork()) < 0)
    {
        close(fds[0]);
        close(fds[1]);
        return -1;
    }

    if (pid == 0 )
    {
        dup2(fds[1],1);
        close(fds[0]);
        close(fds[1]);
        execl("/bin/sh", "sh", "-c", command,NULL);
        _exit(-1);
    }
    else
    {
        waitpid(pid,&status,0);
        close(fds[1]);
        if (WIFEXITED(status)==0)
        {
            close(fds[0]);
            return -1;
        }
        status  = WEXITSTATUS(status);
        if (result!=NULL)
        {
            *result = status;
        }
        //printf("pid(%d) exited,status:%d \r\n",pid,status);
        return fds[0];
    }
}

int main(int argc,char* argv[])
{
    if (argc<2)
    {
        printf("Usage:%s  \r\n",argv[0]);
        return -1;
    }
    int status = -1;
    int fd = pexec(argv[1],&status);
    if (fd==-1)
    {
        printf("pexec(%s) error \r\n",argv[1]);
        return -1;
    }
    char buf[4097];
    int readed = 0;
    while( (readed = read(fd,buf,4096))>0)
    {
        buf[readed] = 0;
        printf("readed:%d\r\n%s",readed,buf);
    }
    close(fd);
    return 0;
}

天下 2012-08-10 09:23 发表评论

pipe、dup、dup2、wait、waitpid、fork函数说明

天下 — Thu, 09 Aug 2012 06:36:00 GMT

pipe、dup、dup2、wait、waitpid、fork函数说明
int pipe(int fd[2]);
功能：创建一个简单的管道，若成功则为数组fd分配两个文件描述符，其中fd[0] 用于读取管道，fd[1]用于写入管道。
返回：成功返回0，失败返回-1；

管道是Linux 支持的最初Unix IPC形式之一，具有以下特点：
管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；只能用于父子进程或者兄弟进程之间(具有亲缘关系的进程)；单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

但值得我们注意的是：管道它有自身的特点。
(1)管道通信是单向的，并且遵守先进先出的原则，即先写入的数据先读出。
(2)管道是一个无结构，无固定大小的字节流。
(3)两个返回的文件描述符以一种特殊的方式连接起来.写到fd[1]的数据都可以从fd[0]中读回来.

向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。

int dup(int fd)
复制一个存在的文件描述符，返回当前可用的最小文件描述符。。。比如当前文件描述符已经到了100，使用 dup(100)　，将返回 101 ，101这个文件描述符拥有100的所有东西，复制了嘛。。。

int dup2(int fd, int fd2)
是可以指定一个文件描述符(fd2)来使用，如果fd2已经打开，则会先将其关闭，如果 fd==fd2 ，直接返回 fd2 且不关闭。
实际上 fcntl 也能完成这2个函数的功能，只是对于 dup2 来说，fcntl 是调用2个函数，而 dup2 是一个原子操作。

dup函数的作用：复制一个现有的句柄，产生一个与“源句柄特性”完全一样的新句柄(也即生成一个新的句柄号，并关联到同一个设备)

dup2函数的作用：复制一个现有的句柄到另一个句柄上，目标句柄的特性与“源句柄特性”完全一样(也即首先关闭目标句柄，与设备断连，接着从源句柄完全拷贝复制到目标句柄)

wait和waitpid函数
头文件
#include<sys/types.h>
#include<sys/wait.h>
函数 pid_t wait (int * status);
进程一旦调用了 wait，就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程，wait 就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现为止。
wait(等待子进程中断或结束)

wait()会暂时停止目前进程的执行，直到有信号来到或子进程结束。如果在调用wait()时子进程已经结束，则wait()会立即返回子进程结束状态值。子进程的结束状态值会由参数status 返回，而子进程的进程识别码也会一快返回。如果不在意结束状态值，则参数status 可以设成NULL。子进程的结束状态值请参考waitpid()。
返回值
如果执行成功则返回子进程识别码(PID)，如果有错误发生则返回-1。失败原因存于errno 中。

waitpid(等待子进程中断或结束)
相关函数 wait，fork
表头文件
#include<sys/types.h>
#include<sys/wait.h>
定义函数 pid_t waitpid(pid_t pid,int * status,int options);
函数说明
waitpid()会暂时停止目前进程的执行，直到有信号来到或子进程结束。如果在调用waitpid()时子进程已经结束，则waitpid()会立即返回子进程结束状态值。子进程的结束状态值会由参数status 返回，而子进程的进程识别码也会一快返回。如果不在意结束状态值，则参数status 可以设成NULL。

参数pid 为欲等待的子进程识别码，其他数值意义如下：
pid<-1 等待进程组识别码为pid 绝对值的任何子进程。
pid=-1 等待任何子进程，相当于wait()。
pid=0 等待进程组识别码与目前进程相同的任何子进程。
pid>0 等待任何子进程识别码为pid 的子进程。

目前在Linux中只支持WNOHANG和WUNTRACED两个选项，
WNOHANG 如果没有任何已经结束的子进程则马上返回，不予以等待。
WUNTRACED 如果子进程进入暂停执行情况则马上返回，但结束状态不予以理会。

如果我们不想使用它们，也可以把options设为0，如：
ret=waitpid(-1,NULL,0);

如果使用了WNOHANG参数调用waitpid，即使没有子进程退出，它也会立即返回，不会像wait那样永远等下去。

而WUNTRACED参数，用于跟踪调试，极少用到，就不说了。
查看linux源代码 unistd.h 我们会发现，其实 wait 就是经过包装的 waitpid:
static inline pid_t wait(int * wait_stat)
{
    return waitpid(-1,wait_stat,0);
}

可以用kill函数杀死子进程
kill(childPid,SIGKILL);

子进程的结束状态返回后存于status，下面有几个宏可判别结束情况：
WIFEXITED(status)如果子进程正常结束则为非0值。
WEXITSTATUS(status)取得子进程exit()返回的结束代码，一般会先用WIFEXITED 来判断是否正常结束才能使用此宏。
WIFSIGNALED(status)如果子进程是因为信号而结束则此宏值为真
WTERMSIG(status) 取得子进程因信号而中止的信号代码，一般会先用WIFSIGNALED 来判断后才使用此宏。
WIFSTOPPED(status) 如果子进程处于暂停执行情况则此宏值为真。一般只有使用WUNTRACED 时才会有此情况。
WSTOPSIG(status) 取得引发子进程暂停的信号代码，一般会先用WIFSTOPPED 来判断后才使用此宏。

if (WIFEXITED(status))
{
    printf("exited, status=%d/n", WEXITSTATUS(status));
}
else if (WIFSIGNALED(status)) {
    printf("killed by signal %d/n", WTERMSIG(status));
}
else if (WIFSTOPPED(status)) {
    printf("stopped by signal %d/n", WSTOPSIG(status));
}
else if (WIFCONTINUED(status)) {
    printf("continued/n");
}

返回值
如果执行成功则返回子进程识别码(PID)，如果有错误发生则返回-1。失败原因存于errno 中。

fork函数
Create a new process

程序段里用了fork();之后程序出了分岔，派生出了两个进程。具体哪个先运行就看该操作的系统的调度算法了。
函数返回2次.
返回值得在子进程中pid的值为0，通过getpid可以获取子进程的进程id；

返回值:
A value of zero to the child process; and the process ID of the child process to the parent process.
Both processes continue to execute from the fork() function. If an error occurs, fork() returns -1 to the parent and sets errno.

#include <sys/types.h>
#include <process.h>
int main()
{
    pid_t pid;

    puts("<1>");
    pid=fork();
    if (pid < 0) {
        printf("error in fork! \r\n");
    }
    else if (pid == 0) {
        printf("i am the child process, my process id is %d \r\n",getpid());
    }
    else {
        printf("i am the parent process, my process id is %d \r\n",getpid());
    }

    puts("<2>");
    return 0;
}

天下 2012-08-09 14:36 发表评论

execl函数 && vfork()

天下 — Thu, 05 Jul 2012 01:41:00 GMT

//execl函数 && vfork()

#include
#include
#include
main()
{
    int pid;
    if((pid=vfork()) == 0) {                                    //(0)
        execl("/bin/ls", "ls", "-al", "/etc/passwd", (char *)0);//(1)
        //char * argv[] = {"ls", "-al", "/etc/passwd", 0};
        //execvp("ls", argv);                                    //(2)
    }
    else if(pid > 0) {
        printf("I'm a parent!\n");
    }

}
---------------------------------------------------
(0) vfork()和execl()配套使用可以提高效率(必须配套使用)
(1) int execvp(const char *file, char *const argv[]);
   函数execvp()应该先构造一个指向各参数的指针数组，然后将该数组地址作为参数
(2) int execl(const char *path, const char *arg, );
   函数execl()要求将新程序的每个命令行参数都说明成一个单独的参数，这种参数表以空指针结尾
(3)vfork创建的子进程后，父进程会被阻塞，直到子进程执行execl和exit
(4)当进程调用一种exec函数时，该进程完全由新程序代换，而新程序则从其main函数开始执行。因为调用exec并不创建新进程，所以前后的进程ID并未改变。exec只是用另一个新程序替换了当前进程的正文、数据、堆和栈段。
(5)当前进程的正文都被替换了，那么execl后的语句，即便execl退出了，都不会被执行。
(6)execl成功则不返回值，失败返回-1，失败原因存于errno中
$ ./a.out
-rw-r--r-- 1 root root 1448 2007-05-16 17:30 /etc/passwd
I'm a parent!

天下 2012-07-05 09:41 发表评论

[原]Linux ExecFun

天下 — Thu, 05 Jul 2012 01:30:00 GMT

//转载必须注明
//Aaron.xu
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include <string.h>

unsigned int GetTickCount(void)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (tv.tv_sec*1000 + tv.tv_usec/1000);
}

typedef int (*ExecFunProc)(void* pArg);

int mysleep(void* pArg)
{
    sleep(4);
    return 2;
}

//返回值: true:执行成功 ,false:执行失败
//参数说明:
//pfnExec    回调函数
//pArg        回调函数的参数
//pnStatus    把pfnExec执行的返回值,返回给pnStatus指向的变量
//dwTimeOut    执行的超时时间,单位毫秒(1秒=1000毫秒)
//bKill        超时退出时,是否杀死子进程.true:杀死,false:不杀死
bool ExecFun(ExecFunProc pfnExec,void* pArg,int* pnStatus,unsigned int dwTimeOut,bool bKill = false)
{
    pid_t childPid;
    pid_t tempPid;
    int nStatus = 0;
    int bRet = 0;
    unsigned int dwEndTime = GetTickCount() + dwTimeOut;

    assert(pfnExec!=NULL);
    assert(pnStatus!=NULL);

    *pnStatus = -1;
    if( (childPid = fork()) < 0 )
    {
        printf("fork error:%d \r\n",errno);
        return false;
    }
    if(childPid == 0)
    {
        printf("at %u,child pid:%d Entry\r\n",GetTickCount(),getpid());
        nStatus = pfnExec(pArg);
        printf("at %u,child pid:%d Exit(%d)\r\n",GetTickCount(),getpid(),nStatus);
        exit(nStatus);
    }
    else
    {
        while( 1)
        {
            usleep(50*1000);
            tempPid = waitpid(childPid,&nStatus,WNOHANG);
            if (tempPid<0)
            {
                printf("waitpid(%d) execption,errno:%d \r\n",childPid,errno);
                return false;
            }
            if (tempPid>0)
            {
                nStatus  = WEXITSTATUS(nStatus);
                printf("waitpid(%d) normal exit(%d)\r\n",childPid,nStatus);
                *pnStatus = nStatus;
                return true;
            }

            if (GetTickCount()>dwEndTime)
            {
                printf("at %d,waitpid(%d) time out exit\r\n",GetTickCount(),childPid);
                if (bKill && (kill(childPid,SIGKILL)==0))
                {
                    wait(&nStatus);
                }
                return false;
            }
        }
        return false;
    }
}

int main() {
    int nRet = 0;
    bool bRet = ExecFun(mysleep,NULL,&nRet,2000,true);

    printf("line:%d , bRet:%d,nRet:%d \r\n",__LINE__,bRet,nRet);

    //puts(strerror(EINTR));
    return 0;
}

天下 2012-07-05 09:30 发表评论

linux kill信号列表

天下 — Mon, 11 Jun 2012 02:18:00 GMT

kill -l
1) SIGHUP     2) SIGINT     3) SIGQUIT     4) SIGILL
5) SIGTRAP     6) SIGABRT     7) SIGBUS     8) SIGFPE
9) SIGKILL    10) SIGUSR1    11) SIGSEGV    12) SIGUSR2
13) SIGPIPE    14) SIGALRM    15) SIGTERM    16) SIGSTKFLT
17) SIGCHLD    18) SIGCONT    19) SIGSTOP    20) SIGTSTP
21) SIGTTIN    22) SIGTTOU    23) SIGURG    24) SIGXCPU
25) SIGXFSZ    26) SIGVTALRM    27) SIGPROF    28) SIGWINCH
29) SIGIO    30) SIGPWR    31) SIGSYS    34) SIGRTMIN
35) SIGRTMIN+1    36) SIGRTMIN+2    37) SIGRTMIN+3    38) SIGRTMIN+4
39) SIGRTMIN+5    40) SIGRTMIN+6    41) SIGRTMIN+7    42) SIGRTMIN+8
43) SIGRTMIN+9    44) SIGRTMIN+10    45) SIGRTMIN+11    46) SIGRTMIN+12
47) SIGRTMIN+13    48) SIGRTMIN+14    49) SIGRTMIN+15    50) SIGRTMAX-14
51) SIGRTMAX-13    52) SIGRTMAX-12    53) SIGRTMAX-11    54) SIGRTMAX-10
55) SIGRTMAX-9    56) SIGRTMAX-8    57) SIGRTMAX-7    58) SIGRTMAX-6
59) SIGRTMAX-5    60) SIGRTMAX-4    61) SIGRTMAX-3    62) SIGRTMAX-2
63) SIGRTMAX-1    64) SIGRTMAX

列表中，编号为1 ~ 31的信号为传统UNIX支持的信号，是不可靠信号(非实时的)，编号为32 ~ 63的信号是后来扩充的，称做可靠信号(实时信号)。不可靠信号和可靠信号的区别在于前者不支持排队，可能会造成信号丢失，而后者不会。

下面我们对编号小于SIGRTMIN的信号进行讨论。

1) SIGHUP

本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各个作业, 这时它们与控制终端不再关联。

登录Linux时，系统会分配给登录用户一个终端(Session)。在这个终端运行的所有程序，包括前台进程组和后台进程组，一般都属于这个 Session。当用户退出Linux登录时，前台进程组和后台有对终端输出的进程将会收到SIGHUP信号。这个信号的默认操作为终止进程，因此前台进程组和后台有终端输出的进程就会中止。不过可以捕获这个信号，比如wget能捕获SIGHUP信号，并忽略它，这样就算退出了Linux登录，wget也能继续下载。

此外，对于与终端脱离关系的守护进程，这个信号用于通知它重新读取配置文件。

2) SIGINT

程序终止(interrupt)信号, 在用户键入INTR字符(通常是Ctrl-C)时发出，用于通知前台进程组终止进程。

3) SIGQUIT

和SIGINT类似, 但由QUIT字符(通常是Ctrl-\)来控制. 进程在因收到SIGQUIT退出时会产生core文件, 在这个意义上类似于一个程序错误信号。

4) SIGILL

执行了非法指令. 通常是因为可执行文件本身出现错误, 或者试图执行数据段. 堆栈溢出时也有可能产生这个信号。

5) SIGTRAP

由断点指令或其它trap指令产生. 由debugger使用。

6) SIGABRT

调用abort函数生成的信号。

7) SIGBUS

非法地址, 包括内存地址对齐(alignment)出错。比如访问一个四个字长的整数, 但其地址不是4的倍数。它与SIGSEGV的区别在于后者是由于对合法存储地址的非法访问触发的(如访问不属于自己存储空间或只读存储空间)。

8) SIGFPE

在发生致命的算术运算错误时发出. 不仅包括浮点运算错误, 还包括溢出及除数为0等其它所有的算术的错误。

9) SIGKILL

用来立即结束程序的运行. 本信号不能被阻塞、处理和忽略。如果管理员发现某个进程终止不了，可尝试发送这个信号。

10) SIGUSR1

留给用户使用

11) SIGSEGV

试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据.

12) SIGUSR2

留给用户使用

13) SIGPIPE

管道破裂。这个信号通常在进程间通信产生，比如采用FIFO(管道)通信的两个进程，读管道没打开或者意外终止就往管道写，写进程会收到SIGPIPE信号。此外用Socket通信的两个进程，写进程在写Socket的时候，读进程已经终止。

14) SIGALRM

时钟定时信号, 计算的是实际的时间或时钟时间. alarm函数使用该信号.

15) SIGTERM

程序结束(terminate)信号, 与SIGKILL不同的是该信号可以被阻塞和处理。通常用来要求程序自己正常退出，shell命令kill缺省产生这个信号。如果进程终止不了，我们才会尝试SIGKILL。

17) SIGCHLD

子进程结束时, 父进程会收到这个信号。

如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程来接管)。

18) SIGCONT

让一个停止(stopped)的进程继续执行. 本信号不能被阻塞. 可以用一个handler来让程序在由stopped状态变为继续执行时完成特定的工作. 例如, 重新显示提示符...

19) SIGSTOP

停止(stopped)进程的执行. 注意它和terminate以及interrupt的区别:该进程还未结束, 只是暂停执行. 本信号不能被阻塞, 处理或忽略.

20) SIGTSTP

停止进程的运行, 但该信号可以被处理和忽略. 用户键入SUSP字符时(通常是Ctrl-Z)发出这个信号

21) SIGTTIN

当后台作业要从用户终端读数据时, 该作业中的所有进程会收到SIGTTIN信号. 缺省时这些进程会停止执行.

22) SIGTTOU

类似于SIGTTIN, 但在写终端(或修改终端模式)时收到.

23) SIGURG

有"紧急"数据或out-of-band数据到达socket时产生.

24) SIGXCPU

超过CPU时间资源限制. 这个限制可以由getrlimit/setrlimit来读取/改变。

25) SIGXFSZ

当进程企图扩大文件以至于超过文件大小资源限制。

26) SIGVTALRM

虚拟时钟信号. 类似于SIGALRM, 但是计算的是该进程占用的CPU时间.

27) SIGPROF

类似于SIGALRM/SIGVTALRM, 但包括该进程用的CPU时间以及系统调用的时间.

28) SIGWINCH

窗口大小改变时发出.

29) SIGIO

文件描述符准备就绪, 可以开始进行输入/输出操作.

30) SIGPWR

Power failure

31) SIGSYS

非法的系统调用。

在以上列出的信号中，程序不可捕获、阻塞或忽略的信号有：SIGKILL,SIGSTOP

不能恢复至默认动作的信号有：SIGILL,SIGTRAP

默认会导致进程流产的信号有：SIGABRT,SIGBUS,SIGFPE,SIGILL,SIGIOT,SIGQUIT,SIGSEGV,SIGTRAP,SIGXCPU,SIGXFSZ

默认会导致进程退出的信号有：SIGALRM,SIGHUP,SIGINT,SIGKILL,SIGPIPE,SIGPOLL,SIGPROF,SIGSYS,SIGTERM,SIGUSR1,SIGUSR2,SIGVTALRM

天下 2012-06-11 10:18 发表评论

popt

天下 — Sat, 26 May 2012 09:58:00 GMT

参考网址:

http://rpm5.org/files/popt/

http://www.linuxfromscratch.org/blfs/view/svn/general/popt.html

arm 平台编译:
./configure CC=arm-linux-gcc --host=arm-linux --prefix=$PWD/_install

make && make install
就可以了

天下 2012-05-26 17:58 发表评论

linux常用C头文件

天下 — Fri, 18 May 2012 01:58:00 GMT

linux常用C头文件

aio.h 异步I/O

assert.h 验证程序断言

complex 复数类

complex.h 复数处理

cpio.h cpio归档值

ctype.h 字符类型

dirent.h 目录项,opendir(),closedir(),readdir(),readdir64()

dlfcn.h 动态链接

errno.h 出错码

exception 异常处理类

fcntl.h 文件控制

fenv.h 浮点环境

float.h 浮点常数

fmtmsg.h 消息显示结构

fnmatch.h 文件名匹配类型

fstream.h 文件输入／输出

ftw.h 文件树漫游

getopt.h 处理命令行参数,getopt()

glob.h 路径名模式匹配类型

grp.h 组文件

iconv.h 代码集转换使用程序

inttypes.h 整数格式转换

iomanip.h 参数化输入／输出

ios 基本输入／输出支持

iosfwd 输入／输出系统使用的前置声明

iostream.h 数据流输入／输出

istream 基本输入流

langinfo.h 语言信息常量

libgen.h 模式匹配函数定义

limits.h 定义各种数据类型最值常量

locale.h 定义本地化函数

math.h 定义数学函数

monetary.h 货币类型

mqueue.h 消息队列

ndbm.h 数据库操作

nl_types.h 消息类别

ostream 基本输出流

poll.h 轮询函数

pthread.h 线程

pwd.h 口令文件

regex.h 正则表达式

sched.h 执行调度

search.h 搜索表

semaphore.h 信号量

signal.h 信号

spawn.h 实时spawn接口

sstream 基于字符串的流

stdarg.h 可变参数表

stdbool.h 布尔环境

stddef.h 标准定义

stdexcept 标准异常类

stdint.h 整型环境

stdio.h 标准I/O库 standard input output header -> stdio.h

stdlib.h 公用函数 standard library header -> stdlib.h

streambuf 底层输入／输出支持

string.h 字符串操作

stropts.h XSI STREAMS接口

strstrea.h 基于数组的输入／输出

syslog.h 系统出错日志记录

tar.h tar归档值

termios.h 终端I/O

tgmath.h 通用类型数学宏

time.h 时间和日期

trace.h 事件跟踪

ucontext.h 用户上下文

ulimit.h 用户限制

unistd.h 符号常数 unix standard header -> unistd.h

utime.h 文件时间

utmpx.h 用户帐户数据库

wchar.h 宽字符处理及输入／输出

wctype.h 宽字符分类

wordexp.h 字符扩展类型

linux/if.h 主要的socket头文件,包括ifreq,ifconf,ifmap

linux/if_packet.h 原始数据包的数据结构定义,包括sockaddr_pkt,sockaddr_ll,同理的还有if_ppp.h,if_tun.h等等

linux/ip.h iphdr的数据结构,以及一些ip层的数据定义,同理的还有tcp.h,udp.h等等

arpa/inet.h INTERNET定义

netdb.h hostent,gethostbyname

net/bpf.h berkeley的数据包过滤头文件

net/ethernet.h ether_addr,ether_header

net/if.h 套接字本地接口

netinet/ether.h 以太祯的网络字节和ascii字节的转换,包括ether_ntoa(),ether_aton这样的函数定义

netinet/if_ether.h ether_arp的数据结构

netinet/in.h ip,结构sockaddr_in,ntoh,hton

netinet/ip.h iphdr的数据结构,同时还包括了timestamp结构

netinet/tcp.h 传输控制协议定义

sys/ipc.h IPC

sys/mman.h 内存管理声明

sys/msg.h 消息队列

sys/select.h Select函数

sys/sem.h 信号量

sys/shm.h 共享存储

sys/socket.h 套接字借口

sys/stat.h 文件状态

sys/statvfs.h 文件系统信息

sys/time.h 时间类型

sys/timeb.h 附加的日期和时间定义

sys/times.h 进程时间

sys/types.h 原系统数据类型

sys/uio.h 矢量I/O操作

sys/un.h UNIX域套接字定义

sys/utsname.h 系统名

sys/wait.h 进程控制

algorithm STL通用算法

bitset STL位集容器

deque STL双端队列容器

functional STL定义运算函数（代替运算符）

list STL线性列表容器

map STL映射容器

queue STL队列容器

set STL集合容器

stack STL堆栈容器

utility STL通用模板类

vector STL动态数组容器

天下 2012-05-18 09:58 发表评论

不带缓存的I/O和标准I/O

天下 — Thu, 10 May 2012 08:53:00 GMT

不带缓存的I/O和标准I/O

首先说说不带缓存的I/O，UNIX的文件I/O read、write是不带缓存的。不带缓存是指每个read、write都调用内核的一个系统调用，它们是POSIX.1的组成部分。
二者的原型为：
ssize_t read( int fd, void* buf, size_t nbytes ); // 若成功返回读到的字节数
ssize_t write( int fd, const void* buf, size_t nbytes ); // 若成功返回已写的字节数

注意，上面的buf不是指read、write带缓存，而是当read时用来存放读出的字节，write时存放待写的字节。对于read，nbytes表示每次最多读的字节数。但这个块的大小将影响I/O的效率，其值和具体系统有关。

补充一下，不带缓存的I/O对文件描述符操作，下面带缓存的I/O是针对流的。

标准I/O库就是带缓存的I/O，它由ANSI C标准说明。当然，标准I/O最终都会调用上面的I/O例程。标准I/O库代替用户处理很多细节，比如缓存分配、以优化长度执行I/O等。

标准I/O提供缓存的目的就是减少调用read和write的次数，它对每个I/O流自动进行缓存管理（标准I/O函数通常调用malloc来分配缓存）。它提供了三种类型的缓存：

1) 全缓存。当填满标准I/O缓存后才执行I/O操作。磁盘上的文件通常是全缓存的。

2) 行缓存。当输入输出遇到新行符或缓存满时，才由标准I/O库执行实际I/O操作。stdin、stdout通常是行缓存的。

3) 无缓存。相当于read、write了。stderr通常是无缓存的，因为它必须尽快输出。

一般而言，由系统选择缓存的长度，并自动分配。标准I/O库在关闭流的时候自动释放缓存。

在标准I/O库中，一个效率不高的不足之处是需要复制的数据量。当每次使用行函数fgets和fputs时，通常需要复制两次数据：一次是在内核和标准I/O缓存之间（当调用read和write时），第二次是在标准I/O缓存（通常系统分配和管理）和用户程序中的行缓存（fgets的参数就需要一个用户行缓存指针）之间。

不管上面讲的到底懂没懂，记住一点：

使用标准I/O例程的一个优点是无需考虑缓存及最佳I/O长度的选择，并且它并不比直接调用read、write慢多少。

带缓存的文件操作是标准C 库的实现，第一次调用带缓存的文件操作函数时标准库会自动分配内存并且读出一段固定大小的内容存储在缓存中。所以以后每次的读写操作并不是针对硬盘上的文件直接进行的，而是针对内存中的缓存的。何时从硬盘中读取文件或者向硬盘中写入文件有标准库的机制控制。不带缓存的文件操作通常都是系统提供的系统调用，更加低级，直接从硬盘中读取和写入文件，由于IO瓶颈的原因，速度并不如意，而且原子操作需要程序员自己保证，但使用得当的话效率并不差。
另外标准库中的带缓存文件IO 是调用系统提供的不带缓存IO实现的。

“术语不带缓冲指的是每个read和write都调用内核中的一个系统调用。所有的磁盘I/O都要经过内核的块缓冲（也称内核的缓冲区高速缓存），唯一例外的是对原始磁盘设备的I/O。既然read或write的数据都要被内核缓冲，那么术语“不带缓冲的I/O“指的是在用户的进程中对这两个函数不会自动缓冲，每次read或write就要进行一次系统调用。“

--------摘自<unix环境编程>

天下 2012-05-10 16:53 发表评论

终级makefile

天下 — Fri, 13 Apr 2012 06:58:00 GMT

#Aaron.xu 13174115@qq.com

targets = main
#CFLAGS        = -g
#LDFLAGS    = -rdynamic
#INC_PATH    = -I ../

CXX         = g++
SRC_EXT        = cpp
SRC_FILE    = $(wildcard *.$(SRC_EXT))

ifeq (,$(SRC_FILE))
    SRC_EXT        = c
    SRC_FILE    = $(wildcard *.$(SRC_EXT))
endif

OBJ_FILE    = $(patsubst %.$(SRC_EXT),%.o,$(wildcard *.$(SRC_EXT)))
HEADER_FILE = $(wildcard *.h)

.PHONY:all,clean,test

all:$(targets)

$(targets):$(OBJ_FILE)
    $(CXX) -o $@ $^ $(LDFLAGS) $(INC_PATH)

#$(OBJ_FILE):
#$(CXX) $(patsubst %.o,%.$(SRC_EXT),$@) -c $(CFLAGS) -o $@

%.o : %.$(SRC_EXT) $(HEADER_FILE)
    $(CXX) -o $@ -c $<  $(CFLAGS) $(INC_PATH)

clean:
    rm -f *.o
    rm -f $(targets)

test:
    ./$(targets)

天下 2012-04-13 14:58 发表评论

Linux目录遍历

天下 — Sun, 25 Mar 2012 02:57:00 GMT

#include "unistd.h"
#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>

using namespace std;

#define USER_LIST_FILE "./UserInfo.txt"
#define USER_LIST_PHOTODIR "./user-photo"
void GetUserList()
{
    FILE* fp = NULL;
    DIR*  pDir = NULL;
    fp = fopen(USER_LIST_FILE,"r");
    if (fp==NULL)
    {
        printf("file open fail \r\n");
        return;
    }

    pDir = opendir(USER_LIST_PHOTODIR);
    if (pDir==NULL)
    {
        printf("dir open fail \r\n");
        return;
    }

    struct dirent *pDirent;
    while((pDirent = readdir(pDir)) != NULL)
    {
        if (pDirent->d_type == DT_REG)//普通文件
        {

        }
        printf("d_type:%d,d_name: %s\n",pDirent->d_type,pDirent->d_name);
    }

}
int main()
{
    GetUserList();
    return 0;
}

结构体

/* File types for `d_type'.  */
enum
{
    DT_UNKNOWN = 0,
    DT_FIFO = 1,
    DT_CHR = 2,
    DT_DIR = 4,
    DT_BLK = 6,
    DT_REG = 8,
    DT_LNK = 10,
    DT_SOCK = 12,
    DT_WHT = 14
};

天下 2012-03-25 10:57 发表评论

单文件版SHA1函数

天下 — Thu, 12 Jan 2012 09:04:00 GMT

//SHA1.cpp
#include <string>

std::string SHA1(std::string s)
{
    const char HEX_CHAR[]={'0', '1', '2', '3', '4', '5', '6', '7',
        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
    const unsigned long K[] = {0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6};
    //扩展成K*512位
    unsigned long *data;
    int l;
    l = s.length()*8;
    data = new unsigned long[((l/512)+1)*512];
    memset(data, 0, sizeof(data[0])*((l/512)+1)*512);
    for(unsigned int i = 0; i < s.length(); ++i){
        data[i / 4] |= s[i] << 8*(3 - (i % 4));
    }
    data[s.length() / 4] |= 0x80 << 8*(3-(s.length()%4));
    data[((l/512)+1)*512/32-1]=l;
    l = (l/512)+1;
    //开始计算
    unsigned long H[5], G[5];
    H[0] = G[0] = 0x67452301;
    H[1] = G[1] = 0xEFCDAB89;
    H[2] = G[2] = 0x98BADCFE;
    H[3] = G[3] = 0x10325476;
    H[4] = G[4] = 0xC3D2E1F0;
    for(int i = 0; i<l; ++i){
        unsigned long W[80];
        int t;
        for(t = 0; t<16; ++t)
            W[t] = data[i*16+t];
        for(t = 16; t<80; ++t){
            unsigned long tmp = W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16];
            W[t] = (tmp << 1)|(tmp >> 31);
        }
        unsigned long tmp;
        for(t = 0; t<5; ++t)
            H[t] = G[t];
        for(t = 0; t<20; ++t){
            tmp = ((H[0] << 5) | (H[0] >> 27)) + ((H[1] & H[2]) | (~ H[1] & H[3])) + H[4] + W[t] + K[0];
            H[4] = H[3]; H[3] = H[2]; H[2] = (H[1]<<30)|(H[1] >> 2); H[1] = H[0]; H[0] = tmp;
        }
        for(t = 20; t<40; ++t){
            tmp = ((H[0] << 5) | (H[0] >> 27)) + (H[1] ^ H[2] ^ H[3]) + H[4] + W[t] + K[1];
            H[4] = H[3]; H[3] = H[2]; H[2] = (H[1]<<30)|(H[1] >> 2); H[1] = H[0]; H[0] = tmp;
        }
        for(t = 40; t<60; ++t){
            tmp = ((H[0] << 5) | (H[0] >> 27)) + ((H[1] & H[2])|(H[2] & H[3])|(H[1] & H[3])) + H[4] + W[t] + K[2];
            H[4] = H[3]; H[3] = H[2]; H[2] = (H[1]<<30)|(H[1] >> 2); H[1] = H[0]; H[0] = tmp;
        }
        for(t = 60; t<80; ++t){
            tmp = ((H[0] << 5) | (H[0] >> 27)) + (H[1] ^ H[2] ^ H[3]) + H[4] + W[t] + K[3];
            H[4] = H[3]; H[3] = H[2]; H[2] = (H[1]<<30)|(H[1] >> 2); H[1] = H[0]; H[0] = tmp;
        }
        for(t = 0; t<5; ++t)
            G[t] += H[t];
    }
    delete data;
    char buf[41];
    for(int i = 0; i<40; ++i){
        buf[i] = HEX_CHAR[(G[i / 8] >> (4*(7- (i % 8))))&0xf];
    }
    buf[40] = '\0';
    return std::string(buf);
}

//Test
//#include
//using namespace std;
//int main(int argc, char* argv[])
//{
//    char s[100];
//    while(true){
//        scanf("%s", s);
//        cout <<  SHA1(s)<< endl;
//    }
//    return 0;
//}

天下 2012-01-12 17:04 发表评论

LINUX 错误代码

天下 — Fri, 06 Jan 2012 03:15:00 GMT

LINUX 错误代码
[转自]
下面这个例子列出了所有系统定义的错误代码及错误描述
源代码是：
/************关于本文档********************************************
*filename: strerror.c
*purpose: 列出了系统定义的所有错误代码及描述
*wrote by: zhoulifa(zhoulifa@163.com) 周立发(http://zhoulifa.bokee.com)
*/

#include <string.h> /* for strerror */
#include <errno.h>
#include <stdio.h>

int main(int argc, char ** argv)        {
        int i = 0;
        for(i = 0; i < 256; i++)
        printf("errno.%02d is: %s\n", i, strerror(i));
        return 0;
}

编译此程序用命令：
gcc -Wall strerror.c
执行程序：
./a.out
输出如下：
errno.00 is: Success
errno.01 is: Operation not permitted
errno.02 is: No such file or directory
errno.03 is: No such process
errno.04 is: Interrupted system call
errno.05 is: Input/output error
errno.06 is: No such device or address
errno.07 is: Argument list too long
errno.08 is: Exec format error
errno.09 is: Bad file descriptor
errno.10 is: No child processes
errno.11 is: Resource temporarily unavailable
errno.12 is: Cannot allocate memory
errno.13 is: Permission denied
errno.14 is: Bad address
errno.15 is: Block device required
errno.16 is: Device or resource busy
errno.17 is: File exists
errno.18 is: Invalid cross-device link
errno.19 is: No such device
errno.20 is: Not a directory
errno.21 is: Is a directory
errno.22 is: Invalid argument
errno.23 is: Too many open files in system
errno.24 is: Too many open files
errno.25 is: Inappropriate ioctl for device
errno.26 is: Text file busy
errno.27 is: File too large
errno.28 is: No space left on device
errno.29 is: Illegal seek
errno.30 is: Read-only file system
errno.31 is: Too many links
errno.32 is: Broken pipe
errno.33 is: Numerical argument out of domain
errno.34 is: Numerical result out of range
errno.35 is: Resource deadlock avoided
errno.36 is: File name too long
errno.37 is: No locks available
errno.38 is: Function not implemented
errno.39 is: Directory not empty
errno.40 is: Too many levels of symbolic links
errno.41 is: Unknown error 41
errno.42 is: No message of desired type
errno.43 is: Identifier removed
errno.44 is: Channel number out of range
errno.45 is: Level 2 not synchronized
errno.46 is: Level 3 halted
errno.47 is: Level 3 reset
errno.48 is: Link number out of range
errno.49 is: Protocol driver not attached
errno.50 is: No CSI structure available
errno.51 is: Level 2 halted
errno.52 is: Invalid exchange
errno.53 is: Invalid request descriptor
errno.54 is: Exchange full
errno.55 is: No anode
errno.56 is: Invalid request code
errno.57 is: Invalid slot
errno.58 is: Unknown error 58
errno.59 is: Bad font file format
errno.60 is: Device not a stream
errno.61 is: No data available
errno.62 is: Timer expired
errno.63 is: Out of streams resources
errno.64 is: Machine is not on the network
errno.65 is: Package not installed
errno.66 is: Object is remote
errno.67 is: Link has been severed
errno.68 is: Advertise error
errno.69 is: Srmount error
errno.70 is: Communication error on send
errno.71 is: Protocol error
errno.72 is: Multihop attempted
errno.73 is: RFS specific error
errno.74 is: Bad message
errno.75 is: Value too large for defined data type
errno.76 is: Name not unique on network
errno.77 is: File descriptor in bad state
errno.78 is: Remote address changed
errno.79 is: Can not access a needed shared library
errno.80 is: Accessing a corrupted shared library
errno.81 is: .lib section in a.out corrupted
errno.82 is: Attempting to link in too many shared libraries
errno.83 is: Cannot exec a shared library directly
errno.84 is: Invalid or incomplete multibyte or wide character
errno.85 is: Interrupted system call should be restarted
errno.86 is: Streams pipe error
errno.87 is: Too many users
errno.88 is: Socket operation on non-socket
errno.89 is: Destination address required
errno.90 is: Message too long
errno.91 is: Protocol wrong type for socket
errno.92 is: Protocol not available
errno.93 is: Protocol not supported
errno.94 is: Socket type not supported
errno.95 is: Operation not supported
errno.96 is: Protocol family not supported
errno.97 is: Address family not supported by protocol
errno.98 is: Address already in use
errno.99 is: Cannot assign requested address
errno.100 is: Network is down
errno.101 is: Network is unreachable
errno.102 is: Network dropped connection on reset
errno.103 is: Software caused connection abort
errno.104 is: Connection reset by peer
errno.105 is: No buffer space available
errno.106 is: Transport endpoint is already connected
errno.107 is: Transport endpoint is not connected
errno.108 is: Cannot send after transport endpoint shutdown
errno.109 is: Too many references: cannot splice
errno.110 is: Connection timed out
errno.111 is: Connection refused
errno.112 is: Host is down
errno.113 is: No route to host
errno.114 is: Operation already in progress
errno.115 is: Operation now in progress
errno.116 is: Stale NFS file handle
errno.117 is: Structure needs cleaning
errno.118 is: Not a XENIX named type file
errno.119 is: No XENIX semaphores available
errno.120 is: Is a named type file
errno.121 is: Remote I/O error
errno.122 is: Disk quota exceeded
errno.123 is: No medium found
errno.124 is: Wrong medium type
errno.125 is: Operation canceled
errno.126 is: Required key not available
errno.127 is: Key has expired
errno.128 is: Key has been revoked
errno.129 is: Key was rejected by service
errno.130 is: Owner died
errno.131 is: State not recoverable
errno.132 is: Unknown error 132
132-255全是Unknown error

天下 2012-01-06 11:15 发表评论

为项目定制VC2008

天下 — Wed, 09 Nov 2011 01:01:00 GMT

@rem VC2008ForArmLinux
@rem 这样的启动的批处理,定制启动VC2008,就是一个纯C/C++的IDE,不包含MS的CRT库及头文件等.这样定制可以用来开发Linux下的项目.

@SET VSINSTALLDIR=C:\Program Files\Microsoft Visual Studio 9.0
@SET VCINSTALLDIR=C:\Program Files\Microsoft Visual Studio 9.0\VC
@rem 这里可以定制INCLUDE的路径,以适应项目.
@set "INCLUDE=

C:\Program Files\ASIDE\MetaWare\arc\inc

"
@set "LIB="
@set PATH=C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE;C:\Program Files\Microsoft Visual Studio 9.0\VC\BIN;C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools;C:\Program Files\Microsoft Visual Studio 9.0\VC\VCPackages;
@devenv /use env

天下 2011-11-09 09:01 发表评论

Debian 6 驱动开发环境搭建

天下 — Tue, 01 Nov 2011 06:24:00 GMT

Debian 6 驱动开发环境搭建
1.安装相关工具
apt-get install -y gcc g++ gdb make build-essential

2.查看系统版本,并安装内核头文件
root@192.168.20.128:~/ # uname -r
2.6.32-5-686
apt-cache search linux-headers-2.6.32-5-686
apt-get install -y linux-headers-2.6.32-5-686

3.查看内核头文件位置
看下会安装到哪:
apt-cache show linux-headers-2.6.32-5-686

有这么句:
These files are going to be installed into
/usr/src/linux-headers-2.6.32-5-686, and can be used for building modules

就是这里啦.
/usr/src/linux-headers-2.6.32-5-686

4.好了,接下来写测试例子:hello,抄了http://bbs.chinaunix.net/thread-3570849-1-1.html
上的代码:
文件1:hello.c
#include
#include
MODULE_LICENSE("GPL");

static int hello_init(void)
{
    printk(KERN_ALERT "Hello, world\n");
    return 0;
}

static void hello_exit(void)
{
    printk(KERN_ALERT "Goodbye, cruel world\n");
}

module_init(hello_init);
module_exit(hello_exit);

文件2:Makefile:
obj-m   +=hello.o
KERNELDIR   := /usr/src/linux-headers-2.6.32-5-686
PWD :=$(shell pwd)
.PHONY: test clean all
all:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versionsm *.order *.symvers

test:
    insmod ./hello.ko
    rmmod hello
    dmesg -c

5.好了,现在测试开始,成功的话,就可以看到下面的文字了.
如果有问题的话,向google大神请教吧.另外要看
root@192.168.20.128:~/cpp # make
make -C /usr/src/linux-headers-2.6.32-5-686 M=/root/cpp modules
make[1]: Entering directory `/usr/src/linux-headers-2.6.32-5-686'
  CC [M]  /root/cpp/hello.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /root/cpp/hello.mod.o
  LD [M]  /root/cpp/hello.ko
make[1]: Leaving directory `/usr/src/linux-headers-2.6.32-5-686'
root@192.168.20.128:~/cpp # make test
insmod ./hello.ko
rmmod hello
dmesg -c
[  673.500413] Hello, world
[  673.504907] Goodbye, cruel world
root@192.168.20.128:~/cpp #

6.最后.安装开发帮助文档
apt-get install -y manpages-kernel-dev linux-manual
man 9 printk
man 9 module_init

参考资料:
http://bbs.chinaunix.net/thread-3570849-1-1.html

天下 2011-11-01 14:24 发表评论

简单Makefile的编写

天下 — Wed, 12 Oct 2011 09:01:00 GMT

指定目标

all
这个伪目标是所有目标的目标，其功能一般是编译所有的目标。

clean
这个伪目标功能是删除所有被make创建的文件。

install
这个伪目标功能是安装已编译好的程序，其实就是把目标执行文件拷贝到指定的目标中去。

print
这个伪目标的功能是例出改变过的源文件。

tar
这个伪目标功能是把源程序打包备份。也就是一个tar文件。

dist
这个伪目标功能是创建一个压缩文件，一般是把tar文件压成Z文件。或是gz文件。

TAGS
这个伪目标功能是更新所有的目标，以备完整地重编译使用。

check和test
这两个伪目标一般用来测试makefile的流程。

自动化变量

$@
表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，$@就是匹配于目标中模式定义的集合。

$^
所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，那个这个变量会去除重复的依赖目标，只保留一份。

$?
所有比目标新的依赖目标的集合。以空格分隔。

$+
这个变量很像$^，也是所有依赖目标的集合。只是它不去除重复的依赖目标。

$%
当规划的目标文件是库文件时，$%表示规则中的目标成员名。
例如，如果一个目标是foo.a(bar.o)，那么，$%就是bar.o，$@就是foo.a。
如果目标不是函数库文件（Unix下是[.a]，Windows下是[.lib]），那么其值为空。

$<
依赖目标中的第一个目标名字。如果依赖目标是以模式（即%）定义的，那么$<将是符合模式的一系列的文件集。注意，其是一个一个取出来的。

例子:

CCLD    = g++ -Wall -g -o
CC    = g++ -Wall -c
OBJS = SocketServer.o
TARGETS = 0928

.PHONY:all
all:$(TARGETS)

SocketServer.o:SocketServer.cpp
    $(CC) $^

0928:$(OBJS) main.cpp
    $(CCLD) $@ $^
    @echo make success

.PHONY:clean
clean:
    #rm -rf ${OBJS}
    rm -rf *.o
    rm -rf $(TARGETS)

天下 2011-10-12 17:01 发表评论

qt对话框+线程小试

天下 — Thu, 22 Sep 2011 02:24:00 GMT

//thread.h
#pragma once
#define QT3_SUPPORT
#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <Qt/qapplication.h>
#include <Qt/qpushbutton.h>
#include <qmessagebox.h>
#include <Qt/qdialog.h>
#include <Qt/qthread.h>
#include <QString>

template<typename T>
class Thread : public QThread
{
public:
    Thread();
    ~Thread();
    void run();
    void setTObj(T* pobj);
public:
    int flag;
    unsigned int pos;
    T* pTObj;
};

template<typename T>
Thread<T>::Thread()
{
    flag = 1;
    pos =0;
}

template<typename T>
Thread<T>::~Thread()
{

}

template<typename T>
void Thread<T>::run()
{
    //QMessageBox::information( NULL, "Application name","Started.\n");
    QString strText;
    while(flag)
    {
        strText.sprintf("flag:%d",pos);
        pTObj->setWindowTitle(strText);
        pos++;
        QThread::msleep(500);
    }
}

template<typename T>
void Thread<T>::setTObj(T* pobj)
{
    pTObj = pobj;
}

//ProcessDialog.h
#pragma once
#define QT3_SUPPORT

#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <Qt/qapplication.h>
#include <Qt/qpushbutton.h>
#include <qmessagebox.h>
#include <Qt/qdialog.h>
#include <Qt/qthread.h>
#include <QString>
#include "Thread.h"

class ProcessDialog :public QDialog
{
    Q_OBJECT
public:
    ProcessDialog(QWidget* parent=0)
        :btnStop("Stop",this)
        ,btnWork("Work",this)
    {
        btnStop.setGeometry( 62, 40, 75, 30 );
        btnWork.setGeometry( 162,140, 75, 30 );

        threadA.setTObj(this);

        connect(&btnWork,SIGNAL( clicked()),this,SLOT(start()) );
        connect(&btnStop,SIGNAL( clicked()),this,SLOT(stop()) );
    }

public:
    QPushButton btnStop;
    QPushButton btnWork;
    private slots:
        void start()
        {
            btnWork.setText("Working");
            threadA.start();
            threadA.flag = 1;
        }
        void stop()
        {
            btnWork.setText("Work");
            threadA.flag = 0;
            //threadA.pos  = 0;
        }

private:
    Thread<ProcessDialog> threadA;
};

//main.cpp
#define QT3_SUPPORT
#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <Qt/qapplication.h>
#include <Qt/qpushbutton.h>
#include <qmessagebox.h>
#include <Qt/qdialog.h>
#include <Qt/qthread.h>
#include <QString>
#include "Thread.h"
#include "ProcessDialog.h"

int main( int argc, char **argv )
{
    QApplication app( argc, argv );
    ProcessDialog dlg;
    app.setMainWidget( &dlg );
    dlg.resize(640,480);
    dlg.setModal(true);
    dlg.exec();
    return app.exec();
}

天下 2011-09-22 10:24 发表评论

Linux Socket子进程模式服务端Demo 63.cpp

天下 — Thu, 08 Sep 2011 08:06:00 GMT

// File: 63.cpp
//客户端代码 62.cpp
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 1234   /* Port that will be opened */
#define BACKLOG 5   /* Number of allowed connections */
#define MAXDATASIZE 4096

void process_cli(int connectfd,struct sockaddr_in client);

int main()
{
int listenfd, connectfd; /* socket descriptors */
pid_t pid;
struct sockaddr_in server; /* server's address information */
struct sockaddr_in client; /* client's address information */
socklen_t sin_size;

/* Create TCP socket  */
if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
  /* handle exception */
  perror("Creating socket failed.\n");
  exit(1);
}

int opt = SO_REUSEADDR;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

bzero(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(PORT);
server.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(listenfd, (struct sockaddr *)&server, sizeof(struct sockaddr)) == -1) {
  /* handle exception */
  perror("Bind error.\n");
  exit(1);
}

if(listen(listenfd,BACKLOG) == -1){  /* calls listen() */
  perror("listen() error\n");
  exit(1);
}

sin_size=sizeof(struct sockaddr_in);

while(1)
{
  /*accept connection */
  if ((connectfd = accept(listenfd,(struct sockaddr *)&client,&sin_size))==-1) {
   perror("accept() error\n");
   exit(1);
  }
  /*  Create child process to service client */
  if ((pid=fork())>0) {
   /* parent process */
   close(connectfd);
   continue;
  }
  else if (pid==0) {
   /*child process*/
   close(listenfd);
   process_cli(connectfd, client);
   exit(0);
  }
  else {
   perror("fork() error\n");
   exit(0);
  }
}
close(listenfd);   /* close listenfd */
}

void process_cli(int connectfd, struct sockaddr_in client)
{
int num;
char recvbuf[MAXDATASIZE], sendbuf[MAXDATASIZE];

/* prints client's IP */
printf("%s:%d Client was connected\n",inet_ntoa(client.sin_addr), ntohs( client.sin_port) );

while (1) {
  num = recv(connectfd, recvbuf, MAXDATASIZE,0);
  if (num == 0) {
   close(connectfd);
   printf("%s:%d Client was disconnected \n",inet_ntoa(client.sin_addr), ntohs( client.sin_port) );
   break;
  }
  if (num == -1) {
   perror("recv() error\n");
   break;
  }
  printf("recvbuf[0]:%d,recvbuf[num-1]:%d,num:%d\n",recvbuf[0],recvbuf[num-1],num);
  recvbuf[num] = '\0';
  printf("Received message From Client : %s\n",recvbuf);
  for (int i = 0; i < num; i++) {
   sendbuf[i] = recvbuf[num-i-1];
   //printf("sendbuf[%d]:%d\n",i,sendbuf[i]);
  }
  //printf("sendbuf[0]:%d,sendbuf[num-1]:%d,num:%d\n",sendbuf[0],sendbuf[num-1],num);
  send(connectfd,sendbuf,num,0); /* send to the client welcome message */
}
close(connectfd); /*  close connectfd */
}

天下 2011-09-08 16:06 发表评论

Linux Socket阻塞模式服务端Demo 61.cpp

天下 — Thu, 08 Sep 2011 08:06:00 GMT

// File: 61.cpp
//客户端代码 62.cpp
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 1234   /* Port that will be opened */
#define BACKLOG 5   /* Number of allowed connections */
#define MAXDATASIZE 4096

void process_cli(int connectfd,struct sockaddr_in client);

int main()  {
int listenfd, connectfd; /* socket descriptors */
struct sockaddr_in server; /* server's address information */
struct sockaddr_in client; /* client's address information */
socklen_t sin_size;

/* Create TCP socket  */
if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  {
  /* handle exception */
  perror("Creating socket failed.\n");
  exit(1);
}

int opt = SO_REUSEADDR;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

bzero(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(PORT);
server.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind(listenfd, (struct sockaddr *)&server, sizeof(struct sockaddr)) == -1) {
  /* handle exception */
  perror("Bind error.\n");
  exit(1);
}

if(listen(listenfd,BACKLOG) == -1){  /* calls listen() */
  perror("listen() error\n");
  exit(1);
}

sin_size=sizeof(struct sockaddr_in);
while (1) {
  if ((connectfd = accept(listenfd,(struct sockaddr *)&client,&sin_size))==-1) {
   perror("accept() error\n");
   exit(1);
  }
  process_cli(connectfd, client);
}

close(listenfd);
}

void process_cli(int connectfd, struct sockaddr_in client)
{
int num;
char recvbuf[MAXDATASIZE], sendbuf[MAXDATASIZE];

/* prints client's IP */
printf("%s:%d Client was connected\n",inet_ntoa(client.sin_addr), ntohs( client.sin_port) );

while (1) {
  num = recv(connectfd, recvbuf, MAXDATASIZE,0);
  if (num == 0) {
   close(connectfd);
   printf("%s:%d Client was disconnected \n",inet_ntoa(client.sin_addr), ntohs( client.sin_port) );
   break;
  }
  if (num == -1) {
   perror("recv() error\n");
   break;
  }
  printf("recvbuf[0]:%d,recvbuf[num-1]:%d,num:%d\n",recvbuf[0],recvbuf[num-1],num);
  recvbuf[num] = '\0';
  printf("Received message From Client : %s\n",recvbuf);
  for (int i = 0; i < num; i++) {
   sendbuf[i] = recvbuf[num-i-1];
   //printf("sendbuf[%d]:%d\n",i,sendbuf[i]);
  }
  //printf("sendbuf[0]:%d,sendbuf[num-1]:%d,num:%d\n",sendbuf[0],sendbuf[num-1],num);
  send(connectfd,sendbuf,num,0); /* send to the client welcome message */
}
close(connectfd); /*  close connectfd */
}

天下 2011-09-08 16:06 发表评论