网络IPC：套接字之数据传输

最新推荐文章于 2019-09-15 02:38:44 发布
最新推荐文章于 2019-09-15 02:38:44 发布
阅读量156 收藏
点赞数
文章标签： 网络 操作系统

既然将套接字端点表示为文件描述符，那么只要建立连接，就可以使用read和write来通过套接字通信。通过在connect函数里设置对方地址，数据报套接字也可以“连接”。在套接字描述符上采用read和write是非常有意义的，因为可以传递套接字描述符到那些原先设计为处理本地文件的函数。而且可以安排传递套接字描述符到执行程序的子进程，该子进程并不了解套接字。

尽管可以通过read和write交换数据，但这就是这两个函数所能做的一切。如果想指定选项、从多个客户端接收数据包或者发送带外数据，需要采用6个传递数据的套接字函数中的一个。

三个函数用来发送数据，三个用来接收数据。首先，考察用于发送数据的函数。

最简单的是send，它和write很像，但是可以指定标志来改变处理传输数据的方式。

#include <sys/socket.h>
ssize_t send(int sockfd, const void *buf, size_t nbytes, int flags);
返回值：若成功则返回发送的字节数，若出错则返回-1

类似write，使用send时套接字必须已经连接。参数buf和nbytes与write中的含义一致。

然而，与write不同的是，send支持第四个参数flags。其中3个标志是Single UNIX Specification规定的，但是其他标志通常实现也支持。表16-7总结了这些标志。

                                                                   表16-7 send套接字调用标志

未命名

如果send成功返回，并不必然表示连接另一端的进程接收数据。所保证的仅是当send成功返回时，数据已经无错误地发送到网络上。

对于支持为报文设限的协议，如果单个报文超过协议所支持的最大尺寸，send失败并将errno设置为EMSGSIZE；对于字节流协议，send会阻塞直到整个数据被传输。

函数sendto和send很类似。区别在于sendto允许在无连接的套接字上指定一个目标地址。

#include <sys/socket.h>
ssize_t sendto(int sockfd, const void *buf, size_t nbytes, int flags,
               const struct sockaddr *destaddr, socklen_t destlen);
返回值：若成功则返回发送的字节数，若出错则返回-1

对于面向连接的套接字，目标地址是忽略的，因为目标地址蕴含在连接中。对于无连接的套接字，不能使用send，除非在调用connect时预先设定了目标地址，或者采用sendto来提供另外一种发送报文方式。

可以使用不止一个的选择来通过套接字发送数据。可以调用带有msghdr结构的sendmsg来指定多重缓冲区传输数据，这和writev很相像（http://www.cnblogs.com/nufangrensheng/p/3559304.html）。

#include <sys/socket.h>
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
返回值：若成功则返回发送的字节数，出错则返回-1

POSIX.1定义了msghdr结构，它至少应该有如下成员：

struct msghdr {
    void            *msg_name;         /* optional address */
    socklen_t        msg_namelen;      /* address size in bytes */
    struct iovec    *msg_iov;          /* array of I/O buffers */
    int              msg_iovlen;       /* number of elements in array */
    void            *msg_control;      /* ancillary data */
    socklen_t        msg_controllen;   /* number of ancillary bytes */
    int              msg_flags;        /* flags for received message */
    ...
};

iovec结构可参考http://www.cnblogs.com/nufangrensheng/p/3559304.html。

下面是用于接收数据的函数。

函数recv和read很像，但是允许指定选项来控制如何接收数据。

#include <sys/socket.h>
ssize_t recv(int sockfd, void *buf, size_t nbytes, int flags);
返回值：以字节计数的消息长度，若无可用消息或对方已经按序结束则返回0，出错则返回-1

表16-8总结了flags标志。其中只有三个标志是Single UNIX Specification规定的。

                                                                   表16-8 recv套接字调用标志

未命名

当指定MSG_PEEK标志时，可以查看下一个要读的数据但不会真正取走。当再次调用read或recv函数时会返回刚才查看的数据。

