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; } }