socket多进程编程

socket多进程编程

一、服务器并发访问的问题

服务器按处理方式可以分为迭代服务器和并发服务器两类。平常用C写的简单Socket客户端服务器通信，服务器每次只能处理一个客户的请求，它实现简单但效率很低，通常这种服务器被称为迭代服务器。 然而在实际应用中，不可能让一个服务器长时间地为一个客户服务，而需要其具有同时处理 多个客户请求的能力，这种同时可以处理多个客户请求的服务器称为并发服务器，其效率很 高却实现复杂。在实际应用中，并发服务器应用的最广泛。linux有3种实现并发服务器的方式：多进程并发服务器，多线程并发服务器，IO复用，先来看多进程并发服务器的实现。

二、多进程编程

1.什么是一个进程？

在操作系统原理使用这样的术语来描述的：正在运行的程序及其占用的资源(CPU、内存、系统资源等)叫做进程。站在程序员的角度来看，我们使用vim编辑生成的C文件叫做源码，源码给程序员来看的但机器不识别，这时我们需要使用编译器gcc编译生成CPU可识别的二进制可执行程序并保存在存储介质上，这时编译生成的可执行程序只能叫做程序而不能叫进程。而一旦我们通过命令(./a.out)开始运行时，那正在运行的这个程序及其占用的资源就叫做进程了。进程这个概念是针对系统而不是针对用户的，对用户来说，他面对的概念是程序。很显然，一个程序可以执行多次，这也意味着多个进程可以执行同一个程序。

2.进程空间内存布局

在深入理解Linux下多进程编程之前，我们首先要了解Linux下进程在运行时的内存布局。Linux 进程内存管理的对象都是虚拟内存，每个进程先天就有 0-4G 的各自互不干涉的虚拟内存空间，0—3G 是用户空间执行用户自己的代码, 高 1GB 的空间是内核空间执行 Linu x 系统调用，这里存放在整个内核的代码和所有的内核模块，用户所看到和接触的都是该虚拟地址，并不是实际的物理内存地址。

Linux下一个进程在内存里有三部分的数据，就是”代码段”、”堆栈段”和”数据段”。其实学过汇编语言的人一定知道，一般的CPU都有上述三种段寄存器，以方便操作系统的运行。这三个部分是构成一个完整的执行序列的必要的部分。

代码段，顾名思义，就是存放了程序代码的数据，假如机器中有数个进程运行相同的一个程序，那么它们就可以使用相同的代码段。
堆栈段存放的就是子程 序的返回地址、子程序的参数以及程序的局部变量和malloc()动态申请内存的地址。
数据段则存放程序的全局变量，静态变量及常量的内存空间。

下图是Linux下进程的内存布局：

栈:栈内存由编译器在程序编译阶段完成，进程的栈空间位于进程用户空间的顶部并且是向下增长，每个函数的每次调用都会在栈空间中开辟自己的栈空间，函数参数、局部变量、函数返回地址等都会按照先入者为栈顶的顺序压入函数栈中，函数返回后该函数的栈空间消失，所以函数中返回局部变量的地址都是非法的。

堆:堆内存是在程序执行过程中分配的，用于存放进程运行中被动态分配的的变量，大小并不固定，堆位于非初始化数据段和栈之间，并且使用过程中是向栈空间靠近的。当进程调用 malloc 等函数分配内存时，新分配的内存并不是该函数的栈帧中，而是被动态添加到堆上，此时堆就向高地址扩张；当利用 free 等函数释放内存时，被释放的内存从堆中被踢出，堆就会缩减。因为动态分配的内存并不在函数栈帧中，所以即使函数返回这段内存也是不会消失。

非初始化数据段。通常将此段称为 bss 段，用来存放未初始化的全局变量和 static 静态变量:并且在程序开始执行之前，就是在 main()之前，内核会将此段中的数据初始化为 0 或空指针。

初始化数据段:用来保已初始化的全局变量和 static 静态变量。

文本段也称代码段，这是可执行文件中由 CPU 执行的机器指令部分。正文段常常是只读的，以防止程序由于意外而修改其自身的执行

Linux 内存管理的基本思想就是只有在真正访问一个地址的时候才建立这个地址的物理映射，Linux C/C++语言的分配方式共有
3 种方式。

（1）从静态存储区域分配。就是数据段的内存分配，这段内存在程序编译阶段就已经分配好，在程序的整个运行期间都存在，
例如全局变量，static 变量。

（2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是系统栈中分配的内存容量有限，比如大额数组就会把栈空间撑爆导致段错误。

（3）从堆上分配，亦称动态内存分配。程序在运行的时候用 malloc 或 new 申请任意多少的内存，程序员自己负责在何时用free 或 delete 释放内存。此 区域内存分配称之为动态内存分配。动态内存的生存期由我们决定，使用非常灵活，但问题也最多，比如指向某个内存块的指针取值发生了变化又没有其他指针指向 这块内存，这块内存就无法访问，发生内存泄露。

3.fork()系统调用

