1 from sock.sock cimport *

     2 from sock.addr cimport sockaddr, build_sockaddr

     3 

     4 cimport libc, py

     5 

     6 from py cimport raise_errno

     7 

     8 # XXX: do some GIL-releasin'

     9 cdef class sock :

    10 

    11     def __init__ (self, int fd = -1) :

    12         """

    13             Construct this socket with the given fd, or -1 to mark it as fd-less

    14         """

    15 

    16         self.fd = fd

    17 

    18     def socket (self, int family = libc.AF_INET, int socktype = libc.SOCK_STREAM, int protocol = 0) :

    19         """

    20             Create a new socket endpoint with the given family/domain, socktype and optionally, specific protocol.

    21 

    22                 family      - one of AF_*

    23                 socktype    - one of SOCK_*

    24                 protocol    - one of IPPROTO_* or zero to select default

    25         """

    26 

    27         if self.fd >= 0 :

    28             raise Exception("Socket fd already exists")

    29         

    30         # socket()

    31         self.fd = libc.socket(family, socktype, protocol)

    32         

    33         # trap

    34         if self.fd < 0 :

    35             raise_errno('socket')

    36 

    37     def bind (self, sockaddr addr) :

    38         """

    39             Bind this socket to the given local socket address. The given sockaddr should be of the same or a

    40             compatible address family.

    41 

    42                 addr        - the local address to bind to. The port may be zero to let the system choose an unused

    43                               ephemeral port.

    44         """

    45 

    46         cdef libc.sockaddr *sa_ptr

    47         cdef libc.socklen_t sa_len

    48 

    49         # get the address

    50         addr._get_sockaddr(&sa_ptr, &sa_len)

    51 

    52         # bind()

    53         if libc.bind(self.fd, sa_ptr, sa_len) :

    54             raise_errno('bind')

    55 

    56     def listen (self, int backlog) :

    57         """

    58             Listen for connections, marking this socket as a passive socket, which can accept incoming connection

    59             requests using sock.accept().

    60 

    61             It is customary to call .bind() before .listen().

    62 

    63                 backlog     - maximum number of pending connections (those not yet .accept()'d).

    64         """

    65         

    66         # listen()

    67         if libc.listen(self.fd, backlog) :

    68             raise_errno('listen')

    69 

    70     def connect (self, sockaddr addr) :

    71         """

    72             Initiate a connection, connecting this socket to the remote endpoint specified by `addr`. The given sockaddr

    73             should be of the same or a compatible address family.

    74 

    75             If the socket is in non-blocking mode, this will presumeably return errno.EINPROGRESS.

    76 

    77             If the socket has not yet been bound (using .bind()), the system will pick an appropriate local address and

    78             ephemeral port.

    79 

    80                 addr        - the remote address to connect to.

    81         """

    82 

    83         cdef libc.sockaddr *sa_ptr

    84         cdef libc.socklen_t sa_len

    85 

    86         # get the address

    87         addr._get_sockaddr(&sa_ptr, &sa_len)

    88         

    89         # connect()

    90         if libc.connect(self.fd, sa_ptr, sa_len) :

    91             raise_errno('connect')

    92 

    93     def accept (self) :

    94         """

    95             Accept a connection, dequeueing the first pending connection and returning a new sock object for it. This

    96             socket must be a connection-based socket (SOCK_STREAM/SOCK_SEQPACKET) and in the passive listening mode

    97             (.listen()).

    98 

    99             This returns a (sock, sockaddr) tuple:

   100                 sock        - the newly created sock, corresponding to the incoming connection

   101                 sockaddr    - the remote address of the incoming connection

   102         """

   103         

   104         # prep the sockaddr that we will return

   105         cdef libc.sockaddr_storage ss

   106         cdef libc.socklen_t ss_len = sizeof(ss)

   107 

   108         cdef socket_t sock_fd

   109 

   110         # accept()

   111         sock_fd = libc.accept(self.fd, <libc.sockaddr *> &ss, &ss_len)

   112 

   113         if sock_fd < 0 :

   114             raise_errno('accept')

   115 

   116         # prep the new socket

   117         sock_obj = sock(sock_fd)

   118 

   119         # prep the new addr

   120         sock_addr = build_sockaddr(<libc.sockaddr *> &ss, ss_len)

   121 

   122         return sock_obj, sock_addr

   123 

   124     def send (self, object buf, int flags = 0) :

   125         """

   126             Transmit a message to the connected remote endpoint.

   127 

   128                 buf     - the data to send

   129                 flags   - MSG_* flags to send with

   130 

   131             Returns the number of bytes sent, which may be less than the length of buf.

   132         """

   133 

   134         cdef char *buf_ptr

   135         cdef libc.ssize_t buf_len, ret

   136 

   137         # get buffer

   138         # XXX: test that except works right

   139         py.PyObject_AsCharBuffer(buf, &buf_ptr, &buf_len)

   140         

   141         # send()

   142         ret = libc.send(self.fd, <void *> buf_ptr, buf_len, flags)

   143         

   144         if ret < 0 :

   145             raise_errno('send')

   146 

   147         else :

   148             return ret

   149