static PyObject *
Channel_func_timeout(Channel *self, PyObject *args)
{
double timeout = -1;
struct timeval tv, maxtv, *tvp, *maxtvp;
CHECK_CHANNEL(self);
if (!PyArg_ParseTuple(args, "|d:timeout", &timeout)) {
return NULL;
}
if (timeout != -1 && timeout < 0.0) {
PyErr_SetString(PyExc_ValueError, "timeout needs to be a positive number");
return NULL;
}
if (timeout != -1) {
timeval_from_double(timeout, &maxtv);
maxtvp = &maxtv;
} else {
maxtvp = NULL;
}
tvp = ares_timeout(self->channel, maxtvp, &tv);
return PyFloat_FromDouble(double_from_timeval(tvp));
}
static PyObject *
Channel_func_gethostbyname(Channel *self, PyObject *args)
{
char *name;
int family;
PyObject *callback, *ret;
CHECK_CHANNEL(self);
if (!PyArg_ParseTuple(args, "etiO:gethostbyname", "idna", &name, &family, &callback)) {
return NULL;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
ret = NULL;
goto finally;
}
Py_INCREF(callback);
ares_gethostbyname(self->channel, name, family, &host_cb, (void *)callback);
ret = Py_None;
finally:
PyMem_Free(name);
Py_XINCREF(ret);
return ret;
}
static PyObject *
Channel_func_cancel(Channel *self)
{
CHECK_CHANNEL(self);
ares_cancel(self->channel);
Py_RETURN_NONE;
}
static PyObject *
Channel_func_destroy(Channel *self)
{
CHECK_CHANNEL(self);
ares_destroy(self->channel);
self->channel = NULL;
Py_RETURN_NONE;
}
static PyObject *
Channel_func_process_fd(Channel *self, PyObject *args)
{
long read_fd, write_fd;
CHECK_CHANNEL(self);
if (!PyArg_ParseTuple(args, "ll:process_fd", &read_fd, &write_fd)) {
return NULL;
}
ares_process_fd(self->channel, (ares_socket_t)read_fd, (ares_socket_t)write_fd);
Py_RETURN_NONE;
}
static PyObject *
Channel_func_set_local_dev(Channel *self, PyObject *args)
{
char *dev;
CHECK_CHANNEL(self);
if (!PyArg_ParseTuple(args, "s:set_local_dev", &dev)) {
return NULL;
}
ares_set_local_dev(self->channel, dev);
Py_RETURN_NONE;
}
static PyObject *
Channel_func_getnameinfo(Channel *self, PyObject *args)
{
char *addr;
int port, flags, length;
struct in_addr addr4;
struct in6_addr addr6;
struct sockaddr *sa;
struct sockaddr_in sa4;
struct sockaddr_in6 sa6;
PyObject *callback;
CHECK_CHANNEL(self);
if (!PyArg_ParseTuple(args, "(si)iO:getnameinfo", &addr, &port, &flags, &callback)) {
return NULL;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
return NULL;
}
if (port < 0 || port > 65535) {
PyErr_SetString(PyExc_ValueError, "port must be between 0 and 65535");
return NULL;
}
if (ares_inet_pton(AF_INET, addr, &addr4) == 1) {
sa4 = uv_ip4_addr(addr, port);
sa = (struct sockaddr *)&sa4;
length = sizeof(struct sockaddr_in);
} else if (ares_inet_pton(AF_INET6, addr, &addr6) == 1) {
sa6 = uv_ip6_addr(addr, port);
sa = (struct sockaddr *)&sa6;
length = sizeof(struct sockaddr_in6);
} else {
PyErr_SetString(PyExc_ValueError, "invalid IP address");
return NULL;
}
Py_INCREF(callback);
ares_getnameinfo(self->channel, sa, length, flags, &nameinfo_cb, (void *)callback);
Py_RETURN_NONE;
}
static PyObject *
Channel_func_gethostbyaddr(Channel *self, PyObject *args)
{
char *name;
int family, length;
void *address;
struct in_addr addr4;
struct in6_addr addr6;
PyObject *callback;
CHECK_CHANNEL(self);
if (!PyArg_ParseTuple(args, "sO:gethostbyaddr", &name, &callback)) {
return NULL;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
return NULL;
}
if (ares_inet_pton(AF_INET, name, &addr4) == 1) {
length = sizeof(struct in_addr);
address = (void *)&addr4;
family = AF_INET;
} else if (ares_inet_pton(AF_INET6, name, &addr6) == 1) {
length = sizeof(struct in6_addr);
address = (void *)&addr6;
family = AF_INET6;
} else {
PyErr_SetString(PyExc_ValueError, "invalid IP address");
return NULL;
}
Py_INCREF(callback);
ares_gethostbyaddr(self->channel, address, length, family, &host_cb, (void *)callback);
Py_RETURN_NONE;
}
static PyObject *
Channel_func_getsock(Channel *self)
{
int i, bitmask;
ares_socket_t socks[ARES_GETSOCK_MAXNUM];
PyObject *tpl, *rfds, *wfds, *item;
CHECK_CHANNEL(self);
tpl = PyTuple_New(2);
rfds = PyList_New(0);
wfds = PyList_New(0);
if (!tpl || !rfds || !wfds) {
PyErr_NoMemory();
Py_XDECREF(tpl);
Py_XDECREF(rfds);
Py_XDECREF(wfds);
return NULL;
}
bitmask = ares_getsock(self->channel, socks, ARES_GETSOCK_MAXNUM);
for(i=0; i < ARES_GETSOCK_MAXNUM; i++) {
if(ARES_GETSOCK_READABLE(bitmask, i)) {
item = PyInt_FromLong((long)socks[i]);
PyList_Append(rfds, item);
Py_DECREF(item);
}
if(ARES_GETSOCK_WRITABLE(bitmask, i)) {
item = PyInt_FromLong((long)socks[i]);
PyList_Append(wfds, item);
Py_DECREF(item);
}
}
PyTuple_SET_ITEM(tpl, 0, rfds);
PyTuple_SET_ITEM(tpl, 1, wfds);
return tpl;
}
static PyObject *
Channel_func_set_local_ip(Channel *self, PyObject *args)
{
char *ip;
struct in_addr addr4;
struct in6_addr addr6;
CHECK_CHANNEL(self);
if (!PyArg_ParseTuple(args, "s:set_local_ip", &ip)) {
return NULL;
}
if (ares_inet_pton(AF_INET, ip, &addr4) == 1) {
ares_set_local_ip4(self->channel, ntohl(addr4.s_addr));
} else if (ares_inet_pton(AF_INET6, ip, &addr6) == 1) {
ares_set_local_ip6(self->channel, addr6.s6_addr);
} else {
PyErr_SetString(PyExc_ValueError, "invalid IP address");
return NULL;
}
Py_RETURN_NONE;
}
static PyObject *
Channel_func_query(Channel *self, PyObject *args)
{
char *name;
int query_type;
PyObject *callback, *ret;
CHECK_CHANNEL(self);
if (!PyArg_ParseTuple(args, "etiO:query", "idna", &name, &query_type, &callback)) {
return NULL;
}
if (!PyCallable_Check(callback)) {
PyErr_SetString(PyExc_TypeError, "a callable is required");
ret = NULL;
goto finally;
}
Py_INCREF(callback);
switch (query_type) {
case T_A:
{
ares_query(self->channel, name, C_IN, T_A, &query_a_cb, (void *)callback);
break;
}
case T_AAAA:
{
ares_query(self->channel, name, C_IN, T_AAAA, &query_aaaa_cb, (void *)callback);
break;
}
case T_CNAME:
{
ares_query(self->channel, name, C_IN, T_CNAME, &query_cname_cb, (void *)callback);
break;
}
case T_MX:
{
ares_query(self->channel, name, C_IN, T_MX, &query_mx_cb, (void *)callback);
break;
}
case T_NAPTR:
{
ares_query(self->channel, name, C_IN, T_NAPTR, &query_naptr_cb, (void *)callback);
break;
}
case T_NS:
{
ares_query(self->channel, name, C_IN, T_NS, &query_ns_cb, (void *)callback);
break;
}
case T_PTR:
{
ares_query(self->channel, name, C_IN, T_PTR, &query_ptr_cb, (void *)callback);
break;
}
case T_SOA:
{
ares_query(self->channel, name, C_IN, T_SOA, &query_soa_cb, (void *)callback);
break;
}
case T_SRV:
{
ares_query(self->channel, name, C_IN, T_SRV, &query_srv_cb, (void *)callback);
break;
}
case T_TXT:
{
ares_query(self->channel, name, C_IN, T_TXT, &query_txt_cb, (void *)callback);
break;
}
default:
{
Py_DECREF(callback);
PyErr_SetString(PyExc_AresError, "invalid query type specified");
ret = NULL;
goto finally;
}
}
ret = Py_None;
finally:
PyMem_Free(name);
Py_XINCREF(ret);
return ret;
}
int allocation(lp_state_type *pointer) {
int i;
int index;
double summ;
channel *c, *ch;
index = -1;
for(i = 0; i < pointer->channels_per_cell; i++){
if(!CHECK_CHANNEL(pointer,i)){
index = i;
break;
}
}
if(index != -1){
SET_CHANNEL(pointer,index);
c = (channel*)malloc(sizeof(channel));
if(c == NULL){
printf("malloc error: unable to allocate channel!\n");
exit(-1);
}
c->next = NULL;
c->prev = pointer->channels;
c->channel_id = index;
c->sir_data = (sir_data_per_cell*)malloc(sizeof(sir_data_per_cell));
if(c->sir_data == NULL){
printf("malloc error: unable to allocate SIR data!\n");
exit(-1);
}
if(pointer->channels != NULL)
pointer->channels->next = c;
pointer->channels = c;
summ = 0.0;
if (pointer->check_fading) {
ch = pointer->channels->prev;
while(ch != NULL){
ch->sir_data->fading = Expent(1.0);
summ += generate_cross_path_gain(pointer) * ch->sir_data->power * ch->sir_data->fading ;
ch = ch->prev;
}
}
if (summ == 0.0) {
// The newly allocated channel receives the minimal power
c->sir_data->power = MIN_POWER;
} else {
c->sir_data->fading = Expent(1.0);
c->sir_data->power = ((SIR_AIM * summ) / (generate_path_gain(pointer) * c->sir_data->fading));
if (c->sir_data->power < MIN_POWER) c->sir_data->power = MIN_POWER;
if (c->sir_data->power > MAX_POWER) c->sir_data->power = MAX_POWER;
}
} else {
printf("Unable to allocate channel, but the counter says I have %d available channels\n", pointer->channel_counter);
abort();
fflush(stdout);
}
return index;
}