UNIX环境高级编程-第16章- 网络IPC：套接字 - 二

最新推荐文章于 2021-12-01 17:19:16 发布
最新推荐文章于 2021-12-01 17:19:16 发布
阅读量718 收藏
点赞数
分类专栏： UNIX环境高级编程 文章标签： unix
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012243115/article/details/42677661
版权

       在基于 TCP 的通信连接请求过程有三次握手，其过程如下所示：


       第一次握手：客户端发送syn包(seq=x)到服务器，并进入SYN_SEND状态，等待服务器确认；

       第二次握手：服务器收到syn包，必须确认客户的SYN（ack=x+1），同时自己也发送一个SYN包（seq=y），即SYN+ACK包，此时服务器进入SYN_RECV状态；

       第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=y+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

       数据传输过程如下图所示：


       关闭通信时，需要四次挥手过程，如下所示：


       第一次挥手：主动关闭方发送一个FIN，用来关闭主动方到被动关闭方的数据传送，也就是主动关闭方告诉被动关闭方：我已经不会再给你发数据了(当然，在fin包之前发送出去的数据，如果没有收到对应的ack确认报文，主动关闭方依然会重发这些数据)，但此时主动关闭方还可以接受数据。

       第二次挥手：被动关闭方收到FIN包后，发送一个ACK给对方，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号）。

       第三次挥手：被动关闭方发送一个FIN，用来关闭被动关闭方到主动关闭方的数据传送，也就是告诉主动关闭方，我的数据也发送完了，不会再给你发数据了。

       第四次挥手：主动关闭方收到FIN后，发送一个ACK给被动关闭方，确认序号为收到序号+1，至此，完成四次挥手。


       下面是基于套接字的编程：

客户端：

/* 基于TCP协议面向连接的客户端进程 */  
  
#include "apue.h"  
#include <netdb.h>  
#include <errno.h>  
#include <sys/socket.h>  
#include "connectre.h"  
  
/* 地址的最长大小 */  
#define MAXADDRLEN 256  
/* 缓冲区大小 */  
#define BUFLEN 128  
  
/* 外部函数定义，该函数功能是实现套接字连接 */  
//extern int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t len);  
  
/* 打印客户端所接收的数据信息 */  
void print_uptime(int sockfd);  
  