对于SOCK_STREAM套接字，接收的数据可以比请求少。标志MSG_WAITALL阻止这种行为，除非所需数据全部收到，recv才会返回。对于SOCK_DGRAM和SOCK_SEQPACKET套接字，MSG_WAITALL标志没有改变什么行为，因为这些基于报文的套接字类型一次读取就返回整个报文。

如果发送者已经调用shutdown（http://www.cnblogs.com/nufangrensheng/p/3564695.html）来结束传输，或者网络协议支持默认的顺序关闭并且发送端已经关闭，那么当所有数据接收完毕后，recv返回0。

如果有兴趣定位发送者，可以使用recvfrom来得到数据发送者的源地址。

#include <sys/socket.h>
ssize_t recvfrom(int sockfd, void *restrict buf, size_t len, int flags,
                 struct sockaddr *restrict addr,
                 socklen_t *restrict addrlen);
返回值：以字节计数的消息长度，若无可用消息或对方已经按序结束则返回0，若出错则返回-1

如果addr非空，它将包含数据发送者的套接字端点地址。当调用recvfrom时，需要设置addrlen参数指向一个包含addr所指的套接字缓冲区字节大小的整数。返回时，该整数设为该地址的实际大小。

因为可以获得发送者的实际地址，recvfrom通常用于无连接套接字。否则recvfrom等同于recv。

为了将接收到的数据送入多个缓冲区（类似于readv（http://www.cnblogs.com/nufangrensheng/p/3559304.html）），或者想接收辅助数据，可以使用recvmsg。

#include <sys/socket.h>
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
返回值：以字节计数的消息长度，若无可用消息或对方已经按序结束则返回0，若出错则返回-1

结构msghdr（在sendmsg中见过）被recvmsg用于指定接收数据的输入缓冲区。可以设置参数flags来改变recvmsg的默认行为。返回时，msghdr结构中的msg_flags字段被设为所接收数据的各种特征（进入recvmsg时msg_flags被忽略）。从recvmsg中返回的各种可能值总结在表16-9中。

                                               表16-9 从recvmsg中返回的msg_flags标志

未命名

实例：面向连接的客户端

程序清单16-4显示了一个客户端命令，该命令用于与服务器通信以获得系统命令uptime的输出。该服务成为“remote uptime”（简称为“ruptime”）。

程序清单16-4 用于获取服务器uptime的客户端命令

#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <sys/socket.h>

#define MAXADDRLEN    256

#define    BUFLEN        128    

extern int connect_retry(int, const struct sockaddr *, socklen_t);

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");
}

int main(int argc, char *argv[])
{
    struct addrinfo *ailist, *aip;
    struct addrinfo hint;
    int        sockfd, err;

    if(argc != 2)
        err_quit("usage: ruptime hostname");
    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;
    if((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0)
        err_quit("getaddrinfo error: %s", gai_strerror(err));
    for(aip = ailist; aip != NULL; aip = aip->ai_next)
    {
        if((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0)
            err = errno;
        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);
}

其中，connect_retry函数见：http://www.cnblogs.com/nufangrensheng/p/3565858.html中的程序清单16-2

这个程序连接服务器，读取服务器发送过来的字符串并将其打印到标准输出。既然使用SOCK_STREAM套接字，就不能保证在一次recv调用中会读取整个字符串，所以需要重复调用直到返回0。

如果服务器支持多重网络接口或多重网络协议，函数getaddrinfo会返回不止一个候选地址。轮流尝试每个地址，当找到一个允许连接到服务的地址时便可停止。

编译上面的程序成功后，执行时出现错误：getaddrinfo error：Servname not supported for ai_socktype，后来经查询在http://blog.163.com/yjie_life/blog/static/16319833720110311528528/找到了解决办法。其原因是我们在getaddrinfo第二个参数传入的服务名“ruptime”还没有分配端口号，我们可以手动为其添加端口号，只需在/etc/services文件中添加一行：ruptime      8888/tcp  其中8888是分配的端口号，需要大于1024且不与其他服务的端口号重复就行，后面的tcp是协议。

实例：面向连接的服务器

程序清单16-5显示服务器程序，用来提供uptime命令到程序清单16-4的客户端程序的输出

程序清单16-5 提供系统uptime的服务器程序

#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <sys/socket.h>

#define BUFLEN    128
#define QLEN    10

#ifndef HOST_NAME_MAX
#define HOST_NAME_MAX    256
#endif

extern int initserver(int, struct sockaddr *, socklen_t, int);

void
serve(int sockfd)
{
    int      clfd;
    FILE    *fp;
    char     buf[BUFLEN];

    for(;;)
    {
        clfd = accept(sockfd, NULL, NULL);
        if(clfd < 0)
        {
            syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno));
            exit(1);
        }
        if((fp = popen("/usr/bin/uptime", "r")) == NULL)
        {
            sprintf(buf, "error: %s\n", strerror(errno));
            send(clfd, buf, strlen(buf), 0);
        }
        else
        {
            while(fgets(buf, BUFLEN, fp) != NULL)
                send(clfd, buf, strlen(buf), 0);
            pclose(fp);
        }
        close(clfd);
    }
}

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: ruptimed");
#ifdef _SC_HOST_NAME_MAX
    n = sysconf(_SC_HOST_NAME_MAX);
    if(n < 0)    /* best guess */
