精华内容
参与话题
问答
  • Accept

    2014-08-28 15:53:34
    Accept

    Accept

     

    SOCKET accept(

      _In_     SOCKET s,

      _Out_    struct sockaddr *addr,

      _Inout_  int *addrlen

    );

     

     

    返回值

    如果没有错误产生,则accept()返回一个描述所接受包的SOCKET类型的值。

    否则,将返回INVALID_SOCKET的价值,以及特定的错误代码可以通过调用WSAGetLastError进行检索。

    错误代码

    WSANOTINITIALISED:在使用此API之前应首先成功地调用WSAStartup()。

    WSAENETDOWN:WINDOWS套接口实现检测到网络子系统失效。

    WSAEFAULT:addrlen参数太小(小于socket结构的大小)。

    WSAEINTR:通过一个WSACancelBlockingCall()来取消一个(阻塞的)调用。

    WSAEINPROGRESS:一个阻塞的WINDOWS套接口调用正在运行中。

    WSAEINVAL:在accept()前未激活listen()。

    WSAEMFILE:调用accept()时队列为空,无可用的描述字。

    WSAENOBUFS:无可用缓冲区空间。

    WSAENOTSOCK:描述字不是一个套接口。

    WSAEOPNOTSUPP:该套接口类型不支持面向连接服务。

    WSAEWOULDBLOCK:该套接口为非阻塞方式且无连接可供接受。

    WSAECONNRESET:接受连接后在accept返回之前,被远程客户端断开连接。

    展开全文
  • ACCEPT

    2014-06-11 14:50:57
    ACCEPT 章节:Linux 程序员手册 (2) 更新:2010-09-10 到 易美翻译 翻译 名字 accept - 通过套接口接受一个连接 概要 #include Esys/types.h> /* 参看 “注意小节” */ #include Esys/socket.h> int ...

    ACCEPT

    章节:Linux 程序员手册 (2)
    更新:2010-09-10

    易美翻译 翻译

    名字

    accept - 通过套接口接受一个连接

    概要

    #include Esys/types.h> /* 参看 “注意小节” */
    #include Esys/socket.h>
    
    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    
    #define _GNU_SOURCE /* 参考 feature_test_macros(7) */
    #include <sys/socket.h>
    
    int accept4(int sockfd, struct sockaddr *addr,
     socklen_t *addrlen, int flags);
    

    描述

    accept() 系统调用应用于可连接套接口类型 (SOCK_STREAM,SOCK_SEQPACKET)。它取出在监听套接口 sockfd请求队列里的第一个连接,新建一个已连接的套接口,并且返回一个引用该套接口新的文件描述符。新建的套接口不处于监听状态。原始的套接口sockfd 没有受到影响。

    参数 sockfd 是一个由 socket(2) 创建的套接口,通过 bind绑定到一个本地地址,并且在调用 listen(2)之后正处于监听之中。

    参数 addr 是指向一个 sockaddr结构的指针。这结构体被填充为一个端套接口,又被称为通信层。返回的地址结体 addr的额外的格式可以通过套接口地址族(参看 socket(2)和各自的协议手册页)来确定。当 addr 是 NULL 时,没有内容被填充,此时 addrlen不被使用,同时也可以是 NULL。

    参数 addrlen 是一个“值-返回”型参数,调用者必须把它初始化为 addr指向的结构的大小(字节数),返回时,它指出端地址的实际大小。

    如果提供的缓冲区太小,返回的地址将被截断,此时,addrlen 将返回一个比传入更大的值。

    如果队列里没有未处理的连接,并且套接口没有标记为不阻塞,accept()会阻塞当前调用进程直到有一个连接出现。如果没有未处理的连接,同时套接口被标记为不阻塞,accept() 返回EAGAINEWOULDBLOCK 错误。

    为了在一个套接口有连接时收到通知,你可以使用 select(2) 或 poll(2)。当有连接时,一个可读事件被递送。进一步,你可以设置当一个套接口可用时,发送一个SIGIO,参看 socket(7)来详细了解。

    对于一些需要显示验证的协议,比如说 DECNet,accept()只是从队列里取出连接请求,并没有执行验证。验证将在下次对新建的文件描述符进行正常的读或写时进行,并且拒绝可以通过关闭那个新建的套接口来进行。目前在Linux 中只有 DECNet 有如此语义。

    flags 是 0,那么 accept4() 与 accept() 功能一样。下面flags 的值可能通过位求或运算来得到不同的行为:

    SOCK_NONBLOCK
    在新打开的文件描述符设置 O_NONBLOCK 标记。在 fcntl(2) 中保存这个标记可以得到相同的效果。
    SOCK_CLOEXEC
    在新打开的文件描述符里设置 close-on-exec (FD_CLOEXEC) 标记。参看在open(2) 里关于 O_CLOEXEC标记的描述来了解这为什么有用。

    返回值

    成功时,这个系统调用返回一个非负整数的文件描述符来代表接受的套接口。错误时,返回 -1,并把 errno设置为合适的值。

    错误处理

    在 Linux 里, accept() (和 accept4()) 把本属于accept() 的但未处理的网络错误传递给新建的套接口。 这个行为不同于其它 BSD 的实现。 可靠的应用应该在调用accept() 之后检测相应协议可能的网络错误,并且处理 EAGAIN 一样重试一次。对于 TCP/IP来说,这些错误有ENETDOWNEPROTOENOPROTOOPTEHOSTDOWNENONETEHOSTUNREACHEOPNOTSUPPENETUNREACH

    错误

    EAGAINEWOULDBLOCK
    套接口被标记为非阻塞并且没有连接等待接受。POSIX.1-2001允许在此时返回这两种错误,但没有要求两个常量必须具有相同的值,所以可移植的程序应该同时检查两者。
    EBADF
    描述符无效。
    ECONNABORTED
    一个连接已经中止了。
    EFAULT
    参数 addr 不在可写的用户地址空间里。
    EINTR
    在一个有效的连接到达之前,本系统调用被信号中断,参看 signal(7)。
    EINVAL
    套接口不在监听连接,或 addrlen 无效(如是负数)。
    EINVAL
    (accept4()) 在 flags 中有无效的值。
    EMFILE
    达到单个进程打开的文件描述上限。
    ENFILE
    达到系统允许打开文件个数的全局上限。
    ENOBUFS, ENOMEM
    没有足够的自由内存。这通常是指套接口内存分配被限制,而不是指系统内存不足。
    ENOTSOCK
    描述符是一个文件,不是一个套接字。
    EOPNOTSUPP
    引用的套接口不是 SOCK_STREAM 类型的。
    EPROTO
    协议错误。

    此外,Linux 下的 accept() 可能因如下原因失败:

    EPERM
    防火墙规则禁止连接。

    还有,新建套接口和协议相关的网络错误也可能被返回。多种 Linux 内核还会返回诸如ENOSRESOCKTNOSUPPORTEPROTONOSUPPORTETIMEDOUT的错误。ERESTARTSYS 的值也可能需要关注。

    版本

    accept4() 系统调用从 Linux 2.6.28 开始支持,glibc 在版本 2.10 开始支持。

    遵循于

    accept():POSIX.1-2001, SVr4, 4.4BSD, (accept() 首次出现在4.2BSD)。

    accept4() 是非标准 Linux 扩展。

    在 Linux 系统里,accept() 返回的新建的套接口 不会 继承监听套接口的诸如O_NONBLOCKO_ASYNC 这样的文件状态。这个行为与正规的 BSD套接口实现不一致。可移植的程序不应该假设文件状态是继承或不继承的,总是显示地设置 accept()返回的套接口需要的标记位。

    注意

    POSIX.1-2001 不要求包含 <sys/types.h>,并且这个头文件在 Linux中也不要求。然而一些历史(BSD)实现要求这个头文件,可移植的应用程序应该包含这个文件。

    SIGIO 递送之后,在 select(2) 或 poll(2) 返回但连接却因为一个异步网络错误而删除之后,或在其它线程调用accept() 之前,不需要总是等待。如果这些事发生了,调用将被阻塞到一个新连接到来,为了让accept() 绝不阻塞,传入的 sockfd 需要设置 O_NONBLOCK 标记(参看socket(7))。

    socklen_t 类型

    accept() 的第三个参数最初被声明为 int* (在 libc4 和 libc5,以及一些诸如4.x BSD、SunOS4、SGI)。POSIX.1g 草案想把它改为 size_t *,这与SunOS 5是一样的,接着 POSIX 草案提出了 socklen_t *,并且在 Single UnixSpecification 和 glibc2 也是如此。Linus Torvalds 曾说:

    “任何合理的库都必须保证 socklen_t 与 int 有相同的长度。否则的话都会与 BSD 套接口不同。POSIX 最初把它定义 为 size_t ,而我(同时也希望其他人,但显然不是太多)对他们表示强烈的不赞同。把它定义为 size_t将是完全地不兼容,尤其在 64 位系统里,size_t 很少跟 int 有相同的宽度。它 必须 与 int有相同的宽度,因为 BSD 接口是这样的。无论如何,制定 POSIX 的人还是创造出 socklen_t了。他们最初不应该去碰这个东西,但是一旦他们碰了,变会因为一些深奥的原因提供一个命名的类型(可能有些人因为之前愚笨的行为而丢脸时,就会静悄悄地他们的行为换个名字)。”

    示例

    参考 bind(2)。

    参看

    bind(2), connect(2), listen(2), select(2), socket(2), socket(7)


    英文原版:http://man7.org/linux/man-pages/dir_all_alphabetic.html

    展开全文
  • accept函数详解

    万次阅读 多人点赞 2013-10-29 00:08:47
    既然服务端已经很虔诚了,很真诚了,处于倾听状态,...接纳客户端请求的函数是accept, 我们先来看看函数的原型: WINSOCK_API_LINKAGE SOCKET WSAAPI accept( SOCKET s, struct sockaddr FAR * addr, int FAR * ad

           既然服务端已经很虔诚了,很真诚了,处于倾听状态,那么该是去尝试接受客户端请求的时候了,别只顾着倾听,不去接纳别人。

           接纳客户端请求的函数是accept, 我们先来看看函数的原型:

    WINSOCK_API_LINKAGE
    SOCKET
    WSAAPI
    accept(
        SOCKET s,
        struct sockaddr FAR * addr,
        int FAR * addrlen
        );

            函数的第一个参数用来标识服务端套接字(也就是listen函数中设置为监听状态的套接字),第二个参数是用来保存客户端套接字对应的“地方”(包括客户端IP和端口信息等), 第三个参数是“地方”的占地大小。返回值对应客户端套接字标识。

     

            实际上是这样的: accept函数指定服务端去接受客户端的连接,接收后,返回了客户端套接字的标识,且获得了客户端套接字的“地方”(包括客户端IP和端口信息等)。

     

           accept函数非常地痴情,痴心不改:

           如果没有客户端套接字去请求,它便会在那里一直痴痴地等下去,直到永远(注意, 此处讨论的是阻塞式的socket.  如果是非阻塞式的socket, 那么accept函数就没那么痴情了, 而是会立即返回, 并意犹未尽地对未来的客户端扔下一句话: 我等了你, 你不来, 那就算了, 我懒得鸟你)。

     

            来看看accpt函数的用法:

            unsigned int sockConn = accept(sockSrv,(SOCKADDR*)&addrClient, &len);

     

            要睡觉了。睡觉之前,最后来看看linux中的accept:

    ubuntu@VM-0-15-ubuntu:~$ man accept
    ACCEPT(2)                                     Linux Programmer's Manual                                    ACCEPT(2)
    
    NAME
           accept, accept4 - accept a connection on a socket
    
    SYNOPSIS
           #include <sys/types.h>          /* See NOTES */
           #include <sys/socket.h>
    
           int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    
           #define _GNU_SOURCE             /* See feature_test_macros(7) */
           #include <sys/socket.h>
    
           int accept4(int sockfd, struct sockaddr *addr,
                       socklen_t *addrlen, int flags);
    
    DESCRIPTION
           The  accept()  system  call  is  used  with  connection-based socket types (SOCK_STREAM, SOCK_SEQPACKET).  It
           extracts the first connection request on the queue of pending connections for the listening  socket,  sockfd,
           creates  a  new connected socket, and returns a new file descriptor referring to that socket.  The newly cre[m
           ated socket is not in the listening state.  The original socket sockfd is unaffected by this call.
    
           The argument sockfd is a socket that has been created with socket(2), bound to a local address with  bind(2),
           and is listening for connections after a listen(2).
    
           The  argument addr is a pointer to a sockaddr structure.  This structure is filled in with the address of the
           peer socket, as known to the communications layer.  The exact format of the address returned addr  is  deter[m
           mined  by  the  socket's  address family (see socket(2) and the respective protocol man pages).  When addr is
           NULL, nothing is filled in; in this case, addrlen is not used, and should also be NULL.
    
           The addrlen argument is a value-result argument: the caller must initialize it to contain the size (in bytes)
           of the structure pointed to by addr; on return it will contain the actual size of the peer address.
    
           The  returned  address  is truncated if the buffer provided is too small; in this case, addrlen will return a
           value greater than was supplied to the call.
    
           If no pending connections are present on the queue, and the socket is not  marked  as  nonblocking,  accept()
           blocks  the caller until a connection is present.  If the socket is marked nonblocking and no pending connec[m
           tions are present on the queue, accept() fails with the error EAGAIN or EWOULDBLOCK.
    
           In order to be notified of incoming connections on a socket, you can use select(2) or  poll(2).   A  readable
           event will be delivered when a new connection is attempted and you may then call accept() to get a socket for
           that connection.  Alternatively, you can set the socket to deliver SIGIO when activity occurs  on  a  socket;
           see socket(7) for details.
    
           For  certain  protocols which require an explicit confirmation, such as DECNet, accept() can be thought of as
           merely dequeuing the next connection request and not implying confirmation.  Confirmation can be implied by a
           normal  read  or  write  on  the new file descriptor, and rejection can be implied by closing the new socket.
           Currently only DECNet has these semantics on Linux.
    
           If flags is 0, then accept4() is the same as accept().  The following values can be bitwise ORed in flags  to
           obtain different behavior:
    
           SOCK_NONBLOCK   Set  the O_NONBLOCK file status flag on the new open file description.  Using this flag saves
                           extra calls to fcntl(2) to achieve the same result.
    
           SOCK_CLOEXEC    Set the close-on-exec (FD_CLOEXEC) flag on the new file descriptor.  See the  description  of
                           the O_CLOEXEC flag in open(2) for reasons why this may be useful.
    
    RETURN VALUE
           On success, these system calls return a nonnegative integer that is a descriptor for the accepted socket.  On
           error, -1 is returned, and errno is set appropriately.
    
       Error handling
           Linux accept() (and accept4()) passes already-pending network errors on the new socket as an error code  from
           accept().   This behavior differs from other BSD socket implementations.  For reliable operation the applica[m
           tion should detect the network errors defined for the protocol after accept() and treat them like  EAGAIN  by
           retrying.   In  the case of TCP/IP, these are ENETDOWN, EPROTO, ENOPROTOOPT, EHOSTDOWN, ENONET, EHOSTUNREACH,
           EOPNOTSUPP, and ENETUNREACH.
    
    ERRORS
           EAGAIN or EWOULDBLOCK
                  The socket is marked nonblocking and no connections are present  to  be  accepted.   POSIX.1-2001  and
                  POSIX.1-2008  allow  either  error to be returned for this case, and do not require these constants to
                  have the same value, so a portable application should check for both possibilities.
    
           EBADF  The descriptor is invalid.
    
           ECONNABORTED
                  A connection has been aborted.
    
           EFAULT The addr argument is not in a writable part of the user address space.
    
           EINTR  The system call was interrupted by a signal that was caught before a  valid  connection  arrived;  see
                  signal(7).
    
           EINVAL Socket is not listening for connections, or addrlen is invalid (e.g., is negative).
    
           EINVAL (accept4()) invalid value in flags.
    
    ......

             

              睡觉。

     


     

    展开全文
  • accept 翻译

    2018-04-25 19:20:09
    ACCEPT(2) Linux Programmer's Manual ACCEPT(2) NAME accept, accept4 - accept a connection on a socket /*在一个套接字上接收一个连接*/ ...
    ACCEPT(2)                                     Linux Programmer's Manual                                     ACCEPT(2)
    
    NAME
           accept, accept4 - accept a connection on a socket		/*在一个套接字上接收一个连接*/
    
    SYNOPSIS
           #include <sys/types.h>          /* See NOTES */
           #include <sys/socket.h>
    
           int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    
           #define _GNU_SOURCE             /* See feature_test_macros(7) */
           #include <sys/socket.h>
    
           int accept4(int sockfd, struct sockaddr *addr,
                       socklen_t *addrlen, int flags);
    
    DESCRIPTION
           The  accept()  system  call  is  used  with  connection-based  socket types (SOCK_STREAM, SOCK_SEQPACKET).  It extracts the first connection request on the queue of pending connections for the  listening  socket,  sockfd, creates a new connected socket, and returns a new file descriptor referring to that socket.  The newly created socket is not in the listening state. The original socket sockfd is unaffected by this call.
    	   /*accept 函数是用于基于连接的套接字(SOCK_STREAM, SOCK_SEQPACKET)。它会选择连接等待队列中的第一个连接请求,然后创建一个新的连接套接字并且返回一个指向该套接字的文件描述符。新创建的套接字并不会处于监听状态,原来的套接字(accept 参数中的套接字描述符所指向的套接字)不会受到 accept 调用函数的影响(包括文件状态位标志等)*/
    	   
           The argument sockfd is a socket that has been created with socket(2), bound to a local address  with  bind(2), and is listening for connections after a listen(2).
    	   /*sockfd 参数是一个套接字,该套接字由 socket 函数创建、bind 函数绑定本地地址,并且最后由 listen 函数设置用于监听连接的套接字。*/
    	     
           The argument addr is a pointer to a sockaddr structure. This structure is filled in with the address of the peer socket, as known to the communications layer. The exact format of the address returned addr is determined by the socket's address family (see socket(2) and the respective protocol man pages). When addr is NULL, nothing is filled in; in this case, addrlen is not used, and should also be NULL.
    	   /*addr 参数是一个指向 sockaddr 结构体的指针。该结构体包含了对方 socket 的地址,也就是众所周知的网络层。addr 的准确格式取决于套接字的地址族(请参阅 socket(2) 和相应的协议手册页)。当 addr == NULL 时,accept 函数不会获取任何信息,这时 addrlen 参数就毫无意义了,那么最后一个参数也应该填 NULL*/
    
           The addrlen argument is a value-result argument: the caller must initialize it to contain the size (in  bytes) of the structure pointed to by addr; on return it will contain the actual size of the peer address.
    	   /*addrlen 参数是一个值结果参数:调用者必须先初始化它,该参数用于储存 addr 指向结构体的大小(以字节为单位)。函数返回时,addrlen 将会把对方地址结构体的大小一并带回*/
    	   	   
           The returned address is truncated if the buffer  provided is too small; in this case, addrlen will return a value greater than was supplied to the call.
    	   /*如果提供的缓冲区太小,那么返回的地址将会被截断;这时,addrlen 将会返回一个大于给该调用提供的值*/
    
           If no pending connections are present on the queue, and the socket is  not  marked  as  nonblocking,  accept() blocks  the  caller until a connection is present.  If the socket is marked nonblocking and no pending connections are present on the queue, accept() fails with the error EAGAIN or EWOULDBLOCK.
    	   /*如果当前队列中没有等待的连接,并且 socket 也没有标记为非阻塞时, accept 函数将会阻塞调用者直到有连接为止。如果 socket 被标记为非阻塞并且当前队列中没有等待的连接时,那么 accept 函数将会出错,错误代码为 EAGAIN 或 EWOULDBLOCK*/
    
           In order to be notified of incoming connections on a socket, you can use select(2) or poll(2). A readable event  will be delivered when a new connection is attempted and you may then call accept() to get a socket for that connection.  Alternatively, you can set the socket to deliver SIGIO when activity occurs on a socket; see socket(7) for details.
    	   /*我们可以通过调用 select 函数或者 poll 函数来知道目前加入到连接队列的套接字。当一个新的请求尝试连接,并且此时我们调用 accept 函数创建了一个 socket ,这时我们就可以实现可读事件的传递了。当然了,我们也可以对 socket 进行设置,当 socket 有变化时立即发送 SIGIO 信号。具体细节参见 socket(7)*/
    
           For certain protocols which require an explicit confirmation, such as DECNet, accept() can be thought of as merely dequeuing the next connection request and not implying confirmation. Confirmation can be implied by a normal read or write on the new file descriptor, and rejection can be implied by closing the new socket. Currently only DECNet has these semantics on Linux.
    	   /*对于某些需要显式确认的协议,例如 DECNet,accept 函数则可以看作仅仅从队列中取出下一个连接而不做确认。当在一个新的文件描述符上进行普通读写操作时暗含了确认,当关闭这个新的套接字时暗含了拒绝。目前在 Linux 上只有 DECNet 具有这些含义*/
    
           If flags is 0, then accept4() is the same as accept(). The following values can be bitwise ORed in flags to obtain different behavior:
    	   /*如果 flag 参数为 0,则 accept4 函数和 accept 函数一样。以下值可以在标志中按位或运算以获得不同的行为。*/
    
           SOCK_NONBLOCK   Set the O_NONBLOCK file status flag on the new open file description. Using this flag saves extra calls to fcntl(2) to achieve the same result.
    	   /*SOCK_NONBLOCK	在新的打开文件描述中设置 O_NONBLOCK(非阻塞)文件状态标志.使用此标志可以节省对 fcntl 的额外调用,以实现相同的结果*/
    
           SOCK_CLOEXEC    Set the close-on-exec (FD_CLOEXEC) flag on the new file descriptor. See the description of the O_CLOEXEC flag in open(2) for reasons why this may be useful.
    	   /*SOCK_CLOEXEC	在新的打开文件描述中设置 close-on-exec (FD_CLOEXEC)文件状态标志.请参阅open 函数中 O_CLOEXEC 标志的说明了解设置该状态标志位的用处。*/	   
    
    RETURN VALUE
    		On  success, these system calls return a nonnegative integer that is a descriptor for the accepted socket. On error, -1 is returned, and errno is set appropriately.
    		/*成功,这些系统调用会返回一个非负整数,它是接受套接字的描述符;失败返回 -1,错误代码保存在 errno 中*/
    
    		Error handling Linux accept() (and accept4()) passes already-pending network errors on the new socket as an error  code  from accept(). This  behavior differs from other BSD socket implementations.  For reliable operation the application should detect the network errors defined for the protocol after accept() and treat them  like  EAGAIN  by retrying.   In the case of TCP/IP, these are ENETDOWN, EPROTO, ENOPROTOOPT, EHOSTDOWN, ENONET, EHOSTUNREACH, EOPNOTSUPP, and ENETUNREACH.
    		/*Linux accept(and accept4) 的错误处理是通过双方所连接的网络上的新的套接字实现的,该套接字所传递的错误信息仅仅只是 accept 函数出错所产生的错误代码,也就是 errno 的值,该方法与其他 BSD 套接字的实现有所不同。为了实现可靠的操作,应用程序应该在 accept 函数之后检测由于协议定义所产生的网络错误,并可以像 EAGAIN 一样通过重试对待。在 TCP/IP 情况下包括: ENETDOWN, EPROTO, ENOPROTOOPT, EHOSTDOWN, ENONET, EHOSTUNREACH, EOPNOTSUPP, and ENETUNREACH*/
    
    	ERRORS
           EAGAIN or EWOULDBLOCK The socket is marked nonblocking and no connections are present to be accepted. POSIX.1-2001  and POSIX.1-2008 allow either error to be returned for this case, and do not require these constants to have the same value, so a portable application should check for both possibilities.
    	   /*EAGAIN or EWOULDBLOCK	套接字被标记为非阻塞,同时并不存在要接受的连接。POSIX.1-2001 和 POSIX.1-2008 允许为这种情况返回错误,并且不要求这些常量具有相同的值,因此可移植的应用程序应该检查两种可能性*/
    
           EBADF  The descriptor is invalid.
    	   /*EBADF		描述符无效*/
    
           ECONNABORTED A connection has been aborted.
    	   /*ECONNABORTED		连接已终止*/
    
           EFAULT The addr argument is not in a writable part of the user address space.
    	   /*EFAULT				addr 参数不是用户地址空间的可写部分*/
    
           EINTR  The system call was interrupted by a signal that was caught before a valid connection arrived; see signal(7).
    	   /*EINTR				系统调用被一个在有效连接到达之前捕获的信号中断*/
    
           EINVAL Socket is not listening for connections, or addrlen is invalid(e.g., is negative).
    	   /*EINVAL				socket 并不是监听套接字,或者 addrlen 是无效的(例如,addrlen 是负值)*/
    
           EINVAL (accept4()) invalid value in flags.
    	   /*EINVAL				accept4 函数无效的标志位设置*/
    
           EMFILE The per-process limit on the number of open file descriptors has been reached.
    	   /*EMFILE				已达每个进程所能打开的文件描述符上限*/
    
           ENFILE The system-wide limit on the total number of open files has been reached.
    	   /*ENFILE				已达到系统范围内打开文件总数的上限*/
    
           ENOBUFS, ENOMEM Not enough free memory. This often means that the memory allocation is limited by the socket buffer limits, not by the system memory.
    	   /*ENOBUFS, ENOMEM	内存不足。这个错误一般来说意味着内存分配受套接字缓冲区所限, 而不是没有系统内存*/
    
           ENOTSOCK The file descriptor sockfd does not refer to a socket.
    	   /*ENOTSOCK			sockfd 参数不是一个套接字*/
    
           EOPNOTSUPP The referenced socket is not of type SOCK_STREAM.
    	   /*EOPNOTSUPP			引用的套接字不是 SOCK_STREAM 类型*/
    
           EPROTO Protocol error.
    	   /*EPROTO				协议错误*/
    
           In addition, Linux accept() may fail if:
    	   /*此外,如果出现以下情况,Linux accept 函数也会出错*/
    
           EPERM  Firewall rules forbid connection.
    	   /*EPERM				防护墙设置禁止连接*/
    
           In addition, network errors for the new socket and as defined for the protocol may be returned. Various Linux kernels  can return other errors such as ENOSR,  ESOCKTNOSUPPORT, EPROTONOSUPPORT, ETIMEDOUT. The value ERESTARTSYS may be seen during a trace.
    	   /*此外,新套接字的网络错误以及协议中定义的错误也会被返回。不同的 Linux 内核也会返回一些其他问题,如:ENOSR,  ESOCKTNOSUPPORT, EPROTONOSUPPORT, ETIMEDOUT。一直追溯可以看到 ERESTARTSYS 的值*/
    
    VERSIONS
           The accept4() system call is available starting with Linux 2.6.28; support in glibc is available starting with version 2.10.
    	   /*accept4 系统调用函数从 Linux 2.6.28 版本才开始使用的;glibc 支持版本是从 2.10 开始提供*/
    
    CONFORMING TO
           accept(): POSIX.1-2001, POSIX.1-2008, SVr4, 4.4BSD (accept() first appeared in 4.2BSD).
    	   /*accept 函数第一次出现是在 4.2BSD 中*/
    
           accept4() is a nonstandard Linux extension.
    	   /*accept4 函数是一个非标准的 Linux 扩展*/
    
           On Linux, the new socket returned by accept() does not inherit file status flags such as O_NONBLOCK and O_ASYNC from the listening socket. This behavior differs from the canonical BSD sockets implementation. Portable programs should not rely on inheritance or noninheritance of file status flags and always explicitly set all required flags on the socket returned from accept().
    	   /*在 Linux 上,accept 函数返回的新套接字不会从监听套接字中继承文件状态标志,例如:O_NONBLOCK 和 O_ASYNC。这和规范的 BSD 套接字实现机制有所不同。可移植程序不应该依赖于文件状态的是否可继承,而是应当在 accept 函数返回时就将所有需求都在 socket 的相应标志位上设置好。
    	   可移植程序不应该依赖于文件状态标志的继承或不继承,并且总是显式地设置从accept()返回的套接字上所有必需的标志。*/
    
    NOTES
           POSIX.1-2001 does not require the inclusion of <sys/types.h>, and this header file is not required on Linux. However, some historical (BSD) implementations required this header file, and portable applications are probably wise to include it.
    	   /*POSIX.1 不需要 <sys/types.h>头文件,但是由于历史原因(例如:BSD)就需要该头文件,所有还是加一下该头文件比较好*/
    	 
           There may not always be a connection waiting after a SIGIO is delivered or select(2) or poll(2) return a readability  event because the connection might have been removed by an asynchronous network error or another thread before accept() is called.  If this happens, then the call will block waiting for the  next  connection to  arrive.   To ensure that accept() never blocks, the passed socket sockfd needs to have the O_NONBLOCK flag set (see socket(7)).
    	   /*当接收到一个 SIGIO 信号或者 select、poll 函数返回读就绪时并不总是意味着有新的连接在等待,因为连接很可能在 accept 函数调用之前被一个异步网络错误或者另一个线程删除。如果发生这种情况, 那么调用将阻塞并等待下一个连接的到来。为确保 accept 永远不会阻塞,传递的套接字 sockfd 需要设置成 O_NONBLOCK 标志(参见 socket(7))*/
    
       The socklen_t type		/*socklen_t 类型*/
           The third argument of accept() was originally declared as an int * (and is that under libc4 and libc5  and  on many other systems like 4.x BSD, SunOS 4, SGI); a POSIX.1g draft standard wanted to change it into a size_t *, and that is what it is for SunOS 5.  Later POSIX drafts have socklen_t *, and so do the Single UNIX Specification and glibc2. Quoting Linus Torvalds:
    	   /*函数 accept 的第三个参数原来被声明为 int * (在libc4 和 libc5 以及其他很多系统中, 比如 BSD 4.x, SunOS 4, SGI); POSIX.1g 草案试图将其改变为 size_t * 类型, SunOS 5  是这么做的。 后来的POSIX 草案和 Single Unix Specification 以及 glibc2 使用了 socklen_t *。引用 Linus Torvalds 一段话:*/
    
           "_Any_ sane library _must_  have 'socklen_t' be the same size as int.  Anything else breaks any BSD socket layer stuff.  POSIX initially did make it a size_t, and I (and hopefully others, but obviously not  too  many) complained  to  them very loudly indeed. Making it a size_t is completely broken, exactly because size_t very seldom is the same size as "int" on 64-bit architectures, for example.  And it has to  be  the  same  size  as "int"  because  that's  what the BSD socket interface is.  Anyway, the POSIX people eventually got a clue, and created "socklen_t".  They shouldn't have touched it in the first place, but once they did they felt it had to have a named type for some unfathomable reason (probably somebody didn't like losing face over having done the original stupid thing, so they silently just renamed their blunder)."
    	   /*任何一个明智的库函数设计者都一定会将 'socklen_t' 的数据类型设置为 int。否则就会破坏 BSD套接字层的填充。POSIX 开始的时候用的是 size_t, Linus Torvalds (他希望有更多的人,但显然不是很多) 努力向他们解释使用 size_t 是完全错误的,因为在 64 位结构中 size_t 和 int 的长度是不一样的,而这个参数(也就是 accept 函数的第三个参数)的长度必须和 int 一致,因为这是BSD套接字接口标准.最终 POSIX 的那帮家伙找到了解决的办法,那就是创造了一个新的类型 socklen_t。Linux Torvalds 说这是由于他们发现了自己的错误但又不好意思向大家伙儿承认,所以另外创造了一个新的数据类型。*/
    
    EXAMPLE
           See bind(2).
    
    SEE ALSO
           bind(2), connect(2), listen(2), select(2), socket(2), socket(7)
    
    COLOPHON
           This page is part of release 4.04 of the Linux man-pages project.  A description of the  project,  information about reporting bugs, and the latest version of this page, can be found at http://www.kernel.org/doc/man-pages/.
    
    Linux                                                 2015-12-28                                            ACCEPT(2)
    

    展开全文
  • accept4
  • accept函数

    2018-03-02 10:51:26
    accept函数,accept a connection on a socket,接收一个socket的连接。函数原型int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);函数说明sockfd:socket 文件描述符addr:表明sockaddr的指针,...
  • accept的用法与搭配是什么首页:高考辅导网 栏目:高中英语 时间:2019-06-23accept作动词,意思是同意、接受。accept的用法有accept sth (as sth),accept sb (into sth) ,accept sb (as sth)等。选自.高三网上补课1...
  • Accept Yours 就是直接选取本地的代码,覆盖掉远程仓库的 Accept Theirs 是直接选取远程仓库的,覆盖掉自己本地的 我们选择Merge,自己手动行进选择、修改。 这里左边部分是你本地仓库的代码,右边部分是远程仓库...
  • Accept Yours 就是直接选取本地的代码,覆盖掉远程仓库的 Accept Theirs 是直接选取远程仓库的,覆盖掉自己本地的 我们选择Merge,自己手动行进选择、修改。 这里左边部分是你本地仓库的代码,右边部分是远程仓库...
  • Accept q

    2015-12-11 14:25:35
    当你有如下Accept头: ①Accept:text/html,application/xml,application/json 将按照如下顺序进行produces的匹配 ①text/html ②application/xml ③application/json ②Accept:application/xml;q=0.5,...
  • Accept-Encoding

    2019-05-17 14:27:12
    Accept-Encoding,HTTP Header中Accept-Encoding 是浏览器发给服务器,声明浏览器支持的编码类型 目录 1Accept-Encoding 2编码类型 Accept-Encoding HTTP Header中Accept-Encoding 是浏览器发给服务器,声明...
  • accept4()函数共有4个参数,相比accept()多了一个flags的参数,用户可以通过此参数直接设置套接字的一些属性,如SOCK_NONBLOCK或者是SOCK_CLOEXEC。 当accept4的flags为0的时候,accept4和accept没有区别。 SOCK_...
  • input accept

    千次阅读 2015-07-19 23:59:56
    input accept是为了上传文件时,浏览器选择什么类型文件而存在的。 比如: html <input type="file" name="pic" accept="image/gif,image.jpg" /> 将寻找gif,jpg格式的文件。 功能很强大,但是chrome不兼容...
  • input的accept

    2019-04-22 09:46:43
    inputtype="file"accept="image/*"capture="camera"> <inputtype="file"accept="video/*"capture="camcorder"> <inputtype="file"accept="audio/*"capture="microphone"> 第一个是只能拍照上传...
  • HTML accept 属性

    2019-03-19 14:51:58
    accept 属性规定了可通过文件上传提交的服务器接受的文件类型。 注意:accept 属性仅适用于 <input type="file">。 提示:请不要将该属性作为您的验证工具。应该在服务器上对文件上传进行验证。 实例 ...
  • ACCEPT()和ACCEPT4()

    万次阅读 2012-11-18 16:59:36
    ACCEPT章节:Linux 程序员手册 (2)更新:2010-09-10到 易美翻译 翻译名字accept - 通过套接口接受一个连接概要#include Esys/types.h> /* 参看 “注意小节” */ #include Esys/socket.h> int accept(int sockfd, ...
  • socket源码分析之accept

    千次阅读 2018-09-12 09:02:04
    socket源码分析之accept() 基于 kernel 3.10 之前有分析过TCP accept()的实现,但是太过于沉浸于代码本身,没有结合应用去分析accept()函数。 我们要解决如下几个问题: 1:accept()函数的实现,包括从...
  • accept 属性规定了可通过文件上传提交的服务器接受的文件类型。 注意:accept 属性仅适用于 <input type="file">。 提示:请不要将该属性作为您的验证工具。应该在服务器上对文件上传进行验证。 实例 ...
  • Http报头Accept

    2016-08-09 11:05:31
    #最近在学习Jsp,对Accept进行记录1.accept="application/msexcel" 2.accept="application/msword" 3.accept="application/pdf" 4.accept="application/poscript" 5.accept="application/rtf" 6.accept="application...
  • 文件上传属性accept

    2020-12-05 14:34:12
    在文件上传中使用 accept 属性,本例中的输入字段可以接受 GIF 和 JPEG 两种图像: 如果不限制图像的格式,可以写为:accept="image/*"。 accept 属性只能与 <input type="file"> 配合使用。它规定能够通过...
  • accept 函数

    千次阅读 2012-04-30 10:44:41
    accept函数 头文件 函数形式 int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 返回值 成功 失败 是否设置...
  • TCP之延迟ACCEPT

    2019-05-08 21:24:29
    通常情况下,在一个新的TCP连接完成三次握手之后,监听端的accept系统调用就可返回与此对应的子套接口。然而,TCP的延迟ACCEPT功能,允许TCP监听端仅在接收到客户端的数据报文后才去唤醒服务端应用的ACCEPT请求。 ...
  • accept使用陷阱

    2017-06-28 01:02:31
    accept 参数中的 addrlen是一个传入传出参数, 在使用的时候先将 addr 结构体指针指向的空间大小传入accept返回时会将addrlen修改为结果addr实际需要的大小, 并且addr返回的是不超过传入的addlen大小的结果。

空空如也

1 2 3 4 5 ... 20
收藏数 113,685
精华内容 45,474
关键字:

accept