UNIX-Linux环境编程（八）：网络通信

最新推荐文章于 2024-08-08 18:22:07 发布
最新推荐文章于 2024-08-08 18:22:07 发布
阅读量263 收藏
点赞数
分类专栏： linux socket 文章标签： socket unix 网络通信 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/perror_0/article/details/106986575
版权
本文详细介绍了UNIX/Linux环境中的网络通信，包括ISO/OSI七层网络协议模型、TCP/IP协议族及其与ISO/OSI模型的对比。重点讨论了套接字(Socket)的概念，如接口、模式、绑定和函数，并分别阐述了基于TCP和UDP协议的客户机/服务器模型，提供了编程示例。
摘要由CSDN通过智能技术生成

网络通信

之前有写过socket网络编程的一些基本概念，最近对一些知识点进行梳理之后打算详细的、有层次地归纳一下这些基础概念。

一、基本概念

1. ISO/OSI七层网络协议模型

ISO/OSI

2. TCP/IP协议族
  1. TCP (Transmission Control Protocol, 传输控制协议) 面向连接的服务。
  2. UDP (User Datagram Protocol, 用户数据报文协议) 面向无连接的服务。
  3. IP (Internet Protocol, 互联网协议) 信息传递机制。
    TCP/IP
3. TCP/IP协议与ISO/OSI模型的对比

TCP对比

4. 消息流

消息流

5. 消息包

消息包

6.IP地址
  1. IP地址是Internet中唯一的地址标识
    A. 一个IP地址占32位，正在扩充至128位。
    B. 每个Internet包必须带IP地址。
  2. 点分十进制表示法
    0x01020304 -> 1.2.3.4，高数位在左，低数位在右。
  3. IP地址分级
    A级：0 + 7位网络地址 + 24位本地地址
    B级：10 + 14位网络地址 + 16位本地地址
    C级：110 + 21位网络地址 + 8位本地地址
    D级：1110 + 28位多播(Muticast)地址
  4. 子网掩码
    IP地址 & 子网掩码 = 网络地址
    IP地址： 192.168.182.48
    子网掩码：255.255.255.0
    网络地址：192.168.182
    本地地址：48

二、套接字(Socket)

1. 接口

socket接口

2. 模式
  1. 点对点(Peer-to-Peer, P2P)：一对一的通信。
  2. 客户机/服务器(Client/Server, C/S)：一对多的通信。
3. 绑定

先要有一个套接字描述符，还要有物理通信载体，然后将二者绑定在一起。

