【计算机网络】网络编程接口 Socket API 解读（5）

news/2024/5/17 17:27:54 标签: TCP, UDP, socket, 套接字, 计算机网络

   Socket 是网络协议栈暴露给编程人员的 API，相比复杂的计算机网络协议，API 对关键操作和配置数据进行了抽象，简化了程序编程。

        本文讲述的 socket 内容源自 Linux man。本文主要对各 API 进行详细介绍，从而更好的理解 socket 编程。

connect

connect()           遵循 POSIX.1 - 2008

1.库

标准 c 库，libc, -lc

2.头文件

<sys/socket.h>

3.接口定义

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

4.接口描述

        connect() 系统调用在 sockfd 指定的 socket 上连接 addr 指定的地址，addrlen 参数指定了 addr 的大小，addr 地址格式取决于 socket 的地址空间，可以参考 socket(2)。

        如果 socket 是 SOCK_DGRAM 类型，那么 addr 是发送报文的默认地址，也是唯一接收报文的地址。如果 socket 类型是 SOCK_STREAM 或者 SOCK_SEQPACKET，那么这个调用就是尝试和绑定了 addr 地址的 socket 建立连接。

        一些协议套接字（比如 UNIX 流套接字）只能成功连接一次。

        一些协议套接字（比如 UNIX TCP 套接字和网络数据报套接字）可以多次 connect() 来修改连接。

        一些协议套接字（比如 UNIX TCP 套接字和网络数据报套接字）可以通过将 sockaddr 的 sa_family 设置为 AF_UNSPEC 来消除连接，之后 socket 就可以连接到其他地址了。（AF_UNSPEC 在 Linux 2.2 之后支持）。

5.返回值

        如果连接或者绑定成功，那么返回 0。

        发生错误时，返回 -1，并设置errno 来指示错误类型。

        错误值定义如下（这里指示普通 socket 的错误，还可能存在 domain-specific 错误码）：

EACCESUNIX 域套接字通过路径名唯一标识，并且是套接字文件是没有写权限的，路径中任何一级的搜索权限也是没有的，可以参考 path_resolution(7)
EACCES/EPERM用户尝试连接到一个广播地址，却没有设置套接字的广播标记，或者请求被防火墙规则拦截了
EACCES如果开启了 SELinux 策略，也可能会导致连接被拒绝（比如策略规定 HTTP 代理只能连接到 HTTP 服务器关联的端口，而 HTTP 代理却连接了其他端口）
EADDRINUSE本地地址已经在用了
EADDRNOTAVAIL（网络域套接字）sockfd 指定的套接字没有绑定到地址，并且在尝试将其绑定到临时端口时，临时端口用尽了
EAFNOSUPPORT地址家族不正确
EAGAIN对于非阻塞的 UNIX 域套接字，套接字是非阻塞的，连接无法立即完成。对于其他套接字家族，这个错误标识路由缓存没有足够的条目了
EALREADY套接字是非阻塞的，并且之前的连接尝试还没有完成
EBADFsockfd 不是一个打开的文件描述符
ECONNREFUSEDconnect() 操作的流套接字发现没有人在监听对应的远程地址
EFAULT套接字结构地址超出用户地址空间
EINPROGRESS套接字是非阻塞的，连接不能立即完成。（UNIX 域套接字会返回 EAGAIN）。可以通过 select(2) 或者 poll(2) 查看套接字的可写事件，来确定连接完成。select(2) 指示可写后，使用 getsockopt(2) 来读取 SOL_SOCKET 级的 SO_ERROR 选项，来确定连接完全成功（SO_ERROR 为 0）或者未成功（SO_ERROR 为这里列出来的普通错误）。
EINTR系统调用被信号打断
EISCONN套接字已经连接
ENETUNREACH网络不可达
ENOTSOCK文件描述符并没有指向一个套接字
EPROTOTYPE该套接字不支持指定的通信协议。这个错误可能在出现在连接一个 UNIX 域报文套接字到一个流套接字
ETIMEDOUT连接超时。可能是服务器太忙了以至于无法接收新的连接。注意：当服务器开启 syncookies 时，IP 套接字的超时可能会非常长。

