Linux简单程序实例（GNU工具链，进程，线程，无名管道pipe，基于fd的文件操作，信号，scoket）

一， GNU工具链简介：

        （1）编译代码步骤：

              预处理 -> 编译 -> 汇编 -> 链接；

              

              预处理：去掉注释，进行宏替换，头文件包含等工作；

              gcc -E test.c -o test.i

              编译：   不同平台使用汇编语言不同，汇编将高级语言编译成汇编语言；

              gcc -S test.c -o test.s

              汇编：   将汇编语言翻译成二进制代码；

              gcc -c test.c -o test.o

              链接：   包含各函数库的入口，得到可执行文件；

              gcc -o test test.c

       （2）gcc编译：

              .c文件编译：gcc -o DESFILE SRCFILE ，将源c文件SRCTILE编译为可执行文件DESFILE ；

                              gcc -o DESFILE SRCFILE ，加上-g选项，生成的可执行文件DESFILE可进行调试；

       （2）gdb调试：

              调试前提：gcc编译时加入-g参数；

              调试选项:gdb DESFILE 进入调试，

                           l 列出代码信息,后面可带整数参数;

                           b 设断点，后面跟要设断点的函数名或者行数;

                           r 运行;

                           n 下一步;

                           c 继续;

                           q 退出，退出调试；