4. 函数

  1. 创建套接字
    套接字描述符类似于文件描述符，UNIX把网络当文件看待，
    发送数据即写文件，接收数据即读文件，一切皆文件。

     #include <sys/socket.h>

 int socket (int domain, int type, int protocol);

 domain   - 域/地址族，取值：

 	AF_UNIX/AF_LOCAL/AF_FILE: 本地通信(进程间通信)；
 	AF_INET: 基于TCP/IPv4(32位IP地址)的网络通信；
 	AF_INET6: 基于TCP/IPv6(128位IP地址)的网络通信；
 	AF_PACKET: 基于底层包接口的网络通信。

 type     - 通信协议，取值：

 	SOCK_STREAM: 数据流协议，即TCP协议；
 	SOCK_DGRAM: 数据报协议，即UDP协议。

 protocol - 特别通信协议，一般不用，置0即可。

 成功返回套接字描述符，失败返回-1。

  2. 准备通信地址

     IP地址用于定位主机，端口号用于定位主机上的进程。
 A. 基本地址类型
 struct sockaddr 
 {
 	sa_family_t sa_family;   // 地址族
 	char        sa_data[14]; // 地址值
 };

 B. 本地地址类型
 #include <sys/un.h>
 struct sockaddr_un 
 {
 	sa_family_t sun_family; // 地址族
 	char        sun_path[]; // 套接字文件路径
 };

 C. 网络地址类型
 #include <netinet/in.h>
 struct sockaddr_in 
 {
 	// 地址族
 	sa_family_t sin_family;

 	// 端口号
 	// unsigned short, 0-65535
 	// 逻辑上表示一个参与通信的进程
 	// 使用时需要转成网络字节序
 	// 0-1024端口一般被系统占用
 	// 如：21-FTP、23-Telnet、80-WWW
 	in_port_t sin_port;

 	// IP地址
 	struct in_addr sin_addr;
 };
 struct in_addr
 {
 	in_addr_t s_addr;
 };
 typedef uint32_t in_addr_t;

    1. 将套接字和通信地址绑定在一起

       #include <sys/socket.h>
 int bind (int sockfd, const struct sockaddr* addr,socklen_t addrlen);
 成功返回0，失败返回-1。

    2. 建立连接

       #include <sys/socket.h>
 int connect (int sockfd, const struct sockaddr* addr,socklen_t addrlen);
 成功返回0，失败返回-1。

    3. 用读写文件的方式通信：read/write

    4. 关闭套接字：close

    5. 字节序转换

       #include <arpa/inet.h>

 // 32位无符号整数，主机字节序 -> 网络字节序
 uint32_t htonl (uint32_t hostlong);

 // 16位无符号整数，主机字节序 -> 网络字节序
 uint16_t htons (uint16_t hostshort);

 // 32位无符号整数，网络字节序 -> 主机字节序
 uint32_t ntohl (uint32_t netlong);

 // 16位无符号整数，网络字节序 -> 主机字节序
 uint16_t ntohs (uint16_t netshort);

主机字节序因处理器架构而异，有的采用小端字节序，有的采用大端字节序。网络字节序则固定采用大端字节序。

  1. IP地址转换

     #include <arpa/inet.h>

 // 点分十进制字符串 -> 网络字节序32位无符号整数
 in_addr_t inet_addr (const char* cp);

 // 点分十进制字符串 -> 网络字节序32位无符号整数
 int inet_aton (const char* cp, struct in_addr* inp);

 // 网络字节序32位无符号整数 -> 点分十进制字符串
 char* inet_ntoa (struct in_addr in);
5. 编程
  1. 本地通信
    服务器：创建套接字(AF_LOCAL)->准备地址(sockaddr_un)并绑定->接收数据->关闭套接字
    客户机：创建套接字(AF_LOCAL)->准备地址(sockaddr_un)并连接->发送数据->关闭套接字
    范例：locsvr.c、loccli.c
    locsvr.c
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCK_FILE "/tmp/sock"

int main () 
{
    printf ("服务器：创建本地数据报套接字...\n");

    int sockfd = socket (AF_LOCAL, SOCK_DGRAM, 0);
    if (sockfd == -1) 
    {
        perror ("socket");
        return -1;
    }

    printf ("服务器：准备地址并绑定...\n");

    struct sockaddr_un addr;
    addr.sun_family = AF_LOCAL;
    strcpy (addr.sun_path, SOCK_FILE);

    if (bind (sockfd, (struct sockaddr*)&addr, sizeof (addr)) == -1) 
    {
        perror ("bind");
        return -1;
    }

    printf ("服务器：接收数据...\n");

    for (;;) 
    {
        char buf[1024];

        ssize_t rb = read (sockfd, buf, sizeof (buf));
        if (rb == -1) 
        {
            perror ("read");
            return -1;
        }

        if (! strcmp (buf, "!!"))
           break;

       printf ("< %s\n", buf);
    }

   printf ("服务器：关闭套接字...\n");

    if (close (sockfd) == -1) 
    {
        perror ("close");
        return -1;
    }

    printf ("服务器：删除套接字文件...\n");

    if (unlink (SOCK_FILE) == -1) 
    {
        perror ("unlink");
        return -1;
    }

    printf ("服务器：大功告成！\n");

    return 0;
}

