]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/other/userstat/datathread.cpp
40d44305e642100e7d1e24988d7bc090b8bcf5d2
[stg.git] / 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 }