#endif
        n = HOST_NAME_MAX;
    host = malloc(n);
    if(host == NULL)
        err_sys("malloc error");
    if(gethostname(host, n) < 0)
        err_sys("gethostname error");
    daemonize("ruptimed");
    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;
    if((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0)
    {
        syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err));
        exit(1);
    }
    for(aip = ailist; aip != NULL; aip = aip->ai_next)
    {
        if((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0)
        {
            serve(sockfd);
            exit(0);
        }
    }
    exit(1);
}

其中，

initserver函数见：http://www.cnblogs.com/nufangrensheng/p/3565858.html中的程序清单16-3

daemonize函数见：http://www.cnblogs.com/nufangrensheng/p/3544104.html中的程序清单13-1

为了找到地址，服务器程序需要获得其运行时的主机名字。一些系统不定义_SC_HOST_NAME_MAX常量，因此这种情况下使用HOST_NAME_MAX。如果系统不定义HOST_NAME_MAX就自己定义。POSXI.1规定该值的最小值为255字节，不包括终结符，因此定义HOST_NAME_MAX为256以包括终结符。

通过调用gethostname，服务器程序获得主机名字。并查看远程uptime服务（ruptime）地址。可能会有多个地址返回，但简单地选择第一个来建立被动套接字端点，在这个端点等待到来的连接请求。

实例：另一个面向连接的服务器

前面说过采用文件描述符来访问套接字是非常有意义的，因为允许程序对联网环境的网络访问一无所知。程序清单16-6中显示的服务器程序版本显示了这一点。为了代替从uptime命令中读取输出并发送到客户端，服务器安排uptime命令的标准输出和标准出错替换为连接到客户端的套接字端点。

程序清单16-6 用于显示命令直接写到套接字的服务器程序

#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/wait.h>

#define QLEN    10

#ifndef HOST_NAME_MAX
#define HOST_NAME_MAX 256
#endif

extern int initserver(int, struct sockaddr *, socklen_t, int);

void
serve(int sockfd)
{
    int      clfd, status;
    pid_t    pid;
    
    for(;;)
    {
        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: fork error: %s", 
                strerror(errno));
            exit(1);
        }
        else if(pid == 0)    /* child */
        {
            /*
            * The parent called daemonize, so 
            * STDIN_FILENO, STDOUT_FILENO, and STDERR_FILENO
            * are already open to /dev/null. Thus, the call to
            * close doesn't need to be protected by checks that
            * clfd isn't already equal to one of these values.
            */
            if(dup2(clfd, STDOUT_FILENO) != STDOUT_FILENO || 
               dup2(clfd, STDERR_FILENO) != STDERR_FILENO)
            {
                syslog(LOG_ERR, "ruptimed: unexpected error");
                exit(1);
            }
            close(clfd);
            execl("/usr/bin/uptime", "uptime", (char *)0);
            syslog(LOG_ERR, "ruptimed: unexpected return from exec:                 %s", strerror(errno));
        }
        else    /* parent */
        {
            close(clfd);
            waitpid(pid, &status, 0);
        }    
    }
}


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: ruptimed");
#ifdef _SC_HOST_NAME_MAX
    n = sysconf(_SC_HOST_NAME_MAX);
    if(n < 0)    /* best guess */