Linux内核在启动的最后阶段会创建init进程来执行程序/sbin/init，该进程是系统运行的第一个进程，进程号为 1，称为Linux 系统的初始化进程，该进程会创建其他子进程来启动不同写系统服务，而每个服务又可能创建不同的子进程来执行不同的程序r。所以init进程是所有其他进程的“祖先”，并且它是由Linux内核创建并以root的权限运行，并不能被杀死。Linux 中维护着一个数据结构叫做 进程表，保存当前加载在内存中的所有进程的有关信息，其中包括进程的 PID(Process ID)、进程的状态、命令字符串等，操作系统通过进程的 PID 对它们进行管理，这些 PID 是进程表的索引。

Linux下有两个基本的系统调用可以用于创建子进程：fork()和vfork()。fork英文中是"分叉"的意思。为什么取这个名字呢？因为一个进程在运行中，如果使用了fork，就产生了另一个进程，于是进程就”分叉”了，所以这个名字取得很形象。
fork()的函数原型及返回值：

#include <unistd.h>

pid_t fork(void);
RETURN VALUE
       On success, the PID of the child process is returned in the parent, and 0 is returned in
       the  child.   On failure, -1 is returned in the parent, no child process is created, and
       errno is set appropriately.
       /*fork()系统调用会创建一个新的进程，这时它会有两次返回。
       一次返回是给父进程，其返回值是子进程的PID(Process ID)，
       第二次返回是给子进程，其返回值为0。*/

系统调用fork()会创建一个新的子进程，这个子进程是父进程的一个副本。这也意味着，系统在创建新的子进程成功后，会将父进程的文本段、数据段、堆栈都复制一份给子进程，但子进程有自己独立的空间，子进程对这些内存的修改并不会影响父进程空间的相应内存。这就好比你父母之前买了一套房子。等到你结婚了，又买了一套一模一样的房子给你，然后你对这套房子怎么装修都不会影响到你父母的房子！

在我们编程的过程中，一个函数调用只有一次返回(return)，但由于fork()系统调用会创建一个新的进程，这时它会有两次返回。一次返回是给父进程，其返回值是子进程的PID(Process ID)，第二次返回是给子程，其返回值为0。所以我们在调用fork()后，需要通过其返回值来判断当前的代码是在父进程还是子进程运行，如果返回值是0说明现在是子进程在运行，如果返回值>0说明是父进程在运行，而如果返回值<0的话，说明fork()系统调用出错。
fork 函数调用失败的原因主要有两个：

1. 系统中已经有太多的进 程；
2. 该实际用户 ID 的进程总数超过了系统限制。

每个子进程只有一个父进程，并且每个进程都可以通过getpid()获取自己的进程PID，也可以通过getppid()获取父进程的PID，这样在fork()时返回0给子进程是可取的。一个进程可以创建多个子进程，这样对于父进程而言，他并没有一个API函数可以获取其子进程的进程ID，所以父进程在通过fork()创建子进程的时候，必须通过返回值的形式告诉父进程其创建的子进程PID。这也是fork()系统调用两次返回值设计的原因。

4.进程的退出

关于进程的退出，我们知道在main()函数里使用return，就会调用exit()函数，从而导致进程退出。对于其他函数，在其任何位置调用exit()也会导致进程退出。因此，倘若子进程使用了return，那么子进程就会退出；同理，父进程使用了return，也会退出。这里我们需要注意的是：在编程时，在程序的任何位置调用exit()函数都会导致本进程退出；在main()函数中使用return，会导致进程退出；但在其他函数中使用return都只是令这个函数返回，而不会导致进程退出。

我们通过下面的程序例子来描述父进程创建子进程的过程来更深入的理解。
示例代码如下：

#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

int g_var = 6;
char g_buf[] = "A string write to stdout.\n";

int main (int argc, char **argv)
{
		int 		var = 88;
 		pid_t 		pid;

 		if (write(STDOUT_FILENO, g_buf, sizeof(g_buf)-1) < 0)
	    {
 			printf("Write string to stdout error: %s\n", strerror(errno));
			return -1;
 		}

 		printf("Befor fork\n");

 		if ((pid = fork()) < 0)
 		{
			printf("fork() error: %s\n", strerror(errno));
			return -2;
 		}
		else if ( 0 == pid)
 		{
 			printf("Child process PID[%d] running...\n", getpid());
 			g_var++;
			var++;
		}
 		else
 		{
 			printf("Parent process PID[%d] waiting...\n", getpid());
 			sleep(1);
 		}

		printf("PID=%ld, g_var=%d, var=%d\n", (long) getpid(), g_var, var);
 		return 0;
}

gcc编译：

gcc fork_var.c -o fork_var
./fork_var

运行结果：

A string write to stdout.
Befor fork
Parent process PID[27642] waiting...
Child process PID[27643] running...
PID=27643, g_var=7, var=89
PID=27642, g_var=6, var=88

程序分析：

1. 因为进程创建之后究竟是父进程还是子进程先运行没有规定，所以父进程在第35行调用了sleep(1)的目的是希望让子进程先运行，但这个机制是不能100%确定能让子进程先执行，**如果系统负载较大时1秒的时间内操作系统可能还没调度到子进程运行，**所以sleep()这个机制并不可靠，这时候我们需要使用到今后学习的进程间通信机制来实现这种父子进程之间的同步问题；

