projects/stargazer/plugins/other/userstat/datathread.cpp

   1 #include "datathread.h"
   2
   3 bool DataThread::Init()
   4 {
   5     parser = XML_ParserCreate(NULL);
   6     if (!parser) {
   7         printfd(__FILE__, "Error creating XML parser\n");
   8     }
   9     XML_SetStartElementHandler(parser, StartHandler);
  10     XML_SetEndElementHandler(parser, EndHandler);
  11     XML_SetCharacterDataHandler(parser, DataHandler);
  12 }
  13
  14 DataThread::~DataThread()
  15 {
  16     XML_ParserFree(parser);
  17 }
  18
  19 void * DataThread::Run(void * val)
  20 {
  21     DataThread * dt = reinterpret_cast<DataThread *>(val);
  22
  23     running = true;
  24     stoppped = false;
  25     while (running) {
  26         if (sock >= 0) {
  27             done = false;
  28             dt->Handle();
  29             done = true;
  30             close(sock);
  31             sock = -1;
  32         } else {
  33             usleep(1000);
  34         }
  35     }
  36     stopped = true;
  37     running = false;
  38
  39     return NULL;
  40 }
  41
  42 void DataThread::Handle()
  43 {
  44     int32_t size;
  45     unsigned char * buf;
  46
  47     if (!PrepareContext())
  48         return;
  49
  50     res = read(sock, &size, sizeof(size));
  51     if (res != sizeof(size))
  52     {
  53         printfd(__FILE__, "Reading stream size failed! Wanted %d bytes, got %d bytes.\n", sizeof(size), res);
  54         return;
  55     }
  56
  57     printfd(__FILE__, "DataThread::Handle() size = %d\n", size);
  58
  59     if (size < 0) {
  60         printfd(__FILE__, "DataThread::Handle() Invalid data size.\n");
  61         return;
  62     }
  63
  64     buf = new unsigned char[size];
  65     res = read(sock, buf, size);
  66     if (res != size)
  67     {
  68         printfd(__FILE__, "Reading stream failed! Wanted %d bytes, got %d bytes.\n", size, res);
  69         return;
  70     }
  71
  72     std::string data;
  73     Decode(buf, data, size);
  74
  75     printfd(__FILE__, "Received XML: %s\n", data.c_str());
  76
  77     XML_ParserReset(parser, NULL);
  78
  79     if (XML_Parse(parser, data.c_str(), data.length(), true) == XML_STATUS_OK) {
  80         SendReply();
  81     } else {
  82         SendError();
  83     }
  84
  85     delete[] buf;
  86
  87     return;
  88 }
  89
  90 bool DataThread::PrepareContext()
  91 {
  92     int32_t size;
  93     char * login;
  94
  95     int res = read(sock, &size, sizeof(size));
  96     if (res != sizeof(size))
  97     {
  98         printfd(__FILE__, "Reading stream size failed! Wanted %d bytes, got %d bytes.\n", sizeof(size), res);
  99         return;
 100     }
 101
 102     printfd(__FILE__, "DataThread::Handle() size = %d\n", size);
 103
 104     if (size < 0) {
 105         printfd(__FILE__, "DataThread::Handle() Invalid data size.\n");
 106         return;
 107     }
 108
 109     login = new char[size];
 110
 111     res = read(sock, login, size);
 112     if (res != size)
 113     {
 114         printfd(__FILE__, "Reading login failed! Wanted %d bytes, got %d bytes.\n", 32, res);
 115         return;
 116     }
 117
 118     std::string l;
 119     l.assign(login, size);
 120     delete[] login;
 121
 122     user_iter it;
 123     if (users->FindByName(l, &it))
 124     {
 125         printfd(__FILE__, "User '%s' not found.\n", login);
 126         return;
 127     }
 128
 129     password = it->property.password;
 130
 131     printfd(__FILE__, "DataThread::Handle() Requested user: '%s'\n", login);
 132     printfd(__FILE__, "DataThread::Handle() Encryption initiated using password: '%s'\n", password.c_str());
 133
 134     char * key = new char[password.length()];
 135     strncpy(key, password.c_str(), password.length());
 136
 137     Blowfish_Init(&ctx,
 138                   reinterpret_cast<unsigned char *>(key),
 139                   password.length());
 140     delete[] key;
 141
 142     return true;
 143 }
 144
 145 void DataThread::Encode(const std::string & src, char * dst, int size)
 146 {
 147     const char * ptr = src.c_str();
 148     for (int i = 0; i < size / 8; ++i) {
 149         uint32_t a;
 150         uint32_t b;
 151         a = n2l(ptr + i * 8);
 152         b = n2l(ptr + i * 8 + 4);
 153         Blowfish_Encrypt(&ctx,
 154                          &a,
 155                          &b);
 156         l2n(a, dst + i * 8);
 157         l2n(b, dst + i * 8 + 4);
 158     }
 159 }
 160
 161 void DataThread::Decode(char * src, std::string & dst, int size)
 162 {
 163     char tmp[9];
 164     tmp[8] = 0;
 165     dst = "";
 166
 167     for (int i = 0; i < size / 8; ++i) {
 168         uint32_t a;
 169         uint32_t b;
 170         a = n2l(src + i * 8);
 171         b = n2l(src + i * 8 + 4);
 172         Blowfish_Decrypt(&ctx,
 173                          &a,
 174                          &b);
 175         l2n(a, tmp);
 176         l2n(b, tmp + 4);
 177
 178         dst += tmp;
 179     }
 180 }
 181
 182 void StartHandler(void *data, const char *el, const char **attr)
 183 {
 184     printfd(__FILE__, "Node: %s\n", el);
 185 }
 186
 187 void EndHandler(void *data, const char *el)
 188 {
 189 }
 190
 191 void DataHandler(void *data, const char *el)
 192 {
 193 }