#endif
        n = HOST_NAME_MAX;
    host = malloc(n);
    if(host == NULL)
        err_sys("malloc error");
    if(gethostname(host, n) < 0)
        err_sys("gethostname error");
    daemonize("ruptimed");
    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;
    if((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0)
    {
        syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", 
            gai_strerror(err));
        exit(1);
    }
    for(aip = ailist; aip != NULL; aip = aip->ai_next)
    {
        if((sockfd = initserver(SOCK_STREAM, aip->ai_addr, 
            aip->ai_addrlen, QLEN)) >= 0)
        {
            serve(sockfd);
            exit(0);
        }
    }
    exit(1);
}

以前的方式是采用popen来运行uptime命令，并从连接到命令标准输出的管道读取输出，现在采用fork来创建一个子进程，并使用dup2使子进程的STDIN_FILENO的副本打开到/dev/null、STDOUT_FILENO和STDERR_FILENO打开到套接字端点。当执行uptime时，命令将结果写到标准输出，该标准输出连到套接字，所以数据被送到ruptime客户端命令。

父进程可以安全地关闭连接到客户端的文件描述符，因为子进程仍旧打开着。父进程等待子进程处理完毕，所以子进程不会变成僵死进程。既然运行uptime花费时间不会太长，父进程在接受下一个连接请求之前，可以等待子进程退出。不过，这种策略不适合子进程运行时间比较长的情况。

前面的例子采用面向连接的套接字。但如何选择合适的套接字类型？何时采用面向连接的套接字，何时采用无连接的套接字呢？答案取决于要做的工作以及对错误的容忍程度。

对于无连接的套接字，数据包的到来可能已经没有次序，因此当所有的数据不能放在一个包里时，在应用程序里必须关心包的次序。包的最大尺寸是通信协议的特性。并且对于无连接套接字，包可能丢失。如果应用程序不能容忍这种丢失，必须使用面向连接的套接字。

容忍包丢失意味着两个选择。如果想和对方可靠通信，必须对数据报编号，如果发现包丢失，则要求对方重新传输。既然包可能因延迟而疑似丢失，我们要求重传，但该包却又出现，与重传过来的包重复。因此必须识别重复包，如果出现重复包，则将其丢弃。

另外一个选择是通过让用户再次尝试命令来处理错误。对于简单的应用程序，这就足够；但对于复杂的应用程序，这种处理方式通常不是可行的选择，一般在这种情况下使用面向连接的套接字更为可取。

面向连接的套接字的缺陷在于需要更多的时间和工作来建立一个连接，并且每个连接需要从操作系统中消耗更多的资源。

实例：无连接的客户端

程序清单16-7中的程序是采用数据报套接字接口的uptime客户端命令版本。

程序清单16-7 采用数据报服务的客户端命令

#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <sys/socket.h>

#define BUFLEN    128
#define TIMEOUT    20

void 
sigalrm(int signo)
{
}

void 
print_uptime(int sockfd, struct addrinfo *aip)
{
    int    n;
    char    buf[BUFLEN];
    
    buf[0] = 0;
    if(sendto(sockfd, buf, 1, 0, aip->ai_addr, aip->ai_addrlen) < 0)
        err_sys("sendto error");
    alarm(TIMEOUT);
    if((n = recvfrom(sockfd, buf, BUFLEN, 0, NULL, NULL)) < 0)
    {
        if(errno != EINTR)
            alarm(0);
        err_sys("recv error");
    }
    alarm(0);
    write(STDOUT_FILENO, buf, 0);
}