2. 程序中38行的printf()被执行了两次，这是因为fork()之后，子进程会复制父进程的代码段，这样38行的代码也被复制给子进程了。而子进程在运行到第30行后并没有调用return()或exit()函数让进程退出，所以程序会继续执行到38行至39行调用return 0退出子进程；同理父进程也是执行38行至39行才让父进程退出，所以38行的printf()分别被父子进程执行了两次。

3. 子进程在第29行和30行改变了这两个变量的值，这个改变只影响子进程的空间的值，并不会影响父进程的内存空间，所以子进程里g_var和var分别变成了7和89，而父进程的g_var和var都没改变；

./fork_var > tmp.log
 cat tmp.log

A string write to stdout.
Befor fork
Child process PID[27647] running...
PID=27647, g_var=7, var=89
Befor fork
Parent process PID[27646] waiting...
PID=27646, g_var=6, var=88

当第二次运行时，我们将标注输出重定向到了tmp.log文件中，这时我们发现13行处的"A string write to stdout.“在两次执行的过程中都只打印了一次，而19行处的"Befor fork” 却在重定向执行时打印了两次。这是因为：

1. write()系统调用是不带缓冲的，不管是否有重定向，13行的输出会立刻输出到标准输出里；
2. printf()库函数在标准输出是终端时默认是行缓冲，而当标准输出重定向到文件中后该函数是全缓冲的；这样19行printf()在第一次没有重定向执行时碰到换行符(\n)时就立刻输出到标准输出里了，而第二次因为有重定向，这时的打印内容并不会输出到标准输出而是存放在缓冲区中。在第21行调用fork()创建子进程时，系统会将缓冲区的内容也复制给了子进程，这样父子进程的printf()缓冲区里都有"Befor fork"的内容。父子进程在运行至38行的时候printf()缓冲区里的内容还没有达到缓冲区的大小，而并不会打印，直到父子进程都执行到39行调用return 0时才会导致进程退出。而进程在退出的时候会自动Flush缓冲区里的数据，这时候才会将缓冲区的内容输出到标准输出tmp.log文件中。所以这种情况下"Beforfork"会被打印两次。

5. 子进程继承父进程哪些东西

我们可以从上面的例子中发现，当知道子进程从父进程那里继承了什么或未继承什么时，会有助于今后的多进程编程。下面这个列表会因为不同Unix的实现而发生变化，所以不能保证完全准确。另外，子进程得到的是这些东西的拷贝，而不是它们本身。

由子进程自父进程继承到：