loccli.c

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCK_FILE "/tmp/sock"

int main () 
{
    printf ("客户机：创建本地数据报套接字...\n");

   int sockfd = socket (AF_LOCAL, SOCK_DGRAM, 0);
    if (sockfd == -1) 
    {
        perror ("socket");
        return -1;
    }

    printf ("客户机：准备地址并连接...\n");

    struct sockaddr_un addr;
    addr.sun_family = AF_LOCAL;
    strcpy (addr.sun_path, SOCK_FILE);
    if (connect (sockfd, (struct sockaddr*)&addr, sizeof (addr)) == -1) 
    {
        perror ("connect");
        return -1;
   }

    printf ("客户机：发送数据...\n");

    for (;;) 
    {
       printf ("> ");

        char buf[1024];
        gets (buf);

       if (! strcmp (buf, "!")) break;

        if (write (sockfd, buf, (strlen (buf) + 1) *
           sizeof (buf[0])) == -1) 
        {
           perror ("write");
            return -1;
       }

        if (! strcmp (buf, "!!"))
            break;
    }

    printf ("客户机：关闭套接字...\n");

    if (close (sockfd) == -1) 
    {
        perror ("close");
        return -1;
    }

    printf ("客户机：大功告成！\n");

    return 0;
}
  1. 网络通信
    服务器：创建套接字(AF_INET)->准备地址(sockaddr_in)并绑定->接收数据->关闭套接字
    客户机：创建套接字(AF_INET)->准备地址(sockaddr_in)并连接->发送数据->关闭套接字
    范例：netsvr.c、netcli.c
    netsvr.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main (int argc, char* argv[]) 
{
    if (argc < 2) 
    {
        fprintf (stderr, "用法：%s <端口号>\n", argv[0]);
        return -1;
    }

    printf ("服务器：创建网络数据报套接字...\n");

    int sockfd = socket (AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) 
    {
        perror ("socket");
        return -1;
    }

    printf ("服务器：准备地址并绑定...\n");

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons (atoi (argv[1]));
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind (sockfd, (struct sockaddr*)&addr, sizeof (addr)) == -1) 
    {
       perror ("bind");
        return -1;
    }

    printf ("服务器：接收数据...\n");

    for (;;) 
    {
        char buf[1024];

        ssize_t rb = read (sockfd, buf, sizeof (buf));
        if (rb == -1) 
        {
            perror ("read");
            return -1;
        }

        if (! strcmp (buf, "!!"))
            break;

        printf ("< %s\n", buf);
    }

    printf ("服务器：关闭套接字...\n");

    if (close (sockfd) == -1) 
    {
        perror ("close");
        return -1;
    }

    printf ("服务器：大功告成！\n");

    return 0;
}

netcli.c

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

int main (int argc, char* argv[]) 
{
    if (argc < 3) 
    {
        fprintf (stderr, "用法：%s <服务器IP地址> <端口号>\n", argv[0]);
        return -1;
    }

    printf ("客户机：创建网络数据报套接字...\n");

    int sockfd = socket (AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) 
    {
        perror ("socket");
        return -1;
    }

    printf ("客户机：准备地址并连接...\n");

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons (atoi (argv[2]));
    addr.sin_addr.s_addr = inet_addr (argv[1]);

    if (connect (sockfd, (struct sockaddr*)&addr, sizeof (addr)) == -1) 
    {
        perror ("connect");
        return -1;
    }

    printf ("客户机：发送数据...\n");

    for (;;) 
    {
        printf ("> ");

        char buf[1024];
        gets (buf);

        if (! strcmp (buf, "!")) break;

        if (write (sockfd, buf, (strlen (buf) + 1) *
            sizeof (buf[0])) == -1) 
        {
            perror ("write");
            return -1;
        }

        if (! strcmp (buf, "!!"))
           break;
    }

    printf ("客户机：关闭套接字...\n");

    if (close (sockfd) == -1) 
    {
        perror ("close");
        return -1;
   }

    printf ("客户机：大功告成！\n");

    return 0;
}