6.注意

       如果 connect() 失败，那么套接字的状态是未知的。一个易于移植的程序应该关闭该套接字应该再创建一个新套接字，重新连接。

7.代码

        这里我们展示下 select() 的用法示例，来将最近几篇内容串起来：

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <errno.h>

#define SERVER_PORT  12345

#define TRUE             1
#define FALSE            0

main (int argc, char *argv[])
{
   int    i, len, rc, on = 1;
   int    listen_sd, max_sd, new_sd;
   int    desc_ready, end_server = FALSE;
   int    close_conn;
   char   buffer[80];
   struct sockaddr_in6   addr;
   struct timeval       timeout;
   struct fd_set        master_set, working_set;

   /*************************************************************/
   /* Create an AF_INET6 stream socket to receive incoming      */
   /* connections on                                            */
   /*************************************************************/
   listen_sd = socket(AF_INET6, SOCK_STREAM, 0);
   if (listen_sd < 0)
   {
      perror("socket() failed");
      exit(-1);
   }

   /*************************************************************/
   /* Allow socket descriptor to be reuseable                   */
   /*************************************************************/
   rc = setsockopt(listen_sd, SOL_SOCKET,  SO_REUSEADDR,
                   (char *)&on, sizeof(on));
   if (rc < 0)
   {
      perror("setsockopt() failed");
      close(listen_sd);
      exit(-1);
   }

   /*************************************************************/
   /* Set socket to be nonblocking. All of the sockets for      */
   /* the incoming connections will also be nonblocking since   */
   /* they will inherit that state from the listening socket.   */
   /*************************************************************/
   rc = ioctl(listen_sd, FIONBIO, (char *)&on);
   if (rc < 0)
   {
      perror("ioctl() failed");
      close(listen_sd);
      exit(-1);
   }

   /*************************************************************/
   /* Bind the socket                                           */
   /*************************************************************/
   memset(&addr, 0, sizeof(addr));
   addr.sin6_family      = AF_INET6;
   memcpy(&addr.sin6_addr, &in6addr_any, sizeof(in6addr_any));
   addr.sin6_port        = htons(SERVER_PORT);
   rc = bind(listen_sd,
             (struct sockaddr *)&addr, sizeof(addr));
   if (rc < 0)
   {
      perror("bind() failed");
      close(listen_sd);
      exit(-1);
   }

   /*************************************************************/
   /* Set the listen back log                                   */
   /*************************************************************/
   rc = listen(listen_sd, 32);
   if (rc < 0)
   {
      perror("listen() failed");
      close(listen_sd);
      exit(-1);
   }

   /*************************************************************/
   /* Initialize the master fd_set                              */
   /*************************************************************/
   FD_ZERO(&master_set);
   max_sd = listen_sd;
   FD_SET(listen_sd, &master_set);

   /*************************************************************/
   /* Initialize the timeval struct to 3 minutes.  If no        */
   /* activity after 3 minutes this program will end.           */
   /*************************************************************/
   timeout.tv_sec  = 3 * 60;
   timeout.tv_usec = 0;

   /*************************************************************/
   /* Loop waiting for incoming connects or for incoming data   */
   /* on any of the connected sockets.                          */
   /*************************************************************/
   do
   {
      /**********************************************************/
      /* Copy the master fd_set over to the working fd_set.     */
      /**********************************************************/
      memcpy(&working_set, &master_set, sizeof(master_set));

      /**********************************************************/
      /* Call select() and wait 3 minutes for it to complete.   */
      /**********************************************************/
      printf("Waiting on select()...\n");
      rc = select(max_sd + 1, &working_set, NULL, NULL, &timeout);

      /**********************************************************/
      /* Check to see if the select call failed.                */
      /**********************************************************/
      if (rc < 0)
      {
         perror("  select() failed");
         break;
      }

      /**********************************************************/
      /* Check to see if the 3 minute time out expired.         */
      /**********************************************************/
      if (rc == 0)
      {
         printf("  select() timed out.  End program.\n");
         break;
      }

      /**********************************************************/
      /* One or more descriptors are readable.  Need to         */
      /* determine which ones they are.                         */
      /**********************************************************/
      desc_ready = rc;
      for (i=0; i <= max_sd  &&  desc_ready > 0; ++i)
      {
         /*******************************************************/
         /* Check to see if this descriptor is ready            */
         /*******************************************************/
         if (FD_ISSET(i, &working_set))
         {
            /****************************************************/
            /* A descriptor was found that was readable - one   */
            /* less has to be looked for.  This is being done   */
            /* so that we can stop looking at the working set   */
            /* once we have found all of the descriptors that   */
            /* were ready.                                      */
            /****************************************************/
            desc_ready -= 1;

            /****************************************************/
            /* Check to see if this is the listening socket     */
            /****************************************************/
            if (i == listen_sd)
            {
               printf("  Listening socket is readable\n");
               /*************************************************/
               /* Accept all incoming connections that are      */
               /* queued up on the listening socket before we   */
               /* loop back and call select again.              */
               /*************************************************/
               do
               {
                  /**********************************************/
                  /* Accept each incoming connection.  If       */
                  /* accept fails with EWOULDBLOCK, then we     */
                  /* have accepted all of them.  Any other      */
                  /* failure on accept will cause us to end the */
                  /* server.                                    */
                  /**********************************************/
                  new_sd = accept(listen_sd, NULL, NULL);
                  if (new_sd < 0)
                  {
                     if (errno != EWOULDBLOCK)
                     {
                        perror("  accept() failed");
                        end_server = TRUE;
                     }
                     break;
                  }

                  /**********************************************/
                  /* Add the new incoming connection to the     */
                  /* master read set                            */
                  /**********************************************/
                  printf("  New incoming connection - %d\n", new_sd);
                  FD_SET(new_sd, &master_set);
                  if (new_sd > max_sd)
                     max_sd = new_sd;

                  /**********************************************/
                  /* Loop back up and accept another incoming   */
                  /* connection                                 */
                  /**********************************************/
               } while (new_sd != -1);
            }

            /****************************************************/
            /* This is not the listening socket, therefore an   */
            /* existing connection must be readable             */
            /****************************************************/
            else
            {
               printf("  Descriptor %d is readable\n", i);
               close_conn = FALSE;
               /*************************************************/
               /* Receive all incoming data on this socket      */
               /* before we loop back and call select again.    */
               /*************************************************/
               do
               {
                  /**********************************************/
                  /* Receive data on this connection until the  */
                  /* recv fails with EWOULDBLOCK.  If any other */
                  /* failure occurs, we will close the          */
                  /* connection.                                */
                  /**********************************************/
                  rc = recv(i, buffer, sizeof(buffer), 0);
                  if (rc < 0)
                  {
                     if (errno != EWOULDBLOCK)
                     {
                        perror("  recv() failed");
                        close_conn = TRUE;
                     }
                     break;
                  }

                  /**********************************************/
                  /* Check to see if the connection has been    */
                  /* closed by the client                       */
                  /**********************************************/
                  if (rc == 0)
                  {
                     printf("  Connection closed\n");
                     close_conn = TRUE;
                     break;
                  }

                  /**********************************************/
                  /* Data was received                          */
                  /**********************************************/
                  len = rc;
                  printf("  %d bytes received\n", len);

                  /**********************************************/
                  /* Echo the data back to the client           */
                  /**********************************************/
                  rc = send(i, buffer, len, 0);
                  if (rc < 0)
                  {
                     perror("  send() failed");
                     close_conn = TRUE;
                     break;
                  }

               } while (TRUE);

               /*************************************************/
               /* If the close_conn flag was turned on, we need */
               /* to clean up this active connection.  This     */
               /* clean up process includes removing the        */
               /* descriptor from the master set and            */
               /* determining the new maximum descriptor value  */
               /* based on the bits that are still turned on in */
               /* the master set.                               */
               /*************************************************/
               if (close_conn)
               {
                  close(i);
                  FD_CLR(i, &master_set);
                  if (i == max_sd)
                  {
                     while (FD_ISSET(max_sd, &master_set) == FALSE)
                        max_sd -= 1;
                  }
               }
            } /* End of existing connection is readable */
         } /* End of if (FD_ISSET(i, &working_set)) */
      } /* End of loop through selectable descriptors */

   } while (end_server == FALSE);

   /*************************************************************/
   /* Clean up all of the sockets that are open                 */
   /*************************************************************/
   for (i=0; i <= max_sd; ++i)
   {
      if (FD_ISSET(i, &master_set))
         close(i);
   }
}


