src/anytun-controld.cpp

   1 /*
   2  *  anytun
   3  *
   4  *  The secure anycast tunneling protocol (satp) defines a protocol used
   5  *  for communication between any combination of unicast and anycast
   6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
   7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
   8  *  ethernet, ip, arp ...). satp directly includes cryptography and
   9  *  message authentication based on the methodes used by SRTP.  It is
  10  *  intended to deliver a generic, scaleable and secure solution for
  11  *  tunneling and relaying of packets of any protocol.
  12  *
  13  *
  14  *  Copyright (C) 2007-2008 Othmar Gsenger, Erwin Nindl,
  15  *                          Christian Pointner <satp@wirdorange.org>
  16  *
  17  *  This file is part of Anytun.
  18  *
  19  *  Anytun is free software: you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License version 3 as
  21  *  published by the Free Software Foundation.
  22  *
  23  *  Anytun is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with anytun.  If not, see <http://www.gnu.org/licenses/>.
  30  */
  31
  32 #include <iostream>
  33 #include <fstream>
  34 #include <poll.h>
  35 #include <fcntl.h>
  36 #include <pwd.h>
  37 #include <grp.h>
  38 #include <string>
  39
  40 #include "datatypes.h"
  41
  42 #include "log.h"
  43 #include "signalController.h"
  44 #include "anyCtrOptions.h"
  45
  46 #include "syncServer.h"
  47 #include "daemon.hpp"
  48
  49 std::string filename;
  50
  51 class ThreadParam
  52 {
  53 public:
  54   ThreadParam() : addr(""), port(0) {};
  55   std::string addr;
  56   u_int16_t port;
  57 };
  58
  59 void syncOnConnect(SyncTcpConnection * connptr)
  60 {
  61   std::ifstream file( filename.c_str() );
  62   if( file.is_open() )
  63         {
  64            std::string line;
  65                  while (! file.eof() )
  66                  {
  67                    getline (file,line);
  68                          connptr->Send(line);
  69                  }
  70          file.close();
  71         }
  72 }
  73
  74 void syncListener(void* p )
  75 {
  76   ThreadParam* param = reinterpret_cast<ThreadParam*>(p);
  77
  78   try
  79   {
  80     asio::io_service io_service;
  81     SyncServer server(io_service,asio::ip::tcp::endpoint(asio::ip::tcp::v6(), param->port));
  82                 server.onConnect=boost::bind(syncOnConnect,_1);
  83     io_service.run();
  84   }
  85   catch (std::exception& e)
  86   {
  87     std::cerr << e.what() << std::endl;
  88   }
  89
  90 }
  91
  92 int main(int argc, char* argv[])
  93 {
  94   if(!gOpt.parse(argc, argv))
  95   {
  96     gOpt.printUsage();
  97     exit(-1);
  98   }
  99
 100   std::ifstream file( gOpt.getFileName().c_str() );
 101   if( file.is_open() )
 102     file.close();
 103   else
 104   {
 105     std::cout << "ERROR: unable to open file!" << std::endl;
 106     exit(-1);
 107   }
 108
 109   std::ofstream pidFile;
 110   if(gOpt.getPidFile() != "") {
 111     pidFile.open(gOpt.getPidFile().c_str());
 112     if(!pidFile.is_open()) {
 113       std::cout << "can't open pid file" << std::endl;
 114     }
 115   }
 116
 117   if(gOpt.getChroot())
 118     chrootAndDrop(gOpt.getChrootDir(), gOpt.getUsername());
 119   if(gOpt.getDaemonize())
 120     daemonize();
 121
 122   if(pidFile.is_open()) {
 123     pid_t pid = getpid();
 124     pidFile << pid;
 125     pidFile.close();
 126   }
 127
 128   SignalController sig;
 129   sig.init();
 130
 131   ThreadParam p;
 132   p.addr = gOpt.getBindToAddr();
 133   p.port = gOpt.getBindToPort();
 134   filename =  gOpt.getFileName();
 135   boost::thread * syncListenerThread;
 136   syncListenerThread = new boost::thread(boost::bind(syncListener,&p));
 137
 138         int ret = sig.run();
 139
 140   return ret;
 141 }
 142