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