int main(int argc, char *argv[])  
{  
    struct addrinfo *ailist, *aip;  
    struct addrinfo hint;  
  
    int sockfd, err;  
    if(argc != 2)  
        err_quit("usage: %s hostname", argv[0]);  
    /* 初始化addrinfo结构变量hint */  
    hint.ai_flags = 0;  
    hint.ai_family = 0;  
    hint.ai_socktype = SOCK_STREAM;/* 有序、可靠、双向的面向连接字节流 */  
    hint.ai_protocol = 0;/* 使用默认协议 */  
    hint.ai_addrlen = 0;  
    hint.ai_canonname = NULL;  
    hint.ai_addr = NULL;  
    hint.ai_next = NULL;/* 表示只有一个addrinfo链表结构 */  
  
    /* 将主机名和服务名映射到一个地址 */  
    if((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0)  
        err_quit("getaddrinfo error: %s", gai_strerror(err));  
    /* 对每个结构addrinfo链表进行以下操作，其实这里只有一个addrinfo结构 */  
    for(aip = ailist; aip != NULL; aip = aip->ai_next)  
    {  
        /* 其中这里才是客户端套接字编程 */    
        /* 步骤1：创建套接字描述符 */  
        if((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0)  
            err =errno;  
        /* 步骤2：connect请求连接 */  
        if(connect_retry(sockfd, aip->ai_addr, aip->ai_addrlen) < 0)  
            err = errno;/* 请求连接失败 */  
        else /* 请求连接成功，则准备传输数据 */  
        {  
            /* 接收来自服务器进程的消息，并打印输出 */  
            print_uptime(sockfd);  
            exit(0);/* 正常退出 */  
        }  
    }  
    /* 异常退出 */  
    fprintf(stderr, "can't connect to %s: %s\n",argv[1], strerror(err));  
    exit(1);  
}  
  
void print_uptime(int sockfd)  
{  
    int n;  
    char buf[BUFLEN];  
  
    /* 接收数据 */  
    while((n = recv(sockfd, buf, BUFLEN, 0)) > 0)  
        /* 把接收到的数据输出到终端 */  
        write(STDOUT_FILENO, buf, n);  
    if(n < 0)  
        err_sys("recv error");  
}

       这个程序连接服务器，读取服务器发送过来的字符串并将其打印到标准输出。

服务器端：

/* 基于TCP的面向连接的服务器进程 */    
#include "apue.h"  
#include <netdb.h>  
#include <errno.h>  
#include <syslog.h>  
#include <fcntl.h>  
#include <sys/socket.h>  
#include <sys/wait.h>  
#include "serverin.h"  
  
/* 定义等待请求队列的最大数 */  
#define QLEN 10  
  
#ifndef HOST_NAME_MAX  
#define HOST_NAME_MAX 256  
#endif  
  
/* 外部定义的服务器初始化套接字端点 */  
//extern int initserver(int type, const struct sockaddr *addr, socklen_t len, int qlen);  
  
/* 服务器接收连接请求，并向请求客户端发送数据 */  
void server(int sockfd);  
  
int main(int argc, char *argv[])  
{  
    struct addrinfo *ailist, *aip;  
    struct addrinfo hint;  
  
    int sockfd, err, n;  
    char *host;  
  
    if(argc != 1)  
        err_quit("usage: %s", argv[0]);  
#ifdef _SC_HOST_NAME_MAX  
    n = sysconf(_SC_HOST_NAME_MAX);  
    if(n < 0) /* best guess */  
#endif  
        n = HOST_NAME_MAX;  
    host = (char *)malloc(n);  
    if(NULL == host)  
        err_sys("malloc error");  
    /* 获取客户端的主机名 */  
    if(gethostname(host, n) < 0)  
        err_sys("gethostname error");  
    daemonize("ruptimed");  
    /* 初始化addrinfo结构变量hint */  
    hint.ai_flags = AI_CANONNAME;/* 需要一个规范名 */  
    hint.ai_family = 0;  
    hint.ai_socktype = SOCK_STREAM;/* 有序、可靠、双向的面向连接字节流 */  
    hint.ai_protocol = 0;/* 使用默认协议 */  
    hint.ai_addrlen = 0;  
    hint.ai_canonname = NULL;  
    hint.ai_addr = NULL;  
    hint.ai_next = NULL;/* 表示只有一个addrinfo链表结构 */  
  
    /* 将主机名和服务名映射到一个地址 */  
    if((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0)  
    {  
        syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err));  
        exit(1);  
    }  
    /* 对每个结构addrinfo链表进行以下操作，其实这里只有一个addrinfo结构 */  
    for(aip = ailist; aip != NULL; aip = aip->ai_next)  
    {  
        /* 其中这里才是服务进程套接字编程 */    
        if((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0)  
        {  
            server(sockfd);  
            exit(0);  
        }  
    }  
    exit(1);  
}  
void server(int sockfd)  
{  
    int clfd, status;  
    pid_t pid;  
  
    while(1)  
    {  
        clfd = accept(sockfd, NULL, NULL);  
        if(clfd < 0)  
        {  
            syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));  
            exit(1);  
        }  
  
        if((pid = fork()) < 0)  
        {  
            syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));  
            exit(1);  
        }  
        else if(pid == 0)  
        {  
            if(dup2(clfd, STDOUT_FILENO) != STDOUT_FILENO || dup2(clfd, STDERR_FILENO) != STDERR_FILENO)  
            {  
                syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));  
                exit(1);  
            }  
            close(clfd);  
            execl("/usr/bin/uptime", "uptime", (char *)0);/* 执行 uptime指令 */  
            syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));  
        }  
        else  
        {  
            close(clfd);  
            waitpid(pid, &status, 0);  
        }  
    }  
}

       为了找到地址，服务器程序需要调用gethostname获得其运行时的主机名字，并查看远程uptime服务地址。

       其中客户端和服务器端包含的函数头文件内容如下：

       服务器serverin.h：