三、基于TCP协议的客户机/服务器模型

1. 基本特征

  1. 面向连接。

  2. 可靠，保证数据的完整性和有序性。
    A B C D E F
    基本特征
    每个发送都有应答，若在时间窗口内没有收到A的应答，则从A开始重发。

2. 编程模型

tcp编程模型
三次握手四次挥手

3. 常用函数

  1. listen

     #include <sys/socket.h>
 int listen (int sockfd, int backlog);

 将sockfd参数所标识的套接字标记为被动模式，使之可用于接受连接请求。

 backlog参数表示未决连接请求队列的最大长度，即最多允许同时有多少个未决连接请求存在。
 若服务器端的未决连接数已达此限，则客户机端的connect()函数将返回-1，且errno为ECONNREFUSED。

 成功返回0，失败返回-1。

listen
2. accept

int accept (int sockfd, struct sockaddr* addr,socklen_t* addrlen);

从sockfd参数所标识套接字的未决连接请求队列中，提取第一个连接请求。
同时创建一个新的套接字，用于在该连接中通信，返回该套接字的描述符。

addr和addrlen参数用于输出连接请求发起者的地址信息。

成功返回通信套接字描述符，失败返回-1。

accpet
3. recv

ssize_t recv (int sockfd, void* buf, size_t len,int flags);

通过sockfd参数所标识的套接字，
期望接收len个字节到buf所指向的缓冲区中。

成功返回实际接收到的字节数，失败返回-1。

  1. send

     ssize_t send (int sockfd, const void* buf,size_t len, int flags);

 通过sockfd参数所标识的套接字，
 从buf所指向的缓冲区中发送len个字节。

 成功返回实际被发送的字节数，失败返回-1。

范例：tcpsvr.c、tcpcli.c
tcpsvr.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <wait.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

void sigchld (int signum) 
{
    for (;;) 
    {
        pid_t pid = waitpid (-1, 0, WNOHANG);
        if (pid == -1) 
        {
            if (errno != ECHILD) 
            {
                perror ("waitpid");
                exit (-1);
            }

            printf ("服务器：全部子进程都已退出。\n");
            break;
        }

        if (pid)
            printf ("服务器：发现%u子进程退出。\n", pid);
        else 
        {
            printf ("服务器：暂时没有子进程退出。\n");
            break;
        }
    }
}

