1

from qmsk.net.socket.socket cimport *

     2

from qmsk.net.socket.addr cimport sockaddr, build_sockaddr

     3

     4

cimport qmsk.net.socket.platform as platform

     5

cimport qmsk.net.libc as libc, qmsk.net.py as py

     6

     7

from qmsk.net.py cimport raise_errno

     8

     9

cdef parse_sockaddr (platform.sockaddr **sa_ptr, platform.socklen_t *sa_len, sockaddr addr, int optional = 0) :

    10

    if addr is not None :

    11

        addr._get_sockaddr(sa_ptr, sa_len)

    12

    13

    elif optional :

    14

        sa_ptr[0] = NULL

    15

        sa_len[0] = 0

    16

    17

    else :

    18

        raise ValueError(addr)

    19

    20

cdef parse_buf (void **buf_ptr, size_t *buf_len, object buf, int optional = 0) :

    21

    cdef libc.ssize_t tmp_len

    22

    23

    if buf is not None :

    24

        # XXX: test that except works right

    25

        py.PyObject_AsCharBuffer(buf, <char **> buf_ptr, &tmp_len)

    26

    27

        # XXX: ensure that this is >= 0

    28

        buf_len[0] = tmp_len

    29

    30

    elif optional :

    31

        buf_ptr[0] = NULL

    32

        buf_len[0] = 0

    33

    34

    else :

    35

        raise ValueError(buf)

    36

    37

# XXX: do some GIL-releasin'

    38