int 
main(int argc, char *argv[])
{
    struct addrinfo        *ailist, *aip;
    struct addrinfo         hint;
    int                     sockfd, err;
    struct sigaction        sa;
    
    if(argc != 2)
        err_quit("usage: ruptime hostname");
    sa.sa_handler = sigalrm;
    sa.sa_flags = 0;
    sigemptyset(&sa.sa_mask);
    if(sigaction(SIGALRM, &sa, NULL) < 0)
        err_sys("sigaction error");
    hint.ai_flags = 0;
    hint.ai_family = 0;
    hint.ai_socktype = SOCK_DGRAM;
    hint.ai_protocol = 0;
    hint.ai_addrlen = 0;
    hint.ai_canonname = NULL;
    hint.ai_addr = NULL;
    hint.ai_next = NULL;
    if((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0)
        err_quit("getaddrinfo error: %s", gai_strerror(err));

    for(aip = ailist; aip != NULL; aip = aip->ai_next)
    {
        if((sockfd = socket(aip->ai_family, SOCK_DGRAM, 0)) < 0)
        {
            err = errno;
        }
        else
        {
            print_uptime(sockfd, aip);
            exit(0);
        }
    }
    fprintf(stderr, "can't contact %s: %s\n", argv[1], strerror(err));
    exit(1);
}

除了为SIGALRM增加了一个信号处理程序以外，基于数据报的客户端main函数和面向连接的客户端中的类似。使用alarm函数来避免调用recvfrom时无限期阻塞。

对于面向连接的协议，需要在交换数据前连接服务器。对于服务器来说，到来的连接请求已经足够判断出所需提供给客户端的服务。但是对于基于数据报的协议，需要有一种方法来通知服务器需要它提供服务。本例中，只是简单地给服务器发送1字节的消息。服务器接收后从包中得到地址，并使用这个地址来发送响应消息。如果服务器提供多个服务，可以使用这个请求消息来指示所需要的服务，但既然服务器只做一件事情，1字节消息的内容是无关紧要的。

如果服务器不在运行状态，客户端调用recvfrom便会无限期阻塞。对于面向连接的例子，如果服务器不运行，connect调用会失败。为了避免无限期阻塞，调用recvfrom之前设置警告时钟。

实例：无连接服务器

程序清单16-8中的程序是数据报版本的uptime服务器程序。

程序清单16-8 基于数据报提供系统uptime的服务器程序

#include "apue.h"
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <sys/socket.h>

#define BUFLEN        128
#define    MAXADDRLEN    256

#ifndef    HOST_NAME_MAX
#define HOST_NAME_MAX    256
#endif

extern int initserver(int, struct sockaddr *, socklen_t, int);

void
serve(int sockfd)
{
    int          n;
    socklen_t    alen;
    FILE        *fp;    
    char         buf[BUFLEN];
    char         abuf[MAXADDRLEN];

    for(;;)
    {
        alen = MAXADDRLEN;
        if((n = recvfrom(sockfd, buf, BUFLEN, 0,
            (struct sockaddr *)abuf, &alen)) < 0)
        {
            syslog(LOG_ERR, "ruptimed: recvfrom error: %s", 
                strerror(errno));
            exit(1);
        }
        if((fp = popen("/usr/bin/uptime", "r")) == NULL)
        {
            sprintf(buf, "error: %s\n", strerror(errno));
            sendto(sockfd, buf, strlen(buf), 0,
                (struct sockaddr *)abuf, alen);
        }
        else
        {
            if(fgets(buf, BUFLEN, fp) != NULL)
                sendto(sockfd, buf, strlen(buf), 0,
                    (struct sockaddr *)abuf, alen);
            pclose(fp);
        }
    }    
}


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: ruptimed");        
    }
#ifdef _SC_HOST_NAME_MAX
    n = sysconf(_SC_HOST_NAME_MAX);
    if(n < 0)    /* best guess */
#endif
        n = HOST_NAME_MAX;
    host = malloc(n);
    if(host == NULL)
        err_sys("malloc error");
    if(gethostname(host, n) < 0)
        err_sys("gethostname error");
    daemonize("ruptimed");
    hint.ai_flags = AI_CANONNAME;
    hint.ai_family = 0;
    hint.ai_socktype = SOCK_DGRAM;
    hint.ai_protocol = 0;
    hint.ai_addrlen = 0;
    hint.ai_canonname = NULL;
    hint.ai_addr = NULL;
    hint.ai_next = NULL;
    if((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0)
    {
        syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s",
            gai_strerror(err));
        exit(1);
    }
    for(aip = ailist; aip != NULL; aip = aip->ai_next)
    {
        if((sockfd = initserver(SOCK_DGRAM, aip->ai_addr, 
            aip->ai_addrlen, 0)) >= 0)
        {
            serve(sockfd);
            exit(0);
        }
    }
    exit(1);
}