int main (int argc, char* argv[]) 
{
    if (argc < 2) 
    {
        fprintf (stderr, "用法：%s <端口号>\n", argv[0]);
        return -1;
    }

    if (signal (SIGCHLD, sigchld) == SIG_ERR) 
    {
        perror ("signal");
        return -1;
    }

    printf ("服务器：创建网络数据流套接字...\n");

    int sockfd = socket (AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) 
    {
        perror ("socket");
        return -1;
    }

    printf ("服务器：准备地址并绑定...\n");

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons (atoi (argv[1]));
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind (sockfd, (struct sockaddr*)&addr, sizeof (addr)) == -1) 
    {
        perror ("bind");
        return -1;
    }
    printf ("服务器：监听套接字...\n");

    if (listen (sockfd, 1024) == -1) 
    {
        perror ("listen");
        return -1;
    }

    for (;;) 
    {
        printf ("服务器：等待连接请求...\n");
        struct sockaddr_in addrcli = {};
        socklen_t addrlen = sizeof (addrcli);
        int connfd = accept (sockfd, (struct sockaddr*)&addrcli,&addrlen);
        if (connfd == -1) 
        {
            perror ("accept");
            return -1;
        }

        printf ("服务器：接受来自%s:%u客户机的连接请求。"
            "创建子进程为其提供服务...\n",
            inet_ntoa (addrcli.sin_addr), ntohs (addrcli.sin_port));

        pid_t pid = fork ();
        if (pid == -1) 
        {
            perror ("fork");
            return -1;
        }

        if (pid == 0) 
        {
            printf ("%u子进程：为%s:%u客户机提供服务...\n", getpid (),
                inet_ntoa (addrcli.sin_addr), ntohs (addrcli.sin_port));

            if (close (sockfd) == -1) 
            {
                perror ("close");
                return -1;
            }

            for (;;) 
            {
                char buf[1024];

                printf ("%u子进程：接收请求...\n", getpid ());

                ssize_t rb = recv (connfd, buf, sizeof (buf), 0);
                if (rb == -1) 
                {
                    perror ("recv");
                    return -1;
                }

                if (rb == 0) 
                {
                    printf ("%u子进程：客户机已关闭连接。\n",
                        getpid ());
                    break;
                }

                printf ("%u子进程：发送响应...\n", getpid ());

                if (send (connfd, buf, rb, 0) == -1) 
                {
                    perror ("send");
                    return -1;
                }
            }

            printf ("%u子进程：关闭连接套接字...\n", getpid ());

            if (close (connfd) == -1) 
            {
                perror ("close");
                return -1;
            }

           printf ("%u子进程：即将退出。\n", getpid ());

            return 0;
        }

        if (close (connfd) == -1) 
        {
            perror ("close");
            return -1;
        }
    }

    printf ("服务器：关闭监听套接字...\n");

    if (close (sockfd) == -1) 
    {
        perror ("close");
       return -1;
    }

    printf ("服务器：大功告成！\n");

    return 0;
}

tcpcli.c

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

int main (int argc, char* argv[]) 
{
    if (argc < 3) 
    {
        fprintf (stderr, "用法：%s <服务器IP地址> <端口号>\n", argv[0]);
       return -1;
    }

    printf ("客户机：创建网络数据流套接字...\n");

    int sockfd = socket (AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1) 
    {
        perror ("socket");
        return -1;
    }

    printf ("客户机：准备地址并连接...\n");

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons (atoi (argv[2]));
    addr.sin_addr.s_addr = inet_addr (argv[1]);

    if (connect (sockfd, (struct sockaddr*)&addr,
        sizeof (addr)) == -1) 
    {
        perror ("connect");
        return -1;
   }

    printf ("客户机：发送请求并接收响应...\n");

    for (;;) 
    {
        printf ("> ");

        char buf[1024];
        gets (buf);
        if (! strcmp (buf, "!")) break;

        if (send (sockfd, buf, (strlen (buf) + 1) *
            sizeof (buf[0]), 0) == -1) 
       {
            perror ("send");
            return -1;
        }

        ssize_t rb = recv (sockfd, buf, sizeof (buf), 0);
        if (rb == -1) 
        {
            perror ("recv");
           return -1;
        }

        if (rb == 0) 
        {
            printf ("客户机：服务器已宕机！\n");
            break;
        }

        printf ("< %s\n", buf);
    }

    printf ("客户机：关闭套接字...\n");

    if (close (sockfd) == -1) 
    {
       perror ("close");
        return -1;
    }

    printf ("客户机：大功告成！\n");

    return 0;
}

四、基于UDP协议的客户机/服务器模型

1. 基本特征

  1. 面向无连接。

  2. 不可靠，不保证数据的完整性和有序性。
    发送

  3. 效率高速度快。

2. 编程模型

udp模型
通信

3. 常用函数
#include <sys/socket.h>

ssize_t recvfrom (int sockfd, void* buf, size_t len,int flags, struct sockaddr* src_addr,socklen_t* addrlen);

通过sockfd参数所标识的套接字，期望接收len个字节到buf所指向的缓冲区中。

若src_addr和addrlen参数不是空指针，则通过这两个参数输出源地址结构及其长度。
注意在这种情况下，addrlen参数的目标应被初始化为，src_addr参数的目标数据结构的大小。