• 进程的资格(真实(real)/有效(effective)/已保存(saved}
• 用户号(UIDs)和组号(GIDs)
• 环境(environment)变量
• 堆栈
• 内存
• 打开文件的描述符(注意对应的文件的位置由父子进程共享， 这会引起含糊情况)
• 执行时关闭(close-on-exec) 标志 信号(signal)控制设定
• nice值 (nice值由nice函数设定，该值表示进程的优先级， 数值越小，优先级越高)
• 进程调度类别(scheduler class) (进程调度类别指进程在系统中被调度时所属的类别，不同类别有不同优先级，根据进程调度类别和nice值，进程调度程序可计算出每个进程的全局优先级(Global process prority)，优先级高的进程优先执行)
• 进程组号
• 对话期ID(Session ID) (进程所属的对话期 (session)ID， 一个对话期包括一个或多个进程组， 详细说明参见《APUE》 9.5节)
• 当前工作目录
• 根目录 (根目录不一定是“/”，它可由chroot函数改变)
• 文件方式创建屏蔽字(file mode creation mask (umask))
• 资源限制
• 控制终端

子进程所独有：

• 进程号不同的父进程号(子进程的父进程号与父进程的父进程号不同， 父进程号可由getppid函数得到)
• 自己的文件描述符和目录流的拷贝(目录流由opendir函数创建，因其为顺序读取，顾称“目录流”)
• 子进程不继承父进程的进程，正文(text)， 数据和其它锁定内存(memory locks) (锁定内存指被锁定的虚拟内存页，锁定后，不允许内核将其在必要时换出(page out))
• 在tms结构中的系统时间(tms结构可由times函数获得， 它保存四个数据用于记录进程使用中央处理器 (CPU：Central Processing Unit)的时间，包括：用户时间，系统时间，用户各子进程合计时间，系统各子进程合计时间)
• 资源使用(resource utilizations)设定为0
• 阻塞信号集初始化为空集
• 不继承由timer_create函数创建的计时器
• 不继承异步输入和输出
• 不继承父进程设置的锁

6.exec*()执行另外一个程序

在上面的例子中，我们创建了一个子进程都是让子进程继续执行父进程的文本段，但更多的情况下是让该进程去执行另外一个程序。这时我们会在fork()之后紧接着调用exec*()系列的函数来让子进程去执行另外一个程序。其中exec*()是一些列的函数，其原型为：

int execl(const char *path, const char *arg, ...)
int execv(const char *path, char *const argv[])
int execle(const char *path, const char *arg, ..., char *const envp[])
int execve(const char *path, char *const argv[], char *const envp[])
int execlp(const char *file, const char *arg, ...)
int execvp(const char *file, char *const argv[])

在上面的函数名中，l 表示以列表(list)的形式传递要执行程序的命令行参数，而v表示以数组(vector)的形式传递要执行程序的命令行参数，而v表示给该命令传递环境变量(environment)。在这么多的函数调用中，我们选择一个实现即可，因为xecl()函数的参数相对简单些所以使用它要多些，接下来以一个程序实例来演示它的使用。首先看一下ifconfig eth0命令的输出：

eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
      inet 192.168.0.131 netmask 255.255.255.0 broadcast 192.168.2.255
      inet6 fe80::ba27:ebff:feb4:c096 prefixlen 64 scopeid 0x20<link>
      ether b8:27:eb:b4:c0:96 txqueuelen 1000 (Ethernet)
      RX packets 535546 bytes 129557958 (123.5 MiB)
      RX errors 0 dropped 0 overruns 0 frame 0
      TX packets 257794 bytes 45121061 (43.0 MiB)
      TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0

我们知道，在Linux下可以使用命令ifconfig eth0来获取网卡的IP地址，但如果我们想在C程序代码里获取IP地址又该如何实现呢？其实ifconfig命令本身是一个程序，这样我们可以在程序里创建一个子进程来执行这个程序即可。另外一个问题是该命令执行的结果会打印到标注输出（默认是屏幕）上，那我们C程不可能像人眼一样在屏幕上获取IP地址。对于这个问题我们可以在子进程里将标准输出重定向到文件里，这样命令的打印信息会输出到该文件中。之后就有三种方法获取IP了。
方法一：利用文件I/O）：子进程执行ifconfig eth0,将执行的结果输出重定向到文件（.ipc.log）中，父进程再从该文件中读出ip地址。
下面是该功能程序的实现源码和注释

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#define IPC_FILE ".ipc.log"
/********************************************************************************
*  Description:
*   Input Args:
*  Output Args:
* Return Value:
********************************************************************************/
int main (int argc, char **argv)
{
    pid_t  pid;
    int    fd = -1;
    char   buf[512];
    FILE   *fp = NULL;
 
    fd = open(IPC_FILE, O_RDWR|O_CREAT|O_TRUNC,0644);    //打开.ipc.log并获取文件描述符fd
    if( fd < 0)
    {
        printf("open file '%s' failure: %s\n",IPC_FILE,strerror(errno));
        return 0;
    }
 
    pid=fork();                           //调用fork创建子进程
    if(pid <0)
    {
       printf("fork() error: %s\n",strerror(errno));
       return 0;
    }
 
    else if(pid == 0)    //###"子进程"###
    {
       dup2(fd,1);       //在子进程中，将标准输出重定向到.ipc.log文件中（将标准输出（1）关掉，再将.ipc.log的文件描述符改为1）
       execl("/sbin/ifconfig","ifconfig","eth0",NULL);  //调用execl执行新的程序（命令ifconfig eth0）
       printf("####haha\n");     //该句不会打印
    }
 
    
    else if(pid > 0)    //###"父进程"###
    {
       int     status;
       wait(&status);       //等待子进程退出后，再继续向下执行
 
       printf("Parent running: child pid[%ld],parent pid[%ld],grandparent pid[%ld]\n",pid,getpid(),getppid());
       
       lseek(fd,0,SEEK_SET);   //将文件偏移量设置为0，不然读到为空
       fp = fdopen(fd,"r");                   //将文件描述符转换为文件流
      // while( read(fd,buf,sizeof(buf))>0 )
       while( fgets(buf,sizeof(buf),fp)>0 )   //将.ipc.log里的内容一行一行的读到buf里
       {
         if( strstr(buf, "netmask") )
         {
         // 查找"inet"关键字，inet关键字后面跟的就是IP地址；
                  ptr=strstr(buf, "inet");
                  if( !ptr )
                  {
                             break;
                  }
                  ptr += strlen("inet");
                 // inet 关键字后面是空白符，我们不确定是空格还是TAB，所以这里使用isblank()函数判断如果字符还是空白符就往后跳过；
                 while( isblank(*ptr) )
                            ptr++;
                 // 跳过空白符后跟着的就是IP地址的起始字符；
                 ip_start = ptr;
                // IP地址后面又是跟着空白字符，跳过所有的非空白字符，即IP地址部分：xxx.xxx.xxx.xxx
                 while( !isblank(*ptr) )
                 ptr++;
                // 第一个空白字符的地址也就是IP地址终止的字符位置
                 ip_end = ptr;
                 // 使用memcpy()函数将IP地址拷贝到存放IP地址的buffer中，  其中ip_end-ip_start就是IP地址的长度，ip_start就是IP地址的起始位置；
                 memset(ipaddr, 0, sizeof(ipaddr));
                 memcpy(ipaddr, ip_start, ip_end-ip_start);
                 break;
                 }
        }
        printf("Parser and get IP address: %s\n", ipaddr);
        fclose(fp);
        unlink(TMP_FILE);
        return 0;
} /* ----- End of main() ----- */

程序执行结果：

[wangyan@localhost]$ ./a.out
parent running :child pid [44139],parent pid[44138],grandparent pid[43078]
Parser and get IP address: 192.168.30.131

方法二(利用管道)：
先创建管道，再创建子进程，这样父进程和子进程都拥有了管道的读端与写端，然后关闭子进程管道读端，关闭父进程写端，子进程执行ifconfig eth0,将执行的结果重定向到管道写端，父进程再从管道读端里获取IP地址。

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<unistd.h>
 
/********************************************************************************
*  Description:
*   Input Args:
*  Output Args:
* Return Value:
********************************************************************************/
int main (int argc, char **argv)
{
    pid_t  pid;
    int    fd[2];
    char   buf[512];
    FILE   *fp = NULL;
 
    if( pipe(fd)<0 )               //调用pipe创建管道， fd参数返回两个文件描述符,fd[0]指向管道的读端,fd[1]指向管道的写端。fd[1]的输出是fd[0]的输入。
    {
       printf("pipe failure: %s\n",strerror(errno));
       return -1;
    }
 
    pid=fork();                      //调用fork创建子进程
    if(pid <0)
    {
       printf("fork() error: %s\n",strerror(errno));
       return 0;
    }
 
    else if(pid == 0)     //###"子进程"###
    {  
       close(fd[0]);      //关闭管道读端
       dup2(fd[1],1);     //在子进程中，将标准输出重定向到管道写端中（将标准输出（1）关掉，再将管道写端的文件描述符改为1）
       execl("/sbin/ifconfig","ifconfig","eth0",NULL);       //调用execl执行新的程序（命令ifconfig eth0）
       printf("####haha\n");  //该句不会打印
    }
 
    else if(pid > 0)     //###"父进程"###
    {  
       close(fd[1]);     //关闭管道写端
       int     status;
       wait(&status);
 
       printf("Parent running: child pid[%ld],parent pid[%ld],grandparent pid[%ld]\n",pid,getpid(),getppid());
       
       fp = fdopen(fd[0],"r");                   //将文件描述符转换为文件流
 
       while( fgets(buf,sizeof(buf),fp)>0 )     // 将父进程管道读端里的内容一行一行的读到buf里
       {
          if( strstr(buf, "netmask") )
         {
         // 查找"inet"关键字，inet关键字后面跟的就是IP地址；
                  ptr=strstr(buf, "inet");
                  if( !ptr )
                  {
                             break;
                  }
                  ptr += strlen("inet");
                 // inet 关键字后面是空白符，我们不确定是空格还是TAB，所以这里使用isblank()函数判断如果字符还是空白符就往后跳过；
                 while( isblank(*ptr) )
                            ptr++;
                 // 跳过空白符后跟着的就是IP地址的起始字符；
                 ip_start = ptr;
                // IP地址后面又是跟着空白字符，跳过所有的非空白字符，即IP地址部分：xxx.xxx.xxx.xxx
                 while( !isblank(*ptr) )
                 ptr++;
                // 第一个空白字符的地址也就是IP地址终止的字符位置
                 ip_end = ptr;
                 // 使用memcpy()函数将IP地址拷贝到存放IP地址的buffer中，  其中ip_end-ip_start就是IP地址的长度，ip_start就是IP地址的起始位置；
                 memset(ipaddr, 0, sizeof(ipaddr));
                 memcpy(ipaddr, ip_start, ip_end-ip_start);
                 break;
                 }
        }
        printf("Parser and get IP address: %s\n", ipaddr);
        fclose(fp);
        unlink(TMP_FILE);
        return 0;
} /* ----- End of main() ----- */

程序执行结果：

[wangyan@localhost]$ ./a.out
parent running :child pid [44139],parent pid[44138],grandparent pid[43078]
Parser and get IP address: 192.168.30.131

方法三（利用popen函数）推荐：
popen()会调用fork（）产生子进程，然后从子进程中调用/bin/sh -c来执行ifconfig eth0 第二个参数“r”代表读取。

#include <stdio.h>
#include <string.h>
#include <errno.h>
/********************************************************************************
*  Description:
*   Input Args:
*  Output Args:
* Return Value:
********************************************************************************/
int main (int argc, char **argv)
{
    FILE   *fp;
    char   buf[512];
    char   *p1,*p2,*p3;
    char   ipaddr[16];
    char   netmask[16];
 
    fp = popen("ifconfig eth0","r");
    if( fp == NULL)
    {
      printf("popen failure: %s\n",strerror(errno));
      return 0;
    }
 
    while( fgets(buf,sizeof(buf),fp)>0)
    {
      if( (p1=strstr(buf,"inet addr:")) !=NULL)  //p1指向含有"inet addr:"关键词这一行的首地址
      {
 
          //printf("%s",buf);
 
          p2=strchr(p1,':');   //p2指向p1行第一个冒号处
          p3=strchr(p2,' ');   //p2指向p2以后第一个空格处
          memset(ipaddr,0,sizeof(ipaddr));
          strncpy(ipaddr,p2+1,p3-p2);      //截取IP地址到ipaddr数组中
          printf("IP address: %s\n",ipaddr);
         
          /*p2=strrchr(p1, ':');   //p2指向p1行最后一个冒号处
          p3=strrchr(p2, '\n');  //p3指向p2以后最后一个换行符处（在p1行中）
          memset(netmask, 0, sizeof(netmask));
          strncpy(netmask, p2+1, p3-p2);    //截取Mask地址到netmask数组中
          printf("Netmask address: %s\n", netmask);*/
      }
    }
    pclose(fp);
 
    return 0;
} /* ----- End of main() ----- */

程序执行结果：

IP address: 192.168.30.131

7.vfork()系统调用

在上面的例子中我们可以看到，在fork()之后常会紧跟着调用exec来执行另外一个程序，而exec会抛弃父进程的文本段、数据段和堆栈等并加载另外一个程序，所以现在的很多fork()实现并不执行一个父进程数据段、堆和栈的完全副本拷贝。作为替代，使用了写时复制(CopyOnWrite)技术： 这些数据区域由父子进程共享，内核将他们的访问权限改成只读，如果父进程和子进程中的任何一个试图修改这些区域的时候，内核再为修改区域的那块内存制作一个副本。

vfork()是另外一个可以用来创建进程的函数，他与fork()的用法相同，也用于创建一个新进程。 但vfork()并不将父进程的地址空间完全复制到子进程中，因为子进程会立即调用exec或exit()，于是也就不会引用该地址空间了。不过子进程再调用exec()或exit()之前，他将在父进程的空间中运行，但如果子进程想尝试修改数据域(数据段、堆、栈)都会带来未知的结果，因为他会影响了父进程空间的数据可能会导致父进程的执行异常。此外，vfork()会保证子进程先运行，在他调用了exec或exit()之后父进程才可能被调度运行。如果子进程依赖于父进程的进一步动作，则会导致死锁。vfork()的函数原型和 fork原型一样。

#include <unistd.h>
#include <sys/types.h>
pid_t fork(void);
pid_t vfork(void);

8.回收子进程wait()与waitpid()

当一个进程正常或异常退出时，内核就会向其父进程发送SIGCHLD信号。因为子进程退出是一个异步事件，所以这种信号也是内核向父进程发送的一个异步通知。父进程可以选择忽略该信号，或者提供一个该信号发生时即将被执行的函数，父进程可以调用wait()或waitpid()可以用来查看子进程退出的状态。

该函数有三个功能：

• 阻塞等待子进程退出
• 回收子进程残留资源
• 获取子进程结束状态（退出原因)

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *status);
pid_t waitpid(pid_t pid, int *status, int options);

RETURN VALUE
       wait(): on success, returns the process ID of the terminated  child;  on  error,  -1  is
       returned.

       waitpid():  on  success, returns the process ID of the child whose state has changed; 
       if WNOHANG was specified and one or more child(ren) specified by pid exist, but have 
       not yet changed state, then 0 is returned.  On error, -1 is returned.

wait返回值：成功：清理掉的子进程ID

​ 失败：-1（没有子进程）

waitpid返回值：>0：清理掉的子进程ID

​ 0：函数调用时，参数3指定为WNOHANG，并且，没有子进程退出(WNOHANG指没有子进程用来回收也会立即返回，不会像wait那样阻塞等待)

​ -1：失败

waitpid特殊参数pid:

​ >0：回收指定ID的子进程

​ -1：回收任意子进程

​ 0：回收和当前调用waitpid一个组的所有子进程

​ <-1：回收指定进程组内的任意子进程
status用法：

获取子进程正常终止值：

​ WIFEXISTED(status) -> 为真 -> 调用WEXISTSTATUS(status) -> 得到子进程退出值

获取导致子进程异常终止信号：

​ WIFSIGNALED(status) -> 为真 -> 调用WTERMSIG(status) -> 得到导致子进程异常终止的信号编号

注意：一次wait或waitpid调用只能清理一个子进程，清理多个应使用循环。

options：允许改变waitpid的行为，最有用的一个选项是WNOHANG,它的作用是防止waitpid把调用者的执行挂起等待（设置非阻塞）。如果设置为0，就是阻塞。

在一个子进程终止前，wait使其调用者阻塞，而waitpid有一选项可使调用者不用阻塞。 waitpid并不等待在其调用的之后的第一个终止进程，他有若干个选项，可以控制他所等待的进程。 如果一个已经终止、但其父进程尚未对其调用wait进行善后处理(获取终止子进程的有关信息如CPU时间片、释放它锁占用的资源如文件描述符等)的进程被称僵死进程(zombie)，ps命令将僵死进程的状态打印为Z。如果子进程已经终止，并且是一个僵死进程，则wait立即返回该子进程的状态。所以，我们在编写多进程程序时，最好调用wait()或waitpid()来解决僵尸进程的问题。此外，如果父进程在子进程退出之前退出了，这时候子进程就变成了孤儿进程。当然每一个进程都应该有一个独一无二的父进程，init进程就是这样的一个“慈父”，Linux内核中所有的子进程在变成孤儿进程之后都会被init进程“领养”，这也意味着孤儿进程的父进程最终会变成init进程

9.system()与popen()函数

如果我们在程序中，想执行另外一个Linux命令时，可以调用fork()然后再exec执行相应的命令即可，但这样相对比较麻烦。
Linux系统提供了一个system()库函数，该库函数可以快速创建一个进程来执行相应的命令。

int system(const char *command);

譬如我们想执行ping命令，则可以使用下面的程序片段：

system("ping -c 4 -I eth0 4.2.2.2");
如果这里的 eth0、4.2.2.2 等是一个变量参数，我们则可以使用snprintf()格式化生成该命令：
char cmd_buf[256];
int count = 4;
char *interface="eth0";
char *dst_ip = "4.2.2.2";
snprintf(cmd_buf, sizeof(buf), "ping -c %d -I %s %s", count, interface, dst_ip);
system(cmd_buf);

执行ifconfig命令，并将该命令执行的结果写入到文件后再来读取的实现，这个过程相对
比较麻烦，另外涉及到了创建文件和读取文件的过程。其实也有另外一个函数popen()可以执行一条命令，并返回一个基于管道(pipe)的文件流，这样我们可以从该文件流中一行样解析了，代码以在上方实现（方法二）。

三、多进程改写服务器程序

在了解Linux下多进程编程之后，我们就可以使用多进程编程模型改写服务器的多进程实现，其流程图和程序代码如下：

代码如下：

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

void print_usage(char *progname)
{
	printf("%s usage: \n", progname);
	printf("-p(--port): sepcify server listen port.\n");
	printf("-h(--Help): print this help information.\n");

	return ;
}

int main(int argc, char **argv)
{
	int 					sockfd = -1;
	int 					rv = -1;
	int 					port = 0;
	int						clifd;
	int 					ch;
	int 					on = 1;
	struct sockaddr_in 		servaddr;
	struct sockaddr_in 		cliaddr;
	socklen_t				len;
	pid_t 					pid;
	struct option opts[] = {
			{"port", required_argument, NULL, 'p'},
			{"help", no_argument, NULL, 'h'},
			{NULL, 0, NULL, 0}
			};
			
	while ((ch=getopt_long(argc, argv, "p:h", opts, NULL)) != -1)
	{
		switch (ch)
		{
			case 'p':
					port=atoi(optarg);
					break;
			case 'h':
					print_usage(argv[0]);
					break;
		}
	}
	
	if (!port)
	{
		print_usage(argv[0]);
		return 0;
	}
	
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd < 0)
	{
		printf("Create socket failure: %s\n", strerror(errno));
		return -1;
	}
	printf("Create socket[%d] successfully!\n", sockfd);
	
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
	
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family=AF_INET;
	servaddr.sin_port = htons(port);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY); /* listen all the IP address on this host */
	
	rv = bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
	if (rv < 0)
	{
		printf("Socket[%d] bind on port[%d] failure: %s\n", sockfd, port, strerror(errno));
		return -2;
	}
	
	listen(sockfd, 13);
	printf("Start to listen on port [%d]\n", port);
	
	while(1)
	{
		printf("Start accept new client incoming...\n");
		
		clifd = accept(sockfd, (struct sockaddr *)&cliaddr, &len);
		if (clifd < 0)
		{
			printf("Accept new client failure: %s\n", strerror(errno));
			continue;
		}	
		printf("Accept new client[%s:%d] successfully\n", inet_ntoa(cliaddr.sin_addr),
				ntohs(cliaddr.sin_port));
				
		pid = fork();
		if (pid < 0)
		{
			printf("fork() create child process failure: %s\n", strerror(errno));
			close(clifd);
			continue;
		}
		else if( pid > 0 )
		{
			/* Parent process close client fd and goes to accept new socket client again */
			close(clifd);
			continue;
		}
		else  //0 == pid
		{
			int  	i;
			char 	buf[1024];

			printf("Child process start to commuicate with socket client...\n");
			
			close(sockfd); /* Child process close the listen socket fd */
			while (1)
			{
				memset(buf, 0, sizeof(buf));
				
				rv = read(clifd, buf, sizeof(buf));
				if (rv < 0)
				{
					printf("Read data from client sockfd[%d] failure: %s\n", clifd,
					strerror(errno));
					
					close(clifd);
					exit(0);
				}
				else if (rv == 0)
				{
					printf("Socket[%d] get disconnected\n", clifd);
					
					close(clifd);
					exit(0);
				}
				else //rv > 0 
				{
					printf("Read %d bytes data from Server: %s\n", rv, buf);
				}
				
				/* convert letter from lowercase to uppercase */
				for (i = 0; i < rv; i++)
				{
					buf[i] = toupper(buf[i]); //转变成大写
				}
				
				rv = write(clifd, buf, rv);
				if (rv < 0)
				{
					printf("Write to client by sockfd[%d] failure: %s\n", clifd,
					strerror(errno));
					
					close(clifd);
					exit(0);
				}
			} /* Child process loop */
		} /* Child process start*/
	}
	
	close(sockfd);
	return 0;
}

