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 void syncOnConnect(SyncTcpConnection * connptr)
  50 {
  51   std::ifstream file( gOpt.getFileName().c_str() );
  52   if( file.is_open() )
  53         {
  54            std::string line;
  55                  while (! file.eof() )
  56                  {
  57                    getline (file,line);
  58                          connptr->Send(line);
  59                  }
  60          file.close();
  61         }
  62 }
  63
  64 void syncListener()
  65 {
  66  boost::asio::io_service io_service;
  67   try
  68   {
  69                 SyncTcpConnection::proto::resolver resolver(io_service);
  70                 SyncTcpConnection::proto::endpoint e;
  71                 if(gOpt.getBindToAddr()!="")
  72                 {
  73                         SyncTcpConnection::proto::resolver::query query(gOpt.getBindToAddr(), gOpt.getBindToPort());
  74                         e = *resolver.resolve(query);
  75                 } else {
  76                         SyncTcpConnection::proto::resolver::query query(gOpt.getBindToPort());
  77                         e = *resolver.resolve(query);
  78                 }
  79
  80
  81     SyncServer server(io_service,e);
  82                 server.onConnect=boost::bind(syncOnConnect,_1);
  83     io_service.run();
  84   }
  85   catch (std::exception& e)
  86   {
  87     std::string addr = gOpt.getBindToAddr() == "" ? "*" : gOpt.getBindToAddr();
  88     cLog.msg(Log::PRIO_ERR) << "cannot bind to " << addr << ":" << gOpt.getBindToPort()
  89                             << " (" << e.what() << ") exiting.." << std::endl;
  90     //return false;
  91   }
  92   //return true;
  93 }
  94
  95 int main(int argc, char* argv[])
  96 {
  97   bool daemonized=false;
  98   try
  99   {
 100
 101     if(!gOpt.parse(argc, argv))
 102     {
 103       gOpt.printUsage();
 104       exit(-1);
 105     }
 106
 107     cLog.setLogName("anytun-controld");
 108     cLog.msg(Log::PRIO_NOTICE) << "anytun-controld started...";
 109
 110     std::ifstream file( gOpt.getFileName().c_str() );
 111     if( file.is_open() )
 112       file.close();
 113     else
 114     {
 115       std::cout << "ERROR: unable to open file!" << std::endl;
 116       exit(-1);
 117     }
 118
 119     std::ofstream pidFile;
 120     if(gOpt.getPidFile() != "") {
 121       pidFile.open(gOpt.getPidFile().c_str());
 122       if(!pidFile.is_open()) {
 123         std::cout << "can't open pid file" << std::endl;
 124       }
 125     }
 126
 127     if(gOpt.getChroot())
 128       chrootAndDrop(gOpt.getChrootDir(), gOpt.getUsername());
 129     if(gOpt.getDaemonize())
 130     {
 131       daemonize();
 132       daemonized = true;
 133     }
 134
 135     if(pidFile.is_open()) {
 136       pid_t pid = getpid();
 137       pidFile << pid;
 138       pidFile.close();
 139     }
 140
 141     SignalController sig;
 142     sig.init();
 143
 144     boost::thread * syncListenerThread;
 145     syncListenerThread = new boost::thread(boost::bind(syncListener));
 146
 147     int ret = sig.run();
 148
 149     return ret;
 150   }
 151   catch(std::runtime_error& e)
 152   {
 153     if(daemonized)
 154       cLog.msg(Log::PRIO_ERR) << "uncaught runtime error, exiting: " << e.what();
 155     else
 156       std::cout << "uncaught runtime error, exiting: " << e.what() << std::endl;
 157   }
 158   catch(std::exception& e)
 159   {
 160     if(daemonized)
 161       cLog.msg(Log::PRIO_ERR) << "uncaught exception, exiting: " << e.what();
 162     else
 163       std::cout << "uncaught exception, exiting: " << e.what() << std::endl;
 164   }
 165 }
 166