socket

int socket(int family, int type, int protocol)  // 成功时返回sockfd

直接看Python的封装：

class _socketobject(object):

__doc__ = _realsocket.__doc__  # _realsocket = socket 是_socket库的

__slots__ = ["_sock", "__weakref__"] + list(_delegate_methods)

def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
    # sockfd
    if _sock is None:
        _sock = _realsocket(family, type, proto)  #这个__realsocket(family, type, proto) 即为c函数版本的
    self._sock = _sock
    for method in _delegate_methods:
        setattr(self, method, getattr(_sock, method))

def close(self, _closedsocket=_closedsocket,
          _delegate_methods=_delegate_methods, setattr=setattr):
    self._sock = _closedsocket()
    dummy = self._sock._dummy
    for method in _delegate_methods:
        setattr(self, method, dummy)
close.__doc__ = _realsocket.close.__doc__

def accept(self):
    sock, addr = self._sock.accept()
    return _socketobject(_sock=sock), addr
accept.__doc__ = _realsocket.accept.__doc__

def dup(self):
    return _socketobject(_sock=self._sock)

def makefile(self, mode='r', bufsize=-1):
    return _fileobject(self._sock, mode, bufsize)

family = property(lambda self: self._sock.family, doc="the socket family")
type = property(lambda self: self._sock.type, doc="the socket type")
proto = property(lambda self: self._sock.proto, doc="the socket protocol")

socket = SocketType = _socketobject

connect

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

再看Python的封装，是直接使用创建好的socket作为方法调用：

def connect(self, address)  # address为(addr, port)

这个版本的connect在连接失败后直接raise异常，可使用connect_ex来判断函数返回值。

bind

int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen)

Python的封装还是直接使用创建好的socket调用方法

 def bind(self, address)

如果服务器不调用bind方法，那么在它调用connect或listen，操作系统会给它分配一个临时端口。绑定ip的好处是可以在内核层面就按ip把客户端的请求分发（如多个网卡的机子，不同网卡绑定不同的服务器类型）。

listen

int listen(int sockfd, int backlog)

使用socket创建的是默认为主动套接字，调用了listen后变为被动套接字。内核为任何一个被动套接字维护两个队列：

1 未完成队列，等待三次握手的最后一步完成（等待客户端的ack）

2 已连接队列

两个队列之和不超过backlog，当进程调用accept时，如果已连接队列中有，则返回队列头部项给进程，如果队列为空则进程会睡眠。

另外不要设置backlog为0，如果不想被连接就直接关闭得了，因为历史问题总是有一些quirk。

accept

int accept(int sockfd, struct sockaddr *clientaddr, socklen_t *addrlen)

Python中的实现还是作为socket的方法：

    def accept(self):
        pass

返回值为两部分：socket, addr ，对应客户端的socket和addr(ip, port)

fork

pid_t fork(void)      -> python     os.fork()

fork返回两次，判断返回值，如果为0是到了子进程中，非0则是子进程的进程id（返回到父进程中），然后子进程可以调用getppid获取父进程的id。

fork的两种用法：

1 创建自身的副本，同时处理（网络服务器）
2 执行新程序

并发服务器

close

int close(int sockfd)

关闭该套接字，但是套接字是引用计数的，即只有当没有人在使用它时，它才会真正的关闭，如果哪里遗忘了调用close，会导致资源耗尽的问题，所以可在确定不使用的时候显式调用shutdown关闭连接。

getsocktname getpeername

返回套接字自身的地址返回套接字所连接的地址

基本套接字