程序分析：

• 父进程accept()接收到新的连接后，就调用fork()系统调用来创建子进程来处理与客户端的通信。子进程会继承父进程处于listen状态的socket文件描述符(sockfd)，也会继承父进程accept()返回的客户端socket文件描述符(clifd)，但子进程只处理与客户端的通信，因此将父进程的listen的文件描述符sockfd关闭；同样父进程只处理监听的事件，所以将clifd关闭。
• 父子进程同时运行完成不同的任务，子进程只负责跟已经建立的客户端通信，而父进程只用来监听到来的socket客户端连接。所以当有新的客户端到来时，父进程就有机会来处理新的客户连接请求了，每来一个客户端都会创建一个子进程为其服务。
• 子进程使用while(1)循环让自己一直执行，并通过toupper()将客户端发过来的小写字母改成大写字母后再传回去。只有当读写socket出错或客户端主动断开时，子进程才退出，并在退出之前调用close()关闭相应的套接字。因为是在main()函数中，所以我们可以使用return或exit()退出进程，但注意不能使用break跳出。

接下来在windows下使用TCPsocket测试工具连接并测试服务器的执行情况，我们可以发现服务器可以同时处理多个客户端的连接请求和通信，并在客户端断开时子进程退出，从而实现了服务器并发访问。

