static PyObject* getladdrs(PyObject* dummy, PyObject* args)
{
PyObject* ret = 0;
int fd;
int assoc_id;
struct sockaddr* saddrs;
int count;
int x;
char addr[256];
if (! PyArg_ParseTuple(args, "ii", &fd, &assoc_id)) {
return ret;
}
count = sctp_getladdrs(fd, assoc_id, &saddrs);
if (count < 0) {
PyErr_SetFromErrno(PyExc_IOError);
} else {
if (count == 0) {
saddrs = 0;
}
ret = PyTuple_New(count);
char *p = (char*) saddrs;
for(x = 0; x < count; ++x) {
int len;
int family;
int port;
PyObject* oaddr;
if (from_sockaddr((struct sockaddr*) p, &family, &len, &port,
addr, sizeof(addr))) {
oaddr = PyTuple_New(2);
PyTuple_SetItem(oaddr, 0, PyString_FromString(addr));
PyTuple_SetItem(oaddr, 1, PyInt_FromLong(port));
PyTuple_SetItem(ret, x, oaddr);
} else {
// something's wrong; not safe to continue
break;
}
p += len;
}
sctp_freeladdrs(saddrs);
// If something went wrong, the remaining expected addresses will be set to None.
for(; x < count; ++x) {
PyTuple_SetItem(ret, x, Py_None);
Py_INCREF(Py_None);
}
}
return ret;
}
static PyObject* _sockaddr_test(PyObject* dummy, PyObject* args)
{
PyObject* ret = 0;
PyObject* addrtupleret = 0;
char *caddr;
int port;
struct sockaddr_storage saddr;
int slen;
int family;
char caddr2[256];
if (! PyArg_ParseTuple(args, "(si)", &caddr, &port)) {
return ret;
}
printf("DEBUG: addr=%s, port=%d\n", caddr, port);
if (! to_sockaddr(caddr, port, (struct sockaddr*) &saddr, &slen)) {
PyErr_SetString(PyExc_ValueError, "address could not be translated");
return ret;
}
port = 0;
caddr = 0;
if (! from_sockaddr((struct sockaddr*) &saddr, &family, &slen, &port, caddr2, sizeof(caddr2))) {
PyErr_SetString(PyExc_ValueError, "address could not be de-translated");
return ret;
}
ret = PyTuple_New(4);
addrtupleret = PyTuple_New(2);
PyTuple_SetItem(ret, 0, PyString_FromFormat("family %d, size %d, address %s.%d", family, slen, caddr2, port));
PyTuple_SetItem(ret, 1, PyInt_FromLong(family));
PyTuple_SetItem(ret, 2, PyInt_FromLong(slen));
PyTuple_SetItem(ret, 3, addrtupleret);
PyTuple_SetItem(addrtupleret, 0, PyString_FromString(caddr2));
PyTuple_SetItem(addrtupleret, 1, PyInt_FromLong(port));
return ret;
}
/**
* @brief Create a graph from a sockaddr_x
*
* Create a new graph from a sockaddr_x. This constructor is useful for creating
* a DAG from from a sockaddr_x obtained from the XSocket API (from the
* XrecvFrom() call, for example).
*
* @param s The sockaddr_x
*/
Graph::Graph(sockaddr_x *s)
{
from_sockaddr(s);
}
static PyObject* get_status(PyObject* dummy, PyObject* args)
{
PyObject* ret = 0;
PyObject* dict;
PyObject* dict2;
PyObject* oassoc_id;
PyObject* oaddr;
char caddr[256];
int family, len, port;
int fd;
struct sctp_status v;
socklen_t lv = sizeof(v);
int ok;
ok = PyArg_ParseTuple(args, "iOO", &fd, &dict, &dict2) && \
PyDict_Check(dict) && PyDict_Check(dict2);
ok = ok && (oassoc_id = PyDict_GetItemString(dict, "assoc_id"));
ok = ok && PyInt_Check(oassoc_id);
if (! ok) {
return ret;
}
bzero(&v, sizeof(v));
v.sstat_assoc_id = PyInt_AsLong(oassoc_id);
if (getsockopt(fd, SOL_SCTP, SCTP_STATUS, &v, &lv)) {
PyErr_SetFromErrno(PyExc_IOError);
} else {
PyDict_SetItemString(dict, "state", PyInt_FromLong(v.sstat_state));
PyDict_SetItemString(dict, "rwnd", PyInt_FromLong(v.sstat_rwnd));
PyDict_SetItemString(dict, "unackdata", PyInt_FromLong(v.sstat_unackdata));
PyDict_SetItemString(dict, "penddata", PyInt_FromLong(v.sstat_penddata));
PyDict_SetItemString(dict, "instrms", PyInt_FromLong(v.sstat_instrms));
PyDict_SetItemString(dict, "outstrms", PyInt_FromLong(v.sstat_outstrms));
PyDict_SetItemString(dict, "fragmentation_point", PyInt_FromLong(v.sstat_fragmentation_point));
if (from_sockaddr((struct sockaddr*) &(v.sstat_primary.spinfo_address), &family,
&len, &port, caddr, sizeof(caddr))) {
oaddr = PyTuple_New(2);
PyTuple_SetItem(oaddr, 0, PyString_FromString(caddr));
PyTuple_SetItem(oaddr, 1, PyInt_FromLong(port));
} else {
// something went wrong
oaddr = Py_None;
Py_INCREF(Py_None);
}
PyDict_SetItemString(dict2, "sockaddr", oaddr);
PyDict_SetItemString(dict2, "assoc_id", PyInt_FromLong(v.sstat_primary.spinfo_assoc_id));
PyDict_SetItemString(dict2, "state", PyInt_FromLong(v.sstat_primary.spinfo_state));
PyDict_SetItemString(dict2, "cwnd", PyInt_FromLong(v.sstat_primary.spinfo_cwnd));
PyDict_SetItemString(dict2, "srtt", PyInt_FromLong(v.sstat_primary.spinfo_srtt));
PyDict_SetItemString(dict2, "rto", PyInt_FromLong(v.sstat_primary.spinfo_rto));
PyDict_SetItemString(dict2, "mtu", PyInt_FromLong(v.sstat_primary.spinfo_mtu));
ret = Py_None; Py_INCREF(ret);
}
return ret;
}
static PyObject* sctp_recv_msg(PyObject* dummy, PyObject* args)
{
int fd, max_len;
struct sockaddr_storage sfrom;
socklen_t sfrom_len = sizeof(sfrom);
int family;
int len;
int port;
char cfrom[256];
char *msg;
int size;
int flags;
struct sctp_sndrcvinfo sinfo;
PyObject* notification = PyDict_New();
PyObject* ret = 0;
PyObject* oaddr = 0;
if (! PyArg_ParseTuple(args, "ii", &fd, &max_len)) {
return ret;
}
msg = malloc(max_len);
if (! msg) {
PyErr_SetString(PyExc_MemoryError, "Out of memory, malloc() failed");
return ret;
}
bzero(&sfrom, sizeof(sfrom));
bzero(&sinfo, sizeof(sinfo));
size = sctp_recvmsg(fd, msg, max_len, (struct sockaddr*) &sfrom, &sfrom_len, &sinfo, &flags);
if (size < 0) {
free(msg);
PyErr_SetFromErrno(PyExc_IOError);
return ret;
}
if (flags & MSG_NOTIFICATION) {
interpret_notification(notification, msg, size);
size = -1;
} else {
interpret_sndrcvinfo(notification, &sinfo);
}
if (from_sockaddr((struct sockaddr*) &sfrom, &family, &len, &port, cfrom, sizeof(cfrom))) {
oaddr = PyTuple_New(2);
PyTuple_SetItem(oaddr, 0, PyString_FromString(cfrom));
PyTuple_SetItem(oaddr, 1, PyInt_FromLong(port));
} else {
// something went wrong
oaddr = Py_None;
Py_INCREF(Py_None);
}
ret = PyTuple_New(4);
PyTuple_SetItem(ret, 0, oaddr);
PyTuple_SetItem(ret, 1, PyInt_FromLong(flags));
if (size >= 0) {
PyTuple_SetItem(ret, 2, PyString_FromStringAndSize(msg, size));
} else {
PyTuple_SetItem(ret, 2, Py_None);
Py_INCREF(Py_None);
}
PyTuple_SetItem(ret, 3, notification);
free(msg);
return ret;
}
void interpret_notification(PyObject* dict, const void *pnotif, int size)
{
const union sctp_notification *notif = pnotif;
PyDict_SetItemString(dict, "type", PyInt_FromLong(notif->sn_header.sn_type));
PyDict_SetItemString(dict, "flags", PyInt_FromLong(notif->sn_header.sn_flags));
PyDict_SetItemString(dict, "length", PyInt_FromLong(notif->sn_header.sn_length));
switch (notif->sn_header.sn_type) {
case SCTP_ASSOC_CHANGE:
{
const struct sctp_assoc_change* n = &(notif->sn_assoc_change);
PyDict_SetItemString(dict, "state", PyInt_FromLong(n->sac_state));
PyDict_SetItemString(dict, "error", PyInt_FromLong(n->sac_error));
PyDict_SetItemString(dict, "outbound_streams", PyInt_FromLong(n->sac_outbound_streams));
PyDict_SetItemString(dict, "inbound_streams", PyInt_FromLong(n->sac_inbound_streams));
PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->sac_assoc_id));
}
break;
case SCTP_PEER_ADDR_CHANGE:
{
const struct sctp_paddr_change* n = &(notif->sn_paddr_change);
char caddr[256];
int family;
int len;
int port;
PyObject* oaddr;
if (from_sockaddr((struct sockaddr*) &(n->spc_aaddr), &family, &len, &port,
caddr, sizeof(caddr))) {
oaddr = PyTuple_New(2);
PyTuple_SetItem(oaddr, 0, PyString_FromString(caddr));
PyTuple_SetItem(oaddr, 1, PyInt_FromLong(port));
} else {
// something went wrong
oaddr = Py_None;
Py_INCREF(Py_None);
}
PyDict_SetItemString(dict, "addr", oaddr);
PyDict_SetItemString(dict, "state", PyInt_FromLong(n->spc_state));
PyDict_SetItemString(dict, "error", PyInt_FromLong(n->spc_error));
PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->spc_assoc_id));
}
break;
case SCTP_SEND_FAILED:
{
const struct sctp_send_failed* n = &(notif->sn_send_failed);
const char* cdata = ((char*) notif) + sizeof(struct sctp_send_failed);
int ldata = size - sizeof(struct sctp_send_failed);
if (ldata >= 0) {
PyObject* info = PyDict_New();
interpret_sndrcvinfo(info, &(n->ssf_info));
PyDict_SetItemString(dict, "_info", info);
PyDict_SetItemString(dict, "error", PyInt_FromLong(n->ssf_error));
PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->ssf_assoc_id));
PyDict_SetItemString(dict, "data", PyString_FromStringAndSize(cdata, ldata));
}
}
break;
case SCTP_REMOTE_ERROR:
{
const struct sctp_remote_error* n = &(notif->sn_remote_error);
const char* cdata = ((char*) notif) + sizeof(struct sctp_remote_error);
int ldata = size - sizeof(struct sctp_remote_error);
if (ldata >= 0) {
PyDict_SetItemString(dict, "error", PyInt_FromLong(n->sre_error));
PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->sre_assoc_id));
PyDict_SetItemString(dict, "data", PyString_FromStringAndSize(cdata, ldata));
}
}
break;
case SCTP_SHUTDOWN_EVENT:
{
const struct sctp_shutdown_event* n = &(notif->sn_shutdown_event);
PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->sse_assoc_id));
}
break;
case SCTP_PARTIAL_DELIVERY_EVENT:
{
const struct sctp_pdapi_event* n = &(notif->sn_pdapi_event);
PyDict_SetItemString(dict, "indication", PyInt_FromLong(n->pdapi_indication));
PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->pdapi_assoc_id));
}
break;
case SCTP_ADAPTATION_INDICATION:
{
const struct sctp_adaptation_event* n = &(notif->sn_adaptation_event);
PyDict_SetItemString(dict, "adaptation_ind", PyInt_FromLong(n->sai_adaptation_ind));
PyDict_SetItemString(dict, "assoc_id", PyInt_FromLong(n->sai_assoc_id));
}
break;
}
}
