示例#1
0
 void actionInit(Json::Value &data,
                 std::shared_ptr<typename WsServer::Connection> &connection,
                 WsPacket<WsServer> &) {
   // LOG(INFO) << "running actionInit JSON";
   IfAddrs ifAddrs;
   if (!IfAddrs::fromJson(data, ifAddrs)) {
     LOG(ERROR) << "can't parse ifAddrs";
     return;
   }
   // LOG(INFO) << ifAddrs.asCommands(std::string());
   std::shared_ptr<TunDevice> tun(
       new TunDevice(ifAddrs, tunaTor.getMtu(), tunaTor.getQsize()));
   if (!tun->start()) {
     LOG(ERROR) << "can't start tun device";
     sendTun("init-res", tun, connection);
     return;
   }
   if (!startStatThread(tun, connection)) {
     tun->stop();
     sendTun("init-res", tun, connection);
     return;
   }
   if (!startRecvThread(tun, connection)) {
     tun->stop();
     sendTun("init-res", tun, connection);
     return;
   }
   tunDevices.insert(std::make_pair(connection, tun));
   // Create TunDevice
   sendTun("init-res", tun, connection);
 }
示例#2
0
文件: tunnels.cpp 项目: ATNoG/ODiMM
uint ip6_tunnels::get(const ip::address_v6& remote)
{
	map::iterator i = _tunnels.find(remote);
	if (i != _tunnels.end()) {
		if (++i->second->refcount == 1)
			_gc.erase(remote);

		return i->second->tunnel.get_device_id();
	}

	std::auto_ptr<entry> tun(new entry(_io_service));
	std::pair<map::iterator, bool> res = _tunnels.insert(remote, tun);

	try {
		res.first->second->tunnel.open("", _local.scope_id(), _local, remote);
		res.first->second->tunnel.set_enable(true);
		if (_global_address == true)	
			res.first->second->tunnel.add_address(_local, 64); // TODO make this prefix configurable
		else {}
	} catch (...) {
		_tunnels.erase(res.first);
		throw;
	}

	return res.first->second->tunnel.get_device_id();
}
示例#3
0
文件: serv.c 项目: lxlee1102/udptun
void tun_serv(struct arguments *args) {
   int fd_udp = 0, fd_tun = 0;

   /* init server state */
   struct tun_state *state = init_tun_state(args);

   /* create tun if and sockets */
   tun(state, &fd_tun); 
   fd_udp         = udp_sock(state->public_port, 1, state->public_addr);

   /* run capture threads */
   xthread_create(capture_notun, (void *) state, 1);
   if (!args->capture_notun_only)
      xthread_create(capture_tun,   (void *) state, 1);
   synchronize();

   /* run server */
   debug_print("running serv ...\n");  
   xthread_create(serv_thread, (void*) state, 1);

   /* init select loop */
   fd_set input_set;
   struct timeval tv;
   int sel = 0, fd_max = 0;
   char buf[BUFF_SIZE], *buffer;
   buffer = buf;

   if (state->planetlab) {
      buffer[0]=0;buffer[1]=0;
      buffer[2]=8;buffer[3]=0;
      buffer+=4;
   }

   fd_max=max(fd_tun,fd_udp);
   loop=1;
   signal(SIGINT, serv_shutdown);
   signal(SIGTERM, serv_shutdown);

   while (loop) {
      FD_ZERO(&input_set);
      FD_SET(fd_udp, &input_set);
      FD_SET(fd_tun, &input_set);
  
      sel = xselect(&input_set, fd_max, &tv, state->inactivity_timeout);

      if (sel == 0) {
         debug_print("timeout\n"); 
         break;
      } else if (sel > 0) {
         if (FD_ISSET(fd_udp, &input_set)) 
            tun_serv_out(fd_udp, fd_tun, state, buffer);
         if (FD_ISSET(fd_tun, &input_set)) 
            tun_serv_in(fd_udp, fd_tun, state, buffer);
      }
   }
}
示例#4
0
文件: utun.c 项目: 0day1day/utils
int 
main (int argc, char **argv)
{
  int utunfd = tun ();

  if (utunfd == -1)
	{
		fprintf(stderr,"Unable to establish UTUN descriptor - aborting\n");
		exit(1);
	}

  fprintf(stderr,"Utun interface is up.. Configure IPv4 using \"ifconfig utun1 _ipA_ _ipB_\"\n");
  fprintf(stderr,"                       Configure IPv6 using \"ifconfig utun1 inet6 _ip6_\"\n");
  fprintf(stderr,"Then (e.g.) ping _ipB_ (IPv6 will automatically generate ND messages)\n");


  // PoC - Just dump the packets...
  for (;;)
	{
		unsigned char 	c[1500];
		int     len;
		int	i;

	
		len = read (utunfd,c, 1500);

		// First 4 bytes of read data are the AF: 2 for AF_INET, 1E for AF_INET6, etc..
		for (i = 4; i< len; i++)
		{
		   printf ("%02x ", c[i]);
		   if ( (i-4)%16 ==15) printf("\n");
		}
		printf ("\n");

		
	}

   return(0);
}
示例#5
0
文件: soctun.c 项目: SciSpike/soctun
int main(int argc, char *argv[])
{
  int header = 4;
  int mtu = 1500;
  int debug = 0;
  char *hostname;
  char *path;
  int port;
  int noDelayFlag = 0;
  int tid;
  int ch;
  int utunfd;
  int remoteFd;
  pid_t pid;

  while ((ch = getopt(argc, argv, "h:m:np:t:u:v")) != -1)
    switch (ch)
    {
    case 'h':
      hostname = optarg;
      break;
    case 'm':
      mtu = atoi(optarg) + header;
      break;
    case 'n':
      noDelayFlag = 1;
      break;
    case 'p':
      port = atoi(optarg);
      break;
    case 't':
      tid = atoi(optarg) + 1;
      break;
    case 'u':
      path = optarg;
      break;
    case 'v':
      debug++;
      break;
    default:
      usage(argv[0]);
    }

  int max = mtu + header;
  utunfd = tun(tid);
  if (port > 0)
  {
    remoteFd = tcp(hostname, port, noDelayFlag);
  }
  else
  {
    remoteFd = unix(path);
  }
  fd_set readset;

  int maxfd = remoteFd;
  if (maxfd < utunfd)
    maxfd = utunfd;

  if (utunfd == -1 || remoteFd == -1)
  {
    fprintf(stderr, "Unable to establish UTUN/IPC descriptors - aborting\n");
    exit(1);
  }

  unsigned char fromRemote[max];
  unsigned char fromTun[max];
  int len;
  int expected = 0;
  int totalLen = 0;
  int remaining = 0;
  for (;;)
  {
    FD_ZERO(&readset);
    FD_SET(utunfd, &readset);
    FD_SET(remoteFd, &readset);

    select(maxfd + 1, &readset, NULL, NULL, NULL);

    if (FD_ISSET(utunfd, &readset))
    {
      len = read(utunfd, fromTun, max);

      if (len > 0)
      {
        if (debug)
        {
          printSome(fromTun, len, ">>");
        }
        //set frame
        fromTun[0] = 0;
        fromTun[1] = 0;
        fromTun[2] = 8;
        fromTun[3] = 0;
        write(remoteFd, fromTun, len);
      }
      else if (len == 0)
      {
        break;
      }
    }

    if (FD_ISSET(remoteFd, &readset))
    {
      //we always have remaining, set to header length
      if (!expected && !remaining && !totalLen)
      {
        //frame + packet header
        remaining = 8;
      }

      len = read(remoteFd, &fromRemote[totalLen], remaining);
      remaining = remaining - len;
      totalLen += len;

      //got it all, but just the header, parse expected
      if (!expected && !remaining)
      {
        remaining = expected = (fromRemote[6] << 8) | (fromRemote[7] & 0xff);
        remaining = remaining - header;
        if (debug)
        {
          fprintf(stderr,
              "Finished reading header totalLen %i pExpected %i remaining %i\n",
              totalLen, expected, remaining);
          printSome(fromRemote, totalLen, "<<");
        }
      }
      //really got it all, ship it
      else if (expected && !remaining)
      {
        if (debug)
        {
          fprintf(stderr,
              "Finished reading packet totalLen %i pExpected %i remaining %i\n",
              totalLen, expected, remaining);
          printSome(fromRemote, totalLen, "<<");
        }
        //set frame
        fromRemote[0] = 0;
        fromRemote[1] = 0;
        fromRemote[2] = 0;
        fromRemote[3] = 2;
        write(utunfd, fromRemote, totalLen);
        //we just completed a packet, so reset
        expected = totalLen = remaining = 0;
      }
      else if (len == 0)
      {
        break;
      }
      else if (debug)
      {
        fprintf(stderr,
            "Keep reading packet totalLen %i pExpected %i remaining %i\n",
            totalLen, expected, remaining);
      }
    }
  }
  close(utunfd);
  close(remoteFd);
  return (0);
}