/* 服务器初始化套接字端点 */  
#ifndef SERVERIN_H  
#define SERVERIN_H  
#include "apue.h"  
#include <sys/socket.h>  
#include <errno.h>  
#include <syslog.h>  
#include <fcntl.h>  
#include <sys/resource.h>  
  
/* type 套接字类型, qlen是监听队列的最大个数 */  
int initserver(int type, const struct sockaddr *addr, socklen_t len, int qlen)  
{  
    int fd;  
    int err = 0;  
  
    /* 采用type类型默认的协议 */  
    if((fd = socket(addr->sa_family, type, 0)) < 0)  
        return -1;/* 出错返回-1*/  
  
    int reuse = 1;  
  
    if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int)) < 0)  
    {  
        err = errno;  
        goto errout;  
    }  
    /* 将地址绑定到一个套接字 */  
    if(bind(fd, addr, len) < 0)  
    {  
        err =errno;  
        goto errout;/* 跳转到出错输出语句 */  
    }  
    /* 若套接字类型type是面向连接(SOCK_STREAM, SOCK_SEQPACKET)的，则执行以下语句 */  
    if(type == SOCK_STREAM || type == SOCK_SEQPACKET)  
    {  
        /* 监听套接字连接队列 */  
        if(listen(fd, qlen) < 0)  
        {  
            err = errno;  
            goto errout;  
        }  
    }  
    return (fd);  
  
errout:  
    close(fd);  
    errno = err;  
    return -1;  
}  
  
/* 初始化守护进程 */  
  
void daemonize(const char *cmd)  
{  
    int i, fd0, fd1, fd2;  
    pid_t pid;  
    struct rlimit rl;  
    struct sigaction sa;  
    umask(0);  
  
    if(getrlimit(RLIMIT_NOFILE, &rl) < 0)  
        err_quit("%s: can't get file limit", cmd);  
  
    if((pid =fork()) < 0)  
        err_quit("%s: can't fork", cmd);  
    else if(pid != 0)  
        exit(0);  
    setsid();  
  
    sa.sa_handler = SIG_IGN;  
    sigemptyset(&sa.sa_mask);  
    sa.sa_flags = 0;  
    if(sigaction(SIGHUP, &sa, NULL) < 0)  
        err_quit("%s: can't ignore SIGHUP");  
    if((pid =fork()) < 0)  
        err_quit("%s: can't fork", cmd);  
    else if(pid != 0)  
        exit(0);  
    if(chdir("/") < 0)  
        err_quit("%s: can't change directory to /");  
  
    if(rl.rlim_max == RLIM_INFINITY)  
        rl.rlim_max = 1024;  
    for(i = 0; i < (int)rl.rlim_max; i++)  
        close(i);  
  
    fd0 = open("/dev/null", O_RDWR);  
    fd1 = dup(0);  
    fd2 = dup(0);  
  
    openlog(cmd, LOG_CONS, LOG_DAEMON);  
    if(fd0 != 0 || fd1 != 1 || fd2 != 2)  
    {  
        syslog(LOG_ERR, "unexpectrd file descriptors %d %d %d", fd0, fd1, fd2);  
        exit(1);  
    }  
  
}  
#endif

       客户端connectre.h： 

/* 建立连接 */  
  
/* 该函数的功能和connect相同，当connect连接出错时，这里支持重试连接 */  
  
#ifndef CONNECTRE_H  
#define CONNECTRE_H  
#include "apue.h"  
#include <sys/socket.h>  
  
#define MAXSLEEP 128  
  
int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t len)  
{  
    int nsec;  
    /* Try to connect with exponential backoff */  
  
    for(nsec = 1; nsec <= MAXSLEEP; nsec <<= 1)  
    {  
        if(connect(sockfd, addr, len) == 0)  
            return 0;  
        /* Delay before trying again */  
        if(nsec <= MAXSLEEP/2)  
            sleep(nsec);  
    }  
    return -1;  
}  
#endif

输出结果： 

/* 
*在输出结果之前一些准备工作，在文件 /etc/servers 添加 ruptime  4000/tcp 
*/  
[root@chenchen 16]# ./server
[root@chenchen 16]# ./client chenchen          //chenchen是主机名，可以通过uname–n查看
 15:30:47 up 14 min,  2 users, load average: 0.00, 0.12, 0.16
