/*

This module provides an interface to bluetooth. A great deal of the code is

taken from the pyaffix project.

- there are three kinds of bluetooth addresses used here

HCI address is a single int specifying the device id

L2CAP address is a pair (host, port)

RFCOMM address is a pair (host, channel)

SCO address is just a host

the host part of the address is always a string of the form "XX:XX:XX:XX:XX"

Local naming conventions:

- names starting with sock_ are socket object methods

- names starting with bt_ are module-level functions

*/

#include "btmodule.h"

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <fcntl.h>

#include <errno.h>

#include <netdb.h>

#include <bluetooth/bluetooth.h>

#include <bluetooth/hci.h>

#include <bluetooth/hci_lib.h>

#include <bluetooth/rfcomm.h>

#include <bluetooth/l2cap.h>

#include <bluetooth/sco.h>

#include <bluetooth/sdp.h>

#include <bluetooth/sdp_lib.h>

#include "btsdp.h"

/* Socket object documentation */

PyDoc_STRVAR(sock_doc,

"BluetoothSocket(proto=RFCOMM) -> bluetooth socket object\n\

\n\

Open a socket of the given protocol. proto must be one of\n\

HCI, L2CAP, RFCOMM, or SCO. SCO sockets have\n\

not been tested at all yet.\n\

\n\

A BluetoothSocket object represents one endpoint of a bluetooth connection.\n\

\n\

Methods of BluetoothSocket objects (keyword arguments not allowed):\n\

\n\

accept() -- accept a connection, returning new socket and client address\n\

bind(addr) -- bind the socket to a local address\n\

close() -- close the socket\n\

connect(addr) -- connect the socket to a remote address\n\

connect_ex(addr) -- connect, return an error code instead of an exception\n\

dup() -- return a new socket object identical to the current one\n\

fileno() -- return underlying file descriptor\n\

getpeername() -- return remote address\n\

getsockname() -- return local address\n\

getsockopt(level, optname[, buflen]) -- get socket options\n\

gettimeout() -- return timeout or None\n\

listen(n) -- start listening for incoming connections\n\

makefile([mode, [bufsize]]) -- return a file object for the socket\n\

recv(buflen[, flags]) -- receive data\n\

recvfrom(buflen[, flags]) -- receive data and sender's address\n\

sendall(data[, flags]) -- send all data\n\

send(data[, flags]) -- send data, may not send all of it\n\

sendto(data[, flags], addr) -- send data to a given address\n\

setblocking(0 | 1) -- set or clear the blocking I/O flag\n\

setsockopt(level, optname, value) -- set socket options\n\

settimeout(None | float) -- set or clear the timeout\n\

shutdown(how) -- shut down traffic in one or both directions");

/* Global variable holding the exception type for errors detected

by this module (but not argument type or memory errors, etc.). */

PyObject *bluetooth_error;

static PyObject *socket_timeout;

/* A forward reference to the socket type object.

The sock_type variable contains pointers to various functions,

some of which call new_sockobject(), which uses sock_type, so

there has to be a circular reference. */

PyTypeObject sock_type;

/* Convenience function to raise an error according to errno

and return a NULL pointer from a function. */

PyObject *

set_error(void)

{

return PyErr_SetFromErrno(bluetooth_error);

}

/* Function to perform the setting of socket blocking mode

internally. block = (1 | 0). */

static int

internal_setblocking(PySocketSockObject *s, int block)

{

int delay_flag;

Py_BEGIN_ALLOW_THREADS

delay_flag = fcntl(s->sock_fd, F_GETFL, 0);

if (block)

delay_flag &= (~O_NONBLOCK);

else

delay_flag |= O_NONBLOCK;

fcntl(s->sock_fd, F_SETFL, delay_flag);

Py_END_ALLOW_THREADS

/* Since these don't return anything */

return 1;

}

/* Do a select() on the socket, if necessary (sock_timeout > 0).

The argument writing indicates the direction.

This does not raise an exception; we'll let our caller do that

after they've reacquired the interpreter lock.

Returns 1 on timeout, 0 otherwise. */

static int

internal_select(PySocketSockObject *s, int writing)

{

fd_set fds;

struct timeval tv;

int n;

/* Nothing to do unless we're in timeout mode (not non-blocking) */

if (s->sock_timeout <= 0.0)

return 0;

/* Guard against closed socket */

if (s->sock_fd < 0)

return 0;

/* Construct the arguments to select */

tv.tv_sec = (int)s->sock_timeout;

tv.tv_usec = (int)((s->sock_timeout - tv.tv_sec) * 1e6);

FD_ZERO(&fds);

FD_SET(s->sock_fd, &fds);

/* See if the socket is ready */

if (writing)

n = select(s->sock_fd+1, NULL, &fds, NULL, &tv);

else

n = select(s->sock_fd+1, &fds, NULL, NULL, &tv);

if (n == 0)

return 1;

return 0;

}

/* Initialize a new socket object. */

static double defaulttimeout = -1.0; /* Default timeout for new sockets */

PyMODINIT_FUNC

init_sockobject(PySocketSockObject *s,

int fd, int family, int type, int proto)

{

s->sock_fd = fd;

s->sock_family = family;

s->sock_type = type;

s->sock_proto = proto;

s->sock_timeout = defaulttimeout;

s->errorhandler = &set_error;

if (defaulttimeout >= 0.0)

internal_setblocking(s, 0);

}

/* Create a new socket object.

This just creates the object and initializes it.

If the creation fails, return NULL and set an exception (implicit

in NEWOBJ()). */

static PySocketSockObject *

new_sockobject(int fd, int family, int type, int proto)

{

PySocketSockObject *s;

s = (PySocketSockObject *)

PyType_GenericNew(&sock_type, NULL, NULL);

if (s != NULL)

init_sockobject(s, fd, family, type, proto);

return s;

}

/* Create an object representing the given socket address,

suitable for passing it back to bind(), connect() etc.

The family field of the sockaddr structure is inspected

to determine what kind of address it really is. */

/*ARGSUSED*/

static PyObject *

makesockaddr(PySocketSockObject *s, struct sockaddr *addr, int addrlen)

{

if (addrlen == 0) {

/* No address -- may be recvfrom() from known socket */

Py_INCREF(Py_None);

return Py_None;

} else {

char ba_name[18];

switch(s->sock_proto) {

case BTPROTO_HCI:

{

return Py_BuildValue("H",

((struct sockaddr_hci*)(addr))->hci_dev );

}

case BTPROTO_L2CAP:

{

struct sockaddr_l2 *a = (struct sockaddr_l2*)addr;

ba2str( &a->l2_bdaddr, ba_name );

return Py_BuildValue("sH", ba_name, btohs(a->l2_psm) );

}

case BTPROTO_RFCOMM:

{

struct sockaddr_rc *a = (struct sockaddr_rc*)addr;

ba2str( &a->rc_bdaddr, ba_name );

return Py_BuildValue("sB", ba_name, a->rc_channel );

}

case BTPROTO_SCO:

{

struct sockaddr_sco *a = (struct sockaddr_sco*)addr;

ba2str( &a->sco_bdaddr, ba_name );

return Py_BuildValue("s", ba_name);

}

default:

PyErr_SetString(bluetooth_error,

"getsockaddrarg: unknown Bluetooth protocol");

return 0;

}

}

}

/* Parse a socket address argument according to the socket object's

address family. Return 1 if the address was in the proper format,

0 of not. The address is returned through addr_ret, its length

through len_ret. */

static int

getsockaddrarg(PySocketSockObject *s, PyObject *args,

struct sockaddr *addr_ret, int *len_ret)

{

memset(addr_ret, 0, sizeof(struct sockaddr));

addr_ret->sa_family = AF_BLUETOOTH;

switch( s->sock_proto )

{

case BTPROTO_HCI:

{

struct sockaddr_hci *addr = (struct sockaddr_hci*) addr_ret;

if ( !PyArg_ParseTuple(args, "H", &addr->hci_dev) ) {

return 0;

}

*len_ret = sizeof(struct sockaddr_hci);

return 1;

}

case BTPROTO_L2CAP:

{

struct sockaddr_l2* addr = (struct sockaddr_l2*) addr_ret;

char *ba_name = 0;

if ( !PyArg_ParseTuple(args, "sH", &ba_name, &addr->l2_psm) )

{

return 0;

}

str2ba( ba_name, &addr->l2_bdaddr );

// check for a valid PSM

if( ! ( 0x1 & addr->l2_psm ) ) {

PyErr_SetString( PyExc_ValueError, "Invalid PSM");

return 0;

}

addr->l2_psm = htobs(addr->l2_psm);

*len_ret = sizeof *addr;

return 1;

}

case BTPROTO_RFCOMM:

{

struct sockaddr_rc *addr = (struct sockaddr_rc*) addr_ret;

char *ba_name = 0;

if( !PyArg_ParseTuple(args, "sB", &ba_name, &addr->rc_channel) )

{

return 0;

}

str2ba( ba_name, &addr->rc_bdaddr );

*len_ret = sizeof *addr;

return 1;

}

case BTPROTO_SCO:

{

struct sockaddr_sco *addr = (struct sockaddr_sco*) addr_ret;

char *ba_name = 0;

if( !PyArg_ParseTuple(args, "s", &ba_name) )

{

return 0;

}

str2ba( ba_name, &addr->sco_bdaddr);

*len_ret = sizeof *addr;

return 1;

}

default:

{

PyErr_SetString(bluetooth_error,

"getsockaddrarg: unknown Bluetooth protocol");

return 0;

}

}

}

/* Get the address length according to the socket object's address family.

Return 1 if the family is known, 0 otherwise. The length is returned

through len_ret. */

int

getsockaddrlen(PySocketSockObject *s, socklen_t *len_ret)

{

switch(s->sock_proto)

{

case BTPROTO_L2CAP:

*len_ret = sizeof (struct sockaddr_l2);

return 1;

case BTPROTO_RFCOMM:

*len_ret = sizeof (struct sockaddr_rc);

return 1;

case BTPROTO_SCO:

*len_ret = sizeof (struct sockaddr_sco);

return 1;

case BTPROTO_HCI:

*len_ret = sizeof (struct sockaddr_hci);

return 1;

default:

PyErr_SetString(bluetooth_error,

"getsockaddrlen: unknown bluetooth protocol");

return 0;

}

}

int str2uuid( const char *uuid_str, uuid_t *uuid )

{

uint32_t uuid_int[4];

char *endptr;

if( strlen( uuid_str ) == 36 ) {

// Parse uuid128 standard format: 12345678-9012-3456-7890-123456789012

char buf[9] = { 0 };

if( uuid_str[8] != '-' && uuid_str[13] != '-' &&

uuid_str[18] != '-' && uuid_str[23] != '-' ) {

return 0;

}

// first 8-bytes

strncpy(buf, uuid_str, 8);

uuid_int[0] = htonl( strtoul( buf, &endptr, 16 ) );

if( endptr != buf + 8 ) return 0;

// second 8-bytes

strncpy(buf, uuid_str+9, 4);

strncpy(buf+4, uuid_str+14, 4);

uuid_int[1] = htonl( strtoul( buf, &endptr, 16 ) );

if( endptr != buf + 8 ) return 0;

// third 8-bytes

strncpy(buf, uuid_str+19, 4);

strncpy(buf+4, uuid_str+24, 4);

uuid_int[2] = htonl( strtoul( buf, &endptr, 16 ) );

if( endptr != buf + 8 ) return 0;

// fourth 8-bytes

strncpy(buf, uuid_str+28, 8);

uuid_int[3] = htonl( strtoul( buf, &endptr, 16 ) );

if( endptr != buf + 8 ) return 0;

if( uuid != NULL ) sdp_uuid128_create( uuid, uuid_int );

} else if ( strlen( uuid_str ) == 8 ) {

// 32-bit reserved UUID

uint32_t i = strtoul( uuid_str, &endptr, 16 );

if( endptr != uuid_str + 8 ) return 0;

if( uuid != NULL ) sdp_uuid32_create( uuid, i );

} else if( strlen( uuid_str ) == 4 ) {

// 16-bit reserved UUID

int i = strtol( uuid_str, &endptr, 16 );

if( endptr != uuid_str + 4 ) return 0;

if( uuid != NULL ) sdp_uuid16_create( uuid, i );

} else {

return 0;

}

return 1;

}

void uuid2str( const uuid_t *uuid, char *dest )

{

if( uuid->type == SDP_UUID16 ) {

sprintf(dest, "%04X", uuid->value.uuid16 );

} else if( uuid->type == SDP_UUID32 ) {

sprintf(dest, "%08X", uuid->value.uuid32 );

} else if( uuid->type == SDP_UUID128 ) {

uint32_t *data = (uint32_t*)(&uuid->value.uuid128);

sprintf(dest, "%08X-%04X-%04X-%04X-%04X%08X",

ntohl(data[0]),

ntohl(data[1])>>16,

(ntohl(data[1])<<16)>>16,

ntohl(data[2])>>16,

(ntohl(data[2])<<16)>>16,

ntohl(data[3]));

}

}

// =================== socket methods ==================== //

/* s.accept() method */

static PyObject *

sock_accept(PySocketSockObject *s)

{

char addrbuf[256];

int newfd;

socklen_t addrlen;

PyObject *sock = NULL;

PyObject *addr = NULL;

PyObject *res = NULL;

int timeout;

if (!getsockaddrlen(s, &addrlen))

return NULL;

memset(addrbuf, 0, addrlen);

newfd = -1;

Py_BEGIN_ALLOW_THREADS

timeout = internal_select(s, 0);

if (!timeout)

newfd = accept(s->sock_fd, (struct sockaddr *) addrbuf,

&addrlen);

Py_END_ALLOW_THREADS

if (timeout) {

PyErr_SetString(socket_timeout, "timed out");

return NULL;

}

if (newfd < 0)

return s->errorhandler();

/* Create the new object with unspecified family,

to avoid calls to bind() etc. on it. */

sock = (PyObject *) new_sockobject(newfd,

s->sock_family,

s->sock_type,

s->sock_proto);

if (sock == NULL) {

close(newfd);

goto finally;

}

addr = makesockaddr(s, (struct sockaddr *)addrbuf, addrlen);

if (addr == NULL)

goto finally;

res = Py_BuildValue("OO", sock, addr);

finally:

Py_XDECREF(sock);

Py_XDECREF(addr);

return res;

}

PyDoc_STRVAR(accept_doc,

"accept() -> (socket object, address info)\n\

\n\

Wait for an incoming connection. Return a new socket representing the\n\

connection, and the address of the client. For L2CAP sockets, the address\n\

is a (host, psm) tuple. For RFCOMM sockets, the address is a (host, channel)\n\

tuple. For SCO sockets, the address is just a host.");

/* s.setblocking(flag) method. Argument:

False -- non-blocking mode; same as settimeout(0)

True -- blocking mode; same as settimeout(None)

*/

static PyObject *

sock_setblocking(PySocketSockObject *s, PyObject *arg)

{

int block;

block = PyInt_AsLong(arg);

if (block == -1 && PyErr_Occurred())

return NULL;

s->sock_timeout = block ? -1.0 : 0.0;

internal_setblocking(s, block);

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(setblocking_doc,

"setblocking(flag)\n\

\n\

Set the socket to blocking (flag is true) or non-blocking (false).\n\

setblocking(True) is equivalent to settimeout(None);\n\

setblocking(False) is equivalent to settimeout(0.0).");

/* s.settimeout(timeout) method. Argument:

None -- no timeout, blocking mode; same as setblocking(True)

0.0 -- non-blocking mode; same as setblocking(False)

> 0 -- timeout mode; operations time out after timeout seconds

< 0 -- illegal; raises an exception

*/

static PyObject *

sock_settimeout(PySocketSockObject *s, PyObject *arg)

{

double timeout;

if (arg == Py_None)

timeout = -1.0;

else {

timeout = PyFloat_AsDouble(arg);

if (timeout < 0.0) {

if (!PyErr_Occurred())

PyErr_SetString(PyExc_ValueError,

"Timeout value out of range");

return NULL;

}

}

s->sock_timeout = timeout;

internal_setblocking(s, timeout < 0.0);

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(settimeout_doc,

"settimeout(timeout)\n\

\n\

Set a timeout on socket operations. 'timeout' can be a float,\n\

giving in seconds, or None. Setting a timeout of None disables\n\

the timeout feature and is equivalent to setblocking(1).\n\

Setting a timeout of zero is the same as setblocking(0).");

/* s.gettimeout() method.

Returns the timeout associated with a socket. */

static PyObject *

sock_gettimeout(PySocketSockObject *s)

{

if (s->sock_timeout < 0.0) {

Py_INCREF(Py_None);

return Py_None;

}

else

return PyFloat_FromDouble(s->sock_timeout);

}

PyDoc_STRVAR(gettimeout_doc,

"gettimeout() -> timeout\n\

\n\

Returns the timeout in floating seconds associated with socket \n\

operations. A timeout of None indicates that timeouts on socket \n\

operations are disabled.");

/* s.setsockopt() method.

With an integer third argument, sets an integer option.

With a string third argument, sets an option from a buffer;

use optional built-in module 'struct' to encode the string. */

static PyObject *

sock_setsockopt(PySocketSockObject *s, PyObject *args)

{

int level;

int optname;

int res;

char *buf;

int buflen;

int flag;

if (PyArg_ParseTuple(args, "iii:setsockopt",

&level, &optname, &flag)) {

buf = (char *) &flag;

buflen = sizeof flag;

}

else {

PyErr_Clear();

if (!PyArg_ParseTuple(args, "iis#:setsockopt",

&level, &optname, &buf, &buflen))

return NULL;

}

res = setsockopt(s->sock_fd, level, optname, (void *)buf, buflen);

if (res < 0)

return s->errorhandler();

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(setsockopt_doc,

"setsockopt(level, option, value)\n\

\n\

Set a socket option. See the Unix manual for level and option.\n\

The value argument can either be an integer or a string.");

/* s.getsockopt() method.

With two arguments, retrieves an integer option.

With a third integer argument, retrieves a string buffer of that size;

use optional built-in module 'struct' to decode the string. */

static PyObject *

sock_getsockopt(PySocketSockObject *s, PyObject *args)

{

int level;

int optname;

int res;

PyObject *buf;

socklen_t buflen = 0;

if (!PyArg_ParseTuple(args, "ii|i:getsockopt",

&level, &optname, &buflen))

return NULL;

if (buflen == 0) {

int flag = 0;

socklen_t flagsize = sizeof flag;

res = getsockopt(s->sock_fd, level, optname,

(void *)&flag, &flagsize);

if (res < 0)

return s->errorhandler();

return PyInt_FromLong(flag);

}

if (buflen <= 0 || buflen > 1024) {

PyErr_SetString(bluetooth_error,

"getsockopt buflen out of range");

return NULL;

}

buf = PyString_FromStringAndSize((char *)NULL, buflen);

if (buf == NULL)

return NULL;

res = getsockopt(s->sock_fd, level, optname,

(void *)PyString_AS_STRING(buf), &buflen);

if (res < 0) {

Py_DECREF(buf);

return s->errorhandler();

}

_PyString_Resize(&buf, buflen);

return buf;

}

PyDoc_STRVAR(getsockopt_doc,

"getsockopt(level, option[, buffersize]) -> value\n\

\n\

Get a socket option. See the Unix manual for level and option.\n\

If a nonzero buffersize argument is given, the return value is a\n\

string of that length; otherwise it is an integer.");

static PyObject *

sock_setl2capsecurity(PySocketSockObject *s, PyObject *args)

{

int level;

struct bt_security sec;

if (! PyArg_ParseTuple(args, "i:setsockopt",

&level))

return NULL;

memset(&sec, 0, sizeof(sec));

sec.level = level;

if (setsockopt(s->sock_fd, SOL_BLUETOOTH, BT_SECURITY, &sec,

sizeof(sec)) == 0) {

Py_INCREF(Py_None);

return Py_None;

}

if (errno != ENOPROTOOPT)

return s->errorhandler();

int lm_map[] = {

0,

L2CAP_LM_AUTH,

L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT,

L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT | L2CAP_LM_SECURE,

}, opt = lm_map[level];

if (setsockopt(s->sock_fd, SOL_L2CAP, L2CAP_LM, &opt, sizeof(opt)) < 0)

return s->errorhandler();

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(setl2capsecurity_doc,

"setl2capsecurity(BT_SECURITY_*) -> value\n\

\n\

Sets socket security. Levels are BT_SECURITY_SDP, LOW, MEDIUM\n\

and HIGH.");

/* s.bind(sockaddr) method */

static PyObject *

sock_bind(PySocketSockObject *s, PyObject *addro)

{

struct sockaddr addr = { 0 };

int addrlen;

int res;

if (!getsockaddrarg(s, addro, &addr, &addrlen))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = bind(s->sock_fd, &addr, addrlen);

Py_END_ALLOW_THREADS

if (res < 0)

return s->errorhandler();

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(bind_doc,

"bind(address)\n\

\n\

Bind the socket to a local address. address must always be a tuple.\n\

HCI sockets: ( device number, )\n\

device number should be 0, 1, 2, etc.\n\

L2CAP sockets: ( host, psm )\n\

host should be an address e.g. \"01:23:45:67:89:ab\"\n\

psm should be an unsigned integer\n\

RFCOMM sockets: ( host, channel )\n\

SCO sockets: ( host )\n\

");

/* s.close() method.

Set the file descriptor to -1 so operations tried subsequently

will surely fail. */

static PyObject *

sock_close(PySocketSockObject *s)

{

int fd;

if ((fd = s->sock_fd) != -1) {

s->sock_fd = -1;

Py_BEGIN_ALLOW_THREADS

(void) close(fd);

Py_END_ALLOW_THREADS

}

if( s->sdp_session ) {

sdp_close( s->sdp_session );

s->sdp_record_handle = 0;

s->sdp_session = NULL;

}

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(close_doc,

"close()\n\

\n\

Close the socket. It cannot be used after this call.");

static int

internal_connect(PySocketSockObject *s, struct sockaddr *addr, int addrlen,

int *timeoutp)

{

int res, timeout;

timeout = 0;

res = connect(s->sock_fd, addr, addrlen);

if (s->sock_timeout > 0.0) {

if (res < 0 && errno == EINPROGRESS) {

timeout = internal_select(s, 1);

res = connect(s->sock_fd, addr, addrlen);

if (res < 0 && errno == EISCONN)

res = 0;

}

}

if (res < 0)

res = errno;

*timeoutp = timeout;

return res;

}

/* s.connect(sockaddr) method */

static PyObject *

sock_connect(PySocketSockObject *s, PyObject *addro)

{

struct sockaddr addr = { 0 };

int addrlen;

int res;

int timeout;

if (!getsockaddrarg(s, addro, &addr, &addrlen))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = internal_connect(s, &addr, addrlen, &timeout);

Py_END_ALLOW_THREADS

if (timeout) {

PyErr_SetString(socket_timeout, "timed out");

return NULL;

}

if (res != 0)

return s->errorhandler();

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(connect_doc,

"connect(address)\n\

\n\

Connect the socket to a remote address. For L2CAP sockets, the address is a \n\

(host,psm) tuple. For RFCOMM sockets, the address is a (host,channel) tuple.\n\

For SCO sockets, the address is just the host.");

/* s.connect_ex(sockaddr) method */

static PyObject *

sock_connect_ex(PySocketSockObject *s, PyObject *addro)

{

struct sockaddr addr = { 0 };

int addrlen;

int res;

int timeout;

if (!getsockaddrarg(s, addro, &addr, &addrlen))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = internal_connect(s, &addr, addrlen, &timeout);

Py_END_ALLOW_THREADS

return PyInt_FromLong((long) res);

}

PyDoc_STRVAR(connect_ex_doc,

"connect_ex(address) -> errno\n\

\n\

This is like connect(address), but returns an error code (the errno value)\n\

instead of raising an exception when an error occurs.");

/* s.fileno() method */

static PyObject *

sock_fileno(PySocketSockObject *s)

{

return PyInt_FromLong((long) s->sock_fd);

}

PyDoc_STRVAR(fileno_doc,

"fileno() -> integer\n\

\n\

Return the integer file descriptor of the socket.");

#ifndef NO_DUP

/* s.dup() method */

static PyObject *

sock_dup(PySocketSockObject *s)

{

int newfd;

PyObject *sock;

newfd = dup(s->sock_fd);

if (newfd < 0)

return s->errorhandler();

sock = (PyObject *) new_sockobject(newfd,

s->sock_family,

s->sock_type,

s->sock_proto);

if (sock == NULL)

close(newfd);

return sock;

}

PyDoc_STRVAR(dup_doc,

"dup() -> socket object\n\

\n\

Return a new socket object connected to the same system resource.");

#endif

/* s.getsockname() method */

static PyObject *

sock_getsockname(PySocketSockObject *s)

{

char addrbuf[256];

int res;

socklen_t addrlen;

if (!getsockaddrlen(s, &addrlen))

return NULL;

memset(addrbuf, 0, addrlen);

Py_BEGIN_ALLOW_THREADS

res = getsockname(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);

Py_END_ALLOW_THREADS

if (res < 0)

return s->errorhandler();

return makesockaddr(s, (struct sockaddr *) addrbuf, addrlen);

}

PyDoc_STRVAR(getsockname_doc,

"getsockname() -> address info\n\

\n\

Return the address of the local endpoint.");

/* s.getpeername() method */

static PyObject *

sock_getpeername(PySocketSockObject *s)

{

char addrbuf[256];

int res;

socklen_t addrlen;

if (!getsockaddrlen(s, &addrlen))

return NULL;

memset(addrbuf, 0, addrlen);

Py_BEGIN_ALLOW_THREADS

res = getpeername(s->sock_fd, (struct sockaddr *) addrbuf, &addrlen);

Py_END_ALLOW_THREADS

if (res < 0)

return s->errorhandler();

return makesockaddr(s, (struct sockaddr *) addrbuf, addrlen);

}

PyDoc_STRVAR(getpeername_doc,

"getpeername() -> address info\n\

\n\

Return the address of the remote endpoint. For HCI sockets, the address is a\n\

device number (0, 1, 2, etc). For L2CAP sockets, the address is a \n\

(host,psm) tuple. For RFCOMM sockets, the address is a (host,channel) tuple.\n\

For SCO sockets, the address is just the host.");

/* s.listen(n) method */

static PyObject *

sock_listen(PySocketSockObject *s, PyObject *arg)

{

int backlog;

int res;

backlog = PyInt_AsLong(arg);

if (backlog == -1 && PyErr_Occurred())

return NULL;

Py_BEGIN_ALLOW_THREADS

if (backlog < 1)

backlog = 1;

res = listen(s->sock_fd, backlog);

Py_END_ALLOW_THREADS

if (res < 0)

return s->errorhandler();

Py_INCREF(Py_None);

s->is_listening_socket = 1;

return Py_None;

}

PyDoc_STRVAR(listen_doc,

"listen(backlog)\n\

\n\

Enable a server to accept connections. The backlog argument must be at\n\

least 1; it specifies the number of unaccepted connection that the system\n\

will allow before refusing new connections.");