四、系统限制

在上面我们使用多进程可以实现多个客户端的并发，那是不是一个服务器就可以给无限多个客户端提供服务呢？其实不然！在Linux下每种资源都有相关的软硬限制，譬如单个用户最多能创建的子进程个数有限制，同样一个进程最多能打开的文件描述符也有相应的限制值，这些限制会限制服务器能够提供并发访问的客户端的数量。 在Linux系统下，我们可以使用下面两个函数来获取或设置这些限制：

#include <sys/resource.h>

int getrlimit(int resource, struct rlimit *rlim);
int setrlimit(int resource, const struct rlimit *rlim);

参数 resource说明：

• RLIMIT_AS 进程的最大虚内存空间，字节为单位。
• RLIMIT_CORE 内核转存文件的最大长度。
• RLIMIT_CPU最大允许的CPU使用时间，秒为单位。当进程达到软限制，内核将给其发送SIGXCPU信号，这一信号的默认行为是终止进程的执行。
• RLIMIT_DATA 进程数据段的最大值。
• RLIMIT_FSIZE 进程可建立的文件的最大长度。如果进程试图超出这一限制时，核心会给其发送
• SIGXFSZ信号，默认情况下将终止进程的执行。
• RLIMIT_LOCKS 进程可建立的锁和租赁的最大值。
• RLIMIT_MEMLOCK 进程可锁定在内存中的最大数据量，字节为单位。
• RLIMIT_MSGQUEUE 进程可为POSIX消息队列分配的最大字节数。
• RLIMIT_NICE 进程可通过setpriority() 或 nice()调用设置的最大完美值。
• RLIMIT_NOFILE 指定比进程可打开的最大文件描述词大一的值，超出此值，将会产生EMFILE错误。
• RLIMIT_NPROC 用户可拥有的最大进程数。
• RLIMIT_RTPRIO 进程可通过sched_setscheduler 和 sched_setparam设置的最大实时优先级。
• RLIMIT_SIGPENDING 用户可拥有的最大挂起信号数。
• RLIMIT_STACK 最大的进程堆栈，以字节为单位。