[root@chenchen 16]#

16.6 套接字选项

       套接字机制有两种套接字选项接口来控制套接字行为：一种接口用来设置选项；另一种接口允许查询一个选项的状态；可以设置或获取下面三种选项：

（1）通用选项，工作在所有套接字类型上；

（2）在套接字层次管理的选项，但依赖于下层协议的支持；

（3）特定于某种协议的选项，为每个协议所独有；

       若要对套接字选项进行设置时，可以调用函数 setsockopt 进行设置，调用函数 getsockopt 获取套接字选项的当前值，其定义如下：

/* 套接字选项 */  
/* 
 * 函数功能：设置套接字选项； 
 * 返回值：若成功返回0，若出错返回-1； 
 * 函数原型： 
 */  
#include <sys/socket.h>  
  
int setsockopt(int sockfd, int level, int option, const void *val, socklen_t len);  
/* 
 * 说明： 
 * level表示选项应用的协议，若选项是通用套接字选项，则level设置为SOL_SOCKET，否则设置为控制这个协议的协议号； 
 * val根据选项 option 不同指向一个数据结构或者一个整数，若整数非零，则启用选项，若整数为零，则禁止选项； 
 * len指定了val指向的对象的大小； 
 */  
/* 
 * 函数功能：获取套接字选项的当前值； 
 * 返回值：若成功返回0，若出错返回-1； 
 * 函数原型： 
 */  
#include <sys/socket.h>  
  
int getsockopt(int sockfd, int level, int option, void *val, socklen_t *lenp);  
/* 
 * 说明： 
 * lenp是指向整数的指针，在调用该函数之前，设置该参数为复制选项缓冲区的大小； 
 * 其他参数和setsockopt函数类型； 
 */

16.7 带外数据

        带外数据是一些通信协议所支持的可选特征，允许更高优先级的数据比普通数据优先传输。即使传输队列已经有数据，带外数据先行传输。TCP 支持带外数据，但是 UDP 并不支持。

        TCP 将带外数据称为紧急数据，但是 紧急数据 并不是 带外数据。TCP 仅支持一个字节的紧急数据，但是允许紧急数据在普通数据传输机制数据流之外传输。为了产生紧急数据，在三个 send 函数中任何一个指定标志 MSG_OOB。如果带 MSG_OOB 标志传输字节超过一个时，最后一个字节被看做紧急数据字节。

        TCP 支持紧急标记：在普通数据流中紧急数据所在的位置，如果采用套接字选项 SO_OOBINLINE，那么可以在普通数据中接收紧急数据。判断是否接收到紧急标记，可以使用函数 sockatmark，其定义如下：

/* 
 * 函数功能：判断是否接收到紧急标记； 
 * 返回值：若在标记处则返回0，若没有在标记处则返回0，若出错返回-1； 
 * 函数原型： 
 */  
#include <sys/socket.h>  
int sockatmark(int sockfd);  
/* 
 * 说明： 
 * 当下一个要读的字节在紧急标记所标识的位置，则该函数返回1； 
 */

         当带外数据出现在套接字读取队列时，select函数会返回一个文件描述符，并且拥有一个异常状态挂起。可以在普通数据流上接收紧急数据，或者在某个recv函数中采用MSG_OOB 标志在其他队列数据之前接收紧急数据。TCP 队列仅有一个字节的紧急数据，如果在接收当前的紧急数据字节之前又有新的紧急数据到来，那么当前的字节会被丢弃。