http://www.niftyadmin.cn/n/5022681.html

相关文章

计算机竞赛 多目标跟踪算法 实时检测 - opencv 深度学习 机器视觉

计算机竞赛 多目标跟踪算法 实时检测 - opencv 深度学习 机器视觉

文章目录 0 前言2 先上成果3 多目标跟踪的两种方法3.1 方法13.2 方法2 4 Tracking By Detecting的跟踪过程4.1 存在的问题4.2 基于轨迹预测的跟踪方式 5 训练代码6 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; 深度学习多目标跟踪 …
阅读更多...
CPU性能优化

CPU性能优化

在进行CPU性能优化的时候&#xff0c;我们经常先需要分析出来我们的应用程序中的CPU资源在哪些函数中使用的比较多&#xff0c;这样才能高效地优化。一个非常好的分析工具就是《性能之巅》作者 Brendan Gregg 发明的火焰图。 我们今天就来介绍下火焰图的使用方法&#xff0c;以…
阅读更多...
机器学习算法详解3：逻辑回归

机器学习算法详解3：逻辑回归

机器学习算法详解3&#xff1a;逻辑回归 前言 ​ 本系列主要对机器学习上算法的原理进行解读&#xff0c;给大家分享一下我的观点和总结。 本篇前言 ​ 本篇对逻辑回归的算法原理进行解读。 目录结构 文章目录 机器学习算法详解3&#xff1a;逻辑回归1. 引子2. sigmoid函数3. 原…
阅读更多...
LeetCode算法心得——和为k的子数组（前缀和+HashMap）