参数rlim说明：描述资源软硬限制的结构体

struct rlimit 
{
		rlim_t rlim_cur;
		rlim_t rlim_max;
};

下面我们用一个例程介绍一下这两个函数的使用方法。
代码如下：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/resource.h>

void print_limits(char* name, int resource)
{
	struct rlimit 		limit;
	
	if (getrlimit(resource, &limit) < 0)
	{
		printf("getrlimit for %s failure: %s\n", strerror(errno));
		return ;
	}
	printf("%-15s ",name);
	
	if	(limit.rlim_cur == RLIM_INFINITY)
	{
		printf("(infinite) ");
	}
	else
	{
		printf("%-15ld",limit.rlim_cur);
	}
	
	if (limit.rlim_max == RLIM_INFINITY)
	{
		printf("(infinite) ");
	}
	else
	{
		printf("%-15ld",limit.rlim_max);
	}
	
	printf("\n");
}

int main(void)
{
	struct rlimit limit = {0};
	
	print_limits("RLIMIT_NPROC", RLIMIT_NPROC);
	print_limits("RLIMIT_DATA", RLIMIT_DATA);
	print_limits("RLIMIT_STACK", RLIMIT_STACK);
	print_limits("RLIMIT_NOFILE", RLIMIT_NOFILE);
	printf("\nAfter set RLIMIT_NOFILE:\n");
	
	getrlimit(RLIMIT_NOFILE, &limit );
	limit.rlim_cur = limit.rlim_max;
	setrlimit(RLIMIT_NOFILE, &limit );
	print_limits("RLIMIT_NOFILE", RLIMIT_NOFILE);
	
	return 0;
}

程序运行结果如下：

RLIMIT_NPROC 7345 7345
RLIMIT_DATA (infinite) (infinite)
RLIMIT_STACK 8388608 (infinite)
RLIMIT_NOFILE 1024 1048576

After set RLIMIT_NOFILE:
RLIMIT_NOFILE 1048576 1048576

由上所知，一个服务器程序抛开硬件（CPU、内存、带宽）限制以外，还会受到Linux系统的资源限制。所以，如果我们想要增加Linux服务器并发访问的客户端数量，则需要在服务器程序里通过调用setrlimit()函数来修改这些限制。