成功返回实际接收到的字节数，失败返回-1。

ssize_t sendto (int sockfd, const void* buf,size_t len, int flags,const struct sockaddr* dest_addr,socklen_t addrlen);

通过sockfd参数所标识的套接字，从buf所指向的缓冲区中发送len个字节。

发送目的的地址结构及其长度，通过dest_addr和addrlen参数输入。

成功返回实际被发送的字节数，失败返回-1。

范例：udpsvr.c、udpcli.c
udpsvr.c

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

int main (int argc, char* argv[]) 
{
    if (argc < 2) 
    {
        fprintf (stderr, "用法：%s <端口号>\n", argv[0]);
        return -1;
    }

    printf ("服务器：创建网络数据报套接字...\n");

    int sockfd = socket (AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) 
    {
        perror ("socket");
        return -1;
    }

    printf ("服务器：准备地址并绑定...\n");

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons (atoi (argv[1]));
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind (sockfd, (struct sockaddr*)&addr, sizeof (addr)) == -1) 
    {
        perror ("bind");
        return -1;
    }

    for (;;) 
    {
        printf ("服务器：接收请求...\n");

        char buf[1024];
        struct sockaddr_in addrcli = {};
        socklen_t addrlen = sizeof (addrcli);

        ssize_t rb = recvfrom (sockfd, buf, sizeof (buf), 0,
            (struct sockaddr*)&addrcli, &addrlen);
        if (rb == -1) 
        {
            perror ("recvfrom");
            return -1;
        }

        printf ("服务器：向%s:%u客户机发送响应...\n",
            inet_ntoa (addrcli.sin_addr), ntohs (addrcli.sin_port));

        if (sendto (sockfd, buf, rb, 0,
            (struct sockaddr*)&addrcli, addrlen) == -1) 
        {
            perror ("sendto");
            return -1;
        }
    }

    printf ("服务器：关闭套接字...\n");

    if (close (sockfd) == -1) 
    {
        perror ("close");
        return -1;
    }

    printf ("服务器：大功告成！\n");

    return 0;
}

udpcli.c

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

int main (int argc, char* argv[])
{
    if (argc < 3)
    {
        fprintf (stderr, "用法：%s <服务器IP地址> <端口号>\n", argv[0]);
        return -1;
    }

    printf ("客户机：创建网络数据报套接字...\n");

    int sockfd = socket (AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1)
    {
        perror ("socket");
        return -1;
    }

    printf ("客户机：准备地址...\n");

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons (atoi (argv[2]));
    addr.sin_addr.s_addr = inet_addr (argv[1]);

    printf ("客户机：发送请求并接收响应...\n");

    for (;;)
    {
        printf ("%s:%u> ", inet_ntoa (addr.sin_addr),
            ntohs (addr.sin_port));

        char buf[1024];
        gets (buf);

        if (! strcmp (buf, "!")) break;

        if (sendto (sockfd, buf, (strlen (buf) + 1) *
            sizeof (buf[0]), 0, (struct sockaddr*)&addr,
            sizeof (addr)) == -1)
        {
            perror ("send");
            return -1;
        }

        struct sockaddr_in addrsvr = {};
        socklen_t addrlen = sizeof (addrsvr);

        if (recvfrom (sockfd, buf, sizeof (buf), 0,
            (struct sockaddr*)&addrsvr, &addrlen) == -1)
        {
            perror ("recv");
            return -1;
        }

        printf ("%s:%u< %s\n", inet_ntoa (addrsvr.sin_addr),
            ntohs (addrsvr.sin_port), buf);
    }

    printf ("客户机：关闭套接字...\n");

    if (close (sockfd) == -1)
    {
        perror ("close");
        return -1;
    }

    printf ("客户机：大功告成！\n");

    return 0;
}

tcp/udp

