1 // SoftEther VPN Source Code - Stable Edition Repository
2 // Cedar Communication Module
3 //
4 // SoftEther VPN Server, Client and Bridge are free software under the Apache License, Version 2.0.
5 //
6 // Copyright (c) Daiyuu Nobori.
7 // Copyright (c) SoftEther VPN Project, University of Tsukuba, Japan.
8 // Copyright (c) SoftEther Corporation.
9 // Copyright (c) all contributors on SoftEther VPN project in GitHub.
10 //
11 // All Rights Reserved.
12 //
13 // http://www.softether.org/
14 //
15 // This stable branch is officially managed by Daiyuu Nobori, the owner of SoftEther VPN Project.
16 // Pull requests should be sent to the Developer Edition Master Repository on https://github.com/SoftEtherVPN/SoftEtherVPN
17 // Contributors:
18 // - ELIN (https://github.com/el1n)
19 //
20 // License: The Apache License, Version 2.0
21 // https://www.apache.org/licenses/LICENSE-2.0
22 //
23 // DISCLAIMER
24 // ==========
25 //
26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
27 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
28 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
29 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
30 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
31 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 // SOFTWARE.
33 //
34 // THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN, UNDER
35 // JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY, MERGE, PUBLISH,
36 // DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS SOFTWARE, THAT ANY
37 // JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS SOFTWARE OR ITS CONTENTS,
38 // AGAINST US (SOFTETHER PROJECT, SOFTETHER CORPORATION, DAIYUU NOBORI OR OTHER
39 // SUPPLIERS), OR ANY JURIDICAL DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND
40 // OF USING, COPYING, MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING,
41 // AND/OR SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND
42 // CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO EXCLUSIVE
43 // JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO, JAPAN. YOU MUST WAIVE
44 // ALL DEFENSES OF LACK OF PERSONAL JURISDICTION AND FORUM NON CONVENIENS.
45 // PROCESS MAY BE SERVED ON EITHER PARTY IN THE MANNER AUTHORIZED BY APPLICABLE
46 // LAW OR COURT RULE.
47 //
48 // USE ONLY IN JAPAN. DO NOT USE THIS SOFTWARE IN ANOTHER COUNTRY UNLESS YOU HAVE
49 // A CONFIRMATION THAT THIS SOFTWARE DOES NOT VIOLATE ANY CRIMINAL LAWS OR CIVIL
50 // RIGHTS IN THAT PARTICULAR COUNTRY. USING THIS SOFTWARE IN OTHER COUNTRIES IS
51 // COMPLETELY AT YOUR OWN RISK. THE SOFTETHER VPN PROJECT HAS DEVELOPED AND
52 // DISTRIBUTED THIS SOFTWARE TO COMPLY ONLY WITH THE JAPANESE LAWS AND EXISTING
53 // CIVIL RIGHTS INCLUDING PATENTS WHICH ARE SUBJECTS APPLY IN JAPAN. OTHER
54 // COUNTRIES' LAWS OR CIVIL RIGHTS ARE NONE OF OUR CONCERNS NOR RESPONSIBILITIES.
55 // WE HAVE NEVER INVESTIGATED ANY CRIMINAL REGULATIONS, CIVIL LAWS OR
56 // INTELLECTUAL PROPERTY RIGHTS INCLUDING PATENTS IN ANY OF OTHER 200+ COUNTRIES
57 // AND TERRITORIES. BY NATURE, THERE ARE 200+ REGIONS IN THE WORLD, WITH
58 // DIFFERENT LAWS. IT IS IMPOSSIBLE TO VERIFY EVERY COUNTRIES' LAWS, REGULATIONS
59 // AND CIVIL RIGHTS TO MAKE THE SOFTWARE COMPLY WITH ALL COUNTRIES' LAWS BY THE
60 // PROJECT. EVEN IF YOU WILL BE SUED BY A PRIVATE ENTITY OR BE DAMAGED BY A
61 // PUBLIC SERVANT IN YOUR COUNTRY, THE DEVELOPERS OF THIS SOFTWARE WILL NEVER BE
62 // LIABLE TO RECOVER OR COMPENSATE SUCH DAMAGES, CRIMINAL OR CIVIL
63 // RESPONSIBILITIES. NOTE THAT THIS LINE IS NOT LICENSE RESTRICTION BUT JUST A
64 // STATEMENT FOR WARNING AND DISCLAIMER.
65 //
66 // READ AND UNDERSTAND THE 'WARNING.TXT' FILE BEFORE USING THIS SOFTWARE.
67 // SOME SOFTWARE PROGRAMS FROM THIRD PARTIES ARE INCLUDED ON THIS SOFTWARE WITH
68 // LICENSE CONDITIONS WHICH ARE DESCRIBED ON THE 'THIRD_PARTY.TXT' FILE.
69 //
70 //
71 // SOURCE CODE CONTRIBUTION
72 // ------------------------
73 //
74 // Your contribution to SoftEther VPN Project is much appreciated.
75 // Please send patches to us through GitHub.
76 // Read the SoftEther VPN Patch Acceptance Policy in advance:
77 // http://www.softether.org/5-download/src/9.patch
78 //
79 //
80 // DEAR SECURITY EXPERTS
81 // ---------------------
82 //
83 // If you find a bug or a security vulnerability please kindly inform us
84 // about the problem immediately so that we can fix the security problem
85 // to protect a lot of users around the world as soon as possible.
86 //
87 // Our e-mail address for security reports is:
88 // softether-vpn-security [at] softether.org
89 //
90 // Please note that the above e-mail address is not a technical support
91 // inquiry address. If you need technical assistance, please visit
92 // http://www.softether.org/ and ask your question on the users forum.
93 //
94 // Thank you for your cooperation.
95 //
96 //
97 // NO MEMORY OR RESOURCE LEAKS
98 // ---------------------------
99 //
100 // The memory-leaks and resource-leaks verification under the stress
101 // test has been passed before release this source code.
102
103
104 // Admin.c
105 // RPC Module for Management
106
107 #include "CedarPch.h"
108
109 // Macro for RPC function declaration
110 #define DECLARE_RPC_EX(rpc_name, data_type, function, in_rpc, out_rpc, free_rpc) \
111 else if (StrCmpi(name, rpc_name) == 0) \
112 { \
113 data_type *t; \
114 t = ZeroMalloc(sizeof(data_type)); \
115 in_rpc(t, p); \
116 err = function(a, t); \
117 if (err == ERR_NO_ERROR) \
118 { \
119 out_rpc(ret, t); \
120 } \
121 free_rpc(t); \
122 Free(t); \
123 ok = true; \
124 }
125 #define DECLARE_RPC(rpc_name, data_type, function, in_rpc, out_rpc) \
126 else if (StrCmpi(name, rpc_name) == 0) \
127 { \
128 data_type *t; \
129 t = ZeroMalloc(sizeof(data_type)); \
130 in_rpc(t, p); \
131 err = function(a, t); \
132 if (err == ERR_NO_ERROR) \
133 { \
134 out_rpc(ret, t); \
135 } \
136 Free(t); \
137 ok = true; \
138 }
139 #define DECLARE_SC_EX(rpc_name, data_type, function, in_rpc, out_rpc, free_rpc) \
140 UINT function(RPC *r, data_type *t) \
141 { \
142 PACK *p, *ret; \
143 UINT err; \
144 if (r == NULL || t == NULL) \
145 { \
146 return ERR_INTERNAL_ERROR; \
147 } \
148 p = NewPack(); \
149 out_rpc(p, t); \
150 free_rpc(t); \
151 Zero(t, sizeof(data_type)); \
152 ret = AdminCall(r, rpc_name, p); \
153 err = GetErrorFromPack(ret); \
154 if (err == ERR_NO_ERROR) \
155 { \
156 in_rpc(t, ret); \
157 } \
158 FreePack(ret); \
159 return err; \
160 }
161 #define DECLARE_SC(rpc_name, data_type, function, in_rpc, out_rpc) \
162 UINT function(RPC *r, data_type *t) \
163 { \
164 PACK *p, *ret; \
165 UINT err; \
166 if (r == NULL || t == NULL) \
167 { \
168 return ERR_INTERNAL_ERROR; \
169 } \
170 p = NewPack(); \
171 out_rpc(p, t); \
172 ret = AdminCall(r, rpc_name, p); \
173 err = GetErrorFromPack(ret); \
174 if (err == ERR_NO_ERROR) \
175 { \
176 in_rpc(t, ret); \
177 } \
178 FreePack(ret); \
179 return err; \
180 }
181 #define CHECK_RIGHT \
182 if (a->ServerAdmin == false && (t->HubName == NULL || StrCmpi(a->HubName, t->HubName) != 0)) \
183 return ERR_NOT_ENOUGH_RIGHT; \
184 if (IsEmptyStr(t->HubName)) \
185 return ERR_INVALID_PARAMETER;
186 #define SERVER_ADMIN_ONLY \
187 if (a->ServerAdmin == false) \
188 return ERR_NOT_ENOUGH_RIGHT;
189 #define NO_SUPPORT_FOR_BRIDGE \
190 if (a->Server->Cedar->Bridge) \
191 return ERR_NOT_SUPPORTED;
192
193 // Get server Caps (Guessing from the build number if failed to get Caps)
ScGetCapsEx(RPC * rpc)194 CAPSLIST *ScGetCapsEx(RPC *rpc)
195 {
196 RPC_SERVER_INFO info;
197 CAPSLIST *t;
198 bool is_bridge = false;
199 // Validate arguments
200 if (rpc == NULL)
201 {
202 return NULL;
203 }
204
205 Zero(&info, sizeof(info));
206 ScGetServerInfo(rpc, &info);
207
208 t = ZeroMalloc(sizeof(CAPSLIST));
209
210 // Try to get Caps by RPC
211 if (ScGetCaps(rpc, t) != ERR_NO_ERROR)
212 {
213 UINT build;
214
215 Free(t);
216 t = NewCapsList();
217
218 // Since acquisition of Caps went wrong, get build number
219 build = info.ServerBuildInt;
220
221 is_bridge = (SearchStrEx(info.ServerProductName, "bridge", 0, false) == INFINITE) ? false : true;
222
223 AddCapsInt(t, "i_max_packet_size", 1514);
224
225 if (is_bridge == false)
226 {
227 AddCapsInt(t, "i_max_hubs", 4096);
228 AddCapsInt(t, "i_max_sessions", 4096);
229
230 if (info.ServerType != SERVER_TYPE_FARM_MEMBER)
231 {
232 AddCapsInt(t, "i_max_users_per_hub", 10000);
233 AddCapsInt(t, "i_max_groups_per_hub", 10000);
234 AddCapsInt(t, "i_max_access_lists", 4096);
235 }
236 else
237 {
238 AddCapsInt(t, "i_max_users_per_hub", 0);
239 AddCapsInt(t, "i_max_groups_per_hub", 0);
240 AddCapsInt(t, "i_max_access_lists", 0);
241 }
242 }
243 else
244 {
245 AddCapsInt(t, "i_max_hubs", 0);
246 AddCapsInt(t, "i_max_sessions", 0);
247 AddCapsInt(t, "i_max_users_per_hub", 0);
248 AddCapsInt(t, "i_max_groups_per_hub", 0);
249 AddCapsInt(t, "i_max_access_lists", 0);
250 }
251
252 AddCapsInt(t, "i_max_mac_tables", 10000);
253 AddCapsInt(t, "i_max_ip_tables", 10000);
254
255 if (info.ServerType == SERVER_TYPE_STANDALONE)
256 {
257 AddCapsBool(t, "b_support_securenat", (build >= 3600) ? true : false);
258 AddCapsInt(t, "i_max_secnat_tables", 4096);
259 }
260 else
261 {
262 AddCapsBool(t, "b_support_securenat", false);
263 AddCapsInt(t, "i_max_secnat_tables", 0);
264 }
265
266 if (is_bridge)
267 {
268 AddCapsBool(t, "b_bridge", true);
269 }
270 else if (info.ServerType == SERVER_TYPE_STANDALONE)
271 {
272 AddCapsBool(t, "b_standalone", true);
273 }
274 else if (info.ServerType == SERVER_TYPE_FARM_CONTROLLER)
275 {
276 AddCapsBool(t, "b_cluster_controller", true);
277 }
278 else
279 {
280 AddCapsBool(t, "b_cluster_member", true);
281 }
282
283 AddCapsBool(t, "b_support_config_hub", info.ServerType != SERVER_TYPE_FARM_MEMBER &&
284 is_bridge == false);
285
286 AddCapsBool(t, "b_vpn_client_connect", is_bridge == false ? true : false);
287
288 AddCapsBool(t, "b_support_radius", info.ServerType != SERVER_TYPE_FARM_MEMBER &&
289 is_bridge == false);
290
291 if (build >= 3600)
292 {
293 RPC_BRIDGE_SUPPORT b;
294 Zero(&b, sizeof(b));
295 if (ScGetBridgeSupport(rpc, &b) == ERR_NO_ERROR)
296 {
297 AddCapsBool(t, "b_local_bridge", b.IsBridgeSupportedOs);
298 AddCapsBool(t, "b_must_install_pcap", b.IsWinPcapNeeded);
299 }
300 else
301 {
302 AddCapsBool(t, "b_local_bridge", false);
303 AddCapsBool(t, "b_must_install_pcap", false);
304 }
305 }
306 else
307 {
308 AddCapsBool(t, "b_local_bridge", false);
309 AddCapsBool(t, "b_must_install_pcap", false);
310 }
311
312 AddCapsBool(t, "b_tap_supported", false);
313
314 if (info.ServerType == SERVER_TYPE_STANDALONE)
315 {
316 AddCapsBool(t, "b_support_cascade", true);
317 }
318 else
319 {
320 AddCapsBool(t, "b_support_cascade", false);
321 }
322
323 AddCapsBool(t, "b_support_cascade_cert", false);
324 AddCapsBool(t, "b_support_config_log", info.ServerType != SERVER_TYPE_FARM_MEMBER);
325 AddCapsBool(t, "b_support_autodelete", false);
326 }
327 else
328 {
329 // Success getting Caps
330 if (info.ServerBuildInt <= 4350)
331 {
332 if (is_bridge == false)
333 {
334 // b_support_cluster should be true for build 4300 or earlier
335 CAPS *caps = GetCaps(t, "b_support_cluster");
336 if (caps == NULL)
337 {
338 AddCapsBool(t, "b_support_cluster", true);
339 }
340 else
341 {
342 caps->Value = 1;
343 }
344 }
345 }
346 }
347
348 if (true)
349 {
350 TOKEN_LIST *names;
351
352 // Fill items that doesn't exist in server-side as false
353 names = GetTableNameStartWith("CT_b_");
354 if (names != NULL)
355 {
356 UINT i;
357 for (i = 0;i < names->NumTokens;i++)
358 {
359 char *name = names->Token[i] + 3;
360
361 if (GetCaps(t, name) == NULL)
362 {
363 AddCapsBool(t, name, false);
364 }
365 }
366
367 FreeToken(names);
368 }
369 }
370
371 FreeRpcServerInfo(&info);
372
373 return t;
374 }
375
376 // Process server side include
AdminWebProcessServerSideInclude(BUF * src_txt,char * filename,UINT depth)377 BUF *AdminWebProcessServerSideInclude(BUF *src_txt, char *filename, UINT depth)
378 {
379 char *src_str;
380 UINT src_str_size;
381 UINT i, len;
382 BUF *ret = NULL;
383 UINT pos = 0;
384 char dirname[MAX_PATH];
385 if (src_txt == NULL || filename == NULL || depth >= 4)
386 {
387 return CloneBuf(src_txt);
388 }
389 if (EndWith(filename, ".html") == false)
390 {
391 // We process only .html files
392 return CloneBuf(src_txt);
393 }
394
395 GetDirNameFromFilePath(dirname, sizeof(dirname), filename);
396
397 src_str_size = src_txt->Size + 1;
398 src_str = ZeroMalloc(src_str_size);
399
400 Copy(src_str, src_txt->Buf, src_txt->Size);
401
402 len = StrLen(src_str);
403
404 ret = NewBuf();
405
406 for (i = 0;i < len;i++)
407 {
408 char *start_tag = "<!--#include file=";
409 bool is_ssi = false;
410
411 if (StartWith(src_str + i, start_tag))
412 {
413 UINT a = i + StrLen(start_tag);
414
415 if (src_str[a] == '\"' || src_str[a] == '\'')
416 {
417 char delimier = src_str[a];
418 char delimier_str[2];
419 UINT b;
420
421 delimier_str[0] = delimier;
422 delimier_str[1] = 0;
423 b = SearchStrEx(src_str, delimier_str, i + StrLen(start_tag) + 1, true);
424
425 if ((b != INFINITE) && (b >= i + StrLen(start_tag) + 1) && ((b - (i + StrLen(start_tag) + 1)) < 32))
426 {
427 char inc_filename[MAX_PATH];
428 char *end_tag = "-->";
429 UINT x;
430
431 Zero(inc_filename, sizeof(inc_filename));
432
433 StrCpy(inc_filename, sizeof(inc_filename), src_str + i + StrLen(start_tag) + 1);
434 inc_filename[b - (i + StrLen(start_tag) + 1)] = 0;
435
436 x = SearchStrEx(src_str, end_tag, b + 1, true);
437
438 if ((x != INFINITE) && (x >= (b + 1)))
439 {
440 BUF *inc_buf;
441 char full_inc_filename[MAX_PATH];
442
443 if (StartWith(inc_filename, "/"))
444 {
445 Format(full_inc_filename, sizeof(full_inc_filename), "|wwwroot/%s", inc_filename + 1);
446 }
447 else
448 {
449 StrCpy(full_inc_filename, sizeof(full_inc_filename), dirname);
450 StrCat(full_inc_filename, sizeof(full_inc_filename), "/");
451 StrCat(full_inc_filename, sizeof(full_inc_filename), inc_filename);
452 }
453
454 Debug("dirname = %s, full_inc_filename (src) = %s\n\n", dirname, full_inc_filename);
455 NormalizePath(full_inc_filename, sizeof(full_inc_filename), full_inc_filename);
456
457 if (StartWith(full_inc_filename, "|wwwroot/") == false
458 && StartWith(full_inc_filename, "|wwwroot\\") == false)
459 {
460 char tmp[MAX_PATH];
461 Format(tmp, sizeof(tmp), "|wwwroot/%s", full_inc_filename);
462 StrCpy(full_inc_filename, sizeof(full_inc_filename), tmp);
463 }
464
465 Debug("inc_filename = %s\nfull_inc_filename = %s\n\n", inc_filename, full_inc_filename);
466
467 inc_buf = ReadDump(full_inc_filename);
468
469 if (inc_buf != NULL)
470 {
471 BUF *inc_buf2;
472
473 inc_buf2 = AdminWebProcessServerSideInclude(inc_buf, full_inc_filename, depth + 1);
474
475 BufSkipUtf8Bom(inc_buf2);
476 WriteBufBufWithOffset(ret, inc_buf2);
477
478 FreeBuf(inc_buf);
479 FreeBuf(inc_buf2);
480 }
481 else
482 {
483 Debug("Loading SSI '%s' error.\n", inc_buf);
484 }
485
486 i = (x + StrLen(end_tag) - 1);
487
488 is_ssi = true;
489 }
490 }
491 }
492 }
493
494 if (is_ssi == false)
495 {
496 WriteBufChar(ret, src_str[i]);
497 }
498 }
499
500 Free(src_str);
501
502 return ret;
503 }
504
505 // Handle the file request
AdminWebHandleFileRequest(ADMIN * a,CONNECTION * c,SOCK * s,HTTP_HEADER * h,char * url_src,char * query_string,char * virtual_root_dir,char * physical_root_dir)506 bool AdminWebHandleFileRequest(ADMIN *a, CONNECTION *c, SOCK *s, HTTP_HEADER *h, char *url_src, char *query_string, char *virtual_root_dir, char *physical_root_dir)
507 {
508 bool ret = false;
509 char url[MAX_PATH];
510 UINT i, len;
511 if (a == NULL || c == NULL || s == NULL || h == NULL || url == NULL || query_string == NULL ||
512 virtual_root_dir == NULL || physical_root_dir == NULL)
513 {
514 return false;
515 }
516
517 StrCpy(url, sizeof(url), url_src);
518
519 len = StrLen(url);
520 for (i = 0;i < len;i++)
521 {
522 if (url[i] == '\\')
523 {
524 url[i] = '/';
525 }
526 }
527
528 // Is dangerous URL?
529 if (InStr(url, "..") || InStr(url, "//") || InStr(url, "\\\\") || InStr(url, "/\\") || InStr(url, "\\/"))
530 {
531 ret = AdminWebSend404Error(s, h);
532 }
533 else
534 {
535 char filename[MAX_PATH];
536 bool is_index_file = false;
537
538 BUF *b = AdminWebTryFindAndReadFile(virtual_root_dir, physical_root_dir, url,
539 filename, sizeof(filename), &is_index_file);
540
541 if (b == NULL)
542 {
543 ret = AdminWebSend404Error(s, h);
544 }
545 else
546 {
547 if (is_index_file && EndWith(url, "/") == false)
548 {
549 char url2[MAX_PATH];
550 StrCpy(url2, sizeof(url2), url);
551 StrCat(url2, sizeof(url2), "/");
552 ret = AdminWebSend302Redirect(s, url2, query_string, h);
553 }
554 else if (is_index_file == false && EndWith(url, "/"))
555 {
556 char url2[MAX_PATH];
557 TrimEndWith(url2, sizeof(url2), url, "/");
558 ret = AdminWebSend302Redirect(s, url2, query_string, h);
559 }
560 else
561 {
562 BUF *b2 = AdminWebProcessServerSideInclude(b, filename, 0);
563 char *mime = GetMimeTypeFromFileName(filename);
564
565 if (mime == NULL)
566 {
567 mime = "application/octet-stream";
568 }
569
570 ret = AdminWebSendBody(s, 200, "OK", b2->Buf, b2->Size, mime, NULL, NULL, h);
571
572 FreeBuf(b2);
573 }
574 FreeBuf(b);
575 }
576 }
577
578 return ret;
579 }
580
581 // Try to find a file, and if exists return the file contents
AdminWebTryFindAndReadFile(char * vroot,char * proot,char * url,char * ret_filename,UINT ret_filename_size,bool * is_index_html)582 BUF *AdminWebTryFindAndReadFile(char *vroot, char *proot, char *url, char *ret_filename, UINT ret_filename_size, bool *is_index_html)
583 {
584 char tmp[MAX_PATH];
585 char tmp2[MAX_PATH];
586 UINT vroot_len;
587 UINT url_len;
588 char relative_path[MAX_PATH];
589 BUF *b;
590 if (vroot == NULL || proot == NULL || url == NULL || ret_filename == NULL || is_index_html == NULL)
591 {
592 return NULL;
593 }
594
595 *is_index_html = false;
596
597 if (StartWith(url, vroot) == false)
598 {
599 return NULL;
600 }
601
602 vroot_len = StrLen(vroot);
603 url_len = StrLen(url);
604
605 StrCpy(relative_path, sizeof(relative_path), url + vroot_len);
606
607 if (StartWith(relative_path, "/"))
608 {
609 char tmp3[MAX_PATH];
610
611 StrCpy(tmp3, sizeof(tmp3), relative_path + 1);
612 StrCpy(relative_path, sizeof(relative_path), tmp3);
613 }
614
615 CombinePath(tmp, sizeof(tmp), proot, relative_path);
616
617 // index.html
618 CombinePath(tmp2, sizeof(tmp2), tmp, "index.html");
619 b = AdminWebTryOneFile(tmp2, ret_filename, ret_filename_size);
620 if (b != NULL)
621 {
622 *is_index_html = true;
623 return b;
624 }
625
626 // dirname/filename
627 StrCpy(tmp2, sizeof(tmp2), tmp);
628 b = AdminWebTryOneFile(tmp2, ret_filename, ret_filename_size);
629 if (b != NULL)
630 {
631 return b;
632 }
633
634 return NULL;
635 }
AdminWebTryOneFile(char * filename,char * ret_filename,UINT ret_filename_size)636 BUF *AdminWebTryOneFile(char *filename, char *ret_filename, UINT ret_filename_size)
637 {
638 BUF *b;
639 if (filename == NULL || ret_filename == NULL)
640 {
641 return NULL;
642 }
643
644 b = ReadDump(filename);
645 if (b == NULL)
646 {
647 return NULL;
648 }
649
650 StrCpy(ret_filename, ret_filename_size, filename);
651
652 return b;
653 }
654
655 // Send a 401 Unauthorized error
AdminWebSendUnauthorized(SOCK * s,HTTP_HEADER * http_request_headers)656 bool AdminWebSendUnauthorized(SOCK *s, HTTP_HEADER *http_request_headers)
657 {
658 char *http_401_str = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<html><head>\r\n<title>401 Unauthorized</title>\r\n</head><body>\r\n<h1>" CEDAR_SERVER_STR ": Administrative authentication required.</h1>\r\n<p>This VPN Server could not verify that you are authorized to access to the \r\nserver in administrative mode.</p>\r\n<p><strong>For web browser logins:<br></strong>You must supply the HTTP basic \r\nauthentication credential as following.</p>\r\n<ul>\r\n\t<li>To login to the VPN server as the entire server administrator, specify empty or "administrator" as the username field, and specify the server administrative \r\n\tpassword as the password field.<br></li>\r\n\t<li>To login to a particular Virtual Hub as the hub administrator, specify \r\n\tthe hub name as the username field, and specify the hub administrative \r\n\tpassword as the password field.</li>\r\n</ul>\r\n<p><strong>For JSON-RPC client logins:<br></strong>Instead to HTTP basic \r\nauthentication, you can also specify the HTTP header parameters as following.</p>\r\n<ul>\r\n\t<li>X-VPNADMIN-HUBNAME: Empty to login to the VPN Server as the entire \r\n\tserver administrator, or specify the target Virtual Hub name as the hub \r\n\tadministrator.</li>\r\n\t<li>X-VPNADMIN-PASSWORD: Specify the administrative password.</li>\r\n</ul>\r\n</body></html>\r\n";
659 bool ret;
660 // Validate arguments
661 if (s == NULL || http_request_headers == NULL)
662 {
663 return false;
664 }
665
666 // Creating a Data
667 ret = AdminWebSendBody(s, 401, "Unauthorized", http_401_str, StrLen(http_401_str), HTTP_CONTENT_TYPE,
668 "WWW-Authenticate",
669 "Basic realm=\"Username 'administrator' for entire VPN Server privilege, or specify Virtual Hub name as the username for specified Virtual Hub administrative privilege.\"",
670 http_request_headers);
671
672 return ret;
673 }
674
675 // Send reply
AdminWebSendBody(SOCK * s,UINT status_code,char * status_string,UCHAR * data,UINT data_size,char * content_type,char * add_header_name,char * add_header_value,HTTP_HEADER * request_headers)676 bool AdminWebSendBody(SOCK *s, UINT status_code, char *status_string, UCHAR *data, UINT data_size, char *content_type, char *add_header_name, char *add_header_value,
677 HTTP_HEADER *request_headers)
678 {
679 HTTP_HEADER *h;
680 char date_str[MAX_SIZE];
681 char error_code_str[16];
682 bool ret = false;
683 HTTP_VALUE *origin;
684 if (s == NULL || status_string == NULL || (data_size != 0 && data == NULL) || request_headers == NULL)
685 {
686 return false;
687 }
688 if (content_type == NULL)
689 {
690 content_type = "text/html; charset=utf-8";
691 }
692
693 ToStr(error_code_str, status_code);
694 GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
695
696 h = NewHttpHeader("HTTP/1.1", error_code_str, status_string);
697
698 if (StrCmpi(request_headers->Method, "OPTIONS") == 0)
699 {
700 AddHttpValue(h, NewHttpValue("Allow", "OPTIONS, GET, POST"));
701 }
702
703 AddHttpValue(h, NewHttpValue("Cache-Control", "no-cache"));
704 AddHttpValue(h, NewHttpValue("Content-Type", content_type));
705 AddHttpValue(h, NewHttpValue("Date", date_str));
706 AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
707 AddHttpValue(h, NewHttpValue("Access-Control-Allow-Methods", "OPTIONS,GET,POST"));
708 AddHttpValue(h, NewHttpValue("Access-Control-Allow-Headers", "X-VPNADMIN-HUBNAME,X-VPNADMIN-PASSWORD"));
709 AddHttpValue(h, NewHttpValue("Access-Control-Allow-Credentials", "true"));
710
711 origin = GetHttpValue(request_headers, "Origin");
712 if (origin != NULL)
713 {
714 AddHttpValue(h, NewHttpValue("Access-Control-Allow-Origin", origin->Data));
715 }
716
717 if (add_header_name != NULL && add_header_value != NULL)
718 {
719 AddHttpValue(h, NewHttpValue(add_header_name, add_header_value));
720 }
721
722 ret = PostHttp(s, h, data, data_size);
723
724 FreeHttpHeader(h);
725
726 return ret;
727 }
728
729 // Send 404 error
AdminWebSend404Error(SOCK * s,HTTP_HEADER * request_headers)730 bool AdminWebSend404Error(SOCK *s, HTTP_HEADER *request_headers)
731 {
732 char *body = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<html><head><title>404 Not Found</title></head><body><h1>Not Found</h1><p>The requested URL was not found on this server.</p></body></html>\r\n";
733 if (s == NULL || request_headers == NULL)
734 {
735 return false;
736 }
737
738 return AdminWebSendBody(s, 404, "Not Found", body, StrLen(body), NULL, NULL, NULL, request_headers);
739 }
740
741 // Send 302 redirect
AdminWebSend302Redirect(SOCK * s,char * url,char * query_string,HTTP_HEADER * request_headers)742 bool AdminWebSend302Redirect(SOCK *s, char *url, char *query_string, HTTP_HEADER *request_headers)
743 {
744 bool ret = false;
745 char *txt;
746 UINT txt_size;
747 char *url2;
748 UINT url2_size;
749 char *body = "<html><head><title>Object moved</title></head><body>\r\n<h2>Object moved to <a href=\"$URL$\">here</a>.</h2>\r\n</body></html>";
750 if (s == NULL || url == NULL || request_headers == NULL)
751 {
752 return false;
753 }
754
755 url2_size = (StrSize(url) + StrSize(query_string) + MAX_SIZE) * 2;
756 url2 = ZeroMalloc(url2_size);
757
758 StrCpy(url2, url2_size, url);
759 if (IsEmptyStr(query_string) == false)
760 {
761 StrCat(url2, url2_size, "?");
762 StrCat(url2, url2_size, query_string);
763 }
764
765 txt_size = (StrSize(body) + StrSize(url2) + MAX_SIZE) * 2;
766 txt = ZeroMalloc(txt_size);
767
768 ReplaceStrEx(txt, txt_size, body, "$URL$", url2, false);
769
770 ret = AdminWebSendBody(s, 302, "Found", txt, StrLen(txt), NULL, "Location", url2, request_headers);
771
772 Free(txt);
773
774 Free(url2);
775
776 return ret;
777 }
778
779 // "/admin" web page POST handler
AdminWebProcPost(CONNECTION * c,SOCK * s,HTTP_HEADER * h,UINT post_data_size,char * url_target)780 void AdminWebProcPost(CONNECTION *c, SOCK *s, HTTP_HEADER *h, UINT post_data_size, char *url_target)
781 {
782 ADMIN *a;
783 UCHAR *data;
784 char url[MAX_PATH];
785 char query_string[MAX_SIZE];
786 UINT i;
787 if (c == NULL || s == NULL || h == NULL || url_target == NULL)
788 {
789 return;
790 }
791
792 a = JsonRpcAuthLogin(c->Cedar, s, h);
793 if (a == NULL)
794 {
795 RecvAllWithDiscard(s, post_data_size, s->SecureMode);
796 AdminWebSendUnauthorized(s, h);
797 return;
798 }
799
800 if (post_data_size > a->MaxJsonRpcRecvSize)
801 {
802 Disconnect(s);
803 return;
804 }
805
806 data = ZeroMalloc(post_data_size + 1);
807
808 if (RecvAll(s, data, post_data_size, s->SecureMode))
809 {
810 c->JsonRpcAuthed = true;
811
812 // Divide url_target into URL and query string
813 StrCpy(url, sizeof(url), url_target);
814 Zero(query_string, sizeof(query_string));
815 i = SearchStr(url, "?", 0);
816 if (i != INFINITE)
817 {
818 StrCpy(query_string, sizeof(query_string), url + i + 1);
819 url[i] = 0;
820 }
821
822 AdminWebHandleFileRequest(a, c, s, h, url, query_string, "/admin", "|wwwroot/admin");
823 }
824
825 Free(data);
826 Free(a);
827 }
828
829 // "/admin" web page GET handler
AdminWebProcGet(CONNECTION * c,SOCK * s,HTTP_HEADER * h,char * url_target)830 void AdminWebProcGet(CONNECTION *c, SOCK *s, HTTP_HEADER *h, char *url_target)
831 {
832 ADMIN *a;
833 char url[MAX_PATH];
834 char query_string[MAX_SIZE];
835 UINT i;
836 if (c == NULL || s == NULL || h == NULL || url_target == NULL)
837 {
838 return;
839 }
840
841 a = JsonRpcAuthLogin(c->Cedar, s, h);
842 if (a == NULL)
843 {
844 AdminWebSendUnauthorized(s, h);
845 return;
846 }
847
848 c->JsonRpcAuthed = true;
849
850 // Divide url_target into URL and query string
851 StrCpy(url, sizeof(url), url_target);
852 Zero(query_string, sizeof(query_string));
853 i = SearchStr(url, "?", 0);
854 if (i != INFINITE)
855 {
856 StrCpy(query_string, sizeof(query_string), url + i + 1);
857 url[i] = 0;
858 }
859
860 AdminWebHandleFileRequest(a, c, s, h, url, query_string, "/admin", "|wwwroot/admin");
861
862 Free(a);
863 }
864
865 // New JSON-RPC Result
JsonRpcNewResponse(PACK * p)866 JSON_VALUE *JsonRpcNewResponse(PACK *p)
867 {
868 JSON_VALUE *jv;
869 JSON_OBJECT *jo;
870 JSON_VALUE *jv2;
871
872 if (p == NULL)
873 {
874 return NULL;
875 }
876
877 jv = JsonNewObject();
878 jo = JsonValueGetObject(jv);
879
880 jv2 = PackToJson(p);
881
882 JsonSet(jo, "result", jv2);
883
884 return jv;
885 }
886
887 // New JSON-RPC Error
JsonRpcNewError(int code,wchar_t * message)888 JSON_VALUE *JsonRpcNewError(int code, wchar_t *message)
889 {
890 wchar_t msg[MAX_PATH];
891 JSON_VALUE *jv;
892 JSON_OBJECT *jo;
893 JSON_VALUE *jv2;
894 JSON_OBJECT *jo2;
895
896 if (UniIsEmptyStr(message))
897 {
898 UniFormat(msg, sizeof(msg), L"Error code %u", code);
899 }
900 else
901 {
902 UniFormat(msg, sizeof(msg), L"Error code %u: %s", code, message);
903 }
904
905 jv = JsonNewObject();
906 jo = JsonValueGetObject(jv);
907
908 jv2 = JsonNewObject();
909 jo2 = JsonValueGetObject(jv2);
910
911 JsonSet(jo, "error", jv2);
912
913 JsonSetNumber(jo2, "code", (UINT64)code);
914 JsonSetUniStr(jo2, "message", msg);
915
916 return jv;
917 }
918
919 // JSON-RPC process request object
JsonRpcProcRequestObject(ADMIN * admin,CONNECTION * c,SOCK * s,JSON_VALUE * json_req,char * method_name)920 JSON_VALUE *JsonRpcProcRequestObject(ADMIN *admin, CONNECTION *c, SOCK *s, JSON_VALUE *json_req, char *method_name)
921 {
922 PACK *pack_request;
923 JSON_VALUE *ret = NULL;
924 if (c == NULL || s == NULL || json_req == NULL || admin == NULL)
925 {
926 return NULL;
927 }
928
929 pack_request = JsonToPack(json_req);
930
931 PackAddStr(pack_request, "function_name", method_name);
932
933 if (pack_request != NULL)
934 {
935 RPC *rpc;
936 PACK *pack_response;
937 UINT err;
938
939 // RPC Server
940 rpc = StartRpcServer(s, AdminDispatch, admin);
941
942 admin->Rpc = rpc;
943
944 pack_response = CallRpcDispatcher(rpc, pack_request);
945
946 if (pack_response == NULL)
947 {
948 pack_response = PackError(ERR_NOT_SUPPORTED);
949 }
950
951 RpcFreeEx(rpc, true);
952
953 FreePack(pack_request);
954
955 // Construct response object
956 err = GetErrorFromPack(pack_response);
957 if (err != 0)
958 {
959 // Return the error
960 ret = JsonRpcNewError(err, _E(err));
961 }
962 else
963 {
964 // Return the PACK
965 ret = JsonRpcNewResponse(pack_response);
966 }
967
968 SLog(admin->Server->Cedar, "LS_API_RPC_CALL",
969 &s->RemoteIP, s->RemotePort, s->RemoteHostname,
970 method_name, err, _E(err));
971
972 FreePack(pack_response);
973 }
974
975 return ret;
976 }
977
978 // JSON-RPC HTTP user authentication
HttpParseBasicAuthHeader(HTTP_HEADER * h,char * username,UINT username_size,char * password,UINT password_size)979 bool HttpParseBasicAuthHeader(HTTP_HEADER *h, char *username, UINT username_size, char *password, UINT password_size)
980 {
981 bool ret = false;
982 HTTP_VALUE *auth_value;
983 HTTP_VALUE *vpnadmin_hubname;
984 HTTP_VALUE *vpnadmin_password;
985 if (h == NULL || username == NULL || password == NULL)
986 {
987 return false;
988 }
989
990 auth_value = GetHttpValue(h, "Authorization");
991 vpnadmin_hubname = GetHttpValue(h, "X-VPNADMIN-HUBNAME");
992 vpnadmin_password = GetHttpValue(h, "X-VPNADMIN-PASSWORD");
993
994 if (vpnadmin_password != NULL)
995 {
996 if (vpnadmin_hubname == NULL)
997 {
998 StrCpy(username, username_size, "");
999 }
1000 else
1001 {
1002 StrCpy(username, username_size, vpnadmin_hubname->Data);
1003 }
1004
1005 StrCpy(password, password_size, vpnadmin_password->Data);
1006
1007 ret = true;
1008 }
1009
1010 if (ret == false && auth_value != NULL)
1011 {
1012 char key[32], value[MAX_SIZE];
1013
1014 if (GetKeyAndValue(auth_value->Data, key, sizeof(key), value, sizeof(value), " \t"))
1015 {
1016 if (StrCmpi(key, "Basic") == 0 && IsEmptyStr(value) == false)
1017 {
1018 UINT b64_dest_size = StrSize(value) * 2 + 256;
1019 char *b64_dest = ZeroMalloc(b64_dest_size);
1020
1021 Decode64(b64_dest, value);
1022
1023 if (IsEmptyStr(b64_dest) == false)
1024 {
1025 if (b64_dest[0] == ':')
1026 {
1027 // Empty username
1028 StrCpy(username, username_size, "");
1029 StrCpy(password, password_size, b64_dest + 1);
1030 ret = true;
1031 }
1032 else
1033 {
1034 if (GetKeyAndValue(b64_dest, username, username_size, password, password_size, ":"))
1035 {
1036 ret = true;
1037 }
1038 }
1039 }
1040
1041 Free(b64_dest);
1042 }
1043 }
1044 }
1045
1046 return ret;
1047 }
1048
1049 // JSON-RPC Login
JsonRpcAuthLogin(CEDAR * c,SOCK * sock,HTTP_HEADER * h)1050 ADMIN *JsonRpcAuthLogin(CEDAR *c, SOCK *sock, HTTP_HEADER *h)
1051 {
1052 ADMIN *a = NULL;
1053 char username[MAX_HUBNAME_LEN + 1];
1054 char password[MAX_PASSWORD_LEN + 1];
1055 SERVER *s;
1056 char empty_pw_hash[SHA1_SIZE];
1057
1058 if (c == NULL || h == NULL || sock == NULL)
1059 {
1060 return NULL;
1061 }
1062
1063 s = c->Server;
1064
1065 HashAdminPassword(empty_pw_hash, "");
1066
1067 Zero(username, sizeof(username));
1068 Zero(password, sizeof(password));
1069
1070 if (HttpParseBasicAuthHeader(h, username, sizeof(username), password, sizeof(password)))
1071 {
1072 char pw_hash[SHA1_SIZE];
1073 bool is_server_admin = false;
1074 bool is_hub_admin = false;
1075 char hub_name[MAX_HUBNAME_LEN + 1];
1076
1077 HashAdminPassword(pw_hash, password);
1078
1079 Zero(hub_name, sizeof(hub_name));
1080
1081 // Check if the server administrator password is empty. If yes, login always success.
1082 if (Cmp(s->HashedPassword, empty_pw_hash, SHA1_SIZE) == 0)
1083 {
1084 is_server_admin = true;
1085 }
1086 else
1087 {
1088 if (IsEmptyStr(username) || StrCmpi(username, ADMINISTRATOR_USERNAME) == 0)
1089 {
1090 // If the username is empty or 'administrator', verify with the server admin password.
1091 if (Cmp(s->HashedPassword, pw_hash, SHA1_SIZE) == 0)
1092 {
1093 is_server_admin = true;
1094 }
1095 }
1096 }
1097
1098 if (is_server_admin == false)
1099 {
1100 HUB *h;
1101 // Hub admin mode
1102 LockHubList(c);
1103 {
1104 h = GetHub(c, username);
1105 }
1106 UnlockHubList(c);
1107
1108 if (h != NULL)
1109 {
1110 Lock(h->lock);
1111 {
1112 if (Cmp(h->HashedPassword, empty_pw_hash, SHA1_SIZE) != 0 && IsZero(h->HashedPassword, sizeof(h->HashedPassword)) == false)
1113 {
1114 if (Cmp(pw_hash, h->HashedPassword, SHA1_SIZE) == 0)
1115 {
1116 is_hub_admin = true;
1117
1118 StrCpy(hub_name, sizeof(hub_name), h->Name);
1119 }
1120 }
1121 }
1122 Unlock(h->lock);
1123
1124 ReleaseHub(h);
1125 }
1126 }
1127
1128 if (is_server_admin || is_hub_admin)
1129 {
1130 if (CheckAdminSourceAddress(sock, hub_name))
1131 {
1132 a = ZeroMalloc(sizeof(ADMIN));
1133
1134 a->Server = s;
1135 a->ServerAdmin = is_server_admin;
1136 a->ClientBuild = c->Build;
1137
1138 if (is_hub_admin)
1139 {
1140 StrCpy(a->dummy1, sizeof(a->dummy1), hub_name);
1141 a->HubName = a->dummy1;
1142 }
1143 }
1144 }
1145 }
1146
1147 if (a != NULL)
1148 {
1149 char admin_mode[256];
1150 if (a->ServerAdmin)
1151 {
1152 a->MaxJsonRpcRecvSize = ADMIN_RPC_MAX_POST_SIZE_BY_SERVER_ADMIN;
1153 }
1154 else
1155 {
1156 a->MaxJsonRpcRecvSize = ADMIN_RPC_MAX_POST_SIZE_BY_HUB_ADMIN;
1157 }
1158
1159 if (IsEmptyStr(a->HubName))
1160 {
1161 StrCpy(admin_mode, sizeof(admin_mode),
1162 "Entire VPN Server Admin Mode");
1163 }
1164 else
1165 {
1166 Format(admin_mode, sizeof(admin_mode),
1167 "Virtual Hub Admin Mode for '%s'",
1168 a->HubName);
1169 }
1170
1171 SLog(s->Cedar, "LS_API_AUTH_OK",
1172 &sock->RemoteIP, sock->RemotePort, sock->RemoteHostname,
1173 admin_mode, username, h->Method, h->Target);
1174 }
1175 else
1176 {
1177 SLog(s->Cedar, "LS_API_AUTH_ERROR",
1178 &sock->RemoteIP, sock->RemotePort, sock->RemoteHostname,
1179 username, h->Method, h->Target);
1180 }
1181
1182
1183 return a;
1184 }
1185
1186 // Query string to JSON list value
QueryStringToJsonListValue(char * qs)1187 JSON_VALUE *QueryStringToJsonListValue(char *qs)
1188 {
1189 TOKEN_LIST *t;
1190 UINT i;
1191 LIST *distinct_list = NULL;
1192 JSON_VALUE *v = NULL;
1193 JSON_OBJECT *o = NULL;
1194 if (qs == NULL)
1195 {
1196 return NULL;
1197 }
1198
1199 t = ParseTokenWithoutNullStr(qs, "&");
1200 if (t == NULL)
1201 {
1202 return NULL;
1203 }
1204
1205 distinct_list = NewStrList();
1206
1207 v = JsonNewObject();
1208 o = JsonValueGetObject(v);
1209
1210 for (i = 0;i < t->NumTokens;i++)
1211 {
1212 char *token = t->Token[i];
1213 UINT pos;
1214
1215 pos = SearchStr(token, "=", 0);
1216 if (pos != INFINITE)
1217 {
1218 char *key_decoded;
1219 char *value_decoded;
1220 char *key = CopyStr(token);
1221 char *value = CopyStr(token + pos + 1);
1222
1223 key[pos] = 0;
1224 key_decoded = UrlDecode(key);
1225 value_decoded = UrlDecode(value);
1226
1227 if (key_decoded != NULL && value_decoded != NULL)
1228 {
1229 if (AddStrToStrListDistinct(distinct_list, key_decoded))
1230 {
1231 JsonSetStr(o, key_decoded, value_decoded);
1232 }
1233 }
1234
1235 Free(value_decoded);
1236 Free(key_decoded);
1237 Free(key);
1238 Free(value);
1239 }
1240 }
1241
1242 FreeToken(t);
1243
1244 FreeStrList(distinct_list);
1245
1246 return v;
1247 }
1248
1249 // Construct new JSON-RPC dummy request
ConstructDummyJsonRpcRequest(char * method_name,JSON_VALUE * p)1250 JSON_VALUE *ConstructDummyJsonRpcRequest(char *method_name, JSON_VALUE *p)
1251 {
1252 JSON_VALUE *ret;
1253 JSON_OBJECT *ret_object;
1254 UCHAR rand[16];
1255 char id_str[64];
1256
1257 Rand(rand, sizeof(rand));
1258
1259 BinToStr(id_str, sizeof(id_str), rand, sizeof(rand));
1260
1261 ret = JsonNewObject();
1262 ret_object = JsonObject(ret);
1263
1264 JsonSetStr(ret_object, "jsonrpc", "2.0");
1265 JsonSetStr(ret_object, "method", method_name);
1266 JsonSet(ret_object, "params", p);
1267 JsonSetStr(ret_object, "id", id_str);
1268
1269 return ret;
1270 }
1271
1272 // JSON-RPC Options Dispatch
JsonRpcProcOptions(CONNECTION * c,SOCK * s,HTTP_HEADER * h,char * url_target)1273 void JsonRpcProcOptions(CONNECTION *c, SOCK *s, HTTP_HEADER *h, char *url_target)
1274 {
1275 if (c == NULL || s == NULL || h == NULL || url_target == NULL)
1276 {
1277 return;
1278 }
1279
1280 c->JsonRpcAuthed = true;
1281
1282
1283 AdminWebSendBody(s, 200, "OK", NULL, 0, NULL, NULL, NULL, h);
1284 }
1285
1286 // JSON-RPC GET Dispatch
JsonRpcProcGet(CONNECTION * c,SOCK * s,HTTP_HEADER * h,char * url_target)1287 void JsonRpcProcGet(CONNECTION *c, SOCK *s, HTTP_HEADER *h, char *url_target)
1288 {
1289 ADMIN *a;
1290 char url[MAX_PATH];
1291 char query_string[MAX_SIZE];
1292 UINT i;
1293 bool reply_sent = false;
1294 if (c == NULL || s == NULL || h == NULL || url_target == NULL)
1295 {
1296 return;
1297 }
1298
1299 a = JsonRpcAuthLogin(c->Cedar, s, h);
1300 if (a == NULL)
1301 {
1302 AdminWebSendUnauthorized(s, h);
1303 return;
1304 }
1305
1306 c->JsonRpcAuthed = true;
1307
1308
1309 // Divide url_target into URL and query string
1310 StrCpy(url, sizeof(url), url_target);
1311 Zero(query_string, sizeof(query_string));
1312 i = SearchStr(url, "?", 0);
1313 if (i != INFINITE)
1314 {
1315 StrCpy(query_string, sizeof(query_string), url + i + 1);
1316 url[i] = 0;
1317 }
1318
1319 if (StartWith(url, "/api/"))
1320 {
1321 // Call a method
1322 JSON_VALUE *params_value = NULL;
1323 JSON_OBJECT *params_object = NULL;
1324 UINT i;
1325 char method_name[MAX_PATH];
1326
1327 StrCpy(method_name, sizeof(method_name), url + 5);
1328
1329 i = SearchStr(method_name, "/", 0);
1330 if (i != INFINITE)
1331 {
1332 method_name[i] = 0;
1333 }
1334
1335 if (IsEmptyStr(method_name) == false)
1336 {
1337 // Call a method
1338 params_value = QueryStringToJsonListValue(query_string);
1339
1340 if (params_value != NULL)
1341 {
1342 JSON_VALUE *json_ret = NULL;
1343 char id[96];
1344 char *ret_str = NULL;
1345
1346 GetDateTimeStrMilli64(id, sizeof(id), LocalTime64());
1347
1348 params_object = JsonObject(params_value);
1349
1350 // Process the request
1351 json_ret = JsonRpcProcRequestObject(a, c, s, params_value, method_name);
1352
1353 if (json_ret == NULL)
1354 {
1355 json_ret = JsonRpcNewError(ERR_INTERNAL_ERROR, L"Internal error");
1356 }
1357
1358 JsonSetStr(JsonObject(json_ret), "jsonrpc", "2.0");
1359 JsonSetStr(JsonObject(json_ret), "id", id);
1360
1361 ret_str = JsonToStr(json_ret);
1362
1363 AdminWebSendBody(s, 200, "OK", ret_str, StrLen(ret_str), "text/plain; charset=UTF-8", NULL, NULL, h);
1364
1365 Free(ret_str);
1366 JsonFree(json_ret);
1367 JsonFree(params_value);
1368 }
1369 }
1370 }
1371
1372
1373 if (reply_sent == false)
1374 {
1375 BUF *html_buf = ReadDump("|vpnserver_api_doc.html");
1376
1377 if (html_buf != NULL)
1378 {
1379 AdminWebSendBody(s, 200, "OK", html_buf->Buf, html_buf->Size, "text/html; charset=UTF-8", NULL, NULL, h);
1380
1381 FreeBuf(html_buf);
1382 }
1383 else
1384 {
1385 AdminWebSend404Error(s, h);
1386 }
1387 }
1388
1389 if (a->LogFileList != NULL)
1390 {
1391 FreeEnumLogFile(a->LogFileList);
1392 }
1393 Free(a);
1394 }
1395
1396 // JSON-RPC POST Dispatch
JsonRpcProcPost(CONNECTION * c,SOCK * s,HTTP_HEADER * h,UINT post_data_size)1397 void JsonRpcProcPost(CONNECTION *c, SOCK *s, HTTP_HEADER *h, UINT post_data_size)
1398 {
1399 ADMIN *a;
1400 UCHAR *data;
1401 if (c == NULL || s == NULL || h == NULL)
1402 {
1403 return;
1404 }
1405
1406 a = JsonRpcAuthLogin(c->Cedar, s, h);
1407 if (a == NULL)
1408 {
1409 RecvAllWithDiscard(s, post_data_size, s->SecureMode);
1410 AdminWebSendUnauthorized(s, h);
1411 return;
1412 }
1413
1414 if (post_data_size > a->MaxJsonRpcRecvSize)
1415 {
1416 Disconnect(s);
1417 return;
1418 }
1419
1420 data = ZeroMalloc(post_data_size + 1);
1421
1422 if (RecvAll(s, data, post_data_size, s->SecureMode))
1423 {
1424 // Parse JSON
1425 JSON_VALUE *json_req = StrToJson(data);
1426 JSON_OBJECT *json_req_object = JsonObject(json_req);
1427 JSON_VALUE *json_ret = NULL;
1428 char *res = NULL;
1429 char *request_id = NULL;
1430 char *method_name = NULL;
1431
1432 c->JsonRpcAuthed = true;
1433
1434
1435 if (json_req == NULL || json_req_object == NULL)
1436 {
1437 // Parse error
1438 json_ret = JsonRpcNewError(ERR_INVALID_PARAMETER, L"Parameter is invalid: JSON-RPC Parse Error");
1439 }
1440 else
1441 {
1442 // check the JSON-RPC version
1443 char *ver_str = JsonGetStr(json_req_object, "jsonrpc");
1444 if (StrCmpi(ver_str, "2.0") != 0)
1445 {
1446 // Invalid version
1447 json_ret = JsonRpcNewError(ERR_INVALID_PARAMETER, L"JSON-RPC version is invalid");
1448 }
1449 else
1450 {
1451 JSON_VALUE *params_value = NULL;
1452 JSON_OBJECT *params_object = NULL;
1453
1454 // Get Request ID
1455 request_id = JsonGetStr(json_req_object, "id");
1456
1457 // Get method name
1458 method_name = JsonGetStr(json_req_object, "method");
1459
1460 // Get parameters
1461 params_value = JsonGet(json_req_object, "params");
1462 params_object = JsonObject(params_value);
1463
1464 if (IsEmptyStr(method_name))
1465 {
1466 // method is empty
1467 json_ret = JsonRpcNewError(ERR_INVALID_PARAMETER, L"JSON-RPC method name is empty");
1468 }
1469 else if (params_value == NULL || params_object == NULL)
1470 {
1471 // params is empty
1472 json_ret = JsonRpcNewError(ERR_INVALID_PARAMETER, L"JSON-RPC parameter is empty");
1473 }
1474 else
1475 {
1476 // Process the request
1477 json_ret = JsonRpcProcRequestObject(a, c, s, params_value, method_name);
1478 }
1479 }
1480 }
1481
1482 if (json_ret == NULL)
1483 {
1484 json_ret = JsonRpcNewError(ERR_INTERNAL_ERROR, L"Internal error");
1485 }
1486
1487 JsonSetStr(JsonObject(json_ret), "jsonrpc", "2.0");
1488 if (request_id == NULL)
1489 {
1490 request_id = "0";
1491 }
1492 JsonSetStr(JsonObject(json_ret), "id", request_id);
1493
1494 res = JsonToStr(json_ret);
1495
1496 AdminWebSendBody(s, 200, "OK", res, StrLen(res), "application/json", NULL, NULL, h);
1497
1498 Free(res);
1499
1500 JsonFree(json_ret);
1501 JsonFree(json_req);
1502 }
1503
1504 Free(data);
1505
1506 if (a->LogFileList != NULL)
1507 {
1508 FreeEnumLogFile(a->LogFileList);
1509 }
1510 Free(a);
1511 }
1512
1513 // Dispatch routine for Administration RPC
AdminDispatch(RPC * rpc,char * name,PACK * p)1514 PACK *AdminDispatch(RPC *rpc, char *name, PACK *p)
1515 {
1516 ADMIN *a;
1517 PACK *ret;
1518 UINT err;
1519 SERVER *server = NULL;
1520 CEDAR *cedar = NULL;
1521 bool ok = false;
1522 // Validate arguments
1523 if (rpc == NULL || name == NULL || p == NULL)
1524 {
1525 return NULL;
1526 }
1527
1528 ret = NewPack();
1529 err = ERR_NO_ERROR;
1530
1531 // Administration structure
1532 a = (ADMIN *)rpc->Param;
1533 if (a == NULL)
1534 {
1535 FreePack(ret);
1536 return NULL;
1537 }
1538
1539 server = a->Server;
1540
1541 if (server != NULL)
1542 {
1543 cedar = server->Cedar;
1544 }
1545
1546 Lock(cedar->CedarSuperLock);
1547
1548 if (true)
1549 {
1550 char tmp[MAX_PATH];
1551 char ip[MAX_PATH];
1552 UINT rpc_id = 0;
1553
1554 StrCpy(ip, sizeof(ip), "Unknown");
1555
1556 if (rpc->Sock != NULL)
1557 {
1558 IPToStr(ip, sizeof(ip), &rpc->Sock->RemoteIP);
1559 rpc_id = rpc->Sock->socket;
1560 }
1561
1562 Format(tmp, sizeof(tmp), "RPC: RPC-%u (%s): Entering RPC [%s]...",
1563 rpc_id, ip, name);
1564
1565 SiDebugLog(a->Server, tmp);
1566 }
1567
1568 if (0) {}
1569
1570 // RPC function declaration: from here
1571 DECLARE_RPC_EX("Test", RPC_TEST, StTest, InRpcTest, OutRpcTest, FreeRpcTest)
1572 DECLARE_RPC_EX("GetServerInfo", RPC_SERVER_INFO, StGetServerInfo, InRpcServerInfo, OutRpcServerInfo, FreeRpcServerInfo)
1573 DECLARE_RPC("GetServerStatus", RPC_SERVER_STATUS, StGetServerStatus, InRpcServerStatus, OutRpcServerStatus)
1574 DECLARE_RPC("CreateListener", RPC_LISTENER, StCreateListener, InRpcListener, OutRpcListener)
1575 DECLARE_RPC_EX("EnumListener", RPC_LISTENER_LIST, StEnumListener, InRpcListenerList, OutRpcListenerList, FreeRpcListenerList)
1576 DECLARE_RPC("DeleteListener", RPC_LISTENER, StDeleteListener, InRpcListener, OutRpcListener)
1577 DECLARE_RPC("EnableListener", RPC_LISTENER, StEnableListener, InRpcListener, OutRpcListener)
1578 DECLARE_RPC("SetServerPassword", RPC_SET_PASSWORD, StSetServerPassword, InRpcSetPassword, OutRpcSetPassword)
1579 DECLARE_RPC_EX("SetFarmSetting", RPC_FARM, StSetFarmSetting, InRpcFarm, OutRpcFarm, FreeRpcFarm)
1580 DECLARE_RPC_EX("GetFarmSetting", RPC_FARM, StGetFarmSetting, InRpcFarm, OutRpcFarm, FreeRpcFarm)
1581 DECLARE_RPC_EX("GetFarmInfo", RPC_FARM_INFO, StGetFarmInfo, InRpcFarmInfo, OutRpcFarmInfo, FreeRpcFarmInfo)
1582 DECLARE_RPC_EX("EnumFarmMember", RPC_ENUM_FARM, StEnumFarmMember, InRpcEnumFarm, OutRpcEnumFarm, FreeRpcEnumFarm)
1583 DECLARE_RPC("GetFarmConnectionStatus", RPC_FARM_CONNECTION_STATUS, StGetFarmConnectionStatus, InRpcFarmConnectionStatus, OutRpcFarmConnectionStatus)
1584 DECLARE_RPC_EX("SetServerCert", RPC_KEY_PAIR, StSetServerCert, InRpcKeyPair, OutRpcKeyPair, FreeRpcKeyPair)
1585 DECLARE_RPC_EX("GetServerCert", RPC_KEY_PAIR, StGetServerCert, InRpcKeyPair, OutRpcKeyPair, FreeRpcKeyPair)
1586 DECLARE_RPC_EX("GetServerCipher", RPC_STR, StGetServerCipher, InRpcStr, OutRpcStr, FreeRpcStr)
1587 DECLARE_RPC_EX("SetServerCipher", RPC_STR, StSetServerCipher, InRpcStr, OutRpcStr, FreeRpcStr)
1588 DECLARE_RPC("CreateHub", RPC_CREATE_HUB, StCreateHub, InRpcCreateHub, OutRpcCreateHub)
1589 DECLARE_RPC("SetHub", RPC_CREATE_HUB, StSetHub, InRpcCreateHub, OutRpcCreateHub)
1590 DECLARE_RPC("GetHub", RPC_CREATE_HUB, StGetHub, InRpcCreateHub, OutRpcCreateHub)
1591 DECLARE_RPC_EX("EnumHub", RPC_ENUM_HUB, StEnumHub, InRpcEnumHub, OutRpcEnumHub, FreeRpcEnumHub)
1592 DECLARE_RPC("DeleteHub", RPC_DELETE_HUB, StDeleteHub, InRpcDeleteHub, OutRpcDeleteHub)
1593 DECLARE_RPC("GetHubRadius", RPC_RADIUS, StGetHubRadius, InRpcRadius, OutRpcRadius)
1594 DECLARE_RPC("SetHubRadius", RPC_RADIUS, StSetHubRadius, InRpcRadius, OutRpcRadius)
1595 DECLARE_RPC_EX("EnumConnection", RPC_ENUM_CONNECTION, StEnumConnection, InRpcEnumConnection, OutRpcEnumConnection, FreeRpcEnumConnetion)
1596 DECLARE_RPC("DisconnectConnection", RPC_DISCONNECT_CONNECTION, StDisconnectConnection, InRpcDisconnectConnection, OutRpcDisconnectConnection)
1597 DECLARE_RPC("GetConnectionInfo", RPC_CONNECTION_INFO, StGetConnectionInfo, InRpcConnectionInfo, OutRpcConnectionInfo)
1598 DECLARE_RPC("SetHubOnline", RPC_SET_HUB_ONLINE, StSetHubOnline, InRpcSetHubOnline, OutRpcSetHubOnline)
1599 DECLARE_RPC("GetHubStatus", RPC_HUB_STATUS, StGetHubStatus, InRpcHubStatus, OutRpcHubStatus)
1600 DECLARE_RPC("SetHubLog", RPC_HUB_LOG, StSetHubLog, InRpcHubLog, OutRpcHubLog)
1601 DECLARE_RPC("GetHubLog", RPC_HUB_LOG, StGetHubLog, InRpcHubLog, OutRpcHubLog)
1602 DECLARE_RPC_EX("AddCa", RPC_HUB_ADD_CA, StAddCa, InRpcHubAddCa, OutRpcHubAddCa, FreeRpcHubAddCa)
1603 DECLARE_RPC_EX("EnumCa", RPC_HUB_ENUM_CA, StEnumCa, InRpcHubEnumCa, OutRpcHubEnumCa, FreeRpcHubEnumCa)
1604 DECLARE_RPC_EX("GetCa", RPC_HUB_GET_CA, StGetCa, InRpcHubGetCa, OutRpcHubGetCa, FreeRpcHubGetCa)
1605 DECLARE_RPC("DeleteCa", RPC_HUB_DELETE_CA, StDeleteCa, InRpcHubDeleteCa, OutRpcHubDeleteCa)
1606 DECLARE_RPC("SetLinkOnline", RPC_LINK, StSetLinkOnline, InRpcLink, OutRpcLink)
1607 DECLARE_RPC("SetLinkOffline", RPC_LINK, StSetLinkOffline, InRpcLink, OutRpcLink)
1608 DECLARE_RPC("DeleteLink", RPC_LINK, StDeleteLink, InRpcLink, OutRpcLink)
1609 DECLARE_RPC("RenameLink", RPC_RENAME_LINK, StRenameLink, InRpcRenameLink, OutRpcRenameLink)
1610 DECLARE_RPC_EX("CreateLink", RPC_CREATE_LINK, StCreateLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)
1611 DECLARE_RPC_EX("GetLink", RPC_CREATE_LINK, StGetLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)
1612 DECLARE_RPC_EX("SetLink", RPC_CREATE_LINK, StSetLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)
1613 DECLARE_RPC_EX("EnumLink", RPC_ENUM_LINK, StEnumLink, InRpcEnumLink, OutRpcEnumLink, FreeRpcEnumLink)
1614 DECLARE_RPC_EX("GetLinkStatus", RPC_LINK_STATUS, StGetLinkStatus, InRpcLinkStatus, OutRpcLinkStatus, FreeRpcLinkStatus)
1615 DECLARE_RPC("AddAccess", RPC_ADD_ACCESS, StAddAccess, InRpcAddAccess, OutRpcAddAccess)
1616 DECLARE_RPC("DeleteAccess", RPC_DELETE_ACCESS, StDeleteAccess, InRpcDeleteAccess, OutRpcDeleteAccess)
1617 DECLARE_RPC_EX("EnumAccess", RPC_ENUM_ACCESS_LIST, StEnumAccess, InRpcEnumAccessList, OutRpcEnumAccessList, FreeRpcEnumAccessList)
1618 DECLARE_RPC_EX("SetAccessList", RPC_ENUM_ACCESS_LIST, StSetAccessList, InRpcEnumAccessList, OutRpcEnumAccessList, FreeRpcEnumAccessList)
1619 DECLARE_RPC_EX("CreateUser", RPC_SET_USER, StCreateUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)
1620 DECLARE_RPC_EX("SetUser", RPC_SET_USER, StSetUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)
1621 DECLARE_RPC_EX("GetUser", RPC_SET_USER, StGetUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)
1622 DECLARE_RPC("DeleteUser", RPC_DELETE_USER, StDeleteUser, InRpcDeleteUser, OutRpcDeleteUser)
1623 DECLARE_RPC_EX("EnumUser", RPC_ENUM_USER, StEnumUser, InRpcEnumUser, OutRpcEnumUser, FreeRpcEnumUser)
1624 DECLARE_RPC_EX("CreateGroup", RPC_SET_GROUP, StCreateGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)
1625 DECLARE_RPC_EX("SetGroup", RPC_SET_GROUP, StSetGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)
1626 DECLARE_RPC_EX("GetGroup", RPC_SET_GROUP, StGetGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)
1627 DECLARE_RPC("DeleteGroup", RPC_DELETE_USER, StDeleteGroup, InRpcDeleteUser, OutRpcDeleteUser)
1628 DECLARE_RPC_EX("EnumGroup", RPC_ENUM_GROUP, StEnumGroup, InRpcEnumGroup, OutRpcEnumGroup, FreeRpcEnumGroup)
1629 DECLARE_RPC_EX("EnumSession", RPC_ENUM_SESSION, StEnumSession, InRpcEnumSession, OutRpcEnumSession, FreeRpcEnumSession)
1630 DECLARE_RPC_EX("GetSessionStatus", RPC_SESSION_STATUS, StGetSessionStatus, InRpcSessionStatus, OutRpcSessionStatus, FreeRpcSessionStatus)
1631 DECLARE_RPC("DeleteSession", RPC_DELETE_SESSION, StDeleteSession, InRpcDeleteSession, OutRpcDeleteSession)
1632 DECLARE_RPC_EX("EnumMacTable", RPC_ENUM_MAC_TABLE, StEnumMacTable, InRpcEnumMacTable, OutRpcEnumMacTable, FreeRpcEnumMacTable)
1633 DECLARE_RPC("DeleteMacTable", RPC_DELETE_TABLE, StDeleteMacTable, InRpcDeleteTable, OutRpcDeleteTable)
1634 DECLARE_RPC_EX("EnumIpTable", RPC_ENUM_IP_TABLE, StEnumIpTable, InRpcEnumIpTable, OutRpcEnumIpTable, FreeRpcEnumIpTable)
1635 DECLARE_RPC("DeleteIpTable", RPC_DELETE_TABLE, StDeleteIpTable, InRpcDeleteTable, OutRpcDeleteTable)
1636 DECLARE_RPC("SetKeep", RPC_KEEP, StSetKeep, InRpcKeep, OutRpcKeep)
1637 DECLARE_RPC("GetKeep", RPC_KEEP, StGetKeep, InRpcKeep, OutRpcKeep)
1638 DECLARE_RPC("EnableSecureNAT", RPC_HUB, StEnableSecureNAT, InRpcHub, OutRpcHub)
1639 DECLARE_RPC("DisableSecureNAT", RPC_HUB, StDisableSecureNAT, InRpcHub, OutRpcHub)
1640 DECLARE_RPC("SetSecureNATOption", VH_OPTION, StSetSecureNATOption, InVhOption, OutVhOption)
1641 DECLARE_RPC("GetSecureNATOption", VH_OPTION, StGetSecureNATOption, InVhOption, OutVhOption)
1642 DECLARE_RPC_EX("EnumNAT", RPC_ENUM_NAT, StEnumNAT, InRpcEnumNat, OutRpcEnumNat, FreeRpcEnumNat)
1643 DECLARE_RPC_EX("EnumDHCP", RPC_ENUM_DHCP, StEnumDHCP, InRpcEnumDhcp, OutRpcEnumDhcp, FreeRpcEnumDhcp)
1644 DECLARE_RPC("GetSecureNATStatus", RPC_NAT_STATUS, StGetSecureNATStatus, InRpcNatStatus, OutRpcNatStatus)
1645 DECLARE_RPC_EX("EnumEthernet", RPC_ENUM_ETH, StEnumEthernet, InRpcEnumEth, OutRpcEnumEth, FreeRpcEnumEth)
1646 DECLARE_RPC("AddLocalBridge", RPC_LOCALBRIDGE, StAddLocalBridge, InRpcLocalBridge, OutRpcLocalBridge)
1647 DECLARE_RPC("DeleteLocalBridge", RPC_LOCALBRIDGE, StDeleteLocalBridge, InRpcLocalBridge, OutRpcLocalBridge)
1648 DECLARE_RPC_EX("EnumLocalBridge", RPC_ENUM_LOCALBRIDGE, StEnumLocalBridge, InRpcEnumLocalBridge, OutRpcEnumLocalBridge, FreeRpcEnumLocalBridge)
1649 DECLARE_RPC("GetBridgeSupport", RPC_BRIDGE_SUPPORT, StGetBridgeSupport, InRpcBridgeSupport, OutRpcBridgeSupport)
1650 DECLARE_RPC("RebootServer", RPC_TEST, StRebootServer, InRpcTest, OutRpcTest)
1651 DECLARE_RPC_EX("GetCaps", CAPSLIST, StGetCaps, InRpcCapsList, OutRpcCapsList, FreeRpcCapsList)
1652 DECLARE_RPC_EX("GetConfig", RPC_CONFIG, StGetConfig, InRpcConfig, OutRpcConfig, FreeRpcConfig)
1653 DECLARE_RPC_EX("SetConfig", RPC_CONFIG, StSetConfig, InRpcConfig, OutRpcConfig, FreeRpcConfig)
1654 DECLARE_RPC_EX("GetDefaultHubAdminOptions", RPC_ADMIN_OPTION, StGetDefaultHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1655 DECLARE_RPC_EX("GetHubAdminOptions", RPC_ADMIN_OPTION, StGetHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1656 DECLARE_RPC_EX("SetHubAdminOptions", RPC_ADMIN_OPTION, StSetHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1657 DECLARE_RPC_EX("GetHubExtOptions", RPC_ADMIN_OPTION, StGetHubExtOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1658 DECLARE_RPC_EX("SetHubExtOptions", RPC_ADMIN_OPTION, StSetHubExtOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1659 DECLARE_RPC("AddL3Switch", RPC_L3SW, StAddL3Switch, InRpcL3Sw, OutRpcL3Sw)
1660 DECLARE_RPC("DelL3Switch", RPC_L3SW, StDelL3Switch, InRpcL3Sw, OutRpcL3Sw)
1661 DECLARE_RPC_EX("EnumL3Switch", RPC_ENUM_L3SW, StEnumL3Switch, InRpcEnumL3Sw, OutRpcEnumL3Sw, FreeRpcEnumL3Sw)
1662 DECLARE_RPC("StartL3Switch", RPC_L3SW, StStartL3Switch, InRpcL3Sw, OutRpcL3Sw)
1663 DECLARE_RPC("StopL3Switch", RPC_L3SW, StStopL3Switch, InRpcL3Sw, OutRpcL3Sw)
1664 DECLARE_RPC("AddL3If", RPC_L3IF, StAddL3If, InRpcL3If, OutRpcL3If)
1665 DECLARE_RPC("DelL3If", RPC_L3IF, StDelL3If, InRpcL3If, OutRpcL3If)
1666 DECLARE_RPC_EX("EnumL3If", RPC_ENUM_L3IF, StEnumL3If, InRpcEnumL3If, OutRpcEnumL3If, FreeRpcEnumL3If)
1667 DECLARE_RPC("AddL3Table", RPC_L3TABLE, StAddL3Table, InRpcL3Table, OutRpcL3Table)
1668 DECLARE_RPC("DelL3Table", RPC_L3TABLE, StDelL3Table, InRpcL3Table, OutRpcL3Table)
1669 DECLARE_RPC_EX("EnumL3Table", RPC_ENUM_L3TABLE, StEnumL3Table, InRpcEnumL3Table, OutRpcEnumL3Table, FreeRpcEnumL3Table)
1670 DECLARE_RPC_EX("EnumCrl", RPC_ENUM_CRL, StEnumCrl, InRpcEnumCrl, OutRpcEnumCrl, FreeRpcEnumCrl)
1671 DECLARE_RPC_EX("AddCrl", RPC_CRL, StAddCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)
1672 DECLARE_RPC_EX("DelCrl", RPC_CRL, StDelCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)
1673 DECLARE_RPC_EX("GetCrl", RPC_CRL, StGetCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)
1674 DECLARE_RPC_EX("SetCrl", RPC_CRL, StSetCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)
1675 DECLARE_RPC_EX("SetAcList", RPC_AC_LIST, StSetAcList, InRpcAcList, OutRpcAcList, FreeRpcAcList)
1676 DECLARE_RPC_EX("GetAcList", RPC_AC_LIST, StGetAcList, InRpcAcList, OutRpcAcList, FreeRpcAcList)
1677 DECLARE_RPC_EX("EnumLogFile", RPC_ENUM_LOG_FILE, StEnumLogFile, InRpcEnumLogFile, OutRpcEnumLogFile, FreeRpcEnumLogFile)
1678 DECLARE_RPC_EX("ReadLogFile", RPC_READ_LOG_FILE, StReadLogFile, InRpcReadLogFile, OutRpcReadLogFile, FreeRpcReadLogFile)
1679 DECLARE_RPC("AddLicenseKey", RPC_TEST, StAddLicenseKey, InRpcTest, OutRpcTest)
1680 DECLARE_RPC("DelLicenseKey", RPC_TEST, StDelLicenseKey, InRpcTest, OutRpcTest)
1681 DECLARE_RPC_EX("EnumLicenseKey", RPC_ENUM_LICENSE_KEY, StEnumLicenseKey, InRpcEnumLicenseKey, OutRpcEnumLicenseKey, FreeRpcEnumLicenseKey)
1682 DECLARE_RPC("GetLicenseStatus", RPC_LICENSE_STATUS, StGetLicenseStatus, InRpcLicenseStatus, OutRpcLicenseStatus)
1683 DECLARE_RPC("SetSysLog", SYSLOG_SETTING, StSetSysLog, InRpcSysLogSetting, OutRpcSysLogSetting)
1684 DECLARE_RPC("GetSysLog", SYSLOG_SETTING, StGetSysLog, InRpcSysLogSetting, OutRpcSysLogSetting)
1685 DECLARE_RPC_EX("EnumEthVLan", RPC_ENUM_ETH_VLAN, StEnumEthVLan, InRpcEnumEthVLan, OutRpcEnumEthVLan, FreeRpcEnumEthVLan)
1686 DECLARE_RPC("SetEnableEthVLan", RPC_TEST, StSetEnableEthVLan, InRpcTest, OutRpcTest)
1687 DECLARE_RPC_EX("SetHubMsg", RPC_MSG, StSetHubMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)
1688 DECLARE_RPC_EX("GetHubMsg", RPC_MSG, StGetHubMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)
1689 DECLARE_RPC("Crash", RPC_TEST, StCrash, InRpcTest, OutRpcTest)
1690 DECLARE_RPC_EX("GetAdminMsg", RPC_MSG, StGetAdminMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)
1691 DECLARE_RPC("Flush", RPC_TEST, StFlush, InRpcTest, OutRpcTest)
1692 DECLARE_RPC("Debug", RPC_TEST, StDebug, InRpcTest, OutRpcTest)
1693 DECLARE_RPC("SetIPsecServices", IPSEC_SERVICES, StSetIPsecServices, InIPsecServices, OutIPsecServices)
1694 DECLARE_RPC("GetIPsecServices", IPSEC_SERVICES, StGetIPsecServices, InIPsecServices, OutIPsecServices)
1695 DECLARE_RPC("AddEtherIpId", ETHERIP_ID, StAddEtherIpId, InEtherIpId, OutEtherIpId)
1696 DECLARE_RPC("GetEtherIpId", ETHERIP_ID, StGetEtherIpId, InEtherIpId, OutEtherIpId)
1697 DECLARE_RPC("DeleteEtherIpId", ETHERIP_ID, StDeleteEtherIpId, InEtherIpId, OutEtherIpId)
1698 DECLARE_RPC_EX("EnumEtherIpId", RPC_ENUM_ETHERIP_ID, StEnumEtherIpId, InRpcEnumEtherIpId, OutRpcEnumEtherIpId, FreeRpcEnumEtherIpId)
1699 DECLARE_RPC("SetOpenVpnSstpConfig", OPENVPN_SSTP_CONFIG, StSetOpenVpnSstpConfig, InOpenVpnSstpConfig, OutOpenVpnSstpConfig)
1700 DECLARE_RPC("GetOpenVpnSstpConfig", OPENVPN_SSTP_CONFIG, StGetOpenVpnSstpConfig, InOpenVpnSstpConfig, OutOpenVpnSstpConfig)
1701 DECLARE_RPC("GetDDnsClientStatus", DDNS_CLIENT_STATUS, StGetDDnsClientStatus, InDDnsClientStatus, OutDDnsClientStatus)
1702 DECLARE_RPC("ChangeDDnsClientHostname", RPC_TEST, StChangeDDnsClientHostname, InRpcTest, OutRpcTest)
1703 DECLARE_RPC("RegenerateServerCert", RPC_TEST, StRegenerateServerCert, InRpcTest, OutRpcTest)
1704 DECLARE_RPC_EX("MakeOpenVpnConfigFile", RPC_READ_LOG_FILE, StMakeOpenVpnConfigFile, InRpcReadLogFile, OutRpcReadLogFile, FreeRpcReadLogFile)
1705 DECLARE_RPC("SetSpecialListener", RPC_SPECIAL_LISTENER, StSetSpecialListener, InRpcSpecialListener, OutRpcSpecialListener)
1706 DECLARE_RPC("GetSpecialListener", RPC_SPECIAL_LISTENER, StGetSpecialListener, InRpcSpecialListener, OutRpcSpecialListener)
1707 DECLARE_RPC("GetAzureStatus", RPC_AZURE_STATUS, StGetAzureStatus, InRpcAzureStatus, OutRpcAzureStatus)
1708 DECLARE_RPC("SetAzureStatus", RPC_AZURE_STATUS, StSetAzureStatus, InRpcAzureStatus, OutRpcAzureStatus)
1709 DECLARE_RPC("GetDDnsInternetSettng", INTERNET_SETTING, StGetDDnsInternetSetting, InRpcInternetSetting, OutRpcInternetSetting)
1710 DECLARE_RPC("SetDDnsInternetSettng", INTERNET_SETTING, StSetDDnsInternetSetting, InRpcInternetSetting, OutRpcInternetSetting)
1711 // RPC function declaration: till here
1712
1713
1714 if (ok == false)
1715 {
1716 err = ERR_NOT_SUPPORTED;
1717 }
1718
1719 if (err != ERR_NO_ERROR)
1720 {
1721 PackAddInt(ret, "error", err);
1722 }
1723
1724 if (true)
1725 {
1726 char tmp[MAX_PATH];
1727 char ip[MAX_PATH];
1728 UINT rpc_id = 0;
1729
1730 StrCpy(ip, sizeof(ip), "Unknown");
1731
1732 if (rpc->Sock != NULL)
1733 {
1734 IPToStr(ip, sizeof(ip), &rpc->Sock->RemoteIP);
1735 rpc_id = rpc->Sock->socket;
1736 }
1737
1738 Format(tmp, sizeof(tmp), "RPC: RPC-%u (%s): Leaving RPC [%s] (Error: %u).",
1739 rpc_id, ip, name, err);
1740
1741 SiDebugLog(a->Server, tmp);
1742 }
1743
1744 Unlock(cedar->CedarSuperLock);
1745
1746 return ret;
1747 }
1748
1749 // RPC call function declaration: from here
1750 DECLARE_SC_EX("Test", RPC_TEST, ScTest, InRpcTest, OutRpcTest, FreeRpcTest)
1751 DECLARE_SC_EX("GetServerInfo", RPC_SERVER_INFO, ScGetServerInfo, InRpcServerInfo, OutRpcServerInfo, FreeRpcServerInfo)
1752 DECLARE_SC("GetServerStatus", RPC_SERVER_STATUS, ScGetServerStatus, InRpcServerStatus, OutRpcServerStatus)
1753 DECLARE_SC("CreateListener", RPC_LISTENER, ScCreateListener, InRpcListener, OutRpcListener)
1754 DECLARE_SC_EX("EnumListener", RPC_LISTENER_LIST, ScEnumListener, InRpcListenerList, OutRpcListenerList, FreeRpcListenerList)
1755 DECLARE_SC("DeleteListener", RPC_LISTENER, ScDeleteListener, InRpcListener, OutRpcListener)
1756 DECLARE_SC("EnableListener", RPC_LISTENER, ScEnableListener, InRpcListener, OutRpcListener)
1757 DECLARE_SC("SetServerPassword", RPC_SET_PASSWORD, ScSetServerPassword, InRpcSetPassword, OutRpcSetPassword)
1758 DECLARE_SC_EX("SetFarmSetting", RPC_FARM, ScSetFarmSetting, InRpcFarm, OutRpcFarm, FreeRpcFarm)
1759 DECLARE_SC_EX("GetFarmSetting", RPC_FARM, ScGetFarmSetting, InRpcFarm, OutRpcFarm, FreeRpcFarm)
1760 DECLARE_SC_EX("GetFarmInfo", RPC_FARM_INFO, ScGetFarmInfo, InRpcFarmInfo, OutRpcFarmInfo, FreeRpcFarmInfo)
1761 DECLARE_SC_EX("EnumFarmMember", RPC_ENUM_FARM, ScEnumFarmMember, InRpcEnumFarm, OutRpcEnumFarm, FreeRpcEnumFarm)
1762 DECLARE_SC("GetFarmConnectionStatus", RPC_FARM_CONNECTION_STATUS, ScGetFarmConnectionStatus, InRpcFarmConnectionStatus, OutRpcFarmConnectionStatus)
1763 DECLARE_SC_EX("SetServerCert", RPC_KEY_PAIR, ScSetServerCert, InRpcKeyPair, OutRpcKeyPair, FreeRpcKeyPair)
1764 DECLARE_SC_EX("GetServerCert", RPC_KEY_PAIR, ScGetServerCert, InRpcKeyPair, OutRpcKeyPair, FreeRpcKeyPair)
1765 DECLARE_SC_EX("GetServerCipher", RPC_STR, ScGetServerCipher, InRpcStr, OutRpcStr, FreeRpcStr)
1766 DECLARE_SC_EX("SetServerCipher", RPC_STR, ScSetServerCipher, InRpcStr, OutRpcStr, FreeRpcStr)
1767 DECLARE_SC("CreateHub", RPC_CREATE_HUB, ScCreateHub, InRpcCreateHub, OutRpcCreateHub)
1768 DECLARE_SC("SetHub", RPC_CREATE_HUB, ScSetHub, InRpcCreateHub, OutRpcCreateHub)
1769 DECLARE_SC("GetHub", RPC_CREATE_HUB, ScGetHub, InRpcCreateHub, OutRpcCreateHub)
1770 DECLARE_SC_EX("EnumHub", RPC_ENUM_HUB, ScEnumHub, InRpcEnumHub, OutRpcEnumHub, FreeRpcEnumHub)
1771 DECLARE_SC("DeleteHub", RPC_DELETE_HUB, ScDeleteHub, InRpcDeleteHub, OutRpcDeleteHub)
1772 DECLARE_SC("GetHubRadius", RPC_RADIUS, ScGetHubRadius, InRpcRadius, OutRpcRadius)
1773 DECLARE_SC("SetHubRadius", RPC_RADIUS, ScSetHubRadius, InRpcRadius, OutRpcRadius)
1774 DECLARE_SC_EX("EnumConnection", RPC_ENUM_CONNECTION, ScEnumConnection, InRpcEnumConnection, OutRpcEnumConnection, FreeRpcEnumConnetion)
1775 DECLARE_SC("DisconnectConnection", RPC_DISCONNECT_CONNECTION, ScDisconnectConnection, InRpcDisconnectConnection, OutRpcDisconnectConnection)
1776 DECLARE_SC("GetConnectionInfo", RPC_CONNECTION_INFO, ScGetConnectionInfo, InRpcConnectionInfo, OutRpcConnectionInfo)
1777 DECLARE_SC("SetHubOnline", RPC_SET_HUB_ONLINE, ScSetHubOnline, InRpcSetHubOnline, OutRpcSetHubOnline)
1778 DECLARE_SC("GetHubStatus", RPC_HUB_STATUS, ScGetHubStatus, InRpcHubStatus, OutRpcHubStatus)
1779 DECLARE_SC("SetHubLog", RPC_HUB_LOG, ScSetHubLog, InRpcHubLog, OutRpcHubLog)
1780 DECLARE_SC("GetHubLog", RPC_HUB_LOG, ScGetHubLog, InRpcHubLog, OutRpcHubLog)
1781 DECLARE_SC_EX("AddCa", RPC_HUB_ADD_CA, ScAddCa, InRpcHubAddCa, OutRpcHubAddCa, FreeRpcHubAddCa)
1782 DECLARE_SC_EX("EnumCa", RPC_HUB_ENUM_CA, ScEnumCa, InRpcHubEnumCa, OutRpcHubEnumCa, FreeRpcHubEnumCa)
1783 DECLARE_SC_EX("GetCa", RPC_HUB_GET_CA, ScGetCa, InRpcHubGetCa, OutRpcHubGetCa, FreeRpcHubGetCa)
1784 DECLARE_SC("DeleteCa", RPC_HUB_DELETE_CA, ScDeleteCa, InRpcHubDeleteCa, OutRpcHubDeleteCa)
1785 DECLARE_SC_EX("CreateLink", RPC_CREATE_LINK, ScCreateLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)
1786 DECLARE_SC_EX("GetLink", RPC_CREATE_LINK, ScGetLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)
1787 DECLARE_SC_EX("SetLink", RPC_CREATE_LINK, ScSetLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)
1788 DECLARE_SC_EX("EnumLink", RPC_ENUM_LINK, ScEnumLink, InRpcEnumLink, OutRpcEnumLink, FreeRpcEnumLink)
1789 DECLARE_SC_EX("GetLinkStatus", RPC_LINK_STATUS, ScGetLinkStatus, InRpcLinkStatus, OutRpcLinkStatus, FreeRpcLinkStatus)
1790 DECLARE_SC("SetLinkOnline", RPC_LINK, ScSetLinkOnline, InRpcLink, OutRpcLink)
1791 DECLARE_SC("SetLinkOffline", RPC_LINK, ScSetLinkOffline, InRpcLink, OutRpcLink)
1792 DECLARE_SC("DeleteLink", RPC_LINK, ScDeleteLink, InRpcLink, OutRpcLink)
1793 DECLARE_SC("RenameLink", RPC_RENAME_LINK, ScRenameLink, InRpcRenameLink, OutRpcRenameLink)
1794 DECLARE_SC("AddAccess", RPC_ADD_ACCESS, ScAddAccess, InRpcAddAccess, OutRpcAddAccess)
1795 DECLARE_SC("DeleteAccess", RPC_DELETE_ACCESS, ScDeleteAccess, InRpcDeleteAccess, OutRpcDeleteAccess)
1796 DECLARE_SC_EX("EnumAccess", RPC_ENUM_ACCESS_LIST, ScEnumAccess, InRpcEnumAccessList, OutRpcEnumAccessList, FreeRpcEnumAccessList)
1797 DECLARE_SC_EX("SetAccessList", RPC_ENUM_ACCESS_LIST, ScSetAccessList, InRpcEnumAccessList, OutRpcEnumAccessList, FreeRpcEnumAccessList)
1798 DECLARE_SC_EX("CreateUser", RPC_SET_USER, ScCreateUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)
1799 DECLARE_SC_EX("SetUser", RPC_SET_USER, ScSetUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)
1800 DECLARE_SC_EX("GetUser", RPC_SET_USER, ScGetUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)
1801 DECLARE_SC("DeleteUser", RPC_DELETE_USER, ScDeleteUser, InRpcDeleteUser, OutRpcDeleteUser)
1802 DECLARE_SC_EX("EnumUser", RPC_ENUM_USER, ScEnumUser, InRpcEnumUser, OutRpcEnumUser, FreeRpcEnumUser)
1803 DECLARE_SC_EX("CreateGroup", RPC_SET_GROUP, ScCreateGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)
1804 DECLARE_SC_EX("SetGroup", RPC_SET_GROUP, ScSetGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)
1805 DECLARE_SC_EX("GetGroup", RPC_SET_GROUP, ScGetGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)
1806 DECLARE_SC("DeleteGroup", RPC_DELETE_USER, ScDeleteGroup, InRpcDeleteUser, OutRpcDeleteUser)
1807 DECLARE_SC_EX("EnumGroup", RPC_ENUM_GROUP, ScEnumGroup, InRpcEnumGroup, OutRpcEnumGroup, FreeRpcEnumGroup)
1808 DECLARE_SC_EX("EnumSession", RPC_ENUM_SESSION, ScEnumSession, InRpcEnumSession, OutRpcEnumSession, FreeRpcEnumSession)
1809 DECLARE_SC_EX("GetSessionStatus", RPC_SESSION_STATUS, ScGetSessionStatus, InRpcSessionStatus, OutRpcSessionStatus, FreeRpcSessionStatus)
1810 DECLARE_SC("DeleteSession", RPC_DELETE_SESSION, ScDeleteSession, InRpcDeleteSession, OutRpcDeleteSession)
1811 DECLARE_SC_EX("EnumMacTable", RPC_ENUM_MAC_TABLE, ScEnumMacTable, InRpcEnumMacTable, OutRpcEnumMacTable, FreeRpcEnumMacTable)
1812 DECLARE_SC("DeleteMacTable", RPC_DELETE_TABLE, ScDeleteMacTable, InRpcDeleteTable, OutRpcDeleteTable)
1813 DECLARE_SC_EX("EnumIpTable", RPC_ENUM_IP_TABLE, ScEnumIpTable, InRpcEnumIpTable, OutRpcEnumIpTable, FreeRpcEnumIpTable)
1814 DECLARE_SC("DeleteIpTable", RPC_DELETE_TABLE, ScDeleteIpTable, InRpcDeleteTable, OutRpcDeleteTable)
1815 DECLARE_SC("SetKeep", RPC_KEEP, ScSetKeep, InRpcKeep, OutRpcKeep)
1816 DECLARE_SC("GetKeep", RPC_KEEP, ScGetKeep, InRpcKeep, OutRpcKeep)
1817 DECLARE_SC("EnableSecureNAT", RPC_HUB, ScEnableSecureNAT, InRpcHub, OutRpcHub)
1818 DECLARE_SC("DisableSecureNAT", RPC_HUB, ScDisableSecureNAT, InRpcHub, OutRpcHub)
1819 DECLARE_SC("SetSecureNATOption", VH_OPTION, ScSetSecureNATOption, InVhOption, OutVhOption)
1820 DECLARE_SC("GetSecureNATOption", VH_OPTION, ScGetSecureNATOption, InVhOption, OutVhOption)
1821 DECLARE_SC_EX("EnumNAT", RPC_ENUM_NAT, ScEnumNAT, InRpcEnumNat, OutRpcEnumNat, FreeRpcEnumNat)
1822 DECLARE_SC_EX("EnumDHCP", RPC_ENUM_DHCP, ScEnumDHCP, InRpcEnumDhcp, OutRpcEnumDhcp, FreeRpcEnumDhcp)
1823 DECLARE_SC("GetSecureNATStatus", RPC_NAT_STATUS, ScGetSecureNATStatus, InRpcNatStatus, OutRpcNatStatus)
1824 DECLARE_SC_EX("EnumEthernet", RPC_ENUM_ETH, ScEnumEthernet, InRpcEnumEth, OutRpcEnumEth, FreeRpcEnumEth)
1825 DECLARE_SC("AddLocalBridge", RPC_LOCALBRIDGE, ScAddLocalBridge, InRpcLocalBridge, OutRpcLocalBridge)
1826 DECLARE_SC("DeleteLocalBridge", RPC_LOCALBRIDGE, ScDeleteLocalBridge, InRpcLocalBridge, OutRpcLocalBridge)
1827 DECLARE_SC_EX("EnumLocalBridge", RPC_ENUM_LOCALBRIDGE, ScEnumLocalBridge, InRpcEnumLocalBridge, OutRpcEnumLocalBridge, FreeRpcEnumLocalBridge)
1828 DECLARE_SC("GetBridgeSupport", RPC_BRIDGE_SUPPORT, ScGetBridgeSupport, InRpcBridgeSupport, OutRpcBridgeSupport)
1829 DECLARE_SC("RebootServer", RPC_TEST, ScRebootServer, InRpcTest, OutRpcTest)
1830 DECLARE_SC_EX("GetCaps", CAPSLIST, ScGetCaps, InRpcCapsList, OutRpcCapsList, FreeRpcCapsList)
1831 DECLARE_SC_EX("GetConfig", RPC_CONFIG, ScGetConfig, InRpcConfig, OutRpcConfig, FreeRpcConfig)
1832 DECLARE_SC_EX("SetConfig", RPC_CONFIG, ScSetConfig, InRpcConfig, OutRpcConfig, FreeRpcConfig)
1833 DECLARE_SC_EX("GetHubAdminOptions", RPC_ADMIN_OPTION, ScGetHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1834 DECLARE_SC_EX("SetHubAdminOptions", RPC_ADMIN_OPTION, ScSetHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1835 DECLARE_SC_EX("GetHubExtOptions", RPC_ADMIN_OPTION, ScGetHubExtOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1836 DECLARE_SC_EX("SetHubExtOptions", RPC_ADMIN_OPTION, ScSetHubExtOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1837 DECLARE_SC_EX("GetDefaultHubAdminOptions", RPC_ADMIN_OPTION, ScGetDefaultHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)
1838 DECLARE_SC("AddL3Switch", RPC_L3SW, ScAddL3Switch, InRpcL3Sw, OutRpcL3Sw)
1839 DECLARE_SC("DelL3Switch", RPC_L3SW, ScDelL3Switch, InRpcL3Sw, OutRpcL3Sw)
1840 DECLARE_SC_EX("EnumL3Switch", RPC_ENUM_L3SW, ScEnumL3Switch, InRpcEnumL3Sw, OutRpcEnumL3Sw, FreeRpcEnumL3Sw)
1841 DECLARE_SC("StartL3Switch", RPC_L3SW, ScStartL3Switch, InRpcL3Sw, OutRpcL3Sw)
1842 DECLARE_SC("StopL3Switch", RPC_L3SW, ScStopL3Switch, InRpcL3Sw, OutRpcL3Sw)
1843 DECLARE_SC("AddL3If", RPC_L3IF, ScAddL3If, InRpcL3If, OutRpcL3If)
1844 DECLARE_SC("DelL3If", RPC_L3IF, ScDelL3If, InRpcL3If, OutRpcL3If)
1845 DECLARE_SC_EX("EnumL3If", RPC_ENUM_L3IF, ScEnumL3If, InRpcEnumL3If, OutRpcEnumL3If, FreeRpcEnumL3If)
1846 DECLARE_SC("AddL3Table", RPC_L3TABLE, ScAddL3Table, InRpcL3Table, OutRpcL3Table)
1847 DECLARE_SC("DelL3Table", RPC_L3TABLE, ScDelL3Table, InRpcL3Table, OutRpcL3Table)
1848 DECLARE_SC_EX("EnumL3Table", RPC_ENUM_L3TABLE, ScEnumL3Table, InRpcEnumL3Table, OutRpcEnumL3Table, FreeRpcEnumL3Table)
1849 DECLARE_SC_EX("EnumCrl", RPC_ENUM_CRL, ScEnumCrl, InRpcEnumCrl, OutRpcEnumCrl, FreeRpcEnumCrl)
1850 DECLARE_SC_EX("AddCrl", RPC_CRL, ScAddCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)
1851 DECLARE_SC_EX("DelCrl", RPC_CRL, ScDelCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)
1852 DECLARE_SC_EX("GetCrl", RPC_CRL, ScGetCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)
1853 DECLARE_SC_EX("SetCrl", RPC_CRL, ScSetCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)
1854 DECLARE_SC_EX("SetAcList", RPC_AC_LIST, ScSetAcList, InRpcAcList, OutRpcAcList, FreeRpcAcList)
1855 DECLARE_SC_EX("GetAcList", RPC_AC_LIST, ScGetAcList, InRpcAcList, OutRpcAcList, FreeRpcAcList)
1856 DECLARE_SC_EX("EnumLogFile", RPC_ENUM_LOG_FILE, ScEnumLogFile, InRpcEnumLogFile, OutRpcEnumLogFile, FreeRpcEnumLogFile)
1857 DECLARE_SC_EX("ReadLogFile", RPC_READ_LOG_FILE, ScReadLogFile, InRpcReadLogFile, OutRpcReadLogFile, FreeRpcReadLogFile)
1858 DECLARE_SC("AddLicenseKey", RPC_TEST, ScAddLicenseKey, InRpcTest, OutRpcTest)
1859 DECLARE_SC("DelLicenseKey", RPC_TEST, ScDelLicenseKey, InRpcTest, OutRpcTest)
1860 DECLARE_SC_EX("EnumLicenseKey", RPC_ENUM_LICENSE_KEY, ScEnumLicenseKey, InRpcEnumLicenseKey, OutRpcEnumLicenseKey, FreeRpcEnumLicenseKey)
1861 DECLARE_SC("GetLicenseStatus", RPC_LICENSE_STATUS, ScGetLicenseStatus, InRpcLicenseStatus, OutRpcLicenseStatus)
1862 DECLARE_SC("SetSysLog", SYSLOG_SETTING, ScSetSysLog, InRpcSysLogSetting, OutRpcSysLogSetting)
1863 DECLARE_SC("GetSysLog", SYSLOG_SETTING, ScGetSysLog, InRpcSysLogSetting, OutRpcSysLogSetting)
1864 DECLARE_SC_EX("EnumEthVLan", RPC_ENUM_ETH_VLAN, ScEnumEthVLan, InRpcEnumEthVLan, OutRpcEnumEthVLan, FreeRpcEnumEthVLan)
1865 DECLARE_SC("SetEnableEthVLan", RPC_TEST, ScSetEnableEthVLan, InRpcTest, OutRpcTest)
1866 DECLARE_SC_EX("SetHubMsg", RPC_MSG, ScSetHubMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)
1867 DECLARE_SC_EX("GetHubMsg", RPC_MSG, ScGetHubMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)
1868 DECLARE_SC("Crash", RPC_TEST, ScCrash, InRpcTest, OutRpcTest)
1869 DECLARE_SC_EX("GetAdminMsg", RPC_MSG, ScGetAdminMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)
1870 DECLARE_SC("Flush", RPC_TEST, ScFlush, InRpcTest, OutRpcTest)
1871 DECLARE_SC("Debug", RPC_TEST, ScDebug, InRpcTest, OutRpcTest)
1872 DECLARE_SC("SetIPsecServices", IPSEC_SERVICES, ScSetIPsecServices, InIPsecServices, OutIPsecServices)
1873 DECLARE_SC("GetIPsecServices", IPSEC_SERVICES, ScGetIPsecServices, InIPsecServices, OutIPsecServices)
1874 DECLARE_SC("AddEtherIpId", ETHERIP_ID, ScAddEtherIpId, InEtherIpId, OutEtherIpId)
1875 DECLARE_SC("GetEtherIpId", ETHERIP_ID, ScGetEtherIpId, InEtherIpId, OutEtherIpId)
1876 DECLARE_SC("DeleteEtherIpId", ETHERIP_ID, ScDeleteEtherIpId, InEtherIpId, OutEtherIpId)
1877 DECLARE_SC_EX("EnumEtherIpId", RPC_ENUM_ETHERIP_ID, ScEnumEtherIpId, InRpcEnumEtherIpId, OutRpcEnumEtherIpId, FreeRpcEnumEtherIpId)
1878 DECLARE_SC("SetOpenVpnSstpConfig", OPENVPN_SSTP_CONFIG, ScSetOpenVpnSstpConfig, InOpenVpnSstpConfig, OutOpenVpnSstpConfig)
1879 DECLARE_SC("GetOpenVpnSstpConfig", OPENVPN_SSTP_CONFIG, ScGetOpenVpnSstpConfig, InOpenVpnSstpConfig, OutOpenVpnSstpConfig)
1880 DECLARE_SC("GetDDnsClientStatus", DDNS_CLIENT_STATUS, ScGetDDnsClientStatus, InDDnsClientStatus, OutDDnsClientStatus)
1881 DECLARE_SC("ChangeDDnsClientHostname", RPC_TEST, ScChangeDDnsClientHostname, InRpcTest, OutRpcTest)
1882 DECLARE_SC("RegenerateServerCert", RPC_TEST, ScRegenerateServerCert, InRpcTest, OutRpcTest)
1883 DECLARE_SC_EX("MakeOpenVpnConfigFile", RPC_READ_LOG_FILE, ScMakeOpenVpnConfigFile, InRpcReadLogFile, OutRpcReadLogFile, FreeRpcReadLogFile)
1884 DECLARE_SC("SetSpecialListener", RPC_SPECIAL_LISTENER, ScSetSpecialListener, InRpcSpecialListener, OutRpcSpecialListener)
1885 DECLARE_SC("GetSpecialListener", RPC_SPECIAL_LISTENER, ScGetSpecialListener, InRpcSpecialListener, OutRpcSpecialListener)
1886 DECLARE_SC("GetAzureStatus", RPC_AZURE_STATUS, ScGetAzureStatus, InRpcAzureStatus, OutRpcAzureStatus)
1887 DECLARE_SC("SetAzureStatus", RPC_AZURE_STATUS, ScSetAzureStatus, InRpcAzureStatus, OutRpcAzureStatus)
1888 DECLARE_SC("GetDDnsInternetSettng", INTERNET_SETTING, ScGetDDnsInternetSetting, InRpcInternetSetting, OutRpcInternetSetting)
1889 DECLARE_SC("SetDDnsInternetSettng", INTERNET_SETTING, ScSetDDnsInternetSetting, InRpcInternetSetting, OutRpcInternetSetting)
1890 // RPC call function declaration: till here
1891
1892 // Setting VPN Gate Server Configuration
StSetVgsConfig(ADMIN * a,VGS_CONFIG * t)1893 UINT StSetVgsConfig(ADMIN *a, VGS_CONFIG *t)
1894 {
1895 return ERR_NOT_SUPPORTED;
1896 }
1897
1898 // Get VPN Gate configuration
StGetVgsConfig(ADMIN * a,VGS_CONFIG * t)1899 UINT StGetVgsConfig(ADMIN *a, VGS_CONFIG *t)
1900 {
1901 return ERR_NOT_SUPPORTED;
1902 }
1903
1904 // Get DDNS proxy configuration
StGetDDnsInternetSetting(ADMIN * a,INTERNET_SETTING * t)1905 UINT StGetDDnsInternetSetting(ADMIN *a, INTERNET_SETTING *t)
1906 {
1907 SERVER *s = a->Server;
1908 CEDAR *c = s->Cedar;
1909 UINT ret = ERR_NO_ERROR;
1910
1911 SERVER_ADMIN_ONLY;
1912 NO_SUPPORT_FOR_BRIDGE;
1913
1914 if (s->DDnsClient == NULL)
1915 {
1916 return ERR_NOT_SUPPORTED;
1917 }
1918
1919 Zero(t, sizeof(INTERNET_SETTING));
1920
1921 DCGetInternetSetting(s->DDnsClient, t);
1922
1923 return ret;
1924 }
1925
1926 // Set DDNS proxy configuration
StSetDDnsInternetSetting(ADMIN * a,INTERNET_SETTING * t)1927 UINT StSetDDnsInternetSetting(ADMIN *a, INTERNET_SETTING *t)
1928 {
1929 SERVER *s = a->Server;
1930 CEDAR *c = s->Cedar;
1931 UINT ret = ERR_NO_ERROR;
1932
1933 SERVER_ADMIN_ONLY;
1934 NO_SUPPORT_FOR_BRIDGE;
1935
1936 if (s->DDnsClient == NULL)
1937 {
1938 return ERR_NOT_SUPPORTED;
1939 }
1940
1941 DCSetInternetSetting(s->DDnsClient, t);
1942
1943 IncrementServerConfigRevision(s);
1944
1945 return ret;
1946 }
1947
1948 // Get Azure status
StGetAzureStatus(ADMIN * a,RPC_AZURE_STATUS * t)1949 UINT StGetAzureStatus(ADMIN *a, RPC_AZURE_STATUS *t)
1950 {
1951 SERVER *s = a->Server;
1952 CEDAR *c = s->Cedar;
1953 UINT ret = ERR_NO_ERROR;
1954 AZURE_CLIENT *ac;
1955
1956 SERVER_ADMIN_ONLY;
1957 NO_SUPPORT_FOR_BRIDGE;
1958
1959 if (SiIsAzureSupported(s) == false)
1960 {
1961 return ERR_NOT_SUPPORTED;
1962 }
1963
1964 ac = s->AzureClient;
1965 if (ac == NULL)
1966 {
1967 return ERR_NOT_SUPPORTED;
1968 }
1969
1970 Zero(t, sizeof(RPC_AZURE_STATUS));
1971
1972 Lock(ac->Lock);
1973 {
1974 t->IsConnected = ac->IsConnected;
1975 t->IsEnabled = ac->IsEnabled;
1976 }
1977 Unlock(ac->Lock);
1978
1979 return ERR_NO_ERROR;
1980 }
1981
1982 // Set Azure status
StSetAzureStatus(ADMIN * a,RPC_AZURE_STATUS * t)1983 UINT StSetAzureStatus(ADMIN *a, RPC_AZURE_STATUS *t)
1984 {
1985 SERVER *s = a->Server;
1986 CEDAR *c = s->Cedar;
1987 UINT ret = ERR_NO_ERROR;
1988
1989 SERVER_ADMIN_ONLY;
1990 NO_SUPPORT_FOR_BRIDGE;
1991
1992 if (SiIsAzureSupported(s) == false)
1993 {
1994 return ERR_NOT_SUPPORTED;
1995 }
1996
1997 SiSetAzureEnable(s, t->IsEnabled);
1998
1999 IncrementServerConfigRevision(s);
2000
2001 return ERR_NO_ERROR;
2002 }
2003
2004 // Get special listener status
StGetSpecialListener(ADMIN * a,RPC_SPECIAL_LISTENER * t)2005 UINT StGetSpecialListener(ADMIN *a, RPC_SPECIAL_LISTENER *t)
2006 {
2007 SERVER *s = a->Server;
2008 CEDAR *c = s->Cedar;
2009 UINT ret = ERR_NO_ERROR;
2010
2011 SERVER_ADMIN_ONLY;
2012 NO_SUPPORT_FOR_BRIDGE;
2013
2014 Zero(t, sizeof(RPC_SPECIAL_LISTENER));
2015 t->VpnOverDnsListener = s->EnableVpnOverDns;
2016 t->VpnOverIcmpListener = s->EnableVpnOverIcmp;
2017
2018 return ERR_NO_ERROR;
2019 }
2020
2021 // Set special listener status
StSetSpecialListener(ADMIN * a,RPC_SPECIAL_LISTENER * t)2022 UINT StSetSpecialListener(ADMIN *a, RPC_SPECIAL_LISTENER *t)
2023 {
2024 SERVER *s = a->Server;
2025 CEDAR *c = s->Cedar;
2026 UINT ret = ERR_NO_ERROR;
2027
2028 SERVER_ADMIN_ONLY;
2029 NO_SUPPORT_FOR_BRIDGE;
2030
2031 // Check ports
2032 if (t->VpnOverDnsListener && (MAKEBOOL(s->EnableVpnOverDns) != MAKEBOOL(t->VpnOverDnsListener)))
2033 {
2034 if (SiCanOpenVpnOverDnsPort() == false)
2035 {
2036 return ERR_SPECIAL_LISTENER_DNS_ERROR;
2037 }
2038 }
2039
2040 if (t->VpnOverIcmpListener && (MAKEBOOL(s->EnableVpnOverIcmp) != MAKEBOOL(t->VpnOverIcmpListener)))
2041 {
2042 if (SiCanOpenVpnOverIcmpPort() == false)
2043 {
2044 return ERR_SPECIAL_LISTENER_ICMP_ERROR;
2045 }
2046 }
2047
2048 s->EnableVpnOverDns = t->VpnOverDnsListener;
2049 s->EnableVpnOverIcmp = t->VpnOverIcmpListener;
2050
2051 SiApplySpecialListenerStatus(s);
2052
2053 ALog(a, NULL, "LA_SET_SPECIAL_LISTENER");
2054
2055 IncrementServerConfigRevision(s);
2056
2057 return ERR_NO_ERROR;
2058 }
2059
2060 // Set configurations for OpenVPN and SSTP
StSetOpenVpnSstpConfig(ADMIN * a,OPENVPN_SSTP_CONFIG * t)2061 UINT StSetOpenVpnSstpConfig(ADMIN *a, OPENVPN_SSTP_CONFIG *t)
2062 {
2063 SERVER *s = a->Server;
2064 CEDAR *c = s->Cedar;
2065 UINT ret = ERR_NO_ERROR;
2066
2067 SERVER_ADMIN_ONLY;
2068 NO_SUPPORT_FOR_BRIDGE;
2069 if (s->ServerType != SERVER_TYPE_STANDALONE)
2070 {
2071 return ERR_NOT_SUPPORTED;
2072 }
2073
2074 SiSetOpenVPNAndSSTPConfig(s, t);
2075
2076 ALog(a, NULL, "LA_SET_OVPN_SSTP_CONFIG");
2077
2078 IncrementServerConfigRevision(s);
2079
2080 return ERR_NO_ERROR;
2081 }
2082
2083 // Get configurations for OpenVPN and SSTP
StGetOpenVpnSstpConfig(ADMIN * a,OPENVPN_SSTP_CONFIG * t)2084 UINT StGetOpenVpnSstpConfig(ADMIN *a, OPENVPN_SSTP_CONFIG *t)
2085 {
2086 SERVER *s = a->Server;
2087 CEDAR *c = s->Cedar;
2088 UINT ret = ERR_NO_ERROR;
2089
2090 SERVER_ADMIN_ONLY;
2091 NO_SUPPORT_FOR_BRIDGE;
2092 if (s->ServerType != SERVER_TYPE_STANDALONE)
2093 {
2094 return ERR_NOT_SUPPORTED;
2095 }
2096
2097 Zero(t, sizeof(OPENVPN_SSTP_CONFIG));
2098 SiGetOpenVPNAndSSTPConfig(s, t);
2099
2100 return ERR_NO_ERROR;
2101 }
2102
2103 // Get status of DDNS client
StGetDDnsClientStatus(ADMIN * a,DDNS_CLIENT_STATUS * t)2104 UINT StGetDDnsClientStatus(ADMIN *a, DDNS_CLIENT_STATUS *t)
2105 {
2106 SERVER *s = a->Server;
2107 CEDAR *c = s->Cedar;
2108 UINT ret = ERR_NO_ERROR;
2109
2110 SERVER_ADMIN_ONLY;
2111 NO_SUPPORT_FOR_BRIDGE;
2112
2113 if (s->DDnsClient == NULL)
2114 {
2115 return ERR_NOT_SUPPORTED;
2116 }
2117
2118 Zero(t, sizeof(DDNS_CLIENT_STATUS));
2119 DCGetStatus(s->DDnsClient, t);
2120
2121 return ERR_NO_ERROR;
2122 }
2123
2124 // Change host-name for DDNS client
StChangeDDnsClientHostname(ADMIN * a,RPC_TEST * t)2125 UINT StChangeDDnsClientHostname(ADMIN *a, RPC_TEST *t)
2126 {
2127 SERVER *s = a->Server;
2128 CEDAR *c = s->Cedar;
2129 UINT ret = ERR_NO_ERROR;
2130
2131 SERVER_ADMIN_ONLY;
2132 NO_SUPPORT_FOR_BRIDGE;
2133
2134 if (s->DDnsClient == NULL)
2135 {
2136 return ERR_NOT_SUPPORTED;
2137 }
2138
2139 ret = DCChangeHostName(s->DDnsClient, t->StrValue);
2140
2141 if (ret == ERR_NO_ERROR)
2142 {
2143 ALog(a, NULL, "LA_DDNS_HOSTNAME_CHANGED", t->StrValue);
2144 }
2145
2146 IncrementServerConfigRevision(s);
2147
2148 return ret;
2149 }
2150
2151 // Regenerate server certification
StRegenerateServerCert(ADMIN * a,RPC_TEST * t)2152 UINT StRegenerateServerCert(ADMIN *a, RPC_TEST *t)
2153 {
2154 SERVER *s = a->Server;
2155 CEDAR *c = s->Cedar;
2156 UINT ret = ERR_NO_ERROR;
2157 X *x;
2158 K *k;
2159
2160 SERVER_ADMIN_ONLY;
2161
2162 SiGenerateDefaultCertEx(&x, &k, t->StrValue);
2163
2164 SetCedarCert(c, x, k);
2165
2166 ALog(a, NULL, "LA_REGENERATE_SERVER_CERT", t->StrValue);
2167
2168 IncrementServerConfigRevision(s);
2169
2170 FreeX(x);
2171 FreeK(k);
2172
2173 return ERR_NO_ERROR;
2174 }
2175
2176 // Generate OpenVPN configuration files
StMakeOpenVpnConfigFile(ADMIN * a,RPC_READ_LOG_FILE * t)2177 UINT StMakeOpenVpnConfigFile(ADMIN *a, RPC_READ_LOG_FILE *t)
2178 {
2179 SERVER *s = a->Server;
2180 CEDAR *c = s->Cedar;
2181 UINT ret = ERR_NO_ERROR;
2182 ZIP_PACKER *p;
2183 FIFO *f;
2184 BUF *readme_buf;
2185 BUF *readme_pdf_buf;
2186 BUF *sample_buf;
2187 OPENVPN_SSTP_CONFIG config;
2188 LIST *port_list;
2189 char my_hostname[MAX_SIZE];
2190
2191 SERVER_ADMIN_ONLY;
2192 NO_SUPPORT_FOR_BRIDGE;
2193 if (s->ServerType != SERVER_TYPE_STANDALONE)
2194 {
2195 return ERR_NOT_SUPPORTED;
2196 }
2197
2198 SiGetOpenVPNAndSSTPConfig(s, &config);
2199
2200 if (config.EnableOpenVPN == false)
2201 {
2202 return ERR_OPENVPN_IS_NOT_ENABLED;
2203 }
2204
2205 port_list = StrToIntList(config.OpenVPNPortList, true);
2206
2207 FreeRpcReadLogFile(t);
2208 Zero(t, sizeof(RPC_READ_LOG_FILE));
2209
2210 p = NewZipPacker();
2211
2212 // readme.txt
2213 readme_buf = ReadDump("|openvpn_readme.txt");
2214
2215 // readme.pdf
2216 readme_pdf_buf = ReadDump("|openvpn_readme.pdf");
2217
2218 // sample.ovpn
2219 sample_buf = ReadDump("|openvpn_sample.ovpn");
2220
2221 // host name
2222 GetMachineHostName(my_hostname, sizeof(my_hostname));
2223 my_hostname[16] = 0;
2224
2225 if (readme_buf == NULL || sample_buf == NULL || readme_pdf_buf == NULL)
2226 {
2227 ret = ERR_INTERNAL_ERROR;
2228 }
2229 else
2230 {
2231 BUF *config_l3_buf, *config_l2_buf;
2232 X *x = NULL;
2233 BUF *x_buf;
2234 char protocol[MAX_SIZE];
2235 UINT port = OPENVPN_UDP_PORT;
2236 char port_str[MAX_SIZE];
2237 char hostname[MAX_SIZE];
2238 char tag_before_hostname[MAX_SIZE];
2239 DDNS_CLIENT_STATUS ddns;
2240 UCHAR *zero_buffer;
2241 UINT zero_buffer_size = 128 * 1024;
2242 char name_tmp[MAX_SIZE];
2243
2244 zero_buffer = ZeroMalloc(zero_buffer_size);
2245
2246
2247 if (x == NULL)
2248 {
2249 Lock(c->lock);
2250 {
2251 x = CloneX(c->ServerX);
2252 }
2253 Unlock(c->lock);
2254
2255 if (x != NULL)
2256 {
2257 // Get the root certificate
2258 if (x->root_cert == false)
2259 {
2260 X *root_x = NULL;
2261 LIST *cert_list = NewCertList(true);
2262
2263 if (TryGetRootCertChain(cert_list, x, true, &root_x))
2264 {
2265 FreeX(x);
2266 x = root_x;
2267 }
2268
2269 FreeCertList(cert_list);
2270 }
2271 }
2272 }
2273
2274 x_buf = XToBuf(x, true);
2275
2276 SeekBufToEnd(x_buf);
2277 WriteBufChar(x_buf, 0);
2278 SeekBufToBegin(x_buf);
2279
2280 FreeX(x);
2281 Zero(hostname, sizeof(hostname));
2282 Zero(tag_before_hostname, sizeof(tag_before_hostname));
2283
2284 Zero(&ddns, sizeof(ddns));
2285 if (s->DDnsClient != NULL)
2286 {
2287 DCGetStatus(s->DDnsClient, &ddns);
2288
2289 if (IsEmptyStr(ddns.CurrentHostName) == false && IsEmptyStr(ddns.DnsSuffix) == false &&
2290 ddns.Err_IPv4 == ERR_NO_ERROR)
2291 {
2292 StrCpy(tag_before_hostname, sizeof(tag_before_hostname),
2293 "# Note: The below hostname is came from the Dynamic DNS Client function\r\n"
2294 "# which is running on the VPN Server. If you don't want to use\r\n"
2295 "# the Dynamic DNS hostname, replace it to either IP address or\r\n"
2296 "# other domain's hostname.\r\n\r\n");
2297
2298 Format(hostname, sizeof(hostname), "%s.v4%s", ddns.CurrentHostName, ddns.DnsSuffix);
2299 }
2300 }
2301
2302 if (IsEmptyStr(hostname))
2303 {
2304 IP myip;
2305
2306 Zero(&myip, sizeof(myip));
2307 GetCurrentGlobalIP(&myip, false);
2308
2309 if (IsZeroIP(&myip))
2310 {
2311 GetCurrentGlobalIPGuess(&myip, false);
2312 }
2313
2314 IPToStr(hostname, sizeof(hostname), &myip);
2315 }
2316
2317 SeekBuf(sample_buf, sample_buf->Size, 0);
2318 WriteBuf(sample_buf, zero_buffer, zero_buffer_size);
2319
2320 config_l3_buf = CloneBuf(sample_buf);
2321 config_l2_buf = CloneBuf(sample_buf);
2322
2323 // Generate contents of configuration
2324 if (LIST_NUM(port_list) >= 1)
2325 {
2326 StrCpy(protocol, sizeof(protocol), "udp");
2327
2328 if (IsIntInList(port_list, OPENVPN_UDP_PORT))
2329 {
2330 port = OPENVPN_UDP_PORT;
2331 }
2332 else
2333 {
2334 port = *((UINT *)(LIST_DATA(port_list, 0)));
2335 }
2336 }
2337 else
2338 {
2339 RPC_LISTENER_LIST tt;
2340 UINT i;
2341
2342 port = 0;
2343
2344 StrCpy(protocol, sizeof(protocol), "tcp");
2345
2346 Zero(&tt, sizeof(tt));
2347
2348 StEnumListener(a, &tt);
2349
2350 for (i = 0;i < tt.NumPort;i++)
2351 {
2352 if (tt.Enables[i] && tt.Errors[i] == false)
2353 {
2354 port = tt.Ports[i];
2355 break;
2356 }
2357 }
2358
2359 FreeRpcListenerList(&tt);
2360
2361 if (port == 0)
2362 {
2363 StrCpy(protocol, sizeof(protocol), "udp");
2364 port = OPENVPN_UDP_PORT;
2365 }
2366 }
2367
2368 ToStr(port_str, port);
2369
2370 if (IsEmptyStr(my_hostname) == false)
2371 {
2372 StrCat(my_hostname, sizeof(my_hostname), "_");
2373
2374 StrLower(my_hostname);
2375 }
2376
2377 ZipAddFileSimple(p, "readme.txt", LocalTime64(), 0, readme_buf->Buf, readme_buf->Size);
2378 ZipAddFileSimple(p, "readme.pdf", LocalTime64(), 0, readme_pdf_buf->Buf, readme_pdf_buf->Size);
2379
2380 ReplaceStrEx((char *)config_l3_buf->Buf, config_l3_buf->Size, (char *)config_l3_buf->Buf,
2381 "$TAG_TUN_TAP$", "tun", false);
2382 ReplaceStrEx((char *)config_l3_buf->Buf, config_l3_buf->Size, (char *)config_l3_buf->Buf,
2383 "$TAG_PROTO$", protocol, false);
2384 ReplaceStrEx((char *)config_l3_buf->Buf, config_l3_buf->Size, (char *)config_l3_buf->Buf,
2385 "$TAG_HOSTNAME$", hostname, false);
2386 ReplaceStrEx((char *)config_l3_buf->Buf, config_l3_buf->Size, (char *)config_l3_buf->Buf,
2387 "$TAG_BEFORE_REMOTE$", tag_before_hostname, false);
2388 ReplaceStrEx((char *)config_l3_buf->Buf, config_l3_buf->Size, (char *)config_l3_buf->Buf,
2389 "$TAG_PORT$", port_str, false);
2390
2391 if (x_buf != NULL)
2392 {
2393 ReplaceStrEx((char *)config_l3_buf->Buf, config_l3_buf->Size, (char *)config_l3_buf->Buf,
2394 "$CA$", x_buf->Buf, false);
2395 }
2396
2397 Format(name_tmp, sizeof(name_tmp), "%sopenvpn_remote_access_l3.ovpn", my_hostname);
2398 ZipAddFileSimple(p, name_tmp, LocalTime64(), 0, config_l3_buf->Buf, StrLen(config_l3_buf->Buf));
2399
2400 ReplaceStrEx((char *)config_l2_buf->Buf, config_l2_buf->Size, (char *)config_l2_buf->Buf,
2401 "$TAG_TUN_TAP$", "tap", false);
2402 ReplaceStrEx((char *)config_l2_buf->Buf, config_l2_buf->Size, (char *)config_l2_buf->Buf,
2403 "$TAG_PROTO$", protocol, false);
2404 ReplaceStrEx((char *)config_l2_buf->Buf, config_l2_buf->Size, (char *)config_l2_buf->Buf,
2405 "$TAG_HOSTNAME$", hostname, false);
2406 ReplaceStrEx((char *)config_l2_buf->Buf, config_l2_buf->Size, (char *)config_l2_buf->Buf,
2407 "$TAG_BEFORE_REMOTE$", tag_before_hostname, false);
2408 ReplaceStrEx((char *)config_l2_buf->Buf, config_l2_buf->Size, (char *)config_l2_buf->Buf,
2409 "$TAG_PORT$", port_str, false);
2410
2411 if (x_buf != NULL)
2412 {
2413 ReplaceStrEx((char *)config_l2_buf->Buf, config_l2_buf->Size, (char *)config_l2_buf->Buf,
2414 "$CA$", x_buf->Buf, false);
2415 }
2416
2417 Format(name_tmp, sizeof(name_tmp), "%sopenvpn_site_to_site_bridge_l2.ovpn", my_hostname);
2418 ZipAddFileSimple(p, name_tmp, LocalTime64(), 0, config_l2_buf->Buf, StrLen(config_l2_buf->Buf));
2419
2420 FreeBuf(config_l3_buf);
2421 FreeBuf(config_l2_buf);
2422
2423 f = ZipFinish(p);
2424
2425 if (f != NULL)
2426 {
2427 t->Buffer = NewBuf();
2428 WriteBuf(t->Buffer, FifoPtr(f), FifoSize(f));
2429 SeekBuf(t->Buffer, 0, 0);
2430 }
2431
2432 FreeBuf(readme_buf);
2433 FreeBuf(sample_buf);
2434 FreeBuf(readme_pdf_buf);
2435 FreeBuf(x_buf);
2436
2437 Free(zero_buffer);
2438 }
2439
2440 FreeStrList(port_list);
2441
2442 FreeZipPacker(p);
2443
2444 return ERR_NO_ERROR;
2445 }
2446
2447 // Set IPsec service configuration
StSetIPsecServices(ADMIN * a,IPSEC_SERVICES * t)2448 UINT StSetIPsecServices(ADMIN *a, IPSEC_SERVICES *t)
2449 {
2450 SERVER *s = a->Server;
2451 CEDAR *c = s->Cedar;
2452 UINT ret = ERR_NO_ERROR;
2453
2454 SERVER_ADMIN_ONLY;
2455 NO_SUPPORT_FOR_BRIDGE;
2456 if (GetServerCapsBool(s, "b_support_ipsec") == false || s->IPsecServer == NULL)
2457 {
2458 return ERR_NOT_SUPPORTED;
2459 }
2460
2461 IPsecServerSetServices(s->IPsecServer, t);
2462
2463 ALog(a, NULL, "LA_SET_IPSEC_CONFIG");
2464
2465 IncrementServerConfigRevision(s);
2466
2467 return ERR_NO_ERROR;
2468 }
2469
2470 // Get IPsec service configuration
StGetIPsecServices(ADMIN * a,IPSEC_SERVICES * t)2471 UINT StGetIPsecServices(ADMIN *a, IPSEC_SERVICES *t)
2472 {
2473 SERVER *s = a->Server;
2474 CEDAR *c = s->Cedar;
2475 UINT ret = ERR_NO_ERROR;
2476
2477 SERVER_ADMIN_ONLY;
2478 NO_SUPPORT_FOR_BRIDGE;
2479 if (GetServerCapsBool(s, "b_support_ipsec") == false || s->IPsecServer == NULL)
2480 {
2481 return ERR_NOT_SUPPORTED;
2482 }
2483
2484 Zero(t, sizeof(IPSEC_SERVICES));
2485 IPsecServerGetServices(s->IPsecServer, t);
2486
2487 return ERR_NO_ERROR;
2488 }
2489
2490 // Add EtherIP ID setting
StAddEtherIpId(ADMIN * a,ETHERIP_ID * t)2491 UINT StAddEtherIpId(ADMIN *a, ETHERIP_ID *t)
2492 {
2493 SERVER *s = a->Server;
2494 CEDAR *c = s->Cedar;
2495 UINT ret = ERR_NO_ERROR;
2496
2497 SERVER_ADMIN_ONLY;
2498 NO_SUPPORT_FOR_BRIDGE;
2499 if (GetServerCapsBool(s, "b_support_ipsec") == false || s->IPsecServer == NULL)
2500 {
2501 return ERR_NOT_SUPPORTED;
2502 }
2503
2504 AddEtherIPId(s->IPsecServer, t);
2505
2506 ALog(a, NULL, "LA_ADD_ETHERIP_ID", t->Id);
2507
2508 IncrementServerConfigRevision(s);
2509
2510 return ERR_NO_ERROR;
2511 }
2512
2513 // Get EtherIP ID setting
StGetEtherIpId(ADMIN * a,ETHERIP_ID * t)2514 UINT StGetEtherIpId(ADMIN *a, ETHERIP_ID *t)
2515 {
2516 SERVER *s = a->Server;
2517 CEDAR *c = s->Cedar;
2518 UINT ret = ERR_NO_ERROR;
2519 char id[MAX_SIZE];
2520
2521 SERVER_ADMIN_ONLY;
2522 NO_SUPPORT_FOR_BRIDGE;
2523 if (GetServerCapsBool(s, "b_support_ipsec") == false || s->IPsecServer == NULL)
2524 {
2525 return ERR_NOT_SUPPORTED;
2526 }
2527
2528 StrCpy(id, sizeof(id), t->Id);
2529
2530 Zero(t, sizeof(ETHERIP_ID));
2531 if (SearchEtherIPId(s->IPsecServer, t, id) == false)
2532 {
2533 return ERR_OBJECT_NOT_FOUND;
2534 }
2535
2536 return ERR_NO_ERROR;
2537 }
2538
2539 // Delete EtherIP ID setting
StDeleteEtherIpId(ADMIN * a,ETHERIP_ID * t)2540 UINT StDeleteEtherIpId(ADMIN *a, ETHERIP_ID *t)
2541 {
2542 SERVER *s = a->Server;
2543 CEDAR *c = s->Cedar;
2544 UINT ret = ERR_NO_ERROR;
2545 char id[MAX_SIZE];
2546
2547 SERVER_ADMIN_ONLY;
2548 NO_SUPPORT_FOR_BRIDGE;
2549 if (GetServerCapsBool(s, "b_support_ipsec") == false || s->IPsecServer == NULL)
2550 {
2551 return ERR_NOT_SUPPORTED;
2552 }
2553
2554 StrCpy(id, sizeof(id), t->Id);
2555
2556 if (DeleteEtherIPId(s->IPsecServer, id) == false)
2557 {
2558 return ERR_OBJECT_NOT_FOUND;
2559 }
2560
2561 ALog(a, NULL, "LA_DEL_ETHERIP_ID", id);
2562
2563 IncrementServerConfigRevision(s);
2564
2565 return ERR_NO_ERROR;
2566 }
2567
2568 // Enumerate EtherIP ID settings
StEnumEtherIpId(ADMIN * a,RPC_ENUM_ETHERIP_ID * t)2569 UINT StEnumEtherIpId(ADMIN *a, RPC_ENUM_ETHERIP_ID *t)
2570 {
2571 SERVER *s = a->Server;
2572 CEDAR *c = s->Cedar;
2573 UINT ret = ERR_NO_ERROR;
2574 SERVER_ADMIN_ONLY;
2575 NO_SUPPORT_FOR_BRIDGE;
2576 if (GetServerCapsBool(s, "b_support_ipsec") == false || s->IPsecServer == NULL)
2577 {
2578 return ERR_NOT_SUPPORTED;
2579 }
2580
2581 FreeRpcEnumEtherIpId(t);
2582 Zero(t, sizeof(RPC_ENUM_ETHERIP_ID));
2583
2584 Lock(s->IPsecServer->LockSettings);
2585 {
2586 UINT i;
2587 UINT num;
2588
2589 num = LIST_NUM(s->IPsecServer->EtherIPIdList);
2590
2591 t->NumItem = num;
2592 t->IdList = ZeroMalloc(sizeof(ETHERIP_ID) * num);
2593
2594 for (i = 0;i < num;i++)
2595 {
2596 ETHERIP_ID *d = &t->IdList[i];
2597 ETHERIP_ID *src = LIST_DATA(s->IPsecServer->EtherIPIdList, i);
2598
2599 Copy(d, src, sizeof(ETHERIP_ID));
2600 }
2601 }
2602 Unlock(s->IPsecServer->LockSettings);
2603
2604 return ERR_NO_ERROR;
2605 }
2606
2607 // Set message of today on hub
StSetHubMsg(ADMIN * a,RPC_MSG * t)2608 UINT StSetHubMsg(ADMIN *a, RPC_MSG *t)
2609 {
2610 SERVER *s = a->Server;
2611 CEDAR *c = s->Cedar;
2612 HUB *h;
2613 UINT ret = ERR_NO_ERROR;
2614 char hubname[MAX_HUBNAME_LEN + 1];
2615
2616 CHECK_RIGHT;
2617 NO_SUPPORT_FOR_BRIDGE;
2618 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
2619 {
2620 return ERR_NOT_SUPPORTED;
2621 }
2622 if (UniStrLen(t->Msg) > HUB_MAXMSG_LEN)
2623 {
2624 return ERR_MEMORY_NOT_ENOUGH;
2625 }
2626
2627 StrCpy(hubname, sizeof(hubname), t->HubName);
2628
2629 h = GetHub(c, hubname);
2630
2631 if (h == NULL)
2632 {
2633 ret = ERR_HUB_NOT_FOUND;
2634 }
2635 else
2636 {
2637 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_msg") != 0)
2638 {
2639 ret = ERR_NOT_ENOUGH_RIGHT;
2640 }
2641 else
2642 {
2643 SetHubMsg(h, t->Msg);
2644 }
2645
2646 ReleaseHub(h);
2647 }
2648
2649 IncrementServerConfigRevision(s);
2650
2651 return ret;
2652 }
2653
2654 // Get message of today on hub
StGetHubMsg(ADMIN * a,RPC_MSG * t)2655 UINT StGetHubMsg(ADMIN *a, RPC_MSG *t)
2656 {
2657 SERVER *s = a->Server;
2658 CEDAR *c = s->Cedar;
2659 HUB *h;
2660 UINT ret = ERR_NO_ERROR;
2661 char hubname[MAX_HUBNAME_LEN + 1];
2662
2663 CHECK_RIGHT;
2664 NO_SUPPORT_FOR_BRIDGE;
2665 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
2666 {
2667 return ERR_NOT_SUPPORTED;
2668 }
2669 if (UniStrLen(t->Msg) > HUB_MAXMSG_LEN)
2670 {
2671 return ERR_MEMORY_NOT_ENOUGH;
2672 }
2673
2674 StrCpy(hubname, sizeof(hubname), t->HubName);
2675
2676 h = GetHub(c, hubname);
2677
2678 if (h == NULL)
2679 {
2680 ret = ERR_HUB_NOT_FOUND;
2681 }
2682 else
2683 {
2684 FreeRpcMsg(t);
2685 Zero(t, sizeof(RPC_MSG));
2686
2687 t->Msg = GetHubMsg(h);
2688
2689 ReleaseHub(h);
2690 }
2691
2692 return ret;
2693 }
2694
2695 // Do debug function
StDebug(ADMIN * a,RPC_TEST * t)2696 UINT StDebug(ADMIN *a, RPC_TEST *t)
2697 {
2698 SERVER *s = a->Server;
2699 CEDAR *c = s->Cedar;
2700 UINT ret = ERR_NO_ERROR;
2701 RPC_TEST t2;
2702
2703 SERVER_ADMIN_ONLY;
2704
2705 Zero(&t2, sizeof(t2));
2706
2707 ret = SiDebug(s, &t2, t->IntValue, t->StrValue);
2708
2709 if (ret == ERR_NO_ERROR)
2710 {
2711 Copy(t, &t2, sizeof(RPC_TEST));
2712 }
2713 else
2714 {
2715 Zero(t, sizeof(RPC_TEST));
2716 }
2717
2718 return ret;
2719 }
2720
2721 // Flush configuration file
StFlush(ADMIN * a,RPC_TEST * t)2722 UINT StFlush(ADMIN *a, RPC_TEST *t)
2723 {
2724 SERVER *s = a->Server;
2725 CEDAR *c = s->Cedar;
2726 UINT ret = ERR_NO_ERROR;
2727 UINT size;
2728
2729 SERVER_ADMIN_ONLY;
2730
2731 size = SiWriteConfigurationFile(s);
2732
2733 t->IntValue = size;
2734
2735 return ERR_NO_ERROR;
2736 }
2737
2738 // Do Crash
StCrash(ADMIN * a,RPC_TEST * t)2739 UINT StCrash(ADMIN *a, RPC_TEST *t)
2740 {
2741 SERVER *s = a->Server;
2742 CEDAR *c = s->Cedar;
2743 UINT ret = ERR_NO_ERROR;
2744
2745 SERVER_ADMIN_ONLY;
2746
2747 #ifdef OS_WIN32
2748 MsSetEnableMinidump(false);
2749 #endif // OS_WIN32
2750
2751 CrashNow();
2752
2753 return ERR_NO_ERROR;
2754 }
2755
2756 // Get message for administrators
StGetAdminMsg(ADMIN * a,RPC_MSG * t)2757 UINT StGetAdminMsg(ADMIN *a, RPC_MSG *t)
2758 {
2759 SERVER *s = a->Server;
2760 CEDAR *c = s->Cedar;
2761 UINT ret = ERR_NO_ERROR;
2762 RPC_WINVER server_ver;
2763 RPC_WINVER client_ver;
2764 wchar_t winver_msg_client[3800];
2765 wchar_t winver_msg_server[3800];
2766 UINT tmpsize;
2767 wchar_t *tmp;
2768
2769 FreeRpcMsg(t);
2770 Zero(t, sizeof(RPC_MSG));
2771
2772 // Check for Windows version
2773 GetWinVer(&server_ver);
2774 Copy(&client_ver, &a->ClientWinVer, sizeof(RPC_WINVER));
2775
2776 Zero(winver_msg_client, sizeof(winver_msg_client));
2777 Zero(winver_msg_server, sizeof(winver_msg_server));
2778
2779 if (IsSupportedWinVer(&client_ver) == false)
2780 {
2781 SYSTEMTIME st;
2782
2783 LocalTime(&st);
2784
2785 UniFormat(winver_msg_client, sizeof(winver_msg_client), _UU("WINVER_ERROR_FORMAT"),
2786 _UU("WINVER_ERROR_PC_LOCAL"),
2787 client_ver.Title,
2788 _UU("WINVER_ERROR_VPNSERVER"),
2789 SUPPORTED_WINDOWS_LIST,
2790 _UU("WINVER_ERROR_PC_LOCAL"),
2791 _UU("WINVER_ERROR_VPNSERVER"),
2792 _UU("WINVER_ERROR_VPNSERVER"),
2793 _UU("WINVER_ERROR_VPNSERVER"),
2794 st.wYear, st.wMonth);
2795 }
2796
2797 if (IsSupportedWinVer(&server_ver) == false)
2798 {
2799 SYSTEMTIME st;
2800
2801 LocalTime(&st);
2802
2803 UniFormat(winver_msg_server, sizeof(winver_msg_server), _UU("WINVER_ERROR_FORMAT"),
2804 _UU("WINVER_ERROR_PC_REMOTE"),
2805 server_ver.Title,
2806 _UU("WINVER_ERROR_VPNSERVER"),
2807 SUPPORTED_WINDOWS_LIST,
2808 _UU("WINVER_ERROR_PC_REMOTE"),
2809 _UU("WINVER_ERROR_VPNSERVER"),
2810 _UU("WINVER_ERROR_VPNSERVER"),
2811 _UU("WINVER_ERROR_VPNSERVER"),
2812 st.wYear, st.wMonth);
2813 }
2814
2815 tmpsize = UniStrSize(winver_msg_client) + UniStrSize(winver_msg_server) + 10000;
2816
2817 tmp = ZeroMalloc(tmpsize);
2818
2819 if (
2820 c->Bridge == false)
2821 {
2822 if (GetGlobalServerFlag(GSF_SHOW_OSS_MSG) != 0)
2823 {
2824 UniStrCat(tmp, tmpsize, _UU("OSS_MSG"));
2825 }
2826 }
2827
2828 UniStrCat(tmp, tmpsize, winver_msg_client);
2829 UniStrCat(tmp, tmpsize, winver_msg_server);
2830
2831 t->Msg = tmp;
2832
2833 return ERR_NO_ERROR;
2834 }
2835
2836 // Enumerate VLAN tag transparent setting
StEnumEthVLan(ADMIN * a,RPC_ENUM_ETH_VLAN * t)2837 UINT StEnumEthVLan(ADMIN *a, RPC_ENUM_ETH_VLAN *t)
2838 {
2839 SERVER *s = a->Server;
2840 CEDAR *c = s->Cedar;
2841 UINT ret = ERR_NO_ERROR;
2842
2843 SERVER_ADMIN_ONLY;
2844
2845 #ifdef OS_WIN32
2846 if (GetServerCapsBool(s, "b_support_eth_vlan") == false)
2847 {
2848 ret = ERR_NOT_SUPPORTED;
2849 }
2850 else
2851 {
2852 FreeRpcEnumEthVLan(t);
2853 Zero(t, sizeof(RPC_ENUM_ETH_VLAN));
2854
2855 if (EnumEthVLanWin32(t) == false)
2856 {
2857 ret = ERR_INTERNAL_ERROR;
2858 }
2859 }
2860 #else // OS_WIN32
2861 ret = ERR_NOT_SUPPORTED;
2862 #endif // OS_WIN32
2863
2864 return ret;
2865 }
2866
2867 // Set VLAN tag transparent setting
StSetEnableEthVLan(ADMIN * a,RPC_TEST * t)2868 UINT StSetEnableEthVLan(ADMIN *a, RPC_TEST *t)
2869 {
2870 SERVER *s = a->Server;
2871 CEDAR *c = s->Cedar;
2872 UINT ret = ERR_NO_ERROR;
2873
2874 SERVER_ADMIN_ONLY;
2875
2876 #ifdef OS_WIN32
2877 if (GetServerCapsBool(s, "b_support_eth_vlan") == false)
2878 {
2879 ret = ERR_NOT_SUPPORTED;
2880 }
2881 else if (MsIsAdmin() == false)
2882 {
2883 ret = ERR_NOT_ENOUGH_RIGHT;
2884 }
2885 else
2886 {
2887 if (SetVLanEnableStatus(t->StrValue, MAKEBOOL(t->IntValue)) == false)
2888 {
2889 ret = ERR_INTERNAL_ERROR;
2890 }
2891 }
2892 #else // OS_WIN32
2893 ret = ERR_NOT_SUPPORTED;
2894 #endif // OS_WIN32
2895
2896 return ret;
2897 }
2898
2899 // Get license status
StGetLicenseStatus(ADMIN * a,RPC_LICENSE_STATUS * t)2900 UINT StGetLicenseStatus(ADMIN *a, RPC_LICENSE_STATUS *t)
2901 {
2902 return ERR_NOT_SUPPORTED;
2903 }
2904
2905 // Enumerate license key
StEnumLicenseKey(ADMIN * a,RPC_ENUM_LICENSE_KEY * t)2906 UINT StEnumLicenseKey(ADMIN *a, RPC_ENUM_LICENSE_KEY *t)
2907 {
2908 return ERR_NOT_SUPPORTED;
2909 }
2910
2911 // Add new license key
StAddLicenseKey(ADMIN * a,RPC_TEST * t)2912 UINT StAddLicenseKey(ADMIN *a, RPC_TEST *t)
2913 {
2914 return ERR_NOT_SUPPORTED;
2915 }
2916
2917 // Delete a license key
StDelLicenseKey(ADMIN * a,RPC_TEST * t)2918 UINT StDelLicenseKey(ADMIN *a, RPC_TEST *t)
2919 {
2920 return ERR_NOT_SUPPORTED;
2921 }
2922
2923 // Download a log file
DownloadFileFromServer(RPC * r,char * server_name,char * filepath,UINT total_size,DOWNLOAD_PROC * proc,void * param)2924 BUF *DownloadFileFromServer(RPC *r, char *server_name, char *filepath, UINT total_size, DOWNLOAD_PROC *proc, void *param)
2925 {
2926 UINT offset;
2927 BUF *buf;
2928 // Validate arguments
2929 if (r == NULL || filepath == NULL)
2930 {
2931 return NULL;
2932 }
2933
2934 if (server_name == NULL)
2935 {
2936 server_name = "";
2937 }
2938
2939 offset = 0;
2940
2941 buf = NewBuf();
2942
2943 while (true)
2944 {
2945 DOWNLOAD_PROGRESS g;
2946 RPC_READ_LOG_FILE t;
2947 UINT ret;
2948
2949 Zero(&t, sizeof(t));
2950 StrCpy(t.FilePath, sizeof(t.FilePath), filepath);
2951 t.Offset = offset;
2952 StrCpy(t.ServerName, sizeof(t.ServerName), server_name);
2953
2954 ret = ScReadLogFile(r, &t);
2955
2956 if (ret != ERR_NO_ERROR)
2957 {
2958 // Failed
2959 FreeRpcReadLogFile(&t);
2960 FreeBuf(buf);
2961 return NULL;
2962 }
2963
2964 if (t.Buffer == NULL)
2965 {
2966 // read to the end
2967 break;
2968 }
2969
2970 // Update current progress
2971 offset += t.Buffer->Size;
2972 Zero(&g, sizeof(g));
2973 g.Param = param;
2974 g.CurrentSize = offset;
2975 g.TotalSize = MAX(total_size, offset);
2976 g.ProgressPercent = (UINT)(MAKESURE((UINT64)g.CurrentSize * 100ULL / (UINT64)(MAX(g.TotalSize, 1)), 0, 100ULL));
2977
2978 WriteBuf(buf, t.Buffer->Buf, t.Buffer->Size);
2979
2980 FreeRpcReadLogFile(&t);
2981
2982 if (proc != NULL)
2983 {
2984 if (proc(&g) == false)
2985 {
2986 // Canceled by user
2987 FreeBuf(buf);
2988 return NULL;
2989 }
2990 }
2991 }
2992
2993 if (buf->Size == 0)
2994 {
2995 // Downloading failed
2996 FreeBuf(buf);
2997 return NULL;
2998 }
2999
3000 return buf;
3001 }
3002
3003 // Read a log file
StReadLogFile(ADMIN * a,RPC_READ_LOG_FILE * t)3004 UINT StReadLogFile(ADMIN *a, RPC_READ_LOG_FILE *t)
3005 {
3006 SERVER *s = a->Server;
3007 CEDAR *c = s->Cedar;
3008 char logfilename[MAX_PATH];
3009 char servername[MAX_HOST_NAME_LEN + 1];
3010 UINT offset;
3011 bool local = true;
3012
3013 if (IsEmptyStr(t->FilePath))
3014 {
3015 return ERR_INVALID_PARAMETER;
3016 }
3017
3018 StrCpy(logfilename, sizeof(logfilename), t->FilePath);
3019 StrCpy(servername, sizeof(servername), t->ServerName);
3020 offset = t->Offset;
3021
3022 if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER)
3023 {
3024 GetMachineName(servername, sizeof(servername));
3025 }
3026
3027 // Check the permission to read the log file
3028 if (a->LogFileList == NULL)
3029 {
3030 // Enum the log files first
3031 RPC_ENUM_LOG_FILE elf;
3032 UINT elf_ret;
3033
3034 Zero(&elf, sizeof(elf));
3035
3036 elf_ret = StEnumLogFile(a, &elf);
3037
3038 FreeRpcEnumLogFile(&elf);
3039
3040 if (elf_ret != ERR_NO_ERROR)
3041 {
3042 return elf_ret;
3043 }
3044 }
3045 if (CheckLogFileNameFromEnumList(a->LogFileList, logfilename, servername) == false)
3046 {
3047 // There is no such file in the log file list
3048 return ERR_OBJECT_NOT_FOUND;
3049 }
3050
3051 FreeRpcReadLogFile(t);
3052 Zero(t, sizeof(RPC_READ_LOG_FILE));
3053
3054 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
3055 {
3056 UINT i;
3057
3058 // When the host name in request is a cluster member, redirect the request
3059 LockList(s->FarmMemberList);
3060 {
3061 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
3062 {
3063 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
3064
3065 if (f->Me == false)
3066 {
3067 if (StrCmpi(f->hostname, servername) == 0)
3068 {
3069 RPC_READ_LOG_FILE tt;
3070
3071 Zero(&tt, sizeof(tt));
3072 local = false;
3073
3074 StrCpy(tt.ServerName, sizeof(tt.ServerName), servername);
3075 StrCpy(tt.FilePath, sizeof(tt.FilePath), logfilename);
3076 tt.Offset = offset;
3077
3078 if (SiCallReadLogFile(s, f, &tt))
3079 {
3080 if (tt.Buffer != NULL && tt.Buffer->Size > 0)
3081 {
3082 t->Buffer = NewBuf();
3083 WriteBuf(t->Buffer, tt.Buffer->Buf, tt.Buffer->Size);
3084 }
3085 }
3086
3087 FreeRpcReadLogFile(&tt);
3088
3089 break;
3090 }
3091 }
3092 }
3093 }
3094 UnlockList(s->FarmMemberList);
3095 }
3096
3097 // Read a local file
3098 if (local)
3099 {
3100 SiReadLocalLogFile(s, logfilename, offset, t);
3101 }
3102
3103 if (offset == 0)
3104 {
3105 ALog(a, NULL, "LA_READ_LOG_FILE", servername, logfilename);
3106 }
3107
3108 StrCpy(t->FilePath, sizeof(t->FilePath), logfilename);
3109 StrCpy(t->ServerName, sizeof(t->ServerName), servername);
3110 t->Offset = offset;
3111
3112 return ERR_NO_ERROR;
3113 }
3114
3115 // Enumerate log files
StEnumLogFile(ADMIN * a,RPC_ENUM_LOG_FILE * t)3116 UINT StEnumLogFile(ADMIN *a, RPC_ENUM_LOG_FILE *t)
3117 {
3118 SERVER *s = a->Server;
3119 CEDAR *c = s->Cedar;
3120 UINT i;
3121 bool no_access = false;
3122
3123 HUB *h;
3124
3125 if (a->ServerAdmin == false)
3126 {
3127 h = GetHub(c, a->HubName);
3128
3129 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_read_log_file") != 0)
3130 {
3131 no_access = true;
3132 }
3133
3134 ReleaseHub(h);
3135 }
3136
3137 if (no_access)
3138 {
3139 return ERR_NOT_ENOUGH_RIGHT;
3140 }
3141
3142 FreeRpcEnumLogFile(t);
3143 Zero(t, sizeof(RPC_ENUM_LOG_FILE));
3144
3145 // Enumerate local log files
3146 SiEnumLocalLogFileList(s, a->ServerAdmin ? NULL : a->HubName, t);
3147
3148 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
3149 {
3150 UINT i;
3151 LIST *tt_list = NewListFast(NULL);
3152
3153 LockList(s->FarmMemberList);
3154 {
3155 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
3156 {
3157 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
3158
3159 if (f->Me == false)
3160 {
3161 // Enumerate log files on other cluster members.
3162 RPC_ENUM_LOG_FILE *tt;
3163 tt = ZeroMalloc(sizeof(RPC_ENUM_LOG_FILE));
3164
3165 if (SiCallEnumLogFileList(s, f, tt, a->ServerAdmin ? "" : a->HubName))
3166 {
3167 UINT i;
3168 for (i = 0;i < tt->NumItem;i++)
3169 {
3170 RPC_ENUM_LOG_FILE_ITEM *e = &tt->Items[i];
3171
3172 StrCpy(e->ServerName, sizeof(e->ServerName), f->hostname);
3173 }
3174
3175 Add(tt_list, tt);
3176 }
3177 else
3178 {
3179 Free(tt);
3180 }
3181 }
3182 }
3183 }
3184 UnlockList(s->FarmMemberList);
3185
3186 for (i = 0;i < LIST_NUM(tt_list);i++)
3187 {
3188 RPC_ENUM_LOG_FILE *tt = LIST_DATA(tt_list, i);
3189
3190 AdjoinRpcEnumLogFile(t, tt);
3191 FreeRpcEnumLogFile(tt);
3192
3193 Free(tt);
3194 }
3195
3196 ReleaseList(tt_list);
3197 }
3198
3199 // Cache the last list of log files on RPC session
3200 if (a->LogFileList != NULL)
3201 {
3202 FreeEnumLogFile(a->LogFileList);
3203 }
3204
3205 a->LogFileList = NewListFast(CmpLogFile);
3206
3207 for (i = 0;i < t->NumItem;i++)
3208 {
3209 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];
3210 LOG_FILE *f = ZeroMalloc(sizeof(LOG_FILE));
3211
3212 f->FileSize = e->FileSize;
3213 f->UpdatedTime = e->UpdatedTime;
3214 StrCpy(f->Path, sizeof(f->Path), e->FilePath);
3215 StrCpy(f->ServerName, sizeof(f->ServerName), e->ServerName);
3216
3217 Insert(a->LogFileList, f);
3218 }
3219
3220 return ERR_NO_ERROR;
3221 }
3222
3223
3224 // Get access control list
StGetAcList(ADMIN * a,RPC_AC_LIST * t)3225 UINT StGetAcList(ADMIN *a, RPC_AC_LIST *t)
3226 {
3227 SERVER *s = a->Server;
3228 CEDAR *c = s->Cedar;
3229 HUB *h;
3230 UINT ret = ERR_NO_ERROR;
3231 char hubname[MAX_HUBNAME_LEN + 1];
3232
3233 CHECK_RIGHT;
3234 NO_SUPPORT_FOR_BRIDGE;
3235 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
3236 {
3237 return ERR_NOT_SUPPORTED;
3238 }
3239
3240
3241 StrCpy(hubname, sizeof(hubname), t->HubName);
3242
3243 FreeRpcAcList(t);
3244 Zero(t, sizeof(RPC_AC_LIST));
3245 StrCpy(t->HubName, sizeof(t->HubName), hubname);
3246
3247 h = GetHub(c, hubname);
3248
3249 if (h == NULL)
3250 {
3251 ret = ERR_HUB_NOT_FOUND;
3252 }
3253 else
3254 {
3255 if (h->HubDb == NULL)
3256 {
3257 ret = ERR_NOT_SUPPORTED;
3258 }
3259 else
3260 {
3261 HUBDB *db = h->HubDb;
3262
3263 LockList(db->AcList);
3264 {
3265 t->o = NewAcList();
3266
3267 SetAcList(t->o, db->AcList);
3268 }
3269 UnlockList(db->AcList);
3270 }
3271 ReleaseHub(h);
3272 }
3273
3274 return ret;
3275 }
3276
3277 // Set access control list
StSetAcList(ADMIN * a,RPC_AC_LIST * t)3278 UINT StSetAcList(ADMIN *a, RPC_AC_LIST *t)
3279 {
3280 SERVER *s = a->Server;
3281 CEDAR *c = s->Cedar;
3282 HUB *h;
3283 UINT ret = ERR_NO_ERROR;
3284 char hubname[MAX_HUBNAME_LEN + 1];
3285
3286
3287 if (c->Bridge)
3288 {
3289 return ERR_NOT_SUPPORTED;
3290 }
3291
3292 if (GetGlobalServerFlag(GSF_DISABLE_AC) != 0 && LIST_NUM(t->o) >= 1)
3293 {
3294 return ERR_NOT_SUPPORTED_FUNCTION_ON_OPENSOURCE;
3295 }
3296
3297 CHECK_RIGHT;
3298 NO_SUPPORT_FOR_BRIDGE;
3299 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
3300 {
3301 return ERR_NOT_SUPPORTED;
3302 }
3303
3304 StrCpy(hubname, sizeof(hubname), t->HubName);
3305
3306 h = GetHub(c, hubname);
3307
3308 if (h == NULL)
3309 {
3310 ret = ERR_HUB_NOT_FOUND;
3311 }
3312 else
3313 {
3314 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_access_control_list") != 0)
3315 {
3316 ret = ERR_NOT_ENOUGH_RIGHT;
3317 }
3318 else
3319 {
3320 if (h->HubDb == NULL)
3321 {
3322 ret = ERR_NOT_SUPPORTED;
3323 }
3324 else
3325 {
3326 HUBDB *db = h->HubDb;
3327
3328 LockList(db->AcList);
3329 {
3330 SetAcList(db->AcList, t->o);
3331
3332 {
3333 ALog(a, h, "LA_SET_AC_LIST", LIST_NUM(t->o));
3334
3335 IncrementServerConfigRevision(s);
3336 }
3337 }
3338 UnlockList(db->AcList);
3339 }
3340 }
3341 ReleaseHub(h);
3342 }
3343
3344 return ret;
3345 }
3346
3347 // Set CRL (Certificate Revocation List) entry
StSetCrl(ADMIN * a,RPC_CRL * t)3348 UINT StSetCrl(ADMIN *a, RPC_CRL *t)
3349 {
3350 SERVER *s = a->Server;
3351 CEDAR *c = s->Cedar;
3352 HUB *h;
3353 UINT ret = ERR_NO_ERROR;
3354 UINT key;
3355 char hubname[MAX_HUBNAME_LEN + 1];
3356
3357 CHECK_RIGHT;
3358 NO_SUPPORT_FOR_BRIDGE;
3359 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
3360 {
3361 return ERR_NOT_SUPPORTED;
3362 }
3363
3364 StrCpy(hubname, sizeof(hubname), t->HubName);
3365 key = t->Key;
3366
3367 h = GetHub(c, hubname);
3368
3369 if (h == NULL)
3370 {
3371 ret = ERR_HUB_NOT_FOUND;
3372 }
3373 else
3374 {
3375 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_crl_list") != 0)
3376 {
3377 ret = ERR_NOT_ENOUGH_RIGHT;
3378 }
3379 else
3380 {
3381 if (h->HubDb == NULL)
3382 {
3383 ret = ERR_NOT_SUPPORTED;
3384 }
3385 else
3386 {
3387 LockList(h->HubDb->CrlList);
3388 {
3389 CRL *crl = ListKeyToPointer(h->HubDb->CrlList, t->Key);
3390
3391 if (crl == NULL)
3392 {
3393 ret = ERR_OBJECT_NOT_FOUND;
3394 }
3395 else
3396 {
3397 CRL *new_crl = CopyCrl(t->Crl);
3398 if (ReplaceListPointer(h->HubDb->CrlList, crl, new_crl))
3399 {
3400 ALog(a, h, "LA_ADD_CRL");
3401 FreeCrl(crl);
3402
3403 IncrementServerConfigRevision(s);
3404 }
3405 }
3406 }
3407 UnlockList(h->HubDb->CrlList);
3408 }
3409 }
3410
3411 ReleaseHub(h);
3412 }
3413
3414 return ret;
3415 }
3416
3417 // Get CRL (Certificate Revocation List) entry
StGetCrl(ADMIN * a,RPC_CRL * t)3418 UINT StGetCrl(ADMIN *a, RPC_CRL *t)
3419 {
3420 SERVER *s = a->Server;
3421 CEDAR *c = s->Cedar;
3422 HUB *h;
3423 UINT ret = ERR_NO_ERROR;
3424 UINT key;
3425 char hubname[MAX_HUBNAME_LEN + 1];
3426
3427 CHECK_RIGHT;
3428 NO_SUPPORT_FOR_BRIDGE;
3429 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
3430 {
3431 return ERR_NOT_SUPPORTED;
3432 }
3433
3434 StrCpy(hubname, sizeof(hubname), t->HubName);
3435 key = t->Key;
3436
3437 FreeRpcCrl(t);
3438 Zero(t, sizeof(RPC_CRL));
3439 StrCpy(t->HubName, sizeof(t->HubName), hubname);
3440 t->Key = key;
3441
3442 h = GetHub(c, hubname);
3443
3444 if (h == NULL)
3445 {
3446 ret = ERR_HUB_NOT_FOUND;
3447 }
3448 else
3449 {
3450 if (h->HubDb == NULL)
3451 {
3452 ret = ERR_NOT_SUPPORTED;
3453 }
3454 else
3455 {
3456 LockList(h->HubDb->CrlList);
3457 {
3458 CRL *crl = ListKeyToPointer(h->HubDb->CrlList, t->Key);
3459
3460 if (crl == NULL)
3461 {
3462 ret = ERR_OBJECT_NOT_FOUND;
3463 }
3464 else
3465 {
3466 t->Crl = CopyCrl(crl);
3467 }
3468 }
3469 UnlockList(h->HubDb->CrlList);
3470 }
3471
3472 ReleaseHub(h);
3473 }
3474
3475 return ret;
3476 }
3477
3478 // Delete CRL (Certificate Revocation List) entry
StDelCrl(ADMIN * a,RPC_CRL * t)3479 UINT StDelCrl(ADMIN *a, RPC_CRL *t)
3480 {
3481 SERVER *s = a->Server;
3482 CEDAR *c = s->Cedar;
3483 HUB *h;
3484 UINT ret = ERR_NO_ERROR;
3485 char hubname[MAX_HUBNAME_LEN + 1];
3486
3487 CHECK_RIGHT;
3488 NO_SUPPORT_FOR_BRIDGE;
3489 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
3490 {
3491 return ERR_NOT_SUPPORTED;
3492 }
3493
3494 StrCpy(hubname, sizeof(hubname), t->HubName);
3495
3496 h = GetHub(c, hubname);
3497
3498 if (h == NULL)
3499 {
3500 ret = ERR_HUB_NOT_FOUND;
3501 }
3502 else
3503 {
3504 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_crl_list") != 0)
3505 {
3506 ret = ERR_NOT_ENOUGH_RIGHT;
3507 }
3508 else
3509 {
3510 if (h->HubDb == NULL)
3511 {
3512 ret = ERR_NOT_SUPPORTED;
3513 }
3514 else
3515 {
3516 LockList(h->HubDb->CrlList);
3517 {
3518 CRL *crl = ListKeyToPointer(h->HubDb->CrlList, t->Key);
3519
3520 if (crl == NULL)
3521 {
3522 ret = ERR_OBJECT_NOT_FOUND;
3523 }
3524 else
3525 {
3526 ALog(a, h, "LA_DEL_CRL");
3527 FreeCrl(crl);
3528 Delete(h->HubDb->CrlList, crl);
3529 }
3530 }
3531 UnlockList(h->HubDb->CrlList);
3532 }
3533 }
3534
3535 ReleaseHub(h);
3536 }
3537
3538 return ret;
3539 }
3540
3541 // Add new CRL (Certificate Revocation List) entry
StAddCrl(ADMIN * a,RPC_CRL * t)3542 UINT StAddCrl(ADMIN *a, RPC_CRL *t)
3543 {
3544 SERVER *s = a->Server;
3545 CEDAR *c = s->Cedar;
3546 HUB *h;
3547 UINT ret = ERR_NO_ERROR;
3548 char hubname[MAX_HUBNAME_LEN + 1];
3549
3550 if (c->Bridge)
3551 {
3552 return ERR_NOT_SUPPORTED;
3553 }
3554
3555 CHECK_RIGHT;
3556 NO_SUPPORT_FOR_BRIDGE;
3557 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
3558 {
3559 return ERR_NOT_SUPPORTED;
3560 }
3561
3562 StrCpy(hubname, sizeof(hubname), t->HubName);
3563
3564 h = GetHub(c, hubname);
3565
3566 if (h == NULL)
3567 {
3568 ret = ERR_HUB_NOT_FOUND;
3569 }
3570 else
3571 {
3572 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_crl_list") != 0)
3573 {
3574 ret = ERR_NOT_ENOUGH_RIGHT;
3575 }
3576 else
3577 {
3578 if (h->HubDb == NULL)
3579 {
3580 ret = ERR_NOT_SUPPORTED;
3581 }
3582 else
3583 {
3584 LockList(h->HubDb->CrlList);
3585 {
3586 if (LIST_NUM(h->HubDb->CrlList) < MAX_HUB_CRLS)
3587 {
3588 CRL *crl = CopyCrl(t->Crl);
3589
3590 Insert(h->HubDb->CrlList, crl);
3591
3592 ALog(a, h, "LA_SET_CRL");
3593
3594 IncrementServerConfigRevision(s);
3595 }
3596 }
3597 UnlockList(h->HubDb->CrlList);
3598 }
3599 }
3600
3601 ReleaseHub(h);
3602 }
3603
3604 return ret;
3605 }
3606
3607 // Get CRL (Certificate Revocation List) index
StEnumCrl(ADMIN * a,RPC_ENUM_CRL * t)3608 UINT StEnumCrl(ADMIN *a, RPC_ENUM_CRL *t)
3609 {
3610 SERVER *s = a->Server;
3611 CEDAR *c = s->Cedar;
3612 HUB *h;
3613 UINT ret = ERR_NO_ERROR;
3614 char hubname[MAX_HUBNAME_LEN + 1];
3615
3616 CHECK_RIGHT;
3617 NO_SUPPORT_FOR_BRIDGE;
3618 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
3619 {
3620 return ERR_NOT_SUPPORTED;
3621 }
3622
3623 StrCpy(hubname, sizeof(hubname), t->HubName);
3624 FreeRpcEnumCrl(t);
3625 Zero(t, sizeof(RPC_ENUM_CRL));
3626
3627 StrCpy(t->HubName, sizeof(t->HubName), hubname);
3628
3629 h = GetHub(c, hubname);
3630
3631 if (h == NULL)
3632 {
3633 ret = ERR_HUB_NOT_FOUND;
3634 }
3635 else
3636 {
3637 if (h->HubDb == NULL)
3638 {
3639 ret = ERR_NOT_SUPPORTED;
3640 }
3641 else
3642 {
3643 LockList(h->HubDb->CrlList);
3644 {
3645 UINT i;
3646
3647 t->NumItem = LIST_NUM(h->HubDb->CrlList);
3648 t->Items = ZeroMalloc(sizeof(RPC_ENUM_CRL_ITEM) * t->NumItem);
3649
3650 for (i = 0;i < LIST_NUM(h->HubDb->CrlList);i++)
3651 {
3652 CRL *crl = LIST_DATA(h->HubDb->CrlList, i);
3653 wchar_t *info = GenerateCrlStr(crl);
3654
3655 UniStrCpy(t->Items[i].CrlInfo, sizeof(t->Items[i].CrlInfo), info);
3656 Free(info);
3657
3658 t->Items[i].Key = POINTER_TO_KEY(crl);
3659 }
3660 }
3661 UnlockList(h->HubDb->CrlList);
3662 }
3663
3664 ReleaseHub(h);
3665 }
3666
3667 return ret;
3668 }
3669
3670 // Get routing table on virtual L3 switch
StEnumL3Table(ADMIN * a,RPC_ENUM_L3TABLE * t)3671 UINT StEnumL3Table(ADMIN *a, RPC_ENUM_L3TABLE *t)
3672 {
3673 SERVER *s = a->Server;
3674 CEDAR *c = s->Cedar;
3675 UINT ret = ERR_NO_ERROR;
3676 L3SW *sw;
3677 char name[MAX_HUBNAME_LEN + 1];
3678
3679 if (IsEmptyStr(t->Name))
3680 {
3681 return ERR_INVALID_PARAMETER;
3682 }
3683
3684 NO_SUPPORT_FOR_BRIDGE;
3685
3686 StrCpy(name, sizeof(name), t->Name);
3687 FreeRpcEnumL3Table(t);
3688 Zero(t, sizeof(RPC_ENUM_L3TABLE));
3689 StrCpy(t->Name, sizeof(t->Name), name);
3690
3691 sw = L3GetSw(c, t->Name);
3692
3693 if (sw == NULL)
3694 {
3695 ret = ERR_LAYER3_SW_NOT_FOUND;
3696 }
3697 else
3698 {
3699 UINT i;
3700
3701 Lock(sw->lock);
3702 {
3703 t->NumItem = LIST_NUM(sw->TableList);
3704 t->Items = ZeroMalloc(sizeof(RPC_L3TABLE) * t->NumItem);
3705
3706 for (i = 0;i < t->NumItem;i++)
3707 {
3708 L3TABLE *tbl = LIST_DATA(sw->TableList, i);
3709 RPC_L3TABLE *e = &t->Items[i];
3710
3711 StrCpy(e->Name, sizeof(e->Name), name);
3712 e->NetworkAddress = tbl->NetworkAddress;
3713 e->SubnetMask = tbl->SubnetMask;
3714 e->GatewayAddress = tbl->GatewayAddress;
3715 e->Metric = tbl->Metric;
3716 }
3717 }
3718 Unlock(sw->lock);
3719
3720 ReleaseL3Sw(sw);
3721 }
3722
3723 return ret;
3724 }
3725
3726 // Delete routing table entry on virtual L3 switch
StDelL3Table(ADMIN * a,RPC_L3TABLE * t)3727 UINT StDelL3Table(ADMIN *a, RPC_L3TABLE *t)
3728 {
3729 SERVER *s = a->Server;
3730 CEDAR *c = s->Cedar;
3731 UINT ret = ERR_NO_ERROR;
3732 L3SW *sw;
3733
3734 SERVER_ADMIN_ONLY;
3735
3736 NO_SUPPORT_FOR_BRIDGE;
3737
3738 sw = L3GetSw(c, t->Name);
3739
3740 if (sw == NULL)
3741 {
3742 ret = ERR_LAYER3_SW_NOT_FOUND;
3743 }
3744 else
3745 {
3746 L3TABLE tbl;
3747
3748 Zero(&tbl, sizeof(tbl));
3749 tbl.NetworkAddress = t->NetworkAddress;
3750 tbl.SubnetMask = t->SubnetMask;
3751 tbl.GatewayAddress = t->GatewayAddress;
3752 tbl.Metric = t->Metric;
3753
3754 if (L3DelTable(sw, &tbl) == false)
3755 {
3756 ret = ERR_LAYER3_TABLE_DEL_FAILED;
3757 }
3758 else
3759 {
3760 char tmp[MAX_SIZE];
3761 IPToStr32(tmp, sizeof(tmp), tbl.NetworkAddress);
3762 ALog(a, NULL, "LA_DEL_L3_TABLE", tmp, t->Name);
3763
3764 IncrementServerConfigRevision(s);
3765 }
3766
3767 ReleaseL3Sw(sw);
3768 }
3769
3770 return ret;
3771 }
3772
3773 // Add new routing table entry on virtual L3 switch
StAddL3Table(ADMIN * a,RPC_L3TABLE * t)3774 UINT StAddL3Table(ADMIN *a, RPC_L3TABLE *t)
3775 {
3776 SERVER *s = a->Server;
3777 CEDAR *c = s->Cedar;
3778 UINT ret = ERR_NO_ERROR;
3779 L3SW *sw;
3780
3781 if (IsNetworkAddress32(t->NetworkAddress, t->SubnetMask) == false ||
3782 IsHostIPAddress32(t->GatewayAddress) == false)
3783 {
3784 return ERR_INVALID_PARAMETER;
3785 }
3786
3787 SERVER_ADMIN_ONLY;
3788
3789 NO_SUPPORT_FOR_BRIDGE;
3790
3791 sw = L3GetSw(c, t->Name);
3792
3793 if (sw == NULL)
3794 {
3795 ret = ERR_LAYER3_SW_NOT_FOUND;
3796 }
3797 else
3798 {
3799 L3TABLE tbl;
3800
3801 Zero(&tbl, sizeof(tbl));
3802 tbl.NetworkAddress = t->NetworkAddress;
3803 tbl.SubnetMask = t->SubnetMask;
3804 tbl.GatewayAddress = t->GatewayAddress;
3805 tbl.Metric = t->Metric;
3806
3807 if (L3AddTable(sw, &tbl) == false)
3808 {
3809 ret = ERR_LAYER3_TABLE_ADD_FAILED;
3810 }
3811 else
3812 {
3813 char tmp[MAX_SIZE];
3814 IPToStr32(tmp, sizeof(tmp), tbl.NetworkAddress);
3815 ALog(a, NULL, "LA_ADD_L3_TABLE", tmp, t->Name);
3816
3817 IncrementServerConfigRevision(s);
3818 }
3819
3820 ReleaseL3Sw(sw);
3821 }
3822
3823 return ret;
3824 }
3825
3826 // Enumerate virtual interfaces on virtual L3 switch
StEnumL3If(ADMIN * a,RPC_ENUM_L3IF * t)3827 UINT StEnumL3If(ADMIN *a, RPC_ENUM_L3IF *t)
3828 {
3829 SERVER *s = a->Server;
3830 CEDAR *c = s->Cedar;
3831 UINT ret = ERR_NO_ERROR;
3832 L3SW *sw;
3833 char name[MAX_HUBNAME_LEN + 1];
3834
3835 NO_SUPPORT_FOR_BRIDGE;
3836
3837 StrCpy(name, sizeof(name), t->Name);
3838
3839 FreeRpcEnumL3If(t);
3840 Zero(t, sizeof(RPC_ENUM_L3IF));
3841
3842 StrCpy(t->Name, sizeof(t->Name), name);
3843
3844 sw = L3GetSw(c, t->Name);
3845
3846 if (sw == NULL)
3847 {
3848 ret = ERR_LAYER3_SW_NOT_FOUND;
3849 }
3850 else
3851 {
3852 Lock(sw->lock);
3853 {
3854 UINT i;
3855
3856 t->NumItem = LIST_NUM(sw->IfList);
3857 t->Items = ZeroMalloc(sizeof(RPC_L3IF) * t->NumItem);
3858
3859 for (i = 0;i < t->NumItem;i++)
3860 {
3861 L3IF *f = LIST_DATA(sw->IfList, i);
3862 RPC_L3IF *e = &t->Items[i];
3863
3864 StrCpy(e->Name, sizeof(e->Name), sw->Name);
3865 StrCpy(e->HubName, sizeof(e->HubName), f->HubName);
3866 e->IpAddress = f->IpAddress;
3867 e->SubnetMask = f->SubnetMask;
3868 }
3869 }
3870 Unlock(sw->lock);
3871
3872 ReleaseL3Sw(sw);
3873 }
3874
3875 return ret;
3876 }
3877
3878 // Delete a virtual interface on virtual L3 switch
StDelL3If(ADMIN * a,RPC_L3IF * t)3879 UINT StDelL3If(ADMIN *a, RPC_L3IF *t)
3880 {
3881 SERVER *s = a->Server;
3882 CEDAR *c = s->Cedar;
3883 UINT ret = ERR_NO_ERROR;
3884 L3SW *sw;
3885
3886 NO_SUPPORT_FOR_BRIDGE;
3887
3888 SERVER_ADMIN_ONLY;
3889
3890 sw = L3GetSw(c, t->Name);
3891
3892 if (sw == NULL)
3893 {
3894 ret = ERR_LAYER3_SW_NOT_FOUND;
3895 }
3896 else
3897 {
3898 if (L3DelIf(sw, t->HubName) == false)
3899 {
3900 ret = ERR_LAYER3_IF_DEL_FAILED;
3901 }
3902 else
3903 {
3904 ALog(a, NULL, "LA_DEL_L3_IF", t->HubName, t->Name);
3905
3906 IncrementServerConfigRevision(s);
3907 }
3908 ReleaseL3Sw(sw);
3909 }
3910
3911 return ret;
3912 }
3913
3914 // Add new virtual interface on virtual L3 switch
StAddL3If(ADMIN * a,RPC_L3IF * t)3915 UINT StAddL3If(ADMIN *a, RPC_L3IF *t)
3916 {
3917 SERVER *s = a->Server;
3918 CEDAR *c = s->Cedar;
3919 UINT ret = ERR_NO_ERROR;
3920 L3SW *sw;
3921
3922
3923 if (IsSubnetMask32(t->SubnetMask) == false || IsHostIPAddress32(t->IpAddress) == false)
3924 {
3925 return ERR_INVALID_PARAMETER;
3926 }
3927 if ((t->IpAddress & (~t->SubnetMask)) == 0)
3928 {
3929 return ERR_INVALID_PARAMETER;
3930 }
3931
3932 NO_SUPPORT_FOR_BRIDGE;
3933
3934 SERVER_ADMIN_ONLY;
3935
3936 sw = L3GetSw(c, t->Name);
3937
3938 if (sw == NULL)
3939 {
3940 ret = ERR_LAYER3_SW_NOT_FOUND;
3941 }
3942 else
3943 {
3944 Lock(sw->lock);
3945 {
3946 if (L3SearchIf(sw, t->HubName) != NULL)
3947 {
3948 // Already exists
3949 ret = ERR_LAYER3_IF_EXISTS;
3950 }
3951 else
3952 {
3953 if (L3AddIf(sw, t->HubName, t->IpAddress, t->SubnetMask) == false)
3954 {
3955 ret = ERR_LAYER3_IF_ADD_FAILED;
3956 }
3957 else
3958 {
3959 ALog(a, NULL, "LA_ADD_L3_IF", t->HubName, t->Name);
3960
3961 IncrementServerConfigRevision(s);
3962 }
3963 }
3964 }
3965 Unlock(sw->lock);
3966 ReleaseL3Sw(sw);
3967 }
3968
3969 return ret;
3970 }
3971
3972 // Stop a virtual layer-3 switch
StStopL3Switch(ADMIN * a,RPC_L3SW * t)3973 UINT StStopL3Switch(ADMIN *a, RPC_L3SW *t)
3974 {
3975 SERVER *s = a->Server;
3976 CEDAR *c = s->Cedar;
3977 UINT ret = ERR_NO_ERROR;
3978 L3SW *sw;
3979
3980 if (IsEmptyStr(t->Name))
3981 {
3982 return ERR_INVALID_PARAMETER;
3983 }
3984
3985 NO_SUPPORT_FOR_BRIDGE;
3986
3987 SERVER_ADMIN_ONLY;
3988
3989 sw = L3GetSw(c, t->Name);
3990
3991 if (sw == NULL)
3992 {
3993 ret = ERR_LAYER3_SW_NOT_FOUND;
3994 }
3995 else
3996 {
3997 L3SwStop(sw);
3998 ALog(a, NULL, "LA_STOP_L3_SW", sw->Name);
3999 ReleaseL3Sw(sw);
4000
4001 IncrementServerConfigRevision(s);
4002 }
4003
4004 return ret;
4005 }
4006
4007 // Start a virtual layer-3 switch
StStartL3Switch(ADMIN * a,RPC_L3SW * t)4008 UINT StStartL3Switch(ADMIN *a, RPC_L3SW *t)
4009 {
4010 SERVER *s = a->Server;
4011 CEDAR *c = s->Cedar;
4012 UINT ret = ERR_NO_ERROR;
4013 L3SW *sw;
4014
4015 if (IsEmptyStr(t->Name))
4016 {
4017 return ERR_INVALID_PARAMETER;
4018 }
4019
4020 NO_SUPPORT_FOR_BRIDGE;
4021
4022 SERVER_ADMIN_ONLY;
4023
4024 sw = L3GetSw(c, t->Name);
4025
4026 if (sw == NULL)
4027 {
4028 ret = ERR_LAYER3_SW_NOT_FOUND;
4029 }
4030 else
4031 {
4032 Lock(sw->lock);
4033 {
4034 // Count the registered virtual interfaces
4035 if (LIST_NUM(sw->IfList) >= 1)
4036 {
4037 L3SwStart(sw);
4038
4039 ALog(a, NULL, "LA_START_L3_SW", sw->Name);
4040
4041 IncrementServerConfigRevision(s);
4042 }
4043 else
4044 {
4045 ret = ERR_LAYER3_CANT_START_SWITCH;
4046 }
4047 }
4048 Unlock(sw->lock);
4049
4050 ReleaseL3Sw(sw);
4051 }
4052
4053 return ret;
4054 }
4055
4056 // Enumerate virtual layer-3 switches
StEnumL3Switch(ADMIN * a,RPC_ENUM_L3SW * t)4057 UINT StEnumL3Switch(ADMIN *a, RPC_ENUM_L3SW *t)
4058 {
4059 UINT i;
4060 SERVER *s = a->Server;
4061 CEDAR *c = s->Cedar;
4062 UINT ret = ERR_NO_ERROR;
4063
4064 NO_SUPPORT_FOR_BRIDGE;
4065
4066 FreeRpcEnumL3Sw(t);
4067 Zero(t, sizeof(RPC_ENUM_L3SW));
4068
4069 LockList(c->L3SwList);
4070 {
4071 t->NumItem = LIST_NUM(c->L3SwList);
4072 t->Items = ZeroMalloc(sizeof(RPC_ENUM_L3SW_ITEM) * t->NumItem);
4073 for (i = 0;i < LIST_NUM(c->L3SwList);i++)
4074 {
4075 L3SW *sw = LIST_DATA(c->L3SwList, i);
4076 RPC_ENUM_L3SW_ITEM *e = &t->Items[i];
4077
4078 Lock(sw->lock);
4079 {
4080 StrCpy(e->Name, sizeof(e->Name), sw->Name);
4081 e->NumInterfaces = LIST_NUM(sw->IfList);
4082 e->NumTables = LIST_NUM(sw->TableList);
4083 e->Active = sw->Active;
4084 e->Online = sw->Online;
4085 }
4086 Unlock(sw->lock);
4087 }
4088 }
4089 UnlockList(c->L3SwList);
4090
4091 return ret;
4092 }
4093
4094 // Delete a virtual layer-3 switch
StDelL3Switch(ADMIN * a,RPC_L3SW * t)4095 UINT StDelL3Switch(ADMIN *a, RPC_L3SW *t)
4096 {
4097 SERVER *s = a->Server;
4098 CEDAR *c = s->Cedar;
4099 UINT ret = ERR_NO_ERROR;
4100
4101 if (IsEmptyStr(t->Name))
4102 {
4103 return ERR_INVALID_PARAMETER;
4104 }
4105
4106 NO_SUPPORT_FOR_BRIDGE;
4107
4108 SERVER_ADMIN_ONLY;
4109
4110 if (L3DelSw(c, t->Name) == false)
4111 {
4112 ret = ERR_LAYER3_SW_NOT_FOUND;
4113 }
4114 else
4115 {
4116 ALog(a, NULL, "LA_DEL_L3_SW", t->Name);
4117
4118 IncrementServerConfigRevision(s);
4119 }
4120
4121 return ret;
4122 }
4123
4124 // Add a new virtual layer-3 switch
StAddL3Switch(ADMIN * a,RPC_L3SW * t)4125 UINT StAddL3Switch(ADMIN *a, RPC_L3SW *t)
4126 {
4127 SERVER *s = a->Server;
4128 CEDAR *c = s->Cedar;
4129 UINT ret = ERR_NO_ERROR;
4130 L3SW *sw;
4131
4132 NO_SUPPORT_FOR_BRIDGE;
4133
4134 if (IsEmptyStr(t->Name))
4135 {
4136 return ERR_INVALID_PARAMETER;
4137 }
4138
4139 if (IsSafeStr(t->Name) == false)
4140 {
4141 return ERR_INVALID_PARAMETER;
4142 }
4143
4144 SERVER_ADMIN_ONLY;
4145
4146 // Duplication check
4147 sw = L3GetSw(c, t->Name);
4148 if (sw != NULL)
4149 {
4150 // Already exists
4151 ReleaseL3Sw(sw);
4152 ret = ERR_LAYER3_SW_EXISTS;
4153 }
4154 else
4155 {
4156 LockList(c->L3SwList);
4157 {
4158 if (LIST_NUM(c->L3SwList) >= GetServerCapsInt(s, "i_max_l3_sw"))
4159 {
4160 // No more virtual interfaces
4161 sw = NULL;
4162 }
4163 else
4164 {
4165 // Create
4166 sw = L3AddSw(c, t->Name);
4167
4168 if (sw != NULL)
4169 {
4170 ALog(a, NULL, "LA_ADD_L3_SW", t->Name);
4171
4172 IncrementServerConfigRevision(s);
4173 }
4174 }
4175 }
4176 UnlockList(c->L3SwList);
4177
4178 if (sw == NULL)
4179 {
4180 // Failed
4181 ret = ERR_INTERNAL_ERROR;
4182 }
4183 else
4184 {
4185 // Success
4186 ReleaseL3Sw(sw);
4187 }
4188 }
4189
4190 return ret;
4191 }
4192
4193 // Set hub extended options
StSetHubExtOptions(ADMIN * a,RPC_ADMIN_OPTION * t)4194 UINT StSetHubExtOptions(ADMIN *a, RPC_ADMIN_OPTION *t)
4195 {
4196 SERVER *s = a->Server;
4197 CEDAR *c = s->Cedar;
4198 HUB *h;
4199
4200 bool not_server_admin = false;
4201
4202 if (t->NumItem > MAX_HUB_ADMIN_OPTIONS)
4203 {
4204 return ERR_TOO_MANT_ITEMS;
4205 }
4206
4207 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
4208 {
4209 return ERR_NOT_SUPPORTED;
4210 }
4211
4212
4213 CHECK_RIGHT;
4214
4215 if (a->ServerAdmin == false)
4216 {
4217 not_server_admin = true;
4218 }
4219
4220 LockHubList(c);
4221 {
4222 h = GetHub(c, t->HubName);
4223 }
4224 UnlockHubList(c);
4225
4226 if (h == NULL)
4227 {
4228 return ERR_HUB_NOT_FOUND;
4229 }
4230
4231 if (GetHubAdminOption(h, "deny_hub_admin_change_ext_option") && not_server_admin)
4232 {
4233 // Insufficient permission
4234 ReleaseHub(h);
4235
4236 return ERR_NOT_ENOUGH_RIGHT;
4237 }
4238
4239 // Update setting
4240 Lock(h->lock);
4241 {
4242 DataToHubOptionStruct(h->Option, t);
4243 }
4244 Unlock(h->lock);
4245
4246 ALog(a, NULL, "LA_SET_HUB_EXT_OPTION", h->Name);
4247
4248 h->CurrentVersion++;
4249 SiHubUpdateProc(h);
4250
4251 ReleaseHub(h);
4252
4253 IncrementServerConfigRevision(s);
4254
4255 return ERR_NO_ERROR;
4256 }
4257
4258 // Get hub extended options
StGetHubExtOptions(ADMIN * a,RPC_ADMIN_OPTION * t)4259 UINT StGetHubExtOptions(ADMIN *a, RPC_ADMIN_OPTION *t)
4260 {
4261 SERVER *s = a->Server;
4262 CEDAR *c = s->Cedar;
4263 HUB *h;
4264
4265 CHECK_RIGHT;
4266
4267 LockHubList(c);
4268 {
4269 h = GetHub(c, t->HubName);
4270 }
4271 UnlockHubList(c);
4272
4273 if (h == NULL)
4274 {
4275 return ERR_HUB_NOT_FOUND;
4276 }
4277
4278 FreeRpcAdminOption(t);
4279 Zero(t, sizeof(RPC_ADMIN_OPTION));
4280
4281 StrCpy(t->HubName, sizeof(t->HubName), h->Name);
4282
4283 // Get options
4284 Lock(h->lock);
4285 {
4286 HubOptionStructToData(t, h->Option, h->Name);
4287 }
4288 Unlock(h->lock);
4289
4290 ReleaseHub(h);
4291
4292 return ERR_NO_ERROR;
4293 }
4294
4295 // Set hub administration options
StSetHubAdminOptions(ADMIN * a,RPC_ADMIN_OPTION * t)4296 UINT StSetHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t)
4297 {
4298 UINT i;
4299 SERVER *s = a->Server;
4300 CEDAR *c = s->Cedar;
4301 HUB *h;
4302
4303 bool not_server_admin = false;
4304
4305
4306 if (t->NumItem > MAX_HUB_ADMIN_OPTIONS)
4307 {
4308 return ERR_TOO_MANT_ITEMS;
4309 }
4310
4311 NO_SUPPORT_FOR_BRIDGE;
4312 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
4313 {
4314 return ERR_NOT_SUPPORTED;
4315 }
4316
4317 CHECK_RIGHT;
4318
4319 if (a->ServerAdmin == false)
4320 {
4321 not_server_admin = true;
4322 }
4323
4324 LockHubList(c);
4325 {
4326 h = GetHub(c, t->HubName);
4327 }
4328 UnlockHubList(c);
4329
4330 if (h == NULL)
4331 {
4332 return ERR_HUB_NOT_FOUND;
4333 }
4334
4335 if (GetHubAdminOption(h, "allow_hub_admin_change_option") == false
4336 && not_server_admin)
4337 {
4338 // Insufficient permission
4339 ReleaseHub(h);
4340
4341 return ERR_NOT_ENOUGH_RIGHT;
4342 }
4343
4344 LockList(h->AdminOptionList);
4345 {
4346 DeleteAllHubAdminOption(h, false);
4347
4348 for (i = 0;i < t->NumItem;i++)
4349 {
4350 ADMIN_OPTION *e = &t->Items[i];
4351 ADMIN_OPTION *a = ZeroMalloc(sizeof(ADMIN_OPTION));
4352
4353 StrCpy(a->Name, sizeof(a->Name), e->Name);
4354 a->Value = e->Value;
4355
4356 Insert(h->AdminOptionList, a);
4357 }
4358
4359 AddHubAdminOptionsDefaults(h, false);
4360 }
4361 UnlockList(h->AdminOptionList);
4362
4363 ALog(a, NULL, "LA_SET_HUB_ADMIN_OPTION", h->Name);
4364
4365 h->CurrentVersion++;
4366 SiHubUpdateProc(h);
4367
4368 ReleaseHub(h);
4369
4370 IncrementServerConfigRevision(s);
4371
4372 return ERR_NO_ERROR;
4373 }
4374
4375 // Get hub administration options
StGetHubAdminOptions(ADMIN * a,RPC_ADMIN_OPTION * t)4376 UINT StGetHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t)
4377 {
4378 UINT i;
4379 SERVER *s = a->Server;
4380 CEDAR *c = s->Cedar;
4381 HUB *h;
4382
4383 CHECK_RIGHT;
4384
4385 NO_SUPPORT_FOR_BRIDGE;
4386 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
4387 {
4388 return ERR_NOT_SUPPORTED;
4389 }
4390
4391 LockHubList(c);
4392 {
4393 h = GetHub(c, t->HubName);
4394 }
4395 UnlockHubList(c);
4396
4397 if (h == NULL)
4398 {
4399 return ERR_HUB_NOT_FOUND;
4400 }
4401
4402 FreeRpcAdminOption(t);
4403 Zero(t, sizeof(RPC_ADMIN_OPTION));
4404
4405 StrCpy(t->HubName, sizeof(t->HubName), h->Name);
4406
4407 LockList(h->AdminOptionList);
4408 {
4409 t->NumItem = LIST_NUM(h->AdminOptionList);
4410 t->Items = ZeroMalloc(sizeof(ADMIN_OPTION) * t->NumItem);
4411
4412 for (i = 0;i < t->NumItem;i++)
4413 {
4414 ADMIN_OPTION *a = LIST_DATA(h->AdminOptionList, i);
4415 ADMIN_OPTION *e = &t->Items[i];
4416
4417 StrCpy(e->Name, sizeof(e->Name), a->Name);
4418 e->Value = a->Value;
4419 UniStrCpy(e->Descrption, sizeof(e->Descrption), GetHubAdminOptionHelpString(e->Name));
4420 }
4421 }
4422 UnlockList(h->AdminOptionList);
4423
4424 ReleaseHub(h);
4425
4426 return ERR_NO_ERROR;
4427 }
4428
4429 // Get default hub administration options
StGetDefaultHubAdminOptions(ADMIN * a,RPC_ADMIN_OPTION * t)4430 UINT StGetDefaultHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t)
4431 {
4432 UINT i;
4433
4434 NO_SUPPORT_FOR_BRIDGE;
4435 if (a->Server->ServerType == SERVER_TYPE_FARM_MEMBER)
4436 {
4437 return ERR_NOT_SUPPORTED;
4438 }
4439
4440 FreeRpcAdminOption(t);
4441 Zero(t, sizeof(RPC_ADMIN_OPTION));
4442
4443 t->NumItem = num_admin_options;
4444 t->Items = ZeroMalloc(sizeof(ADMIN_OPTION) * t->NumItem);
4445
4446 for (i = 0;i < t->NumItem;i++)
4447 {
4448 ADMIN_OPTION *a = &t->Items[i];
4449
4450 StrCpy(a->Name, sizeof(a->Name), admin_options[i].Name);
4451 a->Value = admin_options[i].Value;
4452 UniStrCpy(a->Descrption, sizeof(a->Descrption), GetHubAdminOptionHelpString(a->Name));
4453 }
4454
4455 return ERR_NO_ERROR;
4456 }
4457
4458 // Get configuration file stream
StGetConfig(ADMIN * a,RPC_CONFIG * t)4459 UINT StGetConfig(ADMIN *a, RPC_CONFIG *t)
4460 {
4461 SERVER *s;
4462
4463 SERVER_ADMIN_ONLY;
4464
4465 FreeRpcConfig(t);
4466 Zero(t, sizeof(RPC_CONFIG));
4467
4468 s = a->Server;
4469
4470 ALog(a, NULL, "LA_GET_CONFIG");
4471
4472 if (s->CfgRw != NULL)
4473 {
4474 FOLDER *f = SiWriteConfigurationToCfg(s);
4475 BUF *b = CfgFolderToBuf(f, true);
4476
4477 StrCpy(t->FileName, sizeof(t->FileName), s->CfgRw->FileName + (s->CfgRw->FileName[0] == '@' ? 1 : 0));
4478
4479 t->FileData = ZeroMalloc(b->Size + 1);
4480 Copy(t->FileData, b->Buf, b->Size);
4481
4482 CfgDeleteFolder(f);
4483 FreeBuf(b);
4484
4485 return ERR_NO_ERROR;
4486 }
4487 else
4488 {
4489 return ERR_INTERNAL_ERROR;
4490 }
4491 }
4492
4493 // Overwrite configuration file by specified data
StSetConfig(ADMIN * a,RPC_CONFIG * t)4494 UINT StSetConfig(ADMIN *a, RPC_CONFIG *t)
4495 {
4496 SERVER *s;
4497 IO *o;
4498 char filename[MAX_PATH];
4499
4500 SERVER_ADMIN_ONLY;
4501
4502 s = a->Server;
4503 if (s->CfgRw == NULL)
4504 {
4505 return ERR_INTERNAL_ERROR;
4506 }
4507
4508 // Write new configuration file
4509 Format(filename, sizeof(filename), "%s.new", s->CfgRw->FileName);
4510
4511 o = FileCreate(filename);
4512
4513 FileWrite(o, t->FileData, StrLen(t->FileData));
4514
4515 FileClose(o);
4516
4517 IncrementServerConfigRevision(s);
4518
4519 ALog(a, NULL, "LA_SET_CONFIG");
4520
4521 // Reboot server itself
4522 SiRebootServer(s->Cedar->Bridge);
4523
4524 return ERR_NO_ERROR;
4525 }
4526
4527 // Get capabilities
StGetCaps(ADMIN * a,CAPSLIST * t)4528 UINT StGetCaps(ADMIN *a, CAPSLIST *t)
4529 {
4530 FreeRpcCapsList(t);
4531 Zero(t, sizeof(CAPSLIST));
4532
4533 GetServerCapsMain(a->Server, t);
4534
4535 return ERR_NO_ERROR;
4536 }
4537
4538 // Reboot server itself
StRebootServer(ADMIN * a,RPC_TEST * t)4539 UINT StRebootServer(ADMIN *a, RPC_TEST *t)
4540 {
4541 SERVER_ADMIN_ONLY;
4542
4543 ALog(a, NULL, "LA_REBOOT_SERVER");
4544
4545 SiRebootServerEx(a->Server->Cedar->Bridge, t->IntValue);
4546
4547 return ERR_NO_ERROR;
4548 }
4549
4550 // Get availability to localbridge function
StGetBridgeSupport(ADMIN * a,RPC_BRIDGE_SUPPORT * t)4551 UINT StGetBridgeSupport(ADMIN *a, RPC_BRIDGE_SUPPORT *t)
4552 {
4553 Zero(t, sizeof(RPC_BRIDGE_SUPPORT));
4554
4555 t->IsBridgeSupportedOs = IsBridgeSupported();
4556 t->IsWinPcapNeeded = IsNeedWinPcap();
4557
4558 return ERR_NO_ERROR;
4559 }
4560
4561 // Enumerate Ethernet devices
StEnumEthernet(ADMIN * a,RPC_ENUM_ETH * t)4562 UINT StEnumEthernet(ADMIN *a, RPC_ENUM_ETH *t)
4563 {
4564 TOKEN_LIST *o;
4565 UINT i;
4566 char tmp[MAX_SIZE];
4567 bool unix_support = false;
4568
4569 SERVER_ADMIN_ONLY;
4570
4571 #ifdef OS_UNIX
4572 unix_support = EthIsInterfaceDescriptionSupportedUnix();
4573 #endif // OS_UNIX
4574
4575 o = GetEthList();
4576 if (o == NULL)
4577 {
4578 return ERR_NOT_SUPPORTED;
4579 }
4580
4581 FreeRpcEnumEth(t);
4582 Zero(t, sizeof(RPC_ENUM_ETH));
4583
4584 t->NumItem = o->NumTokens;
4585 t->Items = ZeroMalloc(sizeof(RPC_ENUM_ETH_ITEM) * t->NumItem);
4586
4587 for (i = 0;i < t->NumItem;i++)
4588 {
4589 RPC_ENUM_ETH_ITEM *e = &t->Items[i];
4590
4591 StrCpy(e->DeviceName, sizeof(e->DeviceName), o->Token[i]);
4592
4593 StrCpy(tmp, sizeof(tmp), e->DeviceName);
4594
4595 #ifdef OS_WIN32
4596 GetEthNetworkConnectionName(e->NetworkConnectionName, sizeof(e->NetworkConnectionName), e->DeviceName);
4597 #else
4598 if (unix_support == false)
4599 {
4600 StrCpy(tmp, sizeof(tmp), "");
4601 }
4602 else
4603 {
4604 if (EthGetInterfaceDescriptionUnix(e->DeviceName, tmp, sizeof(tmp)) == false)
4605 {
4606 StrCpy(tmp, sizeof(tmp), e->DeviceName);
4607 }
4608 }
4609
4610 StrToUni(e->NetworkConnectionName, sizeof(e->NetworkConnectionName), tmp);
4611 #endif
4612 }
4613
4614 FreeToken(o);
4615
4616 return ERR_NO_ERROR;
4617 }
4618
4619 // Add a new local bridge
StAddLocalBridge(ADMIN * a,RPC_LOCALBRIDGE * t)4620 UINT StAddLocalBridge(ADMIN *a, RPC_LOCALBRIDGE *t)
4621 {
4622 if (IsEmptyStr(t->DeviceName) || IsEmptyStr(t->HubName))
4623 {
4624 return ERR_INVALID_PARAMETER;
4625 }
4626
4627 SERVER_ADMIN_ONLY;
4628
4629
4630 if (IsEthSupported() == false)
4631 {
4632 return ERR_LOCAL_BRIDGE_UNSUPPORTED;
4633 }
4634
4635 #ifdef OS_WIN32
4636 if (true)
4637 {
4638 char tmp[MAX_SIZE];
4639 UINT id = Win32EthGetNameAndIdFromCombinedName(tmp, sizeof(tmp), t->DeviceName);
4640
4641 if (id == 0)
4642 {
4643 // If a ID is not specified in Win32, adding will fail
4644 return ERR_OBJECT_NOT_FOUND;
4645 }
4646 }
4647 #endif // OS_WIN32
4648
4649 ALog(a, NULL, "LA_ADD_BRIDGE", t->HubName, t->DeviceName);
4650
4651 AddLocalBridge(a->Server->Cedar, t->HubName, t->DeviceName, false, false, t->TapMode, NULL, false);
4652
4653 IncrementServerConfigRevision(a->Server);
4654
4655 return ERR_NO_ERROR;
4656 }
4657
4658 // Delete a local bridge
StDeleteLocalBridge(ADMIN * a,RPC_LOCALBRIDGE * t)4659 UINT StDeleteLocalBridge(ADMIN *a, RPC_LOCALBRIDGE *t)
4660 {
4661 if (IsEmptyStr(t->DeviceName) || IsEmptyStr(t->HubName))
4662 {
4663 return ERR_INVALID_PARAMETER;
4664 }
4665
4666 SERVER_ADMIN_ONLY;
4667
4668 ALog(a, NULL, "LA_DELETE_BRIDGE", t->HubName, t->DeviceName);
4669
4670 if (DeleteLocalBridge(a->Server->Cedar, t->HubName, t->DeviceName) == false)
4671 {
4672 return ERR_OBJECT_NOT_FOUND;
4673 }
4674
4675 IncrementServerConfigRevision(a->Server);
4676
4677 return ERR_NO_ERROR;
4678 }
4679
4680 // Enumerate local bridges
StEnumLocalBridge(ADMIN * a,RPC_ENUM_LOCALBRIDGE * t)4681 UINT StEnumLocalBridge(ADMIN *a, RPC_ENUM_LOCALBRIDGE *t)
4682 {
4683 UINT i;
4684 CEDAR *c;
4685
4686 if (IsEthSupported() == false)
4687 {
4688 return ERR_LOCAL_BRIDGE_UNSUPPORTED;
4689 }
4690
4691 FreeRpcEnumLocalBridge(t);
4692 Zero(t, sizeof(RPC_ENUM_LOCALBRIDGE));
4693
4694 c = a->Server->Cedar;
4695
4696 LockList(c->LocalBridgeList);
4697 {
4698 t->NumItem = LIST_NUM(c->LocalBridgeList);
4699 t->Items = ZeroMalloc(sizeof(RPC_LOCALBRIDGE) * t->NumItem);
4700
4701 for (i = 0;i < t->NumItem;i++)
4702 {
4703 RPC_LOCALBRIDGE *e = &t->Items[i];
4704 LOCALBRIDGE *br = LIST_DATA(c->LocalBridgeList, i);
4705
4706 if (br->Bridge == false)
4707 {
4708 e->Online = e->Active = false;
4709 }
4710 else
4711 {
4712 e->Online = true;
4713 if (br->Bridge->Active)
4714 {
4715 e->Active = true;
4716 }
4717 else
4718 {
4719 e->Active = false;
4720 }
4721 }
4722 StrCpy(e->DeviceName, sizeof(e->DeviceName), br->DeviceName);
4723 StrCpy(e->HubName, sizeof(e->HubName), br->HubName);
4724
4725 e->TapMode = br->TapMode;
4726 }
4727 }
4728 UnlockList(c->LocalBridgeList);
4729
4730 return ERR_NO_ERROR;
4731 }
4732
4733 // Set syslog function setting
StSetSysLog(ADMIN * a,SYSLOG_SETTING * t)4734 UINT StSetSysLog(ADMIN *a, SYSLOG_SETTING *t)
4735 {
4736 SERVER *s = a->Server;
4737
4738 SERVER_ADMIN_ONLY;
4739
4740 if (GetGlobalServerFlag(GSF_DISABLE_SYSLOG) != 0 && t->SaveType != SYSLOG_NONE)
4741 {
4742 return ERR_NOT_SUPPORTED_FUNCTION_ON_OPENSOURCE;
4743 }
4744
4745 if (GetServerCapsBool(s, "b_support_syslog") == false)
4746 {
4747 return ERR_NOT_SUPPORTED;
4748 }
4749
4750 SiSetSysLogSetting(s, t);
4751
4752 IncrementServerConfigRevision(s);
4753 ALog(a, NULL, "LA_SET_SYSLOG");
4754
4755 return ERR_NO_ERROR;
4756 }
4757
4758 // Get syslog function setting
StGetSysLog(ADMIN * a,SYSLOG_SETTING * t)4759 UINT StGetSysLog(ADMIN *a, SYSLOG_SETTING *t)
4760 {
4761 SERVER *s = a->Server;
4762
4763 SiGetSysLogSetting(s, t);
4764
4765 if (a->ServerAdmin == false)
4766 {
4767 // Hide server name for non-administrator
4768 if (t->SaveType == SYSLOG_NONE)
4769 {
4770 StrCpy(t->Hostname, sizeof(t->Hostname), "");
4771 t->Port = 0;
4772 }
4773 else
4774 {
4775 StrCpy(t->Hostname, sizeof(t->Hostname), "Secret");
4776 t->Port = 0;
4777 }
4778 }
4779
4780 return ERR_NO_ERROR;
4781 }
4782
4783 // Set keep-alive function setting
StSetKeep(ADMIN * a,RPC_KEEP * t)4784 UINT StSetKeep(ADMIN *a, RPC_KEEP *t)
4785 {
4786 SERVER *s = a->Server;
4787
4788 if (t->UseKeepConnect)
4789 {
4790 if (IsEmptyStr(t->KeepConnectHost) ||
4791 t->KeepConnectPort == 0 ||
4792 t->KeepConnectPort >= 65536)
4793 {
4794 return ERR_INVALID_PARAMETER;
4795 }
4796 }
4797
4798 SERVER_ADMIN_ONLY;
4799
4800 Lock(s->Keep->lock);
4801 {
4802 KEEP *keep = s->Keep;
4803 keep->Enable = t->UseKeepConnect;
4804 keep->Server = true;
4805 StrCpy(keep->ServerName, sizeof(keep->ServerName), t->KeepConnectHost);
4806 keep->ServerPort = t->KeepConnectPort;
4807 keep->UdpMode = t->KeepConnectProtocol;
4808 keep->Interval = t->KeepConnectInterval * 1000;
4809 if (keep->Interval < 5000)
4810 {
4811 keep->Interval = 5000;
4812 }
4813 else if (keep->Interval > 600000)
4814 {
4815 keep->Interval = 600000;
4816 }
4817 }
4818 Unlock(s->Keep->lock);
4819
4820 ALog(a, NULL, "LA_SET_KEEP");
4821
4822 IncrementServerConfigRevision(s);
4823
4824 return ERR_NO_ERROR;
4825 }
4826
4827 // Get keep-alive function setting
StGetKeep(ADMIN * a,RPC_KEEP * t)4828 UINT StGetKeep(ADMIN *a, RPC_KEEP *t)
4829 {
4830 SERVER *s = a->Server;
4831
4832 Zero(t, sizeof(RPC_KEEP));
4833
4834 Lock(s->Keep->lock);
4835 {
4836 KEEP *k = s->Keep;
4837 t->UseKeepConnect = k->Enable;
4838 StrCpy(t->KeepConnectHost, sizeof(t->KeepConnectHost), k->ServerName);
4839 t->KeepConnectPort = k->ServerPort;
4840 t->KeepConnectProtocol = k->UdpMode;
4841 t->KeepConnectInterval = k->Interval / 1000;
4842 }
4843 Unlock(s->Keep->lock);
4844
4845 return ERR_NO_ERROR;
4846 }
4847
4848 // Delete IP address table entry
StDeleteIpTable(ADMIN * a,RPC_DELETE_TABLE * t)4849 UINT StDeleteIpTable(ADMIN *a, RPC_DELETE_TABLE *t)
4850 {
4851 SERVER *s = a->Server;
4852 CEDAR *c = s->Cedar;
4853 HUB *h = NULL;
4854 UINT ret = ERR_NO_ERROR;
4855
4856 CHECK_RIGHT;
4857
4858 LockHubList(c);
4859 {
4860 h = GetHub(c, t->HubName);
4861 }
4862 UnlockHubList(c);
4863
4864 if (h == NULL)
4865 {
4866 return ERR_HUB_NOT_FOUND;
4867 }
4868
4869 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_delete_iptable") != 0)
4870 {
4871 ReleaseHub(h);
4872 return ERR_NOT_ENOUGH_RIGHT;
4873 }
4874
4875 LockList(h->IpTable);
4876 {
4877 if (IsInListKey(h->IpTable, t->Key))
4878 {
4879 IP_TABLE_ENTRY *e = ListKeyToPointer(h->IpTable, t->Key);
4880 Free(e);
4881 Delete(h->IpTable, e);
4882 }
4883 else
4884 {
4885 ret = ERR_OBJECT_NOT_FOUND;
4886 }
4887 }
4888 UnlockList(h->IpTable);
4889
4890 if (ret == ERR_OBJECT_NOT_FOUND)
4891 {
4892 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
4893 {
4894 UINT i;
4895 LockList(s->FarmMemberList);
4896 {
4897 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
4898 {
4899 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
4900 if (f->Me == false)
4901 {
4902 SiCallDeleteIpTable(s, f, t->HubName, t->Key);
4903 ret = ERR_NO_ERROR;
4904 }
4905 }
4906 }
4907 UnlockList(s->FarmMemberList);
4908 }
4909 }
4910
4911 ReleaseHub(h);
4912
4913 return ret;
4914 }
4915
4916 // Get local IP address table
SiEnumIpTable(SERVER * s,char * hubname,RPC_ENUM_IP_TABLE * t)4917 UINT SiEnumIpTable(SERVER *s, char *hubname, RPC_ENUM_IP_TABLE *t)
4918 {
4919 CEDAR *c;
4920 UINT i;
4921 HUB *h = NULL;
4922 // Validate arguments
4923 if (s == NULL || hubname == NULL || t == NULL)
4924 {
4925 return ERR_INTERNAL_ERROR;
4926 }
4927
4928 c = s->Cedar;
4929
4930 LockHubList(c);
4931 {
4932 h = GetHub(c, hubname);
4933 }
4934 UnlockHubList(c);
4935
4936 if (h == NULL)
4937 {
4938 return ERR_HUB_NOT_FOUND;
4939 }
4940
4941 StrCpy(t->HubName, sizeof(t->HubName), hubname);
4942
4943 LockList(h->IpTable);
4944 {
4945 t->NumIpTable = LIST_NUM(h->IpTable);
4946 t->IpTables = ZeroMalloc(sizeof(RPC_ENUM_IP_TABLE_ITEM) * t->NumIpTable);
4947
4948 for (i = 0;i < t->NumIpTable;i++)
4949 {
4950 RPC_ENUM_IP_TABLE_ITEM *e = &t->IpTables[i];
4951 IP_TABLE_ENTRY *table = LIST_DATA(h->IpTable, i);
4952
4953 e->Key = POINTER_TO_KEY(table);
4954 StrCpy(e->SessionName, sizeof(e->SessionName), table->Session->Name);
4955 e->Ip = IPToUINT(&table->Ip);
4956 Copy(&e->IpV6, &table->Ip, sizeof(IP));
4957 Copy(&e->IpAddress, &table->Ip, sizeof(IP));
4958 e->DhcpAllocated = table->DhcpAllocated;
4959 e->CreatedTime = TickToTime(table->CreatedTime);
4960 e->UpdatedTime = TickToTime(table->UpdatedTime);
4961
4962 GetMachineName(e->RemoteHostname, sizeof(e->RemoteHostname));
4963 }
4964 }
4965 UnlockList(h->IpTable);
4966
4967 ReleaseHub(h);
4968
4969 return ERR_NO_ERROR;
4970 }
4971
4972 // Get IP address table
StEnumIpTable(ADMIN * a,RPC_ENUM_IP_TABLE * t)4973 UINT StEnumIpTable(ADMIN *a, RPC_ENUM_IP_TABLE *t)
4974 {
4975 SERVER *s = a->Server;
4976 CEDAR *c = s->Cedar;
4977 UINT ret = ERR_NO_ERROR;
4978 char hubname[MAX_HUBNAME_LEN + 1];
4979 UINT i;
4980
4981 CHECK_RIGHT;
4982
4983 // Get local IP address table
4984 StrCpy(hubname, sizeof(hubname), t->HubName);
4985 FreeRpcEnumIpTable(t);
4986 Zero(t, sizeof(RPC_ENUM_IP_TABLE));
4987 StrCpy(t->HubName, sizeof(t->HubName), hubname);
4988
4989 ret = SiEnumIpTable(s, hubname, t);
4990 if (ret != ERR_NO_ERROR)
4991 {
4992 return ret;
4993 }
4994
4995 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
4996 {
4997 // Get remote IP address table
4998 LockList(s->FarmMemberList);
4999 {
5000 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
5001 {
5002 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
5003 if (f->Me == false)
5004 {
5005 RPC_ENUM_IP_TABLE tmp;
5006
5007 Zero(&tmp, sizeof(tmp));
5008
5009 SiCallEnumIpTable(s, f, hubname, &tmp);
5010
5011 AdjoinRpcEnumIpTable(t, &tmp);
5012 FreeRpcEnumIpTable(&tmp);
5013 }
5014 }
5015 }
5016 UnlockList(s->FarmMemberList);
5017 }
5018
5019 return ret;
5020 }
5021
5022 // Delete MAC address table entry
StDeleteMacTable(ADMIN * a,RPC_DELETE_TABLE * t)5023 UINT StDeleteMacTable(ADMIN *a, RPC_DELETE_TABLE *t)
5024 {
5025 SERVER *s = a->Server;
5026 CEDAR *c = s->Cedar;
5027 HUB *h = NULL;
5028 UINT ret = ERR_NO_ERROR;
5029
5030 CHECK_RIGHT;
5031
5032 LockHubList(c);
5033 {
5034 h = GetHub(c, t->HubName);
5035 }
5036 UnlockHubList(c);
5037
5038 if (h == NULL)
5039 {
5040 return ERR_HUB_NOT_FOUND;
5041 }
5042
5043 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_delete_mactable") != 0)
5044 {
5045 ReleaseHub(h);
5046 return ERR_NOT_ENOUGH_RIGHT;
5047 }
5048
5049 LockHashList(h->MacHashTable);
5050 {
5051 if (IsInHashListKey(h->MacHashTable, t->Key))
5052 {
5053 MAC_TABLE_ENTRY *e = HashListKeyToPointer(h->MacHashTable, t->Key);
5054 DeleteHash(h->MacHashTable, e);
5055 Free(e);
5056 }
5057 else
5058 {
5059 ret = ERR_OBJECT_NOT_FOUND;
5060 }
5061 }
5062 UnlockHashList(h->MacHashTable);
5063
5064 if (ret == ERR_OBJECT_NOT_FOUND)
5065 {
5066 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
5067 {
5068 UINT i;
5069 LockList(s->FarmMemberList);
5070 {
5071 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
5072 {
5073 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
5074 if (f->Me == false)
5075 {
5076 SiCallDeleteMacTable(s, f, t->HubName, t->Key);
5077 ret = ERR_NO_ERROR;
5078 }
5079 }
5080 }
5081 UnlockList(s->FarmMemberList);
5082 }
5083 }
5084
5085 ReleaseHub(h);
5086
5087 return ret;
5088 }
5089
5090 // Get local MAC address table
SiEnumMacTable(SERVER * s,char * hubname,RPC_ENUM_MAC_TABLE * t)5091 UINT SiEnumMacTable(SERVER *s, char *hubname, RPC_ENUM_MAC_TABLE *t)
5092 {
5093 CEDAR *c;
5094 UINT i;
5095 HUB *h = NULL;
5096 // Validate arguments
5097 if (s == NULL || hubname == NULL || t == NULL)
5098 {
5099 return ERR_INTERNAL_ERROR;
5100 }
5101
5102 c = s->Cedar;
5103
5104 LockHubList(c);
5105 {
5106 h = GetHub(c, hubname);
5107 }
5108 UnlockHubList(c);
5109
5110 if (h == NULL)
5111 {
5112 return ERR_HUB_NOT_FOUND;
5113 }
5114
5115 StrCpy(t->HubName, sizeof(t->HubName), hubname);
5116
5117 LockHashList(h->MacHashTable);
5118 {
5119 MAC_TABLE_ENTRY **pp = (MAC_TABLE_ENTRY **)HashListToArray(h->MacHashTable, &t->NumMacTable);
5120 t->MacTables = ZeroMalloc(sizeof(RPC_ENUM_MAC_TABLE_ITEM) * t->NumMacTable);
5121
5122 for (i = 0;i < t->NumMacTable;i++)
5123 {
5124 RPC_ENUM_MAC_TABLE_ITEM *e = &t->MacTables[i];
5125 MAC_TABLE_ENTRY *mac = pp[i];
5126
5127 e->Key = POINTER_TO_KEY(mac);
5128 StrCpy(e->SessionName, sizeof(e->SessionName), mac->Session->Name);
5129 Copy(e->MacAddress, mac->MacAddress, sizeof(e->MacAddress));
5130 e->CreatedTime = TickToTime(mac->CreatedTime);
5131 e->UpdatedTime = TickToTime(mac->UpdatedTime);
5132 e->VlanId = mac->VlanId;
5133
5134 GetMachineName(e->RemoteHostname, sizeof(e->RemoteHostname));
5135 }
5136
5137 Free(pp);
5138 }
5139 UnlockHashList(h->MacHashTable);
5140
5141 ReleaseHub(h);
5142
5143 return ERR_NO_ERROR;
5144 }
5145
5146 // Get MAC address table
StEnumMacTable(ADMIN * a,RPC_ENUM_MAC_TABLE * t)5147 UINT StEnumMacTable(ADMIN *a, RPC_ENUM_MAC_TABLE *t)
5148 {
5149 SERVER *s = a->Server;
5150 CEDAR *c = s->Cedar;
5151 HUB *h = NULL;
5152 UINT ret = ERR_NO_ERROR;
5153 char hubname[MAX_HUBNAME_LEN + 1];
5154 UINT i;
5155
5156 CHECK_RIGHT;
5157
5158 // Get local MAC address table
5159 StrCpy(hubname, sizeof(hubname), t->HubName);
5160 FreeRpcEnumMacTable(t);
5161 Zero(t, sizeof(RPC_ENUM_MAC_TABLE));
5162
5163 ret = SiEnumMacTable(s, hubname, t);
5164 if (ret != ERR_NO_ERROR)
5165 {
5166 return ret;
5167 }
5168
5169 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
5170 {
5171 // Get remote MAC address table
5172 LockList(s->FarmMemberList);
5173 {
5174 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
5175 {
5176 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
5177 if (f->Me == false)
5178 {
5179 RPC_ENUM_MAC_TABLE tmp;
5180
5181 Zero(&tmp, sizeof(tmp));
5182
5183 SiCallEnumMacTable(s, f, hubname, &tmp);
5184
5185 AdjoinRpcEnumMacTable(t, &tmp);
5186 FreeRpcEnumMacTable(&tmp);
5187 }
5188 }
5189 }
5190 UnlockList(s->FarmMemberList);
5191 }
5192
5193 return ret;
5194 }
5195
5196 // Delete a session
StDeleteSession(ADMIN * a,RPC_DELETE_SESSION * t)5197 UINT StDeleteSession(ADMIN *a, RPC_DELETE_SESSION *t)
5198 {
5199 SERVER *s = a->Server;
5200 CEDAR *c = s->Cedar;
5201 HUB *h = NULL;
5202 UINT ret = ERR_NO_ERROR;
5203 char hubname[MAX_HUBNAME_LEN + 1];
5204 char name[MAX_SESSION_NAME_LEN + 1];
5205 SESSION *sess;
5206
5207 if (IsEmptyStr(t->Name))
5208 {
5209 return ERR_INVALID_PARAMETER;
5210 }
5211
5212 StrCpy(hubname, sizeof(hubname), t->HubName);
5213 StrCpy(name, sizeof(name), t->Name);
5214
5215 CHECK_RIGHT;
5216
5217 LockHubList(c);
5218 {
5219 h = GetHub(c, t->HubName);
5220 }
5221 UnlockHubList(c);
5222
5223 if (h == NULL)
5224 {
5225 return ERR_HUB_NOT_FOUND;
5226 }
5227
5228 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_disconnect_session") != 0)
5229 {
5230 ReleaseHub(h);
5231 return ERR_NOT_ENOUGH_RIGHT;
5232 }
5233
5234 sess = GetSessionByName(h, name);
5235
5236 if (sess == NULL)
5237 {
5238 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
5239 {
5240 // Cluster controller
5241 UINT i;
5242 LockList(s->FarmMemberList);
5243 {
5244 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
5245 {
5246 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
5247 if (f->Me == false)
5248 {
5249 // Try to disconnect
5250 SiCallDeleteSession(s, f, t->HubName, t->Name);
5251 }
5252 }
5253 }
5254 UnlockList(s->FarmMemberList);
5255 }
5256 else
5257 {
5258 ret = ERR_OBJECT_NOT_FOUND;
5259 }
5260 }
5261 else
5262 {
5263 if (sess->LinkModeServer)
5264 {
5265 ret = ERR_LINK_CANT_DISCONNECT;
5266 }
5267 else if (sess->SecureNATMode)
5268 {
5269 ret = ERR_SNAT_CANT_DISCONNECT;
5270 }
5271 else if (sess->BridgeMode)
5272 {
5273 ret = ERR_BRIDGE_CANT_DISCONNECT;
5274 }
5275 else if (sess->L3SwitchMode)
5276 {
5277 ret = ERR_LAYER3_CANT_DISCONNECT;
5278 }
5279 else
5280 {
5281 StopSession(sess);
5282 }
5283 ReleaseSession(sess);
5284 }
5285
5286 if (ret != ERR_NO_ERROR)
5287 {
5288 ALog(a, h, "LA_DELETE_SESSION", t->Name);
5289 }
5290
5291 ReleaseHub(h);
5292
5293 return ret;
5294 }
5295
5296 // Get session status
StGetSessionStatus(ADMIN * a,RPC_SESSION_STATUS * t)5297 UINT StGetSessionStatus(ADMIN *a, RPC_SESSION_STATUS *t)
5298 {
5299 SERVER *s = a->Server;
5300 CEDAR *c = s->Cedar;
5301 HUB *h = NULL;
5302 UINT ret = ERR_NO_ERROR;
5303 char hubname[MAX_HUBNAME_LEN + 1];
5304 char name[MAX_SESSION_NAME_LEN + 1];
5305 SESSION *sess;
5306
5307 StrCpy(hubname, sizeof(hubname), t->HubName);
5308 StrCpy(name, sizeof(name), t->Name);
5309
5310 if (IsEmptyStr(t->Name))
5311 {
5312 return ERR_INVALID_PARAMETER;
5313 }
5314
5315 CHECK_RIGHT;
5316
5317 LockHubList(c);
5318 {
5319 h = GetHub(c, t->HubName);
5320 }
5321 UnlockHubList(c);
5322
5323 if (h == NULL)
5324 {
5325 return ERR_HUB_NOT_FOUND;
5326 }
5327
5328 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_query_session") != 0)
5329 {
5330 ReleaseHub(h);
5331 return ERR_NOT_ENOUGH_RIGHT;
5332 }
5333
5334 FreeRpcSessionStatus(t);
5335 Zero(t, sizeof(RPC_SESSION_STATUS));
5336 StrCpy(t->HubName, sizeof(t->HubName), hubname);
5337 StrCpy(t->Name, sizeof(t->Name), name);
5338
5339 sess = GetSessionByName(h, t->Name);
5340
5341 if (sess == NULL)
5342 {
5343 if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER)
5344 {
5345 // Session is not found
5346 ret = ERR_OBJECT_NOT_FOUND;
5347 }
5348 else
5349 {
5350 UINT i;
5351 // Try to find the session on other cluster member
5352 LockList(s->FarmMemberList);
5353 {
5354 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
5355 {
5356 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
5357 if (f->Me == false)
5358 {
5359 RPC_SESSION_STATUS tmp;
5360 Zero(&tmp, sizeof(tmp));
5361 StrCpy(tmp.HubName, sizeof(tmp.HubName), t->HubName);
5362 StrCpy(tmp.Name, sizeof(tmp.Name), t->Name);
5363
5364 if (SiCallGetSessionStatus(s, f, &tmp))
5365 {
5366 if (StrLen(tmp.HubName) != 0)
5367 {
5368 // Success to get session status
5369 Copy(t, &tmp, sizeof(RPC_SESSION_STATUS));
5370 break;
5371 }
5372 else
5373 {
5374 FreeRpcSessionStatus(&tmp);
5375 }
5376 }
5377 }
5378 }
5379
5380 if (i == LIST_NUM(s->FarmMemberList))
5381 {
5382 // not found after all
5383 //
5384 ret = ERR_OBJECT_NOT_FOUND;
5385 }
5386 }
5387 UnlockList(s->FarmMemberList);
5388 }
5389 }
5390 else
5391 {
5392 SESSION *s = sess;
5393
5394 Lock(s->lock);
5395 {
5396 StrCpy(t->Username, sizeof(t->Username), s->Username);
5397 StrCpy(t->RealUsername, sizeof(t->RealUsername), s->UserNameReal);
5398 StrCpy(t->GroupName, sizeof(t->GroupName), s->GroupName);
5399 Copy(&t->NodeInfo, &s->NodeInfo, sizeof(NODE_INFO));
5400
5401 if (s->Connection != NULL)
5402 {
5403 t->ClientIp = IPToUINT(&s->Connection->ClientIp);
5404 if (IsIP6(&s->Connection->ClientIp))
5405 {
5406 Copy(&t->ClientIp6, &s->Connection->ClientIp.ipv6_addr, sizeof(t->ClientIp6));
5407 }
5408
5409 CopyIP(&t->ClientIpAddress, &s->Connection->ClientIp);
5410
5411 StrCpy(t->ClientHostName, sizeof(t->ClientHostName), s->Connection->ClientHostname);
5412 }
5413 }
5414 Unlock(s->lock);
5415
5416 CiGetSessionStatus(&t->Status, s);
5417
5418 ReleaseSession(s);
5419 }
5420
5421 ReleaseHub(h);
5422
5423 return ret;
5424 }
5425
5426 // Main routine of session enumeration
SiEnumSessionMain(SERVER * s,RPC_ENUM_SESSION * t)5427 void SiEnumSessionMain(SERVER *s, RPC_ENUM_SESSION *t)
5428 {
5429 char hubname[MAX_HUBNAME_LEN + 1];
5430 UINT ret = ERR_NO_ERROR;
5431 UINT num;
5432 UINT i;
5433 // Validate arguments
5434 if (s == NULL || t == NULL)
5435 {
5436 return;
5437 }
5438
5439 StrCpy(hubname, sizeof(hubname), t->HubName);
5440
5441 FreeRpcEnumSession(t);
5442 Zero(t, sizeof(RPC_ENUM_SESSION));
5443 StrCpy(t->HubName, sizeof(t->HubName), hubname);
5444
5445 // Local session enumeration
5446 num = 0;
5447 SiEnumLocalSession(s, hubname, t);
5448
5449 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
5450 {
5451 LIST *fm_list;
5452
5453 fm_list = NewListFast(NULL);
5454
5455 // Remote session enumeration
5456 LockList(s->FarmMemberList);
5457 {
5458 while (true)
5459 {
5460 bool escape = true;
5461
5462 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
5463 {
5464 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
5465
5466 if (IsInList(fm_list, f) == false)
5467 {
5468 Add(fm_list, f);
5469 escape = false;
5470
5471 if (f->Me == false)
5472 {
5473 RPC_ENUM_SESSION tmp;
5474
5475 Zero(&tmp, sizeof(tmp));
5476
5477 SiCallEnumSession(s, f, hubname, &tmp);
5478
5479 AdjoinRpcEnumSession(t, &tmp);
5480 FreeRpcEnumSession(&tmp);
5481 }
5482
5483 break;
5484 }
5485 }
5486
5487 if (escape)
5488 {
5489 break;
5490 }
5491
5492 UnlockList(s->FarmMemberList);
5493 LockList(s->FarmMemberList);
5494 }
5495 }
5496 UnlockList(s->FarmMemberList);
5497
5498 ReleaseList(fm_list);
5499 }
5500 }
5501
5502 // Enumerate sessions
StEnumSession(ADMIN * a,RPC_ENUM_SESSION * t)5503 UINT StEnumSession(ADMIN *a, RPC_ENUM_SESSION *t)
5504 {
5505 SERVER *s = a->Server;
5506 CEDAR *c = s->Cedar;
5507 HUB *h = NULL;
5508 UINT ret = ERR_NO_ERROR;
5509
5510 CHECK_RIGHT;
5511
5512 LockHubList(c);
5513 {
5514 h = GetHub(c, t->HubName);
5515 }
5516 UnlockHubList(c);
5517
5518 if (h == NULL)
5519 {
5520 return ERR_HUB_NOT_FOUND;
5521 }
5522
5523 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_enum_session") != 0)
5524 {
5525 ReleaseHub(h);
5526 return ERR_NOT_ENOUGH_RIGHT;
5527 }
5528
5529 SiEnumSessionMain(s, t);
5530
5531 ReleaseHub(h);
5532
5533 return ret;
5534 }
5535
5536 // Enumerate groups
StEnumGroup(ADMIN * a,RPC_ENUM_GROUP * t)5537 UINT StEnumGroup(ADMIN *a, RPC_ENUM_GROUP *t)
5538 {
5539 SERVER *s = a->Server;
5540 CEDAR *c = s->Cedar;
5541 HUB *h = NULL;
5542 UINT ret = ERR_NO_ERROR;
5543 char hubname[MAX_HUBNAME_LEN + 1];
5544
5545 StrCpy(hubname, sizeof(hubname), t->HubName);
5546
5547 CHECK_RIGHT;
5548
5549 NO_SUPPORT_FOR_BRIDGE;
5550 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
5551 {
5552 return ERR_NOT_SUPPORTED;
5553 }
5554
5555
5556 LockHubList(c);
5557 {
5558 h = GetHub(c, t->HubName);
5559 }
5560 UnlockHubList(c);
5561
5562 if (h == NULL)
5563 {
5564 return ERR_HUB_NOT_FOUND;
5565 }
5566
5567 AcLock(h);
5568 {
5569 UINT i, j;
5570
5571 FreeRpcEnumGroup(t);
5572 Zero(t, sizeof(RPC_ENUM_GROUP));
5573 StrCpy(t->HubName, sizeof(t->HubName), hubname);
5574
5575 t->NumGroup = LIST_NUM(h->HubDb->GroupList);
5576 t->Groups = ZeroMalloc(sizeof(RPC_ENUM_GROUP_ITEM) * t->NumGroup);
5577
5578 for (i = 0;i < t->NumGroup;i++)
5579 {
5580 RPC_ENUM_GROUP_ITEM *e = &t->Groups[i];
5581 USERGROUP *g = LIST_DATA(h->HubDb->GroupList, i);
5582
5583 Lock(g->lock);
5584 {
5585 StrCpy(e->Name, sizeof(e->Name), g->Name);
5586 UniStrCpy(e->Realname, sizeof(e->Realname), g->RealName);
5587 UniStrCpy(e->Note, sizeof(e->Note), g->Note);
5588 if (g->Policy != NULL)
5589 {
5590 if (g->Policy->Access == false)
5591 {
5592 e->DenyAccess = true;
5593 }
5594 }
5595 }
5596 Unlock(g->lock);
5597
5598 e->NumUsers = 0;
5599
5600
5601 LockList(h->HubDb->UserList);
5602 {
5603 for (j = 0;j < LIST_NUM(h->HubDb->UserList);j++)
5604 {
5605 USER *u = LIST_DATA(h->HubDb->UserList, j);
5606
5607 Lock(u->lock);
5608 {
5609 if (u->Group == g)
5610 {
5611 e->NumUsers++;
5612 }
5613 }
5614 Unlock(u->lock);
5615 }
5616 }
5617 UnlockList(h->HubDb->UserList);
5618 }
5619 }
5620 AcUnlock(h);
5621
5622 ReleaseHub(h);
5623
5624 return ERR_NO_ERROR;
5625 }
5626
5627 // Delete a group
StDeleteGroup(ADMIN * a,RPC_DELETE_USER * t)5628 UINT StDeleteGroup(ADMIN *a, RPC_DELETE_USER *t)
5629 {
5630 SERVER *s = a->Server;
5631 CEDAR *c = s->Cedar;
5632 HUB *h = NULL;
5633 UINT ret = ERR_NO_ERROR;
5634
5635 if (IsEmptyStr(t->Name) || IsSafeStr(t->Name) == false)
5636 {
5637 return ERR_INVALID_PARAMETER;
5638 }
5639
5640 CHECK_RIGHT;
5641
5642 NO_SUPPORT_FOR_BRIDGE;
5643 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
5644 {
5645 return ERR_NOT_SUPPORTED;
5646 }
5647
5648 LockHubList(c);
5649 {
5650 h = GetHub(c, t->HubName);
5651 }
5652 UnlockHubList(c);
5653
5654 if (h == NULL)
5655 {
5656 return ERR_HUB_NOT_FOUND;
5657 }
5658
5659 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_groups") != 0)
5660 {
5661 ReleaseHub(h);
5662 return ERR_NOT_ENOUGH_RIGHT;
5663 }
5664
5665 AcLock(h);
5666 {
5667 if (AcDeleteGroup(h, t->Name) == false)
5668 {
5669 ret = ERR_OBJECT_NOT_FOUND;
5670 }
5671 }
5672 AcUnlock(h);
5673
5674 if (ret == ERR_NO_ERROR)
5675 {
5676 ALog(a, h, "LA_DELETE_GROUP", t->Name);
5677 }
5678
5679 ReleaseHub(h);
5680
5681 IncrementServerConfigRevision(s);
5682
5683 return ret;
5684 }
5685
5686 // Get group information
StGetGroup(ADMIN * a,RPC_SET_GROUP * t)5687 UINT StGetGroup(ADMIN *a, RPC_SET_GROUP *t)
5688 {
5689 SERVER *s = a->Server;
5690 CEDAR *c = s->Cedar;
5691 HUB *h = NULL;
5692 UINT ret = ERR_NO_ERROR;
5693 char hubname[MAX_HUBNAME_LEN + 1];
5694
5695 if (IsEmptyStr(t->Name) || IsSafeStr(t->Name) == false)
5696 {
5697 return ERR_INVALID_PARAMETER;
5698 }
5699
5700 CHECK_RIGHT;
5701 NO_SUPPORT_FOR_BRIDGE;
5702 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
5703 {
5704 return ERR_NOT_SUPPORTED;
5705 }
5706
5707 StrCpy(hubname, sizeof(hubname), t->HubName);
5708
5709 LockHubList(c);
5710 {
5711 h = GetHub(c, t->HubName);
5712 }
5713 UnlockHubList(c);
5714
5715 if (h == NULL)
5716 {
5717 return ERR_HUB_NOT_FOUND;
5718 }
5719
5720 AcLock(h);
5721 {
5722 USERGROUP *g = AcGetGroup(h, t->Name);
5723
5724 if (g == NULL)
5725 {
5726 ret = ERR_OBJECT_NOT_FOUND;
5727 }
5728 else
5729 {
5730 FreeRpcSetGroup(t);
5731 Zero(t, sizeof(RPC_SET_GROUP));
5732
5733 StrCpy(t->HubName, sizeof(t->HubName), hubname);
5734
5735 Lock(g->lock);
5736 {
5737 StrCpy(t->Name, sizeof(t->Name), g->Name);
5738 UniStrCpy(t->Realname, sizeof(t->Realname), g->RealName);
5739 UniStrCpy(t->Note, sizeof(t->Note), g->Note);
5740 Copy(&t->Traffic, g->Traffic, sizeof(TRAFFIC));
5741 }
5742 Unlock(g->lock);
5743
5744 t->Policy = GetGroupPolicy(g);
5745
5746 ReleaseGroup(g);
5747 }
5748 }
5749 AcUnlock(h);
5750
5751 ReleaseHub(h);
5752
5753 return ret;
5754 }
5755
5756 // Set group setting
StSetGroup(ADMIN * a,RPC_SET_GROUP * t)5757 UINT StSetGroup(ADMIN *a, RPC_SET_GROUP *t)
5758 {
5759 SERVER *s = a->Server;
5760 CEDAR *c = s->Cedar;
5761 HUB *h = NULL;
5762 UINT ret = ERR_NO_ERROR;
5763
5764 if (IsEmptyStr(t->Name) || IsSafeStr(t->Name) == false)
5765 {
5766 return ERR_INVALID_PARAMETER;
5767 }
5768
5769 CHECK_RIGHT;
5770 NO_SUPPORT_FOR_BRIDGE;
5771 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
5772 {
5773 return ERR_NOT_SUPPORTED;
5774 }
5775
5776 LockHubList(c);
5777 {
5778 h = GetHub(c, t->HubName);
5779 }
5780 UnlockHubList(c);
5781
5782 if (h == NULL)
5783 {
5784 return ERR_HUB_NOT_FOUND;
5785 }
5786
5787 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_groups") != 0)
5788 {
5789 ReleaseHub(h);
5790 return ERR_NOT_ENOUGH_RIGHT;
5791 }
5792
5793 AcLock(h);
5794 {
5795 USERGROUP *g = AcGetGroup(h, t->Name);
5796 if (g == NULL)
5797 {
5798 ret = ERR_OBJECT_NOT_FOUND;
5799 }
5800 else
5801 {
5802 Lock(g->lock);
5803 {
5804 Free(g->RealName);
5805 Free(g->Note);
5806 g->RealName = UniCopyStr(t->Realname);
5807 g->Note = UniCopyStr(t->Note);
5808 }
5809 Unlock(g->lock);
5810
5811 SetGroupPolicy(g, t->Policy);
5812
5813 ReleaseGroup(g);
5814
5815 ALog(a, h, "LA_SET_GROUP", t->Name);
5816 }
5817 }
5818 AcUnlock(h);
5819
5820 ReleaseHub(h);
5821
5822 IncrementServerConfigRevision(s);
5823
5824 return ret;
5825 }
5826
5827 // Create a group
StCreateGroup(ADMIN * a,RPC_SET_GROUP * t)5828 UINT StCreateGroup(ADMIN *a, RPC_SET_GROUP *t)
5829 {
5830 SERVER *s = a->Server;
5831 CEDAR *c = s->Cedar;
5832 HUB *h = NULL;
5833 UINT ret = ERR_NO_ERROR;
5834
5835 if (IsEmptyStr(t->Name) || IsSafeStr(t->Name) == false)
5836 {
5837 return ERR_INVALID_PARAMETER;
5838 }
5839
5840 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
5841 {
5842 return ERR_NOT_FARM_CONTROLLER;
5843 }
5844
5845 CHECK_RIGHT;
5846
5847 NO_SUPPORT_FOR_BRIDGE;
5848 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
5849 {
5850 return ERR_NOT_SUPPORTED;
5851 }
5852
5853 LockHubList(c);
5854 {
5855 h = GetHub(c, t->HubName);
5856 }
5857 UnlockHubList(c);
5858
5859 if (h == NULL)
5860 {
5861 return ERR_HUB_NOT_FOUND;
5862 }
5863
5864 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_groups") != 0)
5865 {
5866 ReleaseHub(h);
5867 return ERR_NOT_ENOUGH_RIGHT;
5868 }
5869
5870 AcLock(h);
5871 {
5872 if (AcIsGroup(h, t->Name))
5873 {
5874 ret = ERR_GROUP_ALREADY_EXISTS;
5875 }
5876 else
5877 {
5878 USERGROUP *g = NewGroup(t->Name, t->Realname, t->Note);
5879 SetGroupPolicy(g, t->Policy);
5880
5881 if ((LIST_NUM(h->HubDb->GroupList) >= GetServerCapsInt(a->Server, "i_max_users_per_hub")) ||
5882 ((GetHubAdminOption(h, "max_groups") != 0) && (LIST_NUM(h->HubDb->GroupList) >= GetHubAdminOption(h, "max_groups"))))
5883 {
5884 ret = ERR_TOO_MANY_GROUP;
5885 }
5886 else
5887 {
5888 AcAddGroup(h, g);
5889 }
5890
5891 ReleaseGroup(g);
5892
5893 ALog(a, h, "LA_CREATE_GROUP", t->Name);
5894 }
5895 }
5896 AcUnlock(h);
5897
5898 ReleaseHub(h);
5899
5900 IncrementServerConfigRevision(s);
5901
5902 return ret;
5903 }
5904
5905 // Enumerate users
StEnumUser(ADMIN * a,RPC_ENUM_USER * t)5906 UINT StEnumUser(ADMIN *a, RPC_ENUM_USER *t)
5907 {
5908 SERVER *s = a->Server;
5909 CEDAR *c = s->Cedar;
5910 HUB *h = NULL;
5911 UINT ret = ERR_NO_ERROR;
5912 char hubname[MAX_HUBNAME_LEN + 1];
5913 UINT i, num;
5914
5915 CHECK_RIGHT;
5916 NO_SUPPORT_FOR_BRIDGE;
5917 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
5918 {
5919 return ERR_NOT_SUPPORTED;
5920 }
5921
5922 LockHubList(c);
5923 {
5924 h = GetHub(c, t->HubName);
5925 }
5926 UnlockHubList(c);
5927
5928 if (h == NULL)
5929 {
5930 return ERR_HUB_NOT_FOUND;
5931 }
5932
5933 FreeRpcEnumUser(t);
5934
5935 StrCpy(hubname, sizeof(hubname), t->HubName);
5936
5937 Zero(t, sizeof(RPC_ENUM_USER));
5938 StrCpy(t->HubName, sizeof(t->HubName), hubname);
5939
5940 LockList(h->HubDb->UserList);
5941 {
5942 num = LIST_NUM(h->HubDb->UserList);
5943
5944 t->NumUser = num;
5945 t->Users = ZeroMalloc(sizeof(RPC_ENUM_USER_ITEM) * num);
5946
5947 for (i = 0;i < num;i++)
5948 {
5949 USER *u = LIST_DATA(h->HubDb->UserList, i);
5950
5951 Lock(u->lock);
5952 {
5953 RPC_ENUM_USER_ITEM *e = &t->Users[i];
5954
5955 StrCpy(e->Name, sizeof(e->Name), u->Name);
5956 StrCpy(e->GroupName, sizeof(e->GroupName), u->GroupName);
5957 UniStrCpy(e->Realname, sizeof(e->Realname), u->RealName);
5958 UniStrCpy(e->Note, sizeof(e->Note), u->Note);
5959 e->AuthType = u->AuthType;
5960 e->LastLoginTime = u->LastLoginTime;
5961 e->NumLogin = u->NumLogin;
5962
5963 if (u->Policy != NULL)
5964 {
5965 e->DenyAccess = u->Policy->Access ? false : true;
5966 }
5967
5968 Copy(&e->Traffic, u->Traffic, sizeof(TRAFFIC));
5969 e->IsTrafficFilled = true;
5970
5971 e->Expires = u->ExpireTime;
5972 e->IsExpiresFilled = true;
5973 }
5974 Unlock(u->lock);
5975 }
5976 }
5977 UnlockList(h->HubDb->UserList);
5978
5979 ReleaseHub(h);
5980
5981 IncrementServerConfigRevision(s);
5982
5983 return ERR_NO_ERROR;
5984 }
5985
5986 // Delete a user
StDeleteUser(ADMIN * a,RPC_DELETE_USER * t)5987 UINT StDeleteUser(ADMIN *a, RPC_DELETE_USER *t)
5988 {
5989 SERVER *s = a->Server;
5990 CEDAR *c = s->Cedar;
5991 HUB *h = NULL;
5992 UINT ret = ERR_NO_ERROR;
5993
5994
5995 if (IsEmptyStr(t->Name) || IsUserName(t->Name) == false)
5996 {
5997 return ERR_INVALID_PARAMETER;
5998 }
5999
6000 CHECK_RIGHT;
6001 NO_SUPPORT_FOR_BRIDGE;
6002 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
6003 {
6004 return ERR_NOT_SUPPORTED;
6005 }
6006
6007 LockHubList(c);
6008 {
6009 h = GetHub(c, t->HubName);
6010 }
6011 UnlockHubList(c);
6012
6013 if (h == NULL)
6014 {
6015 return ERR_HUB_NOT_FOUND;
6016 }
6017
6018 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_users") != 0)
6019 {
6020 ReleaseHub(h);
6021 return ERR_NOT_ENOUGH_RIGHT;
6022 }
6023
6024 ALog(a, h, "LA_DELETE_USER", t->Name);
6025
6026 AcLock(h);
6027 {
6028 if (AcDeleteUser(h, t->Name) == false)
6029 {
6030 ret = ERR_OBJECT_NOT_FOUND;
6031 }
6032 }
6033 AcUnlock(h);
6034
6035 ReleaseHub(h);
6036
6037 IncrementServerConfigRevision(s);
6038
6039 return ret;
6040 }
6041
6042 // Get user setting
StGetUser(ADMIN * a,RPC_SET_USER * t)6043 UINT StGetUser(ADMIN *a, RPC_SET_USER *t)
6044 {
6045 SERVER *s = a->Server;
6046 CEDAR *c = s->Cedar;
6047 HUB *h = NULL;
6048 UINT ret = ERR_NO_ERROR;
6049 USER *u = NULL;
6050 USERGROUP *g = NULL;
6051 char name[MAX_USERNAME_LEN + 1];
6052 char hubname[MAX_HUBNAME_LEN + 1];
6053 StrCpy(name, sizeof(name), t->Name);
6054 StrCpy(hubname, sizeof(hubname), t->HubName);
6055
6056 if (IsEmptyStr(t->Name) || IsUserName(t->Name) == false)
6057 {
6058 return ERR_INVALID_PARAMETER;
6059 }
6060
6061 CHECK_RIGHT;
6062 NO_SUPPORT_FOR_BRIDGE;
6063 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
6064 {
6065 return ERR_NOT_SUPPORTED;
6066 }
6067
6068 FreeRpcSetUser(t);
6069 Zero(t, sizeof(RPC_SET_USER));
6070 StrCpy(t->HubName, sizeof(t->HubName), hubname);
6071 StrCpy(t->Name, sizeof(t->Name), name);
6072
6073 LockHubList(c);
6074 {
6075 h = GetHub(c, hubname);
6076 }
6077 UnlockHubList(c);
6078
6079 if (h == NULL)
6080 {
6081 return ERR_HUB_NOT_FOUND;
6082 }
6083
6084 AcLock(h);
6085 {
6086 u = AcGetUser(h, name);
6087 if (u == NULL)
6088 {
6089 ret = ERR_OBJECT_NOT_FOUND;
6090 }
6091 else
6092 {
6093 Lock(u->lock);
6094 {
6095 StrCpy(t->GroupName, sizeof(t->GroupName), u->GroupName);
6096 UniStrCpy(t->Realname, sizeof(t->Realname), u->RealName);
6097 UniStrCpy(t->Note, sizeof(t->Note), u->Note);
6098 t->CreatedTime = u->CreatedTime;
6099 t->UpdatedTime = u->UpdatedTime;
6100 t->ExpireTime = u->ExpireTime;
6101
6102 t->AuthType = u->AuthType;
6103 t->AuthData = CopyAuthData(u->AuthData, t->AuthType);
6104 t->NumLogin = u->NumLogin;
6105 Copy(&t->Traffic, u->Traffic, sizeof(TRAFFIC));
6106 if (u->Policy != NULL)
6107 {
6108 t->Policy = ClonePolicy(u->Policy);
6109 }
6110 }
6111 Unlock(u->lock);
6112
6113 ReleaseUser(u);
6114 }
6115 }
6116 AcUnlock(h);
6117
6118 ReleaseHub(h);
6119
6120 return ret;
6121 }
6122
6123 // Set user setting
StSetUser(ADMIN * a,RPC_SET_USER * t)6124 UINT StSetUser(ADMIN *a, RPC_SET_USER *t)
6125 {
6126 SERVER *s = a->Server;
6127 CEDAR *c = s->Cedar;
6128 HUB *h = NULL;
6129 UINT ret = ERR_NO_ERROR;
6130 USER *u = NULL;
6131 USERGROUP *g = NULL;
6132
6133
6134 if (IsEmptyStr(t->Name) || IsUserName(t->Name) == false)
6135 {
6136 return ERR_INVALID_PARAMETER;
6137 }
6138
6139 NO_SUPPORT_FOR_BRIDGE;
6140 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
6141 {
6142 return ERR_NOT_SUPPORTED;
6143 }
6144
6145 CHECK_RIGHT;
6146
6147 if (GetGlobalServerFlag(GSF_DISABLE_RADIUS_AUTH) != 0)
6148 {
6149 if (t->AuthType == AUTHTYPE_USERCERT || t->AuthType == AUTHTYPE_RADIUS || t->AuthType == AUTHTYPE_ROOTCERT || t->AuthType == AUTHTYPE_NT)
6150 {
6151 return ERR_NOT_SUPPORTED_AUTH_ON_OPENSOURCE;
6152 }
6153 }
6154
6155 if (StrCmpi(t->Name, "*") == 0)
6156 {
6157 if (t->AuthType != AUTHTYPE_RADIUS && t->AuthType != AUTHTYPE_NT)
6158 {
6159 return ERR_INVALID_PARAMETER;
6160 }
6161 }
6162
6163 if (t->AuthType == AUTHTYPE_USERCERT)
6164 {
6165 AUTHUSERCERT *c = t->AuthData;
6166 if (c != NULL && c->UserX != NULL &&
6167 c->UserX->is_compatible_bit == false)
6168 {
6169 return ERR_NOT_RSA_1024;
6170 }
6171 if (c == NULL || c->UserX == NULL)
6172 {
6173 return ERR_INVALID_PARAMETER;
6174 }
6175 }
6176
6177 LockHubList(c);
6178 {
6179 h = GetHub(c, t->HubName);
6180 }
6181 UnlockHubList(c);
6182
6183 if (h == NULL)
6184 {
6185 return ERR_HUB_NOT_FOUND;
6186 }
6187
6188 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_users") != 0)
6189 {
6190 ReleaseHub(h);
6191 return ERR_NOT_ENOUGH_RIGHT;
6192 }
6193
6194 AcLock(h);
6195 {
6196 u = AcGetUser(h, t->Name);
6197 if (u == NULL)
6198 {
6199 ret = ERR_OBJECT_NOT_FOUND;
6200 }
6201 else
6202 {
6203 Lock(u->lock);
6204 {
6205 if (StrLen(t->GroupName) != 0)
6206 {
6207 g = AcGetGroup(h, t->GroupName);
6208
6209 if (g != NULL)
6210 {
6211 JoinUserToGroup(u, g);
6212 ReleaseGroup(g);
6213 }
6214 else
6215 {
6216 ret = ERR_GROUP_NOT_FOUND;
6217 }
6218 }
6219 else
6220 {
6221 JoinUserToGroup(u, NULL);
6222 }
6223
6224 if (ret != ERR_GROUP_NOT_FOUND)
6225 {
6226 Free(u->RealName);
6227 Free(u->Note);
6228 u->RealName = UniCopyStr(t->Realname);
6229 u->Note = UniCopyStr(t->Note);
6230 SetUserAuthData(u, t->AuthType, CopyAuthData(t->AuthData, t->AuthType));
6231 u->ExpireTime = t->ExpireTime;
6232 u->UpdatedTime = SystemTime64();
6233
6234 SetUserPolicy(u, t->Policy);
6235 }
6236 }
6237 Unlock(u->lock);
6238
6239 IncrementServerConfigRevision(s);
6240
6241 ReleaseUser(u);
6242 }
6243 }
6244 AcUnlock(h);
6245
6246 if (ret == ERR_NO_ERROR)
6247 {
6248 ALog(a, h, "LA_SET_USER", t->Name);
6249 }
6250
6251 ReleaseHub(h);
6252
6253 return ret;
6254 }
6255
6256 // Create a user
StCreateUser(ADMIN * a,RPC_SET_USER * t)6257 UINT StCreateUser(ADMIN *a, RPC_SET_USER *t)
6258 {
6259 SERVER *s = a->Server;
6260 CEDAR *c = s->Cedar;
6261 HUB *h = NULL;
6262 UINT ret = ERR_NO_ERROR;
6263 USER *u;
6264 USERGROUP *g = NULL;
6265
6266
6267 if (IsEmptyStr(t->Name) || IsUserName(t->Name) == false)
6268 {
6269 return ERR_INVALID_PARAMETER;
6270 }
6271
6272 NO_SUPPORT_FOR_BRIDGE;
6273 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
6274 {
6275 return ERR_NOT_SUPPORTED;
6276 }
6277
6278 CHECK_RIGHT;
6279
6280 if (GetGlobalServerFlag(GSF_DISABLE_RADIUS_AUTH) != 0)
6281 {
6282 if (t->AuthType == AUTHTYPE_USERCERT || t->AuthType == AUTHTYPE_RADIUS || t->AuthType == AUTHTYPE_ROOTCERT || t->AuthType == AUTHTYPE_NT)
6283 {
6284 return ERR_NOT_SUPPORTED_AUTH_ON_OPENSOURCE;
6285 }
6286 }
6287
6288 if (t->AuthType == AUTHTYPE_USERCERT)
6289 {
6290 AUTHUSERCERT *c = t->AuthData;
6291 if (c != NULL && c->UserX != NULL &&
6292 c->UserX->is_compatible_bit == false)
6293 {
6294 return ERR_NOT_RSA_1024;
6295 }
6296 if (c == NULL || c->UserX == NULL)
6297 {
6298 return ERR_INVALID_PARAMETER;
6299 }
6300 }
6301
6302 if (IsUserName(t->Name) == false)
6303 {
6304 return ERR_INVALID_PARAMETER;
6305 }
6306
6307 if (StrCmpi(t->Name, "*") == 0)
6308 {
6309 if (t->AuthType != AUTHTYPE_RADIUS && t->AuthType != AUTHTYPE_NT)
6310 {
6311 return ERR_INVALID_PARAMETER;
6312 }
6313 }
6314
6315 LockHubList(c);
6316 {
6317 h = GetHub(c, t->HubName);
6318 }
6319 UnlockHubList(c);
6320
6321 if (h == NULL)
6322 {
6323 return ERR_HUB_NOT_FOUND;
6324 }
6325
6326 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_users") != 0)
6327 {
6328 ReleaseHub(h);
6329 return ERR_NOT_ENOUGH_RIGHT;
6330 }
6331
6332 u = NewUser(t->Name, t->Realname, t->Note, t->AuthType, CopyAuthData(t->AuthData, t->AuthType));
6333 if (u == NULL)
6334 {
6335 ReleaseHub(h);
6336 return ERR_INTERNAL_ERROR;
6337 }
6338
6339 u->ExpireTime = t->ExpireTime;
6340
6341 SetUserPolicy(u, t->Policy);
6342
6343 AcLock(h);
6344 {
6345 if ((LIST_NUM(h->HubDb->UserList) >= GetServerCapsInt(a->Server, "i_max_users_per_hub")) ||
6346 ((GetHubAdminOption(h, "max_users") != 0) && (LIST_NUM(h->HubDb->UserList) >= GetHubAdminOption(h, "max_users"))))
6347 {
6348 ret = ERR_TOO_MANY_USER;
6349 }
6350 else if (SiTooManyUserObjectsInServer(s, false))
6351 {
6352 ret = ERR_TOO_MANY_USERS_CREATED;
6353 ALog(a, h, "ERR_128");
6354 }
6355 else if (AcIsUser(h, t->Name))
6356 {
6357 ret = ERR_USER_ALREADY_EXISTS;
6358 }
6359 else
6360 {
6361 if (StrLen(t->GroupName) != 0)
6362 {
6363 g = AcGetGroup(h, t->GroupName);
6364 if (g == NULL)
6365 {
6366 ret = ERR_GROUP_NOT_FOUND;
6367 }
6368 }
6369
6370 if (ret != ERR_GROUP_NOT_FOUND)
6371 {
6372 if (g != NULL)
6373 {
6374 JoinUserToGroup(u, g);
6375 ReleaseGroup(g);
6376 }
6377
6378 AcAddUser(h, u);
6379 ALog(a, h, "LA_CREATE_USER", t->Name);
6380
6381 IncrementServerConfigRevision(s);
6382 }
6383 }
6384 }
6385 AcUnlock(h);
6386
6387 ReleaseUser(u);
6388
6389 ReleaseHub(h);
6390
6391 return ret;
6392 }
6393
6394 // Get access list
StEnumAccess(ADMIN * a,RPC_ENUM_ACCESS_LIST * t)6395 UINT StEnumAccess(ADMIN *a, RPC_ENUM_ACCESS_LIST *t)
6396 {
6397 SERVER *s = a->Server;
6398 CEDAR *c = s->Cedar;
6399 HUB *h;
6400 UINT i;
6401 char hubname[MAX_HUBNAME_LEN + 1];
6402
6403 CHECK_RIGHT;
6404 NO_SUPPORT_FOR_BRIDGE;
6405 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
6406 {
6407 return ERR_NOT_SUPPORTED;
6408 }
6409
6410 LockHubList(c);
6411 {
6412 h = GetHub(c, t->HubName);
6413 }
6414 UnlockHubList(c);
6415
6416 if (h == NULL)
6417 {
6418 return ERR_HUB_NOT_FOUND;
6419 }
6420
6421 StrCpy(hubname, sizeof(hubname), t->HubName);
6422 FreeRpcEnumAccessList(t);
6423 Zero(t, sizeof(RPC_ENUM_ACCESS_LIST));
6424 StrCpy(t->HubName, sizeof(t->HubName), hubname);
6425
6426 LockList(h->AccessList);
6427 {
6428 t->NumAccess = LIST_NUM(h->AccessList);
6429 t->Accesses = ZeroMalloc(sizeof(ACCESS) * t->NumAccess);
6430
6431 for (i = 0;i < LIST_NUM(h->AccessList);i++)
6432 {
6433 ACCESS *a = &t->Accesses[i];
6434 Copy(a, LIST_DATA(h->AccessList, i), sizeof(ACCESS));
6435 a->UniqueId = HashPtrToUINT(LIST_DATA(h->AccessList, i));
6436 }
6437 }
6438 UnlockList(h->AccessList);
6439
6440 ReleaseHub(h);
6441
6442 return ERR_NO_ERROR;
6443 }
6444
6445 // Delete access list entry
StDeleteAccess(ADMIN * a,RPC_DELETE_ACCESS * t)6446 UINT StDeleteAccess(ADMIN *a, RPC_DELETE_ACCESS *t)
6447 {
6448 SERVER *s = a->Server;
6449 CEDAR *c = s->Cedar;
6450 HUB *h;
6451 UINT i;
6452 bool exists;
6453
6454
6455 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
6456 {
6457 return ERR_NOT_FARM_CONTROLLER;
6458 }
6459
6460 CHECK_RIGHT;
6461 NO_SUPPORT_FOR_BRIDGE;
6462
6463 LockHubList(c);
6464 {
6465 h = GetHub(c, t->HubName);
6466 }
6467 UnlockHubList(c);
6468
6469 if (h == NULL)
6470 {
6471 return ERR_HUB_NOT_FOUND;
6472 }
6473
6474 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_access_list") != 0)
6475 {
6476 ReleaseHub(h);
6477 return ERR_NOT_ENOUGH_RIGHT;
6478 }
6479
6480 exists = false;
6481
6482 LockList(h->AccessList);
6483 {
6484 for (i = 0;i < LIST_NUM(h->AccessList);i++)
6485 {
6486 ACCESS *access = LIST_DATA(h->AccessList, i);
6487
6488 if ((t->Id < MAX_ACCESSLISTS && access->Id == t->Id) ||
6489 (t->Id >= MAX_ACCESSLISTS && HashPtrToUINT(access) == t->Id))
6490 {
6491 Free(access);
6492 Delete(h->AccessList, access);
6493 exists = true;
6494
6495 break;
6496 }
6497 }
6498 }
6499 UnlockList(h->AccessList);
6500
6501 if (exists == false)
6502 {
6503 ReleaseHub(h);
6504 return ERR_OBJECT_NOT_FOUND;
6505 }
6506
6507 ALog(a, h, "LA_DELETE_ACCESS");
6508
6509 IncrementServerConfigRevision(s);
6510
6511 ReleaseHub(h);
6512
6513 return ERR_NO_ERROR;
6514 }
6515
6516 // Set access list
StSetAccessList(ADMIN * a,RPC_ENUM_ACCESS_LIST * t)6517 UINT StSetAccessList(ADMIN *a, RPC_ENUM_ACCESS_LIST *t)
6518 {
6519 SERVER *s = a->Server;
6520 CEDAR *c = s->Cedar;
6521 HUB *h;
6522 UINT i;
6523 bool no_jitter = false;
6524 bool no_include = false;
6525 UINT ret = ERR_NO_ERROR;
6526
6527
6528 NO_SUPPORT_FOR_BRIDGE;
6529 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
6530 {
6531 return ERR_NOT_SUPPORTED;
6532 }
6533
6534 CHECK_RIGHT;
6535
6536 if (t->NumAccess > GetServerCapsInt(a->Server, "i_max_access_lists"))
6537 {
6538 return ERR_TOO_MANY_ACCESS_LIST;
6539 }
6540
6541 LockHubList(c);
6542 {
6543 h = GetHub(c, t->HubName);
6544 }
6545 UnlockHubList(c);
6546
6547 if (h == NULL)
6548 {
6549 return ERR_HUB_NOT_FOUND;
6550 }
6551
6552 no_jitter = GetHubAdminOption(h, "no_delay_jitter_packet_loss");
6553 no_include = GetHubAdminOption(h, "no_access_list_include_file");
6554
6555 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_access_list") != 0)
6556 {
6557 ReleaseHub(h);
6558 return ERR_NOT_ENOUGH_RIGHT;
6559 }
6560
6561 if (a->ServerAdmin == false && GetHubAdminOption(h, "max_accesslists") != 0 &&
6562 t->NumAccess > GetHubAdminOption(h, "max_accesslists"))
6563 {
6564 ReleaseHub(h);
6565 return ERR_TOO_MANY_ACCESS_LIST;
6566 }
6567
6568 LockList(h->AccessList);
6569 {
6570 UINT i;
6571
6572 // Confirm whether the access list of form which cannot handle by the old client already exists
6573 if (a->ClientBuild != 0)
6574 {
6575 if (a->ClientBuild < 6560)
6576 {
6577 for (i = 0;i < LIST_NUM(h->AccessList);i++)
6578 {
6579 ACCESS *access = LIST_DATA(h->AccessList, i);
6580 if (access->IsIPv6 ||
6581 access->Jitter != 0 || access->Loss != 0 || access->Delay != 0)
6582 {
6583 ret = ERR_VERSION_INVALID;
6584 break;
6585 }
6586 }
6587 }
6588
6589 if (a->ClientBuild < 8234)
6590 {
6591 for (i = 0;i < LIST_NUM(h->AccessList);i++)
6592 {
6593 ACCESS *access = LIST_DATA(h->AccessList, i);
6594
6595 if (IsEmptyStr(access->RedirectUrl) == false)
6596 {
6597 ret = ERR_VERSION_INVALID;
6598 break;
6599 }
6600 }
6601 }
6602 }
6603
6604 if (ret == ERR_NO_ERROR)
6605 {
6606 // Delete whole access list
6607 for (i = 0;i < LIST_NUM(h->AccessList);i++)
6608 {
6609 ACCESS *access = LIST_DATA(h->AccessList, i);
6610 Free(access);
6611 }
6612
6613 DeleteAll(h->AccessList);
6614 }
6615 }
6616
6617 if (ret == ERR_NO_ERROR)
6618 {
6619 ALog(a, h, "LA_SET_ACCESS_LIST", t->NumAccess);
6620
6621 // Add whole access list
6622 for (i = 0;i < t->NumAccess;i++)
6623 {
6624 ACCESS *a = &t->Accesses[i];
6625
6626 if (no_jitter)
6627 {
6628 a->Jitter = a->Loss = a->Delay = 0;
6629 }
6630
6631 if (no_include)
6632 {
6633 if (StartWith(a->SrcUsername, ACCESS_LIST_INCLUDED_PREFIX) ||
6634 StartWith(a->SrcUsername, ACCESS_LIST_EXCLUDED_PREFIX))
6635 {
6636 ClearStr(a->SrcUsername, sizeof(a->SrcUsername));
6637 }
6638
6639 if (StartWith(a->DestUsername, ACCESS_LIST_INCLUDED_PREFIX) ||
6640 StartWith(a->DestUsername, ACCESS_LIST_EXCLUDED_PREFIX))
6641 {
6642 ClearStr(a->DestUsername, sizeof(a->DestUsername));
6643 }
6644 }
6645
6646 if (i == (t->NumAccess - 1))
6647 {
6648 Sort(h->AccessList);
6649 }
6650
6651 AddAccessListEx(h, a, ((i != (t->NumAccess - 1)) ? true : false), ((i != (t->NumAccess - 1)) ? true : false));
6652 }
6653
6654 UnlockList(h->AccessList);
6655
6656 IncrementServerConfigRevision(s);
6657
6658 h->CurrentVersion++;
6659 SiHubUpdateProc(h);
6660 }
6661 else
6662 {
6663 UnlockList(h->AccessList);
6664 }
6665
6666 ReleaseHub(h);
6667
6668 return ret;
6669 }
6670
6671 // Add access list entry
StAddAccess(ADMIN * a,RPC_ADD_ACCESS * t)6672 UINT StAddAccess(ADMIN *a, RPC_ADD_ACCESS *t)
6673 {
6674 SERVER *s = a->Server;
6675 CEDAR *c = s->Cedar;
6676 HUB *h;
6677 bool no_jitter = false;
6678 bool no_include = false;
6679
6680
6681 NO_SUPPORT_FOR_BRIDGE;
6682 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
6683 {
6684 return ERR_NOT_SUPPORTED;
6685 }
6686
6687 CHECK_RIGHT;
6688
6689 LockHubList(c);
6690 {
6691 h = GetHub(c, t->HubName);
6692 }
6693 UnlockHubList(c);
6694
6695 if (h == NULL)
6696 {
6697 return ERR_HUB_NOT_FOUND;
6698 }
6699
6700 no_jitter = GetHubAdminOption(h, "no_delay_jitter_packet_loss");
6701 no_include = GetHubAdminOption(h, "no_access_list_include_file");
6702
6703 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_access_list") != 0)
6704 {
6705 ReleaseHub(h);
6706 return ERR_NOT_ENOUGH_RIGHT;
6707 }
6708
6709 if ((LIST_NUM(h->AccessList) >= GetServerCapsInt(a->Server, "i_max_access_lists") ||
6710 (GetHubAdminOption(h, "max_accesslists") != 0) && (LIST_NUM(h->AccessList) >= GetHubAdminOption(h, "max_accesslists"))))
6711 {
6712 ReleaseHub(h);
6713 return ERR_TOO_MANY_ACCESS_LIST;
6714 }
6715
6716 ALog(a, h, "LA_ADD_ACCESS");
6717
6718 if (no_jitter)
6719 {
6720 t->Access.Jitter = t->Access.Delay = t->Access.Loss = 0;
6721 }
6722
6723 if (no_include)
6724 {
6725 if (no_include)
6726 {
6727 if (StartWith(t->Access.SrcUsername, ACCESS_LIST_INCLUDED_PREFIX) ||
6728 StartWith(t->Access.SrcUsername, ACCESS_LIST_EXCLUDED_PREFIX))
6729 {
6730 ClearStr(t->Access.SrcUsername, sizeof(t->Access.SrcUsername));
6731 }
6732
6733 if (StartWith(t->Access.DestUsername, ACCESS_LIST_INCLUDED_PREFIX) ||
6734 StartWith(t->Access.DestUsername, ACCESS_LIST_EXCLUDED_PREFIX))
6735 {
6736 ClearStr(t->Access.DestUsername, sizeof(t->Access.DestUsername));
6737 }
6738 }
6739 }
6740
6741 AddAccessList(h, &t->Access);
6742
6743 h->CurrentVersion++;
6744 SiHubUpdateProc(h);
6745
6746 ReleaseHub(h);
6747
6748 IncrementServerConfigRevision(s);
6749
6750 return ERR_NO_ERROR;
6751 }
6752
6753 // Rename link (cascade connection)
StRenameLink(ADMIN * a,RPC_RENAME_LINK * t)6754 UINT StRenameLink(ADMIN *a, RPC_RENAME_LINK *t)
6755 {
6756 UINT i;
6757 SERVER *s = a->Server;
6758 CEDAR *c = s->Cedar;
6759 HUB *h;
6760 UINT ret = ERR_NO_ERROR;
6761 LINK *k;
6762 bool exists = false;
6763
6764 if (UniIsEmptyStr(t->OldAccountName) || UniIsEmptyStr(t->NewAccountName))
6765 {
6766 return ERR_INVALID_PARAMETER;
6767 }
6768
6769 if (s->ServerType != SERVER_TYPE_STANDALONE)
6770 {
6771 return ERR_NOT_SUPPORTED;
6772 }
6773
6774 CHECK_RIGHT;
6775
6776 if (UniStrCmpi(t->NewAccountName, t->OldAccountName) == 0)
6777 {
6778 // Noop if new name is same to old name
6779 return ERR_NO_ERROR;
6780 }
6781
6782 h = GetHub(c, t->HubName);
6783
6784 if (h == NULL)
6785 {
6786 return ERR_HUB_NOT_FOUND;
6787 }
6788
6789 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)
6790 {
6791 ReleaseHub(h);
6792 return ERR_NOT_ENOUGH_RIGHT;
6793 }
6794
6795 k = NULL;
6796
6797 // Find specified link
6798 LockList(h->LinkList);
6799 {
6800 for (i = 0;i < LIST_NUM(h->LinkList);i++)
6801 {
6802 LINK *kk = LIST_DATA(h->LinkList, i);
6803 Lock(kk->lock);
6804 {
6805 if (UniStrCmpi(kk->Option->AccountName, t->OldAccountName) == 0)
6806 {
6807 k = kk;
6808 AddRef(kk->ref);
6809 }
6810 }
6811 Unlock(kk->lock);
6812
6813 if (k != NULL)
6814 {
6815 break;
6816 }
6817 }
6818
6819 exists = false;
6820
6821 if (k != NULL)
6822 {
6823 // Check whether the new link name is same to other links
6824 for (i = 0;i < LIST_NUM(h->LinkList);i++)
6825 {
6826 LINK *kk = LIST_DATA(h->LinkList, i);
6827 Lock(kk->lock);
6828 {
6829 if (UniStrCmpi(kk->Option->AccountName, t->NewAccountName) == 0)
6830 {
6831 // duplicated
6832 exists = true;
6833 }
6834 }
6835 Unlock(kk->lock);
6836 }
6837
6838 if (exists)
6839 {
6840 // Already same name exists
6841 ret = ERR_LINK_ALREADY_EXISTS;
6842 }
6843 else
6844 {
6845 // Do rename
6846 UniStrCpy(k->Option->AccountName, sizeof(k->Option->AccountName), t->NewAccountName);
6847
6848 ALog(a, h, "LA_RENAME_LINK", t->OldAccountName, t->NewAccountName);
6849
6850 IncrementServerConfigRevision(s);
6851 }
6852 }
6853 }
6854 UnlockList(h->LinkList);
6855
6856 if (k == NULL)
6857 {
6858 // specified link is not found
6859 ReleaseHub(h);
6860 return ERR_OBJECT_NOT_FOUND;
6861 }
6862
6863 ReleaseLink(k);
6864
6865 ReleaseHub(h);
6866
6867 return ret;
6868 }
6869
6870 // Delete a link
StDeleteLink(ADMIN * a,RPC_LINK * t)6871 UINT StDeleteLink(ADMIN *a, RPC_LINK *t)
6872 {
6873 UINT i;
6874 SERVER *s = a->Server;
6875 CEDAR *c = s->Cedar;
6876 HUB *h;
6877 UINT ret = ERR_NO_ERROR;
6878 char hubname[MAX_HUBNAME_LEN + 1];
6879 wchar_t accountname[MAX_ACCOUNT_NAME_LEN + 1];
6880 LINK *k;
6881
6882 if (UniIsEmptyStr(t->AccountName))
6883 {
6884 return ERR_INVALID_PARAMETER;
6885 }
6886
6887 if (s->ServerType != SERVER_TYPE_STANDALONE)
6888 {
6889 return ERR_NOT_SUPPORTED;
6890 }
6891
6892 CHECK_RIGHT;
6893
6894 LockHubList(c);
6895 {
6896 h = GetHub(c, t->HubName);
6897 }
6898 UnlockHubList(c);
6899
6900 if (h == NULL)
6901 {
6902 return ERR_HUB_NOT_FOUND;
6903 }
6904
6905 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)
6906 {
6907 ReleaseHub(h);
6908 return ERR_NOT_ENOUGH_RIGHT;
6909 }
6910
6911 StrCpy(hubname, sizeof(hubname), t->HubName);
6912 UniStrCpy(accountname, sizeof(accountname), t->AccountName);
6913 k = NULL;
6914
6915 // Find specified link
6916 LockList(h->LinkList);
6917 {
6918 for (i = 0;i < LIST_NUM(h->LinkList);i++)
6919 {
6920 LINK *kk = LIST_DATA(h->LinkList, i);
6921 Lock(kk->lock);
6922 {
6923 if (UniStrCmpi(kk->Option->AccountName, accountname) == 0)
6924 {
6925 k = kk;
6926 AddRef(kk->ref);
6927 }
6928 }
6929 Unlock(kk->lock);
6930
6931 if (k != NULL)
6932 {
6933 break;
6934 }
6935 }
6936 }
6937 UnlockList(h->LinkList);
6938
6939 if (k == NULL)
6940 {
6941 // Specified link is not found
6942 ReleaseHub(h);
6943
6944 return ERR_OBJECT_NOT_FOUND;
6945 }
6946
6947 k->NoOnline = true;
6948
6949 ALog(a, h, "LA_DELETE_LINK", t->AccountName);
6950
6951 SetLinkOffline(k);
6952
6953 IncrementServerConfigRevision(s);
6954
6955 DelLink(h, k);
6956
6957 ReleaseLink(k);
6958 ReleaseHub(h);
6959
6960 return ret;
6961 }
6962
6963 // Make a link into off-line
StSetLinkOffline(ADMIN * a,RPC_LINK * t)6964 UINT StSetLinkOffline(ADMIN *a, RPC_LINK *t)
6965 {
6966 UINT i;
6967 SERVER *s = a->Server;
6968 CEDAR *c = s->Cedar;
6969 HUB *h;
6970 UINT ret = ERR_NO_ERROR;
6971 char hubname[MAX_HUBNAME_LEN + 1];
6972 wchar_t accountname[MAX_ACCOUNT_NAME_LEN + 1];
6973 LINK *k;
6974
6975
6976 if (UniIsEmptyStr(t->AccountName))
6977 {
6978 return ERR_INVALID_PARAMETER;
6979 }
6980
6981 if (s->ServerType != SERVER_TYPE_STANDALONE)
6982 {
6983 return ERR_NOT_SUPPORTED;
6984 }
6985
6986 CHECK_RIGHT;
6987
6988 LockHubList(c);
6989 {
6990 h = GetHub(c, t->HubName);
6991 }
6992 UnlockHubList(c);
6993
6994 if (h == NULL)
6995 {
6996 return ERR_HUB_NOT_FOUND;
6997 }
6998
6999 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)
7000 {
7001 ReleaseHub(h);
7002 return ERR_NOT_ENOUGH_RIGHT;
7003 }
7004
7005 StrCpy(hubname, sizeof(hubname), t->HubName);
7006 UniStrCpy(accountname, sizeof(accountname), t->AccountName);
7007 k = NULL;
7008
7009 // Find specified link
7010 LockList(h->LinkList);
7011 {
7012 for (i = 0;i < LIST_NUM(h->LinkList);i++)
7013 {
7014 LINK *kk = LIST_DATA(h->LinkList, i);
7015 Lock(kk->lock);
7016 {
7017 if (UniStrCmpi(kk->Option->AccountName, accountname) == 0)
7018 {
7019 k = kk;
7020 AddRef(kk->ref);
7021 }
7022 }
7023 Unlock(kk->lock);
7024
7025 if (k != NULL)
7026 {
7027 break;
7028 }
7029 }
7030 }
7031 UnlockList(h->LinkList);
7032
7033 if (k == NULL)
7034 {
7035 // Link is not found
7036 ReleaseHub(h);
7037
7038 return ERR_OBJECT_NOT_FOUND;
7039 }
7040
7041 ALog(a, h, "LA_SET_LINK_OFFLINE", t->AccountName);
7042
7043 SetLinkOffline(k);
7044
7045 IncrementServerConfigRevision(s);
7046
7047 ReleaseLink(k);
7048 ReleaseHub(h);
7049
7050 return ret;
7051 }
7052
7053 // Make a link into on-line
StSetLinkOnline(ADMIN * a,RPC_LINK * t)7054 UINT StSetLinkOnline(ADMIN *a, RPC_LINK *t)
7055 {
7056 UINT i;
7057 SERVER *s = a->Server;
7058 CEDAR *c = s->Cedar;
7059 HUB *h;
7060 UINT ret = ERR_NO_ERROR;
7061 char hubname[MAX_HUBNAME_LEN + 1];
7062 wchar_t accountname[MAX_ACCOUNT_NAME_LEN + 1];
7063 LINK *k;
7064
7065
7066 if (UniIsEmptyStr(t->AccountName))
7067 {
7068 return ERR_INVALID_PARAMETER;
7069 }
7070
7071 if (s->ServerType != SERVER_TYPE_STANDALONE)
7072 {
7073 return ERR_NOT_SUPPORTED;
7074 }
7075
7076 CHECK_RIGHT;
7077
7078 LockHubList(c);
7079 {
7080 h = GetHub(c, t->HubName);
7081 }
7082 UnlockHubList(c);
7083
7084 if (h == NULL)
7085 {
7086 return ERR_HUB_NOT_FOUND;
7087 }
7088
7089 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)
7090 {
7091 ReleaseHub(h);
7092 return ERR_NOT_ENOUGH_RIGHT;
7093 }
7094
7095 StrCpy(hubname, sizeof(hubname), t->HubName);
7096 UniStrCpy(accountname, sizeof(accountname), t->AccountName);
7097 k = NULL;
7098
7099 // Find specified link
7100 LockList(h->LinkList);
7101 {
7102 for (i = 0;i < LIST_NUM(h->LinkList);i++)
7103 {
7104 LINK *kk = LIST_DATA(h->LinkList, i);
7105 Lock(kk->lock);
7106 {
7107 if (UniStrCmpi(kk->Option->AccountName, accountname) == 0)
7108 {
7109 k = kk;
7110 AddRef(kk->ref);
7111 }
7112 }
7113 Unlock(kk->lock);
7114
7115 if (k != NULL)
7116 {
7117 break;
7118 }
7119 }
7120 }
7121 UnlockList(h->LinkList);
7122
7123 if (k == NULL)
7124 {
7125 // Specified link is not found
7126 ReleaseHub(h);
7127
7128 return ERR_OBJECT_NOT_FOUND;
7129 }
7130
7131 ALog(a, h, "LA_SET_LINK_ONLINE", t->AccountName);
7132
7133 SetLinkOnline(k);
7134
7135 ReleaseLink(k);
7136 ReleaseHub(h);
7137
7138 IncrementServerConfigRevision(s);
7139
7140 return ret;
7141 }
7142
7143 // Get link status
StGetLinkStatus(ADMIN * a,RPC_LINK_STATUS * t)7144 UINT StGetLinkStatus(ADMIN *a, RPC_LINK_STATUS *t)
7145 {
7146 UINT i;
7147 SERVER *s = a->Server;
7148 CEDAR *c = s->Cedar;
7149 HUB *h;
7150 UINT ret = ERR_NO_ERROR;
7151 char hubname[MAX_HUBNAME_LEN + 1];
7152 wchar_t accountname[MAX_ACCOUNT_NAME_LEN + 1];
7153 LINK *k;
7154 SESSION *sess;
7155
7156 if (UniIsEmptyStr(t->AccountName))
7157 {
7158 return ERR_INVALID_PARAMETER;
7159 }
7160
7161 if (s->ServerType != SERVER_TYPE_STANDALONE)
7162 {
7163 return ERR_NOT_SUPPORTED;
7164 }
7165
7166 CHECK_RIGHT;
7167
7168 LockHubList(c);
7169 {
7170 h = GetHub(c, t->HubName);
7171 }
7172 UnlockHubList(c);
7173
7174 if (h == NULL)
7175 {
7176 return ERR_HUB_NOT_FOUND;
7177 }
7178
7179 StrCpy(hubname, sizeof(hubname), t->HubName);
7180 UniStrCpy(accountname, sizeof(accountname), t->AccountName);
7181 FreeRpcLinkStatus(t);
7182 Zero(t, sizeof(RPC_LINK_STATUS));
7183 StrCpy(t->HubName, sizeof(t->HubName), hubname);
7184 UniStrCpy(t->AccountName, sizeof(t->AccountName), accountname);
7185
7186 k = NULL;
7187
7188 // Find the link
7189 LockList(h->LinkList);
7190 {
7191 for (i = 0;i < LIST_NUM(h->LinkList);i++)
7192 {
7193 LINK *kk = LIST_DATA(h->LinkList, i);
7194 Lock(kk->lock);
7195 {
7196 if (UniStrCmpi(kk->Option->AccountName, accountname) == 0)
7197 {
7198 k = kk;
7199 AddRef(kk->ref);
7200 }
7201 }
7202 Unlock(kk->lock);
7203
7204 if (k != NULL)
7205 {
7206 break;
7207 }
7208 }
7209 }
7210 UnlockList(h->LinkList);
7211
7212 if (k == NULL)
7213 {
7214 // Specified link is not found
7215 ReleaseHub(h);
7216
7217 return ERR_OBJECT_NOT_FOUND;
7218 }
7219
7220 // Get status infomation from session
7221 Lock(k->lock);
7222 {
7223 sess = k->ClientSession;
7224 if (sess != NULL)
7225 {
7226 AddRef(sess->ref);
7227 }
7228 }
7229 Unlock(k->lock);
7230
7231 if (sess != NULL && k->Offline == false)
7232 {
7233 CiGetSessionStatus(&t->Status, sess);
7234 }
7235 else
7236 {
7237 ret = ERR_LINK_IS_OFFLINE;
7238 }
7239 ReleaseSession(sess);
7240
7241 ReleaseLink(k);
7242 ReleaseHub(h);
7243
7244 return ret;
7245 }
7246
7247 // Enumerate links
StEnumLink(ADMIN * a,RPC_ENUM_LINK * t)7248 UINT StEnumLink(ADMIN *a, RPC_ENUM_LINK *t)
7249 {
7250 SERVER *s = a->Server;
7251 CEDAR *c = s->Cedar;
7252 HUB *h;
7253 char hubname[MAX_HUBNAME_LEN + 1];
7254 UINT i;
7255
7256 if (s->ServerType != SERVER_TYPE_STANDALONE)
7257 {
7258 return ERR_NOT_SUPPORTED;
7259 }
7260
7261 CHECK_RIGHT;
7262
7263 LockHubList(c);
7264 {
7265 h = GetHub(c, t->HubName);
7266 }
7267 UnlockHubList(c);
7268
7269 if (h == NULL)
7270 {
7271 return ERR_HUB_NOT_FOUND;
7272 }
7273
7274 StrCpy(hubname, sizeof(hubname), t->HubName);
7275 FreeRpcEnumLink(t);
7276 Zero(t, sizeof(RPC_ENUM_LINK));
7277 StrCpy(t->HubName, sizeof(t->HubName), hubname);
7278
7279 LockList(h->LinkList);
7280 {
7281 t->NumLink = LIST_NUM(h->LinkList);
7282 t->Links = ZeroMalloc(sizeof(RPC_ENUM_LINK_ITEM) * t->NumLink);
7283
7284 for (i = 0;i < LIST_NUM(h->LinkList);i++)
7285 {
7286 LINK *k = LIST_DATA(h->LinkList, i);
7287 RPC_ENUM_LINK_ITEM *e = &t->Links[i];
7288
7289 Lock(k->lock);
7290 {
7291 UniStrCpy(e->AccountName, sizeof(e->AccountName), k->Option->AccountName);
7292 StrCpy(e->Hostname, sizeof(e->Hostname), k->Option->Hostname);
7293 StrCpy(e->HubName, sizeof(e->HubName), k->Option->HubName);
7294 e->Online = k->Offline ? false : true;
7295
7296 if (e->Online)
7297 {
7298 if (k->ClientSession != NULL)
7299 {
7300 e->ConnectedTime = TickToTime(k->ClientSession->CurrentConnectionEstablishTime);
7301 e->Connected = (k->ClientSession->ClientStatus == CLIENT_STATUS_ESTABLISHED);
7302 e->LastError = k->ClientSession->Err;
7303 }
7304 }
7305 }
7306 Unlock(k->lock);
7307 }
7308 }
7309 UnlockList(h->LinkList);
7310
7311 ReleaseHub(h);
7312
7313 return ERR_NO_ERROR;
7314 }
7315
7316 // Get link configuration
StGetLink(ADMIN * a,RPC_CREATE_LINK * t)7317 UINT StGetLink(ADMIN *a, RPC_CREATE_LINK *t)
7318 {
7319 SERVER *s = a->Server;
7320 CEDAR *c = s->Cedar;
7321 HUB *h;
7322 UINT ret = ERR_NO_ERROR;
7323 UINT i;
7324 char hubname[MAX_SIZE];
7325 LINK *k;
7326
7327 if (s->ServerType != SERVER_TYPE_STANDALONE)
7328 {
7329 return ERR_NOT_SUPPORTED;
7330 }
7331
7332 CHECK_RIGHT;
7333
7334 if (s->ServerType != SERVER_TYPE_STANDALONE)
7335 {
7336 return ERR_LINK_CANT_CREATE_ON_FARM;
7337 }
7338
7339 LockHubList(c);
7340 {
7341 h = GetHub(c, t->HubName);
7342 }
7343 UnlockHubList(c);
7344
7345 if (h == NULL)
7346 {
7347 return ERR_HUB_NOT_FOUND;
7348 }
7349
7350 k = NULL;
7351
7352 // Find the link
7353 LockList(h->LinkList);
7354 {
7355 for (i = 0;i < LIST_NUM(h->LinkList);i++)
7356 {
7357 LINK *kk = LIST_DATA(h->LinkList, i);
7358 Lock(kk->lock);
7359 {
7360 if (UniStrCmpi(kk->Option->AccountName, t->ClientOption->AccountName) == 0)
7361 {
7362 k = kk;
7363 AddRef(kk->ref);
7364 }
7365 }
7366 Unlock(kk->lock);
7367
7368 if (k != NULL)
7369 {
7370 break;
7371 }
7372 }
7373 }
7374 UnlockList(h->LinkList);
7375
7376 if (k == NULL)
7377 {
7378 // The link is not found
7379 ReleaseHub(h);
7380 return ERR_OBJECT_NOT_FOUND;
7381 }
7382
7383 StrCpy(hubname, sizeof(hubname), t->HubName);
7384 FreeRpcCreateLink(t);
7385 Zero(t, sizeof(RPC_CREATE_LINK));
7386 StrCpy(t->HubName, sizeof(t->HubName), hubname);
7387
7388 Lock(k->lock);
7389 {
7390 // Get configuration
7391 t->Online = k->Offline ? false : true;
7392 t->ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
7393 Copy(t->ClientOption, k->Option, sizeof(CLIENT_OPTION));
7394 t->ClientAuth = CopyClientAuth(k->Auth);
7395 Copy(&t->Policy, k->Policy, sizeof(POLICY));
7396
7397 t->CheckServerCert = k->CheckServerCert;
7398 t->ServerCert = CloneX(k->ServerCert);
7399 }
7400 Unlock(k->lock);
7401
7402 ReleaseLink(k);
7403 ReleaseHub(h);
7404
7405 return ret;
7406 }
7407
7408 // Set link configuration
StSetLink(ADMIN * a,RPC_CREATE_LINK * t)7409 UINT StSetLink(ADMIN *a, RPC_CREATE_LINK *t)
7410 {
7411 SERVER *s = a->Server;
7412 CEDAR *c = s->Cedar;
7413 HUB *h;
7414 UINT ret = ERR_NO_ERROR;
7415 UINT i;
7416 LINK *k;
7417
7418
7419 if (s->ServerType != SERVER_TYPE_STANDALONE)
7420 {
7421 return ERR_NOT_SUPPORTED;
7422 }
7423
7424 CHECK_RIGHT;
7425
7426 if (s->ServerType != SERVER_TYPE_STANDALONE)
7427 {
7428 return ERR_LINK_CANT_CREATE_ON_FARM;
7429 }
7430
7431 LockHubList(c);
7432 {
7433 h = GetHub(c, t->HubName);
7434 }
7435 UnlockHubList(c);
7436
7437 if (h == NULL)
7438 {
7439 return ERR_HUB_NOT_FOUND;
7440 }
7441
7442 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)
7443 {
7444 ReleaseHub(h);
7445 return ERR_NOT_ENOUGH_RIGHT;
7446 }
7447
7448 k = NULL;
7449
7450 // Find the link
7451 LockList(h->LinkList);
7452 {
7453 for (i = 0;i < LIST_NUM(h->LinkList);i++)
7454 {
7455 LINK *kk = LIST_DATA(h->LinkList, i);
7456 Lock(kk->lock);
7457 {
7458 if (UniStrCmpi(kk->Option->AccountName, t->ClientOption->AccountName) == 0)
7459 {
7460 k = kk;
7461 AddRef(kk->ref);
7462 }
7463 }
7464 Unlock(kk->lock);
7465
7466 if (k != NULL)
7467 {
7468 break;
7469 }
7470 }
7471 }
7472 UnlockList(h->LinkList);
7473
7474 if (k == NULL)
7475 {
7476 // The link is not found
7477 ReleaseHub(h);
7478 return ERR_OBJECT_NOT_FOUND;
7479 }
7480
7481 ALog(a, h, "LA_SET_LINK", t->ClientOption->AccountName);
7482
7483 Lock(k->lock);
7484 {
7485 // Update the configuration of the link
7486 if (k->ServerCert != NULL)
7487 {
7488 FreeX(k->ServerCert);
7489 k->ServerCert = NULL;
7490 }
7491
7492 Copy(k->Option, t->ClientOption, sizeof(CLIENT_OPTION));
7493 StrCpy(k->Option->DeviceName, sizeof(k->Option->DeviceName), LINK_DEVICE_NAME);
7494 k->Option->NumRetry = INFINITE;
7495 k->Option->RetryInterval = 10;
7496 k->Option->NoRoutingTracking = true;
7497 CiFreeClientAuth(k->Auth);
7498 k->Auth = CopyClientAuth(t->ClientAuth);
7499
7500 if (t->Policy.Ver3 == false)
7501 {
7502 Copy(k->Policy, &t->Policy, sizeof(UINT) * NUM_POLICY_ITEM_FOR_VER2);
7503 }
7504 else
7505 {
7506 Copy(k->Policy, &t->Policy, sizeof(POLICY));
7507 }
7508
7509 k->Option->RequireBridgeRoutingMode = true; // Enable Bridge / Routing mode
7510 k->Option->RequireMonitorMode = false; // Disable monitor mode
7511
7512 k->CheckServerCert = t->CheckServerCert;
7513 k->ServerCert = CloneX(t->ServerCert);
7514 }
7515 Unlock(k->lock);
7516
7517 IncrementServerConfigRevision(s);
7518
7519 ReleaseLink(k);
7520 ReleaseHub(h);
7521
7522 return ret;
7523 }
7524
7525 // Create a new link(cascade)
StCreateLink(ADMIN * a,RPC_CREATE_LINK * t)7526 UINT StCreateLink(ADMIN *a, RPC_CREATE_LINK *t)
7527 {
7528 SERVER *s = a->Server;
7529 CEDAR *c = s->Cedar;
7530 HUB *h;
7531 UINT ret = ERR_NO_ERROR;
7532 UINT i;
7533 LINK *k;
7534
7535 CHECK_RIGHT;
7536
7537
7538 if (s->ServerType != SERVER_TYPE_STANDALONE)
7539 {
7540 return ERR_LINK_CANT_CREATE_ON_FARM;
7541 }
7542
7543 LockHubList(c);
7544 {
7545 h = GetHub(c, t->HubName);
7546 }
7547 UnlockHubList(c);
7548
7549 if (h == NULL)
7550 {
7551 return ERR_HUB_NOT_FOUND;
7552 }
7553
7554 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)
7555 {
7556 ReleaseHub(h);
7557 return ERR_NOT_ENOUGH_RIGHT;
7558 }
7559
7560 k = NULL;
7561
7562 // Check for existing a link which has same name
7563 LockList(h->LinkList);
7564 {
7565 for (i = 0;i < LIST_NUM(h->LinkList);i++)
7566 {
7567 LINK *kk = LIST_DATA(h->LinkList, i);
7568 Lock(kk->lock);
7569 {
7570 if (UniStrCmpi(kk->Option->AccountName, t->ClientOption->AccountName) == 0)
7571 {
7572 k = kk;
7573 AddRef(kk->ref);
7574 }
7575 }
7576 Unlock(kk->lock);
7577
7578 if (k != NULL)
7579 {
7580 break;
7581 }
7582 }
7583 }
7584 UnlockList(h->LinkList);
7585
7586 if (k != NULL)
7587 {
7588 // There is a link which has same name
7589 ReleaseLink(k);
7590 ReleaseHub(h);
7591 return ERR_LINK_ALREADY_EXISTS;
7592 }
7593
7594 ALog(a, h, "LA_CREATE_LINK", t->ClientOption->AccountName);
7595
7596 // Create a new link
7597 k = NewLink(c, h, t->ClientOption, t->ClientAuth, &t->Policy);
7598
7599 if (k == NULL)
7600 {
7601 // Link creation failed
7602 ret = ERR_INTERNAL_ERROR;
7603 }
7604 else
7605 {
7606 // setting of verifying server certification
7607 //
7608 k->CheckServerCert = t->CheckServerCert;
7609 k->ServerCert = CloneX(t->ServerCert);
7610
7611 // stay this off-line
7612 k->Offline = false;
7613 SetLinkOffline(k);
7614 ReleaseLink(k);
7615
7616 IncrementServerConfigRevision(s);
7617 }
7618
7619 ReleaseHub(h);
7620
7621 return ret;
7622 }
7623
7624 // Delete a CA(Certificate Authority) setting from the hub
StDeleteCa(ADMIN * a,RPC_HUB_DELETE_CA * t)7625 UINT StDeleteCa(ADMIN *a, RPC_HUB_DELETE_CA *t)
7626 {
7627 SERVER *s = a->Server;
7628 CEDAR *c = s->Cedar;
7629 HUB *h;
7630 UINT ret = ERR_NO_ERROR;
7631
7632 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
7633 {
7634 return ERR_NOT_FARM_CONTROLLER;
7635 }
7636
7637 NO_SUPPORT_FOR_BRIDGE;
7638 CHECK_RIGHT;
7639
7640 LockHubList(c);
7641 {
7642 h = GetHub(c, t->HubName);
7643 }
7644 UnlockHubList(c);
7645
7646 if (h == NULL)
7647 {
7648 return ERR_HUB_NOT_FOUND;
7649 }
7650
7651 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_cert_list") != 0)
7652 {
7653 ReleaseHub(h);
7654 return ERR_NOT_ENOUGH_RIGHT;
7655 }
7656
7657 LockList(h->HubDb->RootCertList);
7658 {
7659 if (IsInListKey(h->HubDb->RootCertList, t->Key))
7660 {
7661 X *x = ListKeyToPointer(h->HubDb->RootCertList, t->Key);
7662 Delete(h->HubDb->RootCertList, x);
7663 FreeX(x);
7664
7665 ALog(a, h, "LA_DELETE_CA");
7666
7667 IncrementServerConfigRevision(s);
7668 }
7669 else
7670 {
7671 ret = ERR_OBJECT_NOT_FOUND;
7672 }
7673 }
7674 UnlockList(h->HubDb->RootCertList);
7675
7676 ReleaseHub(h);
7677
7678 return ret;
7679 }
7680
7681 // Get CA(Certificate Authority) setting from the hub
StGetCa(ADMIN * a,RPC_HUB_GET_CA * t)7682 UINT StGetCa(ADMIN *a, RPC_HUB_GET_CA *t)
7683 {
7684 SERVER *s = a->Server;
7685 CEDAR *c = s->Cedar;
7686 HUB *h;
7687 UINT ret = ERR_NO_ERROR;
7688 char hubname[MAX_HUBNAME_LEN + 1];
7689 UINT key;
7690
7691 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
7692 {
7693 return ERR_NOT_FARM_CONTROLLER;
7694 }
7695
7696 NO_SUPPORT_FOR_BRIDGE;
7697
7698 StrCpy(hubname, sizeof(hubname), t->HubName);
7699 key = t->Key;
7700
7701 FreeRpcHubGetCa(t);
7702 Zero(t, sizeof(RPC_HUB_GET_CA));
7703 t->Key = key;
7704 StrCpy(t->HubName, sizeof(t->HubName), hubname);
7705
7706 CHECK_RIGHT;
7707
7708 LockHubList(c);
7709 {
7710 h = GetHub(c, t->HubName);
7711 }
7712 UnlockHubList(c);
7713
7714 if (h == NULL)
7715 {
7716 return ERR_HUB_NOT_FOUND;
7717 }
7718
7719 LockList(h->HubDb->RootCertList);
7720 {
7721 if (IsInListKey(h->HubDb->RootCertList, key))
7722 {
7723 X *x = ListKeyToPointer(h->HubDb->RootCertList, key);
7724
7725 t->Cert = CloneX(x);
7726 }
7727 else
7728 {
7729 ret = ERR_OBJECT_NOT_FOUND;
7730 }
7731 }
7732 UnlockList(h->HubDb->RootCertList);
7733
7734 ReleaseHub(h);
7735
7736 return ret;
7737 }
7738
7739 // Enumerate CA(Certificate Authority) in the hub
StEnumCa(ADMIN * a,RPC_HUB_ENUM_CA * t)7740 UINT StEnumCa(ADMIN *a, RPC_HUB_ENUM_CA *t)
7741 {
7742 SERVER *s = a->Server;
7743 CEDAR *c = s->Cedar;
7744 HUB *h;
7745 char hubname[MAX_HUBNAME_LEN + 1];
7746 UINT i;
7747
7748 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
7749 {
7750 return ERR_NOT_FARM_CONTROLLER;
7751 }
7752
7753 NO_SUPPORT_FOR_BRIDGE;
7754
7755 StrCpy(hubname, sizeof(hubname), t->HubName);
7756
7757 FreeRpcHubEnumCa(t);
7758 Zero(t, sizeof(RPC_HUB_ENUM_CA));
7759
7760 StrCpy(t->HubName, sizeof(t->HubName), hubname);
7761 CHECK_RIGHT;
7762
7763 LockHubList(c);
7764 {
7765 h = GetHub(c, hubname);
7766 }
7767 UnlockHubList(c);
7768
7769 if (h == NULL)
7770 {
7771 return ERR_HUB_NOT_FOUND;
7772 }
7773
7774 Zero(t, sizeof(RPC_HUB_ENUM_CA));
7775 StrCpy(t->HubName, sizeof(t->HubName), hubname);
7776
7777 if (h->HubDb->RootCertList != NULL)
7778 {
7779 LockList(h->HubDb->RootCertList);
7780 {
7781 t->NumCa = LIST_NUM(h->HubDb->RootCertList);
7782 t->Ca = ZeroMalloc(sizeof(RPC_HUB_ENUM_CA_ITEM) * t->NumCa);
7783
7784 for (i = 0;i < t->NumCa;i++)
7785 {
7786 RPC_HUB_ENUM_CA_ITEM *e = &t->Ca[i];
7787 X *x = LIST_DATA(h->HubDb->RootCertList, i);
7788
7789 e->Key = POINTER_TO_KEY(x);
7790 GetAllNameFromNameEx(e->SubjectName, sizeof(e->SubjectName), x->subject_name);
7791 GetAllNameFromNameEx(e->IssuerName, sizeof(e->IssuerName), x->issuer_name);
7792 e->Expires = x->notAfter;
7793 }
7794 }
7795 UnlockList(h->HubDb->RootCertList);
7796 }
7797
7798 ReleaseHub(h);
7799
7800 return ERR_NO_ERROR;
7801 }
7802
7803 // Add CA(Certificate Authority) into the hub
StAddCa(ADMIN * a,RPC_HUB_ADD_CA * t)7804 UINT StAddCa(ADMIN *a, RPC_HUB_ADD_CA *t)
7805 {
7806 SERVER *s = a->Server;
7807 CEDAR *c = s->Cedar;
7808 HUB *h;
7809
7810 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
7811 {
7812 return ERR_NOT_FARM_CONTROLLER;
7813 }
7814
7815 if (c->Bridge)
7816 {
7817 return ERR_NOT_SUPPORTED;
7818 }
7819
7820 if (t->Cert == NULL)
7821 {
7822 return ERR_INVALID_PARAMETER;
7823 }
7824
7825 if (t->Cert->is_compatible_bit == false)
7826 {
7827 return ERR_NOT_RSA_1024;
7828 }
7829
7830 CHECK_RIGHT;
7831
7832 LockHubList(c);
7833 {
7834 h = GetHub(c, t->HubName);
7835 }
7836 UnlockHubList(c);
7837
7838 if (h == NULL)
7839 {
7840 return ERR_HUB_NOT_FOUND;
7841 }
7842
7843 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_cert_list") != 0)
7844 {
7845 ReleaseHub(h);
7846 return ERR_NOT_ENOUGH_RIGHT;
7847 }
7848
7849 IncrementServerConfigRevision(s);
7850
7851 ALog(a, h, "LA_ADD_CA");
7852
7853 AddRootCert(h, t->Cert);
7854
7855 ReleaseHub(h);
7856
7857 return ERR_NO_ERROR;
7858 }
7859
7860 // Get logging configuration of the hub
StGetHubLog(ADMIN * a,RPC_HUB_LOG * t)7861 UINT StGetHubLog(ADMIN *a, RPC_HUB_LOG *t)
7862 {
7863 SERVER *s = a->Server;
7864 CEDAR *c = s->Cedar;
7865 HUB *h;
7866
7867 CHECK_RIGHT;
7868
7869 LockHubList(c);
7870 {
7871 h = GetHub(c, t->HubName);
7872 }
7873 UnlockHubList(c);
7874
7875 if (h == NULL)
7876 {
7877 return ERR_HUB_NOT_FOUND;
7878 }
7879
7880 GetHubLogSetting(h, &t->LogSetting);
7881
7882 ReleaseHub(h);
7883
7884 return ERR_NO_ERROR;
7885 }
7886
7887 // Set logging configuration into the hub
StSetHubLog(ADMIN * a,RPC_HUB_LOG * t)7888 UINT StSetHubLog(ADMIN *a, RPC_HUB_LOG *t)
7889 {
7890 SERVER *s = a->Server;
7891 CEDAR *c = s->Cedar;
7892 HUB *h;
7893
7894 CHECK_RIGHT;
7895
7896
7897 LockHubList(c);
7898 {
7899 h = GetHub(c, t->HubName);
7900 }
7901 UnlockHubList(c);
7902
7903 if (h == NULL)
7904 {
7905 return ERR_HUB_NOT_FOUND;
7906 }
7907
7908 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_log_config") != 0)
7909 {
7910 ReleaseHub(h);
7911 return ERR_NOT_ENOUGH_RIGHT;
7912 }
7913
7914 ALog(a, h, "LA_SET_HUB_LOG");
7915
7916 SetHubLogSettingEx(h, &t->LogSetting,
7917 (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_log_switch_type") != 0));
7918
7919 h->CurrentVersion++;
7920 SiHubUpdateProc(h);
7921
7922 ReleaseHub(h);
7923
7924 IncrementServerConfigRevision(s);
7925
7926 return ERR_NO_ERROR;
7927 }
7928
7929 // Get hub status
StGetHubStatus(ADMIN * a,RPC_HUB_STATUS * t)7930 UINT StGetHubStatus(ADMIN *a, RPC_HUB_STATUS *t)
7931 {
7932 SERVER *s = a->Server;
7933 CEDAR *c = s->Cedar;
7934 HUB *h;
7935
7936 CHECK_RIGHT;
7937
7938 LockHubList(c);
7939 {
7940 h = GetHub(c, t->HubName);
7941 }
7942 UnlockHubList(c);
7943
7944 if (h == NULL)
7945 {
7946 return ERR_HUB_NOT_FOUND;
7947 }
7948
7949 Zero(t, sizeof(RPC_HUB_STATUS));
7950
7951 Lock(h->lock);
7952 {
7953 StrCpy(t->HubName, sizeof(t->HubName), h->Name);
7954 t->HubType = h->Type;
7955 t->Online = h->Offline ? false : true;
7956 t->NumSessions = LIST_NUM(h->SessionList);
7957 t->NumSessionsClient = Count(h->NumSessionsClient);
7958 t->NumSessionsBridge = Count(h->NumSessionsBridge);
7959 t->NumAccessLists = LIST_NUM(h->AccessList);
7960
7961 if (h->HubDb != NULL)
7962 {
7963 t->NumUsers = LIST_NUM(h->HubDb->UserList);
7964 t->NumGroups = LIST_NUM(h->HubDb->GroupList);
7965 }
7966
7967 t->NumMacTables = HASH_LIST_NUM(h->MacHashTable);
7968 t->NumIpTables = LIST_NUM(h->IpTable);
7969
7970 Lock(h->TrafficLock);
7971 {
7972 Copy(&t->Traffic, h->Traffic, sizeof(TRAFFIC));
7973 }
7974 Unlock(h->TrafficLock);
7975
7976 t->NumLogin = h->NumLogin;
7977 t->LastCommTime = h->LastCommTime;
7978 t->LastLoginTime = h->LastLoginTime;
7979 t->CreatedTime = h->CreatedTime;
7980 }
7981 Unlock(h->lock);
7982
7983 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
7984 {
7985 UINT i;
7986 LockList(s->FarmMemberList);
7987 {
7988 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
7989 {
7990 UINT k;
7991 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
7992
7993 if (f->Me == false)
7994 {
7995 LockList(f->HubList);
7996 {
7997 for (k = 0;k < LIST_NUM(f->HubList);k++)
7998 {
7999 HUB_LIST *h = LIST_DATA(f->HubList, k);
8000
8001 if (StrCmpi(h->Name, t->HubName) == 0)
8002 {
8003 t->NumSessions += h->NumSessions;
8004 t->NumSessionsClient += h->NumSessionsClient;
8005 t->NumSessionsBridge += h->NumSessionsBridge;
8006 t->NumMacTables += h->NumMacTables;
8007 t->NumIpTables += h->NumIpTables;
8008 }
8009 }
8010 }
8011 UnlockList(f->HubList);
8012 }
8013 }
8014 }
8015 UnlockList(s->FarmMemberList);
8016 }
8017
8018 if (h->Type != HUB_TYPE_FARM_STATIC)
8019 {
8020 t->SecureNATEnabled = h->EnableSecureNAT;
8021 }
8022
8023 ReleaseHub(h);
8024
8025 return ERR_NO_ERROR;
8026 }
8027
8028 // Enable SecureNAT function of the hub
StEnableSecureNAT(ADMIN * a,RPC_HUB * t)8029 UINT StEnableSecureNAT(ADMIN *a, RPC_HUB *t)
8030 {
8031 SERVER *s = a->Server;
8032 CEDAR *c = s->Cedar;
8033 HUB *h;
8034
8035 CHECK_RIGHT;
8036
8037
8038 LockHubList(c);
8039 {
8040 h = GetHub(c, t->HubName);
8041 }
8042 UnlockHubList(c);
8043
8044 if (h == NULL)
8045 {
8046 return ERR_HUB_NOT_FOUND;
8047 }
8048
8049 if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)
8050 {
8051 ReleaseHub(h);
8052 return ERR_NOT_SUPPORTED;
8053 }
8054 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
8055 {
8056 ReleaseHub(h);
8057 return ERR_NOT_FARM_CONTROLLER;
8058 }
8059
8060 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat") != 0)
8061 {
8062 ReleaseHub(h);
8063 return ERR_NOT_ENOUGH_RIGHT;
8064 }
8065
8066 ALog(a, h, "LA_ENABLE_SNAT");
8067
8068 EnableSecureNAT(h, true);
8069
8070 h->CurrentVersion++;
8071 SiHubUpdateProc(h);
8072
8073 IncrementServerConfigRevision(s);
8074
8075 ReleaseHub(h);
8076
8077 return ERR_NO_ERROR;
8078 }
8079
8080 // Disable the SecureNAT function of the hub
StDisableSecureNAT(ADMIN * a,RPC_HUB * t)8081 UINT StDisableSecureNAT(ADMIN *a, RPC_HUB *t)
8082 {
8083 SERVER *s = a->Server;
8084 CEDAR *c = s->Cedar;
8085 HUB *h;
8086
8087 CHECK_RIGHT;
8088
8089
8090 LockHubList(c);
8091 {
8092 h = GetHub(c, t->HubName);
8093 }
8094 UnlockHubList(c);
8095
8096 if (h == NULL)
8097 {
8098 return ERR_HUB_NOT_FOUND;
8099 }
8100
8101 if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)
8102 {
8103 ReleaseHub(h);
8104 return ERR_NOT_SUPPORTED;
8105 }
8106 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
8107 {
8108 ReleaseHub(h);
8109 return ERR_NOT_FARM_CONTROLLER;
8110 }
8111
8112 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat") != 0)
8113 {
8114 ReleaseHub(h);
8115 return ERR_NOT_ENOUGH_RIGHT;
8116 }
8117
8118 ALog(a, h, "LA_DISABLE_SNAT");
8119
8120 EnableSecureNAT(h, false);
8121
8122 h->CurrentVersion++;
8123 SiHubUpdateProc(h);
8124
8125 IncrementServerConfigRevision(s);
8126
8127 ReleaseHub(h);
8128
8129 return ERR_NO_ERROR;
8130 }
8131
8132 // Enumerate NAT entries of the SecureNAT
StEnumNAT(ADMIN * a,RPC_ENUM_NAT * t)8133 UINT StEnumNAT(ADMIN *a, RPC_ENUM_NAT *t)
8134 {
8135 SERVER *s = a->Server;
8136 CEDAR *c = s->Cedar;
8137 HUB *h;
8138 UINT ret = ERR_NO_ERROR;
8139 char hubname[MAX_HUBNAME_LEN + 1];
8140 UINT i;
8141
8142 CHECK_RIGHT;
8143
8144 StrCpy(hubname, sizeof(hubname), t->HubName);
8145
8146 LockHubList(c);
8147 {
8148 h = GetHub(c, t->HubName);
8149 }
8150 UnlockHubList(c);
8151
8152 if (h == NULL)
8153 {
8154 return ERR_HUB_NOT_FOUND;
8155 }
8156
8157 if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)
8158 {
8159 ReleaseHub(h);
8160 return ERR_NOT_SUPPORTED;
8161 }
8162
8163 Lock(h->lock_online);
8164 {
8165 if (h->SecureNAT == NULL)
8166 {
8167 ret = ERR_SNAT_NOT_RUNNING;
8168 }
8169 else
8170 {
8171 NtEnumNatList(h->SecureNAT->Nat, t);
8172 }
8173 }
8174 Unlock(h->lock_online);
8175
8176 if (h->Type == HUB_TYPE_FARM_DYNAMIC)
8177 {
8178 if (ret == ERR_SNAT_NOT_RUNNING)
8179 {
8180 // Get status of remote SecureNAT
8181 LockList(s->FarmMemberList);
8182 {
8183 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
8184 {
8185 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
8186 if (f->Me == false)
8187 {
8188 RPC_ENUM_NAT tmp;
8189
8190 Zero(&tmp, sizeof(tmp));
8191
8192 SiCallEnumNat(s, f, hubname, &tmp);
8193
8194 if (tmp.NumItem >= 1)
8195 {
8196 FreeRpcEnumNat(t);
8197 Copy(t, &tmp, sizeof(RPC_ENUM_NAT));
8198 ret = ERR_NO_ERROR;
8199 break;
8200 }
8201 else
8202 {
8203 FreeRpcEnumNat(&tmp);
8204 }
8205 }
8206 }
8207 }
8208 UnlockList(s->FarmMemberList);
8209 }
8210 }
8211
8212 ReleaseHub(h);
8213
8214 ret = ERR_NO_ERROR;
8215
8216 return ret;
8217 }
8218
8219 // Get status of the SecureNAT
StGetSecureNATStatus(ADMIN * a,RPC_NAT_STATUS * t)8220 UINT StGetSecureNATStatus(ADMIN *a, RPC_NAT_STATUS *t)
8221 {
8222 SERVER *s = a->Server;
8223 CEDAR *c = s->Cedar;
8224 HUB *h;
8225 UINT ret = ERR_NO_ERROR;
8226 char hubname[MAX_HUBNAME_LEN + 1];
8227 UINT i;
8228
8229 CHECK_RIGHT;
8230
8231 StrCpy(hubname, sizeof(hubname), t->HubName);
8232
8233 LockHubList(c);
8234 {
8235 h = GetHub(c, t->HubName);
8236 }
8237 UnlockHubList(c);
8238
8239 if (h == NULL)
8240 {
8241 return ERR_HUB_NOT_FOUND;
8242 }
8243
8244 if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)
8245 {
8246 ReleaseHub(h);
8247 return ERR_NOT_SUPPORTED;
8248 }
8249
8250 Lock(h->lock_online);
8251 {
8252 if (h->SecureNAT == NULL)
8253 {
8254 ret = ERR_SNAT_NOT_RUNNING;
8255 }
8256 else
8257 {
8258 NtGetStatus(h->SecureNAT->Nat, t);
8259 }
8260 }
8261 Unlock(h->lock_online);
8262
8263 if (h->Type == HUB_TYPE_FARM_DYNAMIC)
8264 {
8265 if (ret == ERR_SNAT_NOT_RUNNING)
8266 {
8267 // Get status of remote secureNAT
8268 LockList(s->FarmMemberList);
8269 {
8270 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
8271 {
8272 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
8273 if (f->Me == false)
8274 {
8275 RPC_NAT_STATUS tmp;
8276
8277 Zero(&tmp, sizeof(tmp));
8278
8279 SiCallGetNatStatus(s, f, hubname, &tmp);
8280
8281 if (tmp.NumDhcpClients == 0 && tmp.NumTcpSessions == 0 && tmp.NumUdpSessions == 0)
8282 {
8283 }
8284 else
8285 {
8286 Copy(t, &tmp, sizeof(RPC_NAT_STATUS));
8287 ret = ERR_NO_ERROR;
8288 break;
8289 }
8290 }
8291 }
8292 }
8293 UnlockList(s->FarmMemberList);
8294 }
8295 }
8296
8297 ReleaseHub(h);
8298
8299 StrCpy(t->HubName, sizeof(t->HubName), hubname);
8300 ret = ERR_NO_ERROR;
8301
8302 return ret;
8303 }
8304
8305 // Enumerate DHCP entries
StEnumDHCP(ADMIN * a,RPC_ENUM_DHCP * t)8306 UINT StEnumDHCP(ADMIN *a, RPC_ENUM_DHCP *t)
8307 {
8308 SERVER *s = a->Server;
8309 CEDAR *c = s->Cedar;
8310 HUB *h;
8311 UINT ret = ERR_NO_ERROR;
8312 char hubname[MAX_HUBNAME_LEN + 1];
8313 UINT i;
8314 StrCpy(hubname, sizeof(hubname), t->HubName);
8315
8316 CHECK_RIGHT;
8317
8318 LockHubList(c);
8319 {
8320 h = GetHub(c, t->HubName);
8321 }
8322 UnlockHubList(c);
8323
8324 if (h == NULL)
8325 {
8326 return ERR_HUB_NOT_FOUND;
8327 }
8328
8329 if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)
8330 {
8331 ReleaseHub(h);
8332 return ERR_NOT_SUPPORTED;
8333 }
8334
8335 Lock(h->lock_online);
8336 {
8337 if (h->SecureNAT == NULL)
8338 {
8339 ret = ERR_SNAT_NOT_RUNNING;
8340 }
8341 else
8342 {
8343 NtEnumDhcpList(h->SecureNAT->Nat, t);
8344 }
8345 }
8346 Unlock(h->lock_online);
8347
8348 if (h->Type == HUB_TYPE_FARM_DYNAMIC)
8349 {
8350 if (ret == ERR_SNAT_NOT_RUNNING)
8351 {
8352 // Get status of remote DHCP service
8353 LockList(s->FarmMemberList);
8354 {
8355 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
8356 {
8357 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
8358 if (f->Me == false)
8359 {
8360 RPC_ENUM_DHCP tmp;
8361
8362 Zero(&tmp, sizeof(tmp));
8363
8364 SiCallEnumDhcp(s, f, hubname, &tmp);
8365
8366 if (tmp.NumItem >= 1)
8367 {
8368 FreeRpcEnumDhcp(t);
8369 Copy(t, &tmp, sizeof(RPC_ENUM_DHCP));
8370 ret = ERR_NO_ERROR;
8371 break;
8372 }
8373 else
8374 {
8375 FreeRpcEnumDhcp(&tmp);
8376 }
8377 }
8378 }
8379 }
8380 UnlockList(s->FarmMemberList);
8381 }
8382 }
8383
8384 ReleaseHub(h);
8385
8386 ret = ERR_NO_ERROR;
8387
8388 return ret;
8389 }
8390
8391 // Set SecureNAT options
StSetSecureNATOption(ADMIN * a,VH_OPTION * t)8392 UINT StSetSecureNATOption(ADMIN *a, VH_OPTION *t)
8393 {
8394 SERVER *s = a->Server;
8395 CEDAR *c = s->Cedar;
8396 HUB *h;
8397 char push_routes_str_old[MAX_DHCP_CLASSLESS_ROUTE_TABLE_STR_SIZE];
8398
8399
8400 if (IsZero(t->MacAddress, sizeof(t->MacAddress)) ||
8401 IsHostIPAddress4(&t->Ip) == false ||
8402 IsSubnetMask4(&t->Mask) == false)
8403 {
8404 return ERR_INVALID_PARAMETER;
8405 }
8406 if ((IPToUINT(&t->Ip) & (~(IPToUINT(&t->Mask)))) == 0)
8407 {
8408 return ERR_INVALID_PARAMETER;
8409 }
8410 if (GetServerCapsBool(s, "b_support_securenat") == false)
8411 {
8412 t->ApplyDhcpPushRoutes = false;
8413 }
8414 if (t->ApplyDhcpPushRoutes)
8415 {
8416 if (NormalizeClasslessRouteTableStr(t->DhcpPushRoutes, sizeof(t->DhcpPushRoutes), t->DhcpPushRoutes) == false)
8417 {
8418 return ERR_INVALID_PARAMETER;
8419 }
8420 }
8421
8422 CHECK_RIGHT;
8423
8424 LockHubList(c);
8425 {
8426 h = GetHub(c, t->HubName);
8427 }
8428 UnlockHubList(c);
8429
8430 if (h == NULL)
8431 {
8432 return ERR_HUB_NOT_FOUND;
8433 }
8434
8435 if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)
8436 {
8437 ReleaseHub(h);
8438 return ERR_NOT_SUPPORTED;
8439 }
8440 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
8441 {
8442 ReleaseHub(h);
8443 return ERR_NOT_FARM_CONTROLLER;
8444 }
8445
8446 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat") != 0)
8447 {
8448 ReleaseHub(h);
8449 return ERR_NOT_ENOUGH_RIGHT;
8450 }
8451
8452 if (h->SecureNATOption->UseNat == false && t->UseNat)
8453 {
8454 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat_enablenat") != 0)
8455 {
8456 ReleaseHub(h);
8457 return ERR_NOT_ENOUGH_RIGHT;
8458 }
8459 }
8460
8461 if (h->SecureNATOption->UseDhcp == false && t->UseDhcp)
8462 {
8463 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat_enabledhcp") != 0)
8464 {
8465 ReleaseHub(h);
8466 return ERR_NOT_ENOUGH_RIGHT;
8467 }
8468 }
8469
8470 StrCpy(push_routes_str_old, sizeof(push_routes_str_old), h->SecureNATOption->DhcpPushRoutes);
8471 Copy(h->SecureNATOption, t, sizeof(VH_OPTION));
8472 if (t->ApplyDhcpPushRoutes == false)
8473 {
8474 StrCpy(h->SecureNATOption->DhcpPushRoutes, sizeof(h->SecureNATOption->DhcpPushRoutes), push_routes_str_old);
8475 }
8476
8477 if (h->Type != HUB_TYPE_STANDALONE && h->Cedar != NULL && h->Cedar->Server != NULL &&
8478 h->Cedar->Server->ServerType == SERVER_TYPE_FARM_CONTROLLER)
8479 {
8480 NiClearUnsupportedVhOptionForDynamicHub(h->SecureNATOption, false);
8481 }
8482
8483 Lock(h->lock_online);
8484 {
8485 if (h->SecureNAT != NULL)
8486 {
8487 SetVirtualHostOption(h->SecureNAT->Nat->Virtual, t);
8488 }
8489 }
8490 Unlock(h->lock_online);
8491
8492 ALog(a, h, "LA_SET_SNAT_OPTION");
8493
8494 h->CurrentVersion++;
8495 SiHubUpdateProc(h);
8496
8497 IncrementServerConfigRevision(s);
8498
8499 ReleaseHub(h);
8500
8501 return ERR_NO_ERROR;
8502 }
8503
8504 // Get SecureNAT options
StGetSecureNATOption(ADMIN * a,VH_OPTION * t)8505 UINT StGetSecureNATOption(ADMIN *a, VH_OPTION *t)
8506 {
8507 SERVER *s = a->Server;
8508 CEDAR *c = s->Cedar;
8509 HUB *h;
8510 char hubname[MAX_HUBNAME_LEN + 1];
8511
8512 StrCpy(hubname, sizeof(hubname), t->HubName);
8513
8514 CHECK_RIGHT;
8515
8516 LockHubList(c);
8517 {
8518 h = GetHub(c, t->HubName);
8519 }
8520 UnlockHubList(c);
8521
8522 if (h == NULL)
8523 {
8524 return ERR_HUB_NOT_FOUND;
8525 }
8526
8527 if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)
8528 {
8529 ReleaseHub(h);
8530 return ERR_NOT_SUPPORTED;
8531 }
8532 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
8533 {
8534 ReleaseHub(h);
8535 return ERR_NOT_FARM_CONTROLLER;
8536 }
8537
8538 Zero(t, sizeof(VH_OPTION));
8539 Copy(t, h->SecureNATOption, sizeof(VH_OPTION));
8540 StrCpy(t->HubName, sizeof(t->HubName), hubname);
8541 t->ApplyDhcpPushRoutes = true;
8542
8543 ReleaseHub(h);
8544
8545 return ERR_NO_ERROR;
8546 }
8547
8548 // Make a hub on-line or off-line
StSetHubOnline(ADMIN * a,RPC_SET_HUB_ONLINE * t)8549 UINT StSetHubOnline(ADMIN *a, RPC_SET_HUB_ONLINE *t)
8550 {
8551 SERVER *s = a->Server;
8552 CEDAR *c = s->Cedar;
8553 HUB *h;
8554
8555 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
8556 {
8557 return ERR_NOT_FARM_CONTROLLER;
8558 }
8559
8560
8561 NO_SUPPORT_FOR_BRIDGE;
8562
8563 CHECK_RIGHT;
8564
8565 LockHubList(c);
8566 {
8567 h = GetHub(c, t->HubName);
8568 }
8569 UnlockHubList(c);
8570
8571 if (h == NULL)
8572 {
8573 return ERR_HUB_NOT_FOUND;
8574 }
8575
8576 if (a->ServerAdmin == false && t->Online && GetHubAdminOption(h, "no_online") != 0)
8577 {
8578 ReleaseHub(h);
8579 return ERR_NOT_ENOUGH_RIGHT;
8580 }
8581
8582 if (a->ServerAdmin == false && t->Online == false && GetHubAdminOption(h, "no_offline") != 0)
8583 {
8584 ReleaseHub(h);
8585 return ERR_NOT_ENOUGH_RIGHT;
8586 }
8587
8588 if (t->Online)
8589 {
8590 ALog(a, h, "LA_SET_HUB_ONLINE");
8591 SetHubOnline(h);
8592 }
8593 else
8594 {
8595 ALog(a, h, "LA_SET_HUB_OFFLINE");
8596 SetHubOffline(h);
8597 }
8598
8599 h->CurrentVersion++;
8600 SiHubUpdateProc(h);
8601
8602 IncrementServerConfigRevision(s);
8603
8604 ReleaseHub(h);
8605
8606 return ERR_NO_ERROR;
8607 }
8608
8609 // Get connection information
StGetConnectionInfo(ADMIN * a,RPC_CONNECTION_INFO * t)8610 UINT StGetConnectionInfo(ADMIN *a, RPC_CONNECTION_INFO *t)
8611 {
8612 SERVER *s = a->Server;
8613 CEDAR *c = s->Cedar;
8614 CONNECTION *connection;
8615 char name[MAX_CONNECTION_NAME_LEN + 1];
8616
8617 if (IsEmptyStr(t->Name))
8618 {
8619 return ERR_INVALID_PARAMETER;
8620 }
8621
8622 SERVER_ADMIN_ONLY;
8623
8624 LockList(c->ConnectionList);
8625 {
8626 CONNECTION tt;
8627 Zero(&tt, sizeof(tt));
8628 tt.Name = t->Name;
8629 StrCpy(name, sizeof(name), t->Name);
8630
8631 connection = Search(c->ConnectionList, &tt);
8632
8633 if (connection != NULL)
8634 {
8635 AddRef(connection->ref);
8636 }
8637 }
8638 UnlockList(c->ConnectionList);
8639
8640 if (connection == NULL)
8641 {
8642 return ERR_OBJECT_NOT_FOUND;
8643 }
8644
8645 Zero(t, sizeof(RPC_CONNECTION_INFO));
8646 StrCpy(t->Name, sizeof(t->Name), name);
8647
8648 Lock(connection->lock);
8649 {
8650 SOCK *s = connection->FirstSock;
8651
8652 if (s != NULL)
8653 {
8654 t->Ip = IPToUINT(&s->RemoteIP);
8655 t->Port = s->RemotePort;
8656 StrCpy(t->Hostname, sizeof(t->Hostname), s->RemoteHostname);
8657 }
8658
8659 StrCpy(t->Name, sizeof(t->Name), connection->Name);
8660 t->ConnectedTime = TickToTime(connection->ConnectedTick);
8661 t->Type = connection->Type;
8662
8663 StrCpy(t->ServerStr, sizeof(t->ServerStr), connection->ServerStr);
8664 StrCpy(t->ClientStr, sizeof(t->ClientStr), connection->ClientStr);
8665 t->ServerVer = connection->ServerVer;
8666 t->ServerBuild = connection->ServerBuild;
8667 t->ClientVer = connection->ClientVer;
8668 t->ClientBuild = connection->ClientBuild;
8669 }
8670 Unlock(connection->lock);
8671
8672 ReleaseConnection(connection);
8673
8674 return ERR_NO_ERROR;
8675 }
8676
8677 // Disconnect a connection
StDisconnectConnection(ADMIN * a,RPC_DISCONNECT_CONNECTION * t)8678 UINT StDisconnectConnection(ADMIN *a, RPC_DISCONNECT_CONNECTION *t)
8679 {
8680 SERVER *s = a->Server;
8681 CEDAR *c = s->Cedar;
8682 CONNECTION *connection;
8683
8684 if (IsEmptyStr(t->Name))
8685 {
8686 return ERR_INVALID_PARAMETER;
8687 }
8688
8689 SERVER_ADMIN_ONLY;
8690
8691 LockList(c->ConnectionList);
8692 {
8693 CONNECTION tt;
8694 Zero(&tt, sizeof(tt));
8695 tt.Name = t->Name;
8696
8697 connection = Search(c->ConnectionList, &tt);
8698 if (connection != NULL)
8699 {
8700 AddRef(connection->ref);
8701 }
8702 }
8703 UnlockList(c->ConnectionList);
8704
8705 if (connection == NULL)
8706 {
8707 return ERR_OBJECT_NOT_FOUND;
8708 }
8709
8710 StopConnection(connection, true);
8711
8712 ReleaseConnection(connection);
8713
8714 ALog(a, NULL, "LA_DISCONNECT_CONN", t->Name);
8715
8716 return ERR_NO_ERROR;
8717 }
8718
8719 // Enumerate connections
StEnumConnection(ADMIN * a,RPC_ENUM_CONNECTION * t)8720 UINT StEnumConnection(ADMIN *a, RPC_ENUM_CONNECTION *t)
8721 {
8722 SERVER *s = a->Server;
8723 CEDAR *c = s->Cedar;
8724
8725 SERVER_ADMIN_ONLY;
8726
8727 FreeRpcEnumConnetion(t);
8728 Zero(t, sizeof(RPC_ENUM_CONNECTION));
8729
8730 LockList(c->ConnectionList);
8731 {
8732 UINT i;
8733 t->NumConnection = LIST_NUM(c->ConnectionList);
8734 t->Connections = ZeroMalloc(sizeof(RPC_ENUM_CONNECTION_ITEM) * t->NumConnection);
8735
8736 for (i = 0;i < t->NumConnection;i++)
8737 {
8738 RPC_ENUM_CONNECTION_ITEM *e = &t->Connections[i];
8739 CONNECTION *connection = LIST_DATA(c->ConnectionList, i);
8740
8741 Lock(connection->lock);
8742 {
8743 SOCK *s = connection->FirstSock;
8744
8745 if (s != NULL)
8746 {
8747 e->Ip = IPToUINT(&s->RemoteIP);
8748 e->Port = s->RemotePort;
8749 StrCpy(e->Hostname, sizeof(e->Hostname), s->RemoteHostname);
8750 }
8751
8752 StrCpy(e->Name, sizeof(e->Name), connection->Name);
8753 e->ConnectedTime = TickToTime(connection->ConnectedTick);
8754 e->Type = connection->Type;
8755 }
8756 Unlock(connection->lock);
8757 }
8758 }
8759 UnlockList(c->ConnectionList);
8760
8761 return ERR_NO_ERROR;
8762 }
8763
8764 // Set Radius options of the hub
StSetHubRadius(ADMIN * a,RPC_RADIUS * t)8765 UINT StSetHubRadius(ADMIN *a, RPC_RADIUS *t)
8766 {
8767 SERVER *s = a->Server;
8768 CEDAR *c = s->Cedar;
8769 HUB *h = NULL;
8770
8771 NO_SUPPORT_FOR_BRIDGE;
8772
8773 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
8774 {
8775 return ERR_NOT_SUPPORTED;
8776 }
8777
8778 if (GetGlobalServerFlag(GSF_DISABLE_RADIUS_AUTH) != 0 && IsEmptyStr(t->RadiusServerName) == false)
8779 {
8780 return ERR_NOT_SUPPORTED_FUNCTION_ON_OPENSOURCE;
8781 }
8782
8783 CHECK_RIGHT;
8784
8785 LockHubList(c);
8786 {
8787 h = GetHub(c, t->HubName);
8788 }
8789 UnlockHubList(c);
8790
8791 if (h == NULL)
8792 {
8793 return ERR_HUB_NOT_FOUND;
8794 }
8795
8796 //SetRadiusServer(h, t->RadiusServerName, t->RadiusPort, t->RadiusSecret);
8797 SetRadiusServerEx(h, t->RadiusServerName, t->RadiusPort, t->RadiusSecret, t->RadiusRetryInterval);
8798
8799 ALog(a, h, "LA_SET_HUB_RADIUS");
8800
8801 ReleaseHub(h);
8802
8803 IncrementServerConfigRevision(s);
8804
8805 return ERR_NO_ERROR;
8806 }
8807
8808 // Get Radius options of the hub
StGetHubRadius(ADMIN * a,RPC_RADIUS * t)8809 UINT StGetHubRadius(ADMIN *a, RPC_RADIUS *t)
8810 {
8811 SERVER *s = a->Server;
8812 CEDAR *c = s->Cedar;
8813 HUB *h = NULL;
8814
8815 CHECK_RIGHT;
8816
8817 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
8818 {
8819 return ERR_NOT_SUPPORTED;
8820 }
8821
8822 LockHubList(c);
8823 {
8824 h = GetHub(c, t->HubName);
8825 }
8826 UnlockHubList(c);
8827
8828 if (h == NULL)
8829 {
8830 return ERR_HUB_NOT_FOUND;
8831 }
8832
8833 Zero(t, sizeof(RPC_RADIUS));
8834 //GetRadiusServer(h, t->RadiusServerName, sizeof(t->RadiusServerName),
8835 // &t->RadiusPort, t->RadiusSecret, sizeof(t->RadiusSecret));
8836 GetRadiusServerEx(h, t->RadiusServerName, sizeof(t->RadiusServerName),
8837 &t->RadiusPort, t->RadiusSecret, sizeof(t->RadiusSecret), &t->RadiusRetryInterval);
8838
8839 ReleaseHub(h);
8840
8841 return ERR_NO_ERROR;
8842 }
8843
8844 // Delete a hub
StDeleteHub(ADMIN * a,RPC_DELETE_HUB * t)8845 UINT StDeleteHub(ADMIN *a, RPC_DELETE_HUB *t)
8846 {
8847 SERVER *s = a->Server;
8848 CEDAR *c = s->Cedar;
8849 HUB *h = NULL;
8850
8851 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
8852 {
8853 return ERR_NOT_FARM_CONTROLLER;
8854 }
8855
8856
8857 if (IsEmptyStr(t->HubName) || IsSafeStr(t->HubName) == false)
8858 {
8859 return ERR_INVALID_PARAMETER;
8860 }
8861
8862 NO_SUPPORT_FOR_BRIDGE;
8863
8864 SERVER_ADMIN_ONLY;
8865
8866 LockHubList(c);
8867 {
8868 h = GetHub(c, t->HubName);
8869 }
8870 UnlockHubList(c);
8871
8872 if (h == NULL)
8873 {
8874 return ERR_HUB_NOT_FOUND;
8875 }
8876
8877 StopHub(h);
8878
8879 IncrementServerConfigRevision(s);
8880
8881 DelHub(c, h);
8882 ReleaseHub(h);
8883
8884 ALog(a, NULL, "LA_DELETE_HUB", t->HubName);
8885
8886 return ERR_NO_ERROR;
8887 }
8888
8889 // Enumerate hubs
StEnumHub(ADMIN * a,RPC_ENUM_HUB * t)8890 UINT StEnumHub(ADMIN *a, RPC_ENUM_HUB *t)
8891 {
8892 SERVER *s = a->Server;
8893 CEDAR *c = s->Cedar;
8894 HUB *h = NULL;
8895
8896 FreeRpcEnumHub(t);
8897
8898 Zero(t, sizeof(RPC_ENUM_HUB));
8899
8900 LockHubList(c);
8901 {
8902 UINT i, num, j;
8903
8904 num = 0;
8905
8906 for (i = 0;i < LIST_NUM(c->HubList);i++)
8907 {
8908 HUB *h = LIST_DATA(c->HubList, i);
8909
8910 Lock(h->lock);
8911
8912 if (a->ServerAdmin == false &&
8913 h->Option != NULL &&
8914 StrCmpi(h->Name, a->HubName) != 0)
8915 {
8916 // This hub is not listed
8917 }
8918 else
8919 {
8920 // This hub is listed
8921 num++;
8922 }
8923 }
8924
8925 t->NumHub = num;
8926
8927 t->Hubs = ZeroMalloc(sizeof(RPC_ENUM_HUB_ITEM) * num);
8928
8929 i = 0;
8930 for (j = 0;j < LIST_NUM(c->HubList);j++)
8931 {
8932 HUB *h = LIST_DATA(c->HubList, j);
8933
8934 if (a->ServerAdmin == false &&
8935 h->Option != NULL &&
8936 StrCmpi(h->Name, a->HubName) != 0)
8937 {
8938 // This hub is not listed
8939 }
8940 else
8941 {
8942 // This hub is listed
8943 RPC_ENUM_HUB_ITEM *e = &t->Hubs[i++];
8944
8945 StrCpy(e->HubName, sizeof(e->HubName), h->Name);
8946 e->Online = h->Offline ? false : true;
8947 e->HubType = h->Type;
8948
8949 e->NumSessions = LIST_NUM(h->SessionList);
8950
8951 LockHashList(h->MacHashTable);
8952 {
8953 e->NumMacTables = HASH_LIST_NUM(h->MacHashTable);
8954 }
8955 UnlockHashList(h->MacHashTable);
8956
8957 LockList(h->IpTable);
8958 {
8959 e->NumIpTables = LIST_NUM(h->IpTable);
8960 }
8961 UnlockList(h->IpTable);
8962
8963 if (h->HubDb != NULL)
8964 {
8965 LockList(h->HubDb->UserList);
8966 {
8967 e->NumUsers = LIST_NUM(h->HubDb->UserList);
8968 }
8969 UnlockList(h->HubDb->UserList);
8970
8971 LockList(h->HubDb->GroupList);
8972 {
8973 e->NumGroups = LIST_NUM(h->HubDb->GroupList);
8974 }
8975 UnlockList(h->HubDb->GroupList);
8976 }
8977
8978 e->LastCommTime = h->LastCommTime;
8979 e->LastLoginTime = h->LastLoginTime;
8980 e->NumLogin = h->NumLogin;
8981 e->CreatedTime = h->CreatedTime;
8982
8983 Lock(h->TrafficLock);
8984 {
8985 Copy(&e->Traffic, h->Traffic, sizeof(TRAFFIC));
8986 }
8987 Unlock(h->TrafficLock);
8988
8989 e->IsTrafficFilled = true;
8990 }
8991
8992 Unlock(h->lock);
8993 }
8994 }
8995 UnlockHubList(c);
8996
8997 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
8998 {
8999 UINT i, j, k;
9000 LockList(s->FarmMemberList);
9001 {
9002 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)
9003 {
9004 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
9005
9006 LockList(f->HubList);
9007 {
9008 if (f->Me == false)
9009 {
9010 for (j = 0;j < LIST_NUM(f->HubList);j++)
9011 {
9012 HUB_LIST *o = LIST_DATA(f->HubList, j);
9013
9014 for (k = 0;k < t->NumHub;k++)
9015 {
9016 RPC_ENUM_HUB_ITEM *e = &t->Hubs[k];
9017
9018 if (StrCmpi(e->HubName, o->Name) == 0)
9019 {
9020 e->NumIpTables += o->NumIpTables;
9021 e->NumMacTables += o->NumMacTables;
9022 e->NumSessions += o->NumSessions;
9023 }
9024 }
9025 }
9026 }
9027 }
9028 UnlockList(f->HubList);
9029 }
9030 }
9031 UnlockList(s->FarmMemberList);
9032 }
9033
9034 return ERR_NO_ERROR;
9035 }
9036
9037 // Get hub configuration
StGetHub(ADMIN * a,RPC_CREATE_HUB * t)9038 UINT StGetHub(ADMIN *a, RPC_CREATE_HUB *t)
9039 {
9040 SERVER *s = a->Server;
9041 CEDAR *c = s->Cedar;
9042 UINT ret = ERR_NO_ERROR;
9043 HUB *h;
9044
9045 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
9046 {
9047 return ERR_NOT_FARM_CONTROLLER;
9048 }
9049
9050 if (IsEmptyStr(t->HubName) || IsSafeStr(t->HubName) == false)
9051 {
9052 return ERR_INVALID_PARAMETER;
9053 }
9054
9055 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
9056 {
9057 return ERR_NOT_FARM_CONTROLLER;
9058 }
9059
9060 NO_SUPPORT_FOR_BRIDGE;
9061 CHECK_RIGHT;
9062
9063 LockHubList(c);
9064 {
9065 h = GetHub(c, t->HubName);
9066 }
9067 UnlockHubList(c);
9068
9069 Zero(t, sizeof(RPC_CREATE_HUB));
9070
9071 if (h == NULL)
9072 {
9073 return ERR_HUB_NOT_FOUND;
9074 }
9075
9076 Lock(h->lock);
9077 {
9078 StrCpy(t->HubName, sizeof(t->HubName), h->Name);
9079 t->Online = h->Offline ? false : true;
9080 t->HubOption.MaxSession = h->Option->MaxSession;
9081 t->HubOption.NoEnum = h->Option->NoEnum;
9082 t->HubType = h->Type;
9083 }
9084 Unlock(h->lock);
9085
9086 ReleaseHub(h);
9087
9088 return ret;
9089 }
9090
9091 // Set hub configuration
StSetHub(ADMIN * a,RPC_CREATE_HUB * t)9092 UINT StSetHub(ADMIN *a, RPC_CREATE_HUB *t)
9093 {
9094 SERVER *s = a->Server;
9095 CEDAR *c = s->Cedar;
9096 HUB *h;
9097 UINT ret = ERR_NO_ERROR;
9098
9099 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
9100 {
9101 return ERR_NOT_FARM_CONTROLLER;
9102 }
9103
9104 if (IsEmptyStr(t->HubName) || IsSafeStr(t->HubName) == false)
9105 {
9106 return ERR_INVALID_PARAMETER;
9107 }
9108
9109
9110 CHECK_RIGHT;
9111 NO_SUPPORT_FOR_BRIDGE;
9112
9113 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
9114 {
9115 return ERR_NOT_FARM_CONTROLLER;
9116 }
9117
9118 if (s->ServerType == SERVER_TYPE_STANDALONE)
9119 {
9120 if (t->HubType != HUB_TYPE_STANDALONE)
9121 {
9122 return ERR_INVALID_PARAMETER;
9123 }
9124 }
9125
9126 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
9127 {
9128 if (t->HubType == HUB_TYPE_STANDALONE)
9129 {
9130 return ERR_INVALID_PARAMETER;
9131 }
9132 }
9133
9134 LockHubList(c);
9135 {
9136 h = GetHub(c, t->HubName);
9137 }
9138 UnlockHubList(c);
9139
9140 if (h == NULL)
9141 {
9142 return ERR_HUB_NOT_FOUND;
9143 }
9144
9145 if (h->Type != t->HubType)
9146 {
9147 ReleaseHub(h);
9148 return ERR_NOT_SUPPORTED;
9149 }
9150
9151 // For JSON-RPC
9152 if (StrLen(t->AdminPasswordPlainText) != 0)
9153 {
9154 Hash(t->HashedPassword, t->AdminPasswordPlainText, StrLen(t->AdminPasswordPlainText), true);
9155 HashPassword(t->SecurePassword, ADMINISTRATOR_USERNAME, t->AdminPasswordPlainText);
9156 }
9157
9158 if (IsZero(t->HashedPassword, sizeof(t->HashedPassword)) == false &&
9159 IsZero(t->SecurePassword, sizeof(t->SecurePassword)) == false)
9160 {
9161 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_admin_password") != 0)
9162 {
9163 ReleaseHub(h);
9164 return ERR_NOT_ENOUGH_RIGHT;
9165 }
9166 }
9167
9168 // Is the password to be set blank
9169 {
9170 UCHAR hash1[SHA1_SIZE], hash2[SHA1_SIZE];
9171 HashPassword(hash1, ADMINISTRATOR_USERNAME, "");
9172 Hash(hash2, "", 0, true);
9173
9174 if (Cmp(t->HashedPassword, hash2, SHA1_SIZE) == 0 || Cmp(t->SecurePassword, hash1, SHA1_SIZE) == 0)
9175 {
9176 if (a->ServerAdmin == false && a->Rpc->Sock->RemoteIP.addr[0] != 127)
9177 {
9178 // Refuse to set a blank password to hub admin from remote host
9179 ReleaseHub(h);
9180 return ERR_INVALID_PARAMETER;
9181 }
9182 }
9183 }
9184
9185 Lock(h->lock);
9186 {
9187 if (a->ServerAdmin == false && h->Type != t->HubType)
9188 {
9189 ret = ERR_NOT_ENOUGH_RIGHT;
9190 }
9191 else
9192 {
9193 h->Type = t->HubType;
9194 h->Option->MaxSession = t->HubOption.MaxSession;
9195 h->Option->NoEnum = t->HubOption.NoEnum;
9196 if (IsZero(t->HashedPassword, sizeof(t->HashedPassword)) == false &&
9197 IsZero(t->SecurePassword, sizeof(t->SecurePassword)) == false)
9198 {
9199 Copy(h->HashedPassword, t->HashedPassword, SHA1_SIZE);
9200 Copy(h->SecurePassword, t->SecurePassword, SHA1_SIZE);
9201 }
9202 }
9203 }
9204 Unlock(h->lock);
9205
9206 if (t->Online)
9207 {
9208 if (a->ServerAdmin || GetHubAdminOption(h, "no_online") == 0)
9209 {
9210 SetHubOnline(h);
9211 }
9212 }
9213 else
9214 {
9215 if (a->ServerAdmin || GetHubAdminOption(h, "no_offline") == 0)
9216 {
9217 SetHubOffline(h);
9218 }
9219 }
9220
9221 if (h->Type == HUB_TYPE_FARM_STATIC)
9222 {
9223 EnableSecureNAT(h, false);
9224 }
9225
9226 h->CurrentVersion++;
9227 SiHubUpdateProc(h);
9228
9229 IncrementServerConfigRevision(s);
9230
9231 ALog(a, h, "LA_SET_HUB");
9232
9233 ReleaseHub(h);
9234
9235 return ret;
9236 }
9237
9238 // Create a hub
StCreateHub(ADMIN * a,RPC_CREATE_HUB * t)9239 UINT StCreateHub(ADMIN *a, RPC_CREATE_HUB *t)
9240 {
9241 SERVER *s = a->Server;
9242 CEDAR *c = s->Cedar;
9243 HUB *h;
9244 HUB_OPTION o;
9245 UINT current_hub_num;
9246 bool b;
9247
9248 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
9249 {
9250 return ERR_NOT_FARM_CONTROLLER;
9251 }
9252
9253
9254
9255 if (IsEmptyStr(t->HubName) || IsSafeStr(t->HubName) == false)
9256 {
9257 return ERR_INVALID_PARAMETER;
9258 }
9259
9260 NO_SUPPORT_FOR_BRIDGE;
9261
9262 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
9263 {
9264 return ERR_NOT_FARM_CONTROLLER;
9265 }
9266
9267 SERVER_ADMIN_ONLY;
9268
9269 Trim(t->HubName);
9270 if (StrLen(t->HubName) == 0)
9271 {
9272 return ERR_INVALID_PARAMETER;
9273 }
9274 if (StartWith(t->HubName, ".") || EndWith(t->HubName, "."))
9275 {
9276 return ERR_INVALID_PARAMETER;
9277 }
9278
9279 if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
9280 {
9281 return ERR_NOT_FARM_CONTROLLER;
9282 }
9283
9284 if (s->ServerType == SERVER_TYPE_STANDALONE)
9285 {
9286 if (t->HubType != HUB_TYPE_STANDALONE)
9287 {
9288 return ERR_INVALID_PARAMETER;
9289 }
9290 }
9291 else if (t->HubType != HUB_TYPE_FARM_DYNAMIC && t->HubType != HUB_TYPE_FARM_STATIC)
9292 {
9293 return ERR_INVALID_PARAMETER;
9294 }
9295
9296 // Create a hub object
9297 Zero(&o, sizeof(o));
9298 o.MaxSession = t->HubOption.MaxSession;
9299 o.NoEnum = t->HubOption.NoEnum;
9300
9301 // Default setting for hub admin options
9302 SiSetDefaultHubOption(&o);
9303
9304 LockList(c->HubList);
9305 {
9306 current_hub_num = LIST_NUM(c->HubList);
9307 }
9308 UnlockList(c->HubList);
9309
9310 if (current_hub_num > GetServerCapsInt(a->Server, "i_max_hubs"))
9311 {
9312 return ERR_TOO_MANY_HUBS;
9313 }
9314
9315 LockList(c->HubList);
9316 {
9317 b = IsHub(c, t->HubName);
9318 }
9319 UnlockList(c->HubList);
9320
9321 if (b)
9322 {
9323 return ERR_HUB_ALREADY_EXISTS;
9324 }
9325
9326 ALog(a, NULL, "LA_CREATE_HUB", t->HubName);
9327
9328 // For JSON-RPC
9329 if ((IsZero(t->HashedPassword, sizeof(t->HashedPassword)) &&
9330 IsZero(t->SecurePassword, sizeof(t->SecurePassword))) ||
9331 StrLen(t->AdminPasswordPlainText) != 0)
9332 {
9333 Hash(t->HashedPassword, t->AdminPasswordPlainText, StrLen(t->AdminPasswordPlainText), true);
9334 HashPassword(t->SecurePassword, ADMINISTRATOR_USERNAME, t->AdminPasswordPlainText);
9335 }
9336
9337 h = NewHub(c, t->HubName, &o);
9338 Copy(h->HashedPassword, t->HashedPassword, SHA1_SIZE);
9339 Copy(h->SecurePassword, t->SecurePassword, SHA1_SIZE);
9340
9341 h->Type = t->HubType;
9342
9343 AddHub(c, h);
9344
9345 if (t->Online)
9346 {
9347 h->Offline = true;
9348 SetHubOnline(h);
9349 }
9350 else
9351 {
9352 h->Offline = false;
9353 SetHubOffline(h);
9354 }
9355
9356 h->CreatedTime = SystemTime64();
9357
9358 ReleaseHub(h);
9359
9360 IncrementServerConfigRevision(s);
9361
9362 return ERR_NO_ERROR;
9363 }
9364
9365 // Set cipher for SSL to the server
StSetServerCipher(ADMIN * a,RPC_STR * t)9366 UINT StSetServerCipher(ADMIN *a, RPC_STR *t)
9367 {
9368 SERVER *s = a->Server;
9369 CEDAR *c = s->Cedar;
9370
9371 if (IsEmptyStr(t->String))
9372 {
9373 return ERR_INVALID_PARAMETER;
9374 }
9375
9376 SERVER_ADMIN_ONLY;
9377
9378 StrUpper(t->String);
9379
9380 if (CheckCipherListName(t->String) == false)
9381 {
9382 return ERR_CIPHER_NOT_SUPPORTED;
9383 }
9384 else
9385 {
9386 ALog(a, NULL, "LA_SET_SERVER_CIPHER", t->String);
9387 }
9388
9389 Lock(c->lock);
9390 {
9391 SetCedarCipherList(c, t->String);
9392 }
9393 Unlock(c->lock);
9394
9395 IncrementServerConfigRevision(s);
9396
9397 return ERR_NO_ERROR;
9398 }
9399
9400 // Get cipher for SSL
StGetServerCipher(ADMIN * a,RPC_STR * t)9401 UINT StGetServerCipher(ADMIN *a, RPC_STR *t)
9402 {
9403 SERVER *s = a->Server;
9404 CEDAR *c = s->Cedar;
9405
9406 FreeRpcStr(t);
9407 Zero(t, sizeof(RPC_STR));
9408
9409 Lock(c->lock);
9410 {
9411 t->String = CopyStr(c->CipherList);
9412 }
9413 Unlock(c->lock);
9414
9415 return ERR_NO_ERROR;
9416 }
9417
9418 // Get the server certification
StGetServerCert(ADMIN * a,RPC_KEY_PAIR * t)9419 UINT StGetServerCert(ADMIN *a, RPC_KEY_PAIR *t)
9420 {
9421 bool admin;
9422 SERVER *s = a->Server;
9423 CEDAR *c = s->Cedar;
9424 bool is_vgs_cert = false;
9425
9426 admin = a->ServerAdmin;
9427
9428 FreeRpcKeyPair(t);
9429 Zero(t, sizeof(RPC_KEY_PAIR));
9430
9431 Lock(c->lock);
9432 {
9433
9434 t->Cert = CloneX(c->ServerX);
9435 if (admin && is_vgs_cert == false)
9436 {
9437 t->Key = CloneK(c->ServerK);
9438 }
9439 }
9440 Unlock(c->lock);
9441
9442 return ERR_NO_ERROR;
9443 }
9444
9445 // Set the server certification
StSetServerCert(ADMIN * a,RPC_KEY_PAIR * t)9446 UINT StSetServerCert(ADMIN *a, RPC_KEY_PAIR *t)
9447 {
9448 SERVER *s = a->Server;
9449 CEDAR *c = s->Cedar;
9450
9451 SERVER_ADMIN_ONLY;
9452
9453 if (t->Cert == NULL || t->Key == NULL)
9454 {
9455 return ERR_PROTOCOL_ERROR;
9456 }
9457
9458 if (t->Cert->is_compatible_bit == false)
9459 {
9460 return ERR_NOT_RSA_1024;
9461 }
9462
9463 if (CheckXandK(t->Cert, t->Key) == false)
9464 {
9465 return ERR_PROTOCOL_ERROR;
9466 }
9467
9468 t->Flag1 = 1;
9469 if (t->Cert->root_cert == false)
9470 {
9471 if (DownloadAndSaveIntermediateCertificatesIfNecessary(t->Cert) == false)
9472 {
9473 t->Flag1 = 0;
9474 }
9475 }
9476
9477 SetCedarCert(c, t->Cert, t->Key);
9478
9479 ALog(a, NULL, "LA_SET_SERVER_CERT");
9480
9481 IncrementServerConfigRevision(s);
9482
9483 return ERR_NO_ERROR;
9484 }
9485
9486 // Get status of connection to cluster controller
StGetFarmConnectionStatus(ADMIN * a,RPC_FARM_CONNECTION_STATUS * t)9487 UINT StGetFarmConnectionStatus(ADMIN *a, RPC_FARM_CONNECTION_STATUS *t)
9488 {
9489 SERVER *s = a->Server;
9490 CEDAR *c = s->Cedar;
9491 FARM_CONTROLLER *fc;
9492
9493 if (s->ServerType != SERVER_TYPE_FARM_MEMBER)
9494 {
9495 return ERR_NOT_FARM_MEMBER;
9496 }
9497
9498 Zero(t, sizeof(RPC_FARM_CONNECTION_STATUS));
9499
9500 fc = s->FarmController;
9501
9502 Lock(fc->lock);
9503 {
9504 if (fc->Sock != NULL)
9505 {
9506 t->Ip = IPToUINT(&fc->Sock->RemoteIP);
9507 t->Port = fc->Sock->RemotePort;
9508 }
9509
9510 t->Online = fc->Online;
9511 t->LastError = ERR_NO_ERROR;
9512
9513 if (t->Online == false)
9514 {
9515 t->LastError = fc->LastError;
9516 }
9517 else
9518 {
9519 t->CurrentConnectedTime = fc->CurrentConnectedTime;
9520 }
9521
9522 t->StartedTime = fc->StartedTime;
9523 t->FirstConnectedTime = fc->FirstConnectedTime;
9524
9525 t->NumConnected = fc->NumConnected;
9526 t->NumTry = fc->NumTry;
9527 t->NumFailed = fc->NumFailed;
9528 }
9529 Unlock(fc->lock);
9530
9531 return ERR_NO_ERROR;
9532 }
9533
9534 // Enumerate cluster members
StEnumFarmMember(ADMIN * a,RPC_ENUM_FARM * t)9535 UINT StEnumFarmMember(ADMIN *a, RPC_ENUM_FARM *t)
9536 {
9537 SERVER *s = a->Server;
9538 CEDAR *c = s->Cedar;
9539 UINT i;
9540
9541 FreeRpcEnumFarm(t);
9542 Zero(t, sizeof(RPC_ENUM_FARM));
9543
9544 if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER)
9545 {
9546 return ERR_NOT_FARM_CONTROLLER;
9547 }
9548
9549 Zero(t, sizeof(RPC_ENUM_FARM));
9550
9551 LockList(s->FarmMemberList);
9552 {
9553 t->NumFarm = LIST_NUM(s->FarmMemberList);
9554 t->Farms = ZeroMalloc(sizeof(RPC_ENUM_FARM_ITEM) * t->NumFarm);
9555
9556 for (i = 0;i < t->NumFarm;i++)
9557 {
9558 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);
9559 RPC_ENUM_FARM_ITEM *e = &t->Farms[i];
9560
9561 e->Id = POINTER_TO_KEY(f);
9562 e->Controller = f->Me;
9563
9564 if (e->Controller)
9565 {
9566 e->ConnectedTime = TickToTime(c->CreatedTick);
9567 e->Ip = 0x0100007f;
9568 GetMachineName(e->Hostname, sizeof(e->Hostname));
9569 e->Point = f->Point;
9570 e->NumSessions = Count(c->CurrentSessions);
9571 e->NumTcpConnections = Count(c->CurrentTcpConnections);
9572
9573 e->AssignedBridgeLicense = Count(c->AssignedBridgeLicense);
9574 e->AssignedClientLicense = Count(c->AssignedClientLicense);
9575 }
9576 else
9577 {
9578 e->ConnectedTime = f->ConnectedTime;
9579 e->Ip = f->Ip;
9580 StrCpy(e->Hostname, sizeof(e->Hostname), f->hostname);
9581 e->Point = f->Point;
9582 e->NumSessions = f->NumSessions;
9583 e->NumTcpConnections = f->NumTcpConnections;
9584
9585 e->AssignedBridgeLicense = f->AssignedBridgeLicense;
9586 e->AssignedClientLicense = f->AssignedClientLicense;
9587 }
9588 e->NumHubs = LIST_NUM(f->HubList);
9589 }
9590 }
9591 UnlockList(s->FarmMemberList);
9592
9593 return ERR_NO_ERROR;
9594 }
9595
9596 // Get cluster member information
StGetFarmInfo(ADMIN * a,RPC_FARM_INFO * t)9597 UINT StGetFarmInfo(ADMIN *a, RPC_FARM_INFO *t)
9598 {
9599 SERVER *s = a->Server;
9600 UINT id = t->Id;
9601 UINT i;
9602 UINT ret = ERR_NO_ERROR;
9603
9604 FreeRpcFarmInfo(t);
9605 Zero(t, sizeof(RPC_FARM_INFO));
9606
9607 if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER)
9608 {
9609 return ERR_NOT_FARM_CONTROLLER;
9610 }
9611
9612 LockList(s->FarmMemberList);
9613 {
9614 if (IsInListKey(s->FarmMemberList, id))
9615 {
9616 FARM_MEMBER *f = ListKeyToPointer(s->FarmMemberList, id);
9617
9618 t->Id = id;
9619 t->Controller = f->Me;
9620 t->Weight = f->Weight;
9621
9622 LockList(f->HubList);
9623 {
9624 t->NumFarmHub = LIST_NUM(f->HubList);
9625 t->FarmHubs = ZeroMalloc(sizeof(RPC_FARM_HUB) * t->NumFarmHub);
9626
9627 for (i = 0;i < t->NumFarmHub;i++)
9628 {
9629 RPC_FARM_HUB *h = &t->FarmHubs[i];
9630 HUB_LIST *hh = LIST_DATA(f->HubList, i);
9631
9632 h->DynamicHub = hh->DynamicHub;
9633 StrCpy(h->HubName, sizeof(h->HubName), hh->Name);
9634 }
9635 }
9636 UnlockList(f->HubList);
9637
9638 if (t->Controller)
9639 {
9640 t->ConnectedTime = TickToTime(s->Cedar->CreatedTick);
9641 t->Ip = 0x0100007f;
9642 GetMachineName(t->Hostname, sizeof(t->Hostname));
9643 t->Point = f->Point;
9644
9645 LockList(s->ServerListenerList);
9646 {
9647 UINT i, n;
9648 t->NumPort = 0;
9649 for (i = 0;i < LIST_NUM(s->ServerListenerList);i++)
9650 {
9651 SERVER_LISTENER *o = LIST_DATA(s->ServerListenerList, i);
9652 if (o->Enabled)
9653 {
9654 t->NumPort++;
9655 }
9656 }
9657 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);
9658 n = 0;
9659 for (i = 0;i < LIST_NUM(s->ServerListenerList);i++)
9660 {
9661 SERVER_LISTENER *o = LIST_DATA(s->ServerListenerList, i);
9662 if (o->Enabled)
9663 {
9664 t->Ports[n++] = o->Port;
9665 }
9666 }
9667 }
9668 UnlockList(s->ServerListenerList);
9669
9670 t->ServerCert = CloneX(s->Cedar->ServerX);
9671 t->NumSessions = Count(s->Cedar->CurrentSessions);
9672 t->NumTcpConnections = Count(s->Cedar->CurrentTcpConnections);
9673 }
9674 else
9675 {
9676 t->ConnectedTime = f->ConnectedTime;
9677 t->Ip = f->Ip;
9678 StrCpy(t->Hostname, sizeof(t->Hostname), f->hostname);
9679 t->Point = f->Point;
9680 t->NumPort = f->NumPort;
9681 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);
9682 Copy(t->Ports, f->Ports, sizeof(UINT) * t->NumPort);
9683 t->ServerCert = CloneX(f->ServerCert);
9684 t->NumSessions = f->NumSessions;
9685 t->NumTcpConnections = f->NumTcpConnections;
9686 }
9687 }
9688 else
9689 {
9690 ret = ERR_OBJECT_NOT_FOUND;
9691 }
9692 }
9693 UnlockList(s->FarmMemberList);
9694
9695 return ret;
9696 }
9697
9698 // Get clustering configuration
StGetFarmSetting(ADMIN * a,RPC_FARM * t)9699 UINT StGetFarmSetting(ADMIN *a, RPC_FARM *t)
9700 {
9701 SERVER *s;
9702 FreeRpcFarm(t);
9703 Zero(t, sizeof(RPC_FARM));
9704
9705 s = a->Server;
9706 t->ServerType = s->ServerType;
9707 t->ControllerOnly = s->ControllerOnly;
9708 t->Weight = s->Weight;
9709
9710 if (t->ServerType == SERVER_TYPE_FARM_MEMBER)
9711 {
9712 t->NumPort = s->NumPublicPort;
9713 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);
9714 Copy(t->Ports, s->PublicPorts, sizeof(UINT) * t->NumPort);
9715 t->PublicIp = s->PublicIp;
9716 StrCpy(t->ControllerName, sizeof(t->ControllerName), s->ControllerName);
9717 t->ControllerPort = s->ControllerPort;
9718 }
9719 else
9720 {
9721 t->NumPort = 0;
9722 t->Ports = ZeroMalloc(0);
9723 }
9724
9725 return ERR_NO_ERROR;
9726 }
9727
9728 // Set clustering configuration
StSetFarmSetting(ADMIN * a,RPC_FARM * t)9729 UINT StSetFarmSetting(ADMIN *a, RPC_FARM *t)
9730 {
9731 bool cluster_allowed = false;
9732
9733 SERVER_ADMIN_ONLY;
9734 NO_SUPPORT_FOR_BRIDGE;
9735
9736
9737 cluster_allowed = GetServerCapsInt(a->Server, "b_support_cluster");
9738
9739 if (t->ServerType != SERVER_TYPE_STANDALONE && cluster_allowed == false)
9740 {
9741 // When clustering function is disabled, deny turning into clustering mode
9742 return ERR_NOT_SUPPORTED;
9743 }
9744
9745 if (IsZero(t->MemberPassword, sizeof(t->MemberPassword)))
9746 {
9747 if (IsEmptyStr(t->MemberPasswordPlaintext) == false)
9748 {
9749 // For JSON-RPC
9750 HashAdminPassword(t->MemberPassword, t->MemberPasswordPlaintext);
9751 }
9752 }
9753
9754 ALog(a, NULL, "LA_SET_FARM_SETTING");
9755
9756 IncrementServerConfigRevision(a->Server);
9757
9758 SiSetServerType(a->Server, t->ServerType, t->PublicIp, t->NumPort, t->Ports,
9759 t->ControllerName, t->ControllerPort, t->MemberPassword, t->Weight, t->ControllerOnly);
9760
9761 return ERR_NO_ERROR;
9762 }
9763
9764 // Set server password
StSetServerPassword(ADMIN * a,RPC_SET_PASSWORD * t)9765 UINT StSetServerPassword(ADMIN *a, RPC_SET_PASSWORD *t)
9766 {
9767 SERVER_ADMIN_ONLY;
9768
9769
9770 if (IsZero(t->HashedPassword, sizeof(t->HashedPassword)))
9771 {
9772 // For JSON-RPC
9773 HashAdminPassword(t->HashedPassword, t->PlainTextPassword);
9774 }
9775
9776 Copy(a->Server->HashedPassword, t->HashedPassword, SHA1_SIZE);
9777
9778 ALog(a, NULL, "LA_SET_SERVER_PASSWORD");
9779
9780 IncrementServerConfigRevision(a->Server);
9781
9782 return ERR_NO_ERROR;
9783 }
9784
9785 // Enable / Disable listener
StEnableListener(ADMIN * a,RPC_LISTENER * t)9786 UINT StEnableListener(ADMIN *a, RPC_LISTENER *t)
9787 {
9788 UINT ret = ERR_NO_ERROR;
9789
9790 SERVER_ADMIN_ONLY;
9791
9792
9793 LockList(a->Server->ServerListenerList);
9794 {
9795 if (t->Enable)
9796 {
9797 if (SiEnableListener(a->Server, t->Port) == false)
9798 {
9799 ret = ERR_LISTENER_NOT_FOUND;
9800 }
9801 else
9802 {
9803 ALog(a, NULL, "LA_ENABLE_LISTENER", t->Port);
9804 }
9805 }
9806 else
9807 {
9808 if (SiDisableListener(a->Server, t->Port) == false)
9809 {
9810 ret = ERR_LISTENER_NOT_FOUND;
9811 }
9812 else
9813 {
9814 ALog(a, NULL, "LA_DISABLE_LISTENER", t->Port);
9815 }
9816 }
9817 }
9818 UnlockList(a->Server->ServerListenerList);
9819
9820 IncrementServerConfigRevision(a->Server);
9821
9822 SleepThread(250);
9823
9824 return ret;
9825 }
9826
9827 // Delete a listener
StDeleteListener(ADMIN * a,RPC_LISTENER * t)9828 UINT StDeleteListener(ADMIN *a, RPC_LISTENER *t)
9829 {
9830 UINT ret = ERR_NO_ERROR;
9831
9832 SERVER_ADMIN_ONLY;
9833
9834
9835 LockList(a->Server->ServerListenerList);
9836 {
9837 if (SiDeleteListener(a->Server, t->Port) == false)
9838 {
9839 ret = ERR_LISTENER_NOT_FOUND;
9840 }
9841 else
9842 {
9843 ALog(a, NULL, "LA_DELETE_LISTENER", t->Port);
9844
9845 IncrementServerConfigRevision(a->Server);
9846 }
9847 }
9848 UnlockList(a->Server->ServerListenerList);
9849
9850 return ret;
9851 }
9852
9853 // Enumerating listeners
StEnumListener(ADMIN * a,RPC_LISTENER_LIST * t)9854 UINT StEnumListener(ADMIN *a, RPC_LISTENER_LIST *t)
9855 {
9856 CEDAR *c = a->Server->Cedar;
9857 UINT i;
9858
9859 FreeRpcListenerList(t);
9860 Zero(t, sizeof(RPC_LISTENER_LIST));
9861
9862 LockList(a->Server->ServerListenerList);
9863 {
9864 t->NumPort = LIST_NUM(a->Server->ServerListenerList);
9865 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);
9866 t->Enables = ZeroMalloc(sizeof(bool) * t->NumPort);
9867 t->Errors = ZeroMalloc(sizeof(bool) * t->NumPort);
9868
9869 for (i = 0;i < t->NumPort;i++)
9870 {
9871 SERVER_LISTENER *o = LIST_DATA(a->Server->ServerListenerList, i);
9872
9873 t->Ports[i] = o->Port;
9874 t->Enables[i] = o->Enabled;
9875 if (t->Enables[i])
9876 {
9877 if (o->Listener->Status == LISTENER_STATUS_TRYING)
9878 {
9879 t->Errors[i] = true;
9880 }
9881 }
9882 }
9883 }
9884 UnlockList(a->Server->ServerListenerList);
9885
9886 return ERR_NO_ERROR;
9887 }
9888
9889 // Create a listener
StCreateListener(ADMIN * a,RPC_LISTENER * t)9890 UINT StCreateListener(ADMIN *a, RPC_LISTENER *t)
9891 {
9892 UINT ret = ERR_NO_ERROR;
9893 CEDAR *c = a->Server->Cedar;
9894
9895 if (t->Port == 0 || t->Port > 65535)
9896 {
9897 return ERR_INVALID_PARAMETER;
9898 }
9899
9900 SERVER_ADMIN_ONLY;
9901
9902 LockList(a->Server->ServerListenerList);
9903 {
9904 if (SiAddListener(a->Server, t->Port, t->Enable) == false)
9905 {
9906 ret = ERR_LISTENER_ALREADY_EXISTS;
9907 }
9908 else
9909 {
9910 ALog(a, NULL, "LA_CREATE_LISTENER", t->Port);
9911
9912 IncrementServerConfigRevision(a->Server);
9913 }
9914 }
9915 UnlockList(a->Server->ServerListenerList);
9916
9917 SleepThread(250);
9918
9919 return ret;
9920 }
9921
9922 // Get server status
StGetServerStatus(ADMIN * a,RPC_SERVER_STATUS * t)9923 UINT StGetServerStatus(ADMIN *a, RPC_SERVER_STATUS *t)
9924 {
9925 CEDAR *c;
9926 UINT i;
9927
9928 c = a->Server->Cedar;
9929
9930 Zero(t, sizeof(RPC_SERVER_STATUS));
9931
9932 Lock(c->TrafficLock);
9933 {
9934 Copy(&t->Traffic, c->Traffic, sizeof(TRAFFIC));
9935 }
9936 Unlock(c->TrafficLock);
9937
9938 GetMemInfo(&t->MemInfo);
9939
9940 t->ServerType = a->Server->ServerType;
9941 t->NumTcpConnections = t->NumTcpConnectionsLocal = t->NumTcpConnectionsRemote = 0;
9942 t->NumSessionsTotal = t->NumSessionsLocal = t->NumSessionsRemote = 0;
9943
9944 t->NumTcpConnectionsLocal = Count(c->CurrentTcpConnections);
9945
9946 if (a->Server->ServerType == SERVER_TYPE_FARM_CONTROLLER)
9947 {
9948 LockList(a->Server->FarmMemberList);
9949 {
9950 for (i = 0;i < LIST_NUM(a->Server->FarmMemberList);i++)
9951 {
9952 FARM_MEMBER *f = LIST_DATA(a->Server->FarmMemberList, i);
9953
9954 if (f->Me == false)
9955 {
9956 t->NumTcpConnectionsRemote += f->NumTcpConnections;
9957 t->NumSessionsRemote += f->NumSessions;
9958 AddTraffic(&t->Traffic, &f->Traffic);
9959 }
9960 }
9961 }
9962 UnlockList(a->Server->FarmMemberList);
9963 }
9964
9965 t->NumMacTables = t->NumIpTables = t->NumUsers = t->NumGroups = 0;
9966
9967 // The number of hubs
9968 LockList(c->HubList);
9969 {
9970 t->NumHubTotal = LIST_NUM(c->HubList);
9971
9972 t->NumHubStandalone = t->NumHubDynamic = t->NumHubStatic = 0;
9973
9974 for (i = 0;i < LIST_NUM(c->HubList);i++)
9975 {
9976 HUB *h = LIST_DATA(c->HubList, i);
9977 Lock(h->lock);
9978 {
9979 switch (h->Type)
9980 {
9981 case HUB_TYPE_STANDALONE:
9982 t->NumHubStandalone++;
9983 break;
9984
9985 case HUB_TYPE_FARM_STATIC:
9986 t->NumHubStatic++;
9987 break;
9988
9989 case HUB_TYPE_FARM_DYNAMIC:
9990 t->NumHubDynamic++;
9991 break;
9992 }
9993 }
9994
9995 t->NumMacTables += HASH_LIST_NUM(h->MacHashTable);
9996 t->NumIpTables += LIST_NUM(h->IpTable);
9997
9998 if (h->HubDb != NULL)
9999 {
10000 t->NumUsers += LIST_NUM(h->HubDb->UserList);
10001 t->NumGroups += LIST_NUM(h->HubDb->GroupList);
10002 }
10003
10004 Unlock(h->lock);
10005 }
10006 }
10007 UnlockList(c->HubList);
10008
10009 // The number of sessions
10010 t->NumSessionsLocal = Count(c->CurrentSessions);
10011 t->NumSessionsTotal = t->NumSessionsLocal + t->NumSessionsRemote;
10012 t->NumTcpConnections = t->NumTcpConnectionsLocal + t->NumTcpConnectionsRemote;
10013
10014 t->AssignedBridgeLicenses = Count(c->AssignedBridgeLicense);
10015 t->AssignedClientLicenses = Count(c->AssignedClientLicense);
10016
10017 t->AssignedBridgeLicensesTotal = a->Server->CurrentAssignedBridgeLicense;
10018 t->AssignedClientLicensesTotal = a->Server->CurrentAssignedClientLicense;
10019
10020 t->CurrentTick = Tick64();
10021 t->CurrentTime = SystemTime64();
10022
10023 t->StartTime = a->Server->StartTime;
10024
10025 return ERR_NO_ERROR;
10026 }
10027
10028 // Get server information
StGetServerInfo(ADMIN * a,RPC_SERVER_INFO * t)10029 UINT StGetServerInfo(ADMIN *a, RPC_SERVER_INFO *t)
10030 {
10031 CEDAR *c;
10032 OS_INFO *info;
10033 SYSTEMTIME st;
10034 // Validate arguments
10035 if (a == NULL || t == NULL)
10036 {
10037 return ERR_INTERNAL_ERROR;
10038 }
10039
10040 FreeRpcServerInfo(t);
10041 Zero(t, sizeof(RPC_SERVER_INFO));
10042
10043 c = a->Server->Cedar;
10044
10045 GetServerProductName(a->Server, t->ServerProductName, sizeof(t->ServerProductName));
10046
10047 StrCpy(t->ServerVersionString, sizeof(t->ServerVersionString), c->VerString);
10048 StrCpy(t->ServerBuildInfoString, sizeof(t->ServerBuildInfoString), c->BuildInfo);
10049 t->ServerVerInt = c->Version;
10050 t->ServerBuildInt = c->Build;
10051 GetMachineName(t->ServerHostName, sizeof(t->ServerHostName));
10052 t->ServerType = c->Server->ServerType;
10053
10054 Zero(&st, sizeof(st));
10055 st.wYear = BUILD_DATE_Y;
10056 st.wMonth = BUILD_DATE_M;
10057 st.wDay = BUILD_DATE_D;
10058 st.wHour = BUILD_DATE_HO;
10059 st.wMinute = BUILD_DATE_MI;
10060 st.wSecond = BUILD_DATE_SE;
10061
10062 t->ServerBuildDate = SystemToUINT64(&st);
10063 StrCpy(t->ServerFamilyName, sizeof(t->ServerFamilyName), UPDATE_FAMILY_NAME);
10064
10065 info = GetOsInfo();
10066 if (info != NULL)
10067 {
10068 CopyOsInfo(&t->OsInfo, info);
10069 }
10070
10071 return ERR_NO_ERROR;
10072 }
10073
10074 // Copy OS_INFO
CopyOsInfo(OS_INFO * dst,OS_INFO * info)10075 void CopyOsInfo(OS_INFO *dst, OS_INFO *info)
10076 {
10077 // Validate arguments
10078 if (info == NULL || dst == NULL)
10079 {
10080 return;
10081 }
10082
10083 dst->OsType = info->OsType;
10084 dst->OsServicePack = info->OsServicePack;
10085 dst->OsSystemName = CopyStr(info->OsSystemName);
10086 dst->OsProductName = CopyStr(info->OsProductName);
10087 dst->OsVendorName = CopyStr(info->OsVendorName);
10088 dst->OsVersion = CopyStr(info->OsVersion);
10089 dst->KernelName = CopyStr(info->KernelName);
10090 dst->KernelVersion = CopyStr(info->KernelVersion);
10091 }
10092
10093 // OPENVPN_SSTP_CONFIG
InOpenVpnSstpConfig(OPENVPN_SSTP_CONFIG * t,PACK * p)10094 void InOpenVpnSstpConfig(OPENVPN_SSTP_CONFIG *t, PACK *p)
10095 {
10096 // Validate arguments
10097 if (t == NULL || p == NULL)
10098 {
10099 return;
10100 }
10101
10102 Zero(t, sizeof(OPENVPN_SSTP_CONFIG));
10103
10104 t->EnableOpenVPN = PackGetBool(p, "EnableOpenVPN");
10105 t->EnableSSTP = PackGetBool(p, "EnableSSTP");
10106 PackGetStr(p, "OpenVPNPortList", t->OpenVPNPortList, sizeof(t->OpenVPNPortList));
10107 }
OutOpenVpnSstpConfig(PACK * p,OPENVPN_SSTP_CONFIG * t)10108 void OutOpenVpnSstpConfig(PACK *p, OPENVPN_SSTP_CONFIG *t)
10109 {
10110 // Validate arguments
10111 if (t == NULL || p == NULL)
10112 {
10113 return;
10114 }
10115
10116 PackAddBool(p, "EnableOpenVPN", t->EnableOpenVPN);
10117 PackAddBool(p, "EnableSSTP", t->EnableSSTP);
10118 PackAddStr(p, "OpenVPNPortList", t->OpenVPNPortList);
10119 }
10120
10121 // DDNS_CLIENT_STATUS
InDDnsClientStatus(DDNS_CLIENT_STATUS * t,PACK * p)10122 void InDDnsClientStatus(DDNS_CLIENT_STATUS *t, PACK *p)
10123 {
10124 // Validate arguments
10125 if (t == NULL || p == NULL)
10126 {
10127 return;
10128 }
10129
10130 Zero(t, sizeof(DDNS_CLIENT_STATUS));
10131
10132 t->Err_IPv4 = PackGetInt(p, "Err_IPv4");
10133 t->Err_IPv6 = PackGetInt(p, "Err_IPv6");
10134
10135 PackGetStr(p, "CurrentHostName", t->CurrentHostName, sizeof(t->CurrentHostName));
10136 PackGetStr(p, "CurrentFqdn", t->CurrentFqdn, sizeof(t->CurrentFqdn));
10137 PackGetStr(p, "DnsSuffix", t->DnsSuffix, sizeof(t->DnsSuffix));
10138 PackGetStr(p, "CurrentIPv4", t->CurrentIPv4, sizeof(t->CurrentIPv4));
10139 PackGetStr(p, "CurrentIPv6", t->CurrentIPv6, sizeof(t->CurrentIPv6));
10140 PackGetUniStr(p, "ErrStr_IPv4", t->ErrStr_IPv4, sizeof(t->ErrStr_IPv4));
10141 PackGetUniStr(p, "ErrStr_IPv6", t->ErrStr_IPv6, sizeof(t->ErrStr_IPv6));
10142 }
OutDDnsClientStatus(PACK * p,DDNS_CLIENT_STATUS * t)10143 void OutDDnsClientStatus(PACK *p, DDNS_CLIENT_STATUS *t)
10144 {
10145 // Validate arguments
10146 if (t == NULL || p == NULL)
10147 {
10148 return;
10149 }
10150
10151 PackAddInt(p, "Err_IPv4", t->Err_IPv4);
10152 PackAddInt(p, "Err_IPv6", t->Err_IPv6);
10153 PackAddStr(p, "CurrentHostName", t->CurrentHostName);
10154 PackAddStr(p, "CurrentFqdn", t->CurrentFqdn);
10155 PackAddStr(p, "DnsSuffix", t->DnsSuffix);
10156 PackAddStr(p, "CurrentIPv4", t->CurrentIPv4);
10157 PackAddStr(p, "CurrentIPv6", t->CurrentIPv6);
10158 PackAddUniStr(p, "ErrStr_IPv4", t->ErrStr_IPv4);
10159 PackAddUniStr(p, "ErrStr_IPv6", t->ErrStr_IPv6);
10160 }
10161
10162 // INTERNET_SETTING
InRpcInternetSetting(INTERNET_SETTING * t,PACK * p)10163 void InRpcInternetSetting(INTERNET_SETTING *t, PACK *p)
10164 {
10165 // Validate arguments
10166 if (t == NULL || p == NULL)
10167 {
10168 return;
10169 }
10170
10171 t->ProxyType = PackGetInt(p, "ProxyType");
10172 PackGetStr(p, "ProxyHostName", t->ProxyHostName, sizeof(t->ProxyHostName));
10173 t->ProxyPort = PackGetInt(p, "ProxyPort");
10174 PackGetStr(p, "ProxyUsername", t->ProxyUsername, sizeof(t->ProxyUsername));
10175 PackGetStr(p, "ProxyPassword", t->ProxyPassword, sizeof(t->ProxyPassword));
10176 }
OutRpcInternetSetting(PACK * p,INTERNET_SETTING * t)10177 void OutRpcInternetSetting(PACK *p, INTERNET_SETTING *t)
10178 {
10179 // Validate arguments
10180 if (t == NULL || p == NULL)
10181 {
10182 return;
10183 }
10184
10185 PackAddInt(p, "ProxyType", t->ProxyType);
10186 PackAddStr(p, "ProxyHostName", t->ProxyHostName);
10187 PackAddInt(p, "ProxyPort", t->ProxyPort);
10188 PackAddStr(p, "ProxyUsername", t->ProxyUsername);
10189 PackAddStr(p, "ProxyPassword", t->ProxyPassword);
10190 }
10191
10192 // RPC_AZURE_STATUS
InRpcAzureStatus(RPC_AZURE_STATUS * t,PACK * p)10193 void InRpcAzureStatus(RPC_AZURE_STATUS *t, PACK *p)
10194 {
10195 // Validate arguments
10196 if (t == NULL || p == NULL)
10197 {
10198 return;
10199 }
10200
10201 Zero(t, sizeof(RPC_AZURE_STATUS));
10202
10203 t->IsConnected = PackGetBool(p, "IsConnected");
10204 t->IsEnabled = PackGetBool(p, "IsEnabled");
10205 }
OutRpcAzureStatus(PACK * p,RPC_AZURE_STATUS * t)10206 void OutRpcAzureStatus(PACK *p, RPC_AZURE_STATUS *t)
10207 {
10208 // Validate arguments
10209 if (t == NULL || p == NULL)
10210 {
10211 return;
10212 }
10213
10214 PackAddBool(p, "IsConnected", t->IsConnected);
10215 PackAddBool(p, "IsEnabled", t->IsEnabled);
10216 }
10217
10218 // RPC_SPECIAL_LISTENER
InRpcSpecialListener(RPC_SPECIAL_LISTENER * t,PACK * p)10219 void InRpcSpecialListener(RPC_SPECIAL_LISTENER *t, PACK *p)
10220 {
10221 // Validate arguments
10222 if (t == NULL || p == NULL)
10223 {
10224 return;
10225 }
10226
10227 Zero(t, sizeof(RPC_SPECIAL_LISTENER));
10228
10229 t->VpnOverIcmpListener = PackGetBool(p, "VpnOverIcmpListener");
10230 t->VpnOverDnsListener = PackGetBool(p, "VpnOverDnsListener");
10231 }
OutRpcSpecialListener(PACK * p,RPC_SPECIAL_LISTENER * t)10232 void OutRpcSpecialListener(PACK *p, RPC_SPECIAL_LISTENER *t)
10233 {
10234 // Validate arguments
10235 if (t == NULL || p == NULL)
10236 {
10237 return;
10238 }
10239
10240 PackAddBool(p, "VpnOverIcmpListener", t->VpnOverIcmpListener);
10241 PackAddBool(p, "VpnOverDnsListener", t->VpnOverDnsListener);
10242 }
10243
10244
10245 // ETHERIP_ID
InEtherIpId(ETHERIP_ID * t,PACK * p)10246 void InEtherIpId(ETHERIP_ID *t, PACK *p)
10247 {
10248 // Validate arguments
10249 if (t == NULL || p == NULL)
10250 {
10251 return;
10252 }
10253
10254 Zero(t, sizeof(ETHERIP_ID));
10255
10256 PackGetStr(p, "Id", t->Id, sizeof(t->Id));
10257 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
10258 PackGetStr(p, "UserName", t->UserName, sizeof(t->UserName));
10259 PackGetStr(p, "Password", t->Password, sizeof(t->Password));
10260 }
OutEtherIpId(PACK * p,ETHERIP_ID * t)10261 void OutEtherIpId(PACK *p, ETHERIP_ID *t)
10262 {
10263 // Validate arguments
10264 if (t == NULL || p == NULL)
10265 {
10266 return;
10267 }
10268
10269 PackAddStr(p, "Id", t->Id);
10270 PackAddStr(p, "HubName", t->HubName);
10271 PackAddStr(p, "UserName", t->UserName);
10272 PackAddStr(p, "Password", t->Password);
10273 }
10274
10275 // RPC_ENUM_ETHERIP_ID
InRpcEnumEtherIpId(RPC_ENUM_ETHERIP_ID * t,PACK * p)10276 void InRpcEnumEtherIpId(RPC_ENUM_ETHERIP_ID *t, PACK *p)
10277 {
10278 UINT i;
10279 // Validate arguments
10280 if (t == NULL || p == NULL)
10281 {
10282 return;
10283 }
10284
10285 Zero(t, sizeof(RPC_ENUM_ETHERIP_ID));
10286
10287 t->NumItem = PackGetInt(p, "NumItem");
10288 t->IdList = ZeroMalloc(sizeof(ETHERIP_ID) * t->NumItem);
10289
10290 for (i = 0;i < t->NumItem;i++)
10291 {
10292 ETHERIP_ID *e = &t->IdList[i];
10293
10294 PackGetStrEx(p, "Id", e->Id, sizeof(e->Id), i);
10295 PackGetStrEx(p, "HubName", e->HubName, sizeof(e->HubName), i);
10296 PackGetStrEx(p, "UserName", e->UserName, sizeof(e->UserName), i);
10297 PackGetStrEx(p, "Password", e->Password, sizeof(e->Password), i);
10298 }
10299 }
OutRpcEnumEtherIpId(PACK * p,RPC_ENUM_ETHERIP_ID * t)10300 void OutRpcEnumEtherIpId(PACK *p, RPC_ENUM_ETHERIP_ID *t)
10301 {
10302 UINT i;
10303 // Validate arguments
10304 if (p == NULL || t == NULL)
10305 {
10306 return;
10307 }
10308
10309 PackAddInt(p, "NumItem", t->NumItem);
10310
10311 PackSetCurrentJsonGroupName(p, "Settings");
10312 for (i = 0;i < t->NumItem;i++)
10313 {
10314 ETHERIP_ID *e = &t->IdList[i];
10315
10316 PackAddStrEx(p, "Id", e->Id, i, t->NumItem);
10317 PackAddStrEx(p, "HubName", e->HubName, i, t->NumItem);
10318 PackAddStrEx(p, "UserName", e->UserName, i, t->NumItem);
10319 PackAddStrEx(p, "Password", e->Password, i, t->NumItem);
10320 }
10321 PackSetCurrentJsonGroupName(p, NULL);
10322 }
FreeRpcEnumEtherIpId(RPC_ENUM_ETHERIP_ID * t)10323 void FreeRpcEnumEtherIpId(RPC_ENUM_ETHERIP_ID *t)
10324 {
10325 // Validate arguments
10326 if (t == NULL)
10327 {
10328 return;
10329 }
10330
10331 Free(t->IdList);
10332 }
10333
10334 // IPSEC_SERVICES
InIPsecServices(IPSEC_SERVICES * t,PACK * p)10335 void InIPsecServices(IPSEC_SERVICES *t, PACK *p)
10336 {
10337 // Validate arguments
10338 if (t == NULL || p == NULL)
10339 {
10340 return;
10341 }
10342
10343 Zero(t, sizeof(IPSEC_SERVICES));
10344
10345 t->L2TP_Raw = PackGetBool(p, "L2TP_Raw");
10346 t->L2TP_IPsec = PackGetBool(p, "L2TP_IPsec");
10347 t->EtherIP_IPsec = PackGetBool(p, "EtherIP_IPsec");
10348
10349 PackGetStr(p, "IPsec_Secret", t->IPsec_Secret, sizeof(t->IPsec_Secret));
10350 PackGetStr(p, "L2TP_DefaultHub", t->L2TP_DefaultHub, sizeof(t->L2TP_DefaultHub));
10351 }
OutIPsecServices(PACK * p,IPSEC_SERVICES * t)10352 void OutIPsecServices(PACK *p, IPSEC_SERVICES *t)
10353 {
10354 // Validate arguments
10355 if (t == NULL || p == NULL)
10356 {
10357 return;
10358 }
10359
10360 PackAddBool(p, "L2TP_Raw", t->L2TP_Raw);
10361 PackAddBool(p, "L2TP_IPsec", t->L2TP_IPsec);
10362 PackAddBool(p, "EtherIP_IPsec", t->EtherIP_IPsec);
10363
10364 PackAddStr(p, "IPsec_Secret", t->IPsec_Secret);
10365 PackAddStr(p, "L2TP_DefaultHub", t->L2TP_DefaultHub);
10366 }
10367
10368 // RPC_WINVER
InRpcWinVer(RPC_WINVER * t,PACK * p)10369 void InRpcWinVer(RPC_WINVER *t, PACK *p)
10370 {
10371 // Validate arguments
10372 if (t == NULL || p == NULL)
10373 {
10374 return;
10375 }
10376
10377 Zero(t, sizeof(RPC_WINVER));
10378
10379 t->IsWindows = PackGetBool(p, "V_IsWindows");
10380 t->IsNT = PackGetBool(p, "V_IsNT");
10381 t->IsServer = PackGetBool(p, "V_IsServer");
10382 t->IsBeta = PackGetBool(p, "V_IsBeta");
10383 t->VerMajor = PackGetInt(p, "V_VerMajor");
10384 t->VerMinor = PackGetInt(p, "V_VerMinor");
10385 t->Build = PackGetInt(p, "V_Build");
10386 t->ServicePack = PackGetInt(p, "V_ServicePack");
10387 PackGetStr(p, "V_Title", t->Title, sizeof(t->Title));
10388 }
OutRpcWinVer(PACK * p,RPC_WINVER * t)10389 void OutRpcWinVer(PACK *p, RPC_WINVER *t)
10390 {
10391 // Validate arguments
10392 if (t == NULL || p == NULL)
10393 {
10394 return;
10395 }
10396
10397 PackAddBool(p, "V_IsWindows", t->IsWindows);
10398 PackAddBool(p, "V_IsNT", t->IsNT);
10399 PackAddBool(p, "V_IsServer", t->IsServer);
10400 PackAddBool(p, "V_IsBeta", t->IsBeta);
10401 PackAddInt(p, "V_VerMajor", t->VerMajor);
10402 PackAddInt(p, "V_VerMinor", t->VerMinor);
10403 PackAddInt(p, "V_Build", t->Build);
10404 PackAddInt(p, "V_ServicePack", t->ServicePack);
10405 PackAddStr(p, "V_Title", t->Title);
10406 }
10407
10408 // RPC_MSG
InRpcMsg(RPC_MSG * t,PACK * p)10409 void InRpcMsg(RPC_MSG *t, PACK *p)
10410 {
10411 UINT size;
10412 char *utf8;
10413 // Validate arguments
10414 if (t == NULL || p == NULL)
10415 {
10416 return;
10417 }
10418
10419 Zero(t, sizeof(RPC_MSG));
10420
10421 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
10422 size = PackGetDataSize(p, "Msg");
10423 utf8 = ZeroMalloc(size + 8);
10424 PackGetData(p, "Msg", utf8);
10425 t->Msg = CopyUtfToUni(utf8);
10426 Free(utf8);
10427 }
OutRpcMsg(PACK * p,RPC_MSG * t)10428 void OutRpcMsg(PACK *p, RPC_MSG *t)
10429 {
10430 UINT size;
10431 char *utf8;
10432 // Validate arguments
10433 if (t == NULL || p == NULL)
10434 {
10435 return;
10436 }
10437
10438 PackAddStr(p, "HubName", t->HubName);
10439 utf8 = CopyUniToUtf(t->Msg);
10440 size = StrLen(utf8);
10441 PackAddData(p, "Msg", utf8, size);
10442 Free(utf8);
10443 }
FreeRpcMsg(RPC_MSG * t)10444 void FreeRpcMsg(RPC_MSG *t)
10445 {
10446 // Validate arguments
10447 if (t == NULL)
10448 {
10449 return;
10450 }
10451
10452 Free(t->Msg);
10453 }
10454
10455 // RPC_ENUM_ETH_VLAN
InRpcEnumEthVLan(RPC_ENUM_ETH_VLAN * t,PACK * p)10456 void InRpcEnumEthVLan(RPC_ENUM_ETH_VLAN *t, PACK *p)
10457 {
10458 UINT i;
10459 // Validate arguments
10460 if (t == NULL || p == NULL)
10461 {
10462 return;
10463 }
10464
10465 Zero(t, sizeof(RPC_ENUM_ETH_VLAN));
10466
10467 t->NumItem = PackGetIndexCount(p, "DeviceName");
10468 t->Items = ZeroMalloc(sizeof(RPC_ENUM_ETH_VLAN_ITEM) * t->NumItem);
10469
10470 for (i = 0;i < t->NumItem;i++)
10471 {
10472 RPC_ENUM_ETH_VLAN_ITEM *e = &t->Items[i];
10473
10474 PackGetStrEx(p, "DeviceName", e->DeviceName, sizeof(e->DeviceName), i);
10475 PackGetStrEx(p, "Guid", e->Guid, sizeof(e->Guid), i);
10476 PackGetStrEx(p, "DeviceInstanceId", e->DeviceInstanceId, sizeof(e->DeviceInstanceId), i);
10477 PackGetStrEx(p, "DriverName", e->DriverName, sizeof(e->DriverName), i);
10478 PackGetStrEx(p, "DriverType", e->DriverType, sizeof(e->DriverType), i);
10479 e->Support = PackGetBoolEx(p, "Support", i);
10480 e->Enabled = PackGetBoolEx(p, "Enabled", i);
10481 }
10482 }
OutRpcEnumEthVLan(PACK * p,RPC_ENUM_ETH_VLAN * t)10483 void OutRpcEnumEthVLan(PACK *p, RPC_ENUM_ETH_VLAN *t)
10484 {
10485 UINT i;
10486 // Validate arguments
10487 if (t == NULL || p == NULL)
10488 {
10489 return;
10490 }
10491
10492 PackSetCurrentJsonGroupName(p, "Devices");
10493 for (i = 0;i < t->NumItem;i++)
10494 {
10495 RPC_ENUM_ETH_VLAN_ITEM *e = &t->Items[i];
10496
10497 PackAddStrEx(p, "DeviceName", e->DeviceName, i, t->NumItem);
10498 PackAddStrEx(p, "Guid", e->Guid, i, t->NumItem);
10499 PackAddStrEx(p, "DeviceInstanceId", e->DeviceInstanceId, i, t->NumItem);
10500 PackAddStrEx(p, "DriverName", e->DriverName, i, t->NumItem);
10501 PackAddStrEx(p, "DriverType", e->DriverType, i, t->NumItem);
10502 PackAddBoolEx(p, "Support", e->Support, i, t->NumItem);
10503 PackAddBoolEx(p, "Enabled", e->Enabled, i, t->NumItem);
10504 }
10505 PackSetCurrentJsonGroupName(p, NULL);
10506 }
FreeRpcEnumEthVLan(RPC_ENUM_ETH_VLAN * t)10507 void FreeRpcEnumEthVLan(RPC_ENUM_ETH_VLAN *t)
10508 {
10509 // Validate arguments
10510 if (t == NULL)
10511 {
10512 return;
10513 }
10514
10515 Free(t->Items);
10516 }
10517
10518 // RPC_ENUM_LOG_FILE
InRpcEnumLogFile(RPC_ENUM_LOG_FILE * t,PACK * p)10519 void InRpcEnumLogFile(RPC_ENUM_LOG_FILE *t, PACK *p)
10520 {
10521 UINT i;
10522 // Validate arguments
10523 if (t == NULL || p == NULL)
10524 {
10525 return;
10526 }
10527
10528 Zero(t, sizeof(RPC_ENUM_LOG_FILE));
10529 t->NumItem = PackGetInt(p, "NumItem");
10530 t->Items = ZeroMalloc(sizeof(RPC_ENUM_LOG_FILE_ITEM) * t->NumItem);
10531
10532 for (i = 0;i < t->NumItem;i++)
10533 {
10534 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];
10535
10536 PackGetStrEx(p, "FilePath", e->FilePath, sizeof(e->FilePath), i);
10537 PackGetStrEx(p, "ServerName", e->ServerName, sizeof(e->ServerName), i);
10538 e->FileSize = PackGetIntEx(p, "FileSize", i);
10539 e->UpdatedTime = PackGetInt64Ex(p, "UpdatedTime", i);
10540 }
10541 }
OutRpcEnumLogFile(PACK * p,RPC_ENUM_LOG_FILE * t)10542 void OutRpcEnumLogFile(PACK *p, RPC_ENUM_LOG_FILE *t)
10543 {
10544 UINT i;
10545 // Validate arguments
10546 if (t == NULL || p == NULL)
10547 {
10548 return;
10549 }
10550
10551 PackAddInt(p, "NumItem", t->NumItem);
10552
10553 PackSetCurrentJsonGroupName(p, "LogFiles");
10554 for (i = 0;i < t->NumItem;i++)
10555 {
10556 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];
10557
10558 PackAddStrEx(p, "FilePath", e->FilePath, i, t->NumItem);
10559 PackAddStrEx(p, "ServerName", e->ServerName, i, t->NumItem);
10560 PackAddIntEx(p, "FileSize", e->FileSize, i, t->NumItem);
10561 PackAddTime64Ex(p, "UpdatedTime", e->UpdatedTime, i, t->NumItem);
10562 }
10563 PackSetCurrentJsonGroupName(p, NULL);
10564 }
FreeRpcEnumLogFile(RPC_ENUM_LOG_FILE * t)10565 void FreeRpcEnumLogFile(RPC_ENUM_LOG_FILE *t)
10566 {
10567 // Validate arguments
10568 if (t == NULL)
10569 {
10570 return;
10571 }
10572
10573 Free(t->Items);
10574 }
AdjoinRpcEnumLogFile(RPC_ENUM_LOG_FILE * t,RPC_ENUM_LOG_FILE * src)10575 void AdjoinRpcEnumLogFile(RPC_ENUM_LOG_FILE *t, RPC_ENUM_LOG_FILE *src)
10576 {
10577 LIST *o;
10578 UINT i;
10579 // Validate arguments
10580 if (t == NULL || src == NULL)
10581 {
10582 return;
10583 }
10584
10585 o = NewListFast(CmpLogFile);
10586
10587 for (i = 0;i < t->NumItem;i++)
10588 {
10589 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];
10590 LOG_FILE *f = ZeroMalloc(sizeof(LOG_FILE));
10591
10592 f->FileSize = e->FileSize;
10593 StrCpy(f->Path, sizeof(f->Path), e->FilePath);
10594 StrCpy(f->ServerName, sizeof(f->ServerName), e->ServerName);
10595 f->UpdatedTime = e->UpdatedTime;
10596
10597 Add(o, f);
10598 }
10599
10600 for (i = 0;i < src->NumItem;i++)
10601 {
10602 RPC_ENUM_LOG_FILE_ITEM *e = &src->Items[i];
10603 LOG_FILE *f = ZeroMalloc(sizeof(LOG_FILE));
10604
10605 f->FileSize = e->FileSize;
10606 StrCpy(f->Path, sizeof(f->Path), e->FilePath);
10607 StrCpy(f->ServerName, sizeof(f->ServerName), e->ServerName);
10608 f->UpdatedTime = e->UpdatedTime;
10609
10610 Add(o, f);
10611 }
10612
10613 FreeRpcEnumLogFile(t);
10614
10615 Sort(o);
10616
10617 Zero(t, sizeof(RPC_ENUM_LOG_FILE));
10618 t->NumItem = LIST_NUM(o);
10619 t->Items = ZeroMalloc(sizeof(RPC_ENUM_LOG_FILE_ITEM) * t->NumItem);
10620
10621 for (i = 0;i < t->NumItem;i++)
10622 {
10623 LOG_FILE *f = LIST_DATA(o, i);
10624 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];
10625
10626 StrCpy(e->FilePath, sizeof(e->FilePath), f->Path);
10627 StrCpy(e->ServerName, sizeof(e->ServerName), f->ServerName);
10628 e->FileSize = f->FileSize;
10629 e->UpdatedTime = f->UpdatedTime;
10630 }
10631
10632 FreeEnumLogFile(o);
10633 }
10634
10635 // RPC_READ_LOG_FILE
InRpcReadLogFile(RPC_READ_LOG_FILE * t,PACK * p)10636 void InRpcReadLogFile(RPC_READ_LOG_FILE *t, PACK *p)
10637 {
10638 // Validate arguments
10639 if (t == NULL || p == NULL)
10640 {
10641 return;
10642 }
10643
10644 Zero(t, sizeof(RPC_READ_LOG_FILE));
10645 PackGetStr(p, "FilePath", t->FilePath, sizeof(t->FilePath));
10646 PackGetStr(p, "ServerName", t->ServerName, sizeof(t->ServerName));
10647 t->Offset = PackGetInt(p, "Offset");
10648
10649 t->Buffer = PackGetBuf(p, "Buffer");
10650 }
OutRpcReadLogFile(PACK * p,RPC_READ_LOG_FILE * t)10651 void OutRpcReadLogFile(PACK *p, RPC_READ_LOG_FILE *t)
10652 {
10653 // Validate arguments
10654 if (p == NULL || t == NULL)
10655 {
10656 return;
10657 }
10658
10659 PackAddStr(p, "FilePath", t->FilePath);
10660 PackAddStr(p, "ServerName", t->ServerName);
10661 PackAddInt(p, "Offset", t->Offset);
10662
10663 if (t->Buffer != NULL)
10664 {
10665 PackAddBuf(p, "Buffer", t->Buffer);
10666 }
10667 }
FreeRpcReadLogFile(RPC_READ_LOG_FILE * t)10668 void FreeRpcReadLogFile(RPC_READ_LOG_FILE *t)
10669 {
10670 // Validate arguments
10671 if (t == NULL)
10672 {
10673 return;
10674 }
10675
10676 if (t->Buffer != NULL)
10677 {
10678 FreeBuf(t->Buffer);
10679 }
10680 }
10681
10682 // RPC_AC_LIST
InRpcAcList(RPC_AC_LIST * t,PACK * p)10683 void InRpcAcList(RPC_AC_LIST *t, PACK *p)
10684 {
10685 UINT i;
10686 LIST *o;
10687 UINT num;
10688 // Validate arguments
10689 if (t == NULL || p == NULL)
10690 {
10691 return;
10692 }
10693
10694 Zero(t, sizeof(RPC_AC_LIST));
10695 o = NewAcList();
10696
10697 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
10698 num = PackGetIndexCount(p, "IpAddress");
10699
10700 for (i = 0;i < num;i++)
10701 {
10702 AC *ac = ZeroMalloc(sizeof(AC));
10703
10704 ac->Id = PackGetIntEx(p, "Id", i);
10705 ac->Deny = PackGetBoolEx(p, "Deny", i);
10706 PackGetIpEx(p, "IpAddress", &ac->IpAddress, i);
10707 ac->Masked = PackGetBoolEx(p, "Masked", i);
10708
10709 if (ac->Masked)
10710 {
10711 PackGetIpEx(p, "SubnetMask", &ac->SubnetMask, i);
10712 }
10713
10714 ac->Priority = PackGetIntEx(p, "Priority", i);
10715
10716 AddAc(o, ac);
10717
10718 Free(ac);
10719 }
10720
10721 t->o = o;
10722 }
OutRpcAcList(PACK * p,RPC_AC_LIST * t)10723 void OutRpcAcList(PACK *p, RPC_AC_LIST *t)
10724 {
10725 UINT i, num;
10726 LIST *o;
10727 // Validate arguments
10728 if (t == NULL || p == NULL)
10729 {
10730 return;
10731 }
10732
10733 o = t->o;
10734 num = LIST_NUM(o);
10735
10736 PackAddInt(p, "NumItem", num);
10737
10738 PackAddStr(p, "HubName", t->HubName);
10739
10740 PackSetCurrentJsonGroupName(p, "ACList");
10741 for (i = 0;i < num;i++)
10742 {
10743 AC *ac = LIST_DATA(o, i);
10744
10745 PackAddIntEx(p, "Id", ac->Id, i, num);
10746 PackAddBoolEx(p, "Deny", ac->Deny, i, num);
10747 PackAddIpEx(p, "IpAddress", &ac->IpAddress, i, num);
10748 PackAddBoolEx(p, "Masked", ac->Masked, i, num);
10749
10750 PackAddIpEx(p, "SubnetMask", &ac->SubnetMask, i, num);
10751
10752 PackAddIntEx(p, "Priority", ac->Priority, i, num);
10753 }
10754 PackSetCurrentJsonGroupName(p, NULL);
10755 }
FreeRpcAcList(RPC_AC_LIST * t)10756 void FreeRpcAcList(RPC_AC_LIST *t)
10757 {
10758 // Validate arguments
10759 if (t == NULL)
10760 {
10761 return;
10762 }
10763
10764 FreeAcList(t->o);
10765 }
10766
10767 // RPC_INT
InRpcInt(RPC_INT * t,PACK * p)10768 void InRpcInt(RPC_INT *t, PACK *p)
10769 {
10770 // Validate arguments
10771 if (t == NULL || p == NULL)
10772 {
10773 return;
10774 }
10775
10776 Zero(t, sizeof(RPC_INT));
10777 t->IntValue = PackGetInt(p, "IntValue");
10778 }
OutRpcInt(PACK * p,RPC_INT * t)10779 void OutRpcInt(PACK *p, RPC_INT *t)
10780 {
10781 // Validate arguments
10782 if (t == NULL || p == NULL)
10783 {
10784 return;
10785 }
10786
10787 PackAddInt(p, "IntValue", t->IntValue);
10788 }
10789
10790 // RPC_ENUM_CRL
InRpcEnumCrl(RPC_ENUM_CRL * t,PACK * p)10791 void InRpcEnumCrl(RPC_ENUM_CRL *t, PACK *p)
10792 {
10793 UINT i;
10794 // Validate arguments
10795 if (t == NULL || p == NULL)
10796 {
10797 return;
10798 }
10799
10800 Zero(t, sizeof(RPC_ENUM_CRL));
10801 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
10802 t->NumItem = PackGetInt(p, "NumItem");
10803
10804 t->Items = ZeroMalloc(sizeof(RPC_ENUM_CRL_ITEM) * t->NumItem);
10805 for (i = 0;i < t->NumItem;i++)
10806 {
10807 RPC_ENUM_CRL_ITEM *e = &t->Items[i];
10808
10809 e->Key = PackGetIntEx(p, "Key", i);
10810 PackGetUniStrEx(p, "CrlInfo", e->CrlInfo, sizeof(e->CrlInfo), i);
10811 }
10812 }
OutRpcEnumCrl(PACK * p,RPC_ENUM_CRL * t)10813 void OutRpcEnumCrl(PACK *p, RPC_ENUM_CRL *t)
10814 {
10815 UINT i;
10816 // Validate arguments
10817 if (t == NULL || p == NULL)
10818 {
10819 return;
10820 }
10821
10822 PackAddStr(p, "HubName", t->HubName);
10823 PackAddInt(p, "NumItem", t->NumItem);
10824
10825 PackSetCurrentJsonGroupName(p, "CRLList");
10826 for (i = 0;i < t->NumItem;i++)
10827 {
10828 RPC_ENUM_CRL_ITEM *e = &t->Items[i];
10829
10830 PackAddIntEx(p, "Key", e->Key, i, t->NumItem);
10831 PackAddUniStrEx(p, "CrlInfo", e->CrlInfo, i, t->NumItem);
10832 }
10833 PackSetCurrentJsonGroupName(p, NULL);
10834 }
FreeRpcEnumCrl(RPC_ENUM_CRL * t)10835 void FreeRpcEnumCrl(RPC_ENUM_CRL *t)
10836 {
10837 // Validate arguments
10838 if (t == NULL)
10839 {
10840 return;
10841 }
10842
10843 Free(t->Items);
10844 }
10845
10846 // RPC_CRL
InRpcCrl(RPC_CRL * t,PACK * p)10847 void InRpcCrl(RPC_CRL *t, PACK *p)
10848 {
10849 BUF *b;
10850 NAME *n;
10851 wchar_t tmp[MAX_SIZE];
10852 // Validate arguments
10853 if (t == NULL || p == NULL)
10854 {
10855 return;
10856 }
10857
10858 Zero(t, sizeof(RPC_CRL));
10859 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
10860 t->Key = PackGetInt(p, "Key");
10861 b = PackGetBuf(p, "Serial");
10862 t->Crl = ZeroMalloc(sizeof(CRL));
10863 if (b != NULL)
10864 {
10865 t->Crl->Serial = NewXSerial(b->Buf, b->Size);
10866 FreeBuf(b);
10867 }
10868 t->Crl->Name = ZeroMalloc(sizeof(NAME));
10869 n = t->Crl->Name;
10870 if (PackGetUniStr(p, "CommonName", tmp, sizeof(tmp)))
10871 {
10872 n->CommonName = CopyUniStr(tmp);
10873 }
10874 if (PackGetUniStr(p, "Organization", tmp, sizeof(tmp)))
10875 {
10876 n->Organization = CopyUniStr(tmp);
10877 }
10878 if (PackGetUniStr(p, "Unit", tmp, sizeof(tmp)))
10879 {
10880 n->Unit = CopyUniStr(tmp);
10881 }
10882 if (PackGetUniStr(p, "Country", tmp, sizeof(tmp)))
10883 {
10884 n->Country = CopyUniStr(tmp);
10885 }
10886 if (PackGetUniStr(p, "State", tmp, sizeof(tmp)))
10887 {
10888 n->State = CopyUniStr(tmp);
10889 }
10890 if (PackGetUniStr(p, "Local", tmp, sizeof(tmp)))
10891 {
10892 n->Local = CopyUniStr(tmp);
10893 }
10894 if (PackGetDataSize(p, "DigestMD5") == MD5_SIZE)
10895 {
10896 PackGetData(p, "DigestMD5", t->Crl->DigestMD5);
10897 }
10898 if (PackGetDataSize(p, "DigestSHA1") == SHA1_SIZE)
10899 {
10900 PackGetData(p, "DigestSHA1", t->Crl->DigestSHA1);
10901 }
10902 }
OutRpcCrl(PACK * p,RPC_CRL * t)10903 void OutRpcCrl(PACK *p, RPC_CRL *t)
10904 {
10905 NAME *n;
10906 // Validate arguments
10907 if (p == NULL || t == NULL)
10908 {
10909 return;
10910 }
10911
10912 PackAddStr(p, "HubName", t->HubName);
10913 PackAddInt(p, "Key", t->Key);
10914
10915 if (t->Crl == NULL)
10916 {
10917 return;
10918 }
10919
10920 if (t->Crl->Serial != NULL)
10921 {
10922 PackAddData(p, "Serial", t->Crl->Serial->data, t->Crl->Serial->size);
10923 }
10924 n = t->Crl->Name;
10925 if (n->CommonName != NULL)
10926 {
10927 PackAddUniStr(p, "CommonName", n->CommonName);
10928 }
10929 if (n->Organization != NULL)
10930 {
10931 PackAddUniStr(p, "Organization", n->Organization);
10932 }
10933 if (n->Unit != NULL)
10934 {
10935 PackAddUniStr(p, "Unit", n->Unit);
10936 }
10937 if (n->Country != NULL)
10938 {
10939 PackAddUniStr(p, "Country", n->Country);
10940 }
10941 if (n->State != NULL)
10942 {
10943 PackAddUniStr(p, "State", n->State);
10944 }
10945 if (n->Local != NULL)
10946 {
10947 PackAddUniStr(p, "Local", n->Local);
10948 }
10949 if (IsZero(t->Crl->DigestMD5, MD5_SIZE) == false)
10950 {
10951 PackAddData(p, "DigestMD5", t->Crl->DigestMD5, MD5_SIZE);
10952 }
10953 if (IsZero(t->Crl->DigestSHA1, SHA1_SIZE) == false)
10954 {
10955 PackAddData(p, "DigestSHA1", t->Crl->DigestSHA1, SHA1_SIZE);
10956 }
10957 }
FreeRpcCrl(RPC_CRL * t)10958 void FreeRpcCrl(RPC_CRL *t)
10959 {
10960 // Validate arguments
10961 if (t == NULL)
10962 {
10963 return;
10964 }
10965
10966 FreeCrl(t->Crl);
10967 }
10968
10969 // RPC_ENUM_L3TABLE
InRpcEnumL3Table(RPC_ENUM_L3TABLE * t,PACK * p)10970 void InRpcEnumL3Table(RPC_ENUM_L3TABLE *t, PACK *p)
10971 {
10972 UINT i;
10973 // Validate arguments
10974 if (t == NULL || p == NULL)
10975 {
10976 return;
10977 }
10978
10979 Zero(t, sizeof(RPC_ENUM_L3TABLE));
10980 t->NumItem = PackGetInt(p, "NumItem");
10981 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
10982 t->Items = ZeroMalloc(sizeof(RPC_L3TABLE) * t->NumItem);
10983
10984 for (i = 0;i < t->NumItem;i++)
10985 {
10986 RPC_L3TABLE *e = &t->Items[i];
10987
10988 e->NetworkAddress = PackGetIp32Ex(p, "NetworkAddress", i);
10989 e->SubnetMask = PackGetIp32Ex(p, "SubnetMask", i);
10990 e->GatewayAddress = PackGetIp32Ex(p, "GatewayAddress", i);
10991 e->Metric = PackGetIntEx(p, "Metric", i);
10992 }
10993 }
OutRpcEnumL3Table(PACK * p,RPC_ENUM_L3TABLE * t)10994 void OutRpcEnumL3Table(PACK *p, RPC_ENUM_L3TABLE *t)
10995 {
10996 UINT i;
10997 // Validate arguments
10998 if (p == NULL || t == NULL)
10999 {
11000 return;
11001 }
11002
11003 PackAddInt(p, "NumItem", t->NumItem);
11004 PackAddStr(p, "Name", t->Name);
11005
11006 PackSetCurrentJsonGroupName(p, "L3Table");
11007 for (i = 0;i < t->NumItem;i++)
11008 {
11009 RPC_L3TABLE *e = &t->Items[i];
11010
11011 PackAddIp32Ex(p, "NetworkAddress", e->NetworkAddress, i, t->NumItem);
11012 PackAddIp32Ex(p, "SubnetMask", e->SubnetMask, i, t->NumItem);
11013 PackAddIp32Ex(p, "GatewayAddress", e->GatewayAddress, i, t->NumItem);
11014 PackAddIntEx(p, "Metric", e->Metric, i, t->NumItem);
11015 }
11016 PackSetCurrentJsonGroupName(p, NULL);
11017 }
FreeRpcEnumL3Table(RPC_ENUM_L3TABLE * t)11018 void FreeRpcEnumL3Table(RPC_ENUM_L3TABLE *t)
11019 {
11020 Free(t->Items);
11021 }
11022
11023 // RPC_L3TABLE
InRpcL3Table(RPC_L3TABLE * t,PACK * p)11024 void InRpcL3Table(RPC_L3TABLE *t, PACK *p)
11025 {
11026 // Validate arguments
11027 if (t == NULL || p == NULL)
11028 {
11029 return;
11030 }
11031
11032 Zero(t, sizeof(RPC_L3TABLE));
11033 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
11034 t->NetworkAddress = PackGetIp32(p, "NetworkAddress");
11035 t->SubnetMask = PackGetIp32(p, "SubnetMask");
11036 t->GatewayAddress = PackGetIp32(p, "GatewayAddress");
11037 t->Metric = PackGetInt(p, "Metric");
11038 }
OutRpcL3Table(PACK * p,RPC_L3TABLE * t)11039 void OutRpcL3Table(PACK *p, RPC_L3TABLE *t)
11040 {
11041 // Validate arguments
11042 if (p == NULL || t == NULL)
11043 {
11044 return;
11045 }
11046
11047 PackAddStr(p, "Name", t->Name);
11048 PackAddIp32(p, "NetworkAddress", t->NetworkAddress);
11049 PackAddIp32(p, "SubnetMask", t->SubnetMask);
11050 PackAddIp32(p, "GatewayAddress", t->GatewayAddress);
11051 PackAddInt(p, "Metric", t->Metric);
11052 }
11053
11054 // RPC_ENUM_L3IF
InRpcEnumL3If(RPC_ENUM_L3IF * t,PACK * p)11055 void InRpcEnumL3If(RPC_ENUM_L3IF *t, PACK *p)
11056 {
11057 UINT i;
11058 // Validate arguments
11059 if (t == NULL || p == NULL)
11060 {
11061 return;
11062 }
11063
11064 Zero(t, sizeof(RPC_ENUM_L3IF));
11065 t->NumItem = PackGetInt(p, "NumItem");
11066 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
11067 t->Items = ZeroMalloc(sizeof(RPC_L3IF) * t->NumItem);
11068
11069 for (i = 0;i < t->NumItem;i++)
11070 {
11071 RPC_L3IF *f = &t->Items[i];
11072
11073 PackGetStrEx(p, "HubName", f->HubName, sizeof(f->HubName), i);
11074 f->IpAddress = PackGetIp32Ex(p, "IpAddress", i);
11075 f->SubnetMask = PackGetIp32Ex(p, "SubnetMask", i);
11076 }
11077 }
OutRpcEnumL3If(PACK * p,RPC_ENUM_L3IF * t)11078 void OutRpcEnumL3If(PACK *p, RPC_ENUM_L3IF *t)
11079 {
11080 UINT i;
11081 // Validate arguments
11082 if (p == NULL || t == NULL)
11083 {
11084 return;
11085 }
11086
11087 PackAddInt(p, "NumItem", t->NumItem);
11088 PackAddStr(p, "Name", t->Name);
11089
11090 PackSetCurrentJsonGroupName(p, "L3IFList");
11091 for (i = 0;i < t->NumItem;i++)
11092 {
11093 RPC_L3IF *f = &t->Items[i];
11094
11095 PackAddStrEx(p, "HubName", f->HubName, i, t->NumItem);
11096 PackAddIp32Ex(p, "IpAddress", f->IpAddress, i, t->NumItem);
11097 PackAddIp32Ex(p, "SubnetMask", f->SubnetMask, i, t->NumItem);
11098 }
11099 PackSetCurrentJsonGroupName(p, NULL);
11100 }
FreeRpcEnumL3If(RPC_ENUM_L3IF * t)11101 void FreeRpcEnumL3If(RPC_ENUM_L3IF *t)
11102 {
11103 // Validate arguments
11104 if (t == NULL)
11105 {
11106 return;
11107 }
11108
11109 Free(t->Items);
11110 }
11111
11112 // RPC_L3IF
InRpcL3If(RPC_L3IF * t,PACK * p)11113 void InRpcL3If(RPC_L3IF *t, PACK *p)
11114 {
11115 // Validate arguments
11116 if (t == NULL || p == NULL)
11117 {
11118 return;
11119 }
11120
11121 Zero(t, sizeof(RPC_L3IF));
11122 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
11123 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
11124 t->IpAddress = PackGetIp32(p, "IpAddress");
11125 t->SubnetMask = PackGetIp32(p, "SubnetMask");
11126 }
OutRpcL3If(PACK * p,RPC_L3IF * t)11127 void OutRpcL3If(PACK *p, RPC_L3IF *t)
11128 {
11129 // Validate arguments
11130 if (p == NULL || t == NULL)
11131 {
11132 return;
11133 }
11134
11135 PackAddStr(p, "Name", t->Name);
11136 PackAddStr(p, "HubName", t->HubName);
11137 PackAddIp32(p, "IpAddress", t->IpAddress);
11138 PackAddIp32(p, "SubnetMask", t->SubnetMask);
11139 }
11140
11141 // RPC_L3SW
InRpcL3Sw(RPC_L3SW * t,PACK * p)11142 void InRpcL3Sw(RPC_L3SW *t, PACK *p)
11143 {
11144 // Validate arguments
11145 if (t == NULL || p == NULL)
11146 {
11147 return;
11148 }
11149
11150 Zero(t, sizeof(RPC_L3SW));
11151 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
11152 }
OutRpcL3Sw(PACK * p,RPC_L3SW * t)11153 void OutRpcL3Sw(PACK *p, RPC_L3SW *t)
11154 {
11155 // Validate arguments
11156 if (p == NULL || t == NULL)
11157 {
11158 return;
11159 }
11160
11161 PackAddStr(p, "Name", t->Name);
11162 }
11163
11164 // RPC_ENUM_L3SW
InRpcEnumL3Sw(RPC_ENUM_L3SW * t,PACK * p)11165 void InRpcEnumL3Sw(RPC_ENUM_L3SW *t, PACK *p)
11166 {
11167 UINT i;
11168 // Validate arguments
11169 if (t == NULL || p == NULL)
11170 {
11171 return;
11172 }
11173
11174 Zero(t, sizeof(RPC_ENUM_L3SW));
11175 t->NumItem = PackGetInt(p, "NumItem");
11176 t->Items = ZeroMalloc(sizeof(RPC_ENUM_L3SW_ITEM) * t->NumItem);
11177
11178 for (i = 0;i < t->NumItem;i++)
11179 {
11180 RPC_ENUM_L3SW_ITEM *s = &t->Items[i];
11181
11182 PackGetStrEx(p, "Name", s->Name, sizeof(s->Name), i);
11183 s->NumInterfaces = PackGetIntEx(p, "NumInterfaces", i);
11184 s->NumTables = PackGetIntEx(p, "NumTables", i);
11185 s->Active = PackGetBoolEx(p, "Active", i);
11186 s->Online = PackGetBoolEx(p, "Online", i);
11187 }
11188 }
OutRpcEnumL3Sw(PACK * p,RPC_ENUM_L3SW * t)11189 void OutRpcEnumL3Sw(PACK *p, RPC_ENUM_L3SW *t)
11190 {
11191 UINT i;
11192 // Validate arguments
11193 if (p == NULL || t == NULL)
11194 {
11195 return;
11196 }
11197
11198 PackAddInt(p, "NumItem", t->NumItem);
11199
11200 PackSetCurrentJsonGroupName(p, "L3SWList");
11201 for (i = 0;i < t->NumItem;i++)
11202 {
11203 RPC_ENUM_L3SW_ITEM *s = &t->Items[i];
11204
11205 PackAddStrEx(p, "Name", s->Name, i, t->NumItem);
11206 PackAddIntEx(p, "NumInterfaces", s->NumInterfaces, i, t->NumItem);
11207 PackAddIntEx(p, "NumTables", s->NumTables, i, t->NumItem);
11208 PackAddBoolEx(p, "Active", s->Active, i, t->NumItem);
11209 PackAddBoolEx(p, "Online", s->Online, i, t->NumItem);
11210 }
11211 PackSetCurrentJsonGroupName(p, NULL);
11212 }
FreeRpcEnumL3Sw(RPC_ENUM_L3SW * t)11213 void FreeRpcEnumL3Sw(RPC_ENUM_L3SW *t)
11214 {
11215 // Validate arguments
11216 if (t == NULL)
11217 {
11218 return;
11219 }
11220
11221 Free(t->Items);
11222 }
11223
11224 // RPC_ENUM_ETH
InRpcEnumEth(RPC_ENUM_ETH * t,PACK * p)11225 void InRpcEnumEth(RPC_ENUM_ETH *t, PACK *p)
11226 {
11227 UINT i;
11228 // Validate arguments
11229 if (t == NULL || p == NULL)
11230 {
11231 return;
11232 }
11233
11234 Zero(t, sizeof(RPC_ENUM_ETH));
11235 t->NumItem = PackGetInt(p, "NumItem");
11236 t->Items = ZeroMalloc(sizeof(RPC_ENUM_ETH_ITEM) * t->NumItem);
11237
11238 for (i = 0;i < t->NumItem;i++)
11239 {
11240 RPC_ENUM_ETH_ITEM *e = &t->Items[i];
11241 PackGetStrEx(p, "DeviceName", e->DeviceName, sizeof(e->DeviceName), i);
11242 PackGetUniStrEx(p, "NetworkConnectionName", e->NetworkConnectionName, sizeof(e->NetworkConnectionName), i);
11243 }
11244 }
OutRpcEnumEth(PACK * p,RPC_ENUM_ETH * t)11245 void OutRpcEnumEth(PACK *p, RPC_ENUM_ETH *t)
11246 {
11247 UINT i;
11248 // Validate arguments
11249 if (p == NULL || t == NULL)
11250 {
11251 return;
11252 }
11253
11254 PackAddInt(p, "NumItem", t->NumItem);
11255
11256 PackSetCurrentJsonGroupName(p, "EthList");
11257 for (i = 0;i < t->NumItem;i++)
11258 {
11259 RPC_ENUM_ETH_ITEM *e = &t->Items[i];
11260 PackAddStrEx(p, "DeviceName", e->DeviceName, i, t->NumItem);
11261 PackAddUniStrEx(p, "NetworkConnectionName", e->NetworkConnectionName, i, t->NumItem);
11262 }
11263 PackSetCurrentJsonGroupName(p, NULL);
11264 }
FreeRpcEnumEth(RPC_ENUM_ETH * t)11265 void FreeRpcEnumEth(RPC_ENUM_ETH *t)
11266 {
11267 // Validate arguments
11268 if (t == NULL)
11269 {
11270 return;
11271 }
11272
11273 Free(t->Items);
11274 }
11275
11276 // RPC_LOCALBRIDGE
InRpcLocalBridge(RPC_LOCALBRIDGE * t,PACK * p)11277 void InRpcLocalBridge(RPC_LOCALBRIDGE *t, PACK *p)
11278 {
11279 // Validate arguments
11280 if (t == NULL || p == NULL)
11281 {
11282 return;
11283 }
11284
11285 Zero(t, sizeof(RPC_LOCALBRIDGE));
11286 PackGetStr(p, "DeviceName", t->DeviceName, sizeof(t->DeviceName));
11287 PackGetStr(p, "HubNameLB", t->HubName, sizeof(t->HubName));
11288 t->TapMode = PackGetBool(p, "TapMode");
11289 }
OutRpcLocalBridge(PACK * p,RPC_LOCALBRIDGE * t)11290 void OutRpcLocalBridge(PACK *p, RPC_LOCALBRIDGE *t)
11291 {
11292 // Validate arguments
11293 if (t == NULL || p == NULL)
11294 {
11295 return;
11296 }
11297
11298 PackAddStr(p, "DeviceName", t->DeviceName);
11299 PackAddStr(p, "HubNameLB", t->HubName);
11300 PackAddBool(p, "TapMode", t->TapMode);
11301 }
11302
11303 // RPC_ENUM_LOCALBRIDGE
InRpcEnumLocalBridge(RPC_ENUM_LOCALBRIDGE * t,PACK * p)11304 void InRpcEnumLocalBridge(RPC_ENUM_LOCALBRIDGE *t, PACK *p)
11305 {
11306 UINT i;
11307 // Validate arguments
11308 if (t == NULL || p == NULL)
11309 {
11310 return;
11311 }
11312
11313 Zero(t, sizeof(RPC_ENUM_LOCALBRIDGE));
11314 t->NumItem = PackGetInt(p, "NumItem");
11315 t->Items = ZeroMalloc(sizeof(RPC_LOCALBRIDGE) * t->NumItem);
11316
11317 for (i = 0;i < t->NumItem;i++)
11318 {
11319 RPC_LOCALBRIDGE *e = &t->Items[i];
11320
11321 PackGetStrEx(p, "DeviceName", e->DeviceName, sizeof(e->DeviceName), i);
11322 PackGetStrEx(p, "HubNameLB", e->HubName, sizeof(e->HubName), i);
11323 e->Online = PackGetBoolEx(p, "Online", i);
11324 e->Active = PackGetBoolEx(p, "Active", i);
11325 e->TapMode = PackGetBoolEx(p, "TapMode", i);
11326 }
11327 }
OutRpcEnumLocalBridge(PACK * p,RPC_ENUM_LOCALBRIDGE * t)11328 void OutRpcEnumLocalBridge(PACK *p, RPC_ENUM_LOCALBRIDGE *t)
11329 {
11330 UINT i;
11331 // Validate arguments
11332 if (t == NULL || p == NULL)
11333 {
11334 return;
11335 }
11336
11337 PackAddInt(p, "NumItem", t->NumItem);
11338
11339 PackSetCurrentJsonGroupName(p, "LocalBridgeList");
11340 for (i = 0;i < t->NumItem;i++)
11341 {
11342 RPC_LOCALBRIDGE *e = &t->Items[i];
11343
11344 PackAddStrEx(p, "DeviceName", e->DeviceName, i, t->NumItem);
11345 PackAddStrEx(p, "HubNameLB", e->HubName, i, t->NumItem);
11346 PackAddBoolEx(p, "Online", e->Online, i, t->NumItem);
11347 PackAddBoolEx(p, "Active", e->Active, i, t->NumItem);
11348 PackAddBoolEx(p, "TapMode", e->TapMode, i, t->NumItem);
11349 }
11350 PackSetCurrentJsonGroupName(p, NULL);
11351 }
FreeRpcEnumLocalBridge(RPC_ENUM_LOCALBRIDGE * t)11352 void FreeRpcEnumLocalBridge(RPC_ENUM_LOCALBRIDGE *t)
11353 {
11354 // Validate arguments
11355 if (t == NULL)
11356 {
11357 return;
11358 }
11359 Free(t->Items);
11360 }
11361
11362 // MEMINFO
InRpcMemInfo(MEMINFO * t,PACK * p)11363 void InRpcMemInfo(MEMINFO *t, PACK *p)
11364 {
11365 // Validate arguments
11366 if (t == NULL || p == NULL)
11367 {
11368 return;
11369 }
11370
11371 Zero(t, sizeof(MEMINFO));
11372 t->TotalMemory = PackGetInt64(p, "TotalMemory");
11373 t->UsedMemory = PackGetInt64(p, "UsedMemory");
11374 t->FreeMemory = PackGetInt64(p, "FreeMemory");
11375 t->TotalPhys = PackGetInt64(p, "TotalPhys");
11376 t->UsedPhys = PackGetInt64(p, "UsedPhys");
11377 t->FreePhys = PackGetInt64(p, "FreePhys");
11378 }
OutRpcMemInfo(PACK * p,MEMINFO * t)11379 void OutRpcMemInfo(PACK *p, MEMINFO *t)
11380 {
11381 // Validate arguments
11382 if (t == NULL || p == NULL)
11383 {
11384 return;
11385 }
11386
11387 PackAddInt64(p, "TotalMemory", t->TotalMemory);
11388 PackAddInt64(p, "UsedMemory", t->UsedMemory);
11389 PackAddInt64(p, "FreeMemory", t->FreeMemory);
11390 PackAddInt64(p, "TotalPhys", t->TotalPhys);
11391 PackAddInt64(p, "UsedPhys", t->UsedPhys);
11392 PackAddInt64(p, "FreePhys", t->FreePhys);
11393 }
11394
11395 // OS_INFO
InRpcOsInfo(OS_INFO * t,PACK * p)11396 void InRpcOsInfo(OS_INFO *t, PACK *p)
11397 {
11398 char tmp[MAX_SIZE];
11399 // Validate arguments
11400 if (t == NULL || p == NULL)
11401 {
11402 return;
11403 }
11404
11405 Zero(t, sizeof(OS_INFO));
11406 t->OsType = PackGetInt(p, "OsType");
11407 t->OsServicePack = PackGetInt(p, "OsServicePack");
11408 if (PackGetStr(p, "OsSystemName", tmp, sizeof(tmp)))
11409 {
11410 t->OsSystemName = CopyStr(tmp);
11411 }
11412 if (PackGetStr(p, "OsProductName", tmp, sizeof(tmp)))
11413 {
11414 t->OsProductName = CopyStr(tmp);
11415 }
11416 if (PackGetStr(p, "OsVendorName", tmp, sizeof(tmp)))
11417 {
11418 t->OsVendorName = CopyStr(tmp);
11419 }
11420 if (PackGetStr(p, "OsVersion", tmp, sizeof(tmp)))
11421 {
11422 t->OsVersion = CopyStr(tmp);
11423 }
11424 if (PackGetStr(p, "KernelName", tmp, sizeof(tmp)))
11425 {
11426 t->KernelName = CopyStr(tmp);
11427 }
11428 if (PackGetStr(p, "KernelVersion", tmp, sizeof(tmp)))
11429 {
11430 t->KernelVersion = CopyStr(tmp);
11431 }
11432 }
OutRpcOsInfo(PACK * p,OS_INFO * t)11433 void OutRpcOsInfo(PACK *p, OS_INFO *t)
11434 {
11435 // Validate arguments
11436 if (t == NULL || p == NULL)
11437 {
11438 return;
11439 }
11440
11441 PackAddInt(p, "OsType", t->OsType);
11442 PackAddInt(p, "OsServicePack", t->OsServicePack);
11443 PackAddStr(p, "OsSystemName", t->OsSystemName);
11444 PackAddStr(p, "OsProductName", t->OsProductName);
11445 PackAddStr(p, "OsVendorName", t->OsVendorName);
11446 PackAddStr(p, "OsVersion", t->OsVersion);
11447 PackAddStr(p, "KernelName", t->KernelName);
11448 PackAddStr(p, "KernelVersion", t->KernelVersion);
11449 }
FreeRpcOsInfo(OS_INFO * t)11450 void FreeRpcOsInfo(OS_INFO *t)
11451 {
11452 // Validate arguments
11453 if (t == NULL)
11454 {
11455 return;
11456 }
11457
11458 Free(t->OsSystemName);
11459 Free(t->OsProductName);
11460 Free(t->OsVendorName);
11461 Free(t->OsVersion);
11462 Free(t->KernelName);
11463 Free(t->KernelVersion);
11464 }
11465
11466 // Read a local log file
SiReadLocalLogFile(SERVER * s,char * filepath,UINT offset,RPC_READ_LOG_FILE * t)11467 void SiReadLocalLogFile(SERVER *s, char *filepath, UINT offset, RPC_READ_LOG_FILE *t)
11468 {
11469 char exe_dir[MAX_PATH], full_path[MAX_PATH];
11470 IO *o;
11471 // Validate arguments
11472 if (s == NULL || t == NULL || filepath == NULL)
11473 {
11474 return;
11475 }
11476
11477 Zero(t, sizeof(RPC_READ_LOG_FILE));
11478
11479 GetLogDir(exe_dir, sizeof(exe_dir));
11480 Format(full_path, sizeof(full_path), "%s/%s", exe_dir, filepath);
11481
11482 // Read file
11483 o = FileOpenEx(full_path, false, false);
11484 if (o != NULL)
11485 {
11486 UINT filesize = FileSize(o);
11487
11488 if (offset < filesize)
11489 {
11490 UINT readsize = MIN(filesize - offset, FTP_BLOCK_SIZE);
11491 void *buf = ZeroMalloc(readsize);
11492
11493 FileSeek(o, FILE_BEGIN, offset);
11494 FileRead(o, buf, readsize);
11495
11496 t->Buffer = NewBuf();
11497 WriteBuf(t->Buffer, buf, readsize);
11498 Free(buf);
11499 }
11500
11501 FileClose(o);
11502 }
11503 }
11504
11505 // Enumerate local log files
SiEnumLocalLogFileList(SERVER * s,char * hubname,RPC_ENUM_LOG_FILE * t)11506 void SiEnumLocalLogFileList(SERVER *s, char *hubname, RPC_ENUM_LOG_FILE *t)
11507 {
11508 LIST *o;
11509 UINT i;
11510 // Validate arguments
11511 if (s == NULL || t == NULL)
11512 {
11513 return;
11514 }
11515
11516 Zero(t, sizeof(RPC_ENUM_LOG_FILE));
11517
11518 o = EnumLogFile(hubname);
11519
11520 t->NumItem = LIST_NUM(o);
11521 t->Items = ZeroMalloc(sizeof(RPC_ENUM_LOG_FILE_ITEM) * t->NumItem);
11522
11523 for (i = 0;i < LIST_NUM(o);i++)
11524 {
11525 LOG_FILE *f = LIST_DATA(o, i);
11526 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];
11527
11528 StrCpy(e->FilePath, sizeof(e->FilePath), f->Path);
11529 StrCpy(e->ServerName, sizeof(e->ServerName), f->ServerName);
11530 e->FileSize = f->FileSize;
11531 e->UpdatedTime = f->UpdatedTime;
11532 }
11533
11534 FreeEnumLogFile(o);
11535 }
11536
11537 // Enumerate local sessions
SiEnumLocalSession(SERVER * s,char * hubname,RPC_ENUM_SESSION * t)11538 void SiEnumLocalSession(SERVER *s, char *hubname, RPC_ENUM_SESSION *t)
11539 {
11540 HUB *h;
11541 UINT64 now = Tick64();
11542 UINT64 dormant_interval = 0;
11543 // Validate arguments
11544 if (s == NULL || hubname == NULL || t == NULL)
11545 {
11546 return;
11547 }
11548
11549 LockHubList(s->Cedar);
11550 h = GetHub(s->Cedar, hubname);
11551 UnlockHubList(s->Cedar);
11552
11553 if (h == NULL)
11554 {
11555 t->NumSession = 0;
11556 t->Sessions = ZeroMalloc(0);
11557 return;
11558 }
11559
11560 if (h->Option != NULL)
11561 {
11562 dormant_interval = h->Option->DetectDormantSessionInterval * (UINT64)1000;
11563 }
11564
11565 LockList(h->SessionList);
11566 {
11567 UINT i;
11568 t->NumSession = LIST_NUM(h->SessionList);
11569 t->Sessions = ZeroMalloc(sizeof(RPC_ENUM_SESSION_ITEM) * t->NumSession);
11570
11571 for (i = 0;i < t->NumSession;i++)
11572 {
11573 SESSION *s = LIST_DATA(h->SessionList, i);
11574 RPC_ENUM_SESSION_ITEM *e = &t->Sessions[i];
11575 Lock(s->lock);
11576 {
11577 StrCpy(e->Name, sizeof(e->Name), s->Name);
11578 StrCpy(e->Username, sizeof(e->Username), s->Username);
11579 e->Ip = IPToUINT(&s->Connection->ClientIp);
11580 CopyIP(&e->ClientIP, &s->Connection->ClientIp);
11581 StrCpy(e->Hostname, sizeof(e->Hostname), s->Connection->ClientHostname);
11582 e->MaxNumTcp = s->MaxConnection;
11583 e->CreatedTime = Tick64ToTime64(s->CreatedTime);
11584 e->LastCommTime = Tick64ToTime64(s->LastCommTime);
11585 e->LinkMode = s->LinkModeServer;
11586 e->SecureNATMode = s->SecureNATMode;
11587 e->BridgeMode = s->BridgeMode;
11588 e->Layer3Mode = s->L3SwitchMode;
11589 e->VLanId = s->VLanId;
11590 LockList(s->Connection->Tcp->TcpSockList);
11591 {
11592 e->CurrentNumTcp = s->Connection->Tcp->TcpSockList->num_item;
11593 }
11594 UnlockList(s->Connection->Tcp->TcpSockList);
11595 Lock(s->TrafficLock);
11596 {
11597 e->PacketSize = GetTrafficPacketSize(s->Traffic);
11598 e->PacketNum = GetTrafficPacketNum(s->Traffic);
11599 }
11600 Unlock(s->TrafficLock);
11601 e->Client_BridgeMode = s->IsBridgeMode;
11602 e->Client_MonitorMode = s->IsMonitorMode;
11603 Copy(e->UniqueId, s->NodeInfo.UniqueId, 16);
11604
11605 if (s->NormalClient)
11606 {
11607 e->IsDormantEnabled = (dormant_interval == 0 ? false : true);
11608 if (e->IsDormantEnabled)
11609 {
11610 if (s->LastCommTimeForDormant == 0)
11611 {
11612 e->LastCommDormant = (UINT64)0x7FFFFFFF;
11613 }
11614 else
11615 {
11616 e->LastCommDormant = now - s->LastCommTimeForDormant;
11617 }
11618 if (s->LastCommTimeForDormant == 0)
11619 {
11620 e->IsDormant = true;
11621 }
11622 else
11623 {
11624 if ((s->LastCommTimeForDormant + dormant_interval) < now)
11625 {
11626 e->IsDormant = true;
11627 }
11628 }
11629 }
11630 }
11631 }
11632 Unlock(s->lock);
11633
11634 GetMachineName(e->RemoteHostname, sizeof(e->RemoteHostname));
11635 }
11636 }
11637 UnlockList(h->SessionList);
11638
11639 ReleaseHub(h);
11640 }
11641
11642 // RPC_ENUM_LICENSE_KEY
InRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY * t,PACK * p)11643 void InRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY *t, PACK *p)
11644 {
11645 UINT i;
11646 // Validate arguments
11647 if (t == NULL || p == NULL)
11648 {
11649 return;
11650 }
11651
11652 Zero(t, sizeof(RPC_ENUM_LICENSE_KEY));
11653 t->NumItem = PackGetInt(p, "NumItem");
11654 t->Items = ZeroMalloc(sizeof(RPC_ENUM_LICENSE_KEY_ITEM) * t->NumItem);
11655 for (i = 0;i < t->NumItem;i++)
11656 {
11657 RPC_ENUM_LICENSE_KEY_ITEM *e = &t->Items[i];
11658
11659 e->Id = PackGetIntEx(p, "Id", i);
11660 PackGetStrEx(p, "LicenseKey", e->LicenseKey, sizeof(e->LicenseKey), i);
11661 PackGetStrEx(p, "LicenseId", e->LicenseId, sizeof(e->LicenseId), i);
11662 PackGetStrEx(p, "LicenseName", e->LicenseName, sizeof(e->LicenseName), i);
11663 e->Expires = PackGetInt64Ex(p, "Expires", i);
11664 e->Status = PackGetIntEx(p, "Status", i);
11665 e->ProductId = PackGetIntEx(p, "ProductId", i);
11666 e->SystemId = PackGetInt64Ex(p, "SystemId", i);
11667 e->SerialId = PackGetIntEx(p, "SerialId", i);
11668 }
11669 }
OutRpcEnumLicenseKey(PACK * p,RPC_ENUM_LICENSE_KEY * t)11670 void OutRpcEnumLicenseKey(PACK *p, RPC_ENUM_LICENSE_KEY *t)
11671 {
11672 UINT i;
11673 // Validate arguments
11674 if (t == NULL || p == NULL)
11675 {
11676 return;
11677 }
11678
11679 PackAddInt(p, "NumItem", t->NumItem);
11680
11681 PackSetCurrentJsonGroupName(p, "LicenseKeyList");
11682 for (i = 0;i < t->NumItem;i++)
11683 {
11684 RPC_ENUM_LICENSE_KEY_ITEM *e = &t->Items[i];
11685
11686 PackAddIntEx(p, "Id", e->Id, i, t->NumItem);
11687 PackAddStrEx(p, "LicenseKey", e->LicenseKey, i, t->NumItem);
11688 PackAddStrEx(p, "LicenseId", e->LicenseId, i, t->NumItem);
11689 PackAddStrEx(p, "LicenseName", e->LicenseName, i, t->NumItem);
11690 PackAddTime64Ex(p, "Expires", e->Expires, i, t->NumItem);
11691 PackAddIntEx(p, "Status", e->Status, i, t->NumItem);
11692 PackAddIntEx(p, "ProductId", e->ProductId, i, t->NumItem);
11693 PackAddInt64Ex(p, "SystemId", e->SystemId, i, t->NumItem);
11694 PackAddIntEx(p, "SerialId", e->SerialId, i, t->NumItem);
11695 }
11696 PackSetCurrentJsonGroupName(p, NULL);
11697 }
FreeRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY * t)11698 void FreeRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY *t)
11699 {
11700 // Validate arguments
11701 if (t == NULL)
11702 {
11703 return;
11704 }
11705
11706 Free(t->Items);
11707 }
11708
11709 // RPC_LICENSE_STATUS
InRpcLicenseStatus(RPC_LICENSE_STATUS * t,PACK * p)11710 void InRpcLicenseStatus(RPC_LICENSE_STATUS *t, PACK *p)
11711 {
11712 // Validate arguments
11713 if (t == NULL || p == NULL)
11714 {
11715 return;
11716 }
11717
11718 Zero(t, sizeof(RPC_LICENSE_STATUS));
11719
11720 t->EditionId = PackGetInt(p, "EditionId");
11721 PackGetStr(p, "EditionStr", t->EditionStr, sizeof(t->EditionStr) );
11722 t->SystemId = PackGetInt64(p, "SystemId");
11723 t->SystemExpires = PackGetInt64(p, "SystemExpires");
11724 t->NumClientConnectLicense = PackGetInt(p, "NumClientConnectLicense");
11725 t->NumBridgeConnectLicense = PackGetInt(p, "NumBridgeConnectLicense");
11726
11727 // v3.0
11728 t->NeedSubscription = PackGetBool(p, "NeedSubscription");
11729 t->AllowEnterpriseFunction = PackGetBool(p, "AllowEnterpriseFunction");
11730 t->SubscriptionExpires = PackGetInt64(p, "SubscriptionExpires");
11731 t->IsSubscriptionExpired = PackGetBool(p, "IsSubscriptionExpired");
11732 t->NumUserCreationLicense = PackGetInt(p, "NumUserCreationLicense");
11733 t->ReleaseDate = PackGetInt64(p, "ReleaseDate");
11734 }
OutRpcLicenseStatus(PACK * p,RPC_LICENSE_STATUS * t)11735 void OutRpcLicenseStatus(PACK *p, RPC_LICENSE_STATUS *t)
11736 {
11737 // Validate arguments
11738 if (t == NULL || p == NULL)
11739 {
11740 return;
11741 }
11742
11743 PackAddInt(p, "EditionId", t->EditionId);
11744 PackAddStr(p, "EditionStr", t->EditionStr);
11745 PackAddInt64(p, "SystemId", t->SystemId);
11746 PackAddTime64(p, "SystemExpires", t->SystemExpires);
11747 PackAddInt(p, "NumClientConnectLicense", t->NumClientConnectLicense);
11748 PackAddInt(p, "NumBridgeConnectLicense", t->NumBridgeConnectLicense);
11749
11750 // v3.0
11751 PackAddBool(p, "NeedSubscription", t->NeedSubscription);
11752 PackAddBool(p, "AllowEnterpriseFunction", t->AllowEnterpriseFunction);
11753 PackAddTime64(p, "SubscriptionExpires", t->SubscriptionExpires);
11754 PackAddBool(p, "IsSubscriptionExpired", t->IsSubscriptionExpired);
11755 PackAddInt(p, "NumUserCreationLicense", t->NumUserCreationLicense);
11756 PackAddTime64(p, "ReleaseDate", t->ReleaseDate);
11757 }
11758
11759 // RPC_ADMIN_OPTION
InRpcAdminOption(RPC_ADMIN_OPTION * t,PACK * p)11760 void InRpcAdminOption(RPC_ADMIN_OPTION *t, PACK *p)
11761 {
11762 UINT i;
11763 // Validate arguments
11764 if (t == NULL || p == NULL)
11765 {
11766 return;
11767 }
11768
11769 Zero(t, sizeof(RPC_ADMIN_OPTION));
11770 t->NumItem = PackGetIndexCount(p, "Name");
11771 t->Items = ZeroMalloc(sizeof(ADMIN_OPTION) * t->NumItem);
11772
11773 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
11774
11775 for (i = 0;i < t->NumItem;i++)
11776 {
11777 ADMIN_OPTION *o = &t->Items[i];
11778
11779 PackGetStrEx(p, "Name", o->Name, sizeof(o->Name), i);
11780 o->Value = PackGetIntEx(p, "Value", i);
11781 PackGetUniStrEx(p, "Descrption", o->Descrption, sizeof(o->Descrption), i);
11782 }
11783 }
OutRpcAdminOption(PACK * p,RPC_ADMIN_OPTION * t)11784 void OutRpcAdminOption(PACK *p, RPC_ADMIN_OPTION *t)
11785 {
11786 UINT i;
11787 // Validate arguments
11788 if (t == NULL || p == NULL)
11789 {
11790 return;
11791 }
11792
11793 PackAddInt(p, "NumItem", t->NumItem);
11794
11795 PackAddStr(p, "HubName", t->HubName);
11796
11797 PackSetCurrentJsonGroupName(p, "AdminOptionList");
11798 for (i = 0;i < t->NumItem;i++)
11799 {
11800 ADMIN_OPTION *o = &t->Items[i];
11801
11802 PackAddStrEx(p, "Name", o->Name, i, t->NumItem);
11803 PackAddIntEx(p, "Value", o->Value, i, t->NumItem);
11804 PackAddUniStrEx(p, "Descrption", o->Descrption, i, t->NumItem);
11805 }
11806 PackSetCurrentJsonGroupName(p, NULL);
11807 }
FreeRpcAdminOption(RPC_ADMIN_OPTION * t)11808 void FreeRpcAdminOption(RPC_ADMIN_OPTION *t)
11809 {
11810 // Validate arguments
11811 if (t == NULL)
11812 {
11813 return;
11814 }
11815
11816 Free(t->Items);
11817 }
11818
11819 // RPC_CONFIG
InRpcConfig(RPC_CONFIG * t,PACK * p)11820 void InRpcConfig(RPC_CONFIG *t, PACK *p)
11821 {
11822 UINT size;
11823 // Validate arguments
11824 if (t == NULL || p == NULL)
11825 {
11826 return;
11827 }
11828
11829 Zero(t, sizeof(RPC_CONFIG));
11830 PackGetStr(p, "FileName", t->FileName, sizeof(t->FileName));
11831 size = PackGetDataSize(p, "FileData");
11832 t->FileData = ZeroMalloc(size + 1);
11833 PackGetData(p, "FileData", t->FileData);
11834 }
OutRpcConfig(PACK * p,RPC_CONFIG * t)11835 void OutRpcConfig(PACK *p, RPC_CONFIG *t)
11836 {
11837 // Validate arguments
11838 if (t == NULL || p == NULL)
11839 {
11840 return;
11841 }
11842
11843 PackAddStr(p, "FileName", t->FileName);
11844 PackAddData(p, "FileData", t->FileData, StrLen(t->FileData));
11845 }
FreeRpcConfig(RPC_CONFIG * t)11846 void FreeRpcConfig(RPC_CONFIG *t)
11847 {
11848 // Validate arguments
11849 if (t == NULL)
11850 {
11851 return;
11852 }
11853
11854 Free(t->FileData);
11855 }
11856
11857 // RPC_BRIDGE_SUPPORT
InRpcBridgeSupport(RPC_BRIDGE_SUPPORT * t,PACK * p)11858 void InRpcBridgeSupport(RPC_BRIDGE_SUPPORT *t, PACK *p)
11859 {
11860 // Validate arguments
11861 if (t == NULL || p == NULL)
11862 {
11863 return;
11864 }
11865
11866 Zero(t, sizeof(RPC_BRIDGE_SUPPORT));
11867
11868 t->IsBridgeSupportedOs = PackGetBool(p, "IsBridgeSupportedOs");
11869 t->IsWinPcapNeeded = PackGetBool(p, "IsWinPcapNeeded");
11870 }
OutRpcBridgeSupport(PACK * p,RPC_BRIDGE_SUPPORT * t)11871 void OutRpcBridgeSupport(PACK *p, RPC_BRIDGE_SUPPORT *t)
11872 {
11873 // Validate arguments
11874 if (p == NULL || t == NULL)
11875 {
11876 return;
11877 }
11878
11879 PackAddBool(p, "IsBridgeSupportedOs", t->IsBridgeSupportedOs);
11880 PackAddBool(p, "IsWinPcapNeeded",t->IsWinPcapNeeded);
11881 }
11882
11883 // RPC_ADD_ACCESS
InRpcAddAccess(RPC_ADD_ACCESS * t,PACK * p)11884 void InRpcAddAccess(RPC_ADD_ACCESS *t, PACK *p)
11885 {
11886 // Validate arguments
11887 if (t == NULL || p == NULL)
11888 {
11889 return;
11890 }
11891
11892 Zero(t, sizeof(RPC_ADD_ACCESS));
11893
11894 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
11895 InRpcAccess(&t->Access, p);
11896 }
OutRpcAddAccess(PACK * p,RPC_ADD_ACCESS * t)11897 void OutRpcAddAccess(PACK *p, RPC_ADD_ACCESS *t)
11898 {
11899 // Validate arguments
11900 if (t == NULL || p == NULL)
11901 {
11902 return;
11903 }
11904
11905 PackAddStr(p, "HubName", t->HubName);
11906 OutRpcAccess(p, &t->Access);
11907 }
11908
11909 // RPC_DELETE_ACCESS
InRpcDeleteAccess(RPC_DELETE_ACCESS * t,PACK * p)11910 void InRpcDeleteAccess(RPC_DELETE_ACCESS *t, PACK *p)
11911 {
11912 // Validate arguments
11913 if (t == NULL || p == NULL)
11914 {
11915 return;
11916 }
11917
11918 Zero(t, sizeof(RPC_DELETE_ACCESS));
11919
11920 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
11921 t->Id = PackGetInt(p, "Id");
11922 }
OutRpcDeleteAccess(PACK * p,RPC_DELETE_ACCESS * t)11923 void OutRpcDeleteAccess(PACK *p, RPC_DELETE_ACCESS *t)
11924 {
11925 // Validate arguments
11926 if (t == NULL || p == NULL)
11927 {
11928 return;
11929 }
11930
11931 PackAddStr(p, "HubName", t->HubName);
11932 PackAddInt(p, "Id", t->Id);
11933 }
11934
11935
11936 // RPC_SERVER_INFO
InRpcServerInfo(RPC_SERVER_INFO * t,PACK * p)11937 void InRpcServerInfo(RPC_SERVER_INFO *t, PACK *p)
11938 {
11939 // Validate arguments
11940 if (t == NULL || p == NULL)
11941 {
11942 return;
11943 }
11944
11945 Zero(t, sizeof(RPC_SERVER_INFO));
11946
11947 PackGetStr(p, "ServerProductName", t->ServerProductName, sizeof(t->ServerProductName));
11948 PackGetStr(p, "ServerVersionString", t->ServerVersionString, sizeof(t->ServerVersionString));
11949 PackGetStr(p, "ServerBuildInfoString", t->ServerBuildInfoString, sizeof(t->ServerBuildInfoString));
11950 t->ServerVerInt = PackGetInt(p, "ServerVerInt");
11951 t->ServerBuildInt = PackGetInt(p, "ServerBuildInt");
11952 PackGetStr(p, "ServerHostName", t->ServerHostName, sizeof(t->ServerHostName));
11953 t->ServerType = PackGetInt(p, "ServerType");
11954 t->ServerBuildDate = PackGetInt64(p, "ServerBuildDate");
11955 PackGetStr(p, "ServerFamilyName", t->ServerFamilyName, sizeof(t->ServerFamilyName));
11956 InRpcOsInfo(&t->OsInfo, p);
11957 }
OutRpcServerInfo(PACK * p,RPC_SERVER_INFO * t)11958 void OutRpcServerInfo(PACK *p, RPC_SERVER_INFO *t)
11959 {
11960 // Validate arguments
11961 if (t == NULL || p == NULL)
11962 {
11963 return;
11964 }
11965
11966 PackAddStr(p, "ServerProductName", t->ServerProductName);
11967 PackAddStr(p, "ServerVersionString", t->ServerVersionString);
11968 PackAddStr(p, "ServerBuildInfoString", t->ServerBuildInfoString);
11969 PackAddInt(p, "ServerVerInt", t->ServerVerInt);
11970 PackAddInt(p, "ServerBuildInt", t->ServerBuildInt);
11971 PackAddStr(p, "ServerHostName", t->ServerHostName);
11972 PackAddInt(p, "ServerType", t->ServerType);
11973 PackAddTime64(p, "ServerBuildDate", t->ServerBuildDate);
11974 PackAddStr(p, "ServerFamilyName", t->ServerFamilyName);
11975 OutRpcOsInfo(p, &t->OsInfo);
11976 }
FreeRpcServerInfo(RPC_SERVER_INFO * t)11977 void FreeRpcServerInfo(RPC_SERVER_INFO *t)
11978 {
11979 // Validate arguments
11980 if (t == NULL)
11981 {
11982 return;
11983 }
11984
11985 FreeRpcOsInfo(&t->OsInfo);
11986 }
11987
11988 // RPC_SERVER_STATUS
InRpcServerStatus(RPC_SERVER_STATUS * t,PACK * p)11989 void InRpcServerStatus(RPC_SERVER_STATUS *t, PACK *p)
11990 {
11991 // Validate arguments
11992 if (t == NULL || p == NULL)
11993 {
11994 return;
11995 }
11996
11997 Zero(t, sizeof(RPC_SERVER_STATUS));
11998 t->ServerType = PackGetInt(p, "ServerType");
11999 t->NumTcpConnections = PackGetInt(p, "NumTcpConnections");
12000 t->NumTcpConnectionsLocal = PackGetInt(p, "NumTcpConnectionsLocal");
12001 t->NumTcpConnectionsRemote = PackGetInt(p, "NumTcpConnectionsRemote");
12002 t->NumHubTotal = PackGetInt(p, "NumHubTotal");
12003 t->NumHubStandalone = PackGetInt(p, "NumHubStandalone");
12004 t->NumHubStatic = PackGetInt(p, "NumHubStatic");
12005 t->NumHubDynamic = PackGetInt(p, "NumHubDynamic");
12006 t->NumSessionsTotal = PackGetInt(p, "NumSessionsTotal");
12007 t->NumSessionsLocal = PackGetInt(p, "NumSessionsLocal");
12008 t->NumSessionsRemote = PackGetInt(p, "NumSessionsRemote");
12009 t->NumMacTables = PackGetInt(p, "NumMacTables");
12010 t->NumIpTables = PackGetInt(p, "NumIpTables");
12011 t->NumUsers = PackGetInt(p, "NumUsers");
12012 t->NumGroups = PackGetInt(p, "NumGroups");
12013 t->CurrentTime = PackGetInt64(p, "CurrentTime");
12014 t->CurrentTick = PackGetInt64(p, "CurrentTick");
12015 t->AssignedBridgeLicenses = PackGetInt(p, "AssignedBridgeLicenses");
12016 t->AssignedClientLicenses = PackGetInt(p, "AssignedClientLicenses");
12017 t->AssignedBridgeLicensesTotal = PackGetInt(p, "AssignedBridgeLicensesTotal");
12018 t->AssignedClientLicensesTotal = PackGetInt(p, "AssignedClientLicensesTotal");
12019 t->StartTime = PackGetInt64(p, "StartTime");
12020
12021 InRpcTraffic(&t->Traffic, p);
12022
12023 InRpcMemInfo(&t->MemInfo, p);
12024 }
OutRpcServerStatus(PACK * p,RPC_SERVER_STATUS * t)12025 void OutRpcServerStatus(PACK *p, RPC_SERVER_STATUS *t)
12026 {
12027 // Validate arguments
12028 if (t == NULL || p == NULL)
12029 {
12030 return;
12031 }
12032
12033 PackAddInt(p, "ServerType", t->ServerType);
12034 PackAddInt(p, "NumHubTotal", t->NumHubTotal);
12035 PackAddInt(p, "NumHubStandalone", t->NumHubStandalone);
12036 PackAddInt(p, "NumHubStatic", t->NumHubStatic);
12037 PackAddInt(p, "NumHubDynamic", t->NumHubDynamic);
12038 PackAddInt(p, "NumSessionsTotal", t->NumSessionsTotal);
12039 PackAddInt(p, "NumSessionsLocal", t->NumSessionsLocal);
12040 PackAddInt(p, "NumSessionsRemote", t->NumSessionsRemote);
12041 PackAddInt(p, "NumTcpConnections", t->NumTcpConnections);
12042 PackAddInt(p, "NumTcpConnectionsLocal", t->NumTcpConnectionsLocal);
12043 PackAddInt(p, "NumTcpConnectionsRemote", t->NumTcpConnectionsRemote);
12044 PackAddInt(p, "NumMacTables", t->NumMacTables);
12045 PackAddInt(p, "NumIpTables", t->NumIpTables);
12046 PackAddInt(p, "NumUsers", t->NumUsers);
12047 PackAddInt(p, "NumGroups", t->NumGroups);
12048 PackAddTime64(p, "CurrentTime", t->CurrentTime);
12049 PackAddInt64(p, "CurrentTick", t->CurrentTick);
12050 PackAddInt(p, "AssignedBridgeLicenses", t->AssignedBridgeLicenses);
12051 PackAddInt(p, "AssignedClientLicenses", t->AssignedClientLicenses);
12052 PackAddInt(p, "AssignedBridgeLicensesTotal", t->AssignedBridgeLicensesTotal);
12053 PackAddInt(p, "AssignedClientLicensesTotal", t->AssignedClientLicensesTotal);
12054 PackAddTime64(p, "StartTime", t->StartTime);
12055
12056 OutRpcTraffic(p, &t->Traffic);
12057
12058 OutRpcMemInfo(p, &t->MemInfo);
12059 }
12060
12061 // RPC_LISTENER
InRpcListener(RPC_LISTENER * t,PACK * p)12062 void InRpcListener(RPC_LISTENER *t, PACK *p)
12063 {
12064 // Validate arguments
12065 if (t == NULL || p == NULL)
12066 {
12067 return;
12068 }
12069
12070 Zero(t, sizeof(RPC_LISTENER));
12071 t->Port = PackGetInt(p, "Port");
12072 t->Enable = PackGetBool(p, "Enable");
12073 }
OutRpcListener(PACK * p,RPC_LISTENER * t)12074 void OutRpcListener(PACK *p, RPC_LISTENER *t)
12075 {
12076 // Validate arguments
12077 if (t == NULL || p == NULL)
12078 {
12079 return;
12080 }
12081
12082 PackAddInt(p, "Port", t->Port);
12083 PackAddBool(p, "Enable", t->Enable);
12084 }
12085
12086 // RPC_LISTENER_LIST
InRpcListenerList(RPC_LISTENER_LIST * t,PACK * p)12087 void InRpcListenerList(RPC_LISTENER_LIST *t, PACK *p)
12088 {
12089 UINT i;
12090 // Validate arguments
12091 if (t == NULL || p == NULL)
12092 {
12093 return;
12094 }
12095
12096 Zero(t, sizeof(RPC_LISTENER_LIST));
12097 t->NumPort = PackGetIndexCount(p, "Ports");
12098 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);
12099 t->Enables = ZeroMalloc(sizeof(UINT) * t->NumPort);
12100 t->Errors = ZeroMalloc(sizeof(UINT) * t->NumPort);
12101 for (i = 0;i < t->NumPort;i++)
12102 {
12103 t->Ports[i] = PackGetIntEx(p, "Ports", i);
12104 t->Enables[i] = PackGetBoolEx(p, "Enables", i);
12105 t->Errors[i] = PackGetBoolEx(p, "Errors", i);
12106 }
12107 }
OutRpcListenerList(PACK * p,RPC_LISTENER_LIST * t)12108 void OutRpcListenerList(PACK *p, RPC_LISTENER_LIST *t)
12109 {
12110 UINT i;
12111 // Validate arguments
12112 if (t == NULL || p == NULL)
12113 {
12114 return;
12115 }
12116
12117 PackSetCurrentJsonGroupName(p, "ListenerList");
12118 for (i = 0;i < t->NumPort;i++)
12119 {
12120 PackAddIntEx(p, "Ports", t->Ports[i], i, t->NumPort);
12121 PackAddBoolEx(p, "Enables", t->Enables[i], i, t->NumPort);
12122 PackAddBoolEx(p, "Errors", t->Errors[i], i, t->NumPort);
12123 }
12124 PackSetCurrentJsonGroupName(p, NULL);
12125 }
FreeRpcListenerList(RPC_LISTENER_LIST * t)12126 void FreeRpcListenerList(RPC_LISTENER_LIST *t)
12127 {
12128 // Validate arguments
12129 if (t == NULL)
12130 {
12131 return;
12132 }
12133
12134 Free(t->Ports);
12135 Free(t->Enables);
12136 Free(t->Errors);
12137 }
12138
12139 // RPC_STR
InRpcStr(RPC_STR * t,PACK * p)12140 void InRpcStr(RPC_STR *t, PACK *p)
12141 {
12142 UINT size = 65536;
12143 char *tmp = Malloc(size);
12144 // Validate arguments
12145 if (t == NULL || p == NULL)
12146 {
12147 return;
12148 }
12149
12150 Zero(t, sizeof(RPC_STR));
12151 if (PackGetStr(p, "String", tmp, size) == false)
12152 {
12153 t->String = CopyStr("");
12154 }
12155 else
12156 {
12157 t->String = CopyStr(tmp);
12158 }
12159 Free(tmp);
12160 }
OutRpcStr(PACK * p,RPC_STR * t)12161 void OutRpcStr(PACK *p, RPC_STR *t)
12162 {
12163 // Validate arguments
12164 if (t == NULL || p == NULL)
12165 {
12166 return;
12167 }
12168
12169 PackAddStr(p, "String", t->String);
12170 }
FreeRpcStr(RPC_STR * t)12171 void FreeRpcStr(RPC_STR *t)
12172 {
12173 // Validate arguments
12174 if (t == NULL )
12175 {
12176 return;
12177 }
12178
12179 Free(t->String);
12180 }
12181
12182 // RPC_SET_PASSWORD
InRpcSetPassword(RPC_SET_PASSWORD * t,PACK * p)12183 void InRpcSetPassword(RPC_SET_PASSWORD *t, PACK *p)
12184 {
12185 // Validate arguments
12186 if (t == NULL || p == NULL)
12187 {
12188 return;
12189 }
12190
12191 Zero(t, sizeof(RPC_SET_PASSWORD));
12192 PackGetData2(p, "HashedPassword", t->HashedPassword, sizeof(t->HashedPassword));
12193 PackGetStr(p, "PlainTextPassword", t->PlainTextPassword, sizeof(t->PlainTextPassword));
12194 }
OutRpcSetPassword(PACK * p,RPC_SET_PASSWORD * t)12195 void OutRpcSetPassword(PACK *p, RPC_SET_PASSWORD *t)
12196 {
12197 // Validate arguments
12198 if (t == NULL || p == NULL)
12199 {
12200 return;
12201 }
12202
12203 PackAddData(p, "HashedPassword", t->HashedPassword, sizeof(t->HashedPassword));
12204 PackAddStr(p, "PlainTextPassword", t->PlainTextPassword);
12205 }
12206
12207 // RPC_FARM
InRpcFarm(RPC_FARM * t,PACK * p)12208 void InRpcFarm(RPC_FARM *t, PACK *p)
12209 {
12210 UINT i;
12211 // Validate arguments
12212 if (t == NULL || p == NULL)
12213 {
12214 return;
12215 }
12216
12217 Zero(t, sizeof(RPC_FARM));
12218 t->ServerType = PackGetInt(p, "ServerType");
12219 t->NumPort = PackGetIndexCount(p, "Ports");
12220 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);
12221 for (i = 0;i < t->NumPort;i++)
12222 {
12223 t->Ports[i] = PackGetIntEx(p, "Ports", i);
12224 }
12225 t->PublicIp = PackGetIp32(p, "PublicIp");
12226 PackGetStr(p, "ControllerName", t->ControllerName, sizeof(t->ControllerName));
12227 t->ControllerPort = PackGetInt(p, "ControllerPort");
12228 PackGetData2(p, "MemberPassword", t->MemberPassword, sizeof(t->MemberPassword));
12229 PackGetStr(p, "MemberPasswordPlaintext", t->MemberPasswordPlaintext, sizeof(t->MemberPasswordPlaintext));
12230 t->Weight = PackGetInt(p, "Weight");
12231 t->ControllerOnly = PackGetBool(p, "ControllerOnly");
12232 }
OutRpcFarm(PACK * p,RPC_FARM * t)12233 void OutRpcFarm(PACK *p, RPC_FARM *t)
12234 {
12235 UINT i;
12236 // Validate arguments
12237 if (t == NULL || p == NULL)
12238 {
12239 return;
12240 }
12241
12242 PackAddInt(p, "ServerType", t->ServerType);
12243 for (i = 0;i < t->NumPort;i++)
12244 {
12245 PackAddIntEx(p, "Ports", t->Ports[i], i, t->NumPort);
12246 }
12247 PackAddIp32(p, "PublicIp", t->PublicIp);
12248 PackAddStr(p, "ControllerName", t->ControllerName);
12249 PackAddInt(p, "ControllerPort", t->ControllerPort);
12250 PackAddData(p, "MemberPassword", t->MemberPassword, sizeof(t->MemberPassword));
12251 PackAddStr(p, "MemberPasswordPlaintext", t->MemberPasswordPlaintext);
12252 PackAddInt(p, "Weight", t->Weight);
12253 PackAddBool(p, "ControllerOnly", t->ControllerOnly);
12254 }
FreeRpcFarm(RPC_FARM * t)12255 void FreeRpcFarm(RPC_FARM *t)
12256 {
12257 // Validate arguments
12258 if (t == NULL)
12259 {
12260 return;
12261 }
12262
12263 Free(t->Ports);
12264 }
12265
12266 // RPC_FARM_HUB
InRpcFarmHub(RPC_FARM_HUB * t,PACK * p)12267 void InRpcFarmHub(RPC_FARM_HUB *t, PACK *p)
12268 {
12269 // Validate arguments
12270 if (t == NULL || p == NULL)
12271 {
12272 return;
12273 }
12274
12275 Zero(t, sizeof(RPC_FARM_HUB));
12276 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12277 t->DynamicHub = PackGetBool(p, "DynamicHub");
12278 }
OutRpcFarmHub(PACK * p,RPC_FARM_HUB * t)12279 void OutRpcFarmHub(PACK *p, RPC_FARM_HUB *t)
12280 {
12281 // Validate arguments
12282 if (t == NULL || p == NULL)
12283 {
12284 return;
12285 }
12286
12287 PackAddStr(p, "HubName", t->HubName);
12288 PackAddBool(p, "DynamicHub", t->DynamicHub);
12289 }
12290
12291 // RPC_FARM_INFO
InRpcFarmInfo(RPC_FARM_INFO * t,PACK * p)12292 void InRpcFarmInfo(RPC_FARM_INFO *t, PACK *p)
12293 {
12294 UINT i;
12295 // Validate arguments
12296 if (t == NULL)
12297 {
12298 return;
12299 }
12300
12301 Zero(t, sizeof(RPC_FARM_INFO));
12302 t->Id = PackGetInt(p, "Id");
12303 t->Controller = PackGetBool(p, "Controller");
12304 t->ConnectedTime = PackGetInt64(p, "ConnectedTime");
12305 t->Ip = PackGetIp32(p, "Ip");
12306 PackGetStr(p, "Hostname", t->Hostname, sizeof(t->Hostname));
12307 t->Point = PackGetInt(p, "Point");
12308 t->NumPort = PackGetIndexCount(p, "Ports");
12309 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);
12310 for (i = 0;i < t->NumPort;i++)
12311 {
12312 t->Ports[i] = PackGetIntEx(p, "Ports", i);
12313 }
12314 t->ServerCert = PackGetX(p, "ServerCert");
12315 t->NumFarmHub = PackGetIndexCount(p, "HubName");
12316 t->FarmHubs = ZeroMalloc(sizeof(RPC_FARM_HUB) * t->NumFarmHub);
12317 for (i = 0;i < t->NumFarmHub;i++)
12318 {
12319 PackGetStrEx(p, "HubName", t->FarmHubs[i].HubName, sizeof(t->FarmHubs[i].HubName), i);
12320 t->FarmHubs[i].DynamicHub = PackGetBoolEx(p, "DynamicHub", i);
12321 }
12322 t->NumSessions = PackGetInt(p, "NumSessions");
12323 t->NumTcpConnections = PackGetInt(p, "NumTcpConnections");
12324 t->Weight = PackGetInt(p, "Weight");
12325 }
OutRpcFarmInfo(PACK * p,RPC_FARM_INFO * t)12326 void OutRpcFarmInfo(PACK *p, RPC_FARM_INFO *t)
12327 {
12328 UINT i;
12329 // Validate arguments
12330 if (t == NULL || p == NULL)
12331 {
12332 return;
12333 }
12334
12335 PackAddInt(p, "Id", t->Id);
12336 PackAddBool(p, "Controller", t->Controller);
12337 PackAddTime64(p, "ConnectedTime", t->ConnectedTime);
12338 PackAddIp32(p, "Ip", t->Ip);
12339 PackAddStr(p, "Hostname", t->Hostname);
12340 PackAddInt(p, "Point", t->Point);
12341 for (i = 0;i < t->NumPort;i++)
12342 {
12343 PackAddIntEx(p, "Ports", t->Ports[i], i, t->NumPort);
12344 }
12345 PackAddX(p, "ServerCert", t->ServerCert);
12346
12347 PackSetCurrentJsonGroupName(p, "HubsList");
12348 for (i = 0;i < t->NumFarmHub;i++)
12349 {
12350 PackAddStrEx(p, "HubName", t->FarmHubs[i].HubName, i, t->NumFarmHub);
12351 PackAddBoolEx(p, "DynamicHub", t->FarmHubs[i].DynamicHub, i, t->NumFarmHub);
12352 }
12353 PackSetCurrentJsonGroupName(p, NULL);
12354
12355 PackAddInt(p, "NumSessions", t->NumSessions);
12356 PackAddInt(p, "NumTcpConnections", t->NumTcpConnections);
12357 PackAddInt(p, "Weight", t->Weight);
12358 }
FreeRpcFarmInfo(RPC_FARM_INFO * t)12359 void FreeRpcFarmInfo(RPC_FARM_INFO *t)
12360 {
12361 // Validate arguments
12362 if (t == NULL)
12363 {
12364 return;
12365 }
12366
12367 Free(t->Ports);
12368 Free(t->FarmHubs);
12369 FreeX(t->ServerCert);
12370 }
12371
InRpcEnumFarm(RPC_ENUM_FARM * t,PACK * p)12372 void InRpcEnumFarm(RPC_ENUM_FARM *t, PACK *p)
12373 {
12374 UINT i;
12375 // Validate arguments
12376 if (t == NULL || p == NULL)
12377 {
12378 return;
12379 }
12380
12381 Zero(t, sizeof(RPC_ENUM_FARM));
12382 t->NumFarm = PackGetIndexCount(p, "Id");
12383 t->Farms = ZeroMalloc(sizeof(RPC_ENUM_FARM_ITEM) * t->NumFarm);
12384
12385 for (i = 0;i < t->NumFarm;i++)
12386 {
12387 RPC_ENUM_FARM_ITEM *e = &t->Farms[i];
12388
12389 e->Id = PackGetIntEx(p, "Id", i);
12390 e->Controller = PackGetBoolEx(p, "Controller", i);
12391 e->ConnectedTime = PackGetInt64Ex(p, "ConnectedTime", i);
12392 e->Ip = PackGetIp32Ex(p, "Ip", i);
12393 PackGetStrEx(p, "Hostname", e->Hostname, sizeof(e->Hostname), i);
12394 e->Point = PackGetIntEx(p, "Point", i);
12395 e->NumSessions = PackGetIntEx(p, "NumSessions", i);
12396 e->NumTcpConnections = PackGetIntEx(p, "NumTcpConnections", i);
12397 e->NumHubs = PackGetIntEx(p, "NumHubs", i);
12398 e->AssignedClientLicense = PackGetIntEx(p, "AssignedClientLicense", i);
12399 e->AssignedBridgeLicense = PackGetIntEx(p, "AssignedBridgeLicense", i);
12400 }
12401 }
OutRpcEnumFarm(PACK * p,RPC_ENUM_FARM * t)12402 void OutRpcEnumFarm(PACK *p, RPC_ENUM_FARM *t)
12403 {
12404 UINT i;
12405 // Validate arguments
12406 if (t == NULL || p == NULL)
12407 {
12408 return;
12409 }
12410
12411 PackSetCurrentJsonGroupName(p, "FarmMemberList");
12412 for (i = 0;i < t->NumFarm;i++)
12413 {
12414 RPC_ENUM_FARM_ITEM *e = &t->Farms[i];
12415
12416 PackAddIntEx(p, "Id", e->Id, i, t->NumFarm);
12417 PackAddBoolEx(p, "Controller", e->Controller, i, t->NumFarm);
12418 PackAddTime64Ex(p, "ConnectedTime", e->ConnectedTime, i, t->NumFarm);
12419 PackAddIp32Ex(p, "Ip", e->Ip, i, t->NumFarm);
12420 PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumFarm);
12421 PackAddIntEx(p, "Point", e->Point, i, t->NumFarm);
12422 PackAddIntEx(p, "NumSessions", e->NumSessions, i, t->NumFarm);
12423 PackAddIntEx(p, "NumTcpConnections", e->NumTcpConnections, i, t->NumFarm);
12424 PackAddIntEx(p, "NumHubs", e->NumHubs, i, t->NumFarm);
12425 PackAddIntEx(p, "AssignedClientLicense", e->AssignedClientLicense, i, t->NumFarm);
12426 PackAddIntEx(p, "AssignedBridgeLicense", e->AssignedBridgeLicense, i, t->NumFarm);
12427 }
12428 PackSetCurrentJsonGroupName(p, NULL);
12429 }
FreeRpcEnumFarm(RPC_ENUM_FARM * t)12430 void FreeRpcEnumFarm(RPC_ENUM_FARM *t)
12431 {
12432 // Validate arguments
12433 if (t == NULL)
12434 {
12435 return;
12436 }
12437
12438 Free(t->Farms);
12439 }
12440
12441 // RPC_FARM_CONNECTION_STATUS
InRpcFarmConnectionStatus(RPC_FARM_CONNECTION_STATUS * t,PACK * p)12442 void InRpcFarmConnectionStatus(RPC_FARM_CONNECTION_STATUS *t, PACK *p)
12443 {
12444 Zero(t, sizeof(RPC_FARM_CONNECTION_STATUS));
12445 // Validate arguments
12446 if (t == NULL || p == NULL)
12447 {
12448 return;
12449 }
12450
12451 t->Ip = PackGetIp32(p, "Ip");
12452 t->Port = PackGetInt(p, "Port");
12453 t->Online = PackGetBool(p, "Online");
12454 t->LastError = PackGetInt(p, "LastError");
12455 t->StartedTime = PackGetInt64(p, "StartedTime");
12456 t->CurrentConnectedTime = PackGetInt64(p, "CurrentConnectedTime");
12457 t->FirstConnectedTime = PackGetInt64(p, "FirstConnectedTime");
12458 t->NumConnected = PackGetInt(p, "NumConnected");
12459 t->NumTry = PackGetInt(p, "NumTry");
12460 t->NumFailed = PackGetInt(p, "NumFailed");
12461 }
OutRpcFarmConnectionStatus(PACK * p,RPC_FARM_CONNECTION_STATUS * t)12462 void OutRpcFarmConnectionStatus(PACK *p, RPC_FARM_CONNECTION_STATUS *t)
12463 {
12464 // Validate arguments
12465 if (t == NULL || p == NULL)
12466 {
12467 return;
12468 }
12469
12470 PackAddIp32(p, "Ip", t->Ip);
12471 PackAddInt(p, "Port", t->Port);
12472 PackAddBool(p, "Online", t->Online);
12473 PackAddInt(p, "LastError", t->LastError);
12474 PackAddTime64(p, "StartedTime", t->StartedTime);
12475 PackAddTime64(p, "CurrentConnectedTime", t->CurrentConnectedTime);
12476 PackAddTime64(p, "FirstConnectedTime", t->FirstConnectedTime);
12477 PackAddInt(p, "NumConnected", t->NumConnected);
12478 PackAddInt(p, "NumTry", t->NumTry);
12479 PackAddInt(p, "NumFailed", t->NumFailed);
12480 }
12481
12482 // RPC_HUB_OPTION
InRpcHubOption(RPC_HUB_OPTION * t,PACK * p)12483 void InRpcHubOption(RPC_HUB_OPTION *t, PACK *p)
12484 {
12485 // Validate arguments
12486 if (t == NULL || p == NULL)
12487 {
12488 return;
12489 }
12490
12491 Zero(t, sizeof(RPC_HUB_OPTION));
12492 t->MaxSession = PackGetInt(p, "MaxSession");
12493 t->NoEnum = PackGetBool(p, "NoEnum");
12494 }
OutRpcHubOption(PACK * p,RPC_HUB_OPTION * t)12495 void OutRpcHubOption(PACK *p, RPC_HUB_OPTION *t)
12496 {
12497 // Validate arguments
12498 if (t == NULL || p == NULL)
12499 {
12500 return;
12501 }
12502
12503 PackAddInt(p, "MaxSession", t->MaxSession);
12504 PackAddBool(p, "NoEnum", t->NoEnum);
12505 }
12506
12507 // RPC_RADIUS
InRpcRadius(RPC_RADIUS * t,PACK * p)12508 void InRpcRadius(RPC_RADIUS *t, PACK *p)
12509 {
12510 // Validate arguments
12511 if (t == NULL || p == NULL)
12512 {
12513 return;
12514 }
12515
12516 Zero(t, sizeof(RPC_RADIUS));
12517 PackGetStr(p, "RadiusServerName", t->RadiusServerName, sizeof(t->RadiusServerName));
12518 t->RadiusPort = PackGetInt(p, "RadiusPort");
12519 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12520 PackGetStr(p, "RadiusSecret", t->RadiusSecret, sizeof(t->RadiusSecret));
12521 t->RadiusRetryInterval = PackGetInt(p, "RadiusRetryInterval");
12522 }
OutRpcRadius(PACK * p,RPC_RADIUS * t)12523 void OutRpcRadius(PACK *p, RPC_RADIUS *t)
12524 {
12525 // Validate arguments
12526 if (t == NULL || p == NULL)
12527 {
12528 return;
12529 }
12530
12531 PackAddStr(p, "RadiusServerName", t->RadiusServerName);
12532 PackAddInt(p, "RadiusPort", t->RadiusPort);
12533 PackAddStr(p, "HubName", t->HubName);
12534 PackAddStr(p, "RadiusSecret", t->RadiusSecret);
12535 PackAddInt(p, "RadiusRetryInterval", t->RadiusRetryInterval);
12536 }
12537
12538 // RPC_HUB
InRpcHub(RPC_HUB * t,PACK * p)12539 void InRpcHub(RPC_HUB *t, PACK *p)
12540 {
12541 // Validate arguments
12542 if (t == NULL || p == NULL)
12543 {
12544 return;
12545 }
12546
12547 Zero(t, sizeof(RPC_HUB));
12548 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12549 }
OutRpcHub(PACK * p,RPC_HUB * t)12550 void OutRpcHub(PACK *p, RPC_HUB *t)
12551 {
12552 // Validate arguments
12553 if (t == NULL || p == NULL)
12554 {
12555 return;
12556 }
12557
12558 PackAddStr(p, "HubName", t->HubName);
12559 }
12560
12561 // RPC_CREATE_HUB
InRpcCreateHub(RPC_CREATE_HUB * t,PACK * p)12562 void InRpcCreateHub(RPC_CREATE_HUB *t, PACK *p)
12563 {
12564 // Validate arguments
12565 if (t == NULL || p == NULL)
12566 {
12567 return;
12568 }
12569
12570 Zero(t, sizeof(RPC_CREATE_HUB));
12571 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12572 PackGetData2(p, "HashedPassword", t->HashedPassword, sizeof(t->HashedPassword));
12573 PackGetData2(p, "SecurePassword", t->SecurePassword, sizeof(t->SecurePassword));
12574 PackGetStr(p, "AdminPasswordPlainText", t->AdminPasswordPlainText, sizeof(t->AdminPasswordPlainText));
12575 t->Online = PackGetBool(p, "Online");
12576 InRpcHubOption(&t->HubOption, p);
12577 t->HubType = PackGetInt(p, "HubType");
12578 }
OutRpcCreateHub(PACK * p,RPC_CREATE_HUB * t)12579 void OutRpcCreateHub(PACK *p, RPC_CREATE_HUB *t)
12580 {
12581 // Validate arguments
12582 if (t == NULL || p == NULL)
12583 {
12584 return;
12585 }
12586
12587 PackAddStr(p, "HubName", t->HubName);
12588 PackAddData(p, "HashedPassword", t->HashedPassword, sizeof(t->HashedPassword));
12589 PackAddData(p, "SecurePassword", t->SecurePassword, sizeof(t->SecurePassword));
12590 PackAddBool(p, "Online", t->Online);
12591 PackAddStr(p, "AdminPasswordPlainText", t->AdminPasswordPlainText);
12592 OutRpcHubOption(p, &t->HubOption);
12593 PackAddInt(p, "HubType", t->HubType);
12594 }
12595
12596 // RPC_ENUM_HUB
InRpcEnumHub(RPC_ENUM_HUB * t,PACK * p)12597 void InRpcEnumHub(RPC_ENUM_HUB *t, PACK *p)
12598 {
12599 UINT i;
12600 // Validate arguments
12601 if (t == NULL || p == NULL)
12602 {
12603 return;
12604 }
12605
12606 Zero(t, sizeof(RPC_ENUM_HUB));
12607 t->NumHub = PackGetIndexCount(p, "HubName");
12608 t->Hubs = ZeroMalloc(sizeof(RPC_ENUM_HUB_ITEM) * t->NumHub);
12609
12610 for (i = 0;i < t->NumHub;i++)
12611 {
12612 RPC_ENUM_HUB_ITEM *e = &t->Hubs[i];
12613
12614 PackGetStrEx(p, "HubName", e->HubName, sizeof(e->HubName), i);
12615 e->Online = PackGetBoolEx(p, "Online", i);
12616 e->HubType = PackGetIntEx(p, "HubType", i);
12617 e->NumSessions = PackGetIntEx(p, "NumSessions", i);
12618 e->NumUsers = PackGetIntEx(p, "NumUsers", i);
12619 e->NumGroups = PackGetIntEx(p, "NumGroups", i);
12620 e->NumMacTables = PackGetIntEx(p, "NumMacTables", i);
12621 e->NumIpTables = PackGetIntEx(p, "NumIpTables", i);
12622 e->LastCommTime = PackGetInt64Ex(p, "LastCommTime", i);
12623 e->CreatedTime = PackGetInt64Ex(p, "CreatedTime", i);
12624 e->LastLoginTime = PackGetInt64Ex(p, "LastLoginTime", i);
12625 e->NumLogin = PackGetIntEx(p, "NumLogin", i);
12626 e->IsTrafficFilled = PackGetBoolEx(p, "IsTrafficFilled", i);
12627
12628 InRpcTrafficEx(&e->Traffic, p, i);
12629 }
12630 }
OutRpcEnumHub(PACK * p,RPC_ENUM_HUB * t)12631 void OutRpcEnumHub(PACK *p, RPC_ENUM_HUB *t)
12632 {
12633 UINT i;
12634 // Validate arguments
12635 if (t == NULL || p == NULL)
12636 {
12637 return;
12638 }
12639
12640 PackSetCurrentJsonGroupName(p, "HubList");
12641 for (i = 0;i < t->NumHub;i++)
12642 {
12643 RPC_ENUM_HUB_ITEM *e = &t->Hubs[i];
12644
12645 PackAddStrEx(p, "HubName", e->HubName, i, t->NumHub);
12646 PackAddBoolEx(p, "Online", e->Online, i, t->NumHub);
12647 PackAddIntEx(p, "HubType", e->HubType, i, t->NumHub);
12648 PackAddIntEx(p, "NumSessions", e->NumSessions, i, t->NumHub);
12649 PackAddIntEx(p, "NumUsers", e->NumUsers, i, t->NumHub);
12650 PackAddIntEx(p, "NumGroups", e->NumGroups, i, t->NumHub);
12651 PackAddIntEx(p, "NumMacTables", e->NumMacTables, i, t->NumHub);
12652 PackAddIntEx(p, "NumIpTables", e->NumIpTables, i, t->NumHub);
12653 PackAddTime64Ex(p, "LastCommTime", e->LastCommTime, i, t->NumHub);
12654 PackAddTime64Ex(p, "CreatedTime", e->CreatedTime, i, t->NumHub);
12655 PackAddTime64Ex(p, "LastLoginTime", e->LastLoginTime, i, t->NumHub);
12656 PackAddIntEx(p, "NumLogin", e->NumLogin, i, t->NumHub);
12657 PackAddBoolEx(p, "IsTrafficFilled", e->IsTrafficFilled, i, t->NumHub);
12658
12659 OutRpcTrafficEx(&e->Traffic, p, i, t->NumHub);
12660 }
12661 PackSetCurrentJsonGroupName(p, NULL);
12662 }
FreeRpcEnumHub(RPC_ENUM_HUB * t)12663 void FreeRpcEnumHub(RPC_ENUM_HUB *t)
12664 {
12665 // Validate arguments
12666 if (t == NULL)
12667 {
12668 return;
12669 }
12670
12671 Free(t->Hubs);
12672 }
12673
12674 // RPC_DELETE_HUB
InRpcDeleteHub(RPC_DELETE_HUB * t,PACK * p)12675 void InRpcDeleteHub(RPC_DELETE_HUB *t, PACK *p)
12676 {
12677 // Validate arguments
12678 if (t == NULL || p == NULL)
12679 {
12680 return;
12681 }
12682
12683 Zero(t, sizeof(RPC_DELETE_HUB));
12684 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12685 }
OutRpcDeleteHub(PACK * p,RPC_DELETE_HUB * t)12686 void OutRpcDeleteHub(PACK *p, RPC_DELETE_HUB *t)
12687 {
12688 // Validate arguments
12689 if (t == NULL || p == NULL)
12690 {
12691 return;
12692 }
12693
12694 PackAddStr(p, "HubName", t->HubName);
12695 }
12696
12697 // RPC_ENUM_CONNECTION
InRpcEnumConnection(RPC_ENUM_CONNECTION * t,PACK * p)12698 void InRpcEnumConnection(RPC_ENUM_CONNECTION *t, PACK *p)
12699 {
12700 UINT i;
12701 // Validate arguments
12702 if (t == NULL || p == NULL)
12703 {
12704 return;
12705 }
12706
12707 Zero(t, sizeof(RPC_ENUM_CONNECTION));
12708 t->NumConnection = PackGetIndexCount(p, "Name");
12709 t->Connections = ZeroMalloc(sizeof(RPC_ENUM_CONNECTION_ITEM) * t->NumConnection);
12710
12711 for (i = 0;i < t->NumConnection;i++)
12712 {
12713 RPC_ENUM_CONNECTION_ITEM *e = &t->Connections[i];
12714
12715 e->Ip = PackGetIp32Ex(p, "Ip", i);
12716 e->Port = PackGetIntEx(p, "Port", i);
12717 PackGetStrEx(p, "Name", e->Name, sizeof(e->Name), i);
12718 PackGetStrEx(p, "Hostname", e->Hostname, sizeof(e->Hostname), i);
12719 e->ConnectedTime = PackGetInt64Ex(p, "ConnectedTime", i);
12720 e->Type = PackGetIntEx(p, "Type", i);
12721 }
12722 }
OutRpcEnumConnection(PACK * p,RPC_ENUM_CONNECTION * t)12723 void OutRpcEnumConnection(PACK *p, RPC_ENUM_CONNECTION *t)
12724 {
12725 UINT i;
12726 // Validate arguments
12727 if (t == NULL || p == NULL)
12728 {
12729 return;
12730 }
12731
12732 PackSetCurrentJsonGroupName(p, "ConnectionList");
12733 for (i = 0;i < t->NumConnection;i++)
12734 {
12735 RPC_ENUM_CONNECTION_ITEM *e = &t->Connections[i];
12736
12737 PackAddIp32Ex(p, "Ip", e->Ip, i, t->NumConnection);
12738 PackAddIntEx(p, "Port", e->Port, i, t->NumConnection);
12739 PackAddStrEx(p, "Name", e->Name, i, t->NumConnection);
12740 PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumConnection);
12741 PackAddTime64Ex(p, "ConnectedTime", e->ConnectedTime, i, t->NumConnection);
12742 PackAddIntEx(p, "Type", e->Type, i, t->NumConnection);
12743 }
12744 PackSetCurrentJsonGroupName(p, NULL);
12745 }
FreeRpcEnumConnetion(RPC_ENUM_CONNECTION * t)12746 void FreeRpcEnumConnetion(RPC_ENUM_CONNECTION *t)
12747 {
12748 // Validate arguments
12749 if (t == NULL)
12750 {
12751 return;
12752 }
12753
12754 Free(t->Connections);
12755 }
12756
12757 // RPC_DISCONNECT_CONNECTION
InRpcDisconnectConnection(RPC_DISCONNECT_CONNECTION * t,PACK * p)12758 void InRpcDisconnectConnection(RPC_DISCONNECT_CONNECTION *t, PACK *p)
12759 {
12760 // Validate arguments
12761 if (t == NULL || p == NULL)
12762 {
12763 return;
12764 }
12765
12766 Zero(t, sizeof(RPC_DISCONNECT_CONNECTION));
12767 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
12768 }
OutRpcDisconnectConnection(PACK * p,RPC_DISCONNECT_CONNECTION * t)12769 void OutRpcDisconnectConnection(PACK *p, RPC_DISCONNECT_CONNECTION *t)
12770 {
12771 // Validate arguments
12772 if (t == NULL || p == NULL)
12773 {
12774 return;
12775 }
12776
12777 PackAddStr(p, "Name", t->Name);
12778 }
12779
12780 // RPC_CONNECTION_INFO
InRpcConnectionInfo(RPC_CONNECTION_INFO * t,PACK * p)12781 void InRpcConnectionInfo(RPC_CONNECTION_INFO *t, PACK *p)
12782 {
12783 // Validate arguments
12784 if (t == NULL || p == NULL)
12785 {
12786 return;
12787 }
12788
12789 Zero(t, sizeof(RPC_CONNECTION_INFO));
12790 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
12791 t->Ip = PackGetIp32(p, "Ip");
12792 t->Port = PackGetInt(p, "Port");
12793 t->ConnectedTime = PackGetInt64(p, "ConnectedTime");
12794 PackGetStr(p, "Hostname", t->Hostname, sizeof(t->Hostname));
12795 PackGetStr(p, "ServerStr", t->ServerStr, sizeof(t->ServerStr));
12796 PackGetStr(p, "ClientStr", t->ClientStr, sizeof(t->ClientStr));
12797 t->ServerVer = PackGetInt(p, "ServerVer");
12798 t->ServerBuild = PackGetInt(p, "ServerBuild");
12799 t->ClientVer = PackGetInt(p, "ClientVer");
12800 t->ClientBuild = PackGetInt(p, "ClientBuild");
12801 t->Type = PackGetInt(p, "Type");
12802 }
OutRpcConnectionInfo(PACK * p,RPC_CONNECTION_INFO * t)12803 void OutRpcConnectionInfo(PACK *p, RPC_CONNECTION_INFO *t)
12804 {
12805 // Validate arguments
12806 if (t == NULL || p == NULL)
12807 {
12808 return;
12809 }
12810
12811 PackAddStr(p, "Name", t->Name);
12812 PackAddIp32(p, "Ip", t->Ip);
12813 PackAddInt(p, "Port", t->Port);
12814 PackAddTime64(p, "ConnectedTime", t->ConnectedTime);
12815 PackAddStr(p, "Hostname", t->Hostname);
12816 PackAddStr(p, "ServerStr", t->ServerStr);
12817 PackAddStr(p, "ClientStr", t->ClientStr);
12818 PackAddInt(p, "ServerVer", t->ServerVer);
12819 PackAddInt(p, "ServerBuild", t->ServerBuild);
12820 PackAddInt(p, "ClientVer", t->ClientVer);
12821 PackAddInt(p, "ClientBuild", t->ClientBuild);
12822 PackAddInt(p, "Type", t->Type);
12823 }
12824
12825 // RPC_SET_HUB_ONLINE
InRpcSetHubOnline(RPC_SET_HUB_ONLINE * t,PACK * p)12826 void InRpcSetHubOnline(RPC_SET_HUB_ONLINE *t, PACK *p)
12827 {
12828 // Validate arguments
12829 if (t == NULL || p == NULL)
12830 {
12831 return;
12832 }
12833
12834 Zero(t, sizeof(RPC_SET_HUB_ONLINE));
12835 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12836 t->Online = PackGetBool(p, "Online");
12837 }
OutRpcSetHubOnline(PACK * p,RPC_SET_HUB_ONLINE * t)12838 void OutRpcSetHubOnline(PACK *p, RPC_SET_HUB_ONLINE *t)
12839 {
12840 // Validate arguments
12841 if (t == NULL || p == NULL)
12842 {
12843 return;
12844 }
12845
12846 PackAddStr(p, "HubName", t->HubName);
12847 PackAddBool(p, "Online", t->Online);
12848 }
12849
12850 // RPC_HUB_STATUS
InRpcHubStatus(RPC_HUB_STATUS * t,PACK * p)12851 void InRpcHubStatus(RPC_HUB_STATUS *t, PACK *p)
12852 {
12853 Zero(t, sizeof(RPC_HUB_STATUS));
12854 // Validate arguments
12855 if (t == NULL || p == NULL)
12856 {
12857 return;
12858 }
12859
12860 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12861 t->Online = PackGetBool(p, "Online");
12862 t->HubType = PackGetInt(p, "HubType");
12863 t->NumSessions = PackGetInt(p, "NumSessions");
12864 t->NumSessionsClient = PackGetInt(p, "NumSessionsClient");
12865 t->NumSessionsBridge = PackGetInt(p, "NumSessionsBridge");
12866 t->NumAccessLists = PackGetInt(p, "NumAccessLists");
12867 t->NumUsers = PackGetInt(p, "NumUsers");
12868 t->NumGroups = PackGetInt(p, "NumGroups");
12869 t->NumMacTables = PackGetInt(p, "NumMacTables");
12870 t->NumIpTables = PackGetInt(p, "NumIpTables");
12871 t->SecureNATEnabled = PackGetBool(p, "SecureNATEnabled");
12872 InRpcTraffic(&t->Traffic, p);
12873 t->LastCommTime = PackGetInt64(p, "LastCommTime");
12874 t->CreatedTime = PackGetInt64(p, "CreatedTime");
12875 t->LastLoginTime = PackGetInt64(p, "LastLoginTime");
12876 t->NumLogin = PackGetInt(p, "NumLogin");
12877 }
OutRpcHubStatus(PACK * p,RPC_HUB_STATUS * t)12878 void OutRpcHubStatus(PACK *p, RPC_HUB_STATUS *t)
12879 {
12880 // Validate arguments
12881 if (t == NULL || p == NULL)
12882 {
12883 return;
12884 }
12885
12886 PackAddStr(p, "HubName", t->HubName);
12887 PackAddBool(p, "Online", t->Online);
12888 PackAddInt(p, "HubType", t->HubType);
12889 PackAddInt(p, "NumSessions", t->NumSessions);
12890 PackAddInt(p, "NumSessionsClient", t->NumSessionsClient);
12891 PackAddInt(p, "NumSessionsBridge", t->NumSessionsBridge);
12892 PackAddInt(p, "NumAccessLists", t->NumAccessLists);
12893 PackAddInt(p, "NumUsers", t->NumUsers);
12894 PackAddInt(p, "NumGroups", t->NumGroups);
12895 PackAddInt(p, "NumMacTables", t->NumMacTables);
12896 PackAddInt(p, "NumIpTables", t->NumIpTables);
12897 PackAddBool(p, "SecureNATEnabled", t->SecureNATEnabled);
12898 OutRpcTraffic(p, &t->Traffic);
12899 PackAddTime64(p, "LastCommTime", t->LastCommTime);
12900 PackAddTime64(p, "CreatedTime", t->CreatedTime);
12901 PackAddTime64(p, "LastLoginTime", t->LastLoginTime);
12902 PackAddInt(p, "NumLogin", t->NumLogin);
12903 }
12904
12905 // RPC_HUB_LOG
InRpcHubLog(RPC_HUB_LOG * t,PACK * p)12906 void InRpcHubLog(RPC_HUB_LOG *t, PACK *p)
12907 {
12908 UINT i;
12909 // Validate arguments
12910 if (t == NULL || p == NULL)
12911 {
12912 return;
12913 }
12914
12915 Zero(t, sizeof(RPC_HUB_LOG));
12916 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12917 t->LogSetting.SaveSecurityLog = PackGetBool(p, "SaveSecurityLog");
12918 t->LogSetting.SecurityLogSwitchType = PackGetInt(p, "SecurityLogSwitchType");
12919 t->LogSetting.SavePacketLog = PackGetBool(p, "SavePacketLog");
12920 t->LogSetting.PacketLogSwitchType = PackGetInt(p, "PacketLogSwitchType");
12921 for (i = 0;i < NUM_PACKET_LOG;i++)
12922 {
12923 t->LogSetting.PacketLogConfig[i] = PackGetIntEx(p, "PacketLogConfig", i);
12924 }
12925 }
OutRpcHubLog(PACK * p,RPC_HUB_LOG * t)12926 void OutRpcHubLog(PACK *p, RPC_HUB_LOG *t)
12927 {
12928 UINT i;
12929 // Validate arguments
12930 if (t == NULL || p == NULL)
12931 {
12932 return;
12933 }
12934
12935 PackAddStr(p, "HubName", t->HubName);
12936 PackAddBool(p, "SaveSecurityLog", t->LogSetting.SaveSecurityLog);
12937 PackAddInt(p, "SecurityLogSwitchType", t->LogSetting.SecurityLogSwitchType);
12938 PackAddBool(p, "SavePacketLog", t->LogSetting.SavePacketLog);
12939 PackAddInt(p, "PacketLogSwitchType", t->LogSetting.PacketLogSwitchType);
12940 for (i = 0;i < NUM_PACKET_LOG;i++)
12941 {
12942 PackAddIntEx(p, "PacketLogConfig", t->LogSetting.PacketLogConfig[i], i, NUM_PACKET_LOG);
12943 }
12944 }
12945
12946 // RPC_HUB_ADD_CA
InRpcHubAddCa(RPC_HUB_ADD_CA * t,PACK * p)12947 void InRpcHubAddCa(RPC_HUB_ADD_CA *t, PACK *p)
12948 {
12949 // Validate arguments
12950 if (t == NULL || p == NULL)
12951 {
12952 return;
12953 }
12954
12955 Zero(t, sizeof(RPC_HUB_ADD_CA));
12956 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12957 t->Cert = PackGetX(p, "Cert");
12958 }
OutRpcHubAddCa(PACK * p,RPC_HUB_ADD_CA * t)12959 void OutRpcHubAddCa(PACK *p, RPC_HUB_ADD_CA *t)
12960 {
12961 // Validate arguments
12962 if (t == NULL || p == NULL)
12963 {
12964 return;
12965 }
12966
12967 PackAddStr(p, "HubName", t->HubName);
12968 PackAddX(p, "Cert", t->Cert);
12969 }
FreeRpcHubAddCa(RPC_HUB_ADD_CA * t)12970 void FreeRpcHubAddCa(RPC_HUB_ADD_CA *t)
12971 {
12972 // Validate arguments
12973 if (t == NULL)
12974 {
12975 return;
12976 }
12977
12978 FreeX(t->Cert);
12979 }
12980
12981 // RPC_HUB_ENUM_CA
InRpcHubEnumCa(RPC_HUB_ENUM_CA * t,PACK * p)12982 void InRpcHubEnumCa(RPC_HUB_ENUM_CA *t, PACK *p)
12983 {
12984 UINT i;
12985 // Validate arguments
12986 if (t == NULL || p == NULL)
12987 {
12988 return;
12989 }
12990
12991 Zero(t, sizeof(RPC_HUB_ENUM_CA));
12992 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
12993 t->NumCa = PackGetIndexCount(p, "Key");
12994 t->Ca = ZeroMalloc(sizeof(RPC_HUB_ENUM_CA_ITEM) * t->NumCa);
12995
12996 for (i = 0;i < t->NumCa;i++)
12997 {
12998 RPC_HUB_ENUM_CA_ITEM *e = &t->Ca[i];
12999
13000 e->Key = PackGetIntEx(p, "Key", i);
13001 PackGetUniStrEx(p, "SubjectName", e->SubjectName, sizeof(e->SubjectName), i);
13002 PackGetUniStrEx(p, "IssuerName", e->IssuerName, sizeof(e->IssuerName), i);
13003 e->Expires = PackGetInt64Ex(p, "Expires", i);
13004 }
13005 }
OutRpcHubEnumCa(PACK * p,RPC_HUB_ENUM_CA * t)13006 void OutRpcHubEnumCa(PACK *p, RPC_HUB_ENUM_CA *t)
13007 {
13008 UINT i;
13009 // Validate arguments
13010 if (t == NULL || p == NULL)
13011 {
13012 return;
13013 }
13014 PackAddStr(p, "HubName", t->HubName);
13015
13016 PackSetCurrentJsonGroupName(p, "CAList");
13017 for (i = 0;i < t->NumCa;i++)
13018 {
13019 RPC_HUB_ENUM_CA_ITEM *e = &t->Ca[i];
13020
13021 PackAddIntEx(p, "Key", e->Key, i, t->NumCa);
13022 PackAddUniStrEx(p, "SubjectName", e->SubjectName, i, t->NumCa);
13023 PackAddUniStrEx(p, "IssuerName", e->IssuerName, i, t->NumCa);
13024 PackAddTime64Ex(p, "Expires", e->Expires, i, t->NumCa);
13025 }
13026 PackSetCurrentJsonGroupName(p, NULL);
13027 }
FreeRpcHubEnumCa(RPC_HUB_ENUM_CA * t)13028 void FreeRpcHubEnumCa(RPC_HUB_ENUM_CA *t)
13029 {
13030 // Validate arguments
13031 if (t == NULL)
13032 {
13033 return;
13034 }
13035
13036 Free(t->Ca);
13037 }
13038
13039 // RPC_HUB_GET_CA
InRpcHubGetCa(RPC_HUB_GET_CA * t,PACK * p)13040 void InRpcHubGetCa(RPC_HUB_GET_CA *t, PACK *p)
13041 {
13042 // Validate arguments
13043 if (t == NULL || p == NULL)
13044 {
13045 return;
13046 }
13047
13048 Zero(t, sizeof(RPC_HUB_GET_CA));
13049 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13050 t->Key = PackGetInt(p, "Key");
13051 t->Cert = PackGetX(p, "Cert");
13052 }
OutRpcHubGetCa(PACK * p,RPC_HUB_GET_CA * t)13053 void OutRpcHubGetCa(PACK *p, RPC_HUB_GET_CA *t)
13054 {
13055 // Validate arguments
13056 if (t == NULL || p == NULL)
13057 {
13058 return;
13059 }
13060
13061 PackAddStr(p, "HubName", t->HubName);
13062 PackAddInt(p, "Key", t->Key);
13063 PackAddX(p, "Cert", t->Cert);
13064 }
FreeRpcHubGetCa(RPC_HUB_GET_CA * t)13065 void FreeRpcHubGetCa(RPC_HUB_GET_CA *t)
13066 {
13067 // Validate arguments
13068 if (t == NULL)
13069 {
13070 return;
13071 }
13072
13073 FreeX(t->Cert);
13074 }
13075
13076 // RPC_HUB_DELETE_CA
InRpcHubDeleteCa(RPC_HUB_DELETE_CA * t,PACK * p)13077 void InRpcHubDeleteCa(RPC_HUB_DELETE_CA *t, PACK *p)
13078 {
13079 // Validate arguments
13080 if (t == NULL || p == NULL)
13081 {
13082 return;
13083 }
13084
13085 Zero(t, sizeof(RPC_HUB_DELETE_CA));
13086 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13087 t->Key = PackGetInt(p, "Key");
13088 }
OutRpcHubDeleteCa(PACK * p,RPC_HUB_DELETE_CA * t)13089 void OutRpcHubDeleteCa(PACK *p, RPC_HUB_DELETE_CA *t)
13090 {
13091 // Validate arguments
13092 if (t == NULL || p == NULL)
13093 {
13094 return;
13095 }
13096
13097 PackAddStr(p, "HubName", t->HubName);
13098 PackAddInt(p, "Key", t->Key);
13099 }
13100
13101 // RPC_CREATE_LINK
InRpcCreateLink(RPC_CREATE_LINK * t,PACK * p)13102 void InRpcCreateLink(RPC_CREATE_LINK *t, PACK *p)
13103 {
13104 BUF *b;
13105 // Validate arguments
13106 if (t == NULL || p == NULL)
13107 {
13108 return;
13109 }
13110
13111 Zero(t, sizeof(RPC_CREATE_LINK));
13112 PackGetStr(p, "HubName_Ex", t->HubName, sizeof(t->HubName));
13113 t->Online = PackGetBool(p, "Online");
13114 t->ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
13115 InRpcClientOption(t->ClientOption, p);
13116 t->ClientAuth = ZeroMalloc(sizeof(CLIENT_AUTH));
13117 InRpcClientAuth(t->ClientAuth, p);
13118 InRpcPolicy(&t->Policy, p);
13119
13120 t->CheckServerCert = PackGetBool(p, "CheckServerCert");
13121 b = PackGetBuf(p, "ServerCert");
13122 if (b != NULL)
13123 {
13124 t->ServerCert = BufToX(b, false);
13125 FreeBuf(b);
13126 }
13127 }
OutRpcCreateLink(PACK * p,RPC_CREATE_LINK * t)13128 void OutRpcCreateLink(PACK *p, RPC_CREATE_LINK *t)
13129 {
13130 // Validate arguments
13131 if (t == NULL || p == NULL)
13132 {
13133 return;
13134 }
13135
13136 PackAddStr(p, "HubName_Ex",t->HubName);
13137 PackAddBool(p, "Online", t->Online);
13138 OutRpcClientOption(p, t->ClientOption);
13139 OutRpcClientAuth(p, t->ClientAuth);
13140 OutRpcPolicy(p, &t->Policy);
13141
13142 PackAddBool(p, "CheckServerCert", t->CheckServerCert);
13143 if (t->ServerCert != NULL)
13144 {
13145 BUF *b;
13146 b = XToBuf(t->ServerCert, false);
13147 PackAddBuf(p, "ServerCert", b);
13148 FreeBuf(b);
13149 }
13150 }
FreeRpcCreateLink(RPC_CREATE_LINK * t)13151 void FreeRpcCreateLink(RPC_CREATE_LINK *t)
13152 {
13153 // Validate arguments
13154 if (t == NULL)
13155 {
13156 return;
13157 }
13158
13159 if (t->ServerCert != NULL)
13160 {
13161 FreeX(t->ServerCert);
13162 }
13163 Free(t->ClientOption);
13164 CiFreeClientAuth(t->ClientAuth);
13165 }
13166
13167 // RPC_ENUM_LINK
InRpcEnumLink(RPC_ENUM_LINK * t,PACK * p)13168 void InRpcEnumLink(RPC_ENUM_LINK *t, PACK *p)
13169 {
13170 UINT i;
13171 // Validate arguments
13172 if (t == NULL || p == NULL)
13173 {
13174 return;
13175 }
13176
13177 Zero(t, sizeof(RPC_ENUM_LINK));
13178 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13179 t->NumLink = PackGetIndexCount(p, "AccountName");
13180 t->Links = ZeroMalloc(sizeof(RPC_ENUM_LINK_ITEM) * t->NumLink);
13181
13182 for (i = 0;i < t->NumLink;i++)
13183 {
13184 RPC_ENUM_LINK_ITEM *e = &t->Links[i];
13185
13186 PackGetUniStrEx(p, "AccountName", e->AccountName, sizeof(e->AccountName), i);
13187 PackGetStrEx(p, "Hostname", e->Hostname, sizeof(e->Hostname), i);
13188 PackGetStrEx(p, "ConnectedHubName", e->HubName, sizeof(e->HubName), i);
13189 e->Online = PackGetBoolEx(p, "Online", i);
13190 e->ConnectedTime = PackGetInt64Ex(p, "ConnectedTime", i);
13191 e->Connected = PackGetBoolEx(p, "Connected", i);
13192 e->LastError = PackGetIntEx(p, "LastError", i);
13193 PackGetStrEx(p, "LinkHubName", e->HubName, sizeof(e->HubName), i);
13194 }
13195 }
OutRpcEnumLink(PACK * p,RPC_ENUM_LINK * t)13196 void OutRpcEnumLink(PACK *p, RPC_ENUM_LINK *t)
13197 {
13198 UINT i;
13199 // Validate arguments
13200 if (t == NULL || p == NULL)
13201 {
13202 return;
13203 }
13204
13205 PackAddStr(p, "HubName", t->HubName);
13206
13207 PackSetCurrentJsonGroupName(p, "LinkList");
13208 for (i = 0;i < t->NumLink;i++)
13209 {
13210 RPC_ENUM_LINK_ITEM *e = &t->Links[i];
13211
13212 PackAddUniStrEx(p, "AccountName", e->AccountName, i, t->NumLink);
13213 PackAddStrEx(p, "ConnectedHubName", e->HubName, i, t->NumLink);
13214 PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumLink);
13215 PackAddBoolEx(p, "Online", e->Online, i, t->NumLink);
13216 PackAddTime64Ex(p, "ConnectedTime", e->ConnectedTime, i, t->NumLink);
13217 PackAddBoolEx(p, "Connected", e->Connected, i, t->NumLink);
13218 PackAddIntEx(p, "LastError", e->LastError, i, t->NumLink);
13219 PackAddStrEx(p, "TargetHubName", e->HubName, i, t->NumLink);
13220 }
13221 PackSetCurrentJsonGroupName(p, NULL);
13222 }
FreeRpcEnumLink(RPC_ENUM_LINK * t)13223 void FreeRpcEnumLink(RPC_ENUM_LINK *t)
13224 {
13225 // Validate arguments
13226 if (t == NULL)
13227 {
13228 return;
13229 }
13230
13231 Free(t->Links);
13232 }
13233
13234 // RPC_LINK_STATUS
InRpcLinkStatus(RPC_LINK_STATUS * t,PACK * p)13235 void InRpcLinkStatus(RPC_LINK_STATUS *t, PACK *p)
13236 {
13237 // Validate arguments
13238 if (t == NULL || p == NULL)
13239 {
13240 return;
13241 }
13242
13243 Zero(t, sizeof(RPC_LINK_STATUS));
13244 PackGetStr(p, "HubName_Ex", t->HubName, sizeof(t->HubName));
13245 PackGetUniStr(p, "AccountName", t->AccountName, sizeof(t->AccountName));
13246 InRpcClientGetConnectionStatus(&t->Status, p);
13247 }
OutRpcLinkStatus(PACK * p,RPC_LINK_STATUS * t)13248 void OutRpcLinkStatus(PACK *p, RPC_LINK_STATUS *t)
13249 {
13250 // Validate arguments
13251 if (t == NULL || p == NULL)
13252 {
13253 return;
13254 }
13255
13256 PackAddStr(p, "HubName_Ex", t->HubName);
13257 PackAddUniStr(p, "AccountName", t->AccountName);
13258 OutRpcClientGetConnectionStatus(p, &t->Status);
13259 }
FreeRpcLinkStatus(RPC_LINK_STATUS * t)13260 void FreeRpcLinkStatus(RPC_LINK_STATUS *t)
13261 {
13262 // Validate arguments
13263 if (t == NULL)
13264 {
13265 return;
13266 }
13267
13268 CiFreeClientGetConnectionStatus(&t->Status);
13269 }
13270
13271 // RPC_LINK
InRpcLink(RPC_LINK * t,PACK * p)13272 void InRpcLink(RPC_LINK *t, PACK *p)
13273 {
13274 // Validate arguments
13275 if (t == NULL || p == NULL)
13276 {
13277 return;
13278 }
13279
13280 Zero(t, sizeof(RPC_LINK));
13281 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13282 PackGetUniStr(p, "AccountName", t->AccountName, sizeof(t->AccountName));
13283 }
OutRpcLink(PACK * p,RPC_LINK * t)13284 void OutRpcLink(PACK *p, RPC_LINK *t)
13285 {
13286 // Validate arguments
13287 if (t == NULL)
13288 {
13289 return;
13290 }
13291
13292 PackAddStr(p, "HubName", t->HubName);
13293 PackAddUniStr(p, "AccountName", t->AccountName);
13294 }
13295
13296 // RPC_RENAME_LINK
InRpcRenameLink(RPC_RENAME_LINK * t,PACK * p)13297 void InRpcRenameLink(RPC_RENAME_LINK *t, PACK *p)
13298 {
13299 // Validate arguments
13300 if (t == NULL || p == NULL)
13301 {
13302 return;
13303 }
13304
13305 Zero(t, sizeof(RPC_RENAME_LINK));
13306 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13307 PackGetUniStr(p, "OldAccountName", t->OldAccountName, sizeof(t->OldAccountName));
13308 PackGetUniStr(p, "NewAccountName", t->NewAccountName, sizeof(t->NewAccountName));
13309 }
OutRpcRenameLink(PACK * p,RPC_RENAME_LINK * t)13310 void OutRpcRenameLink(PACK *p, RPC_RENAME_LINK *t)
13311 {
13312 // Validate arguments
13313 if (p == NULL || t == NULL)
13314 {
13315 return;
13316 }
13317
13318 PackAddStr(p, "HubName", t->HubName);
13319 PackAddUniStr(p, "OldAccountName", t->OldAccountName);
13320 PackAddUniStr(p, "NewAccountName", t->NewAccountName);
13321 }
13322
13323 // ACCESS
InRpcAccessEx(ACCESS * a,PACK * p,UINT index)13324 void InRpcAccessEx(ACCESS *a, PACK *p, UINT index)
13325 {
13326 // Validate arguments
13327 if (a == NULL || p == NULL)
13328 {
13329 return;
13330 }
13331
13332 Zero(a, sizeof(ACCESS));
13333 a->Id = PackGetIntEx(p, "Id", index);
13334 PackGetUniStrEx(p, "Note", a->Note, sizeof(a->Note), index);
13335 a->Active = PackGetBoolEx(p, "Active", index);
13336 a->Priority = PackGetIntEx(p, "Priority", index);
13337 a->Discard = PackGetBoolEx(p, "Discard", index);
13338 a->SrcIpAddress = PackGetIp32Ex(p, "SrcIpAddress", index);
13339 a->SrcSubnetMask = PackGetIp32Ex(p, "SrcSubnetMask", index);
13340 a->DestIpAddress = PackGetIp32Ex(p, "DestIpAddress", index);
13341 a->DestSubnetMask = PackGetIp32Ex(p, "DestSubnetMask", index);
13342 a->Protocol = PackGetIntEx(p, "Protocol", index);
13343 a->SrcPortStart = PackGetIntEx(p, "SrcPortStart", index);
13344 a->SrcPortEnd = PackGetIntEx(p, "SrcPortEnd", index);
13345 a->DestPortStart = PackGetIntEx(p, "DestPortStart", index);
13346 a->DestPortEnd = PackGetIntEx(p, "DestPortEnd", index);
13347 //a->SrcUsernameHash = PackGetIntEx(p, "SrcUsernameHash", index);
13348 PackGetStrEx(p, "SrcUsername", a->SrcUsername, sizeof(a->SrcUsername), index);
13349 //a->DestUsernameHash = PackGetIntEx(p, "DestUsernameHash", index);
13350 PackGetStrEx(p, "DestUsername", a->DestUsername, sizeof(a->DestUsername), index);
13351 a->CheckSrcMac = PackGetBoolEx(p, "CheckSrcMac", index);
13352 PackGetDataEx2(p, "SrcMacAddress", a->SrcMacAddress, sizeof(a->SrcMacAddress), index);
13353 PackGetDataEx2(p, "SrcMacMask", a->SrcMacMask, sizeof(a->SrcMacMask), index);
13354 a->CheckDstMac = PackGetBoolEx(p, "CheckDstMac", index);
13355 PackGetDataEx2(p, "DstMacAddress", a->DstMacAddress, sizeof(a->DstMacAddress), index);
13356 PackGetDataEx2(p, "DstMacMask", a->DstMacMask, sizeof(a->DstMacMask), index);
13357 a->CheckTcpState = PackGetBoolEx(p, "CheckTcpState", index);
13358 a->Established = PackGetBoolEx(p, "Established", index);
13359 a->Delay = PackGetIntEx(p, "Delay", index);
13360 a->Jitter = PackGetIntEx(p, "Jitter", index);
13361 a->Loss = PackGetIntEx(p, "Loss", index);
13362 a->IsIPv6 = PackGetBoolEx(p, "IsIPv6", index);
13363 a->UniqueId = PackGetIntEx(p, "UniqueId", index);
13364 PackGetStrEx(p, "RedirectUrl", a->RedirectUrl, sizeof(a->RedirectUrl), index);
13365 if (a->IsIPv6)
13366 {
13367 PackGetIp6AddrEx(p, "SrcIpAddress6", &a->SrcIpAddress6, index);
13368 PackGetIp6AddrEx(p, "SrcSubnetMask6", &a->SrcSubnetMask6, index);
13369 PackGetIp6AddrEx(p, "DestIpAddress6", &a->DestIpAddress6, index);
13370 PackGetIp6AddrEx(p, "DestSubnetMask6", &a->DestSubnetMask6, index);
13371 }
13372 }
InRpcAccess(ACCESS * a,PACK * p)13373 void InRpcAccess(ACCESS *a, PACK *p)
13374 {
13375 // Validate arguments
13376 if (a == NULL || p == NULL)
13377 {
13378 return;
13379 }
13380
13381 InRpcAccessEx(a, p, 0);
13382 }
OutRpcAccessEx(PACK * p,ACCESS * a,UINT index,UINT total)13383 void OutRpcAccessEx(PACK *p, ACCESS *a, UINT index, UINT total)
13384 {
13385 // Validate arguments
13386 if (a == NULL || p == NULL)
13387 {
13388 return;
13389 }
13390
13391 PackAddIntEx(p, "Id", a->Id, index, total);
13392 PackAddUniStrEx(p, "Note", a->Note, index, total);
13393 PackAddBoolEx(p, "Active", a->Active, index, total);
13394 PackAddIntEx(p, "Priority", a->Priority, index, total);
13395 PackAddBoolEx(p, "Discard", a->Discard, index, total);
13396 if (a->IsIPv6)
13397 {
13398 PackAddIp32Ex(p, "SrcIpAddress", 0xFDFFFFDF, index, total);
13399 PackAddIp32Ex(p, "SrcSubnetMask", 0xFFFFFFFF, index, total);
13400 PackAddIp32Ex(p, "DestIpAddress", 0xFDFFFFDF, index, total);
13401 PackAddIp32Ex(p, "DestSubnetMask", 0xFFFFFFFF, index, total);
13402 }
13403 else
13404 {
13405 PackAddIp32Ex(p, "SrcIpAddress", a->SrcIpAddress, index, total);
13406 PackAddIp32Ex(p, "SrcSubnetMask", a->SrcSubnetMask, index, total);
13407 PackAddIp32Ex(p, "DestIpAddress", a->DestIpAddress, index, total);
13408 PackAddIp32Ex(p, "DestSubnetMask", a->DestSubnetMask, index, total);
13409 }
13410 PackAddIntEx(p, "Protocol", a->Protocol, index, total);
13411 PackAddIntEx(p, "SrcPortStart", a->SrcPortStart, index, total);
13412 PackAddIntEx(p, "SrcPortEnd", a->SrcPortEnd, index, total);
13413 PackAddIntEx(p, "DestPortStart", a->DestPortStart, index, total);
13414 PackAddIntEx(p, "DestPortEnd", a->DestPortEnd, index, total);
13415 //PackAddIntEx(p, "SrcUsernameHash", a->SrcUsernameHash, index, total);
13416 PackAddStrEx(p, "SrcUsername", a->SrcUsername, index, total);
13417 //PackAddIntEx(p, "DestUsernameHash", a->DestUsernameHash, index, total);
13418 PackAddStrEx(p, "DestUsername", a->DestUsername, index, total);
13419 PackAddBoolEx(p, "CheckSrcMac", a->CheckSrcMac, index, total);
13420 PackAddDataEx(p, "SrcMacAddress", a->SrcMacAddress, sizeof(a->SrcMacAddress), index, total);
13421 PackAddDataEx(p, "SrcMacMask", a->SrcMacMask, sizeof(a->SrcMacMask), index, total);
13422 PackAddBoolEx(p, "CheckDstMac", a->CheckDstMac, index, total);
13423 PackAddDataEx(p, "DstMacAddress", a->DstMacAddress, sizeof(a->DstMacAddress), index, total);
13424 PackAddDataEx(p, "DstMacMask", a->DstMacMask, sizeof(a->DstMacMask), index, total);
13425 PackAddBoolEx(p, "CheckTcpState", a->CheckTcpState, index, total);
13426 PackAddBoolEx(p, "Established", a->Established, index, total);
13427 PackAddIntEx(p, "Delay", a->Delay, index, total);
13428 PackAddIntEx(p, "Jitter", a->Jitter, index, total);
13429 PackAddIntEx(p, "Loss", a->Loss, index, total);
13430 PackAddBoolEx(p, "IsIPv6", a->IsIPv6, index, total);
13431 PackAddIntEx(p, "UniqueId", a->UniqueId, index, total);
13432 PackAddStrEx(p, "RedirectUrl", a->RedirectUrl, index, total);
13433 if (a->IsIPv6)
13434 {
13435 PackAddIp6AddrEx(p, "SrcIpAddress6", &a->SrcIpAddress6, index, total);
13436 PackAddIp6AddrEx(p, "SrcSubnetMask6", &a->SrcSubnetMask6, index, total);
13437 PackAddIp6AddrEx(p, "DestIpAddress6", &a->DestIpAddress6, index, total);
13438 PackAddIp6AddrEx(p, "DestSubnetMask6", &a->DestSubnetMask6, index, total);
13439 }
13440 else
13441 {
13442 IPV6_ADDR zero;
13443
13444 Zero(&zero, sizeof(zero));
13445
13446 PackAddIp6AddrEx(p, "SrcIpAddress6", &zero, index, total);
13447 PackAddIp6AddrEx(p, "SrcSubnetMask6", &zero, index, total);
13448 PackAddIp6AddrEx(p, "DestIpAddress6", &zero, index, total);
13449 PackAddIp6AddrEx(p, "DestSubnetMask6", &zero, index, total);
13450 }
13451 }
OutRpcAccess(PACK * p,ACCESS * a)13452 void OutRpcAccess(PACK *p, ACCESS *a)
13453 {
13454 // Validate arguments
13455 if (a == NULL || p == NULL)
13456 {
13457 return;
13458 }
13459
13460 OutRpcAccessEx(p, a, 0, 1);
13461 }
13462
13463 // RPC_ENUM_ACCESS_LIST
InRpcEnumAccessList(RPC_ENUM_ACCESS_LIST * a,PACK * p)13464 void InRpcEnumAccessList(RPC_ENUM_ACCESS_LIST *a, PACK *p)
13465 {
13466 UINT i;
13467 // Validate arguments
13468 if (a == NULL || p == NULL)
13469 {
13470 return;
13471 }
13472
13473 Zero(a, sizeof(RPC_ENUM_ACCESS_LIST));
13474 PackGetStr(p, "HubName", a->HubName, sizeof(a->HubName));
13475 a->NumAccess = PackGetIndexCount(p, "Protocol");
13476 a->Accesses = ZeroMalloc(sizeof(ACCESS) * a->NumAccess);
13477
13478 for (i = 0;i < a->NumAccess;i++)
13479 {
13480 ACCESS *e = &a->Accesses[i];
13481
13482 InRpcAccessEx(e, p, i);
13483 }
13484 }
OutRpcEnumAccessList(PACK * p,RPC_ENUM_ACCESS_LIST * a)13485 void OutRpcEnumAccessList(PACK *p, RPC_ENUM_ACCESS_LIST *a)
13486 {
13487 UINT i;
13488 // Validate arguments
13489 if (a == NULL || p == NULL)
13490 {
13491 return;
13492 }
13493 PackAddStr(p, "HubName", a->HubName);
13494
13495 PackSetCurrentJsonGroupName(p, "AccessList");
13496 for (i = 0;i < a->NumAccess;i++)
13497 {
13498 ACCESS *e = &a->Accesses[i];
13499
13500 OutRpcAccessEx(p, e, i, a->NumAccess);
13501 }
13502 PackSetCurrentJsonGroupName(p, NULL);
13503 }
FreeRpcEnumAccessList(RPC_ENUM_ACCESS_LIST * a)13504 void FreeRpcEnumAccessList(RPC_ENUM_ACCESS_LIST *a)
13505 {
13506 // Validate arguments
13507 if (a == NULL)
13508 {
13509 return;
13510 }
13511
13512 Free(a->Accesses);
13513 }
13514
13515 // AUTHDATA
InRpcAuthData(PACK * p,UINT * authtype,char * username)13516 void *InRpcAuthData(PACK *p, UINT *authtype, char *username)
13517 {
13518 wchar_t tmp[MAX_SIZE];
13519 AUTHPASSWORD *pw;
13520 AUTHUSERCERT *usercert;
13521 AUTHROOTCERT *rootcert;
13522 AUTHRADIUS *radius;
13523 AUTHNT *nt;
13524 BUF *b;
13525 char plain_pw[MAX_SIZE];
13526 // Validate arguments
13527 if (p == NULL)
13528 {
13529 return NULL;
13530 }
13531 if (authtype == NULL)
13532 {
13533 return NULL;
13534 }
13535
13536 *authtype = PackGetInt(p, "AuthType");
13537
13538 switch (*authtype)
13539 {
13540 case AUTHTYPE_PASSWORD:
13541 pw = ZeroMalloc(sizeof(AUTHPASSWORD));
13542 PackGetData2(p, "HashedKey", pw->HashedKey, sizeof(pw->HashedKey));
13543 PackGetData2(p, "NtLmSecureHash", pw->NtLmSecureHash, sizeof(pw->NtLmSecureHash));
13544
13545 if (PackGetStr(p, "Auth_Password", plain_pw, sizeof(plain_pw)))
13546 {
13547 if (IsZero(pw->HashedKey, sizeof(pw->HashedKey)))
13548 {
13549 HashPassword(pw->HashedKey, username, plain_pw);
13550 GenerateNtPasswordHash(pw->NtLmSecureHash, plain_pw);
13551 }
13552 }
13553
13554 return pw;
13555
13556 case AUTHTYPE_USERCERT:
13557 usercert = ZeroMalloc(sizeof(AUTHUSERCERT));
13558 usercert->UserX = PackGetX(p, "UserX");
13559 return usercert;
13560
13561 case AUTHTYPE_ROOTCERT:
13562 rootcert = ZeroMalloc(sizeof(AUTHROOTCERT));
13563 b = PackGetBuf(p, "Serial");
13564 if (b != NULL)
13565 {
13566 rootcert->Serial = NewXSerial(b->Buf, b->Size);
13567 FreeBuf(b);
13568 }
13569 if (PackGetUniStr(p, "CommonName", tmp, sizeof(tmp)))
13570 {
13571 rootcert->CommonName = CopyUniStr(tmp);
13572 }
13573 return rootcert;
13574
13575 case AUTHTYPE_RADIUS:
13576 radius = ZeroMalloc(sizeof(AUTHRADIUS));
13577 if (PackGetUniStr(p, "RadiusUsername", tmp, sizeof(tmp)))
13578 {
13579 radius->RadiusUsername = CopyUniStr(tmp);
13580 }
13581 else
13582 {
13583 radius->RadiusUsername = CopyUniStr(L"");
13584 }
13585 return radius;
13586
13587 case AUTHTYPE_NT:
13588 nt = ZeroMalloc(sizeof(AUTHNT));
13589 if (PackGetUniStr(p, "NtUsername", tmp, sizeof(tmp)))
13590 {
13591 nt->NtUsername = CopyUniStr(tmp);
13592 }
13593 else
13594 {
13595 nt->NtUsername = CopyUniStr(L"");
13596 }
13597 return nt;
13598 }
13599
13600 return NULL;
13601 }
OutRpcAuthData(PACK * p,void * authdata,UINT authtype)13602 void OutRpcAuthData(PACK *p, void *authdata, UINT authtype)
13603 {
13604 AUTHPASSWORD *pw = authdata;
13605 AUTHUSERCERT *usercert = authdata;
13606 AUTHROOTCERT *rootcert = authdata;
13607 AUTHRADIUS *radius = authdata;
13608 AUTHNT *nt = authdata;
13609 // Validate arguments
13610 if (p == NULL)
13611 {
13612 return;
13613 }
13614
13615 PackAddInt(p, "AuthType", authtype);
13616
13617 switch (authtype)
13618 {
13619 case AUTHTYPE_PASSWORD:
13620 PackAddData(p, "HashedKey", pw->HashedKey, sizeof(pw->HashedKey));
13621 PackAddData(p, "NtLmSecureHash", pw->NtLmSecureHash, sizeof(pw->NtLmSecureHash));
13622 break;
13623
13624 case AUTHTYPE_USERCERT:
13625 PackAddX(p, "UserX", usercert->UserX);
13626 break;
13627
13628 case AUTHTYPE_ROOTCERT:
13629 if (rootcert->Serial != NULL)
13630 {
13631 PackAddData(p, "Serial", rootcert->Serial->data, rootcert->Serial->size);
13632 }
13633 if (rootcert->CommonName != NULL)
13634 {
13635 PackAddUniStr(p, "CommonName", rootcert->CommonName);
13636 }
13637 break;
13638
13639 case AUTHTYPE_RADIUS:
13640 PackAddUniStr(p, "RadiusUsername", radius->RadiusUsername);
13641 break;
13642
13643 case AUTHTYPE_NT:
13644 PackAddUniStr(p, "NtUsername", nt->NtUsername);
13645 break;
13646 }
13647 }
FreeRpcAuthData(void * authdata,UINT authtype)13648 void FreeRpcAuthData(void *authdata, UINT authtype)
13649 {
13650 FreeAuthData(authtype, authdata);
13651 }
13652
13653 // RPC_SET_USER
InRpcSetUser(RPC_SET_USER * t,PACK * p)13654 void InRpcSetUser(RPC_SET_USER *t, PACK *p)
13655 {
13656 // Validate arguments
13657 if (t == NULL || p == NULL)
13658 {
13659 return;
13660 }
13661
13662 Zero(t, sizeof(RPC_SET_USER));
13663 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13664 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
13665 PackGetStr(p, "GroupName", t->GroupName, sizeof(t->GroupName));
13666 PackGetUniStr(p, "Realname", t->Realname, sizeof(t->Realname));
13667 PackGetUniStr(p, "Note", t->Note, sizeof(t->Note));
13668 t->CreatedTime = PackGetInt64(p, "CreatedTime");
13669 t->UpdatedTime = PackGetInt64(p, "UpdatedTime");
13670 t->ExpireTime = PackGetInt64(p, "ExpireTime");
13671 t->AuthData = InRpcAuthData(p, &t->AuthType, t->Name);
13672 t->NumLogin = PackGetInt(p, "NumLogin");
13673 InRpcTraffic(&t->Traffic, p);
13674
13675 if (PackGetBool(p, "UsePolicy"))
13676 {
13677 t->Policy = ZeroMalloc(sizeof(POLICY));
13678 InRpcPolicy(t->Policy, p);
13679 }
13680 }
13681
OutRpcSetUser(PACK * p,RPC_SET_USER * t)13682 void OutRpcSetUser(PACK *p, RPC_SET_USER *t)
13683 {
13684 // Validate arguments
13685 if (t == NULL || p == NULL)
13686 {
13687 return;
13688 }
13689
13690 PackAddStr(p, "HubName", t->HubName);
13691 PackAddStr(p, "Name", t->Name);
13692 PackAddStr(p, "GroupName", t->GroupName);
13693 PackAddUniStr(p, "Realname", t->Realname);
13694 PackAddUniStr(p, "Note", t->Note);
13695 PackAddTime64(p, "CreatedTime", t->CreatedTime);
13696 PackAddTime64(p, "UpdatedTime", t->UpdatedTime);
13697 PackAddTime64(p, "ExpireTime", t->ExpireTime);
13698 OutRpcAuthData(p, t->AuthData, t->AuthType);
13699 PackAddInt(p, "NumLogin", t->NumLogin);
13700 OutRpcTraffic(p, &t->Traffic);
13701
13702 if (t->Policy != NULL)
13703 {
13704 PackAddBool(p, "UsePolicy", true);
13705 OutRpcPolicy(p, t->Policy);
13706 }
13707 }
FreeRpcSetUser(RPC_SET_USER * t)13708 void FreeRpcSetUser(RPC_SET_USER *t)
13709 {
13710 // Validate arguments
13711 if (t == NULL)
13712 {
13713 return;
13714 }
13715
13716 FreeRpcAuthData(t->AuthData, t->AuthType);
13717 if (t->Policy)
13718 {
13719 Free(t->Policy);
13720 }
13721 }
13722
13723 // RPC_ENUM_USER
InRpcEnumUser(RPC_ENUM_USER * t,PACK * p)13724 void InRpcEnumUser(RPC_ENUM_USER *t, PACK *p)
13725 {
13726 UINT i;
13727 // Validate arguments
13728 if (t == NULL || p == NULL)
13729 {
13730 return;
13731 }
13732
13733 Zero(t, sizeof(RPC_ENUM_USER));
13734 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13735 t->NumUser = PackGetIndexCount(p, "Name");
13736 t->Users = ZeroMalloc(sizeof(RPC_ENUM_USER_ITEM) * t->NumUser);
13737
13738 for (i = 0;i < t->NumUser;i++)
13739 {
13740 RPC_ENUM_USER_ITEM *e = &t->Users[i];
13741
13742 PackGetStrEx(p, "Name", e->Name, sizeof(e->Name), i);
13743 PackGetStrEx(p, "GroupName", e->GroupName, sizeof(e->GroupName), i);
13744 PackGetUniStrEx(p, "Realname", e->Realname, sizeof(e->Realname), i);
13745 PackGetUniStrEx(p, "Note", e->Note, sizeof(e->Note), i);
13746 e->AuthType = PackGetIntEx(p, "AuthType", i);
13747 e->LastLoginTime = PackGetInt64Ex(p, "LastLoginTime", i);
13748 e->NumLogin = PackGetIntEx(p, "NumLogin", i);
13749 e->DenyAccess = PackGetBoolEx(p, "DenyAccess", i);
13750
13751 e->IsTrafficFilled = PackGetBoolEx(p, "IsTrafficFilled", i);
13752 InRpcTrafficEx(&e->Traffic, p, i);
13753
13754 e->IsExpiresFilled = PackGetBoolEx(p, "IsExpiresFilled", i);
13755 e->Expires = PackGetInt64Ex(p, "Expires", i);
13756 }
13757 }
OutRpcEnumUser(PACK * p,RPC_ENUM_USER * t)13758 void OutRpcEnumUser(PACK *p, RPC_ENUM_USER *t)
13759 {
13760 UINT i;
13761 // Validate arguments
13762 if (t == NULL || p == NULL)
13763 {
13764 return;
13765 }
13766 PackAddStr(p, "HubName", t->HubName);
13767
13768 PackSetCurrentJsonGroupName(p, "UserList");
13769 for (i = 0;i < t->NumUser;i++)
13770 {
13771 RPC_ENUM_USER_ITEM *e = &t->Users[i];
13772
13773 PackAddStrEx(p, "Name", e->Name, i, t->NumUser);
13774 PackAddStrEx(p, "GroupName", e->GroupName, i, t->NumUser);
13775 PackAddUniStrEx(p, "Realname", e->Realname, i, t->NumUser);
13776 PackAddUniStrEx(p, "Note", e->Note, i, t->NumUser);
13777 PackAddIntEx(p, "AuthType", e->AuthType, i, t->NumUser);
13778 PackAddTime64Ex(p, "LastLoginTime", e->LastLoginTime, i, t->NumUser);
13779 PackAddIntEx(p, "NumLogin", e->NumLogin, i, t->NumUser);
13780 PackAddBoolEx(p, "DenyAccess", e->DenyAccess, i, t->NumUser);
13781
13782 PackAddBoolEx(p, "IsTrafficFilled", e->IsTrafficFilled, i, t->NumUser);
13783 OutRpcTrafficEx(&e->Traffic, p, i, t->NumUser);
13784
13785 PackAddBoolEx(p, "IsExpiresFilled", e->IsExpiresFilled, i, t->NumUser);
13786 PackAddTime64Ex(p, "Expires", e->Expires, i, t->NumUser);
13787 }
13788 PackSetCurrentJsonGroupName(p, NULL);
13789 }
FreeRpcEnumUser(RPC_ENUM_USER * t)13790 void FreeRpcEnumUser(RPC_ENUM_USER *t)
13791 {
13792 // Validate arguments
13793 if (t == NULL)
13794 {
13795 return;
13796 }
13797
13798 Free(t->Users);
13799 }
13800
13801 // RPC_SET_GROUP
InRpcSetGroup(RPC_SET_GROUP * t,PACK * p)13802 void InRpcSetGroup(RPC_SET_GROUP *t, PACK *p)
13803 {
13804 // Validate arguments
13805 if (t == NULL || p == NULL)
13806 {
13807 return;
13808 }
13809
13810 Zero(t, sizeof(RPC_SET_GROUP));
13811 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13812 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
13813 PackGetUniStr(p, "Realname", t->Realname, sizeof(t->Realname));
13814 PackGetUniStr(p, "Note", t->Note, sizeof(t->Note));
13815 InRpcTraffic(&t->Traffic, p);
13816
13817 if (PackGetBool(p, "UsePolicy"))
13818 {
13819 t->Policy = ZeroMalloc(sizeof(POLICY));
13820 InRpcPolicy(t->Policy, p);
13821 }
13822 }
OutRpcSetGroup(PACK * p,RPC_SET_GROUP * t)13823 void OutRpcSetGroup(PACK *p, RPC_SET_GROUP *t)
13824 {
13825 // Validate arguments
13826 if (t == NULL || p == NULL)
13827 {
13828 return;
13829 }
13830
13831 PackAddStr(p, "HubName", t->HubName);
13832 PackAddStr(p, "Name", t->Name);
13833 PackAddUniStr(p, "Realname", t->Realname);
13834 PackAddUniStr(p, "Note", t->Note);
13835 OutRpcTraffic(p, &t->Traffic);
13836
13837 if (t->Policy != NULL)
13838 {
13839 PackAddBool(p, "UsePolicy", true);
13840 OutRpcPolicy(p, t->Policy);
13841 }
13842 }
FreeRpcSetGroup(RPC_SET_GROUP * t)13843 void FreeRpcSetGroup(RPC_SET_GROUP *t)
13844 {
13845 Free(t->Policy);
13846 }
13847
13848 // RPC_ENUM_GROUP
InRpcEnumGroup(RPC_ENUM_GROUP * t,PACK * p)13849 void InRpcEnumGroup(RPC_ENUM_GROUP *t, PACK *p)
13850 {
13851 UINT i;
13852 // Validate arguments
13853 if (t == NULL || p == NULL)
13854 {
13855 return;
13856 }
13857
13858 Zero(t, sizeof(RPC_ENUM_GROUP));
13859 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13860 t->NumGroup = PackGetIndexCount(p, "Name");
13861 t->Groups = ZeroMalloc(sizeof(RPC_ENUM_GROUP_ITEM) * t->NumGroup);
13862
13863 for (i = 0;i < t->NumGroup;i++)
13864 {
13865 RPC_ENUM_GROUP_ITEM *e = &t->Groups[i];
13866
13867 PackGetStrEx(p, "Name", e->Name, sizeof(e->Name), i);
13868 PackGetUniStrEx(p, "Realname", e->Realname, sizeof(e->Realname), i);
13869 PackGetUniStrEx(p, "Note", e->Note, sizeof(e->Note), i);
13870 e->NumUsers = PackGetIntEx(p, "NumUsers", i);
13871 e->DenyAccess = PackGetBoolEx(p, "DenyAccess", i);
13872 }
13873 }
OutRpcEnumGroup(PACK * p,RPC_ENUM_GROUP * t)13874 void OutRpcEnumGroup(PACK *p, RPC_ENUM_GROUP *t)
13875 {
13876 UINT i;
13877 // Validate arguments
13878 if (t == NULL || p == NULL)
13879 {
13880 return;
13881 }
13882
13883 PackAddStr(p, "HubName", t->HubName);
13884
13885 PackSetCurrentJsonGroupName(p, "GroupList");
13886 for (i = 0;i < t->NumGroup;i++)
13887 {
13888 RPC_ENUM_GROUP_ITEM *e = &t->Groups[i];
13889
13890 PackAddStrEx(p, "Name", e->Name, i, t->NumGroup);
13891 PackAddUniStrEx(p, "Realname", e->Realname, i, t->NumGroup);
13892 PackAddUniStrEx(p, "Note", e->Note, i, t->NumGroup);
13893 PackAddIntEx(p, "NumUsers", e->NumUsers, i, t->NumGroup);
13894 PackAddBoolEx(p, "DenyAccess", e->DenyAccess, i, t->NumGroup);
13895 }
13896 PackSetCurrentJsonGroupName(p, NULL);
13897 }
FreeRpcEnumGroup(RPC_ENUM_GROUP * t)13898 void FreeRpcEnumGroup(RPC_ENUM_GROUP *t)
13899 {
13900 // Validate arguments
13901 if (t == NULL)
13902 {
13903 return;
13904 }
13905
13906 Free(t->Groups);
13907 }
13908
13909 // RPC_DELETE_USER
InRpcDeleteUser(RPC_DELETE_USER * t,PACK * p)13910 void InRpcDeleteUser(RPC_DELETE_USER *t, PACK *p)
13911 {
13912 // Validate arguments
13913 if (t == NULL || p == NULL)
13914 {
13915 return;
13916 }
13917
13918 Zero(t, sizeof(RPC_DELETE_USER));
13919 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13920 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
13921 }
OutRpcDeleteUser(PACK * p,RPC_DELETE_USER * t)13922 void OutRpcDeleteUser(PACK *p, RPC_DELETE_USER *t)
13923 {
13924 // Validate arguments
13925 if (t == NULL || p == NULL)
13926 {
13927 return;
13928 }
13929
13930 PackAddStr(p, "HubName", t->HubName);
13931 PackAddStr(p, "Name", t->Name);
13932 }
13933
13934 // RPC_ENUM_SESSION
InRpcEnumSession(RPC_ENUM_SESSION * t,PACK * p)13935 void InRpcEnumSession(RPC_ENUM_SESSION *t, PACK *p)
13936 {
13937 UINT i;
13938 // Validate arguments
13939 if (t == NULL || p == NULL)
13940 {
13941 return;
13942 }
13943
13944 Zero(t, sizeof(RPC_ENUM_SESSION));
13945 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
13946 t->NumSession = PackGetIndexCount(p, "Name");
13947 t->Sessions = ZeroMalloc(sizeof(RPC_ENUM_SESSION_ITEM) * t->NumSession);
13948
13949 for (i = 0;i < t->NumSession;i++)
13950 {
13951 RPC_ENUM_SESSION_ITEM *e = &t->Sessions[i];
13952
13953 PackGetStrEx(p, "Name", e->Name, sizeof(e->Name), i);
13954 PackGetStrEx(p, "Username", e->Username, sizeof(e->Username), i);
13955 e->Ip = PackGetIntEx(p, "Ip", i);
13956 PackGetIpEx(p, "ClientIP", &e->ClientIP, i);
13957 PackGetStrEx(p, "Hostname", e->Hostname, sizeof(e->Hostname), i);
13958 e->MaxNumTcp = PackGetIntEx(p, "MaxNumTcp", i);
13959 e->CurrentNumTcp = PackGetIntEx(p, "CurrentNumTcp", i);
13960 e->PacketSize = PackGetInt64Ex(p, "PacketSize", i);
13961 e->PacketNum = PackGetInt64Ex(p, "PacketNum", i);
13962 e->RemoteSession = PackGetBoolEx(p, "RemoteSession", i);
13963 e->LinkMode = PackGetBoolEx(p, "LinkMode", i);
13964 e->SecureNATMode = PackGetBoolEx(p, "SecureNATMode", i);
13965 e->BridgeMode = PackGetBoolEx(p, "BridgeMode", i);
13966 e->Layer3Mode = PackGetBoolEx(p, "Layer3Mode", i);
13967 e->Client_BridgeMode = PackGetBoolEx(p, "Client_BridgeMode", i);
13968 e->Client_MonitorMode = PackGetBoolEx(p, "Client_MonitorMode", i);
13969 PackGetStrEx(p, "RemoteHostname", e->RemoteHostname, sizeof(e->RemoteHostname), i);
13970 e->VLanId = PackGetIntEx(p, "VLanId", i);
13971 PackGetDataEx2(p, "UniqueId", e->UniqueId, sizeof(e->UniqueId), i);
13972 e->IsDormantEnabled = PackGetBoolEx(p, "IsDormantEnabled", i);
13973 e->IsDormant = PackGetBoolEx(p, "IsDormant", i);
13974 e->LastCommDormant = PackGetInt64Ex(p, "LastCommDormant", i);
13975 e->CreatedTime = PackGetInt64Ex(p, "CreatedTime", i);
13976 e->LastCommTime = PackGetInt64Ex(p, "LastCommTime", i);
13977 }
13978 }
OutRpcEnumSession(PACK * p,RPC_ENUM_SESSION * t)13979 void OutRpcEnumSession(PACK *p, RPC_ENUM_SESSION *t)
13980 {
13981 UINT i;
13982 // Validate arguments
13983 if (t == NULL || p == NULL)
13984 {
13985 return;
13986 }
13987 PackAddStr(p, "HubName", t->HubName);
13988
13989 PackSetCurrentJsonGroupName(p, "SessionList");
13990 for (i = 0;i < t->NumSession;i++)
13991 {
13992 RPC_ENUM_SESSION_ITEM *e = &t->Sessions[i];
13993
13994 PackAddStrEx(p, "Name", e->Name, i, t->NumSession);
13995 PackAddStrEx(p, "Username", e->Username, i, t->NumSession);
13996 PackAddIp32Ex(p, "Ip", e->Ip, i, t->NumSession);
13997 PackAddIpEx(p, "ClientIP", &e->ClientIP, i, t->NumSession);
13998 PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumSession);
13999 PackAddIntEx(p, "MaxNumTcp", e->MaxNumTcp, i, t->NumSession);
14000 PackAddIntEx(p, "CurrentNumTcp", e->CurrentNumTcp, i, t->NumSession);
14001 PackAddInt64Ex(p, "PacketSize", e->PacketSize, i, t->NumSession);
14002 PackAddInt64Ex(p, "PacketNum", e->PacketNum, i, t->NumSession);
14003 PackAddBoolEx(p, "RemoteSession", e->RemoteSession, i, t->NumSession);
14004 PackAddStrEx(p, "RemoteHostname", e->RemoteHostname, i, t->NumSession);
14005 PackAddBoolEx(p, "LinkMode", e->LinkMode, i, t->NumSession);
14006 PackAddBoolEx(p, "SecureNATMode", e->SecureNATMode, i, t->NumSession);
14007 PackAddBoolEx(p, "BridgeMode", e->BridgeMode, i, t->NumSession);
14008 PackAddBoolEx(p, "Layer3Mode", e->Layer3Mode, i, t->NumSession);
14009 PackAddBoolEx(p, "Client_BridgeMode", e->Client_BridgeMode, i, t->NumSession);
14010 PackAddBoolEx(p, "Client_MonitorMode", e->Client_MonitorMode, i, t->NumSession);
14011 PackAddIntEx(p, "VLanId", e->VLanId, i, t->NumSession);
14012 PackAddDataEx(p, "UniqueId", e->UniqueId, sizeof(e->UniqueId), i, t->NumSession);
14013 PackAddBoolEx(p, "IsDormantEnabled", e->IsDormantEnabled, i, t->NumSession);
14014 PackAddBoolEx(p, "IsDormant", e->IsDormant, i, t->NumSession);
14015 PackAddTime64Ex(p, "LastCommDormant", e->LastCommDormant, i, t->NumSession);
14016 PackAddTime64Ex(p, "CreatedTime", e->CreatedTime, i, t->NumSession);
14017 PackAddTime64Ex(p, "LastCommTime", e->LastCommTime, i, t->NumSession);
14018 }
14019 PackSetCurrentJsonGroupName(p, NULL);
14020 }
FreeRpcEnumSession(RPC_ENUM_SESSION * t)14021 void FreeRpcEnumSession(RPC_ENUM_SESSION *t)
14022 {
14023 // Validate arguments
14024 if (t == NULL)
14025 {
14026 return;
14027 }
14028
14029 Free(t->Sessions);
14030 }
14031
14032 // RPC_KEY_PAIR
InRpcKeyPair(RPC_KEY_PAIR * t,PACK * p)14033 void InRpcKeyPair(RPC_KEY_PAIR *t, PACK *p)
14034 {
14035 // Validate arguments
14036 if (t == NULL || p == NULL)
14037 {
14038 return;
14039 }
14040
14041 t->Cert = PackGetX(p, "Cert");
14042 t->Key = PackGetK(p, "Key");
14043 t->Flag1 = PackGetInt(p, "Flag1");
14044 }
OutRpcKeyPair(PACK * p,RPC_KEY_PAIR * t)14045 void OutRpcKeyPair(PACK *p, RPC_KEY_PAIR *t)
14046 {
14047 // Validate arguments
14048 if (p == NULL || t == NULL)
14049 {
14050 return;
14051 }
14052
14053 PackAddX(p, "Cert", t->Cert);
14054 PackAddK(p, "Key", t->Key);
14055 PackAddInt(p, "Flag1", t->Flag1);
14056 }
FreeRpcKeyPair(RPC_KEY_PAIR * t)14057 void FreeRpcKeyPair(RPC_KEY_PAIR *t)
14058 {
14059 FreeX(t->Cert);
14060 FreeK(t->Key);
14061 }
14062
14063 // NODE_INFO
InRpcNodeInfo(NODE_INFO * t,PACK * p)14064 void InRpcNodeInfo(NODE_INFO *t, PACK *p)
14065 {
14066 // Validate arguments
14067 if (t == NULL || p == NULL)
14068 {
14069 return;
14070 }
14071
14072 Zero(t, sizeof(NODE_INFO));
14073 PackGetStr(p, "ClientProductName", t->ClientProductName, sizeof(t->ClientProductName));
14074 PackGetStr(p, "ServerProductName", t->ServerProductName, sizeof(t->ServerProductName));
14075 PackGetStr(p, "ClientOsName", t->ClientOsName, sizeof(t->ClientOsName));
14076 PackGetStr(p, "ClientOsVer", t->ClientOsVer, sizeof(t->ClientOsVer));
14077 PackGetStr(p, "ClientOsProductId", t->ClientOsProductId, sizeof(t->ClientOsProductId));
14078 PackGetStr(p, "ClientHostname", t->ClientHostname, sizeof(t->ClientHostname));
14079 PackGetStr(p, "ServerHostname", t->ServerHostname, sizeof(t->ServerHostname));
14080 PackGetStr(p, "ProxyHostname", t->ProxyHostname, sizeof(t->ProxyHostname));
14081 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
14082 PackGetData2(p, "UniqueId", t->UniqueId, sizeof(t->UniqueId));
14083
14084 t->ClientProductVer = PackGetInt(p, "ClientProductVer");
14085 t->ClientProductBuild = PackGetInt(p, "ClientProductBuild");
14086 t->ServerProductVer = PackGetInt(p, "ServerProductVer");
14087 t->ServerProductBuild = PackGetInt(p, "ServerProductBuild");
14088 t->ClientIpAddress = PackGetIp32(p, "ClientIpAddress");
14089 PackGetData2(p, "ClientIpAddress6", t->ClientIpAddress6, sizeof(t->ClientIpAddress6));
14090 t->ClientPort = PackGetInt(p, "ClientPort");
14091 t->ServerIpAddress = PackGetIp32(p, "ServerIpAddress");
14092 PackGetData2(p, "ServerIpAddress6", t->ServerIpAddress6, sizeof(t->ServerIpAddress6));
14093 t->ServerPort = PackGetInt(p, "ServerPort2");
14094 t->ProxyIpAddress = PackGetIp32(p, "ProxyIpAddress");
14095 PackGetData2(p, "ProxyIpAddress6", t->ProxyIpAddress6, sizeof(t->ProxyIpAddress6));
14096 t->ProxyPort = PackGetInt(p, "ProxyPort");
14097 }
OutRpcNodeInfo(PACK * p,NODE_INFO * t)14098 void OutRpcNodeInfo(PACK *p, NODE_INFO *t)
14099 {
14100 // Validate arguments
14101 if (t == NULL || p == NULL)
14102 {
14103 return;
14104 }
14105
14106 PackAddStr(p, "ClientProductName", t->ClientProductName);
14107 PackAddStr(p, "ServerProductName", t->ServerProductName);
14108 PackAddStr(p, "ClientOsName", t->ClientOsName);
14109 PackAddStr(p, "ClientOsVer", t->ClientOsVer);
14110 PackAddStr(p, "ClientOsProductId", t->ClientOsProductId);
14111 PackAddStr(p, "ClientHostname", t->ClientHostname);
14112 PackAddStr(p, "ServerHostname", t->ServerHostname);
14113 PackAddStr(p, "ProxyHostname", t->ProxyHostname);
14114 PackAddStr(p, "HubName", t->HubName);
14115 PackAddData(p, "UniqueId", t->UniqueId, sizeof(t->UniqueId));
14116
14117 PackAddInt(p, "ClientProductVer", t->ClientProductVer);
14118 PackAddInt(p, "ClientProductBuild", t->ClientProductBuild);
14119 PackAddInt(p, "ServerProductVer", t->ServerProductVer);
14120 PackAddInt(p, "ServerProductBuild", t->ServerProductBuild);
14121 PackAddIp32(p, "ClientIpAddress", t->ClientIpAddress);
14122 PackAddData(p, "ClientIpAddress6", t->ClientIpAddress6, sizeof(t->ClientIpAddress6));
14123 PackAddInt(p, "ClientPort", t->ClientPort);
14124 PackAddIp32(p, "ServerIpAddress", t->ServerIpAddress);
14125 PackAddData(p, "ServerIpAddress6", t->ServerIpAddress6, sizeof(t->ServerIpAddress6));
14126 PackAddInt(p, "ServerPort2", t->ServerPort);
14127 PackAddIp32(p, "ProxyIpAddress", t->ProxyIpAddress);
14128 PackAddData(p, "ProxyIpAddress6", t->ProxyIpAddress6, sizeof(t->ProxyIpAddress6));
14129 PackAddInt(p, "ProxyPort", t->ProxyPort);
14130 }
14131
14132 // RPC_SESSION_STATUS
InRpcSessionStatus(RPC_SESSION_STATUS * t,PACK * p)14133 void InRpcSessionStatus(RPC_SESSION_STATUS *t, PACK *p)
14134 {
14135 // Validate arguments
14136 if (t == NULL || p == NULL)
14137 {
14138 return;
14139 }
14140
14141 Zero(t, sizeof(RPC_SESSION_STATUS));
14142 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
14143 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
14144 PackGetStr(p, "Username", t->Username, sizeof(t->Username));
14145 PackGetStr(p, "GroupName", t->GroupName, sizeof(t->GroupName));
14146 PackGetStr(p, "RealUsername", t->RealUsername, sizeof(t->RealUsername));
14147 t->ClientIp = PackGetIp32(p, "SessionStatus_ClientIp");
14148 PackGetData2(p, "SessionStatus_ClientIp6", t->ClientIp6, sizeof(t->ClientIp6));
14149 PackGetStr(p, "SessionStatus_ClientHostName", t->ClientHostName, sizeof(t->ClientHostName));
14150 PackGetIp(p, "Client_Ip_Address", &t->ClientIpAddress);
14151
14152 InRpcClientGetConnectionStatus(&t->Status, p);
14153 InRpcNodeInfo(&t->NodeInfo, p);
14154 }
OutRpcSessionStatus(PACK * p,RPC_SESSION_STATUS * t)14155 void OutRpcSessionStatus(PACK *p, RPC_SESSION_STATUS *t)
14156 {
14157 // Validate arguments
14158 if (t == NULL || p == NULL)
14159 {
14160 return;
14161 }
14162
14163 PackAddStr(p, "HubName", t->HubName);
14164 PackAddStr(p, "Name", t->Name);
14165 PackAddStr(p, "Username", t->Username);
14166 PackAddStr(p, "GroupName", t->GroupName);
14167 PackAddStr(p, "RealUsername", t->RealUsername);
14168 PackAddIp32(p, "SessionStatus_ClientIp", t->ClientIp);
14169 PackAddData(p, "SessionStatus_ClientIp6", t->ClientIp6, sizeof(t->ClientIp6));
14170 PackAddStr(p, "SessionStatus_ClientHostName", t->ClientHostName);
14171 PackAddIp(p, "Client_Ip_Address", &t->ClientIpAddress);
14172
14173 OutRpcClientGetConnectionStatus(p, &t->Status);
14174 OutRpcNodeInfo(p, &t->NodeInfo);
14175 }
FreeRpcSessionStatus(RPC_SESSION_STATUS * t)14176 void FreeRpcSessionStatus(RPC_SESSION_STATUS *t)
14177 {
14178 // Validate arguments
14179 if (t == NULL)
14180 {
14181 return;
14182 }
14183
14184 CiFreeClientGetConnectionStatus(&t->Status);
14185 }
14186
14187 // RPC_DELETE_SESSION
InRpcDeleteSession(RPC_DELETE_SESSION * t,PACK * p)14188 void InRpcDeleteSession(RPC_DELETE_SESSION *t, PACK *p)
14189 {
14190 // Validate arguments
14191 if (t == NULL || p == NULL)
14192 {
14193 return;
14194 }
14195
14196 Zero(t, sizeof(RPC_DELETE_SESSION));
14197 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
14198 PackGetStr(p, "Name", t->Name, sizeof(t->Name));
14199 }
OutRpcDeleteSession(PACK * p,RPC_DELETE_SESSION * t)14200 void OutRpcDeleteSession(PACK *p, RPC_DELETE_SESSION *t)
14201 {
14202 // Validate arguments
14203 if (t == NULL || p == NULL)
14204 {
14205 return;
14206 }
14207
14208 PackAddStr(p, "HubName", t->HubName);
14209 PackAddStr(p, "Name", t->Name);
14210 }
14211
14212 // RPC_ENUM_MAC_TABLE
InRpcEnumMacTable(RPC_ENUM_MAC_TABLE * t,PACK * p)14213 void InRpcEnumMacTable(RPC_ENUM_MAC_TABLE *t, PACK *p)
14214 {
14215 UINT i;
14216 // Validate arguments
14217 if (t == NULL || p == NULL)
14218 {
14219 return;
14220 }
14221
14222 Zero(t, sizeof(RPC_ENUM_MAC_TABLE));
14223 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
14224 t->NumMacTable = PackGetIndexCount(p, "SessionName");
14225 t->MacTables = ZeroMalloc(sizeof(RPC_ENUM_MAC_TABLE_ITEM) * t->NumMacTable);
14226
14227 for (i = 0;i < t->NumMacTable;i++)
14228 {
14229 RPC_ENUM_MAC_TABLE_ITEM *e = &t->MacTables[i];
14230
14231 e->Key = PackGetIntEx(p, "Key", i);
14232 PackGetStrEx(p, "SessionName", e->SessionName, sizeof(e->SessionName), i);
14233 PackGetDataEx2(p, "MacAddress", e->MacAddress, sizeof(e->MacAddress), i);
14234 e->VlanId = PackGetIntEx(p, "VlanId", i);
14235 e->CreatedTime = PackGetInt64Ex(p, "CreatedTime", i);
14236 e->UpdatedTime = PackGetInt64Ex(p, "UpdatedTime", i);
14237 e->RemoteItem = PackGetBoolEx(p, "RemoteItem", i);
14238 PackGetStrEx(p, "RemoteHostname", e->RemoteHostname, sizeof(e->RemoteHostname), i);
14239 }
14240 }
OutRpcEnumMacTable(PACK * p,RPC_ENUM_MAC_TABLE * t)14241 void OutRpcEnumMacTable(PACK *p, RPC_ENUM_MAC_TABLE *t)
14242 {
14243 UINT i;
14244 // Validate arguments
14245 if (t == NULL || p == NULL)
14246 {
14247 return;
14248 }
14249
14250 PackAddStr(p, "HubName", t->HubName);
14251
14252 PackSetCurrentJsonGroupName(p, "MacTable");
14253 for (i = 0;i < t->NumMacTable;i++)
14254 {
14255 RPC_ENUM_MAC_TABLE_ITEM *e = &t->MacTables[i];
14256
14257 PackAddIntEx(p, "Key", e->Key, i, t->NumMacTable);
14258 PackAddStrEx(p, "SessionName", e->SessionName, i, t->NumMacTable);
14259 PackAddDataEx(p, "MacAddress", e->MacAddress, sizeof(e->MacAddress), i, t->NumMacTable);
14260 PackAddIntEx(p, "VlanId", e->VlanId, i, t->NumMacTable);
14261 PackAddTime64Ex(p, "CreatedTime", e->CreatedTime, i, t->NumMacTable);
14262 PackAddTime64Ex(p, "UpdatedTime", e->UpdatedTime, i, t->NumMacTable);
14263 PackAddBoolEx(p, "RemoteItem", e->RemoteItem, i, t->NumMacTable);
14264 PackAddStrEx(p, "RemoteHostname", e->RemoteHostname, i, t->NumMacTable);
14265 }
14266 PackSetCurrentJsonGroupName(p, NULL);
14267 }
FreeRpcEnumMacTable(RPC_ENUM_MAC_TABLE * t)14268 void FreeRpcEnumMacTable(RPC_ENUM_MAC_TABLE *t)
14269 {
14270 // Validate arguments
14271 if (t == NULL)
14272 {
14273 return;
14274 }
14275
14276 Free(t->MacTables);
14277 }
14278
14279 // RPC_ENUM_IP_TABLE
InRpcEnumIpTable(RPC_ENUM_IP_TABLE * t,PACK * p)14280 void InRpcEnumIpTable(RPC_ENUM_IP_TABLE *t, PACK *p)
14281 {
14282 UINT i;
14283 // Validate arguments
14284 if (t == NULL || p == NULL)
14285 {
14286 return;
14287 }
14288
14289 Zero(t, sizeof(RPC_ENUM_IP_TABLE));
14290 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
14291 t->NumIpTable = PackGetIndexCount(p, "SessionName");
14292 t->IpTables = ZeroMalloc(sizeof(RPC_ENUM_IP_TABLE_ITEM) * t->NumIpTable);
14293
14294 for (i = 0;i < t->NumIpTable;i++)
14295 {
14296 RPC_ENUM_IP_TABLE_ITEM *e = &t->IpTables[i];
14297
14298 e->Key = PackGetIntEx(p, "Key", i);
14299 PackGetStrEx(p, "SessionName", e->SessionName, sizeof(e->SessionName), i);
14300 e->Ip = PackGetIp32Ex(p, "Ip", i);
14301 if (PackGetIpEx(p, "IpV6", &e->IpV6, i) == false)
14302 {
14303 UINTToIP(&e->IpV6, e->Ip);
14304 }
14305 PackGetIp(p, "IpAddress", &e->IpAddress);
14306 e->DhcpAllocated = PackGetBoolEx(p, "DhcpAllocated", i);
14307 e->CreatedTime = PackGetInt64Ex(p, "CreatedTime", i);
14308 e->UpdatedTime = PackGetInt64Ex(p, "UpdatedTime", i);
14309 e->RemoteItem = PackGetBoolEx(p, "RemoteItem", i);
14310 PackGetStrEx(p, "RemoteHostname", e->RemoteHostname, sizeof(e->RemoteHostname), i);
14311 }
14312 }
OutRpcEnumIpTable(PACK * p,RPC_ENUM_IP_TABLE * t)14313 void OutRpcEnumIpTable(PACK *p, RPC_ENUM_IP_TABLE *t)
14314 {
14315 UINT i;
14316 // Validate arguments
14317 if (t == NULL || p == NULL)
14318 {
14319 return;
14320 }
14321
14322 PackAddStr(p, "HubName", t->HubName);
14323
14324 PackSetCurrentJsonGroupName(p, "IpTable");
14325 for (i = 0;i < t->NumIpTable;i++)
14326 {
14327 RPC_ENUM_IP_TABLE_ITEM *e = &t->IpTables[i];
14328
14329 PackAddIntEx(p, "Key", e->Key, i, t->NumIpTable);
14330 PackAddStrEx(p, "SessionName", e->SessionName, i, t->NumIpTable);
14331 PackAddIp32Ex(p, "Ip", e->Ip, i, t->NumIpTable);
14332 PackAddIpEx(p, "IpV6", &e->IpV6, i, t->NumIpTable);
14333 PackAddIpEx(p, "IpAddress", &e->IpAddress, i, t->NumIpTable);
14334 PackAddBoolEx(p, "DhcpAllocated", e->DhcpAllocated, i, t->NumIpTable);
14335 PackAddTime64Ex(p, "CreatedTime", e->CreatedTime, i, t->NumIpTable);
14336 PackAddTime64Ex(p, "UpdatedTime", e->UpdatedTime, i, t->NumIpTable);
14337 PackAddBoolEx(p, "RemoteItem", e->RemoteItem, i, t->NumIpTable);
14338 PackAddStrEx(p, "RemoteHostname", e->RemoteHostname, i, t->NumIpTable);
14339 }
14340 PackSetCurrentJsonGroupName(p, NULL);
14341 }
FreeRpcEnumIpTable(RPC_ENUM_IP_TABLE * t)14342 void FreeRpcEnumIpTable(RPC_ENUM_IP_TABLE *t)
14343 {
14344 // Validate arguments
14345 if (t == NULL)
14346 {
14347 return;
14348 }
14349
14350 Free(t->IpTables);
14351 }
14352
14353 // RPC_DELETE_TABLE
InRpcDeleteTable(RPC_DELETE_TABLE * t,PACK * p)14354 void InRpcDeleteTable(RPC_DELETE_TABLE *t, PACK *p)
14355 {
14356 // Validate arguments
14357 if (t == NULL || p == NULL)
14358 {
14359 return;
14360 }
14361
14362 Zero(t, sizeof(RPC_DELETE_TABLE));
14363 PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));
14364 t->Key = PackGetInt(p, "Key");
14365 }
OutRpcDeleteTable(PACK * p,RPC_DELETE_TABLE * t)14366 void OutRpcDeleteTable(PACK *p, RPC_DELETE_TABLE *t)
14367 {
14368 // Validate arguments
14369 if (t == NULL || p == NULL)
14370 {
14371 return;
14372 }
14373
14374 PackAddStr(p, "HubName", t->HubName);
14375 PackAddInt(p, "Key", t->Key);
14376 }
14377
14378 // Adjoin RPC_ENUM_IP_TABLE
AdjoinRpcEnumIpTable(RPC_ENUM_IP_TABLE * dest,RPC_ENUM_IP_TABLE * src)14379 void AdjoinRpcEnumIpTable(RPC_ENUM_IP_TABLE *dest, RPC_ENUM_IP_TABLE *src)
14380 {
14381 UINT old_num;
14382 UINT i, n;
14383 if (dest == NULL || src == NULL)
14384 {
14385 return;
14386 }
14387
14388 if (src->NumIpTable == 0)
14389 {
14390 return;
14391 }
14392
14393 old_num = dest->NumIpTable;
14394 dest->NumIpTable += src->NumIpTable;
14395 dest->IpTables = ReAlloc(dest->IpTables, sizeof(RPC_ENUM_IP_TABLE_ITEM) * dest->NumIpTable);
14396
14397 n = 0;
14398 for (i = old_num;i < dest->NumIpTable;i++)
14399 {
14400 Copy(&dest->IpTables[i], &src->IpTables[n++], sizeof(RPC_ENUM_IP_TABLE_ITEM));
14401 }
14402 }
14403
14404 // Adjoin RPC_ENUM_MAC_TABLE
AdjoinRpcEnumMacTable(RPC_ENUM_MAC_TABLE * dest,RPC_ENUM_MAC_TABLE * src)14405 void AdjoinRpcEnumMacTable(RPC_ENUM_MAC_TABLE *dest, RPC_ENUM_MAC_TABLE *src)
14406 {
14407 UINT old_num;
14408 UINT i, n;
14409 if (dest == NULL || src == NULL)
14410 {
14411 return;
14412 }
14413
14414 if (src->NumMacTable == 0)
14415 {
14416 return;
14417 }
14418
14419 old_num = dest->NumMacTable;
14420 dest->NumMacTable += src->NumMacTable;
14421 dest->MacTables = ReAlloc(dest->MacTables, sizeof(RPC_ENUM_MAC_TABLE_ITEM) * dest->NumMacTable);
14422
14423 n = 0;
14424 for (i = old_num;i < dest->NumMacTable;i++)
14425 {
14426 Copy(&dest->MacTables[i], &src->MacTables[n++], sizeof(RPC_ENUM_MAC_TABLE_ITEM));
14427 }
14428 }
14429
14430 // Adjoin RPC_ENUM_SESSION
AdjoinRpcEnumSession(RPC_ENUM_SESSION * dest,RPC_ENUM_SESSION * src)14431 void AdjoinRpcEnumSession(RPC_ENUM_SESSION *dest, RPC_ENUM_SESSION *src)
14432 {
14433 UINT old_num;
14434 UINT i, n;
14435 if (dest == NULL || src == NULL)
14436 {
14437 return;
14438 }
14439
14440 if (src->NumSession == 0)
14441 {
14442 return;
14443 }
14444
14445 old_num = dest->NumSession;
14446 dest->NumSession += src->NumSession;
14447 dest->Sessions = ReAlloc(dest->Sessions, sizeof(RPC_ENUM_SESSION_ITEM) * dest->NumSession);
14448
14449 n = 0;
14450 for (i = old_num;i < dest->NumSession;i++)
14451 {
14452 Copy(&dest->Sessions[i], &src->Sessions[n++], sizeof(RPC_ENUM_SESSION_ITEM));
14453 }
14454 }
14455
14456 // RPC_KEEP
InRpcKeep(RPC_KEEP * t,PACK * p)14457 void InRpcKeep(RPC_KEEP *t, PACK *p)
14458 {
14459 // Validate arguments
14460 if (t == NULL || p == NULL)
14461 {
14462 return;
14463 }
14464
14465 Zero(t, sizeof(RPC_KEEP));
14466 t->UseKeepConnect = PackGetBool(p, "UseKeepConnect");
14467 PackGetStr(p, "KeepConnectHost", t->KeepConnectHost, sizeof(t->KeepConnectHost));
14468 t->KeepConnectPort = PackGetInt(p, "KeepConnectPort");
14469 t->KeepConnectProtocol = PackGetInt(p, "KeepConnectProtocol");
14470 t->KeepConnectInterval = PackGetInt(p, "KeepConnectInterval");
14471 }
OutRpcKeep(PACK * p,RPC_KEEP * t)14472 void OutRpcKeep(PACK *p, RPC_KEEP *t)
14473 {
14474 // Validate arguments
14475 if (t == NULL || p == NULL)
14476 {
14477 return;
14478 }
14479
14480 PackAddBool(p, "UseKeepConnect", t->UseKeepConnect);
14481 PackAddStr(p, "KeepConnectHost", t->KeepConnectHost);
14482 PackAddInt(p, "KeepConnectPort", t->KeepConnectPort);
14483 PackAddInt(p, "KeepConnectProtocol", t->KeepConnectProtocol);
14484 PackAddInt(p, "KeepConnectInterval", t->KeepConnectInterval);
14485 }
14486
14487 // test RPC function
StTest(ADMIN * a,RPC_TEST * t)14488 UINT StTest(ADMIN *a, RPC_TEST *t)
14489 {
14490 Format(t->StrValue, sizeof(t->StrValue), "%u", t->IntValue);
14491
14492 return ERR_NO_ERROR;
14493 }
14494
14495 // RPC_TEST
InRpcTest(RPC_TEST * t,PACK * p)14496 void InRpcTest(RPC_TEST *t, PACK *p)
14497 {
14498 Zero(t, sizeof(RPC_TEST));
14499 t->IntValue = PackGetInt(p, "IntValue");
14500 t->Int64Value = PackGetInt64(p, "Int64Value");
14501 PackGetStr(p, "StrValue", t->StrValue, sizeof(t->StrValue));
14502 PackGetUniStr(p, "UniStrValue", t->UniStrValue, sizeof(t->UniStrValue));
14503 }
OutRpcTest(PACK * p,RPC_TEST * t)14504 void OutRpcTest(PACK *p, RPC_TEST *t)
14505 {
14506 PackAddInt(p, "IntValue", t->IntValue);
14507 PackAddInt64(p, "Int64Value", t->Int64Value);
14508 PackAddStr(p, "StrValue", t->StrValue);
14509 PackAddUniStr(p, "UniStrValue", t->UniStrValue);
14510 }
FreeRpcTest(RPC_TEST * t)14511 void FreeRpcTest(RPC_TEST *t)
14512 {
14513 }
14514
14515 // Admin RPC call
AdminCall(RPC * rpc,char * function_name,PACK * p)14516 PACK *AdminCall(RPC *rpc, char *function_name, PACK *p)
14517 {
14518 // Validate arguments
14519 if (rpc == NULL || function_name == NULL)
14520 {
14521 return NULL;
14522 }
14523 if (p == NULL)
14524 {
14525 p = NewPack();
14526 }
14527
14528 // Debug("Admin RPC Call: %s\n", function_name);
14529
14530 return RpcCall(rpc, function_name, p);
14531 }
14532
14533 // Check whether the source IP address is permitted to admin connection
CheckAdminSourceAddress(SOCK * sock,char * hubname)14534 bool CheckAdminSourceAddress(SOCK *sock, char *hubname)
14535 {
14536 BUF *b;
14537 char *s;
14538 bool ok = false;
14539 // Validate arguments
14540 if (sock == NULL)
14541 {
14542 return false;
14543 }
14544
14545 b = ReadDump(ADMINIP_TXT);
14546 if (b == NULL)
14547 {
14548 return true;
14549 }
14550
14551 while (true)
14552 {
14553 UINT i;
14554 TOKEN_LIST *t;
14555 IP ip;
14556 IP mask;
14557 IP ip1;
14558 IP ip2;
14559 s = CfgReadNextLine(b);
14560
14561 if (s == NULL)
14562 {
14563 break;
14564 }
14565
14566 Trim(s);
14567
14568 i = SearchStrEx(s, "//", 0, false);
14569 if (i != INFINITE)
14570 {
14571 s[i] = 0;
14572 }
14573
14574 i = SearchStrEx(s, "#", 0, false);
14575 if (i != INFINITE)
14576 {
14577 s[i] = 0;
14578 }
14579
14580 Trim(s);
14581
14582 t = ParseToken(s, " \t");
14583 if (t != NULL)
14584 {
14585 if (t->NumTokens >= 1)
14586 {
14587 if (t->NumTokens == 1 || StrCmpi(hubname, t->Token[1]) == 0)
14588 {
14589 if (ParseIpAndMask46(t->Token[0], &ip, &mask))
14590 {
14591 if (IsIP4(&sock->RemoteIP) && IsIP4(&ip))
14592 {
14593 IPAnd4(&ip1, &sock->RemoteIP, &mask);
14594 IPAnd4(&ip2, &ip, &mask);
14595
14596 if (CmpIpAddr(&ip1, &ip2) == 0)
14597 {
14598 ok = true;
14599 }
14600 }
14601 else if (IsIP6(&sock->RemoteIP) && IsIP6(&ip))
14602 {
14603 IPAnd6(&ip1, &sock->RemoteIP, &mask);
14604 IPAnd6(&ip2, &ip, &mask);
14605
14606 if (CmpIpAddr(&ip1, &ip2) == 0)
14607 {
14608 ok = true;
14609 }
14610 }
14611 }
14612 else if (StrToIP(&ip, t->Token[0]))
14613 {
14614 if (CmpIpAddr(&sock->RemoteIP, &ip) == 0)
14615 {
14616 ok = true;
14617 }
14618 }
14619
14620 if (StrCmpi(t->Token[0], "*") == 0)
14621 {
14622 ok = true;
14623 }
14624 }
14625 }
14626
14627 FreeToken(t);
14628 }
14629
14630 Free(s);
14631 }
14632
14633 FreeBuf(b);
14634
14635 return ok;
14636 }
14637
14638 // Accept admin connection
AdminAccept(CONNECTION * c,PACK * p)14639 UINT AdminAccept(CONNECTION *c, PACK *p)
14640 {
14641 ADMIN *a;
14642 UCHAR secure_password[SHA1_SIZE];
14643 UCHAR null_password[SHA1_SIZE];
14644 UCHAR secure_null_password[SHA1_SIZE];
14645 char hubname[MAX_HUBNAME_LEN + 1];
14646 CEDAR *cedar;
14647 SOCK *sock;
14648 RPC *rpc;
14649 UINT err;
14650 SERVER *server = NULL;
14651 RPC_WINVER ver;
14652 bool accept_empty_password;
14653 bool is_empty_password = false;
14654 // Validate arguments
14655 if (c == NULL || p == NULL)
14656 {
14657 return ERR_INTERNAL_ERROR;
14658 }
14659
14660 cedar = c->Cedar;
14661 sock = c->FirstSock;
14662
14663 if (cedar != NULL)
14664 {
14665 server = cedar->Server;
14666 }
14667
14668 accept_empty_password = PackGetBool(p, "accept_empty_password");
14669
14670 // Get client OS version
14671 InRpcWinVer(&ver, p);
14672
14673 // Get hub name
14674 if (PackGetStr(p, "hubname", hubname, sizeof(hubname)) == false)
14675 {
14676 // without hub name
14677 StrCpy(hubname, sizeof(hubname), "");
14678 }
14679
14680 // Cehck source IP address
14681 if (CheckAdminSourceAddress(sock, hubname) == false)
14682 {
14683 SLog(c->Cedar, "LA_IP_DENIED", c->Name);
14684 return ERR_IP_ADDRESS_DENIED;
14685 }
14686
14687 // Get password information
14688 if (PackGetDataSize(p, "secure_password") != SHA1_SIZE)
14689 {
14690 // Malformed information
14691 return ERR_PROTOCOL_ERROR;
14692 }
14693 PackGetData(p, "secure_password", secure_password);
14694
14695 if (StrLen(hubname) == 0)
14696 {
14697 // Server admin mode
14698 SLog(c->Cedar, "LA_CONNECTED_1", c->Name);
14699 }
14700 else
14701 {
14702 // Hub admin mode
14703 if (cedar->Server != NULL && cedar->Server->ServerType == SERVER_TYPE_FARM_MEMBER)
14704 {
14705 // Connection with hub admin mode to cluster member is not permitted
14706 return ERR_NOT_ENOUGH_RIGHT;
14707 }
14708 SLog(c->Cedar, "LA_CONNECTED_2", c->Name, hubname);
14709 }
14710
14711 // Check password
14712 err = AdminCheckPassword(cedar, c->Random, secure_password,
14713 StrLen(hubname) != 0 ? hubname : NULL, accept_empty_password, &is_empty_password);
14714
14715 if (err != ERR_NO_ERROR)
14716 {
14717 // Error occured
14718 SLog(c->Cedar, "LA_ERROR", c->Name, GetUniErrorStr(err), err);
14719 return err;
14720 }
14721
14722 SLog(c->Cedar, "LA_OK", c->Name);
14723
14724 HashAdminPassword(null_password, "");
14725 SecurePassword(secure_null_password, null_password, c->Random);
14726
14727 if (Cmp(secure_null_password, secure_password, SHA1_SIZE) == 0)
14728 {
14729 if (sock->RemoteIP.addr[0] != 127)
14730 {
14731 // The client tried to use blank password for hub admin mode from remote
14732 if (StrLen(hubname) != 0)
14733 {
14734 return ERR_NULL_PASSWORD_LOCAL_ONLY;
14735 }
14736 }
14737 }
14738
14739
14740 // Reply success result
14741 p = NewPack();
14742 if (accept_empty_password && is_empty_password)
14743 {
14744 PackAddBool(p, "empty_password", true);
14745 }
14746 HttpServerSend(sock, p);
14747 FreePack(p);
14748
14749 // Construct ADMIN object
14750 a = ZeroMalloc(sizeof(ADMIN));
14751 a->ServerAdmin = ((StrLen(hubname) == 0) ? true : false);
14752 a->HubName = (StrLen(hubname) != 0 ? hubname : NULL);
14753 a->Server = c->Cedar->Server;
14754 a->ClientBuild = c->ClientBuild;
14755
14756 Copy(&a->ClientWinVer, &ver, sizeof(RPC_WINVER));
14757
14758 // Timeout setting
14759 SetTimeout(sock, INFINITE);
14760
14761 // RPC Server
14762 rpc = StartRpcServer(sock, AdminDispatch, a);
14763
14764 a->Rpc = rpc;
14765
14766 SLog(c->Cedar, "LA_RPC_START", c->Name, rpc->Name);
14767
14768 RpcServer(rpc);
14769 RpcFree(rpc);
14770
14771 if (a->LogFileList != NULL)
14772 {
14773 // Free cached log file list, if it exists
14774 FreeEnumLogFile(a->LogFileList);
14775 }
14776
14777 // Free ADMIN object
14778 Free(a);
14779
14780 return ERR_NO_ERROR;
14781 }
14782
14783 // Check for admin password
AdminCheckPassword(CEDAR * c,void * random,void * secure_password,char * hubname,bool accept_empty_password,bool * is_password_empty)14784 UINT AdminCheckPassword(CEDAR *c, void *random, void *secure_password, char *hubname,
14785 bool accept_empty_password, bool *is_password_empty)
14786 {
14787 UCHAR check[SHA1_SIZE];
14788 bool b_dummy;
14789 // Validate arguments
14790 if (c == NULL || random == NULL || secure_password == NULL)
14791 {
14792 return ERR_INTERNAL_ERROR;
14793 }
14794 if (is_password_empty == NULL)
14795 {
14796 is_password_empty = &b_dummy;
14797 }
14798
14799 *is_password_empty = false;
14800
14801 if (hubname == NULL || StrLen(hubname) == 0)
14802 {
14803 // Server admin mode
14804 Lock(c->lock);
14805 {
14806 if (accept_empty_password && SiIsEmptyPassword(c->Server->HashedPassword))
14807 {
14808 // blank password
14809 *is_password_empty = true;
14810 }
14811
14812 SecurePassword(check, c->Server->HashedPassword, random);
14813 }
14814 Unlock(c->lock);
14815
14816 if (Cmp(check, secure_password, SHA1_SIZE) != 0)
14817 {
14818 // Password incorrect
14819 return ERR_ACCESS_DENIED;
14820 }
14821 }
14822 else
14823 {
14824 HUB *h;
14825
14826 #if 0
14827 if (c->Server->ServerType == SERVER_TYPE_FARM_MEMBER)
14828 {
14829 // In cluster member mode, hub admin mode is disabled
14830 return ERR_FARM_MEMBER_HUB_ADMIN;
14831 }
14832 #endif
14833
14834 // Hub admin mode
14835 LockHubList(c);
14836 {
14837 h = GetHub(c, hubname);
14838 }
14839 UnlockHubList(c);
14840
14841 if (h == NULL)
14842 {
14843 // Specified hub is not found
14844 return ERR_HUB_NOT_FOUND;
14845 }
14846
14847 Lock(h->lock);
14848 {
14849 if (accept_empty_password && SiIsEmptyPassword(h->HashedPassword))
14850 {
14851 // User specified blank password
14852 *is_password_empty = true;
14853 }
14854
14855 SecurePassword(check, h->HashedPassword, random);
14856 }
14857 Unlock(h->lock);
14858
14859 ReleaseHub(h);
14860
14861 if (Cmp(check, secure_password, SHA1_SIZE) != 0)
14862 {
14863 // Incorrect password
14864 return ERR_ACCESS_DENIED;
14865 }
14866 }
14867
14868 return ERR_NO_ERROR;
14869 }
14870
14871 // Hash admin password
HashAdminPassword(void * hash,char * password)14872 void HashAdminPassword(void *hash, char *password)
14873 {
14874 // Validate arguments
14875 if (hash == NULL || password == NULL)
14876 {
14877 return;
14878 }
14879
14880 Hash(hash, password, StrLen(password), true);
14881 }
14882
14883 // Disconnect admin connection
AdminDisconnect(RPC * rpc)14884 void AdminDisconnect(RPC *rpc)
14885 {
14886 SESSION *s;
14887 SOCK *sock;
14888 // Validate arguments
14889 if (rpc == NULL)
14890 {
14891 return;
14892 }
14893
14894 s = (SESSION *)rpc->Param;
14895 sock = rpc->Sock;
14896
14897 EndRpc(rpc);
14898
14899 Disconnect(sock);
14900 ReleaseSession(s);
14901 }
14902
14903 // Admin connection main routine
AdminConnectMain(CEDAR * cedar,CLIENT_OPTION * o,char * hubname,void * hashed_password,UINT * err,char * client_name,void * hWnd,bool * empty_password)14904 SESSION *AdminConnectMain(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name, void *hWnd, bool *empty_password)
14905 {
14906 UCHAR secure_password[SHA1_SIZE];
14907 SESSION *s;
14908 SOCK *sock;
14909 PACK *p;
14910 RPC_WINVER ver;
14911 // connect
14912 s = NewRpcSessionEx2(cedar, o, err, client_name, hWnd);
14913 if (s == NULL)
14914 {
14915 return NULL;
14916 }
14917
14918 // Get socket
14919 sock = s->Connection->FirstSock;
14920
14921 // Generate connect method
14922 p = NewPack();
14923
14924 PackAddClientVersion(p, s->Connection);
14925
14926 PackAddStr(p, "method", "admin");
14927 PackAddBool(p, "accept_empty_password", true);
14928
14929 // Windows version on client
14930 GetWinVer(&ver);
14931 OutRpcWinVer(p, &ver);
14932
14933 // Secure Password
14934 SecurePassword(secure_password, hashed_password, s->Connection->Random);
14935
14936 PackAddData(p, "secure_password", secure_password, sizeof(secure_password));
14937
14938 // HUB name
14939 if (hubname != NULL)
14940 {
14941 PackAddStr(p, "hubname", hubname);
14942 }
14943
14944 if (HttpClientSend(sock, p) == false)
14945 {
14946 // disconnect
14947 FreePack(p);
14948 ReleaseSession(s);
14949 *err = ERR_DISCONNECTED;
14950 return NULL;
14951 }
14952
14953 FreePack(p);
14954
14955 p = HttpClientRecv(sock);
14956 if (p == NULL)
14957 {
14958 // disconnect
14959 ReleaseSession(s);
14960 *err = ERR_DISCONNECTED;
14961 return NULL;
14962 }
14963
14964 if (GetErrorFromPack(p) != 0)
14965 {
14966 // error
14967 ReleaseSession(s);
14968 *err = GetErrorFromPack(p);
14969 FreePack(p);
14970 return NULL;
14971 }
14972
14973 if (empty_password != NULL)
14974 {
14975 *empty_password = PackGetBool(p, "empty_password");
14976 }
14977
14978 FreePack(p);
14979
14980 return s;
14981 }
14982
14983 // Admin connection
AdminConnect(CEDAR * cedar,CLIENT_OPTION * o,char * hubname,void * hashed_password,UINT * err)14984 RPC *AdminConnect(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err)
14985 {
14986 return AdminConnectEx(cedar, o, hubname, hashed_password, err, NULL);
14987 }
AdminConnectEx(CEDAR * cedar,CLIENT_OPTION * o,char * hubname,void * hashed_password,UINT * err,char * client_name)14988 RPC *AdminConnectEx(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name)
14989 {
14990 return AdminConnectEx2(cedar, o, hubname, hashed_password, err, client_name, NULL);
14991 }
AdminConnectEx2(CEDAR * cedar,CLIENT_OPTION * o,char * hubname,void * hashed_password,UINT * err,char * client_name,void * hWnd)14992 RPC *AdminConnectEx2(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name, void *hWnd)
14993 {
14994 SESSION *s;
14995 SOCK *sock;
14996 RPC *rpc;
14997 UCHAR hashed_password_2[SHA1_SIZE];
14998 bool empty_password = false;
14999 // Validate arguments
15000 if (cedar == NULL || o == NULL || hashed_password == NULL || err == NULL)
15001 {
15002 return NULL;
15003 }
15004
15005 if (client_name == NULL)
15006 {
15007 client_name = CEDAR_MANAGER_STR;
15008 }
15009
15010 Copy(hashed_password_2, hashed_password, SHA1_SIZE);
15011
15012 s = AdminConnectMain(cedar, o, hubname, hashed_password_2, err, client_name, hWnd, &empty_password);
15013
15014 if (s == NULL)
15015 {
15016 return NULL;
15017 }
15018
15019 sock = s->Connection->FirstSock;
15020
15021 // RPC start
15022 rpc = StartRpcClient(sock, s);
15023
15024 rpc->IsVpnServer = true;
15025 Copy(&rpc->VpnServerClientOption, o, sizeof(CLIENT_OPTION));
15026 StrCpy(rpc->VpnServerHubName, sizeof(rpc->VpnServerHubName), hubname);
15027 StrCpy(rpc->VpnServerClientName, sizeof(rpc->VpnServerClientName), client_name);
15028
15029 if (empty_password == false)
15030 {
15031 Copy(rpc->VpnServerHashedPassword, hashed_password_2, SHA1_SIZE);
15032 }
15033 else
15034 {
15035 HashAdminPassword(rpc->VpnServerHashedPassword, "");
15036 }
15037
15038 // timeout setting
15039 SetTimeout(sock, INFINITE);
15040
15041 return rpc;
15042 }
15043
15044 // Reconnect admin connection
AdminReconnect(RPC * rpc)15045 UINT AdminReconnect(RPC *rpc)
15046 {
15047 SESSION *s;
15048 SOCK *sock;
15049 CEDAR *cedar;
15050 UINT err;
15051 bool empty_password = false;
15052 // Validate arguments
15053 if (rpc == NULL || rpc->IsVpnServer == false)
15054 {
15055 return ERR_INTERNAL_ERROR;
15056 }
15057
15058 s = (SESSION *)rpc->Param;
15059 cedar = s->Cedar;
15060 AddRef(cedar->ref);
15061
15062 sock = rpc->Sock;
15063 Disconnect(sock);
15064 ReleaseSock(sock);
15065 ReleaseSession(s);
15066 rpc->Param = NULL;
15067
15068 rpc->Sock = NULL;
15069
15070 s = AdminConnectMain(cedar, &rpc->VpnServerClientOption,
15071 rpc->VpnServerHubName,
15072 rpc->VpnServerHashedPassword,
15073 &err,
15074 rpc->VpnServerClientName, NULL, &empty_password);
15075
15076 ReleaseCedar(cedar);
15077
15078 if (s == NULL)
15079 {
15080 return err;
15081 }
15082
15083 if (empty_password)
15084 {
15085 HashAdminPassword(rpc->VpnServerHashedPassword, "");
15086 }
15087
15088 rpc->Param = s;
15089 rpc->Sock = s->Connection->FirstSock;
15090 AddRef(rpc->Sock->ref);
15091
15092 return ERR_NO_ERROR;
15093 }
15094
15095 // Identify blank password
SiIsEmptyPassword(void * hash_password)15096 bool SiIsEmptyPassword(void *hash_password)
15097 {
15098 UCHAR hash[SHA1_SIZE];
15099 // Validate arguments
15100 if (hash_password == NULL)
15101 {
15102 return false;
15103 }
15104
15105 Hash(hash, "", 0, true);
15106
15107 if (Cmp(hash_password, hash, SHA1_SIZE) == 0)
15108 {
15109 return true;
15110 }
15111
15112 return false;
15113 }
15114
15115