二，Linux下简单编程实例：

        （1）进程创建：

               函数说明：

              #include <sys/types.h>

              #include <unistd.h>

              pid_t fork();

              调用fork()创建进程，若创建成功，父进程返回子进程ID(>0)，子进程返回0，出错返回-1；

              

              实例:

             

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main(void)
{
       pid_t child_pid;
       printf("the main program process ID is:%d",(int)getpid);
       child_pid = fork();
       if(child_pid >0)
       {
             printf("This is parent process:%d
",(int)getpid);
        }
        else if(pid == 0)
        {
             printf("This is child process:%d
",(int)getpid);
         }
         else
         {
             printf("fork() occurr erro!
");
         }
         return 0;
}

              

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int spawn(char* progam,char** arg_list)
{
        pid_t child_pid;
        child_pid = fork();
        if(child_pid!=0)
        {
                return child_pid;
        }
        else
        {
                execvp(program,arg_list);
                fprintf(stderr,"Erro occured!
");
                abort();
         }
         return 0;
}

int main(void)
{
         char* arg_list[] = {"ls","-l","/",NULL};
         spawn("ls",arg_list);
         return 0;
}

         （2）线程创建：

                函数说明：

                int pthread_create(pthread_t *thread,const pthread_attr_t *attr,

                                                     void *(start_routine)(void *),void *arg);

                第一个参数为线程ID；

                第二个参数为线程属性，可默认为NULL;

                第三个参数为线程执行的函数；

                第四个为函数的参数；

           实例：

           线程创建：

#include <stdio.h>
#include <sys/types.h>
#include <pthread.h>

void* print_x(void* unused)
{
       while(1)
       {
            printf("x");
        }
        return NULL;
}

int main(void)
{
        pthread_t thread_id;
        pthread_create(&thread_id,NULL,&print_x,NULL);
        while(1)
        {
             printf("s");
        }
        return 0;
}

          （3）信号:

                  signal:软件中断，传递给进程的异步消息；

                  当进程收到信号后，将立即对信号进行处理；

                  信号可以在任何代码位置中断；

                  

           实例：

           

#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>

void sig_usr(int signo)
{
       printf("Receive signal !
");
}

int main(void)
{
       printf("%d
",(int)getpid());
       if(signal(SIGUSR1,sig_usr)==SIG_ERR)
       {
             printf("Can't catch signal");
       }
       for(;;)
       {
             pause();
       }
       return 0;
}

            （4）线程，信号量

                   

             实例:

             

void* thread_fun(void* arg)
{
       while(1)
       {
                pthread_mutex_lock(&thread_flag_mutex);
                while(!thread_flag)
                {
                                 thread_cond_wait(&thread_flag_cv,&thread_flag_mutex);
                }
                pthread_mutex_unlock();
                do_work();
       }
       return NULL;
}

void set_thread_flag(int flag_vlaue)
{
       pthread_mutex_lock(&thread_flag_mutex);
       thread_flag_mutex = flag_vlaue;
       pthread_cond_signal(&thread_flag_cv);
       pthread_mutex_unlock(&thread_flag_mutex);
}

            

            （5）无名管道pipe:

                  函数原型: int pipe(int fd[2]);

                 生成两个文件描述符，一个用于读f[0],一个用于写f[1];

                 无名管道的使用条件：父子进程；

             实例：

                

             

#include <unistd>

int main(void)
{
      int fd[2];
      char buffer[80];
      pipe(fd);
      if(fork()>0)
      {
            char s[] = "Hello!
";
            write(fd[1],s,sizeof(s));
      }
      else
      {
           read(fd[1],buffer,80);
           printf("buffer: %s",buffer);
      }
      return 0;
}

             （6）基于文件描述符的文件简单操作：

              文件打开与关闭函数：

              #include <sys/types.h>

              #include <sys/stat.h>

              #include <fcntl.h>

              int open(const char *pathname,int flags);

              int open(const char *pathname,int flags,mode_t mode);

              int close(int fd);

              flags类型：flags决定文件的打开方式，有以下常用类型：

                             O_RDONLY:只读；      O_RDWR:读写；

                             O_WRONLY:只写；      O_CREAT:若文件不存在则创建；     

              文件读写函数：

              #include <unistd.h>

              ssize_t read(int fd,void *buf,size_t count);

              ssize_t write(int fdvoid *buf,size_t count);

              

              文件的定位：

              #include <sys/types.h>

              #include <unistd.h>

              off_t lseek(int fd,off_t offset,int whence);

              fd:文件注释符；

              offset:偏移量；

              whence:取值范围：SEEK_SET(将文件位移量设置为据文件开始出offset字节)；

                                       SEEK_CUR(将文件位移量设置为当前值+offset字节)；

                                       SEEK_END(将文件位移量设置为文件长度+offset字节)；

             

               

               实例：

               

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(void)
{
      char s[] = "Linux c program!
"
      char buffer[80];
      int fd,count;
      fd = open("./test.txt",O_WRONLY|O_CREAT);
      write(fd,s,sizeof(s));
      close(fd);
      fd = open("./test.txt",O_RDONLY);
      count = read(fd,buffer,80);
      close(fd);
      printf("buffer:%s",buffer);
      return 0;
}

              （7）socket客户端与服务器端：

                基于TCP的socket通信流程：

                           

                socket套接字基础：

                               IPV4套接字：

                               #include <netinet/in.h>

                               struct sockaddr_in

                               {

                                        unsigned short        sin_len;        //IPV4 地址长度

                                        sa_family_t             sin_family;   //通信地址类型,AF_INET对应IPV4, AF_INET6对应IPV6

                                        unsigned short int    sin_port;     //16位端口号，以网络字节序存储

                                        struct in_addr          sin_addr;    //将要访问的IP地址, 其中struct in_addr{uint32_t s_addr;}以网络字节顺序

                                        unsigned char          sin_zero[8];//未使用的字段，填充为0

                                 }

                           

                                  struct hostent结构体定义：

                                  struct hostent

                                  {

                                         char   *h_name;         //主机正式名称

                                         char   **h_aliases;      //主机别名

                                         int     h_addrtype;      //主机地址类型，IPV4为AF_INET

                                         int     h_length;          //地址长度，IPV4为4字节，32位

                                         char   **h_addr_list;   //主机IP地址列表

                                   };

                                   函数:

                                   #include <netdb.h>

                                   struct hostent *gethostbyname(const char *hostname);                      //实现域名或主机名到IP地址的转换

                                   struct hostent *gethostbyaddr(const char *addr,size_t len,int family);  //实现IP地址到域名或主机名的转换

                客户端：

                主要函数：

                socket()：建立套接字，设定远程IP和端口；

                connect()：连接远程计算机指定端口；

                read()或recv()，读取客户端发来的数据；

                write()或send()发送数据；

                    

          

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

#define MYPORT  8887
#define BUFFER_SIZE 1024

int main()
{
    ///定义sockfd
    int sock_cli = socket(AF_INET,SOCK_STREAM, 0);

    ///定义sockaddr_in
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(MYPORT);  ///服务器端口
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  ///服务器ip

    ///连接服务器，成功返回0，错误返回-1
    if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        perror("connect");
        exit(1);
    }

    char sendbuf[BUFFER_SIZE];
    char recvbuf[BUFFER_SIZE];
    while (fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
    {
        send(sock_cli, sendbuf, strlen(sendbuf),0); ///发送
        if(strcmp(sendbuf,"exit
")==0)
            break;
        recv(sock_cli, recvbuf, sizeof(recvbuf),0); ///接收
        fputs(recvbuf, stdout);

        memset(sendbuf, 0, sizeof(sendbuf));
        memset(recvbuf, 0, sizeof(recvbuf));
    }

    close(sock_cli);
    return 0;
}

                服务器端：

                主要函数：

                socke()：建立套接字，用这个套接字完成通讯监听，数据收发；

                bind()： 绑定一个端口号和一个IP,使套接字与之关联;

                listen()：使服务器该端口和IP处于监听状态，等待连接请求；

                accept()：接收远程计算机的连接请求，建立服务器与客户端之间的连接；

                read()或recv()，读取客户端发来的数据；

                write()或send()发送数据；

          

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

#define MYPORT  8887
#define QUEUE   20
#define BUFFER_SIZE 1024

int main()
{
    ///定义sockfd
    int server_sockfd = socket(AF_INET,SOCK_STREAM, 0);

    ///定义sockaddr_in
    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(MYPORT);
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    ///bind，成功返回0，出错返回-1
    if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,sizeof(server_sockaddr))==-1)
    {
        perror("bind");
        exit(1);
    }

    ///listen，成功返回0，出错返回-1
    if(listen(server_sockfd,QUEUE) == -1)
    {
        perror("listen");
        exit(1);
    }

    ///客户端套接字
    char buffer[BUFFER_SIZE];
    struct sockaddr_in client_addr;
    socklen_t length = sizeof(client_addr);

    ///成功返回非负描述字，出错返回-1
    int conn = accept(server_sockfd, (struct sockaddr*)&client_addr, &length);
    if(conn<0)
    {
        perror("connect");
        exit(1);
    }

    while(1)
    {
        memset(buffer,0,sizeof(buffer));
        int len = recv(conn, buffer, sizeof(buffer),0);
        if(strcmp(buffer,"exit
")==0)
            break;
        fputs(buffer, stdout);
        send(conn, buffer, len, 0);
    }
    close(conn);
    close(server_sockfd);
    return 0;
}