perror_0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UNIX环境高级编程c语言---本地通信
weixin_53272394的博客
08-22 216
网络通信 参数： AF_UNIX/AF_LOCAL/AF_FILE: 本地通信(进程间通信)； AF_INET: 基于TCP/IPv4(32位IP地址)的网络通信； AF_INET6: 基于TCP/IPv6(128位IP地址)的网络通信； AF_PACKET: 基于底层包接口的网络通信。 type - 通信协议，取值： SOCK_STREAM: 数据流协议，即TCP协议； SOCK_DGRAM: 数据报协议，即UDP协议。 protocol - 特别通信协议，一般不用，置0即可。 成功返回套接字
UNIX-Linux socket网络编程（上）：基本概念
perror_0的博客
06-15 291
一、基本概念 OSI模型与TCP/IP模型： OSI(开放系统互联参考模型)为计算机网络设计的一个通信模型，由于太过复杂而没有完全实现，仅仅是一套设计方案。 共分为七层：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层 TCP/IP模型是OSI的具体实现，只实现出一部分，还没有完全实现，还有一些漏洞不太安全，是我们目前使用通信模型。 TCP/IP也叫协议簇，由一堆网络通信协议组成，其中TCP、IP是最重要的两个协议，因此简称TCP/IP。 共分为四层： 物理层：负责通过网络
Unix/Linux操作系统-网络通信
年糕的博客
08-05 528
一、计算机网络 什么是计算机网络 计算机网络是指地理位置不同的具有独立功能的多台计算机以及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 计算机网络的功能 数据通信 资源共享 提高系统的可靠性 分布式网络处理和负载均衡 计算机网络的组成 通信子网：网卡、线缆、集线器、中继器、交换机、路由器 资源子网：网络中的计...
unix-linux 网络通信
weixin_45396618的博客
08-11 195
网络通信ISO/OSITCP/IPTCP (Transmission Control Protocol, 传输控制协议) 面向连接的服务。UDP (User Datagram Protocol, 用户数据报文协议) 面向无连接的服务。IP (Internet Protocol, 互联网协议) 信息传递机制。套接字1.创建套接字2.准备通信地址本地un sun网络in sin3.套接字和通信地址绑定在一起4.建立链接5.用读写文件的方式通信：read/write6.关闭套接字close7.字节序转
Linux系统之网络编程
乐享的博客
11-06 384
Linux系统之网络编程1 网络基础理论1.1 OSI模型与TCP/IP协议1.2 TCP/IP体系模型1.2 TCP与UDP1.3 IP地址、端口、字节序1.4 socket相关函数1.4.1 socket()函数1.4.2 bind()函数1.4.3 listen()函数1.4.4 accept()函数1.4.5 connect()函数1.4.6 send()函数1.4.7 recv()函数1.4.8 sendto()函数1.4.9 recvfrom()函数1.5 TCP编程1.6 TCP粘包和拆包1.
Unix-Linux核心编程(精简).ppt
06-03
总结来说，《Unix-Linux核心编程》课程涵盖了操作系统的核心要素，包括操作系统简介、开发工具、编程接口、内存和文件管理、进程和线程控制以及网络通信。深入理解和掌握这些知识点对于任何想要在Unix/Linux环境下...
UNIX-LINUX-System-programming-example:Linux系统编程的一些例子
06-30
6. **网络编程**：在Linux下，使用套接字（socket）进行网络通信是常见的系统编程任务。`socket()`, `bind()`, `listen()`, `accept()`, `connect()`, `send()`, `recv()`等函数用于创建、连接、监听和交换数据。 7...
Unix-Linux编程实践教程.rar
07-13
《Unix-Linux编程实践教程》是一本专注于Unix和Linux系统编程的深度学习资源。这个教程旨在帮助读者理解和掌握在这些操作系统环境下进行程序开发的核心技术。Unix和Linux是两种广泛使用的开源操作系统，它们提供了...
Unix-Linux编程实践教程
02-14
《Unix-Linux编程实践教程》是一本专注于操作系统层面编程的指南，主要涵盖了Unix和Linux环境下的编程技术。这本书深入浅出地介绍了如何在这些开放源码操作系统上进行系统级编程和应用开发，对于想要深入了解这两种...
Unix-Linux编程实践教程(中文清晰带书签).pdf
01-06
《Unix-Linux编程实践教程》是一本面向程序员和系统管理员的实用指南，旨在通过丰富的实例深入浅出地介绍Unix和Linux环境下的系统级编程技术。这本书涵盖了从基本的命令行操作到复杂的系统调用和库函数的使用，是...
Linux--网络编程
qq_42579119的博客
01-19 214
1.Linux的优点之一就是在于它丰富而稳定的网络协议栈，其范围是从协议无关层（如通用的socket层接口和设备层）到各种网络协议的实现 2.对于网络理论介绍一般采用OSI模型，但是Linux中网络栈的介绍一般分为四层的Internet模型 2.1数据链路层 数据链路层实现了网卡接口的网络驱动程序，以处理数据在网络媒介上（比如以太网）上的传输。不同的物理网络层具有不同的电器特性，网络驱动驱动程...
C语言基础学习——第10天(文件操作)
cfl927096306的博客
10-07 439
C语言基础学习——第10天(文件操作)
行列式的计算
include_heqile的博客
05-31 1037
版本一： /********************************************* 思路： 对行列式进行初等变换，将某一列化至只有一个非零数 交换完毕之后产生新的数组和维度，递归执行determinant，当维度为2时， 计算该行列式的值，返回这个值 回溯返回最终结果 *********************************************/ #inc...
libevent
weixin_44705391的博客
06-09 249
文章目录前言概述基本函数介绍event_initevent_setevent_dispatchevent_base_setevent_addevent_base_loopevent_base_dispatch重要结构体实现一个简单的server使用buffereventbufferevent高级 前言 概述 官网：https://libevent.org/ 使用文档：https://www.monkey.org/~provos/libevent/doxygen-2.0.1/index.html lib
POSIX线程编程（上）：基本概念、特点和常用函数
perror_0的博客
06-14 897
多线程一、基本概念二、基本特点三、POSIX线程四、线程函数 一、基本概念 1、线程就是程序的执行路线，它是进程内部的控制序列，是资源的调度单位的基本单位，或者说它是进程的一部分。 2、线程是轻量级的，没有自己独立的内存资源、代码段、数据区、堆区、环境变量、命令行参数、文件描述符、信号处理函数、当前目录等资源。 3、线程拥有自己独立的栈内存，也就是有自己独立的局部变量，还有独立的线各ID、错误码、信号掩码。 4、一个进程可以同时拥有多个线程，也就是拥有多个执行路线，其中一个叫主线程。 5、线程是进程的一部分
【linux|001】Unix和Linux的关系 及 它们的发展历史
小鹏linux的博客
08-05 893
Unix和Linux之间的关系是复杂而紧密的。Linux是Unix的一种衍生系统，在继承Unix设计思想的同时，也发展出了自己的独特之处。两者在应用领域上有所重叠，但也各有侧重。随着计算机技术的不断发展，Unix和Linux将继续相互竞争和合作，共同推动计算机科学的发展。
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 498
使用TCP协议支持与多个客户端同时通信。
SSH 和 Telnet 之间的区别
ITmoster的博客
08-08 171
SSH 和 Telnet是帮助用户与远程系统建立连接的两种通信协议，这些通信协议决定了数据如何在网络上的不同设备之间传输，这些设备通常需要通过各种物理和数字环境进行传输，网络协议的主要目标是通信、网络管理和安全。
网络药理学：autodock tool（mgltools）实现大分子蛋白（PDB ID已知）和小分子配体的分子快速实践流程总结
最新发布
zhiaidaidai的博客
08-08 94
这里是快速实践的流程总结版（正文步骤都需要在中进行）。pocasaPDB。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值