cdef class socket :

    39

    41

        """

    43

        """

    44

    46

    48

        """

    51

    52

                family      - one of AF_*

    53

                socktype    - one of SOCK_*

    54

                protocol    - one of IPPROTO_* or zero to select default

    55

        """

    56

    64

    65

        # trap

    66

        if self.fd < 0 :

    67

            raise_errno('socket')

    68

    69

    def bind (self, sockaddr addr) :

    70

        """

    71

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

    72

            compatible address family.

    73

    74

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

    75

                              ephemeral port.

    76

        """

    77

    78

        cdef platform.sockaddr *sa

    79

        cdef platform.socklen_t sa_len

    80

    81

        # XXX: require non-NULL addr?

    82

        parse_sockaddr(&sa, &sa_len, addr, 1)

    83

    84

        # bind()

    85

        if platform.bind(self.fd, sa, sa_len) :

    86

            raise_errno('bind')

    87

    88

    def listen (self, int backlog) :

    89

        """

    90

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

    91

            requests using sock.accept().

    92

    93

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

    94

    95

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

    96

        """

    97

    98

        # listen()

    99

        if platform.listen(self.fd, backlog) :

   100

            raise_errno('listen')

   101

   102

    def connect (self, sockaddr addr) :

   103

        """

   104

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

   105

            should be of the same or a compatible address family.

   106

   107

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

   108

   109

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

   110

            ephemeral port.

   111

   112

                addr        - the remote address to connect to.

   113

        """

   114

   115

        cdef platform.sockaddr *sa

   116

        cdef platform.socklen_t sa_len

   117

   118

        # XXX: require non-NULL addr?

   119

        parse_sockaddr(&sa, &sa_len, addr, 1)

   120

   121

        # connect()

   122

        if platform.connect(self.fd, sa, sa_len) :

   123

            raise_errno('connect')

   124

   125

    def accept (self) :

   126

        """

   127

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

   128

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

   129

            (.listen()).

   130

   131

            This returns a (sock, sockaddr) tuple:

   132

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

   133

                sockaddr    - the remote address of the incoming connection

   134

        """

   135

   136

        # prep the sockaddr that we will return

   137

        cdef platform.sockaddr_storage ss

   138

        cdef platform.socklen_t ss_len = sizeof(ss)

   139

   140

        cdef socket_t sock_fd

   141

   142

        # accept()

   143

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

   144

   145

        if sock_fd < 0 :

   146

            raise_errno('accept')

   151

   157

   158

        # prep the new addr

   159

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

   160

   161

        return sock_obj, sock_addr

   162

   163

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

   164

        """

   165

            Transmit a message to the connected remote endpoint.

   166

   167

                buf         - the data to send

   168

                flags       - (optional) MSG_* flags to send with

   169

   170

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

   171

        """

   172

   173

        cdef void *buf_ptr

   174

        cdef size_t buf_len

   175

        cdef libc.ssize_t ret

   176

   177

        parse_buf(&buf_ptr, &buf_len, buf, 0)

   178

   179

        # send()

   180

        ret = platform.send(self.fd, buf_ptr, buf_len, flags)

   181

   182

        if ret < 0 :

   183

            raise_errno('send')

   184

   185

        else :

   186

            return ret

   187

   188

    def sendto (self, object buf, int flags = 0, sockaddr addr = None) :

   189

        """

   190

            Transmit a message to the given remote endpoint. If this socket is connected, the addr must not be

   191

            specified, and this acts like send()

   192

   193

                buf         - the data to send

   194

                flags       - (optional) MSG_* flags to send with

   195

                addr        - (optional) target address

   196

   197

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

   198

        """

   199

   200

        cdef void *buf_ptr

   201

        cdef size_t buf_len

   202

        cdef libc.ssize_t ret

   203

   204

        cdef platform.sockaddr *sa

   205

        cdef platform.socklen_t sa_len

   206

   207

        parse_sockaddr(&sa, &sa_len, addr, 1)

   208

        parse_buf(&buf_ptr, &buf_len, buf, 0)

   209

   210

        # send()

   211

        ret = platform.sendto(self.fd, buf_ptr, buf_len, flags, sa, sa_len)

   212

   213

        if ret < 0 :

   214

            raise_errno('sendto')

   215

   216

        else :

   217

            return ret

   218

   219

    def sendmsg (self, sockaddr addr = None, iov = None, control = None, int flags = 0) :

   220

        """

   221

            Transmit an extended message to the given remote endpoint (or default for connected sockets) with the given

   222

            extra parameters.

   223

   224

                addr        - (optional) destination address (struct msghdr::msg_name)

   225

                iov         - (optional) sequence of read-buffers to transmit

   226

                control     - (optional) control message to transmit

   227

                flags       - (optional) MSG_* flags to send with

   228

   229

            Returns the number of bytes sent, which may be less than the total length of iov.

   230

        """

   231

   232

        cdef libc.ssize_t ret

   233

        cdef libc.iovec *iovec

   234

        cdef platform.msghdr msg

   235

   236

        libc.memset(&msg, 0, sizeof(msg))

   237

   238

        parse_sockaddr(<platform.sockaddr **> &msg.msg_name, &msg.msg_namelen, addr, 1)

   239

        parse_buf(&msg.msg_control, &msg.msg_controllen, control, 1)

   240

   241

        # iov

   242

        if iov :

   243

            iov = tuple(iov)

   244

   245

            # numerb of bufs = number of iovecs

   246

            msg.msg_iovlen = len(iov)

   247

   248

            # alloca the required number of iovec's

   249

            msg.msg_iov = <libc.iovec *> libc.alloca(msg.msg_iovlen * sizeof(libc.iovec))

   250

   251

            # fill in the iovecs

   252

            for i, buf in enumerate(iov) :

   253

                iovec = &msg.msg_iov[i]

   254

   255

                parse_buf(&iovec.iov_base, &iovec.iov_len, buf, 1)

   256

   257

        # sendmsg()

   258

        ret = platform.sendmsg(self.fd, &msg, flags)

   259

   260

        if ret < 0 :

   261

            raise_errno('sendmsg')

   262

   263

        else :

   264

            return ret

   265

   266

    def write (self, object buf) :

   267

        """

   268

            Write data to socket, mostly equivalent to send() with flags=0.

   269

   270

                buf         - the data to send

   271

   272

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

   273

        """

   274

   275

        cdef void *buf_ptr

   276

        cdef size_t buf_len

   277

        cdef libc.ssize_t ret

   278

   279

        parse_buf(&buf_ptr, &buf_len, buf, 0)

   280

   281

        # send()

   282

        ret = libc.write(self.fd, buf_ptr, buf_len)

   283

   284

        if ret < 0 :

   285

            raise_errno('write')

   286

   287

        else :

   288

            return ret

   289

   290

    def writev (self, iov) :

   291

        """

   292

            Write data to a socket from multiple read-buffers.

   293

   294

                iov         - sequence of read-buffers to transmit

   295

   296

            Returns the number of bytes sent, which may be less than the total length of iov.

   297

        """

   298

   299

        # iov

   300

        cdef libc.iovec *iov_list = NULL

   301

        cdef size_t iov_count = 0

   302

        cdef libc.iovec *iovec

   303

   304

        iov = tuple(iov)

   305

   306

        # numerb of bufs = number of iovecs

   307

        iov_count = len(iov)

   308

   309

        # alloca the required number of iovec's

   310

        iov_list = <libc.iovec *> libc.alloca(iov_count * sizeof(libc.iovec))

   311

   312

        # fill in the iovecs

   313

        for i, buf in enumerate(iov) :

   314

            iovec = &iov_list[i]

   315

   316

            parse_buf(&iovec.iov_base, &iovec.iov_len, buf, 1)

   317

   318

        # sendmsg()

   319

        ret = libc.writev(self.fd, iov_list, iov_count)

   320

   321

        if ret < 0 :

   322

            raise_errno('writev')

   323

   324

        else :

   325

            return ret