LeetCode算法心得——和为k的子数组（前缀和+HashMap）

大家好&#xff0c;我是晴天学长&#xff0c;这是一个很重要的前缀和hash运用的题&#xff0c;为后面很多的题打基础&#xff0c;需要的小伙伴可以关注支持一下哦&#xff01;后续会继续更新的。 1) .和为k的子数组 2) .算法思路 和为k的子数组 1.首先是前缀和 2.根据关系 s【…
阅读更多...
接口优化1

接口优化1

接口优化 文章目录 接口优化1. 内容概述2. 集成RabbitMQ2.1 下载2.2 SpringBoot集成RabbitMQ 快速入门1.相关配置2.创建发送者者和接收者 2.3 rabbitmq四种交换模式2.4 秒杀接口优化 1. 内容概述 核心思路:减少对数据库的访问&#xff0c;利用Redis的高并发特性来实现。 系统初…
阅读更多...
RDP远程登录后全屏，本地的任务栏始终显示的问题解决

RDP远程登录后全屏，本地的任务栏始终显示的问题解决

文章目录 问题解决参考 问题 RDP远程登录后全屏&#xff0c;本地的任务栏&#xff08;Task Bar&#xff09;始终在下面&#xff0c;遮住了远程桌面的最下面&#xff0c;进行了解决。 解决 Best solution how to hide local Taskbar when RDP to a remote desktop Launch Ta…
阅读更多...
蓝桥杯官网练习题（幸运数字）

蓝桥杯官网练习题（幸运数字）

问题描述 哈沙德数是指在某个固定的进位制当中&#xff0c;可以被各位数字之和整除的正整数。例如 126 是十进制下的一个哈沙德数&#xff0c;因为 (126)10​mod(126)0&#xff1b;126 也是八进制下的哈沙德数&#xff0c;因为 (126)10(176)8&#xff0c;(126)10mod(176)0&…
阅读更多...
华为hcie认证培训报班培训好?还是自学好

华为hcie认证培训报班培训好?还是自学好

华为HCIE认证培训报班培训和自学各有优势。 培训的优势&#xff1a; 系统性学习&#xff1a;培训课程通常会系统地涵盖HCIE认证所需的各个知识点&#xff0c;帮助你建立全面的理论体系。指导与互动&#xff1a;培训中&#xff0c;能够与资深讲师互动&#xff0c;及时解答疑惑…
阅读更多...
最新文章

Copyright @ 2022~2023