Пример #1
0
/*
 * is_group_invalid
 *
 * returns 1 if the `gid' of level `lvl' is invalid and
 * cannot be used in a regular IP.
 */
int
is_group_invalid(int *gids, int gid, int lvl, int family)
{
	if (family == AF_INET) {
		if (lvl == GET_LEVELS(family) - 1) {
			if (!gid)			/* ZERONET */
				return 1;

			if (gid >= 224 && gid <= 255)
				/* MULTICAST and BADCLASS */
				return 1;

			if (gid == 127)		/* LOOPBACK */
				return 1;

			if (gid == 192 && gids[lvl - 1] == 168)
				/* 192.168.x.x is private, we cannot use IP of
				 * that range */
				return 1;

			if ((gid == 172
				 && (gids[lvl - 1] >= 16 || gids[lvl - 1] <= 31))
				&& !restricted_mode)
				/* We aren't in restricted mode, so
				 * 172.16.0.0-172.31.255.255 is a private
				 * class */
				return 1;

			if (restricted_mode &&
				((restricted_class == RESTRICTED_10 && gid != 10) ||
				 (restricted_class == RESTRICTED_172 &&
				  !(gid == 172 && (gids[lvl - 1] >= 16 ||
								   gids[lvl - 1] <= 31))
				 )
				)
				)
				/* We are in restricted mode, thus this IP is
				 * invalid because it isn't in the 10.x.x.x or
				 * 172.(16-31).x.x format */
				return 1;

		} else if (lvl == GET_LEVELS(family) - 2) {
			if (gid == 168 && gids[lvl + 1] == 192)
				/* 192.168.x.x */
				return 1;
			if (((gid >= 16 || gid <= 31) && gids[lvl + 1] == 172) &&
				!restricted_mode)
				/* 172.16.0.0-172.31.255.255 */
				return 1;
		}
	} else if (family == AF_INET6) {
		/* TODO: nothing ? */
		return 0;
	}

	return 0;
}
Пример #2
0
/*
 * gidtoipstart
 *
 * It sets in `*ip' the ipstart of the gnode using the `gid[x]' for
 * each level x.
 * `total_levels' is the total number of levels and the `gid' array
 * has `total_levels' elements.
 * `levels' is the number of array elements considered, gidtoipstart() will use
 * only the elements going from gid[total_levels-levels] to gid[total_levels-1].
 * `family' is used to fill the inet_prefix of ipstart.
 */
void
gidtoipstart(int *gid, u_char total_levels, u_char levels, int family,
			 inet_prefix * ip)
{
	int i, h_ip[MAX_IP_INT];
	u_char *ipstart;

	setzero(h_ip, MAX_IP_SZ);
	ipstart = (u_char *) h_ip;

	for (i = total_levels - ZERO_LEVEL; i >= total_levels - levels; i--) {
		/* The formula is:
		 * ipstart += MAXGROUPNODE^i * gid[i];
		 * but since MAXGROUPNODE is equal to 2^8 we just set each
		 * single byte of ipstart. */
#if BYTE_ORDER == LITTLE_ENDIAN
		ipstart[i] = (u_char) gid[i];
#else
		ipstart[GET_LEVELS(family) - i - 1] = (u_char) gid[i];
#endif

	}

	memcpy(ip->data, h_ip, MAX_IP_SZ);
	ip->family = family;
	ip->len = (family == AF_INET) ? 4 : 16;
	ip->bits = ip->len * 8;
}
Пример #3
0
/*
 * iptoquadg
 *
 * Using the given `ip' it fills the `qg' quadro_group struct. The `flags'
 * given specify what element fill in the struct (the flags are in gmap.h).
 */
