]> git.vomp.tv Git - vompclient.git/blob - vdpc.cc
Control/main/winmain/util reorg
[vompclient.git] / vdpc.cc
1 /*
2     Copyright 2020 Chris Tallon
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP.  If not, see <https://www.gnu.org/licenses/>.
18 */
19
20 #ifndef WIN32
21   #include <unistd.h>
22   #include <fcntl.h>
23 #endif
24
25 #include <cstdlib>
26 #include <chrono>
27 #include <algorithm>
28
29 #include "log.h"
30 #include "wol.h"
31
32 #include "vdpc.h"
33
34 void VDPC::TEMPaddCLIServer(const std::string& cliServer)
35 {
36   std::lock_guard<std::mutex> lg(serversLock);
37   servers.emplace_back(4, cliServer, "", 3024, 0);
38 }
39
40 bool VDPC::init()
41 {
42   AddServerCallback addFunc( [this] (int ipVersion, const char* ip, const char* name, USHORT port, ULONG version)
43   {
44     std::lock_guard<std::mutex> lg(serversLock);
45
46     if (dedupServers)
47     {
48       UINT i = 0;
49       for (; i < servers.size(); i++)
50       {
51         if (servers[i].name == name) break;
52       }
53
54       if (i == servers.size())
55       {
56         servers.emplace_back(ipVersion, ip, name, port, version);
57       }
58       else
59       {
60         if (ipVersion == preferIPV) // delete the other
61         {
62           servers[i].ipVersion = ipVersion;
63           servers[i].ip = ip;
64           servers[i].name = name;
65           servers[i].port = port;
66           servers[i].version = version;
67         }
68       }
69
70     }
71     else
72     {
73       servers.emplace_back(ipVersion, ip, name, port, version);
74     }
75   });
76
77 #ifdef IPV4
78   if (!vdpc4.init(addFunc)) return false;
79 #endif
80 #ifdef IPV6
81   if (!vdpc6.init(addFunc)) return false;
82 #endif
83
84   return true;
85 }
86
87 int VDPC::go()
88 {
89   std::unique_lock<std::mutex> ul(waitMutex);
90
91   servers.clear();
92
93 #ifdef IPV4
94   vdpc4.run();
95 #endif
96 #ifdef IPV6
97   vdpc6.run();
98 #endif
99
100   do
101   {
102     Log::getInstance()->log("VDPC", Log::DEBUG, "Sending broadcasts");
103
104 #ifdef IPV4
105     vdpc4.sendRequest();
106 #endif
107 #ifdef IPV6
108     vdpc6.sendRequest();
109 #endif
110
111     waitCond.wait_for(ul, std::chrono::milliseconds(1500), [this]{ return stopNow == true; });
112     Log::getInstance()->log("VDPC", Log::DEBUG, "go() wait finished");
113
114     if (stopNow) break;
115     if (servers.size() == 0) Wol::getInstance()->doWakeUp();
116
117   } while(servers.size() < 1);
118
119 #ifdef IPV4
120     vdpc4.stop();
121 #endif
122 #ifdef IPV6
123     vdpc6.stop();
124 #endif
125
126   std::sort(servers.begin(), servers.end(), ServerSorter(preferIPV));
127   return servers.size();
128 }
129
130 void VDPC::stop()
131 {
132   std::lock_guard<std::mutex> lg(waitMutex);
133   stopNow = true;
134   waitCond.notify_one();
135 }
136
137 ULONG VDPC::numServers() const
138 {
139   return servers.size();
140 }
141
142 const VDRServer& VDPC::operator[](ULONG index) const
143 {
144   if (index >= servers.size()) std::abort();
145   return servers[index];
146 }
147
148 #ifdef IPV4
149
150 // ======================================= VDPC4
151
152 bool VDPC::VDPC4::init(AddServerCallback& taddFunc)
153 {
154   Log::getInstance()->log("VDPC4", Log::DEBUG, "init");
155   addFunc = taddFunc;
156
157   if (!udp4.init(0))
158   {
159     Log::getInstance()->log("VDPC4", Log::CRIT, "Failed to init VDPC4 UDP");
160     return false;
161   }
162
163   return true;
164 }
165
166 void VDPC::VDPC4::run()
167 {
168   Log::getInstance()->log("VDPC4", Log::DEBUG, "run");
169   stopNow = false;
170
171   startProtect.lock();
172   receiveThread = std::thread([this]
173   {
174     startProtect.lock();
175     startProtect.unlock();
176     threadMethod();
177   });
178   startProtect.unlock();
179 }
180
181 void VDPC::VDPC4::stop()
182 {
183   Log::getInstance()->log("VDPC4", Log::DEBUG, "stop");
184
185   stopNow = true;
186
187 #ifdef WIN32
188   CLOSESOCKET(quitPipe);
189 #else
190   write(pfdsUDP4[1], "X", 1);
191 #endif
192
193   receiveThread.join();
194
195 #ifndef WIN32
196   close(pfdsUDP4[0]);
197   close(pfdsUDP4[1]);
198 #endif
199 }
200
201 void VDPC::VDPC4::threadMethod()
202 {
203   Log* logger = Log::getInstance();
204
205 #ifdef WIN32
206   quitPipe = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
207   if (quitPipe == INVALID_SOCKET)
208   {
209     logger->log("VDPC4", Log::ERR, "socket() fail");
210     return;
211   }
212 #else
213   if (pipe2(pfdsUDP4, O_NONBLOCK) == -1)
214   {
215     logger->log("VDPC4", Log::ERR, "pipe2 error B");
216     return;
217   }
218 #endif
219
220   while (!stopNow)
221   {
222     Log::getInstance()->log("VDPC4", Log::DEBUG, "goto waitformessage");
223
224     #ifdef WIN32
225     UCHAR retval = udp4.waitforMessage(3, quitPipe);
226     #else
227     UCHAR retval = udp4.waitforMessage(3, pfdsUDP4[0]);
228     #endif
229     Log::getInstance()->log("VDPC4", Log::DEBUG, "backfrom waitformessage");
230
231     if (retval == 2) // we got a reply
232     {
233       const char* vdpreply = static_cast<const char*>(udp4.getData());
234       if ((udp4.getDataLength() >= 24) && !strncmp(vdpreply, "VDP-0002", 8))
235       {
236         // FIXME upgrade this to look for a return IP in the reply packet
237
238         USHORT newServerPort;
239         memcpy(&newServerPort, &vdpreply[26], 2);
240
241         ULONG newServerVersion;
242         memcpy(&newServerVersion, &vdpreply[28], 4);
243
244         // FIXME - packet length > 24 not checked, end NULL not checked!!
245         addFunc(4, udp4.getFromIPA(), &vdpreply[32], ntohs(newServerPort), ntohl(newServerVersion));
246       }
247     }
248
249     Log::getInstance()->log("VDPC4", Log::DEBUG, "loop stopnow = %i", stopNow);
250   }
251 }
252
253 void VDPC::VDPC4::sendRequest()
254 {
255   Log::getInstance()->log("VDPC4", Log::DEBUG, "broadcast");
256
257   char message[15];
258   memset(message, 0, 15);
259   strcpy(message, "VDP-0001");
260   /*tcp->getMAC(&message[9]); put mac here when TCP modified to do this*/
261
262   udp4.send("255.255.255.255", 51051U, message, 15);
263   udp4.send("255.255.255.255", 51052U, message, 15);
264   udp4.send("255.255.255.255", 51053U, message, 15);
265   udp4.send("255.255.255.255", 51054U, message, 15);
266   udp4.send("255.255.255.255", 51055U, message, 15);
267 }
268
269 #endif
270
271 #ifdef IPV6
272
273 // ======================================= VDPC6
274
275 bool VDPC::VDPC6::init(AddServerCallback& taddFunc)
276 {
277   Log::getInstance()->log("VDPC6", Log::DEBUG, "init");
278   addFunc = taddFunc;
279
280   if (!udp6.init(0))
281   {
282     Log::getInstance()->log("VDPC6", Log::CRIT, "Failed to init VDPC6 UDP");
283     return false;
284   }
285
286   return true;
287 }
288
289 void VDPC::VDPC6::run()
290 {
291   Log::getInstance()->log("VDPC6", Log::DEBUG, "run");
292   stopNow = false;
293
294   startProtect.lock();
295   receiveThread = std::thread([this]
296   {
297     startProtect.lock();
298     startProtect.unlock();
299     threadMethod();
300   });
301   startProtect.unlock();
302 }
303
304 void VDPC::VDPC6::stop()
305 {
306   Log::getInstance()->log("VDPC6", Log::DEBUG, "stop");
307
308   stopNow = true;
309   write(pfdsUDP6[1], "X", 1);
310   receiveThread.join();
311
312   close(pfdsUDP6[0]);
313   close(pfdsUDP6[1]);
314 }
315
316 void VDPC::VDPC6::threadMethod()
317 {
318   Log* logger = Log::getInstance();
319
320   if (pipe2(pfdsUDP6, O_NONBLOCK) == -1)
321   {
322     logger->log("VDPC6", Log::ERR, "pipe2 error B");
323     return;
324   }
325
326   while (!stopNow)
327   {
328     Log::getInstance()->log("VDPC6", Log::DEBUG, "goto waitformessage");
329
330     UCHAR retval = udp6.waitforMessage(3, pfdsUDP6[0]);
331     Log::getInstance()->log("VDPC6", Log::DEBUG, "backfrom waitformessage");
332
333     if (retval == 2) // we got a reply
334     {
335       const char* vdpreply = static_cast<const char*>(udp6.getData());
336       if ((udp6.getDataLength() >= 24) && !strncmp(vdpreply, "VDP-0002", 8))
337       {
338         // FIXME upgrade this to look for a return IP in the reply packet
339
340         USHORT newServerPort;
341         memcpy(&newServerPort, &vdpreply[26], 2);
342
343         ULONG newServerVersion;
344         memcpy(&newServerVersion, &vdpreply[28], 4);
345
346         // FIXME - packet length > 24 not checked, end NULL not checked!!
347         addFunc(6, udp6.getFromIPA(), &vdpreply[32], ntohs(newServerPort), ntohl(newServerVersion));
348       }
349     }
350
351     Log::getInstance()->log("VDPC6", Log::DEBUG, "loop stopnow = %i", stopNow);
352   }
353 }
354
355 void VDPC::VDPC6::sendRequest()
356 {
357   Log::getInstance()->log("VDPC6", Log::DEBUG, "broadcast");
358
359   char message[15];
360   memset(message, 0, 15);
361   strcpy(message, "VDP-0001");
362   /*tcp->getMAC(&message[9]); put mac here when TCP modified to do this*/
363
364   udp6.send("ff15:766f:6d70:2064:6973:636f:7665:7279", 51056U, message, 15, true);
365 }
366
367 #endif