思翊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
UNIX环境高级编程（第2版）书和源码
08-26
第16章　网络IPC：套接字　437 第17章　高级进程间通信　469 第18章　终端I/O　507 第19章　伪终端　541 第20章　数据库函数库　567 第21章　与网络打印机通信　603 附录A　函数原型　647 附录B　其他源代码...
linux 套接字接口
胜利者的经验并不复杂,那就是寻找人生的关键点,并在关键时刻竭尽全力
10-07 1383
大多参考unp，算个总结 一、套接字地址结构 1）IPv4套接字地址 IPv4套接字地址结构通常也称为“网际套接字地址结构”，它以sockaddr_in命名，定义在头文件里面，下面是POSIX定义 struct in_addr{  in_addr_t s_addr; //32bit IPv4 address, network byte ordered }; 这个结构只有一个32位的无
网络编程-套接字（socket）
b2312996177的博客
09-06 192
一.什么是套接字 　　套接字（socket）是计算机之前数据传输的工具，是有计算机系统提供的一个组件，是网络数据传输的软件设备。 二.TCP/IP协议 　　TCP/IP协议栈共分为4层（OSI规范分7层）,tcp、udp就是基于socket的一种协议 　　 三.套接字的分类 　　1.流式套接字（TCP） 　　　　它提供了一种可靠的、面向连接的双向通讯方式。适用于...
APUE 第三版 程序 16-16&16-17 ruptimed (简单的TCP，C/S 实例)
Error Man 的博客
05-03 322
如有错误，欢迎批评指正，本人也是才学APUE的菜鸟 实验的系统是 Ubuntu 18.04 代码先贴一下，和书上一样，没啥改变 ，主要是为了没书的时候看： connect_retry.c // // Created by hjm on 2020/5/3. // #include "apue.h" #include <sys/socket.h> #define MAXSLEEP 12...
《unix高级环境编程》套接字——基于 socket 的编程
嵌入式Linux开发
11-25 635
基于套接字的连接建立成功之后，就可以进行通信，下面是基于套接字的编程的过程： 在基于 TCP 的通信连接请求过程有三次握手，其过程如下所示： 第一次握手：客户端发送syn包(seq=x)到服务器，并进入SYN_SEND状态，等待服务器确认；第二次握手：服务器收到syn包，必须确认客户的SYN（ack=x+1），同时自己也发送一个SYN包（seq=y），即SYN+AC
Linux套接字编程socket，服务器和客户端代码
a15322910600的博客
08-10 253
代码是参考Linux下getaddrinfo文件中的示例 链接：https://man7.org/linux/man-pages/man3/getaddrinfo.3.html 服务器端 #include <stdio.h> #include <sys/types.h> //目录为/usr/include/sys/types.h #include <stdlib.h> //标准库定义 #include <unistd.h> //定义了各种符号常量 和类型，并声
UNIX环境高级编程 学习笔记 第十六章 网络IPC:套接字
tus00000的博客
12-01 543
socket的设计目标之一：同样的接口既可以用于计算机间通信，也可以用于计算机内通信。socket接口可采用许多不同的网络协议进行通信，本章讨论限制在因特网事实上的通信标准：TCP/IP协议栈。 套接字是通信端点的抽象。正如使用文件描述符访问文件，应用程序用套接字描述符访问套接字。套接字描述符在UNIX系统中是一种文件描述符，许多处理文件描述符的函数（如read、write函数）都可用于处理套接字描述符。 创建一个套接字： domain（域）参数确定通信的特性，包括地址格式。POSIX.1指定的各个域如下
UNIX环境高级编程_第2版.part2
08-28
第16章网络ipc：套接字437 16.1 引言437 16.2 套接字描述符437 16.3 寻址439 16.3.1 字节序440 16.3.2 地址格式441 16.3.3 地址查询442 16.3.4 将套接字与地址绑定449 16.4 建立连接450 16.5 数据传输452 ...
UNIX环境高级编程
04-19
第16章　网络IPC：套接字　437 16.1　引言　437 16.2　套接字描述符　437 16.3　寻址　439 16.3.1　字节序　440 16.3.2　地址格式　441 16.3.3　地址查询　442 16.3.4　将套接字与地址绑定　449 16.4　建立连接　450...
UNIX网络编程——网络IPC：套接字
ctthuangcheng
08-03 2431
Contents套接字接口套接字描述符寻址字节序地址格式地址查询绑定地址建立连接数据传输套接字选项带外数据UNIX域套接字使用套接字的示例面向连接的ruptime无连接的ruptime套接字接口套接字接口是一组用来结合UNIX I/O函数进行进程间通信的函数，大多数系统上都实现了它，包括各种UNIX变种、Windows和Mac系统。套接字接口套接字描述符套接字是通信端点的抽象，使用套接字描述符访问
第十六章 网络IPC:套接字
kevin_liu11的专栏
07-26 259
1. 套接字描述符   套接字是通信端点的抽象。   int socket(int domain, int type, int protocol); //创建一个套接字，返回套接字的描述符   //domain确定通信的特性，type确定套接字的类型，protocol代表通信协议   int shutdown(int sockfd, int how); //套接字的通信是双向的，它用来禁止
《unix环境高级编程》--- 网络IPC：套接字
新博客：https://aping-dev.com/
06-04 442
打印主机和服务信息 如果由多个协议为指定的主机提供相应的服务，程序性会打印出超过一条的信息。本例中，仅打印IPv4上的协议的地址信息，可在hint中设置ai_family打印限制在AF_INET协议族。 #include "apue.h" #include &lt;netdb.h&gt; #include &lt;arpa/inet.h&gt; #if defined(BSD) || de...
关于线程编程中“undefined reference to 'pthread_create'等问题的解决
灯火阑珊处
01-04 855
今天学习UNIX环境高级编程第11章中的线程编程，在编译第一个demo时，出现了“undefined reference to ‘pthread_create’”这种错误导致无法编译通过。 问题的原因：pthread 库不是 Linux 系统默认的库，连接时需要使用静态库 libpthread.a，所以在使用pthread_create()创建线程，以及调用 pthread_atfork()
UNIX环境高级编程-第9章- 进程关系
灯火阑珊处
12-23 695
9.4 进程组  在UNIX 系统中，每个进程除了自己的进程 ID之外，还属于一个进程组。进程组是一个进程或多个进程的集合，进程组本身也有属于自己的进程组ID，进程组属于一个会话，fork()并不改变进程组ID。 进程组组长：         进程ID与进程组ID相等的进程。组长可以改变子进程的进程组ID，使其转移到另一进程组。组长进程可以在所在的进程组创建进程，然后终止，从进程组创建开始到
I/O多路复用技术之 - epoll
灯火阑珊处
01-24 674
1、基础知识 　　epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。 2、epoll接口 　　epoll操作过程需要三个接口，分别如下： #include
UNIX环境高级编程-第17章- 高级进程间通信 - 一
灯火阑珊处
01-14 650
17.1 引言        前面两章介绍了UNIX系统提供的各种IPC，包括管道和套接字。本章介绍两种高级IPC：基于STREAM的管道和UNIX域套接字，并说明它们的应用方法。前面介绍的管道是半双工管道，本章基于 STREAMS 的管道是属于全双工的管道，半双工和全双工管道的区别如下：半双工只能在一端进行读或写；全双工可以在某一端同时进行读写；   17.2 基于 STREAMS
UNIX环境高级编程-第15章- 进程间通信 - 一
灯火阑珊处
01-10 632
15.1 引言 进程通信（IPC）是处理一个多进程系统中各个进程之间的协调。进程通信就是指多个进程之间相互通信、交换信息的方法。进程通信的目的如下： （1）数据传输：一个进程需要将它的数据发送给另一个进程； （2）共享数据：多个进程操作共享数据，若其中一个进程修改了共享数据，则其他进程立即可以看到修改后的数据； （3）通知事件：一个进程要向另一个或一组进程发送消息，通知它们发生了某种事，例
UNIX环境高级编程-第8章- 进程控制 - 一
灯火阑珊处
12-21 612
8.3 fork 函数 在 UNIX 系统中，一个现有进程可以调用 fork 函数创建一个新进程。调用 fork 函数的进程称为父进程，由 fork 创建的新进程被称为子进程（child process）。fork函数被调用一次但返回两次，两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。首先看下fork函数的原型； /* 创建进程 */ /* fork 函数 */
unix网络编程 卷1:套接字联网api
最新发布
07-31
《UNIX网络编程：卷1 套接字联网API》是一本由W. Richard Stevens所著的经典图书。该书系统地介绍了UNIX操作系统上的套接字编程技术。 套接字是UNIX网络编程中的核心概念之一，它提供了一种通信机制，使得不同主机...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值