void
iptoquadg(inet_prefix ip, map_gnode ** ext_map, quadro_group * qg,
		  char flags)
{
	int i;
	u_char levels;
	int gid[MAX_LEVELS];

	setzero(qg, sizeof(quadro_group));

	levels = GET_LEVELS(ip.family);
	qg->levels = levels;

	if (flags & QUADG_GID) {
		iptogids(&ip, qg->gid, levels);
		memcpy(gid, qg->gid, sizeof(gid));

		if (flags & QUADG_IPSTART)
			for (i = 0; i < levels; i++)
				gidtoipstart(gid, levels, levels - i, ip.family,
							 &qg->ipstart[i]);
	}
	if (flags & QUADG_GNODE) {
		for (i = 0; i < levels - ZERO_LEVEL; i++)
			qg->gnode[i] = gnode_from_pos(qg->gid[i + 1], ext_map[i]);
		qg->gnode[levels - ZERO_LEVEL] = &ext_map[i][0];
	}
}
Пример #4
0
Файл: coding.c Проект: cran/cba
SEXP as_dummy(SEXP R_x) {

    int n, l, i, j;

    SEXP R_obj, R_tmp;
	
    n = LENGTH(R_x);
    l = LENGTH(GET_LEVELS(R_x));

    if (l == 0)
       return R_NilValue;

    PROTECT(R_obj = NEW_LOGICAL(n*l));

    for (i = 0; i < n*l; i++)		/* this sucks! */
	LOGICAL(R_obj)[i] = FALSE;

    for (i = 0; i < n; i++) {
	j = INTEGER(R_x)[i];
	if (j == NA_INTEGER)
	   continue;
	LOGICAL(R_obj)[i+(j-1)*n] = TRUE;
    }

    PROTECT(R_tmp = NEW_INTEGER(2));

    INTEGER(R_tmp)[0] = n;
    INTEGER(R_tmp)[1] = l;

    SET_DIM(R_obj, R_tmp);
    UNPROTECT(1);
    
    SET_LEVELS(R_obj, duplicate(GET_LEVELS(R_x)));

    UNPROTECT(1);
    
    return R_obj;
}
Пример #5
0
/*
 * iptogid
 *
 * ip to gnode id, of the specified `level', conversion function.
 * Note: this function cannot fail! So be sure to pass a valid `level'.
 */
int
iptogid(inet_prefix * ip, int level)
{
	u_char *h_ip = (u_char *) ip->data;
	int gid;

	/*
	 * The formula is:
	 * gid=(ip/MAXGROUPNODE^level) - (ip/MAXGROUPNODE^(level+1) * MAXGROUPNODE);
	 * but since we have a MAXGROUPNODE equal to 2^8 we can just return
	 * the `level'-th byte of ip.data.
	 */
#if BYTE_ORDER == LITTLE_ENDIAN
	gid = (int) h_ip[level];
#else
	gid = (int) h_ip[GET_LEVELS(ip->family) - level - 1];
#endif

	return gid;
}
Пример #6
0
/*
 * init_internet_gateway_search:
 * Initialization of the igs.c code.
 */
