projects/stargazer/plugins/configuration/sgconfig2/stgconfig.cpp

   1 #include <cstdio>
   2 #include <cunistd>
   3 #include <csignal>
   4 #include <functional>
   5 #include <algorithm>
   6
   7 #include "stg/plugin_creator.h"
   8 #include "stgconfig.h"
   9 #include "../../../tariffs.h"
  10 #include "../../../admins.h"
  11 #include "../../../users.h"
  12
  13 PLUGIN_CREATOR<STG_CONFIG> stgc;
  14
  15 BASE_PLUGIN * GetPlugin()
  16 {
  17 return stgc.GetPlugin();
  18 }
  19
  20 STG_CONFIG_SETTINGS::STG_CONFIG_SETTINGS()
  21     : port(0)
  22 {
  23 }
  24
  25 const string& STG_CONFIG_SETTINGS::GetStrError() const
  26 {
  27 return errorStr;
  28 }
  29
  30 int STG_CONFIG_SETTINGS::ParseSettings(const MODULE_SETTINGS & s)
  31 {
  32 int p;
  33 PARAM_VALUE pv;
  34 vector<PARAM_VALUE>::const_iterator pvi;
  35 ///////////////////////////
  36 pv.param = "Port";
  37 pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv);
  38 if (pvi == s.moduleParams.end())
  39     {
  40     errorStr = "Parameter \'Port\' not found.";
  41     printfd(__FILE__, "Parameter 'Port' not found\n");
  42     return -1;
  43     }
  44 if (ParseIntInRange(pvi->value[0], 2, 65535, &p))
  45     {
  46     errorStr = "Cannot parse parameter \'Port\': " + errorStr;
  47     printfd(__FILE__, "%s\n", errorStr.c_str());
  48     return -1;
  49     }
  50 port = p;
  51
  52 return 0;
  53 }
  54
  55 uint16_t STG_CONFIG_SETTINGS::GetPort()
  56 {
  57 return port;
  58 }
  59
  60 STG_CONFIG::STG_CONFIG()
  61     : running(false),
  62       stopped(true)
  63 {
  64 }
  65
  66 string STG_CONFIG::GetVersion() const
  67 {
  68 return "Stg configurator v.2.00";
  69 }
  70
  71 int STG_CONFIG::ParseSettings()
  72 {
  73 int ret = stgConfigSettings.ParseSettings(settings);
  74 if (ret)
  75     errorStr = stgConfigSettings.GetStrError();
  76 return ret;
  77 }
  78
  79 int STG_CONFIG::Start()
  80 {
  81 if (running)
  82     return false;
  83
  84 if (PrepareNetwork())
  85     return true;
  86
  87 stopped = false;
  88
  89 config.SetPort(stgConfigSettings.GetPort());
  90 config.SetAdmins(admins);
  91 config.SetUsers(users);
  92 config.SetTariffs(tariffs);
  93 config.SetStgSettings(stgSettings);
  94 config.SetStore(store);
  95
  96 if (config.Prepare())
  97     {
  98     errorStr = config.GetStrError();
  99     return true;
 100     }
 101
 102 if (pthread_create(&thread, NULL, Run, this))
 103     {
 104     errorStr = "Cannot create thread.";
 105     printfd(__FILE__, "Cannot create thread\n");
 106     return true;
 107     }
 108
 109 errorStr = "";
 110 return false;
 111 }
 112
 113 int STG_CONFIG::Stop()
 114 {
 115 if (!running)
 116     return false;
 117
 118 running = false;
 119
 120 config.Stop();
 121
 122 //5 seconds to thread stops itself
 123 int i;
 124 for (i = 0; i < 25 && !stopped; i++)
 125     {
 126     usleep(200000);
 127     }
 128
 129 //after 5 seconds waiting thread still running. now killing it
 130 if (!stopped)
 131     {
 132     //TODO pthread_cancel()
 133     if (pthread_kill(thread, SIGINT))
 134         {
 135         errorStr = "Cannot kill thread.";
 136         printfd(__FILE__, "Cannot kill thread\n");
 137         return FinalizeNetwork();
 138         }
 139     printfd(__FILE__, "STG_CONFIG killed\n");
 140     }
 141
 142 return FinalizeNetwork();
 143 }
 144
 145 void * STG_CONFIG::Run(void * d)
 146 {
 147 STG_CONFIG * stgConf = static_cast<STG_CONFIG *>(d);
 148 stgConf->running = true;
 149
 150 stgConf->RealRun();
 151
 152 stgConf->stopped = true;
 153 return NULL;
 154 }
 155
 156 uint16_t STG_CONFIG::GetStartPosition() const
 157 {
 158 return 20;
 159 }
 160
 161 uint16_t STG_CONFIG::GetStopPosition() const
 162 {
 163 return 20;
 164 }
 165
 166 bool PrepareNetwork()
 167 {
 168 struct sockaddr_in local;
 169
 170 local.sin_family = AF_INET;
 171 local.sin_port = htons(port);
 172 local.sin_addr.s_addr = INADDR_ANY;
 173
 174 sd = socket(AF_INET, SOCK_STREAM, 0);
 175 if (sd < 0)
 176     {
 177     errorStr = "Error creating socket: '";
 178     errorStr += strerror(errno);
 179     errorStr += "'";
 180     return true;
 181     }
 182
 183 if (bind(sd, static_cast<struct sockaddr *>(&local), sizeof(local)) < 0)
 184     {
 185     errorStr = "Error binding socket: '";
 186     errorStr += strerror(errno);
 187     errorStr += "'";
 188     return true;
 189     }
 190
 191 return false;
 192 }
 193
 194 bool FinalizeNetwork()
 195 {
 196 if (close(sd) < 0)
 197     {
 198     errorStr = "Error closing socket: '";
 199     errorStr += strerror(errno);
 200     errorStr += "'";
 201     return true;
 202     }
 203 return false;
 204 }
 205
 206 void STG_CONFIG::RealRun()
 207 {
 208 if (listen(sd, 64) < 0)
 209     {
 210     errorStr = "Error listening socket: '";
 211     errorStr += strerror(errno);
 212     errorStr += "'";
 213     return;
 214     }
 215
 216 fd_set rfds;
 217
 218 FD_ZERO(&rfds);
 219 FD_SET(sd, &rfds);
 220
 221 running = true;
 222 while (running)
 223     {
 224     struct timeval tv;
 225     tv.tv_sec = 0;
 226     tv.tv_usec = 500000;
 227
 228     int res = select(sd + 1, &rfds, NULL, NULL, &tv);
 229
 230     if (res < 0)
 231         {
 232         // Error logging
 233         }
 234     else if (res == 0)
 235         {
 236         // Timeout
 237         }
 238     else
 239         {
 240         if (FD_ISSET(sd, &rfds))
 241             {
 242             AcceptConnection();
 243             }
 244         }
 245
 246     // Reorder: right part is done
 247     std::list<ConnectionThread *>::iterator done(
 248             std::remove_if(
 249                 connections.begin(),
 250                 connections.end(),
 251                 std::not1(std::mem_fun(&ConnectionThread::isDone))
 252             )
 253     );
 254     // Destruct done
 255     std::for_each(
 256             done,
 257             connections.end(),
 258             DeleteConnection());
 259     // Erase done
 260     std::erase(done, connections.end());
 261
 262     }
 263 stopped = true;
 264 }
 265
 266 void STG_CONFIG::AcceptConnection()
 267 {
 268 struct sockaddr_in remoteAddr;
 269 socklen_t len = sizeof(struct sockaddr_in);
 270 int rsd = accept(sd, &remoteAddr, &len);
 271
 272 if (rsd < 0)
 273     {
 274     // Error logging
 275     }
 276
 277 connections.push_back(new ConnectionThread(this, rsd, remoteAddr, users, admins, tariffs, store, stgSettings));
 278 }