服务器在recvfrom中阻塞等待服务请求。当一个请求到达时，保存请求者地址并使用popen来运行uptime命令。采用sendto函数将输出发送到客户端，其目标地址就设为刚才的请求者地址。

本篇博文内容摘自《UNIX环境高级编程》（第2版），仅作个人学习记录所用。关于本书可参考：http://www.apuebook.com/。

weixin_34005042
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++教程网视频：linux网络编程
05-15
套接字类型 07socket编程（二） TCP客户/服务器模型 回射客户/服务器 socket、bind、listen、accept、connect 08socket编程（三） SO_REUSEADDR 处理多客户连接（process-per-conection） 点对点聊天程序...
进程间通信 六种IPC方式详解
one goto one 的博客
04-21 4560
进程间通信（IPC）介绍 IPC 单机形式有管道、消息队列、信号量、共享储存。多机形式有socket、streams。 一、管道 管道分为无名管道和有名管道。而管道通常指无名管道。 无名管道 特点 工作方式为半双工 ， 一方写另一方只能读（同一时间数据只能单方向流动） 使用只限于具有亲缘关系的进程之间，即父子、兄弟进程之间 管道可以理解为一种特殊的文件，可以使用read、write等函数进行读写， 但它不是普通文件，存在于内存中 数据被读取后就消失，不可进行二次读取 ......
利用流式套接字传输数据文件
新博客：https://aping-dev.com/
12-18 4774
服务器端： 1>建立一个基于对话框的应用程序StreamSocketServer 2>设计界面，将“确定”按钮的标题改为“启动” 3>双击“启动按钮”，添加以下代码，初始化网络，启动服务器监听void CStreamSocketServerDlg::OnOK() { // TODO: Add extra validation here WSADATA wsaData;
IPC（一）
jiangxt211的专栏
03-21 264
Communication Facilities We can break the communication facilities into two categories: Datatransfer facilities: The key factor distinguishing these facilities is the notion of writing and reading. 
计算机网络面试题
热门推荐
madman007的专栏
08-26 3万+
一、华为公司面试新员工的有关计算机网络的题目和答案       RFC1918文件规定了保留作为局域网使用的私有地址：            10.0.0.0                 -       10.255.255.255     (10/8   prefix)
看图理解进程间通信IPC
02-24
进程间通信(inter-processcommunication或interprocesscommunication，简写IPC)是指两个或两个以上进程(或线程)之间进行...套接字(Socket)通过网络接口将数据量发送到本机的不同进程或远程计算机。Unix域套接字(Unixd
soii-2021-ipc-JimenaVega:soii-2021-ipc-JimenaVega由GitHub Classroom创建
04-19
我们已经看到，它们可以分为两大类：数据传输（管道，FIFO，消息队列，套接字等）和共享内存（共享内存，内存映射等）。 所有这些机制在任何项目中都非常有用，这是当前工作的动力。 客观的 这项实际工作的目的是使...
Linux网络编程 视频 教程
08-16
套接字类型 07socket编程（二） TCP客户/服务器模型 回射客户 /服务器 socket、bind、listen、accept、connect 08socket编程（三） SO_REUSEADDR 处理多客户连接（process-per-conection） 点对点聊天...
c++教程网的linux网络编程视频下载
12-20
套接字类型 07socket编程（二） TCP客户/服务器模型 回射客户/服务器 socket、bind、listen、accept、connect 08socket编程（三） SO_REUSEADDR 处理多客户连接（process-per-conection） 点对点聊天程序...
LinuxIPC通信socket（C）
weixin_38452632的博客
01-03 716
Internet－“冷战”的产物 1957年10月和11月，前苏联先后有两颗“Sputnik”卫星上天 1958年美国总统艾森豪威尔向美国国会提出建立DARPA (Defense Advanced Research Project Agency)，即国防部高级研究计划署，简称ARPA 1968年6月DARPA提出“资源共享计算机网络” (Resource Sharing Computer Netw...
利用IP组播技术传输视频信息
vchelp小鱼儿的Blog
04-26 1939
 随着全球互联网（Internet）的迅猛发展，上网人数正以几何级数快速增长，以因特网技术为主导的数据通信在通信业务总量中的比列迅速上升，因特网业务已成为多媒体通信业中发展最为迅速、竞争最为激烈的领域。Internet网络传输和处理能力的大幅提高，使得网上应用业务越来越多，特别是视音频压缩技术的发展和成熟，使得网上视音频业务成为Internet网上最重要的业务之一。在Internet上实现的视
Linux 进程间通信（二）（网络IPC：套接字）
weixin_34254823的博客
09-05 113
socket描述符 套接字是通信端点的抽象,创建一个套接字使用如下函数: #include <sys/socket.h> int socket(int domain, int type, int protocol); 返回值：若成功，返回套接字描述符；若出错，返回-1 说明： domain: 指定通信的特征，包括地址格式，以AF_开头的常数表示地址族（add...
学习笔记☞python3☞网络编程（一）☞【OSI模型，网络概念，传输层服务，套接字编程-tcp编程】
赵卫坡的博客
05-09 250
1、OSI模型    1、OSI 七层模型        应用层：提供用户服务，具体内容由特定程序规定        表示层：提供数据的压缩、解压和加密        会话层：建立程序级的连接，决定使用什么样的传输服务        传输层：提供合适的通信服务，流量控制        网络层：路由选择，网络互连，分组传输        链路层：提供链路交换，具体消息的发送        物理层：物...
OOB套接字传输实例(达不到预期结果)
JoeBlackZQQ的专栏
11-09 1472
参考资料：>page119-205 代码本来是全照书上抄的，后来发现编译不成功，所以就稍微改了下。下面是我修改后的代码： server.c // OOB套接字传输服务端(Server.c) #include #include #include #include #include #include #include #include #include
Python网络编程 5.1 字符串、字节与其传输
MustangJy的博客
12-21 2465
1.网络通信中字节的一个特点是，套接字接口将字节暴露了出来，使得其无论是对程序员还是对应用程序都是可见的。我们通常无可避免地要考虑在传输过程中表示数据的方式。这会给我们带来一些问题，而python这种高级语言是可以让我们避免这类问题的。 2.如果想通过套接字传输一个符号串，那么就需要使用某种编码方法来为每个符号分配一个确切的字节值。最流行的一个编码方式是ASCII码，定义了从0到127的
网络编程四 套接字异常处理
weixin_41522164的博客
09-15 402
套接字异常捕获 套接字创建失败，8000 socket.error 客户端错误： 连接失败： ConnectionRefusedError socket.gaierror c.settimeout(1)： 设置客户端超时 如果超时，引发：socket.timeout 如果不设置该属性，引发的异常是：TimeoutError 客户端套接字： TCP：连接 成功连接之后：不...
套接字传输控制块
九天小哥的专栏
10-21 1448
传输控制块是协议栈的核心数据结构，一个套接字在TCP、IP层的代表就是一个传输控制块，它包含了一个套接字所需要的所有信息。linux对传输控制块的定义是分层次的，这篇笔记记录了传输控制块中各个成员的含义，实际中需要结合相应的使用代码来理解这些字段的含义。 注：当前只是罗列，并没有全部弄明白，该结构是在是太大了，后续慢慢补充 传输控制块的基石struct sock_common 其实看注释就能大概明...
Autosar 中的套接字
最新发布
05-24
基于UDP的套接字提供无连接的数据包传输，而基于TCP的套接字提供可靠的面向连接的数据流传输。 AUTOSAR套接字API包括以下功能： - 创建和销毁套接字 - 绑定套接字到本地地址 - 连接套接字到远程地址 - 接收和发送...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值