| 446 |
andreas |
1 |
/*
|
|
|
2 |
* Copyright (C) 2018 to 2024 by Andreas Theofilu <andreas@theosys.at>
|
|
|
3 |
*
|
|
|
4 |
* This program is free software; you can redistribute it and/or modify
|
|
|
5 |
* it under the terms of the GNU General Public License as published by
|
|
|
6 |
* the Free Software Foundation; either version 3 of the License, or
|
|
|
7 |
* (at your option) any later version.
|
|
|
8 |
*
|
|
|
9 |
* This program is distributed in the hope that it will be useful,
|
|
|
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
12 |
* GNU General Public License for more details.
|
|
|
13 |
*
|
|
|
14 |
* You should have received a copy of the GNU General Public License
|
|
|
15 |
* along with this program; if not, write to the Free Software Foundation,
|
|
|
16 |
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
17 |
*/
|
|
|
18 |
|
|
|
19 |
#include <sys/utsname.h>
|
|
|
20 |
|
|
|
21 |
#include <functional>
|
|
|
22 |
#include <iostream>
|
|
|
23 |
#include <fstream>
|
|
|
24 |
#include <cstring>
|
|
|
25 |
#include <string>
|
|
|
26 |
#include <chrono>
|
|
|
27 |
#include <thread>
|
|
|
28 |
#include <mutex>
|
|
|
29 |
#include <map>
|
|
|
30 |
|
|
|
31 |
#include <sys/stat.h>
|
|
|
32 |
#include <sys/types.h>
|
|
|
33 |
#include <unistd.h>
|
|
|
34 |
|
|
|
35 |
#include "tamxnet.h"
|
|
|
36 |
#include "terror.h"
|
|
|
37 |
#include "tconfig.h"
|
|
|
38 |
#include "tdirectory.h"
|
|
|
39 |
#include "tresources.h"
|
|
|
40 |
#include "texpand.h"
|
|
|
41 |
#include "tsocket.h"
|
|
|
42 |
#include "texcept.h"
|
|
|
43 |
#include "tpagemanager.h"
|
|
|
44 |
|
|
|
45 |
using namespace amx;
|
|
|
46 |
using namespace std;
|
|
|
47 |
using std::mutex;
|
|
|
48 |
|
|
|
49 |
using placeholders::_1;
|
|
|
50 |
using placeholders::_2;
|
|
|
51 |
|
|
|
52 |
string cmdList[] =
|
|
|
53 |
{
|
|
|
54 |
"@WLD-", "@AFP-", "@GCE-", "@APG-", "@CPG-", "@DPG-", "@PDR-", "@PHE-",
|
|
|
55 |
"@PHP-", "@PHT-", "@PPA-", "@PPF-", "@PPG-", "@PPK-", "@PPM-", "@PPN-",
|
|
|
56 |
"@PPT-", "@PPX", "@PSE-", "@PSP-", "@PST-", "PAGE-", "PPOF-", "PPOG-",
|
|
|
57 |
"PPON-", "^ANI-", "^APF-", "^BAT-", "^BAU-", "^BCB-", "^BCF-", "^BCT-",
|
|
|
58 |
"^BDO-", "^BFB-", "^BIM-", "^BLN-", "^BMC-", "^BMF-", "^BMI-", "^BML-",
|
|
|
59 |
"^BMP-", "^BNC-", "^BNN-", "^BNT-", "^BOP-", "^BOR-", "^BOS-", "^BPP-",
|
|
|
60 |
"^BRD-", "^BSF-", "^BSP-", "^BSM-", "^BSO-", "^BVL-", "^BVN-", "^BVP-",
|
|
|
61 |
"^BVT-", "^BWW-", "^CPF-", "^DLD-", "^DPF-", "^ENA-", "^FON-", "^GDI-",
|
|
|
62 |
"^GIV-", "^GLH-", "^GLL-", "^GRD-", "^GRU-", "^GSC-", "^GSN-", "^ICO-",
|
|
|
63 |
"^IRM-", "^JSB-", "^JSI-", "^JST-", "^MBT-", "^MDC-", "^SHO-", "^TEC-",
|
|
|
64 |
"^TEF-", "^TOP-", "^TXT-", "^UNI-", "^LPC-", "^LPR-", "^LPS-", "?BCB-",
|
|
|
65 |
"?BCF-", "?BCT-", "?BMP-", "?BOP-", "?BRD-", "?BWW-", "?FON-", "?ICO-",
|
|
|
66 |
"?JSB-", "?JSI-", "?JST-", "?TEC-", "?TEF-", "?TXT-", "ABEEP", "ADBEEP",
|
|
|
67 |
"@AKB-", "AKEYB-", "AKEYP-", "AKEYR-", "@AKP-", "@AKR", "BEEP", "BRIT-",
|
|
|
68 |
"@BRT-", "DBEEP", "@EKP-", "PKEYP-", "@PKP-", "SETUP", "SHUTDOWN", "SLEEP",
|
|
|
69 |
"@SOU-", "@TKP-", "TPAGEON", "TPAGEOFF", "@VKB", "WAKE", "^CAL", "^KPS-",
|
|
|
70 |
"^VKS-", "@PWD-", "^PWD-", "^BBR-", "^RAF-", "^RFR-", "^RMF-", "^RSR-",
|
|
|
71 |
"^MODEL?", "^ICS-", "^ICE-", "^ICM-", "^PHN-", "?PHN-", "LEVON", "RXON",
|
|
|
72 |
"BLINK", "TPCCMD", "TPCACC", "^EPR", "^SCE", "^SDR", "^SHD", "^SSH",
|
|
|
73 |
"^STG", "^MSP", "^LPB", "^RPP",
|
|
|
74 |
// G5 commands
|
|
|
75 |
"^ABP-", "^ADB", "^SOU-", "^STP", "^TKP-", "^PGE-", "^PPA-", "^PPF-",
|
|
|
76 |
"^PPG-", "^PPK-", "^PPM-", "^PPN-", "^PPT-", "^PPX", "^UTF-", "^LVC-",
|
|
|
77 |
"^LVD-", "^LVE-", "^LVF-", "^LVL-", "^LVM-", "^LVN-", "^LVR-", "^LVS-",
|
|
|
78 |
"^MUT-", "\0"
|
|
|
79 |
};
|
|
|
80 |
|
|
|
81 |
#define NUMBER_CMDS 144
|
|
|
82 |
|
|
|
83 |
std::atomic<bool> killed{false};
|
|
|
84 |
std::atomic<bool> _netRunning{false};
|
|
|
85 |
amx::TAmxNet *gAmxNet = nullptr;
|
|
|
86 |
static bool __CommValid = false;
|
|
|
87 |
std::map<ulong, FUNC_NETWORK_t> mFuncsNetwork;
|
|
|
88 |
std::map<ulong, FUNC_TIMER_t> mFuncsTimer;
|
|
|
89 |
|
|
|
90 |
//std::vector<ANET_COMMAND> TAmxNet::comStack; // commands to answer
|
|
|
91 |
extern TPageManager *gPageManager;
|
|
|
92 |
|
|
|
93 |
//mutex read_mutex;
|
|
|
94 |
|
|
|
95 |
TAmxNet::TAmxNet()
|
|
|
96 |
{
|
|
|
97 |
DECL_TRACER("TAmxNet::TAmxNet()");
|
|
|
98 |
|
|
|
99 |
init();
|
|
|
100 |
}
|
|
|
101 |
|
|
|
102 |
TAmxNet::TAmxNet(const string& sn)
|
|
|
103 |
: serNum(sn)
|
|
|
104 |
{
|
|
|
105 |
DECL_TRACER("TAmxNet::TAmxNet(const string& sn)");
|
|
|
106 |
|
|
|
107 |
init();
|
|
|
108 |
}
|
|
|
109 |
|
|
|
110 |
TAmxNet::TAmxNet(const string& sn, const string& nm)
|
|
|
111 |
: panName(nm),
|
|
|
112 |
serNum(sn)
|
|
|
113 |
{
|
|
|
114 |
DECL_TRACER("TAmxNet::TAmxNet(const string& sn)");
|
|
|
115 |
|
|
|
116 |
size_t pos = nm.find(" (TPC)");
|
|
|
117 |
|
|
|
118 |
if (pos != string::npos)
|
|
|
119 |
{
|
|
|
120 |
panName = nm.substr(0, pos) + "i";
|
|
|
121 |
MSG_TRACE("Converted TP name: " << panName);
|
|
|
122 |
}
|
|
|
123 |
|
|
|
124 |
init();
|
|
|
125 |
}
|
|
|
126 |
|
|
|
127 |
TAmxNet::~TAmxNet()
|
|
|
128 |
{
|
|
|
129 |
DECL_TRACER("TAmxNet::~TAmxNet()");
|
|
|
130 |
|
|
|
131 |
callback = 0;
|
|
|
132 |
write_busy = false;
|
|
|
133 |
stop();
|
|
|
134 |
|
|
|
135 |
if (mSocket)
|
|
|
136 |
{
|
|
|
137 |
delete mSocket;
|
|
|
138 |
mSocket = nullptr;
|
|
|
139 |
__CommValid = false;
|
|
|
140 |
}
|
|
|
141 |
|
|
|
142 |
gAmxNet = nullptr;
|
|
|
143 |
}
|
|
|
144 |
|
|
|
145 |
void TAmxNet::init()
|
|
|
146 |
{
|
|
|
147 |
DECL_TRACER("TAmxNet::init()");
|
|
|
148 |
|
|
|
149 |
sendCounter = 0;
|
|
|
150 |
initSend = false;
|
|
|
151 |
ready = false;
|
|
|
152 |
|
|
|
153 |
callback = 0;
|
|
|
154 |
stopped_ = false;
|
|
|
155 |
write_busy = false;
|
|
|
156 |
gAmxNet = this;
|
|
|
157 |
|
|
|
158 |
if (!mSocket)
|
|
|
159 |
{
|
|
|
160 |
mSocket = new TSocket;
|
|
|
161 |
__CommValid = true;
|
|
|
162 |
}
|
|
|
163 |
|
|
|
164 |
string version = "v2.01.00"; // A version > 2.0 is needed for file transfer!
|
|
|
165 |
int devID = 0x0163, fwID = 0x0290;
|
|
|
166 |
|
|
|
167 |
if (TConfig::getPanelType().length() > 0)
|
|
|
168 |
panName = TConfig::getPanelType();
|
|
|
169 |
else if (panName.empty())
|
|
|
170 |
panName.assign("TheoSys");
|
|
|
171 |
|
|
|
172 |
if (panName.find("MVP") != string::npos && panName.find("5200") != string::npos)
|
|
|
173 |
{
|
|
|
174 |
devID = 0x0149;
|
|
|
175 |
fwID = 0x0310;
|
|
|
176 |
}
|
|
|
177 |
else if (panName.find("NX-CV7") != string::npos)
|
|
|
178 |
{
|
|
|
179 |
devID = 0x0123;
|
|
|
180 |
fwID = 0x0135;
|
|
|
181 |
}
|
|
|
182 |
|
|
|
183 |
// Initialize the devive info structure
|
|
|
184 |
DEVICE_INFO di;
|
|
|
185 |
// Answer to MC = 0x0017 --> MC = 0x0097
|
|
|
186 |
di.objectID = 0;
|
|
|
187 |
di.parentID = 0;
|
|
|
188 |
di.manufacturerID = 1;
|
|
|
189 |
di.deviceID = devID;
|
|
|
190 |
memset(di.serialNum, 0, sizeof(di.serialNum));
|
|
|
191 |
|
|
|
192 |
if (!serNum.empty())
|
|
|
193 |
memcpy(di.serialNum, serNum.c_str(), serNum.length());
|
|
|
194 |
|
|
|
195 |
di.firmwareID = fwID;
|
|
|
196 |
memset(di.versionInfo, 0, sizeof(di.versionInfo));
|
|
|
197 |
strncpy(di.versionInfo, version.c_str(), version.length());
|
|
|
198 |
memset(di.deviceInfo, 0, sizeof(di.deviceInfo));
|
|
|
199 |
strncpy(di.deviceInfo, panName.c_str(), min(panName.length(), sizeof(di.deviceInfo) - 1));
|
|
|
200 |
memset(di.manufacturerInfo, 0, sizeof(di.manufacturerInfo));
|
|
|
201 |
strncpy(di.manufacturerInfo, "TheoSys", 7);
|
|
|
202 |
di.format = 2;
|
|
|
203 |
di.len = 4;
|
|
|
204 |
memset(di.addr, 0, sizeof(di.addr));
|
|
|
205 |
devInfo.push_back(di);
|
|
|
206 |
// Kernel info
|
|
|
207 |
di.objectID = 2;
|
|
|
208 |
di.firmwareID = fwID + 1;
|
|
|
209 |
memset(di.serialNum, 0x20, sizeof(di.serialNum));
|
|
|
210 |
memcpy(di.serialNum, "N/A", 3);
|
|
|
211 |
memset(di.deviceInfo, 0, sizeof(di.deviceInfo));
|
|
|
212 |
strncpy(di.deviceInfo, "Kernel", 6);
|
|
|
213 |
memset(di.versionInfo, 0, sizeof(di.versionInfo));
|
|
|
214 |
#ifdef __linux__
|
|
|
215 |
struct utsname kinfo;
|
|
|
216 |
uname(&kinfo);
|
|
|
217 |
strncpy(di.versionInfo, kinfo.release, sizeof(di.versionInfo));
|
|
|
218 |
char *ppos = strnstr(di.versionInfo, "-", sizeof(di.versionInfo));
|
|
|
219 |
|
|
|
220 |
if (ppos && (ppos - di.versionInfo) < 16)
|
|
|
221 |
*ppos = 0;
|
|
|
222 |
#else
|
|
|
223 |
strncpy(di.versionInfo, "4.00.00", 7);
|
|
|
224 |
#endif
|
|
|
225 |
devInfo.push_back(di);
|
|
|
226 |
}
|
|
|
227 |
|
|
|
228 |
void TAmxNet::registerNetworkState(function<void (int)> registerNetwork, ulong handle)
|
|
|
229 |
{
|
|
|
230 |
DECL_TRACER("TAmxNet::registerNetworkState(function<void (int)> registerNetwork, ulong handle)");
|
|
|
231 |
|
|
|
232 |
map<ulong, FUNC_NETWORK_t>::iterator iter = mFuncsNetwork.find(handle);
|
|
|
233 |
|
|
|
234 |
if (mFuncsNetwork.size() == 0 || iter == mFuncsNetwork.end())
|
|
|
235 |
{
|
|
|
236 |
FUNC_NETWORK_t fn;
|
|
|
237 |
fn.handle = handle;
|
|
|
238 |
fn.func = registerNetwork;
|
|
|
239 |
mFuncsNetwork.insert(pair<ulong, FUNC_NETWORK_t>(handle, fn));
|
|
|
240 |
}
|
|
|
241 |
|
|
|
242 |
registerNetwork((isRunning() ? NSTATE_ONLINE : NSTATE_OFFLINE));
|
|
|
243 |
}
|
|
|
244 |
|
|
|
245 |
void TAmxNet::registerTimer(function<void (const ANET_BLINK &)> registerBlink, ulong handle)
|
|
|
246 |
{
|
|
|
247 |
DECL_TRACER("TAmxNet::registerTimer(function<void (const ANET_BLINK &)> registerBlink, ulong handle)");
|
|
|
248 |
|
|
|
249 |
map<ulong, FUNC_TIMER_t>::iterator iter = mFuncsTimer.find(handle);
|
|
|
250 |
|
|
|
251 |
if (mFuncsTimer.size() == 0 || iter == mFuncsTimer.end())
|
|
|
252 |
{
|
|
|
253 |
FUNC_TIMER_t ft;
|
|
|
254 |
ft.handle = handle;
|
|
|
255 |
ft.func = registerBlink;
|
|
|
256 |
mFuncsTimer.insert(pair<ulong, FUNC_TIMER_t>(handle, ft));
|
|
|
257 |
}
|
|
|
258 |
}
|
|
|
259 |
|
|
|
260 |
void TAmxNet::deregNetworkState(ulong handle)
|
|
|
261 |
{
|
|
|
262 |
DECL_TRACER("TAmxNet::deregNetworkState(ulong handle)");
|
|
|
263 |
|
|
|
264 |
if (mFuncsNetwork.size() == 0)
|
|
|
265 |
return;
|
|
|
266 |
|
|
|
267 |
map<ulong, FUNC_NETWORK_t>::iterator iter = mFuncsNetwork.find(handle);
|
|
|
268 |
|
|
|
269 |
if (iter != mFuncsNetwork.end())
|
|
|
270 |
mFuncsNetwork.erase(iter);
|
|
|
271 |
}
|
|
|
272 |
|
|
|
273 |
void TAmxNet::deregTimer(ulong handle)
|
|
|
274 |
{
|
|
|
275 |
DECL_TRACER("TAmxNet::deregTimer(ulong handle)");
|
|
|
276 |
|
|
|
277 |
if (mFuncsTimer.size() == 0)
|
|
|
278 |
return;
|
|
|
279 |
|
|
|
280 |
map<ulong, FUNC_TIMER_t>::iterator iter = mFuncsTimer.find(handle);
|
|
|
281 |
|
|
|
282 |
if (iter != mFuncsTimer.end())
|
|
|
283 |
mFuncsTimer.erase(iter);
|
|
|
284 |
}
|
|
|
285 |
|
|
|
286 |
void TAmxNet::stop(bool soft)
|
|
|
287 |
{
|
|
|
288 |
DECL_TRACER("TAmxNet::stop: Stopping the client...");
|
|
|
289 |
|
|
|
290 |
if (stopped_)
|
|
|
291 |
return;
|
|
|
292 |
|
|
|
293 |
if (!soft)
|
|
|
294 |
stopped_ = true;
|
|
|
295 |
|
|
|
296 |
if (mSocket)
|
|
|
297 |
mSocket->close();
|
|
|
298 |
}
|
|
|
299 |
|
|
|
300 |
bool TAmxNet::reconnect()
|
|
|
301 |
{
|
|
|
302 |
DECL_TRACER("TAmxNet::reconnect()");
|
|
|
303 |
|
|
|
304 |
if (!mSocket || !__CommValid)
|
|
|
305 |
return false;
|
|
|
306 |
|
|
|
307 |
mSocket->close();
|
|
|
308 |
initSend = false;
|
|
|
309 |
ready = false;
|
|
|
310 |
return true;
|
|
|
311 |
}
|
|
|
312 |
|
|
|
313 |
bool TAmxNet::isNetRun()
|
|
|
314 |
{
|
|
|
315 |
return _netRunning;
|
|
|
316 |
}
|
|
|
317 |
|
|
|
318 |
void TAmxNet::Run()
|
|
|
319 |
{
|
|
|
320 |
DECL_TRACER("TAmxNet::Run()");
|
|
|
321 |
|
|
|
322 |
if (_netRunning || !__CommValid)
|
|
|
323 |
return;
|
|
|
324 |
|
|
|
325 |
_netRunning = true;
|
|
|
326 |
stopped_ = false;
|
|
|
327 |
_retry = false;
|
|
|
328 |
|
|
|
329 |
try
|
|
|
330 |
{
|
|
|
331 |
mThread = std::thread([=] { this->start(); });
|
|
|
332 |
mThread.detach();
|
|
|
333 |
}
|
|
|
334 |
catch (std::exception& e)
|
|
|
335 |
{
|
|
|
336 |
MSG_ERROR("Error connecting to " << TConfig::getController() << ":" << to_string(TConfig::getPort()) << " [" << e.what() << "]");
|
|
|
337 |
_netRunning = false;
|
|
|
338 |
}
|
|
|
339 |
}
|
|
|
340 |
|
|
|
341 |
/*
|
|
|
342 |
* This function is running as a thread. It is the main method connecting to
|
|
|
343 |
* a controller and it handles all the communication with the controller.
|
|
|
344 |
*/
|
|
|
345 |
void TAmxNet::start()
|
|
|
346 |
{
|
|
|
347 |
DECL_TRACER("TAmxNet::start()");
|
|
|
348 |
|
|
|
349 |
sendAllFuncNetwork(NSTATE_CONNECTING);
|
|
|
350 |
|
|
|
351 |
while (__CommValid && mSocket && isRunning())
|
|
|
352 |
{
|
|
|
353 |
initSend = false;
|
|
|
354 |
ready = false;
|
|
|
355 |
|
|
|
356 |
if (__CommValid && TConfig::getController() == "0.0.0.0")
|
|
|
357 |
{
|
|
|
358 |
string controller = TConfig::getController();
|
|
|
359 |
MSG_INFO("Refusing to connect to invalid controller " << controller);
|
|
|
360 |
sendAllFuncNetwork(mLastOnlineState == NSTATE_OFFLINE ? NSTATE_OFFLINE1 : NSTATE_OFFLINE);
|
|
|
361 |
std::this_thread::sleep_for(std::chrono::seconds(10)); // Wait 10 seconds before next try
|
|
|
362 |
continue;
|
|
|
363 |
}
|
|
|
364 |
|
|
|
365 |
if (__CommValid && mSocket && !mSocket->connect(TConfig::getController(), TConfig::getPort()))
|
|
|
366 |
{
|
|
|
367 |
MSG_DEBUG("Connection failed. Retrying ...");
|
|
|
368 |
sendAllFuncNetwork(NSTATE_OFFLINE);
|
|
|
369 |
std::this_thread::sleep_for(std::chrono::seconds(mWaitTime));
|
|
|
370 |
setWaitTime(WAIT_RESET);
|
|
|
371 |
continue;
|
|
|
372 |
}
|
|
|
373 |
else if (!mSocket)
|
|
|
374 |
break;
|
|
|
375 |
|
|
|
376 |
sendAllFuncNetwork(NSTATE_ONLINE);
|
|
|
377 |
|
|
|
378 |
if (__CommValid && isRunning() && gPageManager && gPageManager->getRepaintWindows())
|
|
|
379 |
gPageManager->getRepaintWindows()();
|
|
|
380 |
|
|
|
381 |
handle_connect();
|
|
|
382 |
std::this_thread::sleep_for(std::chrono::seconds(mWaitTime));
|
|
|
383 |
setWaitTime(WAIT_RESET);
|
|
|
384 |
MSG_INFO("Network will be reestablished ...");
|
|
|
385 |
}
|
|
|
386 |
|
|
|
387 |
_netRunning = false;
|
|
|
388 |
}
|
|
|
389 |
|
|
|
390 |
void TAmxNet::handle_connect()
|
|
|
391 |
{
|
|
|
392 |
DECL_TRACER("TAmxNet::handle_connect()");
|
|
|
393 |
|
|
|
394 |
try
|
|
|
395 |
{
|
|
|
396 |
while (__CommValid && mSocket && isRunning() && mSocket->isConnected())
|
|
|
397 |
{
|
|
|
398 |
// Start the input actor.
|
|
|
399 |
start_read();
|
|
|
400 |
|
|
|
401 |
// Start the output actor.
|
|
|
402 |
if (isRunning() && !write_busy)
|
|
|
403 |
runWrite();
|
|
|
404 |
}
|
|
|
405 |
|
|
|
406 |
if (!stopped_ && (killed || prg_stopped))
|
|
|
407 |
stop();
|
|
|
408 |
}
|
|
|
409 |
catch (std::exception& e)
|
|
|
410 |
{
|
|
|
411 |
MSG_ERROR("Error: " << e.what());
|
|
|
412 |
|
|
|
413 |
if (mSocket)
|
|
|
414 |
mSocket->close();
|
|
|
415 |
}
|
|
|
416 |
catch (TXceptComm& e)
|
|
|
417 |
{
|
|
|
418 |
if (mSocket)
|
|
|
419 |
mSocket->close();
|
|
|
420 |
}
|
|
|
421 |
|
|
|
422 |
sendAllFuncNetwork(NSTATE_CONNECTING);
|
|
|
423 |
setWaitTime(WAIT_RECONNECT);
|
|
|
424 |
}
|
|
|
425 |
|
|
|
426 |
void TAmxNet::start_read()
|
|
|
427 |
{
|
|
|
428 |
DECL_TRACER("TAmxNet::start_read()");
|
|
|
429 |
|
|
|
430 |
if (!__CommValid || !mSocket || !isRunning() || !mSocket->isConnected())
|
|
|
431 |
return;
|
|
|
432 |
|
|
|
433 |
string _message = "TAmxNet::start_read(): Invalid argument received!";
|
|
|
434 |
protError = false;
|
|
|
435 |
comm.clear();
|
|
|
436 |
|
|
|
437 |
try
|
|
|
438 |
{
|
|
|
439 |
// Read the first byte. It should be 0x02
|
|
|
440 |
if (mSocket->readAbsolut(buff_, 1) == 1)
|
|
|
441 |
handle_read(1, RT_ID);
|
|
|
442 |
else if (mSocket->isConnected())
|
|
|
443 |
{
|
|
|
444 |
_message.append(" [RT_ID]");
|
|
|
445 |
XCEPTCOMM(_message);
|
|
|
446 |
}
|
|
|
447 |
else
|
|
|
448 |
{
|
|
|
449 |
setWaitTime(WAIT_RECONNECT);
|
|
|
450 |
return;
|
|
|
451 |
}
|
|
|
452 |
|
|
|
453 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
454 |
handle_read(2, RT_LEN);
|
|
|
455 |
else if (mSocket->isConnected())
|
|
|
456 |
{
|
|
|
457 |
_message.append(" [RT_LEN]");
|
|
|
458 |
XCEPTCOMM(_message);
|
|
|
459 |
}
|
|
|
460 |
else
|
|
|
461 |
{
|
|
|
462 |
setWaitTime(WAIT_RECONNECT);
|
|
|
463 |
return;
|
|
|
464 |
}
|
|
|
465 |
|
|
|
466 |
if (mSocket->readAbsolut(buff_, 1) == 1)
|
|
|
467 |
handle_read(1, RT_SEP1);
|
|
|
468 |
else if (mSocket->isConnected())
|
|
|
469 |
{
|
|
|
470 |
_message.append(" [RT_SEP1]");
|
|
|
471 |
XCEPTCOMM(_message);
|
|
|
472 |
}
|
|
|
473 |
else
|
|
|
474 |
{
|
|
|
475 |
setWaitTime(WAIT_RECONNECT);
|
|
|
476 |
return;
|
|
|
477 |
}
|
|
|
478 |
|
|
|
479 |
if (mSocket->readAbsolut(buff_, 1) == 1)
|
|
|
480 |
handle_read(1, RT_TYPE);
|
|
|
481 |
else if (mSocket->isConnected())
|
|
|
482 |
{
|
|
|
483 |
_message.append(" [RT_TYPE]");
|
|
|
484 |
XCEPTCOMM(_message);
|
|
|
485 |
}
|
|
|
486 |
else
|
|
|
487 |
{
|
|
|
488 |
setWaitTime(WAIT_RECONNECT);
|
|
|
489 |
return;
|
|
|
490 |
}
|
|
|
491 |
|
|
|
492 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
493 |
handle_read(2, RT_WORD1);
|
|
|
494 |
else if (mSocket->isConnected())
|
|
|
495 |
{
|
|
|
496 |
_message.append(" [RT_WORD1]");
|
|
|
497 |
XCEPTCOMM(_message);
|
|
|
498 |
}
|
|
|
499 |
else
|
|
|
500 |
{
|
|
|
501 |
setWaitTime(30);
|
|
|
502 |
return;
|
|
|
503 |
}
|
|
|
504 |
|
|
|
505 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
506 |
handle_read(2, RT_DEVICE);
|
|
|
507 |
else if (mSocket->isConnected())
|
|
|
508 |
{
|
|
|
509 |
_message.append(" [RT_DEVIVE]");
|
|
|
510 |
XCEPTCOMM(_message);
|
|
|
511 |
}
|
|
|
512 |
else
|
|
|
513 |
{
|
|
|
514 |
setWaitTime(WAIT_RECONNECT);
|
|
|
515 |
return;
|
|
|
516 |
}
|
|
|
517 |
|
|
|
518 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
519 |
handle_read(2, RT_WORD2);
|
|
|
520 |
else if (mSocket->isConnected())
|
|
|
521 |
{
|
|
|
522 |
_message.append(" [RT_WORD2]");
|
|
|
523 |
XCEPTCOMM(_message);
|
|
|
524 |
}
|
|
|
525 |
else
|
|
|
526 |
{
|
|
|
527 |
setWaitTime(WAIT_RECONNECT);
|
|
|
528 |
return;
|
|
|
529 |
}
|
|
|
530 |
|
|
|
531 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
532 |
handle_read(2, RT_WORD3);
|
|
|
533 |
else if (mSocket->isConnected())
|
|
|
534 |
{
|
|
|
535 |
_message.append(" [RT_WORD3]");
|
|
|
536 |
XCEPTCOMM(_message);
|
|
|
537 |
}
|
|
|
538 |
else
|
|
|
539 |
{
|
|
|
540 |
setWaitTime(WAIT_RECONNECT);
|
|
|
541 |
return;
|
|
|
542 |
}
|
|
|
543 |
|
|
|
544 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
545 |
handle_read(2, RT_WORD4);
|
|
|
546 |
else if (mSocket->isConnected())
|
|
|
547 |
{
|
|
|
548 |
_message.append(" [RT_WORD4]");
|
|
|
549 |
XCEPTCOMM(_message);
|
|
|
550 |
}
|
|
|
551 |
else
|
|
|
552 |
{
|
|
|
553 |
setWaitTime(WAIT_RECONNECT);
|
|
|
554 |
return;
|
|
|
555 |
}
|
|
|
556 |
|
|
|
557 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
558 |
handle_read(2, RT_WORD5);
|
|
|
559 |
else if (mSocket->isConnected())
|
|
|
560 |
{
|
|
|
561 |
_message.append(" [RT_WORD5]");
|
|
|
562 |
XCEPTCOMM(_message);
|
|
|
563 |
}
|
|
|
564 |
else
|
|
|
565 |
{
|
|
|
566 |
setWaitTime(WAIT_RECONNECT);
|
|
|
567 |
return;
|
|
|
568 |
}
|
|
|
569 |
|
|
|
570 |
if (mSocket->readAbsolut(buff_, 1) == 1)
|
|
|
571 |
handle_read(1, RT_SEP2);
|
|
|
572 |
else if (mSocket->isConnected())
|
|
|
573 |
{
|
|
|
574 |
_message.append(" [RT_SEP2]");
|
|
|
575 |
XCEPTCOMM(_message);
|
|
|
576 |
}
|
|
|
577 |
else
|
|
|
578 |
{
|
|
|
579 |
setWaitTime(WAIT_RECONNECT);
|
|
|
580 |
return;
|
|
|
581 |
}
|
|
|
582 |
|
|
|
583 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
584 |
handle_read(2, RT_COUNT);
|
|
|
585 |
else if (mSocket->isConnected())
|
|
|
586 |
{
|
|
|
587 |
_message.append(" [RT_COUNT]");
|
|
|
588 |
XCEPTCOMM(_message);
|
|
|
589 |
}
|
|
|
590 |
else
|
|
|
591 |
{
|
|
|
592 |
setWaitTime(WAIT_RECONNECT);
|
|
|
593 |
return;
|
|
|
594 |
}
|
|
|
595 |
|
|
|
596 |
if (mSocket->readAbsolut(buff_, 2) == 2)
|
|
|
597 |
handle_read(2, RT_MC);
|
|
|
598 |
else if (mSocket->isConnected())
|
|
|
599 |
{
|
|
|
600 |
_message.append(" [RT_MC]");
|
|
|
601 |
XCEPTCOMM(_message);
|
|
|
602 |
}
|
|
|
603 |
else
|
|
|
604 |
{
|
|
|
605 |
setWaitTime(WAIT_RECONNECT);
|
|
|
606 |
return;
|
|
|
607 |
}
|
|
|
608 |
|
|
|
609 |
// Calculate the length of the data block. This is the rest of the total length
|
|
|
610 |
size_t len = (comm.hlen + 3) - 0x0015;
|
|
|
611 |
|
|
|
612 |
if (mSocket->isConnected() && len > BUF_SIZE)
|
|
|
613 |
{
|
|
|
614 |
_message = "Length to read is " + to_string(len) + " bytes, but the buffer is only " + to_string(BUF_SIZE) + " bytes!";
|
|
|
615 |
XCEPTCOMM(_message);
|
|
|
616 |
}
|
|
|
617 |
else if (!mSocket->isConnected())
|
|
|
618 |
{
|
|
|
619 |
setWaitTime(WAIT_RECONNECT);
|
|
|
620 |
return;
|
|
|
621 |
}
|
|
|
622 |
|
|
|
623 |
if (mSocket->readAbsolut(buff_, len) == len)
|
|
|
624 |
handle_read(len, RT_DATA);
|
|
|
625 |
else if (mSocket->isConnected())
|
|
|
626 |
{
|
|
|
627 |
_message.append(" [RT_DATA]");
|
|
|
628 |
XCEPTCOMM(_message);
|
|
|
629 |
}
|
|
|
630 |
}
|
|
|
631 |
catch (TXceptNetwork& e)
|
|
|
632 |
{
|
|
|
633 |
setWaitTime(WAIT_RECONNECT);
|
|
|
634 |
}
|
|
|
635 |
}
|
|
|
636 |
|
|
|
637 |
void TAmxNet::handle_read(size_t n, R_TOKEN tk)
|
|
|
638 |
{
|
|
|
639 |
DECL_TRACER("TAmxNet::handle_read(const error_code& error, size_t n, R_TOKEN tk)");
|
|
|
640 |
|
|
|
641 |
if (stopped_ || !__CommValid || !mSocket || !mSocket->isConnected())
|
|
|
642 |
return;
|
|
|
643 |
|
|
|
644 |
if (killed || prg_stopped)
|
|
|
645 |
{
|
|
|
646 |
stop();
|
|
|
647 |
return;
|
|
|
648 |
}
|
|
|
649 |
|
|
|
650 |
uint32_t dw;
|
|
|
651 |
int val, pos;
|
|
|
652 |
size_t len;
|
|
|
653 |
ANET_SEND s; // Used to answer system requests
|
|
|
654 |
string cmd;
|
|
|
655 |
|
|
|
656 |
len = (n < BUF_SIZE) ? n : BUF_SIZE - 1;
|
|
|
657 |
input_buffer_.assign((char *)&buff_[0], len);
|
|
|
658 |
|
|
|
659 |
MSG_DEBUG("Token: " << tk << ", " << len << " bytes");
|
|
|
660 |
|
|
|
661 |
switch (tk)
|
|
|
662 |
{
|
|
|
663 |
case RT_ID:
|
|
|
664 |
if (buff_[0] != 0x02)
|
|
|
665 |
protError = true;
|
|
|
666 |
else
|
|
|
667 |
comm.ID = buff_[0];
|
|
|
668 |
break;
|
|
|
669 |
|
|
|
670 |
case RT_LEN: comm.hlen = makeWord(buff_[0], buff_[1]); break;
|
|
|
671 |
|
|
|
672 |
case RT_SEP1:
|
|
|
673 |
if (buff_[0] != 0x02)
|
|
|
674 |
protError = true;
|
|
|
675 |
else
|
|
|
676 |
comm.sep1 = buff_[0];
|
|
|
677 |
break;
|
|
|
678 |
|
|
|
679 |
case RT_TYPE: comm.type = buff_[0]; break;
|
|
|
680 |
case RT_WORD1: comm.unk1 = makeWord(buff_[0], buff_[1]); break;
|
|
|
681 |
case RT_DEVICE: comm.device1 = makeWord(buff_[0], buff_[1]); break;
|
|
|
682 |
case RT_WORD2: comm.port1 = makeWord(buff_[0], buff_[1]); break;
|
|
|
683 |
case RT_WORD3: comm.system = makeWord(buff_[0], buff_[1]); break;
|
|
|
684 |
case RT_WORD4: comm.device2 = makeWord(buff_[0], buff_[1]); break;
|
|
|
685 |
case RT_WORD5: comm.port2 = makeWord(buff_[0], buff_[1]); break;
|
|
|
686 |
|
|
|
687 |
case RT_SEP2:
|
|
|
688 |
if (buff_[0] != 0x0f)
|
|
|
689 |
protError = true;
|
|
|
690 |
else
|
|
|
691 |
comm.unk6 = buff_[0];
|
|
|
692 |
break;
|
|
|
693 |
|
|
|
694 |
case RT_COUNT: comm.count = makeWord(buff_[0], buff_[1]); break;
|
|
|
695 |
case RT_MC: comm.MC = makeWord(buff_[0], buff_[1]); break;
|
|
|
696 |
|
|
|
697 |
case RT_DATA:
|
|
|
698 |
if (protError || !isRunning())
|
|
|
699 |
break;
|
|
|
700 |
|
|
|
701 |
MSG_DEBUG("Received message type: 0x" << std::setw(4) << std::setfill('0') << std::hex << comm.MC);
|
|
|
702 |
|
|
|
703 |
switch (comm.MC)
|
|
|
704 |
{
|
|
|
705 |
case 0x0001: // ACK
|
|
|
706 |
case 0x0002: // NAK
|
|
|
707 |
comm.checksum = buff_[0];
|
|
|
708 |
break;
|
|
|
709 |
|
|
|
710 |
case 0x0084: // input channel ON
|
|
|
711 |
case 0x0085: // input channel OFF
|
|
|
712 |
case 0x0006: // output channel ON
|
|
|
713 |
case 0x0086: // output channel ON status
|
|
|
714 |
case 0x0007: // output channel OFF
|
|
|
715 |
case 0x0087: // output channel OFF status
|
|
|
716 |
case 0x0088: // input/output channel ON status
|
|
|
717 |
case 0x0089: // input/output channel OFF status
|
|
|
718 |
case 0x0018: // feedback channel ON
|
|
|
719 |
case 0x0019: // feedback channel OFF
|
|
|
720 |
comm.data.chan_state.device = makeWord(buff_[0], buff_[1]);
|
|
|
721 |
comm.data.chan_state.port = makeWord(buff_[2], buff_[3]);
|
|
|
722 |
comm.data.chan_state.system = makeWord(buff_[4], buff_[5]);
|
|
|
723 |
comm.data.chan_state.channel = makeWord(buff_[6], buff_[7]);
|
|
|
724 |
comm.checksum = buff_[8];
|
|
|
725 |
|
|
|
726 |
s.channel = comm.data.chan_state.channel;
|
|
|
727 |
s.level = 0;
|
|
|
728 |
s.port = comm.data.chan_state.port;
|
|
|
729 |
s.value = 0;
|
|
|
730 |
|
|
|
731 |
switch (comm.MC)
|
|
|
732 |
{
|
|
|
733 |
case 0x0006: s.MC = 0x0086; break;
|
|
|
734 |
case 0x0007: s.MC = 0x0087; break;
|
|
|
735 |
}
|
|
|
736 |
|
|
|
737 |
if (comm.MC < 0x0020)
|
|
|
738 |
{
|
|
|
739 |
if (callback)
|
|
|
740 |
callback(comm);
|
|
|
741 |
else
|
|
|
742 |
MSG_WARNING("Missing callback function!");
|
|
|
743 |
}
|
|
|
744 |
else
|
|
|
745 |
sendCommand(s);
|
|
|
746 |
break;
|
|
|
747 |
|
|
|
748 |
case 0x000a: // level value change
|
|
|
749 |
case 0x008a:
|
|
|
750 |
comm.data.message_value.device = makeWord(buff_[0], buff_[1]);
|
|
|
751 |
comm.data.message_value.port = makeWord(buff_[2], buff_[3]);
|
|
|
752 |
comm.data.message_value.system = makeWord(buff_[4], buff_[5]);
|
|
|
753 |
comm.data.message_value.value = makeWord(buff_[6], buff_[7]);
|
|
|
754 |
comm.data.message_value.type = buff_[8];
|
|
|
755 |
val = (int)buff_[8];
|
|
|
756 |
|
|
|
757 |
switch (val)
|
|
|
758 |
{
|
|
|
759 |
case 0x010: comm.data.message_value.content.byte = buff_[9]; comm.checksum = buff_[10]; break;
|
|
|
760 |
case 0x011: comm.data.message_value.content.ch = buff_[9]; comm.checksum = buff_[10]; break;
|
|
|
761 |
case 0x020: comm.data.message_value.content.integer = makeWord(buff_[9], buff_[10]); comm.checksum = buff_[11]; break;
|
|
|
762 |
case 0x021: comm.data.message_value.content.sinteger = makeWord(buff_[9], buff_[10]); comm.checksum = buff_[11]; break;
|
|
|
763 |
case 0x040: comm.data.message_value.content.dword = makeDWord(buff_[9], buff_[10], buff_[11], buff_[12]); comm.checksum = buff_[13]; break;
|
|
|
764 |
case 0x041: comm.data.message_value.content.sdword = makeDWord(buff_[9], buff_[10], buff_[11], buff_[12]); comm.checksum = buff_[13]; break;
|
|
|
765 |
|
|
|
766 |
case 0x04f:
|
|
|
767 |
dw = makeDWord(buff_[9], buff_[10], buff_[11], buff_[12]);
|
|
|
768 |
memcpy(&comm.data.message_value.content.fvalue, &dw, 4);
|
|
|
769 |
comm.checksum = buff_[13];
|
|
|
770 |
break;
|
|
|
771 |
|
|
|
772 |
case 0x08f:
|
|
|
773 |
memcpy(&comm.data.message_value.content.dvalue, &buff_[9], 8); // FIXME: wrong byte order on Intel CPU?
|
|
|
774 |
comm.checksum = buff_[17];
|
|
|
775 |
break;
|
|
|
776 |
}
|
|
|
777 |
|
|
|
778 |
if (callback)
|
|
|
779 |
callback(comm);
|
|
|
780 |
else
|
|
|
781 |
MSG_WARNING("Missing callback function!");
|
|
|
782 |
break;
|
|
|
783 |
|
|
|
784 |
case 0x000b: // string value change
|
|
|
785 |
case 0x008b:
|
|
|
786 |
case 0x000c: // command string
|
|
|
787 |
case 0x008c:
|
|
|
788 |
comm.data.message_string.device = makeWord(buff_[0], buff_[1]);
|
|
|
789 |
comm.data.message_string.port = makeWord(buff_[2], buff_[3]);
|
|
|
790 |
comm.data.message_string.system = makeWord(buff_[4], buff_[5]);
|
|
|
791 |
comm.data.message_string.type = buff_[6];
|
|
|
792 |
comm.data.message_string.length = makeWord(buff_[7], buff_[8]);
|
|
|
793 |
memset(&comm.data.message_string.content[0], 0, sizeof(comm.data.message_string.content));
|
|
|
794 |
len = (buff_[6] == 0x01) ? comm.data.message_string.length : comm.data.message_string.length * 2;
|
|
|
795 |
|
|
|
796 |
if (len >= sizeof(comm.data.message_string.content))
|
|
|
797 |
{
|
|
|
798 |
len = sizeof(comm.data.message_string.content) - 1;
|
|
|
799 |
comm.data.message_string.length = (buff_[6] == 0x01) ? len : len / 2;
|
|
|
800 |
}
|
|
|
801 |
|
|
|
802 |
memcpy(&comm.data.message_string.content[0], &buff_[9], len);
|
|
|
803 |
pos = (int)(len + 10);
|
|
|
804 |
comm.checksum = buff_[pos];
|
|
|
805 |
cmd.assign((char *)&comm.data.message_string.content[0], len);
|
|
|
806 |
MSG_DEBUG("cmd=" << cmd);
|
|
|
807 |
|
|
|
808 |
if (isCommand(cmd))
|
|
|
809 |
{
|
|
|
810 |
MSG_DEBUG("Command found!");
|
|
|
811 |
oldCmd.assign(cmd);
|
|
|
812 |
}
|
|
|
813 |
else
|
|
|
814 |
{
|
|
|
815 |
oldCmd.append(cmd);
|
|
|
816 |
MSG_DEBUG("Concatenated cmd=" << oldCmd);
|
|
|
817 |
memset(&comm.data.message_string.content[0], 0, sizeof(comm.data.message_string.content));
|
|
|
818 |
memcpy(&comm.data.message_string.content[0], oldCmd.c_str(), sizeof(comm.data.message_string.content) - 1);
|
|
|
819 |
comm.data.message_string.length = oldCmd.length();
|
|
|
820 |
oldCmd.clear();
|
|
|
821 |
}
|
|
|
822 |
|
|
|
823 |
if (callback)
|
|
|
824 |
callback(comm);
|
|
|
825 |
else
|
|
|
826 |
MSG_WARNING("Missing callback function!");
|
|
|
827 |
break;
|
|
|
828 |
|
|
|
829 |
case 0x000e: // request level value
|
|
|
830 |
comm.data.level.device = makeWord(buff_[0], buff_[1]);
|
|
|
831 |
comm.data.level.port = makeWord(buff_[2], buff_[3]);
|
|
|
832 |
comm.data.level.system = makeWord(buff_[4], buff_[5]);
|
|
|
833 |
comm.data.level.level = makeWord(buff_[6], buff_[7]);
|
|
|
834 |
comm.checksum = buff_[8];
|
|
|
835 |
|
|
|
836 |
if (callback)
|
|
|
837 |
callback(comm);
|
|
|
838 |
else
|
|
|
839 |
MSG_WARNING("Missing callback function!");
|
|
|
840 |
break;
|
|
|
841 |
|
|
|
842 |
case 0x000f: // request output channel status
|
|
|
843 |
comm.data.channel.device = makeWord(buff_[0], buff_[1]);
|
|
|
844 |
comm.data.channel.port = makeWord(buff_[2], buff_[3]);
|
|
|
845 |
comm.data.channel.system = makeWord(buff_[4], buff_[5]);
|
|
|
846 |
comm.data.channel.channel = makeWord(buff_[6], buff_[7]);
|
|
|
847 |
comm.checksum = buff_[8];
|
|
|
848 |
|
|
|
849 |
if (callback)
|
|
|
850 |
callback(comm);
|
|
|
851 |
else
|
|
|
852 |
MSG_WARNING("Missing callback function!");
|
|
|
853 |
break;
|
|
|
854 |
|
|
|
855 |
case 0x0010: // request port count
|
|
|
856 |
case 0x0017: // request device info
|
|
|
857 |
comm.data.reqPortCount.device = makeWord(buff_[0], buff_[1]);
|
|
|
858 |
comm.data.reqPortCount.system = makeWord(buff_[2], buff_[3]);
|
|
|
859 |
comm.checksum = buff_[4];
|
|
|
860 |
s.channel = false;
|
|
|
861 |
s.level = 0;
|
|
|
862 |
s.port = 0;
|
|
|
863 |
s.value = 0x0015;
|
|
|
864 |
s.MC = (comm.MC == 0x0010) ? 0x0090 : 0x0097;
|
|
|
865 |
|
|
|
866 |
if (s.MC == 0x0097)
|
|
|
867 |
{
|
|
|
868 |
comm.data.srDeviceInfo.device = comm.device2;
|
|
|
869 |
comm.data.srDeviceInfo.system = comm.system;
|
|
|
870 |
comm.data.srDeviceInfo.flag = 0x0000;
|
|
|
871 |
comm.data.srDeviceInfo.parentID = 0;
|
|
|
872 |
comm.data.srDeviceInfo.herstID = 1;
|
|
|
873 |
msg97fill(&comm);
|
|
|
874 |
}
|
|
|
875 |
else
|
|
|
876 |
sendCommand(s);
|
|
|
877 |
break;
|
|
|
878 |
|
|
|
879 |
case 0x0011: // request output channel count
|
|
|
880 |
case 0x0012: // request level count
|
|
|
881 |
case 0x0013: // request string size
|
|
|
882 |
case 0x0014: // request command size
|
|
|
883 |
comm.data.reqOutpChannels.device = makeWord(buff_[0], buff_[1]);
|
|
|
884 |
comm.data.reqOutpChannels.port = makeWord(buff_[2], buff_[3]);
|
|
|
885 |
comm.data.reqOutpChannels.system = makeWord(buff_[4], buff_[5]);
|
|
|
886 |
comm.checksum = buff_[6];
|
|
|
887 |
s.channel = false;
|
|
|
888 |
s.level = 0;
|
|
|
889 |
s.port = comm.data.reqOutpChannels.port;
|
|
|
890 |
s.value = 0;
|
|
|
891 |
|
|
|
892 |
switch (comm.MC)
|
|
|
893 |
{
|
|
|
894 |
case 0x0011:
|
|
|
895 |
s.MC = 0x0091;
|
|
|
896 |
s.value = 0x0f75; // # channels
|
|
|
897 |
break;
|
|
|
898 |
|
|
|
899 |
case 0x0012:
|
|
|
900 |
s.MC = 0x0092;
|
|
|
901 |
s.value = 0x000d; // # levels
|
|
|
902 |
break;
|
|
|
903 |
|
|
|
904 |
case 0x0013:
|
|
|
905 |
s.MC = 0x0093;
|
|
|
906 |
s.value = 0x00c7; // string size
|
|
|
907 |
break;
|
|
|
908 |
|
|
|
909 |
case 0x0014:
|
|
|
910 |
s.MC = 0x0094;
|
|
|
911 |
s.value = 0x00c7; // command size
|
|
|
912 |
break;
|
|
|
913 |
}
|
|
|
914 |
|
|
|
915 |
sendCommand(s);
|
|
|
916 |
break;
|
|
|
917 |
|
|
|
918 |
case 0x0015: // request level size
|
|
|
919 |
comm.data.reqLevels.device = makeWord(buff_[0], buff_[1]);
|
|
|
920 |
comm.data.reqLevels.port = makeWord(buff_[2], buff_[3]);
|
|
|
921 |
comm.data.reqLevels.system = makeWord(buff_[4], buff_[5]);
|
|
|
922 |
comm.data.reqLevels.level = makeWord(buff_[6], buff_[7]);
|
|
|
923 |
comm.checksum = buff_[8];
|
|
|
924 |
s.channel = false;
|
|
|
925 |
s.level = comm.data.reqLevels.level;
|
|
|
926 |
s.port = comm.data.reqLevels.port;
|
|
|
927 |
s.value = 0;
|
|
|
928 |
s.MC = 0x0095;
|
|
|
929 |
sendCommand(s);
|
|
|
930 |
break;
|
|
|
931 |
|
|
|
932 |
case 0x0016: // request status code
|
|
|
933 |
comm.data.sendStatusCode.device = makeWord(buff_[0], buff_[1]);
|
|
|
934 |
comm.data.sendStatusCode.port = makeWord(buff_[2], buff_[3]);
|
|
|
935 |
comm.data.sendStatusCode.system = makeWord(buff_[4], buff_[5]);
|
|
|
936 |
|
|
|
937 |
if (callback)
|
|
|
938 |
callback(comm);
|
|
|
939 |
else
|
|
|
940 |
MSG_WARNING("Missing callback function!");
|
|
|
941 |
break;
|
|
|
942 |
|
|
|
943 |
case 0x0097: // receive device info
|
|
|
944 |
comm.data.srDeviceInfo.device = makeWord(buff_[0], buff_[1]);
|
|
|
945 |
comm.data.srDeviceInfo.system = makeWord(buff_[2], buff_[3]);
|
|
|
946 |
comm.data.srDeviceInfo.flag = makeWord(buff_[4], buff_[5]);
|
|
|
947 |
comm.data.srDeviceInfo.objectID = buff_[6];
|
|
|
948 |
comm.data.srDeviceInfo.parentID = buff_[7];
|
|
|
949 |
comm.data.srDeviceInfo.herstID = makeWord(buff_[8], buff_[9]);
|
|
|
950 |
comm.data.srDeviceInfo.deviceID = makeWord(buff_[10], buff_[11]);
|
|
|
951 |
memcpy(comm.data.srDeviceInfo.serial, &buff_[12], 16);
|
|
|
952 |
comm.data.srDeviceInfo.fwid = makeWord(buff_[28], buff_[29]);
|
|
|
953 |
memset(comm.data.srDeviceInfo.info, 0, sizeof(comm.data.srDeviceInfo.info));
|
|
|
954 |
memcpy(comm.data.srDeviceInfo.info, &buff_[30], comm.hlen - 0x0015 - 29);
|
|
|
955 |
comm.checksum = buff_[comm.hlen + 3];
|
|
|
956 |
// Prepare answer
|
|
|
957 |
s.channel = false;
|
|
|
958 |
s.level = 0;
|
|
|
959 |
s.port = 0;
|
|
|
960 |
s.value = 0;
|
|
|
961 |
|
|
|
962 |
if (!initSend)
|
|
|
963 |
{
|
|
|
964 |
s.MC = 0x0097;
|
|
|
965 |
initSend = true;
|
|
|
966 |
}
|
|
|
967 |
else if (!ready)
|
|
|
968 |
{
|
|
|
969 |
// Send counts
|
|
|
970 |
s.MC = 0x0090;
|
|
|
971 |
s.value = 0x0015; // # ports
|
|
|
972 |
sendCommand(s);
|
|
|
973 |
s.MC = 0x0091;
|
|
|
974 |
s.value = 0x0f75; // # channels
|
|
|
975 |
sendCommand(s);
|
|
|
976 |
s.MC = 0x0092;
|
|
|
977 |
s.value = 0x000d; // # levels
|
|
|
978 |
sendCommand(s);
|
|
|
979 |
s.MC = 0x0093;
|
|
|
980 |
s.value = 0x00c7; // string size
|
|
|
981 |
sendCommand(s);
|
|
|
982 |
s.MC = 0x0094;
|
|
|
983 |
s.value = 0x00c7; // command size
|
|
|
984 |
sendCommand(s);
|
|
|
985 |
s.MC = 0x0098;
|
|
|
986 |
ready = true;
|
|
|
987 |
}
|
|
|
988 |
else
|
|
|
989 |
break;
|
|
|
990 |
|
|
|
991 |
sendCommand(s);
|
|
|
992 |
|
|
|
993 |
MSG_DEBUG("S/N: " << comm.data.srDeviceInfo.serial << " | " << comm.data.srDeviceInfo.info);
|
|
|
994 |
break;
|
|
|
995 |
|
|
|
996 |
case 0x00a1: // request status
|
|
|
997 |
reqDevStatus = makeWord(buff_[0], buff_[1]);
|
|
|
998 |
comm.checksum = buff_[2];
|
|
|
999 |
break;
|
|
|
1000 |
|
|
|
1001 |
case 0x0204: // file transfer
|
|
|
1002 |
s.device = comm.device2;
|
|
|
1003 |
comm.data.filetransfer.ftype = makeWord(buff_[0], buff_[1]);
|
|
|
1004 |
comm.data.filetransfer.function = makeWord(buff_[2], buff_[3]);
|
|
|
1005 |
pos = 4;
|
|
|
1006 |
|
|
|
1007 |
if (comm.data.filetransfer.ftype == 0 && comm.data.filetransfer.function == 0x0105) // Directory exist?
|
|
|
1008 |
{
|
|
|
1009 |
for (size_t i = 0; i < 0x0104; i++)
|
|
|
1010 |
{
|
|
|
1011 |
comm.data.filetransfer.data[i] = buff_[pos];
|
|
|
1012 |
pos++;
|
|
|
1013 |
}
|
|
|
1014 |
|
|
|
1015 |
comm.data.filetransfer.data[0x0103] = 0;
|
|
|
1016 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1017 |
}
|
|
|
1018 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0100) // Controller have more files
|
|
|
1019 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1020 |
else if (comm.data.filetransfer.ftype == 0 && comm.data.filetransfer.function == 0x0100) // Request directory listing
|
|
|
1021 |
{
|
|
|
1022 |
comm.data.filetransfer.unk = makeWord(buff_[4], buff_[5]);
|
|
|
1023 |
pos = 6;
|
|
|
1024 |
|
|
|
1025 |
for (size_t i = 0; i < 0x0104; i++)
|
|
|
1026 |
{
|
|
|
1027 |
comm.data.filetransfer.data[i] = buff_[pos];
|
|
|
1028 |
pos++;
|
|
|
1029 |
}
|
|
|
1030 |
|
|
|
1031 |
comm.data.filetransfer.data[0x0103] = 0;
|
|
|
1032 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1033 |
}
|
|
|
1034 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0102) // controller will send a file
|
|
|
1035 |
{
|
|
|
1036 |
comm.data.filetransfer.unk = makeDWord(buff_[4], buff_[5], buff_[6], buff_[7]);
|
|
|
1037 |
comm.data.filetransfer.unk1 = makeDWord(buff_[8], buff_[9], buff_[10], buff_[11]);
|
|
|
1038 |
pos = 12;
|
|
|
1039 |
|
|
|
1040 |
for (size_t i = 0; i < 0x0104; i++)
|
|
|
1041 |
{
|
|
|
1042 |
comm.data.filetransfer.data[i] = buff_[pos];
|
|
|
1043 |
pos++;
|
|
|
1044 |
}
|
|
|
1045 |
|
|
|
1046 |
comm.data.filetransfer.data[0x0103] = 0;
|
|
|
1047 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1048 |
}
|
|
|
1049 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0103) // file or part of a file
|
|
|
1050 |
{
|
|
|
1051 |
comm.data.filetransfer.unk = makeWord(buff_[4], buff_[5]);
|
|
|
1052 |
pos = 6;
|
|
|
1053 |
|
|
|
1054 |
for (size_t i = 0; i < comm.data.filetransfer.unk; i++)
|
|
|
1055 |
{
|
|
|
1056 |
comm.data.filetransfer.data[i] = buff_[pos];
|
|
|
1057 |
pos++;
|
|
|
1058 |
}
|
|
|
1059 |
|
|
|
1060 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1061 |
}
|
|
|
1062 |
else if (comm.data.filetransfer.ftype == 0 && comm.data.filetransfer.function == 0x0104) // Does file exist;
|
|
|
1063 |
{
|
|
|
1064 |
for (size_t i = 0; i < 0x0104; i++)
|
|
|
1065 |
{
|
|
|
1066 |
comm.data.filetransfer.data[i] = buff_[pos];
|
|
|
1067 |
pos++;
|
|
|
1068 |
}
|
|
|
1069 |
|
|
|
1070 |
comm.data.filetransfer.data[0x0103] = 0;
|
|
|
1071 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1072 |
}
|
|
|
1073 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0104) // request a file
|
|
|
1074 |
{
|
|
|
1075 |
comm.data.filetransfer.unk = makeWord(buff_[4], buff_[5]);
|
|
|
1076 |
pos = 6;
|
|
|
1077 |
|
|
|
1078 |
for (size_t i = 0; i < 0x0104; i++)
|
|
|
1079 |
{
|
|
|
1080 |
comm.data.filetransfer.data[i] = buff_[pos];
|
|
|
1081 |
pos++;
|
|
|
1082 |
}
|
|
|
1083 |
|
|
|
1084 |
comm.data.filetransfer.data[0x0103] = 0;
|
|
|
1085 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1086 |
}
|
|
|
1087 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0106) // ACK for 0x0105
|
|
|
1088 |
{
|
|
|
1089 |
comm.data.filetransfer.unk = makeDWord(buff_[4], buff_[5], buff_[6], buff_[7]);
|
|
|
1090 |
pos = 8;
|
|
|
1091 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1092 |
}
|
|
|
1093 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0002) // request next part of file
|
|
|
1094 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1095 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0003) // File content from controller
|
|
|
1096 |
{
|
|
|
1097 |
comm.data.filetransfer.unk = makeWord(buff_[4], buff_[5]); // length of data block
|
|
|
1098 |
pos = 6;
|
|
|
1099 |
|
|
|
1100 |
for (size_t i = 0; i < comm.data.filetransfer.unk; i++)
|
|
|
1101 |
{
|
|
|
1102 |
comm.data.filetransfer.data[i] = buff_[pos];
|
|
|
1103 |
pos++;
|
|
|
1104 |
}
|
|
|
1105 |
|
|
|
1106 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1107 |
}
|
|
|
1108 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0004) // End of file
|
|
|
1109 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1110 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0005) // End of file ACK
|
|
|
1111 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1112 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0006) // End of directory listing ACK
|
|
|
1113 |
{
|
|
|
1114 |
comm.data.filetransfer.unk = makeWord(buff_[4], buff_[5]); // length of received data block
|
|
|
1115 |
pos = 6;
|
|
|
1116 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1117 |
}
|
|
|
1118 |
else if (comm.data.filetransfer.ftype == 4 && comm.data.filetransfer.function == 0x0007) // End of file transfer
|
|
|
1119 |
handleFTransfer(s, comm.data.filetransfer);
|
|
|
1120 |
|
|
|
1121 |
break;
|
|
|
1122 |
|
| 464 |
andreas |
1123 |
case 0x020d: // request network information
|
|
|
1124 |
s.MC = 0x020e;
|
|
|
1125 |
s.channel = 0;
|
|
|
1126 |
s.level = 0;
|
|
|
1127 |
s.port = 0;
|
|
|
1128 |
s.value = 0;
|
|
|
1129 |
sendCommand(s);
|
|
|
1130 |
break;
|
|
|
1131 |
|
| 446 |
andreas |
1132 |
case 0x0501: // ping
|
|
|
1133 |
comm.data.chan_state.device = makeWord(buff_[0], buff_[1]);
|
|
|
1134 |
comm.data.chan_state.system = makeWord(buff_[2], buff_[3]);
|
|
|
1135 |
s.channel = 0;
|
|
|
1136 |
s.level = 0;
|
|
|
1137 |
s.port = 0;
|
|
|
1138 |
s.value = 0;
|
|
|
1139 |
s.MC = 0x0581;
|
|
|
1140 |
sendCommand(s);
|
|
|
1141 |
break;
|
|
|
1142 |
|
|
|
1143 |
case 0x0502: // Date and time
|
|
|
1144 |
comm.data.blinkMessage.heartBeat = buff_[0];
|
|
|
1145 |
comm.data.blinkMessage.LED = buff_[1];
|
|
|
1146 |
comm.data.blinkMessage.month = buff_[2];
|
|
|
1147 |
comm.data.blinkMessage.day = buff_[3];
|
|
|
1148 |
comm.data.blinkMessage.year = makeWord(buff_[4], buff_[5]);
|
|
|
1149 |
comm.data.blinkMessage.hour = buff_[6];
|
|
|
1150 |
comm.data.blinkMessage.minute = buff_[7];
|
|
|
1151 |
comm.data.blinkMessage.second = buff_[8];
|
|
|
1152 |
comm.data.blinkMessage.weekday = buff_[9];
|
|
|
1153 |
comm.data.blinkMessage.extTemp = makeWord(buff_[10], buff_[11]);
|
|
|
1154 |
memset(comm.data.blinkMessage.dateTime, 0, sizeof(comm.data.blinkMessage.dateTime));
|
|
|
1155 |
memcpy(comm.data.blinkMessage.dateTime, &buff_[12], comm.hlen - 0x0015 - 11);
|
|
|
1156 |
comm.checksum = buff_[comm.hlen + 3];
|
|
|
1157 |
|
|
|
1158 |
sendAllFuncTimer(comm.data.blinkMessage);
|
|
|
1159 |
sendAllFuncNetwork(mLastOnlineState == NSTATE_ONLINE ? NSTATE_ONLINE1 : NSTATE_ONLINE);
|
|
|
1160 |
break;
|
|
|
1161 |
}
|
|
|
1162 |
break;
|
|
|
1163 |
|
|
|
1164 |
default: // Every unknown or unsupported command/request should be ignored.
|
|
|
1165 |
ignore = true;
|
|
|
1166 |
}
|
|
|
1167 |
}
|
|
|
1168 |
|
|
|
1169 |
bool TAmxNet::sendCommand(const ANET_SEND& s)
|
|
|
1170 |
{
|
|
|
1171 |
DECL_TRACER("TAmxNet::sendCommand (const ANET_SEND& s)");
|
|
|
1172 |
|
|
|
1173 |
size_t len, size;
|
|
|
1174 |
ANET_COMMAND com;
|
|
|
1175 |
com.clear();
|
|
|
1176 |
com.MC = s.MC;
|
|
|
1177 |
|
|
|
1178 |
if (s.MC == 0x0204) // file transfer
|
|
|
1179 |
com.device1 = s.device;
|
|
|
1180 |
else
|
|
|
1181 |
com.device1 = 0;
|
|
|
1182 |
|
|
|
1183 |
com.device2 = panelID;
|
|
|
1184 |
com.port1 = 1;
|
|
|
1185 |
com.system = TConfig::getSystem();
|
|
|
1186 |
com.port2 = s.port;
|
|
|
1187 |
sendCounter++;
|
|
|
1188 |
com.count = sendCounter;
|
|
|
1189 |
|
|
|
1190 |
switch (s.MC)
|
|
|
1191 |
{
|
|
|
1192 |
case 0x0084: // push button
|
|
|
1193 |
com.data.channel.device = com.device2;
|
|
|
1194 |
com.data.channel.port = s.port;
|
|
|
1195 |
com.data.channel.system = com.system;
|
|
|
1196 |
com.data.channel.channel = s.channel;
|
|
|
1197 |
com.hlen = 0x0016 - 0x0003 + sizeof(ANET_CHANNEL);
|
|
|
1198 |
MSG_DEBUG("SEND: BUTTON PUSH-" << s.channel << ":" << s.port << ":" << com.device2);
|
|
|
1199 |
comStack.push_back(com);
|
|
|
1200 |
mSendReady = true;
|
|
|
1201 |
break;
|
|
|
1202 |
|
|
|
1203 |
case 0x0085: // release button
|
|
|
1204 |
com.data.channel.device = com.device2;
|
|
|
1205 |
com.data.channel.port = s.port;
|
|
|
1206 |
com.data.channel.system = com.system;
|
|
|
1207 |
com.data.channel.channel = s.channel;
|
|
|
1208 |
com.hlen = 0x0016 - 0x0003 + sizeof(ANET_CHANNEL);
|
|
|
1209 |
MSG_DEBUG("SEND: BUTTON RELEASE-" << s.channel << ":" << s.port << ":" << com.device2);
|
|
|
1210 |
comStack.push_back(com);
|
|
|
1211 |
mSendReady = true;
|
|
|
1212 |
break;
|
|
|
1213 |
|
|
|
1214 |
case 0x0086: // output channel on
|
|
|
1215 |
case 0x0088: // feedback/input channel on
|
|
|
1216 |
com.data.channel.device = com.device2;
|
|
|
1217 |
com.data.channel.port = s.port;
|
|
|
1218 |
com.data.channel.system = com.system;
|
|
|
1219 |
com.data.channel.channel = s.channel;
|
|
|
1220 |
com.hlen = 0x0016 - 0x0003 + sizeof(ANET_CHANNEL);
|
|
|
1221 |
MSG_DEBUG("SEND: CHANNEL ON-" << s.channel << ":" << s.port << ":" << com.device2);
|
|
|
1222 |
comStack.push_back(com);
|
|
|
1223 |
mSendReady = true;
|
|
|
1224 |
break;
|
|
|
1225 |
|
|
|
1226 |
case 0x0087: // output channel off
|
|
|
1227 |
case 0x0089: // feedback/input channel off
|
|
|
1228 |
com.data.channel.device = com.device2;
|
|
|
1229 |
com.data.channel.port = s.port;
|
|
|
1230 |
com.data.channel.system = com.system;
|
|
|
1231 |
com.data.channel.channel = s.channel;
|
|
|
1232 |
com.hlen = 0x0016 - 0x0003 + sizeof(ANET_CHANNEL);
|
|
|
1233 |
MSG_DEBUG("SEND: CHANNEL OFF-" << s.channel << ":" << s.port << ":" << com.device2);
|
|
|
1234 |
comStack.push_back(com);
|
|
|
1235 |
mSendReady = true;
|
|
|
1236 |
break;
|
|
|
1237 |
|
|
|
1238 |
case 0x008a: // level value changed
|
|
|
1239 |
if (gPageManager && gPageManager->getLevelSendState())
|
|
|
1240 |
{
|
|
|
1241 |
com.data.message_value.device = com.device2;
|
|
|
1242 |
com.data.message_value.port = s.port;
|
|
|
1243 |
com.data.message_value.system = com.system;
|
|
|
1244 |
com.data.message_value.value = s.level;
|
|
|
1245 |
com.data.message_value.type = DTSZ_UINT; // unsigned integer
|
|
|
1246 |
com.data.message_value.content.integer = s.value;
|
|
|
1247 |
com.hlen = 0x0016 - 0x0003 + 11;
|
|
|
1248 |
MSG_DEBUG("SEND: LEVEL-" << s.value << "," << s.level << ":" << s.port << ":" << com.device2);
|
|
|
1249 |
comStack.push_back(com);
|
|
|
1250 |
mSendReady = true;
|
|
|
1251 |
}
|
|
|
1252 |
break;
|
|
|
1253 |
|
|
|
1254 |
case 0x008b: // string command
|
|
|
1255 |
case 0x008c: // send command string
|
|
|
1256 |
if (gPageManager && gPageManager->getRxSendState())
|
|
|
1257 |
{
|
|
|
1258 |
com.data.message_string.device = com.device2;
|
|
|
1259 |
com.data.message_string.port = s.port;
|
|
|
1260 |
com.data.message_string.system = com.system;
|
|
|
1261 |
com.data.message_string.type = DTSZ_STRING; // char string
|
|
|
1262 |
|
|
|
1263 |
if (s.msg.length() >= sizeof(com.data.message_string.content))
|
|
|
1264 |
len = sizeof(com.data.message_string.content) - 1;
|
|
|
1265 |
else
|
|
|
1266 |
len = s.msg.length();
|
|
|
1267 |
|
|
|
1268 |
com.data.message_string.length = len;
|
|
|
1269 |
strncpy((char *)&com.data.message_string.content[0], s.msg.c_str(), len);
|
|
|
1270 |
com.hlen = 0x0016 - 3 + 9 + len;
|
|
|
1271 |
|
|
|
1272 |
if (s.MC == 0x008b)
|
|
|
1273 |
{
|
|
|
1274 |
MSG_DEBUG("SEND: STRING-'" << s.msg << "'," << s.port << ":" << com.device2);
|
|
|
1275 |
}
|
|
|
1276 |
else
|
|
|
1277 |
{
|
|
|
1278 |
MSG_DEBUG("SEND: COMMAND-'" << s.msg << "'," << s.port << ":" << com.device2);
|
|
|
1279 |
}
|
|
|
1280 |
|
|
|
1281 |
comStack.push_back(com);
|
|
|
1282 |
mSendReady = true;
|
|
|
1283 |
}
|
|
|
1284 |
break;
|
|
|
1285 |
|
|
|
1286 |
case 0x008d: // Custom event
|
|
|
1287 |
com.data.customEvent.device = com.device2;
|
|
|
1288 |
com.data.customEvent.port = s.port;
|
|
|
1289 |
com.data.customEvent.system = com.system;
|
|
|
1290 |
com.data.customEvent.ID = s.ID;
|
|
|
1291 |
com.data.customEvent.type = s.type;
|
|
|
1292 |
com.data.customEvent.flag = s.flag;
|
|
|
1293 |
com.data.customEvent.value1 = s.value1;
|
|
|
1294 |
com.data.customEvent.value2 = s.value2;
|
|
|
1295 |
com.data.customEvent.value3 = s.value3;
|
|
|
1296 |
com.data.customEvent.dtype = s.dtype;
|
|
|
1297 |
|
|
|
1298 |
if (s.msg.length() >= sizeof(com.data.customEvent.data))
|
|
|
1299 |
len = sizeof(com.data.customEvent.data) - 1;
|
|
|
1300 |
else
|
|
|
1301 |
len = s.msg.length();
|
|
|
1302 |
|
|
|
1303 |
com.data.customEvent.length = len;
|
|
|
1304 |
memset(com.data.customEvent.data, 0, sizeof(com.data.customEvent.data));
|
|
|
1305 |
|
|
|
1306 |
if (len > 0)
|
|
|
1307 |
memcpy(&com.data.customEvent.data[0], s.msg.c_str(), len);
|
|
|
1308 |
|
|
|
1309 |
com.hlen = 0x0016 - 3 + 29 + len;
|
|
|
1310 |
comStack.push_back(com);
|
|
|
1311 |
mSendReady = true;
|
|
|
1312 |
break;
|
|
|
1313 |
|
|
|
1314 |
case 0x0090: // port count
|
|
|
1315 |
com.data.sendPortNumber.device = com.device2;
|
|
|
1316 |
com.data.sendPortNumber.system = com.system;
|
|
|
1317 |
com.data.sendPortNumber.pcount = s.value;
|
|
|
1318 |
com.hlen = 0x0016 - 3 + 6;
|
|
|
1319 |
comStack.push_back(com);
|
|
|
1320 |
mSendReady = true;
|
|
|
1321 |
break;
|
|
|
1322 |
|
|
|
1323 |
case 0x0091: // output channel count
|
|
|
1324 |
case 0x0092: // send level count
|
|
|
1325 |
com.data.sendOutpChannels.device = com.device2;
|
|
|
1326 |
com.data.sendOutpChannels.port = s.port;
|
|
|
1327 |
com.data.sendOutpChannels.system = com.system;
|
|
|
1328 |
com.data.sendOutpChannels.count = s.value;
|
|
|
1329 |
com.hlen = 0x0016 - 3 + 8;
|
|
|
1330 |
comStack.push_back(com);
|
|
|
1331 |
mSendReady = true;
|
|
|
1332 |
break;
|
|
|
1333 |
|
|
|
1334 |
case 0x0093: // string size
|
|
|
1335 |
case 0x0094: // command size
|
|
|
1336 |
com.data.sendSize.device = com.device2;
|
|
|
1337 |
com.data.sendSize.port = s.port;
|
|
|
1338 |
com.data.sendSize.system = com.system;
|
|
|
1339 |
com.data.sendSize.type = DTSZ_STRING;
|
|
|
1340 |
com.data.sendSize.length = s.value;
|
|
|
1341 |
com.hlen = 0x0016 - 3 + 9;
|
|
|
1342 |
comStack.push_back(com);
|
|
|
1343 |
mSendReady = true;
|
|
|
1344 |
break;
|
|
|
1345 |
|
|
|
1346 |
case 0x0095: // suported level types
|
|
|
1347 |
com.data.sendLevSupport.device = com.device2;
|
|
|
1348 |
com.data.sendLevSupport.port = s.port;
|
|
|
1349 |
com.data.sendLevSupport.system = com.system;
|
|
|
1350 |
com.data.sendLevSupport.level = s.level;
|
|
|
1351 |
com.data.sendLevSupport.num = 6;
|
|
|
1352 |
com.data.sendLevSupport.types[0] = 0x10;
|
|
|
1353 |
com.data.sendLevSupport.types[1] = 0x11;
|
|
|
1354 |
com.data.sendLevSupport.types[2] = 0x20;
|
|
|
1355 |
com.data.sendLevSupport.types[3] = 0x21;
|
|
|
1356 |
com.data.sendLevSupport.types[4] = 0x40;
|
|
|
1357 |
com.data.sendLevSupport.types[5] = 0x41;
|
|
|
1358 |
com.hlen = 0x0016 - 0x0003 + sizeof(ANET_LEVSUPPORT);
|
|
|
1359 |
comStack.push_back(com);
|
|
|
1360 |
mSendReady = true;
|
|
|
1361 |
break;
|
|
|
1362 |
|
|
|
1363 |
case 0x0096: // Status code
|
|
|
1364 |
com.data.sendStatusCode.device = com.device2;
|
|
|
1365 |
com.data.sendStatusCode.port = s.port;
|
|
|
1366 |
com.data.sendStatusCode.system = com.system;
|
|
|
1367 |
com.data.sendStatusCode.status = 0;
|
|
|
1368 |
com.data.sendStatusCode.type = DTSZ_CHAR;
|
|
|
1369 |
com.data.sendStatusCode.length = 2;
|
|
|
1370 |
com.data.sendStatusCode.str[0] = 'O';
|
|
|
1371 |
com.data.sendStatusCode.str[1] = 'K';
|
|
|
1372 |
com.hlen = 0x0016 - 3 + 13;
|
|
|
1373 |
comStack.push_back(com);
|
|
|
1374 |
mSendReady = true;
|
|
|
1375 |
break;
|
|
|
1376 |
|
|
|
1377 |
case 0x0097: // device info
|
|
|
1378 |
com.data.srDeviceInfo.device = com.device2;
|
|
|
1379 |
com.data.srDeviceInfo.system = com.system;
|
|
|
1380 |
com.data.srDeviceInfo.flag = 0x0000;
|
|
|
1381 |
com.data.srDeviceInfo.objectID = 0;
|
|
|
1382 |
com.data.srDeviceInfo.parentID = 0;
|
|
|
1383 |
com.data.srDeviceInfo.herstID = 1;
|
|
|
1384 |
msg97fill(&com);
|
|
|
1385 |
mSendReady = true;
|
|
|
1386 |
break;
|
|
|
1387 |
|
|
|
1388 |
case 0x0098:
|
|
|
1389 |
com.data.reqPortCount.device = com.device2;
|
|
|
1390 |
com.data.reqPortCount.system = com.system;
|
|
|
1391 |
com.hlen = 0x0016 - 3 + 4;
|
|
|
1392 |
comStack.push_back(com);
|
|
|
1393 |
mSendReady = true;
|
|
|
1394 |
break;
|
|
|
1395 |
|
|
|
1396 |
case 0x0204: // File transfer
|
|
|
1397 |
com.port1 = 0;
|
|
|
1398 |
com.port2 = 0;
|
|
|
1399 |
com.data.filetransfer.ftype = s.dtype;
|
|
|
1400 |
com.data.filetransfer.function = s.type;
|
|
|
1401 |
com.data.filetransfer.info1 = s.value;
|
|
|
1402 |
com.data.filetransfer.info2 = s.level;
|
|
|
1403 |
com.data.filetransfer.unk = s.value1;
|
|
|
1404 |
com.data.filetransfer.unk1 = s.value2;
|
|
|
1405 |
com.data.filetransfer.unk2 = s.value3;
|
|
|
1406 |
size = min(s.msg.length(), sizeof(com.data.filetransfer.data) - 1);
|
|
|
1407 |
memcpy(com.data.filetransfer.data, s.msg.c_str(), size);
|
|
|
1408 |
com.data.filetransfer.data[size] = 0;
|
|
|
1409 |
len = 4;
|
|
|
1410 |
|
|
|
1411 |
if (s.dtype == 0)
|
|
|
1412 |
{
|
|
|
1413 |
switch (s.type)
|
|
|
1414 |
{
|
|
|
1415 |
case 0x0001: len += 2; break;
|
|
|
1416 |
case 0x0101: len += 16 + size + 1; break;
|
|
|
1417 |
case 0x0102: len += 19 + size + 1; break;
|
|
|
1418 |
}
|
|
|
1419 |
}
|
|
|
1420 |
else
|
|
|
1421 |
{
|
|
|
1422 |
switch (s.type)
|
|
|
1423 |
{
|
|
|
1424 |
case 0x0003: len += 2 + s.value1; break;
|
|
|
1425 |
case 0x0101: len += 8; break;
|
|
|
1426 |
case 0x0103: len += 6; break;
|
|
|
1427 |
case 0x0105: len += 8; break;
|
|
|
1428 |
}
|
|
|
1429 |
}
|
|
|
1430 |
|
|
|
1431 |
com.hlen = 0x0016 - 3 + len;
|
|
|
1432 |
comStack.push_back(com);
|
|
|
1433 |
mSendReady = true;
|
|
|
1434 |
break;
|
|
|
1435 |
|
| 464 |
andreas |
1436 |
case 0x020c:
|
|
|
1437 |
case 0x020e:
|
|
|
1438 |
{
|
|
|
1439 |
if (!mSocket)
|
|
|
1440 |
break;
|
|
|
1441 |
|
|
|
1442 |
string host = mSocket->getMyHostName();
|
|
|
1443 |
string netmask = mSocket->getMyNetmask();
|
|
|
1444 |
string ip = mSocket->getMyIP();
|
|
|
1445 |
|
|
|
1446 |
size_t total = host.length() + 1 + netmask.length() + 1 + ip.length() + 1 + 1;
|
|
|
1447 |
|
|
|
1448 |
MSG_DEBUG("Host name (" << host.length() << "): " << host);
|
|
|
1449 |
MSG_DEBUG("Host IP (" << ip.length() << "): " << ip);
|
|
|
1450 |
MSG_DEBUG("Netmask (" << netmask.length() << "): " << netmask);
|
|
|
1451 |
MSG_DEBUG("Total length: " << total);
|
|
|
1452 |
|
|
|
1453 |
if (total >= sizeof(com.data.network.data))
|
|
|
1454 |
{
|
|
|
1455 |
MSG_WARNING("Not enough space for sending network information!");
|
|
|
1456 |
break;
|
|
|
1457 |
}
|
|
|
1458 |
|
|
|
1459 |
memset(com.data.network.data, 0, sizeof(com.data.network.data));
|
|
|
1460 |
|
|
|
1461 |
com.data.network.bf = 0; // Satic IP address
|
| 465 |
andreas |
1462 |
size_t pos = 0;
|
|
|
1463 |
|
|
|
1464 |
if (!host.empty())
|
|
|
1465 |
{
|
|
|
1466 |
pos = host.length();
|
|
|
1467 |
memcpy(com.data.network.data, host.c_str(), host.length());
|
|
|
1468 |
*(com.data.network.data+pos) = 0;
|
|
|
1469 |
}
|
|
|
1470 |
|
| 464 |
andreas |
1471 |
pos++;
|
| 465 |
andreas |
1472 |
|
|
|
1473 |
if (!ip.empty())
|
|
|
1474 |
{
|
|
|
1475 |
memcpy(com.data.network.data+pos, ip.c_str(), ip.length());
|
|
|
1476 |
pos += ip.length();
|
|
|
1477 |
*(com.data.network.data+pos) = 0;
|
|
|
1478 |
}
|
|
|
1479 |
|
| 464 |
andreas |
1480 |
pos++;
|
| 465 |
andreas |
1481 |
|
|
|
1482 |
if (!netmask.empty())
|
|
|
1483 |
{
|
|
|
1484 |
memcpy(com.data.network.data+pos, netmask.c_str(), netmask.length());
|
|
|
1485 |
pos += netmask.length();
|
|
|
1486 |
*(com.data.network.data+pos) = 0;
|
|
|
1487 |
}
|
|
|
1488 |
|
|
|
1489 |
pos += 2;
|
|
|
1490 |
|
|
|
1491 |
if (TStreamError::checkFilter(HLOG_DEBUG))
|
|
|
1492 |
{
|
|
|
1493 |
MSG_DEBUG("Counted length: " << pos);
|
|
|
1494 |
TError::logHex(com.data.network.data, total);
|
|
|
1495 |
}
|
|
|
1496 |
|
|
|
1497 |
com.data.network.len = total;
|
| 464 |
andreas |
1498 |
com.hlen = 0x0016 - 3 + total + 1;
|
|
|
1499 |
comStack.push_back(com);
|
|
|
1500 |
mSendReady = true;
|
|
|
1501 |
}
|
|
|
1502 |
break;
|
|
|
1503 |
|
| 446 |
andreas |
1504 |
case 0x0581: // Pong
|
|
|
1505 |
com.data.srDeviceInfo.device = panelID; // Configuration->getAMXChannel();
|
|
|
1506 |
com.data.srDeviceInfo.system = TConfig::getSystem();
|
|
|
1507 |
com.data.srDeviceInfo.herstID = devInfo[0].manufacturerID;
|
|
|
1508 |
com.data.srDeviceInfo.deviceID = devInfo[0].deviceID;
|
|
|
1509 |
com.data.srDeviceInfo.info[0] = 2; // Type: IPv4 address
|
|
|
1510 |
com.data.srDeviceInfo.info[1] = 4; // length of following data
|
|
|
1511 |
|
|
|
1512 |
{
|
|
|
1513 |
string addr = mSocket->getMyIP();
|
|
|
1514 |
vector<string> parts = StrSplit(addr, ".");
|
|
|
1515 |
|
|
|
1516 |
for (size_t i = 0; i < parts.size(); i++)
|
|
|
1517 |
com.data.srDeviceInfo.info[i + 2] = (unsigned char)atoi(parts[i].c_str());
|
|
|
1518 |
}
|
|
|
1519 |
|
|
|
1520 |
com.hlen = 0x0016 - 3 + 14;
|
|
|
1521 |
comStack.push_back(com);
|
|
|
1522 |
mSendReady = true;
|
|
|
1523 |
break;
|
|
|
1524 |
}
|
|
|
1525 |
|
|
|
1526 |
if (mSendReady && !write_busy)
|
|
|
1527 |
runWrite();
|
|
|
1528 |
|
|
|
1529 |
return mSendReady;
|
|
|
1530 |
}
|
|
|
1531 |
|
|
|
1532 |
void TAmxNet::handleFTransfer(ANET_SEND &s, ANET_FILETRANSFER &ft)
|
|
|
1533 |
{
|
|
|
1534 |
DECL_TRACER("TAmxNet::handleFTransfer (ANET_SEND &s, ANET_FILETRANSFER &ft)");
|
|
|
1535 |
|
|
|
1536 |
int len;
|
|
|
1537 |
ANET_COMMAND ftr;
|
|
|
1538 |
ftr.MC = 0x1000;
|
|
|
1539 |
ftr.device1 = s.device;
|
|
|
1540 |
ftr.device2 = s.device;
|
|
|
1541 |
ftr.port1 = 0;
|
|
|
1542 |
ftr.port2 = 0;
|
|
|
1543 |
ftr.count = 0;
|
|
|
1544 |
ftr.data.filetransfer.ftype = ft.ftype;
|
|
|
1545 |
ftr.data.filetransfer.function = ft.function;
|
|
|
1546 |
ftr.data.filetransfer.data[0] = 0;
|
|
|
1547 |
|
|
|
1548 |
if (ft.ftype == 0 && ft.function == 0x0105) // Create directory
|
|
|
1549 |
{
|
|
|
1550 |
s.channel = 0;
|
|
|
1551 |
s.level = 0;
|
|
|
1552 |
s.port = 0;
|
|
|
1553 |
s.value = 0;
|
|
|
1554 |
s.MC = 0x0204;
|
|
|
1555 |
s.dtype = 0; // ftype --> function type
|
|
|
1556 |
s.type = 0x0001; // function
|
|
|
1557 |
s.value1 = 0; // 1st data byte 0x00
|
|
|
1558 |
s.value2 = 0x10; // 2nd data byte 0x10
|
|
|
1559 |
string f((char *)&ft.data);
|
|
|
1560 |
MSG_DEBUG("0x0000/0x0105: Directory " << f << " exist?");
|
|
|
1561 |
string prjPath = TConfig::getProjectPath();
|
|
|
1562 |
string newPath;
|
|
|
1563 |
dir::TDirectory dir;
|
|
|
1564 |
|
|
|
1565 |
if (f.compare(0, 8, "AMXPanel") == 0)
|
|
|
1566 |
{
|
|
|
1567 |
if (f.find("/images") > 0)
|
|
|
1568 |
{
|
|
|
1569 |
newPath = prjPath + "/images";
|
|
|
1570 |
dir.createAllPath(newPath);
|
|
|
1571 |
}
|
|
|
1572 |
else if (f.find("/sounds") > 0)
|
|
|
1573 |
{
|
|
|
1574 |
newPath = prjPath + "/sounds";
|
|
|
1575 |
dir.createAllPath(newPath);
|
|
|
1576 |
}
|
|
|
1577 |
else if (f.find("/fonts") > 0)
|
|
|
1578 |
{
|
|
|
1579 |
newPath = prjPath + "/fonts";
|
|
|
1580 |
dir.createAllPath(newPath);
|
|
|
1581 |
}
|
|
|
1582 |
}
|
|
|
1583 |
else if (f.compare(0, 8, "__system") == 0)
|
|
|
1584 |
{
|
|
|
1585 |
vector<string> subDirs = { "borders", "cursors", "fonts", "images", "sliders", "sounds" };
|
|
|
1586 |
vector<string>::iterator iter;
|
|
|
1587 |
|
|
|
1588 |
for (iter = subDirs.begin(); iter != subDirs.end(); ++iter)
|
|
|
1589 |
{
|
|
|
1590 |
newPath = prjPath + "/__system/graphics/" + *iter;
|
|
|
1591 |
dir.createAllPath(newPath);
|
|
|
1592 |
}
|
|
|
1593 |
}
|
|
|
1594 |
|
|
|
1595 |
sendCommand(s);
|
|
|
1596 |
|
|
|
1597 |
if (!receiveSetup)
|
|
|
1598 |
{
|
|
|
1599 |
receiveSetup = true;
|
|
|
1600 |
ftransfer.maxFiles = countFiles();
|
|
|
1601 |
|
|
|
1602 |
if (callback)
|
|
|
1603 |
callback(ftr);
|
|
|
1604 |
else
|
|
|
1605 |
MSG_WARNING("Missing callback function!");
|
|
|
1606 |
}
|
|
|
1607 |
}
|
|
|
1608 |
else if (ft.ftype == 0 && ft.function == 0x0100) // Request directory
|
|
|
1609 |
{
|
|
|
1610 |
string fname((char *)&ft.data);
|
|
|
1611 |
string amxpath(fname);
|
|
|
1612 |
string realPath;
|
|
|
1613 |
size_t pos = 0;
|
|
|
1614 |
len = 0;
|
|
|
1615 |
dir::TDirectory dr;
|
|
|
1616 |
|
|
|
1617 |
if (fname.compare("AMXPanel/") == 0)
|
|
|
1618 |
{
|
|
|
1619 |
realPath.assign(TConfig::getProjectPath());
|
|
|
1620 |
amxpath.assign("/opt/amx/user/AMXPanel");
|
|
|
1621 |
}
|
|
|
1622 |
else if ((pos = fname.find("AMXPanel/")) != string::npos)
|
|
|
1623 |
{
|
|
|
1624 |
if (pos == 0)
|
|
|
1625 |
amxpath = "/opt/amx/user/" + fname;
|
|
|
1626 |
|
|
|
1627 |
realPath = dr.stripPath("AMXPanel", fname);
|
|
|
1628 |
realPath = TConfig::getProjectPath() + "/" + realPath;
|
|
|
1629 |
|
|
|
1630 |
if (dr.isFile(realPath))
|
|
|
1631 |
len = dr.getFileSize(realPath);
|
|
|
1632 |
}
|
|
|
1633 |
|
|
|
1634 |
MSG_DEBUG("0x0000/0x0100: Request directory " << fname);
|
|
|
1635 |
snprintf((char *)&ftr.data.filetransfer.data[0], sizeof(ftr.data.filetransfer.data), "Syncing %d files ...", ftransfer.maxFiles);
|
|
|
1636 |
|
|
|
1637 |
if (callback)
|
|
|
1638 |
callback(ftr);
|
|
|
1639 |
else
|
|
|
1640 |
MSG_WARNING("Missing callback function!");
|
|
|
1641 |
|
|
|
1642 |
s.channel = 0;
|
|
|
1643 |
s.level = 0;
|
|
|
1644 |
s.port = 0;
|
|
|
1645 |
s.value = 0;
|
|
|
1646 |
s.MC = 0x0204;
|
|
|
1647 |
s.dtype = 0x0000;
|
|
|
1648 |
s.type = 0x0101;
|
|
|
1649 |
s.value1 = len; // File length
|
|
|
1650 |
s.value2 = 0x0000be42;
|
|
|
1651 |
s.value3 = 0x00003e75;
|
|
|
1652 |
s.msg = amxpath;
|
|
|
1653 |
sendCommand(s);
|
|
|
1654 |
// Read the directory tree
|
|
|
1655 |
dr.setStripPath(true);
|
|
|
1656 |
dr.readDir(realPath);
|
|
|
1657 |
amxpath = fname;
|
|
|
1658 |
|
|
|
1659 |
if (amxpath.length() > 1 && amxpath.at(amxpath.length() - 1) == '/')
|
|
|
1660 |
amxpath = amxpath.substr(0, amxpath.length() - 1);
|
|
|
1661 |
|
|
|
1662 |
for (pos = 0; pos < dr.getNumEntries(); pos++)
|
|
|
1663 |
{
|
|
|
1664 |
dir::DFILES_T df = dr.getEntry(pos);
|
|
|
1665 |
s.type = 0x0102;
|
|
|
1666 |
|
|
|
1667 |
s.value = (dr.testDirectory(df.attr)) ? 1 : 0; // Depends on type of entry
|
|
|
1668 |
s.level = dr.getNumEntries(); // # entries
|
|
|
1669 |
s.value1 = df.count; // counter
|
|
|
1670 |
s.value2 = df.size; // Size of file
|
|
|
1671 |
s.value3 = df.date; // Last modification date (epoch)
|
|
|
1672 |
s.msg.assign(amxpath + "/" + df.name);
|
|
|
1673 |
sendCommand(s);
|
|
|
1674 |
}
|
|
|
1675 |
|
|
|
1676 |
if (dr.getNumEntries() == 0)
|
|
|
1677 |
{
|
|
|
1678 |
s.type = 0x0102;
|
|
|
1679 |
|
|
|
1680 |
s.value = 0;
|
|
|
1681 |
s.level = 0; // # entries
|
|
|
1682 |
s.value1 = 0; // counter
|
|
|
1683 |
s.value2 = 0; // Size of file
|
|
|
1684 |
s.value3 = 0; // Last modification date (epoch)
|
|
|
1685 |
s.msg.assign(amxpath + "/");
|
|
|
1686 |
sendCommand(s);
|
|
|
1687 |
}
|
|
|
1688 |
}
|
|
|
1689 |
else if (ft.ftype == 4 && ft.function == 0x0100) // Have more files to send.
|
|
|
1690 |
{
|
|
|
1691 |
MSG_DEBUG("0x0004/0x0100: Have more files to send.");
|
|
|
1692 |
s.channel = 0;
|
|
|
1693 |
s.level = 0;
|
|
|
1694 |
s.port = 0;
|
|
|
1695 |
s.value = 0;
|
|
|
1696 |
s.MC = 0x0204;
|
|
|
1697 |
s.dtype = 4; // ftype --> function type
|
|
|
1698 |
s.type = 0x0101; // function:
|
|
|
1699 |
s.value1 = 0x01bb3000; // ?
|
|
|
1700 |
s.value2 = 0; // ?
|
|
|
1701 |
sendCommand(s);
|
|
|
1702 |
}
|
|
|
1703 |
else if (ft.ftype == 4 && ft.function == 0x0102) // Controller will send a file
|
|
|
1704 |
{
|
|
|
1705 |
string f((char*)&ft.data);
|
|
|
1706 |
size_t pos;
|
|
|
1707 |
rcvFileName.assign(TConfig::getProjectPath());
|
|
|
1708 |
|
|
|
1709 |
if (f.find("AMXPanel") != string::npos)
|
|
|
1710 |
{
|
|
|
1711 |
pos = f.find_first_of("/");
|
|
|
1712 |
rcvFileName.append(f.substr(pos));
|
|
|
1713 |
}
|
|
|
1714 |
else
|
|
|
1715 |
{
|
|
|
1716 |
rcvFileName.append("/");
|
|
|
1717 |
rcvFileName.append((char*)&ft.data);
|
|
|
1718 |
}
|
|
|
1719 |
|
|
|
1720 |
if (rcvFile != nullptr)
|
|
|
1721 |
{
|
|
|
1722 |
fclose(rcvFile);
|
|
|
1723 |
rcvFile = nullptr;
|
|
|
1724 |
isOpenRcv = false;
|
|
|
1725 |
}
|
|
|
1726 |
|
|
|
1727 |
// The file name is encoded as CP1250 (Windows). Because we use UTF-8 we
|
|
|
1728 |
// must convert the file name to get rid of non ASCII characters.
|
|
|
1729 |
rcvFileName = cp1250ToUTF8(rcvFileName);
|
|
|
1730 |
dir::TDirectory dr;
|
|
|
1731 |
|
|
|
1732 |
if (!dr.exists(rcvFileName))
|
|
|
1733 |
dr.createAllPath(rcvFileName, true);
|
|
|
1734 |
else
|
|
|
1735 |
dr.drop(rcvFileName);
|
|
|
1736 |
|
|
|
1737 |
rcvFile = fopen(rcvFileName.c_str(), "w+");
|
|
|
1738 |
|
|
|
1739 |
if (!rcvFile)
|
|
|
1740 |
{
|
|
|
1741 |
MSG_ERROR("Error creating file " << rcvFileName << " (" << strerror(errno) << ")");
|
|
|
1742 |
isOpenRcv = false;
|
|
|
1743 |
}
|
|
|
1744 |
else
|
|
|
1745 |
{
|
|
|
1746 |
isOpenRcv = true;
|
|
|
1747 |
|
|
|
1748 |
if (!TStreamError::checkFilter(HLOG_TRACE))
|
|
|
1749 |
{
|
|
|
1750 |
MSG_INFO("Writing file: " << rcvFileName);
|
|
|
1751 |
}
|
|
|
1752 |
}
|
|
|
1753 |
|
|
|
1754 |
MSG_DEBUG("0x0004/0x0102: Controller will send file " << rcvFileName);
|
|
|
1755 |
|
|
|
1756 |
ftransfer.actFileNum++;
|
|
|
1757 |
ftransfer.lengthFile = ft.unk;
|
|
|
1758 |
|
|
|
1759 |
if (ftransfer.actFileNum > ftransfer.maxFiles)
|
|
|
1760 |
ftransfer.maxFiles = ftransfer.actFileNum;
|
|
|
1761 |
|
|
|
1762 |
ftransfer.percent = (int)(100.0 / (double)ftransfer.maxFiles * (double)ftransfer.actFileNum);
|
|
|
1763 |
pos = rcvFileName.find_last_of("/");
|
|
|
1764 |
string shfn;
|
|
|
1765 |
|
|
|
1766 |
if (pos != string::npos)
|
|
|
1767 |
shfn = rcvFileName.substr(pos + 1);
|
|
|
1768 |
else
|
|
|
1769 |
shfn = rcvFileName;
|
|
|
1770 |
|
|
|
1771 |
snprintf((char*)&ftr.data.filetransfer.data[0], sizeof(ftr.data.filetransfer.data), "[%d/%d] %s", ftransfer.actFileNum, ftransfer.maxFiles, shfn.c_str());
|
|
|
1772 |
ftr.count = ftransfer.percent;
|
|
|
1773 |
ftr.data.filetransfer.info1 = 0;
|
|
|
1774 |
|
|
|
1775 |
if (callback)
|
|
|
1776 |
callback(ftr);
|
|
|
1777 |
else
|
|
|
1778 |
MSG_WARNING("Missing callback function!");
|
|
|
1779 |
|
|
|
1780 |
posRcv = 0;
|
|
|
1781 |
lenRcv = ft.unk;
|
|
|
1782 |
s.channel = 0;
|
|
|
1783 |
s.level = 0;
|
|
|
1784 |
s.port = 0;
|
|
|
1785 |
s.value = 0;
|
|
|
1786 |
s.MC = 0x0204;
|
|
|
1787 |
s.dtype = 4; // ftype --> function type
|
|
|
1788 |
s.type = 0x0103; // function: ready for receiving file
|
|
|
1789 |
s.value1 = MAX_CHUNK; // Maximum length of a chunk
|
|
|
1790 |
s.value2 = ft.unk1; // ID?
|
|
|
1791 |
sendCommand(s);
|
|
|
1792 |
}
|
|
|
1793 |
else if (ft.ftype == 0 && ft.function == 0x0104) // Delete file <name>
|
|
|
1794 |
{
|
|
|
1795 |
dir::TDirectory dr;
|
|
|
1796 |
s.channel = 0;
|
|
|
1797 |
s.level = 0;
|
|
|
1798 |
s.port = 0;
|
|
|
1799 |
s.value = 0;
|
|
|
1800 |
s.MC = 0x0204;
|
|
|
1801 |
string f((char*)&ft.data[0]);
|
|
|
1802 |
size_t pos = 0;
|
|
|
1803 |
|
|
|
1804 |
if ((pos = f.find("AMXPanel/")) == string::npos)
|
|
|
1805 |
pos = f.find("__system/");
|
|
|
1806 |
|
|
|
1807 |
MSG_DEBUG("0x0000/0x0104: Delete file " << f);
|
|
|
1808 |
|
|
|
1809 |
if (pos != string::npos)
|
|
|
1810 |
f = TConfig::getProjectPath() + "/" + f.substr(pos + 9);
|
|
|
1811 |
else
|
|
|
1812 |
f = TConfig::getProjectPath() + "/" + f;
|
|
|
1813 |
|
|
|
1814 |
if (dr.exists(f))
|
|
|
1815 |
{
|
|
|
1816 |
s.dtype = 0; // ftype --> function type
|
|
|
1817 |
s.type = 0x0002; // function: yes file exists
|
|
|
1818 |
remove(f.c_str());
|
|
|
1819 |
}
|
|
|
1820 |
else // Send: file was deleted although it does not exist.
|
|
|
1821 |
{
|
|
|
1822 |
MSG_ERROR("[DELETE] File " << f << " not found!");
|
|
|
1823 |
s.dtype = 0; // ftype --> function type
|
|
|
1824 |
s.type = 0x0002; // function: yes file exists
|
|
|
1825 |
}
|
|
|
1826 |
|
|
|
1827 |
sendCommand(s);
|
|
|
1828 |
|
|
|
1829 |
if (ftransfer.actDelFile == 0)
|
|
|
1830 |
{
|
|
|
1831 |
ftransfer.actDelFile++;
|
|
|
1832 |
ftransfer.percent = (int)(100.0 / (double)ftransfer.maxFiles * (double)ftransfer.actDelFile);
|
|
|
1833 |
ftr.count = ftransfer.percent;
|
|
|
1834 |
|
|
|
1835 |
if (callback)
|
|
|
1836 |
callback(ftr);
|
|
|
1837 |
else
|
|
|
1838 |
MSG_WARNING("Missing callback function!");
|
|
|
1839 |
}
|
|
|
1840 |
else
|
|
|
1841 |
{
|
|
|
1842 |
ftransfer.actDelFile++;
|
|
|
1843 |
int prc = (int)(100.0 / (double)ftransfer.maxFiles * (double)ftransfer.actDelFile);
|
|
|
1844 |
|
|
|
1845 |
if (prc != ftransfer.percent)
|
|
|
1846 |
{
|
|
|
1847 |
ftransfer.percent = prc;
|
|
|
1848 |
ftr.count = prc;
|
|
|
1849 |
|
|
|
1850 |
if (callback)
|
|
|
1851 |
callback(ftr);
|
|
|
1852 |
else
|
|
|
1853 |
MSG_WARNING("Missing callback function!");
|
|
|
1854 |
}
|
|
|
1855 |
}
|
|
|
1856 |
}
|
|
|
1857 |
else if (ft.ftype == 4 && ft.function == 0x0104) // request a file
|
|
|
1858 |
{
|
|
|
1859 |
string f((char*)&ft.data);
|
|
|
1860 |
size_t pos;
|
|
|
1861 |
len = 0;
|
|
|
1862 |
sndFileName.assign(TConfig::getProjectPath());
|
|
|
1863 |
MSG_DEBUG("0x0004/0x0104: Request file " << f);
|
|
|
1864 |
|
|
|
1865 |
if (f.find("AMXPanel") != string::npos)
|
|
|
1866 |
{
|
|
|
1867 |
pos = f.find_first_of("/");
|
|
|
1868 |
sndFileName.append(f.substr(pos));
|
|
|
1869 |
}
|
|
|
1870 |
else
|
|
|
1871 |
{
|
|
|
1872 |
sndFileName.append("/");
|
|
|
1873 |
sndFileName.append(f);
|
|
|
1874 |
}
|
|
|
1875 |
|
|
|
1876 |
if (!access(sndFileName.c_str(), R_OK))
|
|
|
1877 |
{
|
|
|
1878 |
struct stat s;
|
|
|
1879 |
|
|
|
1880 |
if (stat(sndFileName.c_str(), &s) == 0)
|
|
|
1881 |
len = s.st_size;
|
|
|
1882 |
else
|
|
|
1883 |
len = 0;
|
|
|
1884 |
}
|
|
|
1885 |
else if (sndFileName.find("/version.xma") > 0)
|
|
|
1886 |
len = 0x0015;
|
|
|
1887 |
else
|
|
|
1888 |
len = 0;
|
|
|
1889 |
|
|
|
1890 |
MSG_DEBUG("0x0004/0x0104: (" << len << ") File: " << sndFileName);
|
|
|
1891 |
|
|
|
1892 |
s.channel = 0;
|
|
|
1893 |
s.level = 0;
|
|
|
1894 |
s.port = 0;
|
|
|
1895 |
s.value = 0;
|
|
|
1896 |
s.MC = 0x0204;
|
|
|
1897 |
s.dtype = 4; // ftype --> function type
|
|
|
1898 |
s.type = 0x0105; // function
|
|
|
1899 |
s.value1 = len; // length of file to send
|
|
|
1900 |
s.value2 = 0x00001388; // ID for device when sending a file.
|
|
|
1901 |
sendCommand(s);
|
|
|
1902 |
}
|
|
|
1903 |
else if (ft.ftype == 4 && ft.function == 0x0106) // Controller is ready for receiving file
|
|
|
1904 |
{
|
|
|
1905 |
MSG_DEBUG("0x0004/0x0106: Controller is ready for receiving file.");
|
|
|
1906 |
|
|
|
1907 |
if (!access(sndFileName.c_str(), R_OK))
|
|
|
1908 |
{
|
|
|
1909 |
struct stat st;
|
|
|
1910 |
stat(sndFileName.c_str(), &st);
|
|
|
1911 |
len = st.st_size;
|
|
|
1912 |
lenSnd = len;
|
|
|
1913 |
posSnd = 0;
|
|
|
1914 |
sndFile = fopen(sndFileName.c_str(), "r");
|
|
|
1915 |
|
|
|
1916 |
if (!sndFile)
|
|
|
1917 |
{
|
|
|
1918 |
MSG_ERROR("Error reading file " << sndFileName);
|
|
|
1919 |
len = 0;
|
|
|
1920 |
isOpenSnd = false;
|
|
|
1921 |
}
|
|
|
1922 |
else
|
|
|
1923 |
isOpenSnd = true;
|
|
|
1924 |
|
|
|
1925 |
if (isOpenSnd && len <= MAX_CHUNK)
|
|
|
1926 |
{
|
|
|
1927 |
char *buf = new char[len + 1];
|
|
|
1928 |
fread(buf, 1, len, sndFile);
|
|
|
1929 |
s.msg.assign(buf, len);
|
|
|
1930 |
delete[] buf;
|
|
|
1931 |
posSnd = len;
|
|
|
1932 |
}
|
|
|
1933 |
else if (isOpenSnd)
|
|
|
1934 |
{
|
|
|
1935 |
char *buf = new char[MAX_CHUNK + 1];
|
|
|
1936 |
fread(buf, 1, MAX_CHUNK, sndFile);
|
|
|
1937 |
s.msg.assign(buf, MAX_CHUNK);
|
|
|
1938 |
delete[] buf;
|
|
|
1939 |
posSnd = MAX_CHUNK;
|
|
|
1940 |
len = MAX_CHUNK;
|
|
|
1941 |
}
|
|
|
1942 |
}
|
|
|
1943 |
else if (sndFileName.find("/version.xma") > 0)
|
|
|
1944 |
{
|
|
|
1945 |
s.msg.assign("<version>9</version>\n");
|
|
|
1946 |
len = s.msg.length();
|
|
|
1947 |
posSnd = len;
|
|
|
1948 |
}
|
|
|
1949 |
else
|
|
|
1950 |
len = 0;
|
|
|
1951 |
|
|
|
1952 |
s.channel = 0;
|
|
|
1953 |
s.level = 0;
|
|
|
1954 |
s.port = 0;
|
|
|
1955 |
s.value = 0;
|
|
|
1956 |
s.MC = 0x0204;
|
|
|
1957 |
s.dtype = 4; // ftype --> function type
|
|
|
1958 |
s.type = 0x0003; // function: Sending file with length <len>
|
|
|
1959 |
s.value1 = len; // length of content to send
|
|
|
1960 |
sendCommand(s);
|
|
|
1961 |
}
|
|
|
1962 |
else if (ft.ftype == 4 && ft.function == 0x0002) // request next part of file
|
|
|
1963 |
{
|
|
|
1964 |
MSG_DEBUG("0x0004/0x0002: Request next part of file.");
|
|
|
1965 |
s.channel = 0;
|
|
|
1966 |
s.level = 0;
|
|
|
1967 |
s.port = 0;
|
|
|
1968 |
s.value = 0;
|
|
|
1969 |
s.MC = 0x0204;
|
|
|
1970 |
s.dtype = 4; // ftype --> function type
|
|
|
1971 |
|
|
|
1972 |
if (posSnd < lenSnd)
|
|
|
1973 |
{
|
|
|
1974 |
s.type = 0x0003; // Next part of file
|
|
|
1975 |
|
|
|
1976 |
if ((posSnd + MAX_CHUNK) > lenSnd)
|
|
|
1977 |
len = lenSnd - posSnd;
|
|
|
1978 |
else
|
|
|
1979 |
len = MAX_CHUNK;
|
|
|
1980 |
|
|
|
1981 |
s.value1 = len;
|
|
|
1982 |
|
|
|
1983 |
if (isOpenSnd)
|
|
|
1984 |
{
|
|
|
1985 |
char *buf = new char[len + 1];
|
|
|
1986 |
fread(buf, 1, len, sndFile);
|
|
|
1987 |
s.msg.assign(buf, len);
|
|
|
1988 |
delete[] buf;
|
|
|
1989 |
posSnd += len;
|
|
|
1990 |
}
|
|
|
1991 |
else
|
|
|
1992 |
s.value1 = 0;
|
|
|
1993 |
}
|
|
|
1994 |
else
|
|
|
1995 |
s.type = 0x0004; // function: End of file reached
|
|
|
1996 |
|
|
|
1997 |
sendCommand(s);
|
|
|
1998 |
}
|
|
|
1999 |
else if (ft.ftype == 4 && ft.function == 0x0003) // File content
|
|
|
2000 |
{
|
|
|
2001 |
MSG_DEBUG("0x0004/0x0003: Received (part of) file.");
|
|
|
2002 |
len = ft.unk;
|
|
|
2003 |
|
|
|
2004 |
if (isOpenRcv)
|
|
|
2005 |
{
|
|
|
2006 |
fwrite(ft.data, 1, len, rcvFile);
|
|
|
2007 |
posRcv += ft.unk;
|
|
|
2008 |
}
|
|
|
2009 |
else
|
|
|
2010 |
MSG_WARNING("No open file to write to! (" << rcvFileName << ")");
|
|
|
2011 |
|
|
|
2012 |
s.channel = 0;
|
|
|
2013 |
s.level = 0;
|
|
|
2014 |
s.port = 0;
|
|
|
2015 |
s.value = 0;
|
|
|
2016 |
s.MC = 0x0204;
|
|
|
2017 |
s.dtype = 4; // ftype --> function type
|
|
|
2018 |
s.type = 0x0002; // function: Request next part of file
|
|
|
2019 |
sendCommand(s);
|
|
|
2020 |
|
|
|
2021 |
int prc = (int)(100.0 / (double)ftransfer.lengthFile * (double)posRcv);
|
|
|
2022 |
|
|
|
2023 |
if (prc != ftr.data.filetransfer.info1)
|
|
|
2024 |
{
|
|
|
2025 |
ftr.data.filetransfer.info1 = (int)(100.0 / (double)ftransfer.lengthFile * (double)posRcv);
|
|
|
2026 |
ftr.count = ftransfer.percent;
|
|
|
2027 |
|
|
|
2028 |
if (callback)
|
|
|
2029 |
callback(ftr);
|
|
|
2030 |
else
|
|
|
2031 |
MSG_WARNING("Missing callback function!");
|
|
|
2032 |
}
|
|
|
2033 |
}
|
|
|
2034 |
else if (ft.ftype == 4 && ft.function == 0x0004) // End of file
|
|
|
2035 |
{
|
|
|
2036 |
MSG_DEBUG("0x0004/0x0004: End of file.");
|
|
|
2037 |
|
|
|
2038 |
if (isOpenRcv)
|
|
|
2039 |
{
|
|
|
2040 |
unsigned char buf[8];
|
|
|
2041 |
fseek(rcvFile, 0, SEEK_SET);
|
|
|
2042 |
fread(buf, 1, sizeof(buf), rcvFile);
|
|
|
2043 |
fclose(rcvFile);
|
|
|
2044 |
isOpenRcv = false;
|
|
|
2045 |
rcvFile = nullptr;
|
|
|
2046 |
posRcv = 0;
|
|
|
2047 |
|
|
|
2048 |
if (buf[0] == 0x1f && buf[1] == 0x8b) // GNUzip compressed?
|
|
|
2049 |
{
|
|
|
2050 |
TExpand exp(rcvFileName);
|
|
|
2051 |
exp.unzip();
|
|
|
2052 |
}
|
|
|
2053 |
}
|
|
|
2054 |
|
|
|
2055 |
ftr.count = ftransfer.percent;
|
|
|
2056 |
ftr.data.filetransfer.info1 = 100;
|
|
|
2057 |
|
|
|
2058 |
if (callback)
|
|
|
2059 |
callback(ftr);
|
|
|
2060 |
else
|
|
|
2061 |
MSG_WARNING("Missing callback functiom!");
|
|
|
2062 |
|
|
|
2063 |
s.channel = 0;
|
|
|
2064 |
s.level = 0;
|
|
|
2065 |
s.port = 0;
|
|
|
2066 |
s.value = 0;
|
|
|
2067 |
s.MC = 0x0204;
|
|
|
2068 |
s.dtype = 4; // ftype --> function type
|
|
|
2069 |
s.type = 0x0005; // function: ACK, file received. No answer expected.
|
|
|
2070 |
sendCommand(s);
|
|
|
2071 |
}
|
|
|
2072 |
else if (ft.ftype == 4 && ft.function == 0x0005) // ACK, controller received file, no answer
|
|
|
2073 |
{
|
|
|
2074 |
MSG_DEBUG("0x0004/0x0005: Controller received file.");
|
|
|
2075 |
posSnd = 0;
|
|
|
2076 |
lenSnd = 0;
|
|
|
2077 |
|
|
|
2078 |
if (isOpenSnd && sndFile != nullptr)
|
|
|
2079 |
fclose(sndFile);
|
|
|
2080 |
|
|
|
2081 |
ftransfer.lengthFile = 0;
|
|
|
2082 |
sndFile = nullptr;
|
|
|
2083 |
}
|
|
|
2084 |
else if (ft.ftype == 4 && ft.function == 0x0006) // End of directory transfer ACK
|
|
|
2085 |
{
|
|
|
2086 |
MSG_DEBUG("0x0004/0x0006: End of directory transfer.");
|
|
|
2087 |
}
|
|
|
2088 |
else if (ft.ftype == 4 && ft.function == 0x0007) // End of file transfer
|
|
|
2089 |
{
|
|
|
2090 |
MSG_DEBUG("0x0004/0x0007: End of file transfer.");
|
|
|
2091 |
|
|
|
2092 |
if (callback)
|
|
|
2093 |
callback(ftr);
|
|
|
2094 |
else
|
|
|
2095 |
MSG_WARNING("Missing callback function!");
|
|
|
2096 |
|
|
|
2097 |
receiveSetup = false;
|
|
|
2098 |
}
|
|
|
2099 |
}
|
|
|
2100 |
|
|
|
2101 |
int TAmxNet::msg97fill(ANET_COMMAND *com)
|
|
|
2102 |
{
|
|
|
2103 |
DECL_TRACER("TAmxNet::msg97fill(ANET_COMMAND *com)");
|
|
|
2104 |
|
|
|
2105 |
int pos = 0;
|
|
|
2106 |
unsigned char buf[512];
|
|
|
2107 |
|
|
|
2108 |
for (size_t i = 0; i < devInfo.size(); i++)
|
|
|
2109 |
{
|
|
|
2110 |
pos = 0;
|
|
|
2111 |
|
|
|
2112 |
if (i == 0)
|
|
|
2113 |
com->sep1 = 0x12;
|
|
|
2114 |
else
|
|
|
2115 |
com->sep1 = 0x02;
|
|
|
2116 |
|
|
|
2117 |
memset(buf, 0, sizeof(buf));
|
|
|
2118 |
com->data.srDeviceInfo.objectID = devInfo[i].objectID;
|
|
|
2119 |
com->data.srDeviceInfo.parentID = devInfo[i].parentID;
|
|
|
2120 |
com->data.srDeviceInfo.herstID = devInfo[i].manufacturerID;
|
|
|
2121 |
com->data.srDeviceInfo.deviceID = devInfo[i].deviceID;
|
|
|
2122 |
memcpy(com->data.srDeviceInfo.serial, devInfo[i].serialNum, 16);
|
|
|
2123 |
com->data.srDeviceInfo.fwid = devInfo[i].firmwareID;
|
|
|
2124 |
memcpy(buf, devInfo[i].versionInfo, strlen(devInfo[i].versionInfo));
|
|
|
2125 |
pos = (int)strlen(devInfo[i].versionInfo) + 1;
|
|
|
2126 |
memcpy(buf + pos, devInfo[i].deviceInfo, strlen(devInfo[i].deviceInfo));
|
|
|
2127 |
pos += strlen(devInfo[i].deviceInfo) + 1;
|
|
|
2128 |
memcpy(buf + pos, devInfo[i].manufacturerInfo, strlen(devInfo[i].manufacturerInfo));
|
|
|
2129 |
pos += strlen(devInfo[i].manufacturerInfo) + 1;
|
|
|
2130 |
*(buf + pos) = 0x02; // type IP address
|
|
|
2131 |
pos++;
|
|
|
2132 |
*(buf + pos) = 0x04; // field length: 4 bytes
|
|
|
2133 |
// Now the IP Address
|
|
|
2134 |
string addr = mSocket->getMyIP();
|
|
|
2135 |
vector<string> parts = StrSplit(addr, ".");
|
|
|
2136 |
|
|
|
2137 |
for (size_t i = 0; i < parts.size(); i++)
|
|
|
2138 |
{
|
|
|
2139 |
pos++;
|
|
|
2140 |
*(buf + pos) = (unsigned char)atoi(parts[i].c_str());
|
|
|
2141 |
}
|
|
|
2142 |
|
|
|
2143 |
pos++;
|
|
|
2144 |
com->data.srDeviceInfo.len = pos;
|
|
|
2145 |
memcpy(com->data.srDeviceInfo.info, buf, pos);
|
|
|
2146 |
com->hlen = 0x0016 - 3 + 31 + pos - 1;
|
|
|
2147 |
comStack.push_back(*com);
|
|
|
2148 |
sendCounter++;
|
|
|
2149 |
com->count = sendCounter;
|
|
|
2150 |
}
|
|
|
2151 |
|
|
|
2152 |
return pos;
|
|
|
2153 |
}
|
|
|
2154 |
|
|
|
2155 |
void TAmxNet::runWrite()
|
|
|
2156 |
{
|
|
|
2157 |
DECL_TRACER("TAmxNet::runWrite()");
|
|
|
2158 |
|
|
|
2159 |
if (write_busy)
|
|
|
2160 |
return;
|
|
|
2161 |
|
|
|
2162 |
try
|
|
|
2163 |
{
|
|
|
2164 |
mWriteThread = std::thread([=] { this->start_write(); });
|
|
|
2165 |
mWriteThread.detach();
|
|
|
2166 |
}
|
|
|
2167 |
catch (std::exception& e)
|
|
|
2168 |
{
|
|
|
2169 |
MSG_ERROR("Error starting write thread: " << e.what());
|
|
|
2170 |
_netRunning = false;
|
|
|
2171 |
}
|
|
|
2172 |
}
|
|
|
2173 |
|
|
|
2174 |
void TAmxNet::start_write()
|
|
|
2175 |
{
|
|
|
2176 |
DECL_TRACER("TAmxNet::start_write()");
|
|
|
2177 |
|
|
|
2178 |
if (!__CommValid || !mSocket || !isRunning() || !mSocket->isConnected())
|
|
|
2179 |
return;
|
|
|
2180 |
|
|
|
2181 |
if (write_busy)
|
|
|
2182 |
return;
|
|
|
2183 |
|
|
|
2184 |
write_busy = true;
|
|
|
2185 |
|
|
|
2186 |
while (write_busy && !_restart_ && !killed && _netRunning)
|
|
|
2187 |
{
|
|
|
2188 |
while (comStack.size() > 0)
|
|
|
2189 |
{
|
|
|
2190 |
if (!isRunning())
|
|
|
2191 |
{
|
|
|
2192 |
comStack.clear();
|
|
|
2193 |
write_busy = false;
|
|
|
2194 |
return;
|
|
|
2195 |
}
|
|
|
2196 |
|
|
|
2197 |
mSend = comStack.at(0);
|
|
|
2198 |
comStack.erase(comStack.begin()); // delete oldest element
|
|
|
2199 |
unsigned char *buf = makeBuffer(mSend);
|
|
|
2200 |
|
|
|
2201 |
if (buf == nullptr)
|
|
|
2202 |
{
|
|
|
2203 |
MSG_ERROR("Error creating a buffer! Token number: " << mSend.MC);
|
|
|
2204 |
continue;
|
|
|
2205 |
}
|
|
|
2206 |
|
| 464 |
andreas |
2207 |
MSG_DEBUG("Wrote buffer with token 0x" << std::setw(4) << std::setfill('0') << std::hex << mSend.MC << " and " << std::setw(0) << std::setfill(' ') << std::dec << (mSend.hlen + 4) << " bytes.");
|
| 446 |
andreas |
2208 |
mSocket->send((char *)buf, mSend.hlen + 4);
|
|
|
2209 |
delete[] buf;
|
|
|
2210 |
}
|
|
|
2211 |
|
|
|
2212 |
mSendReady = false;
|
|
|
2213 |
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
|
|
2214 |
}
|
|
|
2215 |
|
|
|
2216 |
write_busy = false;
|
|
|
2217 |
}
|
|
|
2218 |
|
|
|
2219 |
uint16_t TAmxNet::swapWord(uint16_t w)
|
|
|
2220 |
{
|
|
|
2221 |
uint16_t word = 0;
|
|
|
2222 |
word = ((w << 8) & 0xff00) | ((w >> 8) & 0x00ff);
|
|
|
2223 |
return word;
|
|
|
2224 |
}
|
|
|
2225 |
|
|
|
2226 |
uint32_t TAmxNet::swapDWord(uint32_t dw)
|
|
|
2227 |
{
|
|
|
2228 |
uint32_t dword = 0;
|
|
|
2229 |
dword = ((dw << 24) & 0xff000000) | ((dw << 8) & 0x00ff0000) | ((dw >> 8) & 0x0000ff00) | ((dw >> 24) & 0x000000ff);
|
|
|
2230 |
return dword;
|
|
|
2231 |
}
|
|
|
2232 |
|
|
|
2233 |
unsigned char TAmxNet::calcChecksum(const unsigned char* buffer, size_t len)
|
|
|
2234 |
{
|
|
|
2235 |
DECL_TRACER("TAmxNet::calcChecksum(const unsigned char* buffer, size_t len)");
|
|
|
2236 |
unsigned long sum = 0;
|
|
|
2237 |
|
|
|
2238 |
for (size_t i = 0; i < len; i++)
|
|
|
2239 |
sum += (unsigned long)(*(buffer + i)) & 0x000000ff;
|
|
|
2240 |
|
|
|
2241 |
sum &= 0x000000ff;
|
|
|
2242 |
MSG_DEBUG("Checksum=" << std::setw(2) << std::setfill('0') << std::hex << sum << ", #bytes=" << len << " bytes.");
|
|
|
2243 |
return (unsigned char)sum;
|
|
|
2244 |
}
|
|
|
2245 |
|
|
|
2246 |
uint16_t TAmxNet::makeWord(unsigned char b1, unsigned char b2)
|
|
|
2247 |
{
|
|
|
2248 |
return ((b1 << 8) & 0xff00) | b2;
|
|
|
2249 |
}
|
|
|
2250 |
|
|
|
2251 |
uint32_t TAmxNet::makeDWord(unsigned char b1, unsigned char b2, unsigned char b3, unsigned char b4)
|
|
|
2252 |
{
|
|
|
2253 |
return ((b1 << 24) & 0xff000000) | ((b2 << 16) & 0x00ff0000) | ((b3 << 8) & 0x0000ff00) | b4;
|
|
|
2254 |
}
|
|
|
2255 |
|
|
|
2256 |
bool TAmxNet::isCommand(const string& cmd)
|
|
|
2257 |
{
|
|
|
2258 |
DECL_TRACER("TAmxNet::isCommand(string& cmd)");
|
|
|
2259 |
|
|
|
2260 |
int i = 0;
|
|
|
2261 |
|
|
|
2262 |
while (cmdList[i][0] != 0)
|
|
|
2263 |
{
|
|
|
2264 |
if (cmd.find(cmdList[i]) == 0)
|
|
|
2265 |
return true;
|
|
|
2266 |
|
|
|
2267 |
i++;
|
|
|
2268 |
}
|
|
|
2269 |
|
|
|
2270 |
if (cmd.length() > 0 && (cmd[0] == '^' || cmd[0] == '@' || cmd[0] == '?'))
|
|
|
2271 |
return true;
|
|
|
2272 |
|
|
|
2273 |
if (startsWith(cmd, "GET ") || startsWith(cmd, "SET "))
|
|
|
2274 |
return true;
|
|
|
2275 |
|
|
|
2276 |
return false;
|
|
|
2277 |
}
|
|
|
2278 |
|
|
|
2279 |
unsigned char *TAmxNet::makeBuffer(const ANET_COMMAND& s)
|
|
|
2280 |
{
|
|
|
2281 |
DECL_TRACER("TAmxNet::makeBuffer (const ANET_COMMAND& s)");
|
|
|
2282 |
|
|
|
2283 |
int pos = 0;
|
|
|
2284 |
int len;
|
|
|
2285 |
bool valid = false;
|
|
|
2286 |
unsigned char *buf;
|
|
|
2287 |
|
|
|
2288 |
try
|
|
|
2289 |
{
|
|
|
2290 |
buf = new unsigned char[s.hlen + 5];
|
|
|
2291 |
memset(buf, 0, s.hlen + 5);
|
|
|
2292 |
}
|
|
|
2293 |
catch (std::exception& e)
|
|
|
2294 |
{
|
|
|
2295 |
MSG_ERROR("Error allocating memory: " << e.what());
|
|
|
2296 |
return nullptr;
|
|
|
2297 |
}
|
|
|
2298 |
|
|
|
2299 |
*buf = s.ID;
|
|
|
2300 |
*(buf + 1) = s.hlen >> 8;
|
|
|
2301 |
*(buf + 2) = s.hlen;
|
|
|
2302 |
*(buf + 3) = s.sep1;
|
|
|
2303 |
*(buf + 4) = s.type;
|
|
|
2304 |
*(buf + 5) = s.unk1 >> 8;
|
|
|
2305 |
*(buf + 6) = s.unk1;
|
|
|
2306 |
*(buf + 7) = s.device1 >> 8;
|
|
|
2307 |
*(buf + 8) = s.device1;
|
|
|
2308 |
*(buf + 9) = s.port1 >> 8;
|
|
|
2309 |
*(buf + 10) = s.port1;
|
|
|
2310 |
*(buf + 11) = s.system >> 8;
|
|
|
2311 |
*(buf + 12) = s.system;
|
|
|
2312 |
*(buf + 13) = s.device2 >> 8;
|
|
|
2313 |
*(buf + 14) = s.device2;
|
|
|
2314 |
*(buf + 15) = s.port2 >> 8;
|
|
|
2315 |
*(buf + 16) = s.port2;
|
|
|
2316 |
*(buf + 17) = s.unk6;
|
|
|
2317 |
*(buf + 18) = s.count >> 8;
|
|
|
2318 |
*(buf + 19) = s.count;
|
|
|
2319 |
*(buf + 20) = s.MC >> 8;
|
|
|
2320 |
*(buf + 21) = s.MC;
|
|
|
2321 |
|
|
|
2322 |
// Here the fixed block is complete. The data are following.
|
|
|
2323 |
switch (s.MC)
|
|
|
2324 |
{
|
|
|
2325 |
case 0x0006:
|
|
|
2326 |
case 0x0007:
|
|
|
2327 |
case 0x0018:
|
|
|
2328 |
case 0x0019:
|
|
|
2329 |
case 0x0084:
|
|
|
2330 |
case 0x0085:
|
|
|
2331 |
case 0x0086:
|
|
|
2332 |
case 0x0087:
|
|
|
2333 |
case 0x0088:
|
|
|
2334 |
case 0x0089:
|
|
|
2335 |
*(buf + 22) = s.data.chan_state.device >> 8;
|
|
|
2336 |
*(buf + 23) = s.data.chan_state.device;
|
|
|
2337 |
*(buf + 24) = s.data.chan_state.port >> 8;
|
|
|
2338 |
*(buf + 25) = s.data.chan_state.port;
|
|
|
2339 |
*(buf + 26) = s.data.chan_state.system >> 8;
|
|
|
2340 |
*(buf + 27) = s.data.chan_state.system;
|
|
|
2341 |
*(buf + 28) = s.data.chan_state.channel >> 8;
|
|
|
2342 |
*(buf + 29) = s.data.chan_state.channel;
|
|
|
2343 |
*(buf + 30) = calcChecksum(buf, 30);
|
|
|
2344 |
valid = true;
|
|
|
2345 |
break;
|
|
|
2346 |
|
|
|
2347 |
case 0x000a:
|
|
|
2348 |
case 0x008a:
|
|
|
2349 |
*(buf + 22) = s.data.message_value.device >> 8;
|
|
|
2350 |
*(buf + 23) = s.data.message_value.device;
|
|
|
2351 |
*(buf + 24) = s.data.message_value.port >> 8;
|
|
|
2352 |
*(buf + 25) = s.data.message_value.port;
|
|
|
2353 |
*(buf + 26) = s.data.message_value.system >> 8;
|
|
|
2354 |
*(buf + 27) = s.data.message_value.system;
|
|
|
2355 |
*(buf + 28) = s.data.message_value.value >> 8;
|
|
|
2356 |
*(buf + 29) = s.data.message_value.value;
|
|
|
2357 |
*(buf + 30) = s.data.message_value.type;
|
|
|
2358 |
pos = 31;
|
|
|
2359 |
|
|
|
2360 |
switch (s.data.message_value.type)
|
|
|
2361 |
{
|
|
|
2362 |
case 0x10: *(buf + pos) = s.data.message_value.content.byte; break;
|
|
|
2363 |
|
|
|
2364 |
case 0x11: *(buf + pos) = s.data.message_value.content.ch; break;
|
|
|
2365 |
|
|
|
2366 |
case 0x20:
|
|
|
2367 |
*(buf + pos) = s.data.message_value.content.integer >> 8;
|
|
|
2368 |
pos++;
|
|
|
2369 |
*(buf + pos) = s.data.message_value.content.integer;
|
|
|
2370 |
break;
|
|
|
2371 |
|
|
|
2372 |
case 0x21:
|
|
|
2373 |
*(buf + pos) = s.data.message_value.content.sinteger >> 8;
|
|
|
2374 |
pos++;
|
|
|
2375 |
*(buf + pos) = s.data.message_value.content.sinteger;
|
|
|
2376 |
break;
|
|
|
2377 |
|
|
|
2378 |
case 0x40:
|
|
|
2379 |
*(buf + pos) = s.data.message_value.content.dword >> 24;
|
|
|
2380 |
pos++;
|
|
|
2381 |
*(buf + pos) = s.data.message_value.content.dword >> 16;
|
|
|
2382 |
pos++;
|
|
|
2383 |
*(buf + pos) = s.data.message_value.content.dword >> 8;
|
|
|
2384 |
pos++;
|
|
|
2385 |
*(buf + pos) = s.data.message_value.content.dword;
|
|
|
2386 |
break;
|
|
|
2387 |
|
|
|
2388 |
case 0x41:
|
|
|
2389 |
*(buf + pos) = s.data.message_value.content.sdword >> 24;
|
|
|
2390 |
pos++;
|
|
|
2391 |
*(buf + pos) = s.data.message_value.content.sdword >> 16;
|
|
|
2392 |
pos++;
|
|
|
2393 |
*(buf + pos) = s.data.message_value.content.sdword >> 8;
|
|
|
2394 |
pos++;
|
|
|
2395 |
*(buf + pos) = s.data.message_value.content.sdword;
|
|
|
2396 |
break;
|
|
|
2397 |
|
|
|
2398 |
case 0x4f:
|
|
|
2399 |
memcpy(buf + pos, &s.data.message_value.content.fvalue, 4);
|
|
|
2400 |
pos += 3;
|
|
|
2401 |
break;
|
|
|
2402 |
|
|
|
2403 |
case 0x8f:
|
|
|
2404 |
memcpy(buf + pos, &s.data.message_value.content.fvalue, 8);
|
|
|
2405 |
pos += 3;
|
|
|
2406 |
break;
|
|
|
2407 |
}
|
|
|
2408 |
|
|
|
2409 |
pos++;
|
|
|
2410 |
*(buf + pos) = calcChecksum(buf, pos);
|
|
|
2411 |
valid = true;
|
|
|
2412 |
break;
|
|
|
2413 |
|
|
|
2414 |
case 0x000b:
|
|
|
2415 |
case 0x000c:
|
|
|
2416 |
case 0x008b:
|
|
|
2417 |
case 0x008c:
|
|
|
2418 |
*(buf + 22) = s.data.message_string.device >> 8;
|
|
|
2419 |
*(buf + 23) = s.data.message_string.device;
|
|
|
2420 |
*(buf + 24) = s.data.message_string.port >> 8;
|
|
|
2421 |
*(buf + 25) = s.data.message_string.port;
|
|
|
2422 |
*(buf + 26) = s.data.message_string.system >> 8;
|
|
|
2423 |
*(buf + 27) = s.data.message_string.system;
|
|
|
2424 |
*(buf + 28) = s.data.message_string.type;
|
|
|
2425 |
*(buf + 29) = s.data.message_string.length >> 8;
|
|
|
2426 |
*(buf + 30) = s.data.message_string.length;
|
|
|
2427 |
pos = 31;
|
|
|
2428 |
memcpy(buf + pos, s.data.message_string.content, s.data.message_string.length);
|
|
|
2429 |
pos += s.data.message_string.length;
|
|
|
2430 |
*(buf + pos) = calcChecksum(buf, pos);
|
|
|
2431 |
valid = true;
|
|
|
2432 |
break;
|
|
|
2433 |
|
|
|
2434 |
case 0x008d: // Custom event
|
|
|
2435 |
*(buf + 22) = s.data.customEvent.device >> 8;
|
|
|
2436 |
*(buf + 23) = s.data.customEvent.device;
|
|
|
2437 |
*(buf + 24) = s.data.customEvent.port >> 8;
|
|
|
2438 |
*(buf + 25) = s.data.customEvent.port;
|
|
|
2439 |
*(buf + 26) = s.data.customEvent.system >> 8;
|
|
|
2440 |
*(buf + 27) = s.data.customEvent.system;
|
|
|
2441 |
*(buf + 28) = s.data.customEvent.ID >> 8;
|
|
|
2442 |
*(buf + 29) = s.data.customEvent.ID;
|
|
|
2443 |
*(buf + 30) = s.data.customEvent.type >> 8;
|
|
|
2444 |
*(buf + 31) = s.data.customEvent.type;
|
|
|
2445 |
*(buf + 32) = s.data.customEvent.flag >> 8;
|
|
|
2446 |
*(buf + 33) = s.data.customEvent.flag;
|
|
|
2447 |
*(buf + 34) = s.data.customEvent.value1 >> 24;
|
|
|
2448 |
*(buf + 35) = s.data.customEvent.value1 >> 16;
|
|
|
2449 |
*(buf + 36) = s.data.customEvent.value1 >> 8;
|
|
|
2450 |
*(buf + 37) = s.data.customEvent.value1;
|
|
|
2451 |
*(buf + 38) = s.data.customEvent.value2 >> 24;
|
|
|
2452 |
*(buf + 39) = s.data.customEvent.value2 >> 16;
|
|
|
2453 |
*(buf + 40) = s.data.customEvent.value2 >> 8;
|
|
|
2454 |
*(buf + 41) = s.data.customEvent.value2;
|
|
|
2455 |
*(buf + 42) = s.data.customEvent.value3 >> 24;
|
|
|
2456 |
*(buf + 43) = s.data.customEvent.value3 >> 16;
|
|
|
2457 |
*(buf + 44) = s.data.customEvent.value3 >> 8;
|
|
|
2458 |
*(buf + 45) = s.data.customEvent.value3;
|
|
|
2459 |
*(buf + 46) = s.data.customEvent.dtype;
|
|
|
2460 |
*(buf + 47) = s.data.customEvent.length >> 8;
|
|
|
2461 |
*(buf + 48) = s.data.customEvent.length;
|
|
|
2462 |
pos = 49;
|
|
|
2463 |
|
|
|
2464 |
if (s.data.customEvent.length > 0)
|
|
|
2465 |
{
|
|
|
2466 |
memcpy(buf + pos, s.data.customEvent.data, s.data.customEvent.length);
|
|
|
2467 |
pos += s.data.customEvent.length;
|
|
|
2468 |
}
|
|
|
2469 |
|
|
|
2470 |
*(buf + pos) = 0;
|
|
|
2471 |
*(buf + pos + 1) = 0;
|
|
|
2472 |
pos += 2;
|
|
|
2473 |
*(buf + pos) = calcChecksum(buf, pos);
|
|
|
2474 |
valid = true;
|
|
|
2475 |
break;
|
|
|
2476 |
|
|
|
2477 |
case 0x0090:
|
|
|
2478 |
*(buf + 22) = s.data.sendPortNumber.device >> 8;
|
|
|
2479 |
*(buf + 23) = s.data.sendPortNumber.device;
|
|
|
2480 |
*(buf + 24) = s.data.sendPortNumber.system >> 8;
|
|
|
2481 |
*(buf + 25) = s.data.sendPortNumber.system;
|
|
|
2482 |
*(buf + 26) = s.data.sendPortNumber.pcount >> 8;
|
|
|
2483 |
*(buf + 27) = s.data.sendPortNumber.pcount;
|
|
|
2484 |
*(buf + 28) = calcChecksum(buf, 28);
|
|
|
2485 |
valid = true;
|
|
|
2486 |
break;
|
|
|
2487 |
|
|
|
2488 |
case 0x0091:
|
|
|
2489 |
case 0x0092:
|
|
|
2490 |
*(buf + 22) = s.data.sendOutpChannels.device >> 8;
|
|
|
2491 |
*(buf + 23) = s.data.sendOutpChannels.device;
|
|
|
2492 |
*(buf + 24) = s.data.sendOutpChannels.port >> 8;
|
|
|
2493 |
*(buf + 25) = s.data.sendOutpChannels.port;
|
|
|
2494 |
*(buf + 26) = s.data.sendOutpChannels.system >> 8;
|
|
|
2495 |
*(buf + 27) = s.data.sendOutpChannels.system;
|
|
|
2496 |
*(buf + 28) = s.data.sendOutpChannels.count >> 8;
|
|
|
2497 |
*(buf + 29) = s.data.sendOutpChannels.count;
|
|
|
2498 |
*(buf + 30) = calcChecksum(buf, 30);
|
|
|
2499 |
valid = true;
|
|
|
2500 |
break;
|
|
|
2501 |
|
|
|
2502 |
case 0x0093:
|
|
|
2503 |
case 0x0094:
|
|
|
2504 |
*(buf + 22) = s.data.sendSize.device >> 8;
|
|
|
2505 |
*(buf + 23) = s.data.sendSize.device;
|
|
|
2506 |
*(buf + 24) = s.data.sendSize.port >> 8;
|
|
|
2507 |
*(buf + 25) = s.data.sendSize.port;
|
|
|
2508 |
*(buf + 26) = s.data.sendSize.system >> 8;
|
|
|
2509 |
*(buf + 27) = s.data.sendSize.system;
|
|
|
2510 |
*(buf + 28) = s.data.sendSize.type;
|
|
|
2511 |
*(buf + 29) = s.data.sendSize.length >> 8;
|
|
|
2512 |
*(buf + 30) = s.data.sendSize.length;
|
|
|
2513 |
*(buf + 31) = calcChecksum(buf, 31);
|
|
|
2514 |
valid = true;
|
|
|
2515 |
break;
|
|
|
2516 |
|
|
|
2517 |
case 0x0095:
|
|
|
2518 |
*(buf + 22) = s.data.sendLevSupport.device >> 8;
|
|
|
2519 |
*(buf + 23) = s.data.sendLevSupport.device;
|
|
|
2520 |
*(buf + 24) = s.data.sendLevSupport.port >> 8;
|
|
|
2521 |
*(buf + 25) = s.data.sendLevSupport.port;
|
|
|
2522 |
*(buf + 26) = s.data.sendLevSupport.system >> 8;
|
|
|
2523 |
*(buf + 27) = s.data.sendLevSupport.system;
|
|
|
2524 |
*(buf + 28) = s.data.sendLevSupport.level >> 8;
|
|
|
2525 |
*(buf + 29) = s.data.sendLevSupport.level;
|
|
|
2526 |
*(buf + 30) = s.data.sendLevSupport.num;
|
|
|
2527 |
*(buf + 31) = s.data.sendLevSupport.types[0];
|
|
|
2528 |
*(buf + 32) = s.data.sendLevSupport.types[1];
|
|
|
2529 |
*(buf + 33) = s.data.sendLevSupport.types[2];
|
|
|
2530 |
*(buf + 34) = s.data.sendLevSupport.types[3];
|
|
|
2531 |
*(buf + 35) = s.data.sendLevSupport.types[4];
|
|
|
2532 |
*(buf + 36) = s.data.sendLevSupport.types[5];
|
|
|
2533 |
*(buf + 37) = calcChecksum(buf, 37);
|
|
|
2534 |
valid = true;
|
|
|
2535 |
break;
|
|
|
2536 |
|
|
|
2537 |
case 0x0096:
|
|
|
2538 |
*(buf + 22) = s.data.sendStatusCode.device >> 8;
|
|
|
2539 |
*(buf + 23) = s.data.sendStatusCode.device;
|
|
|
2540 |
*(buf + 24) = s.data.sendStatusCode.port >> 8;
|
|
|
2541 |
*(buf + 25) = s.data.sendStatusCode.port;
|
|
|
2542 |
*(buf + 26) = s.data.sendStatusCode.system >> 8;
|
|
|
2543 |
*(buf + 27) = s.data.sendStatusCode.system;
|
|
|
2544 |
*(buf + 28) = s.data.sendStatusCode.status >> 8;
|
|
|
2545 |
*(buf + 29) = s.data.sendStatusCode.status;
|
|
|
2546 |
*(buf + 30) = s.data.sendStatusCode.type;
|
|
|
2547 |
*(buf + 31) = s.data.sendStatusCode.length >> 8;
|
|
|
2548 |
*(buf + 32) = s.data.sendStatusCode.length;
|
|
|
2549 |
pos = 33;
|
|
|
2550 |
memset((void*)&s.data.sendStatusCode.str[0], 0, sizeof(s.data.sendStatusCode.str));
|
|
|
2551 |
memcpy(buf + pos, s.data.sendStatusCode.str, s.data.sendStatusCode.length);
|
|
|
2552 |
pos += s.data.sendStatusCode.length;
|
|
|
2553 |
*(buf + pos) = calcChecksum(buf, pos);
|
|
|
2554 |
valid = true;
|
|
|
2555 |
break;
|
|
|
2556 |
|
|
|
2557 |
case 0x0097:
|
|
|
2558 |
*(buf + 22) = s.data.srDeviceInfo.device >> 8;
|
|
|
2559 |
*(buf + 23) = s.data.srDeviceInfo.device;
|
|
|
2560 |
*(buf + 24) = s.data.srDeviceInfo.system >> 8;
|
|
|
2561 |
*(buf + 25) = s.data.srDeviceInfo.system;
|
|
|
2562 |
*(buf + 26) = s.data.srDeviceInfo.flag >> 8;
|
|
|
2563 |
*(buf + 27) = s.data.srDeviceInfo.flag;
|
|
|
2564 |
*(buf + 28) = s.data.srDeviceInfo.objectID;
|
|
|
2565 |
*(buf + 29) = s.data.srDeviceInfo.parentID;
|
|
|
2566 |
*(buf + 30) = s.data.srDeviceInfo.herstID >> 8;
|
|
|
2567 |
*(buf + 31) = s.data.srDeviceInfo.herstID;
|
|
|
2568 |
*(buf + 32) = s.data.srDeviceInfo.deviceID >> 8;
|
|
|
2569 |
*(buf + 33) = s.data.srDeviceInfo.deviceID;
|
|
|
2570 |
pos = 34;
|
|
|
2571 |
memcpy(buf + pos, s.data.srDeviceInfo.serial, 16);
|
|
|
2572 |
pos += 16;
|
|
|
2573 |
*(buf + pos) = s.data.srDeviceInfo.fwid >> 8;
|
|
|
2574 |
pos++;
|
|
|
2575 |
*(buf + pos) = s.data.srDeviceInfo.fwid;
|
|
|
2576 |
pos++;
|
|
|
2577 |
memcpy(buf + pos, s.data.srDeviceInfo.info, s.data.srDeviceInfo.len);
|
|
|
2578 |
pos += s.data.srDeviceInfo.len;
|
|
|
2579 |
*(buf + pos) = calcChecksum(buf, pos);
|
|
|
2580 |
valid = true;
|
|
|
2581 |
break;
|
|
|
2582 |
|
|
|
2583 |
case 0x0098:
|
|
|
2584 |
*(buf + 22) = s.data.reqPortCount.device >> 8;
|
|
|
2585 |
*(buf + 23) = s.data.reqPortCount.device;
|
|
|
2586 |
*(buf + 24) = s.data.reqPortCount.system >> 8;
|
|
|
2587 |
*(buf + 25) = s.data.reqPortCount.system;
|
|
|
2588 |
*(buf + 26) = calcChecksum(buf, 26);
|
|
|
2589 |
valid = true;
|
|
|
2590 |
break;
|
|
|
2591 |
|
|
|
2592 |
case 0x0204: // file transfer
|
|
|
2593 |
*(buf + 22) = s.data.filetransfer.ftype >> 8;
|
|
|
2594 |
*(buf + 23) = s.data.filetransfer.ftype;
|
|
|
2595 |
*(buf + 24) = s.data.filetransfer.function >> 8;
|
|
|
2596 |
*(buf + 25) = s.data.filetransfer.function;
|
|
|
2597 |
pos = 26;
|
|
|
2598 |
|
|
|
2599 |
switch (s.data.filetransfer.function)
|
|
|
2600 |
{
|
|
|
2601 |
case 0x0001:
|
|
|
2602 |
*(buf + 26) = s.data.filetransfer.unk;
|
|
|
2603 |
*(buf + 27) = s.data.filetransfer.unk1;
|
|
|
2604 |
pos = 28;
|
|
|
2605 |
break;
|
|
|
2606 |
|
|
|
2607 |
case 0x0003:
|
|
|
2608 |
*(buf + 26) = s.data.filetransfer.unk >> 8;
|
|
|
2609 |
*(buf + 27) = s.data.filetransfer.unk;
|
|
|
2610 |
pos = 28;
|
|
|
2611 |
|
|
|
2612 |
for (uint32_t i = 0; i < s.data.filetransfer.unk && pos < (s.hlen + 3); i++)
|
|
|
2613 |
{
|
|
|
2614 |
*(buf + pos) = s.data.filetransfer.data[i];
|
|
|
2615 |
pos++;
|
|
|
2616 |
}
|
|
|
2617 |
break;
|
|
|
2618 |
|
|
|
2619 |
case 0x0101:
|
|
|
2620 |
if (s.data.filetransfer.ftype == 0)
|
|
|
2621 |
{
|
|
|
2622 |
*(buf + 26) = s.data.filetransfer.unk >> 24;
|
|
|
2623 |
*(buf + 27) = s.data.filetransfer.unk >> 16;
|
|
|
2624 |
*(buf + 28) = s.data.filetransfer.unk >> 8;
|
|
|
2625 |
*(buf + 29) = s.data.filetransfer.unk;
|
|
|
2626 |
*(buf + 30) = s.data.filetransfer.unk1 >> 24;
|
|
|
2627 |
*(buf + 31) = s.data.filetransfer.unk1 >> 16;
|
|
|
2628 |
*(buf + 32) = s.data.filetransfer.unk1 >> 8;
|
|
|
2629 |
*(buf + 33) = s.data.filetransfer.unk1;
|
|
|
2630 |
*(buf + 34) = s.data.filetransfer.unk2 >> 24;
|
|
|
2631 |
*(buf + 35) = s.data.filetransfer.unk2 >> 16;
|
|
|
2632 |
*(buf + 36) = s.data.filetransfer.unk2 >> 8;
|
|
|
2633 |
*(buf + 37) = s.data.filetransfer.unk2;
|
|
|
2634 |
*(buf + 38) = 0x00;
|
|
|
2635 |
*(buf + 39) = 0x00;
|
|
|
2636 |
*(buf + 40) = 0x3e;
|
|
|
2637 |
*(buf + 41) = 0x75;
|
|
|
2638 |
pos = 42;
|
|
|
2639 |
len = 0;
|
|
|
2640 |
|
|
|
2641 |
while (s.data.filetransfer.data[len] != 0)
|
|
|
2642 |
{
|
|
|
2643 |
*(buf + pos) = s.data.filetransfer.data[len];
|
|
|
2644 |
len++;
|
|
|
2645 |
pos++;
|
|
|
2646 |
}
|
|
|
2647 |
|
|
|
2648 |
*(buf + pos) = 0;
|
|
|
2649 |
pos++;
|
|
|
2650 |
}
|
|
|
2651 |
else
|
|
|
2652 |
{
|
|
|
2653 |
*(buf + 26) = s.data.filetransfer.unk >> 24;
|
|
|
2654 |
*(buf + 27) = s.data.filetransfer.unk >> 16;
|
|
|
2655 |
*(buf + 28) = s.data.filetransfer.unk >> 8;
|
|
|
2656 |
*(buf + 29) = s.data.filetransfer.unk;
|
|
|
2657 |
*(buf + 30) = 0x00;
|
|
|
2658 |
*(buf + 31) = 0x00;
|
|
|
2659 |
*(buf + 32) = 0x00;
|
|
|
2660 |
*(buf + 33) = 0x00;
|
|
|
2661 |
pos = 34;
|
|
|
2662 |
}
|
|
|
2663 |
|
|
|
2664 |
break;
|
|
|
2665 |
|
|
|
2666 |
case 0x0102:
|
|
|
2667 |
*(buf + 26) = 0x00;
|
|
|
2668 |
*(buf + 27) = 0x00;
|
|
|
2669 |
*(buf + 28) = 0x00;
|
|
|
2670 |
*(buf + 29) = s.data.filetransfer.info1; // dir flag
|
|
|
2671 |
*(buf + 30) = s.data.filetransfer.info2 >> 8; // # entries
|
|
|
2672 |
*(buf + 31) = s.data.filetransfer.info2;
|
|
|
2673 |
*(buf + 32) = s.data.filetransfer.unk >> 8; // counter
|
|
|
2674 |
*(buf + 33) = s.data.filetransfer.unk;
|
|
|
2675 |
*(buf + 34) = s.data.filetransfer.unk1 >> 24; // file size
|
|
|
2676 |
*(buf + 35) = s.data.filetransfer.unk1 >> 16;
|
|
|
2677 |
*(buf + 36) = s.data.filetransfer.unk1 >> 8;
|
|
|
2678 |
*(buf + 37) = s.data.filetransfer.unk1;
|
|
|
2679 |
*(buf + 38) = (s.data.filetransfer.info1 == 1) ? 0x0c : 0x0b;
|
|
|
2680 |
*(buf + 39) = (s.data.filetransfer.info1 == 1) ? 0x0e : 0x13;
|
|
|
2681 |
*(buf + 40) = 0x07;
|
|
|
2682 |
*(buf + 41) = s.data.filetransfer.unk2 >> 24; // Date
|
|
|
2683 |
*(buf + 42) = s.data.filetransfer.unk2 >> 16;
|
|
|
2684 |
*(buf + 43) = s.data.filetransfer.unk2 >> 8;
|
|
|
2685 |
*(buf + 44) = s.data.filetransfer.unk2;
|
|
|
2686 |
pos = 45;
|
|
|
2687 |
len = 0;
|
|
|
2688 |
|
|
|
2689 |
while (s.data.filetransfer.data[len] != 0)
|
|
|
2690 |
{
|
|
|
2691 |
*(buf + pos) = s.data.filetransfer.data[len];
|
|
|
2692 |
pos++;
|
|
|
2693 |
len++;
|
|
|
2694 |
}
|
|
|
2695 |
|
|
|
2696 |
*(buf + pos) = 0;
|
|
|
2697 |
pos++;
|
|
|
2698 |
break;
|
|
|
2699 |
|
|
|
2700 |
case 0x0103:
|
|
|
2701 |
*(buf + 26) = s.data.filetransfer.unk >> 8;
|
|
|
2702 |
*(buf + 27) = s.data.filetransfer.unk;
|
|
|
2703 |
*(buf + 28) = s.data.filetransfer.unk1 >> 24;
|
|
|
2704 |
*(buf + 29) = s.data.filetransfer.unk1 >> 16;
|
|
|
2705 |
*(buf + 30) = s.data.filetransfer.unk1 >> 8;
|
|
|
2706 |
*(buf + 31) = s.data.filetransfer.unk1;
|
|
|
2707 |
pos = 32;
|
|
|
2708 |
break;
|
|
|
2709 |
|
|
|
2710 |
case 0x105:
|
|
|
2711 |
*(buf + 26) = s.data.filetransfer.unk >> 24;
|
|
|
2712 |
*(buf + 27) = s.data.filetransfer.unk >> 16;
|
|
|
2713 |
*(buf + 28) = s.data.filetransfer.unk >> 8;
|
|
|
2714 |
*(buf + 29) = s.data.filetransfer.unk;
|
|
|
2715 |
*(buf + 30) = s.data.filetransfer.unk1 >> 24;
|
|
|
2716 |
*(buf + 31) = s.data.filetransfer.unk1 >> 16;
|
|
|
2717 |
*(buf + 32) = s.data.filetransfer.unk1 >> 8;
|
|
|
2718 |
*(buf + 33) = s.data.filetransfer.unk1;
|
|
|
2719 |
pos = 34;
|
|
|
2720 |
break;
|
|
|
2721 |
}
|
|
|
2722 |
|
|
|
2723 |
*(buf + pos) = calcChecksum(buf, pos);
|
|
|
2724 |
valid = true;
|
|
|
2725 |
break;
|
|
|
2726 |
|
| 464 |
andreas |
2727 |
case 0x020c:
|
|
|
2728 |
case 0x020e:
|
|
|
2729 |
*(buf+22) = s.data.network.bf;
|
| 465 |
andreas |
2730 |
pos = 23;
|
|
|
2731 |
memcpy(buf+pos, s.data.network.data, s.data.network.len);
|
|
|
2732 |
pos += s.data.network.len;
|
|
|
2733 |
*(buf+pos) = calcChecksum(buf, pos);
|
| 464 |
andreas |
2734 |
valid = true;
|
|
|
2735 |
break;
|
|
|
2736 |
|
| 446 |
andreas |
2737 |
case 0x0581: // Pong
|
|
|
2738 |
*(buf + 22) = s.data.srDeviceInfo.device >> 8;
|
|
|
2739 |
*(buf + 23) = s.data.srDeviceInfo.device;
|
|
|
2740 |
*(buf + 24) = s.data.srDeviceInfo.system >> 8;
|
|
|
2741 |
*(buf + 25) = s.data.srDeviceInfo.system;
|
|
|
2742 |
*(buf + 26) = s.data.srDeviceInfo.herstID >> 8;
|
|
|
2743 |
*(buf + 27) = s.data.srDeviceInfo.herstID;
|
|
|
2744 |
*(buf + 28) = s.data.srDeviceInfo.deviceID >> 8;
|
|
|
2745 |
*(buf + 29) = s.data.srDeviceInfo.deviceID;
|
|
|
2746 |
*(buf + 30) = s.data.srDeviceInfo.info[0];
|
|
|
2747 |
*(buf + 31) = s.data.srDeviceInfo.info[1];
|
|
|
2748 |
*(buf + 32) = s.data.srDeviceInfo.info[2];
|
|
|
2749 |
*(buf + 33) = s.data.srDeviceInfo.info[3];
|
|
|
2750 |
*(buf + 34) = s.data.srDeviceInfo.info[4];
|
|
|
2751 |
*(buf + 35) = s.data.srDeviceInfo.info[5];
|
|
|
2752 |
*(buf + 36) = calcChecksum(buf, 36);
|
|
|
2753 |
valid = true;
|
|
|
2754 |
break;
|
|
|
2755 |
}
|
|
|
2756 |
|
|
|
2757 |
if (!valid)
|
|
|
2758 |
{
|
|
|
2759 |
delete[] buf;
|
|
|
2760 |
return 0;
|
|
|
2761 |
}
|
|
|
2762 |
|
|
|
2763 |
// MSG_TRACE("Buffer:");
|
|
|
2764 |
// TError::logHex((char *)buf, s.hlen + 4);
|
|
|
2765 |
return buf;
|
|
|
2766 |
}
|
|
|
2767 |
|
|
|
2768 |
void TAmxNet::setSerialNum(const string& sn)
|
|
|
2769 |
{
|
|
|
2770 |
DECL_TRACER("TAmxNet::setSerialNum(const string& sn)");
|
|
|
2771 |
|
|
|
2772 |
serNum = sn;
|
|
|
2773 |
size_t len = (sn.length() > 15) ? 15 : sn.length();
|
|
|
2774 |
|
|
|
2775 |
for (size_t i = 0; i < devInfo.size(); i++)
|
|
|
2776 |
strncpy(devInfo[i].serialNum, sn.c_str(), len);
|
|
|
2777 |
}
|
|
|
2778 |
|
|
|
2779 |
int TAmxNet::countFiles()
|
|
|
2780 |
{
|
|
|
2781 |
DECL_TRACER("TAmxNet::countFiles()");
|
|
|
2782 |
|
|
|
2783 |
int count = 0;
|
|
|
2784 |
ifstream in;
|
|
|
2785 |
|
|
|
2786 |
try
|
|
|
2787 |
{
|
|
|
2788 |
in.open(TConfig::getProjectPath() + "/manifest.xma", fstream::in);
|
|
|
2789 |
|
|
|
2790 |
if (!in)
|
|
|
2791 |
return 0;
|
|
|
2792 |
|
|
|
2793 |
for (string line; getline(in, line);)
|
|
|
2794 |
count++;
|
|
|
2795 |
|
|
|
2796 |
in.close();
|
|
|
2797 |
}
|
|
|
2798 |
catch (exception& e)
|
|
|
2799 |
{
|
|
|
2800 |
MSG_ERROR("Error: " << e.what());
|
|
|
2801 |
return 0;
|
|
|
2802 |
}
|
|
|
2803 |
|
|
|
2804 |
return count;
|
|
|
2805 |
}
|
|
|
2806 |
|
|
|
2807 |
void TAmxNet::sendAllFuncNetwork(int state)
|
|
|
2808 |
{
|
|
|
2809 |
DECL_TRACER("TAmxNet::sendAllFuncNetwork(int state)");
|
|
|
2810 |
|
|
|
2811 |
mLastOnlineState = state;
|
|
|
2812 |
|
|
|
2813 |
if (mFuncsNetwork.empty())
|
|
|
2814 |
return;
|
|
|
2815 |
|
|
|
2816 |
MSG_DEBUG("Setting network state to " << state);
|
|
|
2817 |
map<ulong, FUNC_NETWORK_t>::iterator iter;
|
|
|
2818 |
|
|
|
2819 |
for (iter = mFuncsNetwork.begin(); iter != mFuncsNetwork.end(); ++iter)
|
|
|
2820 |
iter->second.func(state);
|
|
|
2821 |
}
|
|
|
2822 |
|
|
|
2823 |
void TAmxNet::sendAllFuncTimer(const ANET_BLINK& blink)
|
|
|
2824 |
{
|
|
|
2825 |
DECL_TRACER("TAmxNet::sendAllFuncTimer(const ANET_BLINK& blink)");
|
|
|
2826 |
|
|
|
2827 |
if (mFuncsTimer.empty())
|
|
|
2828 |
return;
|
|
|
2829 |
|
|
|
2830 |
map<ulong, FUNC_TIMER_t>::iterator iter;
|
|
|
2831 |
|
|
|
2832 |
for (iter = mFuncsTimer.begin(); iter != mFuncsTimer.end(); ++iter)
|
|
|
2833 |
iter->second.func(blink);
|
|
|
2834 |
}
|
|
|
2835 |
|
|
|
2836 |
void TAmxNet::setWaitTime(int secs)
|
|
|
2837 |
{
|
|
|
2838 |
DECL_TRACER("TAmxNet::setWaitTime(int secs)");
|
|
|
2839 |
|
|
|
2840 |
if (secs <= 0 || secs > 300) // Maximal 5 minutes
|
|
|
2841 |
return;
|
|
|
2842 |
|
|
|
2843 |
mOldWaitTime = mWaitTime;
|
|
|
2844 |
mWaitTime = secs;
|
|
|
2845 |
}
|
|
|
2846 |
|
|
|
2847 |
int TAmxNet::swapWaitTime()
|
|
|
2848 |
{
|
|
|
2849 |
DECL_TRACER("TAmxNet::restoreWaitTime()");
|
|
|
2850 |
|
|
|
2851 |
int wt = mWaitTime;
|
|
|
2852 |
|
|
|
2853 |
mWaitTime = mOldWaitTime;
|
|
|
2854 |
mOldWaitTime = wt;
|
|
|
2855 |
return mWaitTime;
|
|
|
2856 |
}
|