void
init_internet_gateway_search(void)
{
	inet_prefix new_gw;
	char new_gw_dev[IFNAMSIZ];

	pthread_t ping_thread;
	pthread_attr_t t_attr;
	int i, ret, res, e;

	active_gws = 0;
	igw_multi_gw_disabled = 0;
	setzero(multigw_nh, sizeof(igw_nexthop) * MAX_MULTIPATH_ROUTES);

	/*
	 * Just return if we aren't in restricted mode or if the user doesn't
	 * want to use shared internet connections
	 */
	if (!restricted_mode || (!server_opt.use_shared_inet &&
							 !server_opt.share_internet))
		return;

	loginfo("Activating the Internet Gateway Search engine");

	init_igws(&me.igws, &me.igws_counter, GET_LEVELS(my_family));
	init_tunnels_ifs();

	/* delete all the old tunnels */
	del_all_tunnel_ifs(0, 0, 0, NTK_TUNL_PREFIX);

	/*
	 * Bring tunl0 up (just to test if the ipip module is loaded)
	 */
	loginfo("Checking if \"" DEFAULT_TUNL_IF "\" exists");
	if (tunnel_change(0, 0, 0, DEFAULT_TUNL_PREFIX, DEFAULT_TUNL_NUMBER) <
		0) {
		printf("Cannot read \"" DEFAULT_TUNL_IF "\". "
			   "Is the \"ipip\" kernel module loaded?\n"
			   "  If you don't care about using the shared internet "
			   "connections of the ntk nodes\n"
			   "  around you, disable the \"use_shared_inet\" option "
			   "in netsukuku.conf");
		del_resolv_conf("nameserver 127.0.0.1", "/etc/resolv.conf");
		exit(1);
	}
	ifs_del_all_name(me.cur_ifs, &me.cur_ifs_n, NTK_TUNL_PREFIX);
	ifs_del_all_name(me.cur_ifs, &me.cur_ifs_n, DEFAULT_TUNL_PREFIX);

	/*
	 * Delete old routing rules
	 */
	reset_igw_rules();

	/*
	 * Init netfilter
	 */
	res = mark_init(server_opt.share_internet);
	if (res) {
		error(err_str);
		error("Cannot set the netfilter rules needed for the multi-igw. "
			  "This feature will be disabled");
		igw_multi_gw_disabled = 1;
	}

	/*
	 * Check anomalies: from this point we initialize stuff only if we
	 * have an Inet connection
	 */
	if (!server_opt.inet_connection)
		return;
	if (!server_opt.inet_hosts)
		fatal("You didn't specified any Internet hosts in the "
			  "configuration file. What hosts should I ping?");

	/*
	 * If we are sharing our internet connection, activate the
	 * masquerading.
	 */
	if (server_opt.share_internet) {
		igw_exec_masquerade_sh(server_opt.ip_masq_script, 0);
		if (!server_opt.ip_masq_script)
			fatal("No masquerading script was configured!");
	};

	/*
	 * Get the default gateway route currently set in the kernel routing
	 * table
	 */
	setzero(&new_gw, sizeof(inet_prefix));
	ret = rt_get_default_gw(&new_gw, new_gw_dev);

	/*
	 * If there is no IP set in the route, fetch it at least from the
	 * device included in it.
	 */
	if (!new_gw.family && *new_gw_dev) {
		if (get_dev_ip(&new_gw, my_family, new_gw_dev) < 0)
			(*new_gw_dev) = 0;
	}

	if (ret < 0 || (!*new_gw_dev && !new_gw.family)) {
		/* Nothing useful has been found  */

		loginfo("The retrieval of the default gw from the kernel failed.");

		if (!server_opt.inet_gw.data[0])
			fatal("The default gw isn't set in the kernel and you "
				  "didn't specified it in netsukuku.conf. "
				  "Cannot continue!");
	} else if (!server_opt.inet_gw_dev ||
			   strncmp(new_gw_dev, server_opt.inet_gw_dev, IFNAMSIZ) ||
			   memcmp(new_gw.data, server_opt.inet_gw.data, MAX_IP_SZ)) {

		if (server_opt.inet_gw.data[0])
			loginfo("Your specified Internet gateway doesn't match with "
					"the one currently stored in the kernel routing table."
					"I'm going to use the kernel gateway: %s dev %s",
					inet_to_str(new_gw), new_gw_dev);

		if (!server_opt.inet_gw_dev)
			server_opt.inet_gw_dev = xstrdup(new_gw_dev);
		else
			strncpy(server_opt.inet_gw_dev, new_gw_dev, IFNAMSIZ);
		memcpy(&server_opt.inet_gw, &new_gw, sizeof(inet_prefix));

		/* Delete the default gw, we are replacing it */
		rt_delete_def_gw(0);
	}

	loginfo("Using \"%s dev %s\" as your first Internet gateway.",
			inet_to_str(server_opt.inet_gw), server_opt.inet_gw_dev);
	if (rt_replace_def_gw(server_opt.inet_gw_dev, server_opt.inet_gw, 0))
		fatal("Cannot set the default gw to %s %s",
			  inet_to_str(server_opt.inet_gw), server_opt.inet_gw_dev);
	active_gws++;

	/*
	 * Activate the anti-loop multi-igw shield
	 */
	if (server_opt.share_internet) {
		rule_add(0, 0, 0, 0, FWMARK_ALISHIELD, RTTABLE_ALISHIELD);
		if (rt_replace_def_gw(server_opt.inet_gw_dev, server_opt.inet_gw,
							  RTTABLE_ALISHIELD)) {
			error("Cannot set the default route in the ALISHIELD table. "
				  "Disabling the multi-inet_gw feature");
			igw_multi_gw_disabled = 1;
		}
	}


	/*
	 * Activate the traffic shaping for the `server_opt.inet_gw_dev'
	 * device
	 */
	if (server_opt.shape_internet)
		igw_exec_tcshaper_sh(server_opt.tc_shaper_script, 0,
							 server_opt.inet_gw_dev,
							 server_opt.my_upload_bw,
							 server_opt.my_dnload_bw);

	for (i = 0; i < me.cur_ifs_n; i++)
		if (!strcmp(me.cur_ifs[i].dev_name, server_opt.inet_gw_dev)) {
			for (e = 0; e < server_opt.ifs_n; e++)
				if (!strcmp(server_opt.ifs[i], server_opt.inet_gw_dev))
					fatal("You specified the \"%s\" interface"
						  " in the options, but this device is also"
						  " part of the primary Internet gw route."
						  " Don't include \"%s\" in the list of "
						  "interfaces utilised by the daemon",
						  server_opt.inet_gw_dev, server_opt.inet_gw_dev);

			loginfo("Deleting the \"%s\" interface from the device "
					"list since it is part of the primary Internet"
					" gw route.", me.cur_ifs[i].dev_name);

			ifs_del(me.cur_ifs, &me.cur_ifs_n, i);
			if (me.cur_ifs_n <= 0)
				fatal
					("The deleted interface cannot be used by NetsukukuD because it is part\n"
					 "  of your primary Internet gw route. You have to specify another\n"
					 "  interface with the -i option or you won't be able share your"
					 "  Internet connection");
		}

	loginfo("Launching the first ping to the Internet hosts");
	if (!server_opt.disable_andna)
		internet_hosts_to_ip();
	me.inet_connected = igw_check_inet_conn();
	if (me.inet_connected)
		loginfo("The Internet connection is up & running");
	else
		loginfo("The Internet connection appears to be down");
	if (!me.inet_connected && server_opt.share_internet)
		fatal("We are not connected to the Internet, but you want to "
			  "share your connection. Please check your options");

	debug(DBG_SOFT, "Evoking the Internet ping daemon.");
	pthread_attr_init(&t_attr);
	pthread_attr_setdetachstate(&t_attr, PTHREAD_CREATE_DETACHED);
	pthread_create(&ping_thread, &t_attr, igw_check_inet_conn_t, 0);
}
Пример #7
0
/* NOTE: R vectors of length 1 will yield a python list of length 1*/
int
to_Pyobj_vector(SEXP robj, PyObject **obj, int mode)
{
  PyObject *it, *tmp;
  SEXP names, dim;
  int len, *integers, i, type;
  const char *strings, *thislevel;
  double *reals;
  Rcomplex *complexes;
#ifdef WITH_NUMERIC
  PyObject *array;
#endif

  if (!robj)
    {
    // return -1;                  /* error */
    // if(my_callback){
        // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "robj does not exist"));
        // PyObject_CallObject(my_callback, argslist);
    // }
    return 1;
    }
  if (robj == R_NilValue) {
    Py_INCREF(Py_None);
    *obj = Py_None;
    return 1;                   /* succeed */
  }

  len = GET_LENGTH(robj);
  tmp = PyList_New(len);
  type = TYPEOF(robj);

    // if(my_callback){
        // argslist = Py_BuildValue("(O)", Py_BuildValue("(si)", "robj length is ", len));
        // PyObject_CallObject(my_callback, argslist);
    // }
    
  /// break for checking the R length and other aspects
  for (i=0; i<len; i++) {
    switch (type)
      {
      case LGLSXP:
            // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In LGLSXP"));
                // PyObject_CallObject(my_callback, argslist);
            // }
         integers = INTEGER(robj);
         if(integers[i]==NA_INTEGER) /* watch out for NA's */
           {
             if (!(it = PyInt_FromLong(integers[i])))
             //return -1;
             tmp = Py_BuildValue("s", "failed in the PyInt_FromLong");  // we are at least getting an robj
             *obj = tmp;
             return 1;
             //it = Py_None;
           }
         else if (!(it = PyBool_FromLong(integers[i])))
            {
            tmp = Py_BuildValue("s", "failed in the PyBool_FromLong");  // we are at least getting an robj
             *obj = tmp;
             return 1;
           //return -1;
           }
         break;
      case INTSXP:
            // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In INTSXP"));
                // PyObject_CallObject(my_callback, argslist);
            // }
        integers = INTEGER(robj);
        if(isFactor(robj)) {
          /* Watch for NA's! */
          if(integers[i]==NA_INTEGER)
            it = PyString_FromString(CHAR(NA_STRING));
          else
            {
              thislevel = CHAR(STRING_ELT(GET_LEVELS(robj), integers[i]-1));
              if (!(it = PyString_FromString(thislevel)))
                {
                tmp = Py_BuildValue("s", "failed in the PyString_FromString");  // we are at least getting an robj
                *obj = tmp;
                return 1;
                }
                //return -1;
            }
        }
        else {
          if (!(it = PyInt_FromLong(integers[i])))
            {
            tmp = Py_BuildValue("s", "failed in the PyInt_FromLong");  // we are at least getting an robj
                *obj = tmp;
                return 1;
            //return -1;
            }
        }
        break;
      case REALSXP:
            // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In REALSXP"));
                // PyObject_CallObject(my_callback, argslist);
            // }
        reals = REAL(robj);
        if (!(it = PyFloat_FromDouble(reals[i])))
        {
        // tmp = Py_BuildValue("s", "failed in the PyFloat_FromDouble");  // we are at least getting an robj
                // *obj = tmp;
                // return 1;
         return -1;
        }
        break;
      case CPLXSXP:
            // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In CPLXSXP"));
                // PyObject_CallObject(my_callback, argslist);
            // }
        complexes = COMPLEX(robj);
        if (!(it = PyComplex_FromDoubles(complexes[i].r,
                                         complexes[i].i)))
          {
            
            // tmp = Py_BuildValue("s", "failed in PyComplex_FromDoubles!!!");  // we are at least getting an robj
            // *obj = tmp;
            // return 1;
            return -1;
            }
        break;
      case STRSXP:
            // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In STRSXP"));
                // PyObject_CallObject(my_callback, argslist);
            // }
        if(STRING_ELT(robj, i)==R_NaString)
          it = PyString_FromString(CHAR(NA_STRING));
        else
          {
            strings = CHAR(STRING_ELT(robj, i));
            if (!(it = PyString_FromString(strings)))
              {
            
                // tmp = Py_BuildValue("s", "failed in PyString_FromString!!!");  // we are at least getting an robj
                // *obj = tmp;
                // return 1;
                return -1;
                }
          }
        break;
      case LISTSXP:
            // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In LISTSXP"));
                // PyObject_CallObject(my_callback, argslist);
            // }
        if (!(it = to_Pyobj_with_mode(elt(robj, i), mode)))
            {
            
            // tmp = Py_BuildValue("s", "failed in to_Pyobj_with_mode LISTSXP!!!");  // we are at least getting an robj
            // *obj = tmp;
            // return 1;
            return -1;
            }
        break;
      case VECSXP:
            // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "In VECSXP"));
                // PyObject_CallObject(my_callback, argslist);
            // }
        if (!(it = to_Pyobj_with_mode(VECTOR_ELT(robj, i), mode)))
            {
            return -1;
            }
        break;
      default:
        Py_DECREF(tmp);
        return 0;                 /* failed */
    }
    
    if (PyList_SetItem(tmp, i, it) < 0) // there was a failure in setting the item
            {
            
            // tmp = Py_BuildValue("s", "failed in PyList_SetItem!!!");  // we are at least getting an robj
            // *obj = tmp;
            // return 1;
            return -1;
            }
  }

  dim = GET_DIM(robj);
  if (dim != R_NilValue) {
// #ifdef WITH_NUMERIC
    // if(use_numeric)
      // {
        // array = to_PyNumericArray(tmp, dim);
        // if (array) {                /* If the conversion to Numeric succeed.. */
          // *obj = array;             /* we are done */
          // Py_DECREF(tmp);
          // return 1;
        // }
        // PyErr_Clear();
      // }
// #endif
    len = GET_LENGTH(dim);
    *obj = to_PyArray(tmp, INTEGER(dim), len);
    Py_DECREF(tmp);
    return 1;
  }
    // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(O)", tmp));
                // PyObject_CallObject(my_callback, argslist);
            // }
  names = GET_NAMES(robj);
  if (names == R_NilValue)
    {
    *obj = tmp;
        // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "returning as list (of lists)"));
                // PyObject_CallObject(my_callback, argslist);
            // }
    }
  else {
    *obj = to_PyDict(tmp, names);
        // if(my_callback){
                // argslist = Py_BuildValue("(O)", Py_BuildValue("(s)", "returning as dict"));
                // PyObject_CallObject(my_callback, argslist);
            // }
    Py_DECREF(tmp);
  }
  return 1;
}
Пример #8
0
SEXP foreach_bed(SEXP bed, SEXP function, SEXP envir) {
  SEXP chroms, starts, ends, strands = R_NilValue;
  SEXP arg_idx, arg_chrom, arg_start, arg_end, arg_strand;
  SEXP fcall;
  int has_strand = 0;
  int i, N;

  PROTECT(bed);

  if(!isEnvironment(envir)) 
    error("'envir' should be an environment");

  chroms = VECTOR_ELT(bed, 0);
  if (!isFactor(chroms) && TYPEOF(chroms) != STRSXP)
    error("first column of bed file must be a factor or character vector");

  PROTECT(starts = AS_INTEGER(VECTOR_ELT(bed, 1)));
  PROTECT(ends = AS_INTEGER(VECTOR_ELT(bed, 2)));

  if (length(bed) >= 6) {
    has_strand = 1;
    strands = VECTOR_ELT(bed, 5);

    if (!isFactor(strands) && TYPEOF(strands) != STRSXP)
      error("sixth column of bed file must be a factor or character vector");
  }

  /* build function call */
  PROTECT(arg_idx = NEW_INTEGER(1));
  PROTECT(arg_chrom = allocVector(STRSXP, 1));
  PROTECT(arg_start = NEW_INTEGER(1));
  PROTECT(arg_end = NEW_INTEGER(1));
  PROTECT(arg_strand = allocVector(STRSXP, 1));

  if (has_strand == 0)
    SET_STRING_ELT(arg_strand, 0, NA_STRING);

  PROTECT(fcall = lang6(function, arg_idx, arg_chrom, arg_start, arg_end, arg_strand));

  /* run loop */
  N = length(chroms);
  for (i = 0; i < N; ++i) {
    INTEGER(arg_idx)[0] = i + 1;
    INTEGER(arg_start)[0] = INTEGER(starts)[i];
    INTEGER(arg_end)[0] = INTEGER(ends)[i];
    
    /* chrom */
    if (isFactor(chroms)) {
      int idx = INTEGER(chroms)[i] - 1;
      SET_STRING_ELT(arg_chrom, 0, STRING_ELT(GET_LEVELS(chroms), idx));
    } else
      SET_STRING_ELT(arg_chrom, 0, STRING_ELT(chroms, i));
    
    /* strand */
    if (has_strand == 1) {
      if (isFactor(strands)) {
        int idx = INTEGER(strands)[i] - 1;
        SET_STRING_ELT(arg_strand, 0, STRING_ELT(GET_LEVELS(strands), idx));
      } else
        SET_STRING_ELT(arg_strand, 0, STRING_ELT(strands, i));
    }
    
    /* eval and ignore result */
    eval(fcall, envir);
    
    /* check for interrupts */
    R_CheckUserInterrupt();
  }
  
  /* clean up */
  UNPROTECT(9);
  
  return R_NilValue;
}