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 // 18 // License: The Apache License, Version 2.0 19 // https://www.apache.org/licenses/LICENSE-2.0 20 // 21 // DISCLAIMER 22 // ========== 23 // 24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 25 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 27 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 29 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 // SOFTWARE. 31 // 32 // THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN, UNDER 33 // JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY, MERGE, PUBLISH, 34 // DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS SOFTWARE, THAT ANY 35 // JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS SOFTWARE OR ITS CONTENTS, 36 // AGAINST US (SOFTETHER PROJECT, SOFTETHER CORPORATION, DAIYUU NOBORI OR OTHER 37 // SUPPLIERS), OR ANY JURIDICAL DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND 38 // OF USING, COPYING, MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING, 39 // AND/OR SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND 40 // CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO EXCLUSIVE 41 // JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO, JAPAN. YOU MUST WAIVE 42 // ALL DEFENSES OF LACK OF PERSONAL JURISDICTION AND FORUM NON CONVENIENS. 43 // PROCESS MAY BE SERVED ON EITHER PARTY IN THE MANNER AUTHORIZED BY APPLICABLE 44 // LAW OR COURT RULE. 45 // 46 // USE ONLY IN JAPAN. DO NOT USE THIS SOFTWARE IN ANOTHER COUNTRY UNLESS YOU HAVE 47 // A CONFIRMATION THAT THIS SOFTWARE DOES NOT VIOLATE ANY CRIMINAL LAWS OR CIVIL 48 // RIGHTS IN THAT PARTICULAR COUNTRY. USING THIS SOFTWARE IN OTHER COUNTRIES IS 49 // COMPLETELY AT YOUR OWN RISK. THE SOFTETHER VPN PROJECT HAS DEVELOPED AND 50 // DISTRIBUTED THIS SOFTWARE TO COMPLY ONLY WITH THE JAPANESE LAWS AND EXISTING 51 // CIVIL RIGHTS INCLUDING PATENTS WHICH ARE SUBJECTS APPLY IN JAPAN. OTHER 52 // COUNTRIES' LAWS OR CIVIL RIGHTS ARE NONE OF OUR CONCERNS NOR RESPONSIBILITIES. 53 // WE HAVE NEVER INVESTIGATED ANY CRIMINAL REGULATIONS, CIVIL LAWS OR 54 // INTELLECTUAL PROPERTY RIGHTS INCLUDING PATENTS IN ANY OF OTHER 200+ COUNTRIES 55 // AND TERRITORIES. BY NATURE, THERE ARE 200+ REGIONS IN THE WORLD, WITH 56 // DIFFERENT LAWS. IT IS IMPOSSIBLE TO VERIFY EVERY COUNTRIES' LAWS, REGULATIONS 57 // AND CIVIL RIGHTS TO MAKE THE SOFTWARE COMPLY WITH ALL COUNTRIES' LAWS BY THE 58 // PROJECT. EVEN IF YOU WILL BE SUED BY A PRIVATE ENTITY OR BE DAMAGED BY A 59 // PUBLIC SERVANT IN YOUR COUNTRY, THE DEVELOPERS OF THIS SOFTWARE WILL NEVER BE 60 // LIABLE TO RECOVER OR COMPENSATE SUCH DAMAGES, CRIMINAL OR CIVIL 61 // RESPONSIBILITIES. NOTE THAT THIS LINE IS NOT LICENSE RESTRICTION BUT JUST A 62 // STATEMENT FOR WARNING AND DISCLAIMER. 63 // 64 // READ AND UNDERSTAND THE 'WARNING.TXT' FILE BEFORE USING THIS SOFTWARE. 65 // SOME SOFTWARE PROGRAMS FROM THIRD PARTIES ARE INCLUDED ON THIS SOFTWARE WITH 66 // LICENSE CONDITIONS WHICH ARE DESCRIBED ON THE 'THIRD_PARTY.TXT' FILE. 67 // 68 // 69 // SOURCE CODE CONTRIBUTION 70 // ------------------------ 71 // 72 // Your contribution to SoftEther VPN Project is much appreciated. 73 // Please send patches to us through GitHub. 74 // Read the SoftEther VPN Patch Acceptance Policy in advance: 75 // http://www.softether.org/5-download/src/9.patch 76 // 77 // 78 // DEAR SECURITY EXPERTS 79 // --------------------- 80 // 81 // If you find a bug or a security vulnerability please kindly inform us 82 // about the problem immediately so that we can fix the security problem 83 // to protect a lot of users around the world as soon as possible. 84 // 85 // Our e-mail address for security reports is: 86 // softether-vpn-security [at] softether.org 87 // 88 // Please note that the above e-mail address is not a technical support 89 // inquiry address. If you need technical assistance, please visit 90 // http://www.softether.org/ and ask your question on the users forum. 91 // 92 // Thank you for your cooperation. 93 // 94 // 95 // NO MEMORY OR RESOURCE LEAKS 96 // --------------------------- 97 // 98 // The memory-leaks and resource-leaks verification under the stress 99 // test has been passed before release this source code. 100 101 102 // Admin.h 103 // Header of Admin.c 104 105 #ifndef ADMIN_H 106 #define ADMIN_H 107 108 // Windows version 109 struct RPC_WINVER 110 { 111 bool IsWindows; 112 bool IsNT; 113 bool IsServer; 114 bool IsBeta; 115 UINT VerMajor; 116 UINT VerMinor; 117 UINT Build; 118 UINT ServicePack; 119 char Title[128]; 120 }; 121 122 // Server-side structure 123 struct ADMIN 124 { 125 SERVER *Server; // Server 126 bool ServerAdmin; // Server Administrator 127 char *HubName; // HUB name that can be managed 128 RPC *Rpc; // RPC 129 LIST *LogFileList; // Accessible log file list 130 UINT ClientBuild; // Build number of the client 131 RPC_WINVER ClientWinVer; // Windows version of client 132 UINT MaxJsonRpcRecvSize; // Max JSON-RPC Receive Size 133 char dummy1[MAX_HUBNAME_LEN + 1]; // hubname buffer (dummy) 134 }; 135 136 // Test 137 struct RPC_TEST 138 { 139 UINT IntValue; 140 UINT64 Int64Value; 141 char StrValue[1024]; 142 wchar_t UniStrValue[1024]; 143 }; 144 145 // Server Information * 146 struct RPC_SERVER_INFO 147 { 148 char ServerProductName[128]; // Server product name 149 char ServerVersionString[128]; // Server version string 150 char ServerBuildInfoString[128]; // Server build information string 151 UINT ServerVerInt; // Server version integer value 152 UINT ServerBuildInt; // Server build number integer value 153 char ServerHostName[MAX_HOST_NAME_LEN + 1]; // Server host name 154 UINT ServerType; // Type of server 155 UINT64 ServerBuildDate; // Build date and time of the server 156 char ServerFamilyName[128]; // Family name 157 OS_INFO OsInfo; // OS information 158 }; 159 160 // Server status 161 struct RPC_SERVER_STATUS 162 { 163 UINT ServerType; // Type of server 164 UINT NumTcpConnections; // Total number of TCP connections 165 UINT NumTcpConnectionsLocal; // Number of Local TCP connections 166 UINT NumTcpConnectionsRemote; // Number of remote TCP connections 167 UINT NumHubTotal; // Total number of HUBs 168 UINT NumHubStandalone; // Nymber of stand-alone HUB 169 UINT NumHubStatic; // Number of static HUBs 170 UINT NumHubDynamic; // Number of Dynamic HUBs 171 UINT NumSessionsTotal; // Total number of sessions 172 UINT NumSessionsLocal; // Number of Local sessions (only controller) 173 UINT NumSessionsRemote; // The number of remote sessions (other than the controller) 174 UINT NumMacTables; // Number of MAC table entries 175 UINT NumIpTables; // Number of IP table entries 176 UINT NumUsers; // Number of users 177 UINT NumGroups; // Number of groups 178 UINT AssignedBridgeLicenses; // Number of assigned bridge licenses 179 UINT AssignedClientLicenses; // Number of assigned client licenses 180 UINT AssignedBridgeLicensesTotal; // Number of Assigned bridge license (cluster-wide) 181 UINT AssignedClientLicensesTotal; // Number of assigned client licenses (cluster-wide) 182 TRAFFIC Traffic; // Traffic information 183 UINT64 CurrentTime; // Current time 184 UINT64 CurrentTick; // Current tick 185 UINT64 StartTime; // Start-up time 186 MEMINFO MemInfo; // Memory information 187 }; 188 189 // Listener 190 struct RPC_LISTENER 191 { 192 UINT Port; // Port number 193 bool Enable; // Active state 194 }; 195 196 // List of listeners * 197 struct RPC_LISTENER_LIST 198 { 199 UINT NumPort; // Number of ports 200 UINT *Ports; // Port List 201 bool *Enables; // Effective state 202 bool *Errors; // An error occurred 203 }; 204 205 // String * 206 struct RPC_STR 207 { 208 char *String; // String 209 }; 210 211 // Integer 212 struct RPC_INT 213 { 214 UINT IntValue; // Integer 215 }; 216 217 // Set Password 218 struct RPC_SET_PASSWORD 219 { 220 UCHAR HashedPassword[SHA1_SIZE]; // Hashed password (for traditional RPC) 221 char PlainTextPassword[MAX_SIZE]; // Plaintext password (for JSON-RPC) 222 }; 223 224 // Server farm configuration * 225 struct RPC_FARM 226 { 227 UINT ServerType; // Type of server 228 UINT NumPort; // Number of public ports 229 UINT *Ports; // Public port list 230 UINT PublicIp; // Public IP 231 char ControllerName[MAX_HOST_NAME_LEN + 1]; // Controller name 232 UINT ControllerPort; // Controller port 233 UCHAR MemberPassword[SHA1_SIZE]; // Member password 234 char MemberPasswordPlaintext[MAX_SIZE]; // Member password (plaintext) 235 UINT Weight; // Performance ratio 236 bool ControllerOnly; // Only controller function 237 }; 238 239 // HUB item of each farm member 240 struct RPC_FARM_HUB 241 { 242 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 243 bool DynamicHub; // Dynamic HUB 244 }; 245 246 // Server farm member information acquisition * 247 struct RPC_FARM_INFO 248 { 249 UINT Id; // ID 250 bool Controller; // Controller 251 UINT64 ConnectedTime; // Connection time 252 UINT Ip; // IP address 253 char Hostname[MAX_HOST_NAME_LEN + 1]; // Host name 254 UINT Point; // Point 255 UINT NumPort; // Number of ports 256 UINT *Ports; // Port 257 X *ServerCert; // Server certificate 258 UINT NumFarmHub; // Number of farm HUB 259 RPC_FARM_HUB *FarmHubs; // Farm HUB 260 UINT NumSessions; // Number of sessions 261 UINT NumTcpConnections; // Number of TCP connections 262 UINT Weight; // Performance ratio 263 }; 264 265 // Server farm members enumeration items 266 struct RPC_ENUM_FARM_ITEM 267 { 268 UINT Id; // ID 269 bool Controller; // Controller 270 UINT64 ConnectedTime; // Connection time 271 UINT Ip; // IP address 272 char Hostname[MAX_HOST_NAME_LEN + 1]; // Host name 273 UINT Point; // Point 274 UINT NumSessions; // Number of sessions 275 UINT NumTcpConnections; // Number of TCP connections 276 UINT NumHubs; // Number of HUBs 277 UINT AssignedClientLicense; // Number of assigned client licenses 278 UINT AssignedBridgeLicense; // Number of assigned bridge licenses 279 }; 280 281 // Server farm member enumeration * 282 struct RPC_ENUM_FARM 283 { 284 UINT NumFarm; // Number of farm members 285 RPC_ENUM_FARM_ITEM *Farms; // Farm member list 286 }; 287 288 // Connection state to the controller 289 struct RPC_FARM_CONNECTION_STATUS 290 { 291 UINT Ip; // IP address 292 UINT Port; // Port number 293 bool Online; // Online state 294 UINT LastError; // Last error 295 UINT64 StartedTime; // Connection start time 296 UINT64 FirstConnectedTime; // First connection time 297 UINT64 CurrentConnectedTime; // Connection time of this time 298 UINT NumTry; // Number of trials 299 UINT NumConnected; // Number of connection count 300 UINT NumFailed; // Connection failure count 301 }; 302 303 // Key pair 304 struct RPC_KEY_PAIR 305 { 306 X *Cert; // Certificate 307 K *Key; // Secret key 308 UINT Flag1; // Flag1 309 }; 310 311 // HUB option 312 struct RPC_HUB_OPTION 313 { 314 UINT MaxSession; // Maximum number of sessions 315 bool NoEnum; // Not listed 316 }; 317 318 // Radius server options 319 struct RPC_RADIUS 320 { 321 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 322 char RadiusServerName[MAX_HOST_NAME_LEN + 1]; // Radius server name 323 UINT RadiusPort; // Radius port number 324 char RadiusSecret[MAX_PASSWORD_LEN + 1]; // Secret key 325 UINT RadiusRetryInterval; // Radius retry interval 326 }; 327 328 // Specify the HUB 329 struct RPC_HUB 330 { 331 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 332 }; 333 334 // Create a HUB 335 struct RPC_CREATE_HUB 336 { 337 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 338 UCHAR HashedPassword[SHA1_SIZE]; // Administrative password 339 UCHAR SecurePassword[SHA1_SIZE]; // Administrator password 340 char AdminPasswordPlainText[MAX_SIZE]; // Password (plaintext) 341 bool Online; // Online flag 342 RPC_HUB_OPTION HubOption; // HUB options 343 UINT HubType; // Type of HUB 344 }; 345 346 // Enumeration items of HUB 347 struct RPC_ENUM_HUB_ITEM 348 { 349 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 350 bool Online; // Online 351 UINT HubType; // Type of HUB 352 UINT NumUsers; // Number of users 353 UINT NumGroups; // Number of groups 354 UINT NumSessions; // Number of sessions 355 UINT NumMacTables; // Number of MAC table entries 356 UINT NumIpTables; // Number of IP table entries 357 UINT64 LastCommTime; // Last communication date and time 358 UINT64 LastLoginTime; // Last login date and time 359 UINT64 CreatedTime; // Creation date and time 360 UINT NumLogin; // Number of logins 361 bool IsTrafficFilled; // Whether the traffic information exists 362 TRAFFIC Traffic; // Traffic 363 }; 364 365 // Enumeration of HUB 366 struct RPC_ENUM_HUB 367 { 368 UINT NumHub; // Number of HUBs 369 RPC_ENUM_HUB_ITEM *Hubs; // HUB 370 }; 371 372 // Delete the HUB 373 struct RPC_DELETE_HUB 374 { 375 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 376 }; 377 378 // Connection enumeration items 379 struct RPC_ENUM_CONNECTION_ITEM 380 { 381 char Name[MAX_SIZE]; // Connection name 382 char Hostname[MAX_SIZE]; // Host name 383 UINT Ip; // IP address 384 UINT Port; // Port number 385 UINT64 ConnectedTime; // Connected time 386 UINT Type; // Type 387 }; 388 389 // Connection enumeration 390 struct RPC_ENUM_CONNECTION 391 { 392 UINT NumConnection; // Number of connections 393 RPC_ENUM_CONNECTION_ITEM *Connections; // Connection list 394 }; 395 396 // Disconnection 397 struct RPC_DISCONNECT_CONNECTION 398 { 399 char Name[MAX_SIZE]; // Connection name 400 }; 401 402 // Connection information 403 struct RPC_CONNECTION_INFO 404 { 405 char Name[MAX_SIZE]; // Connection name 406 UINT Type; // Type 407 char Hostname[MAX_SIZE]; // Host name 408 UINT Ip; // IP address 409 UINT Port; // Port number 410 UINT64 ConnectedTime; // Connected time 411 char ServerStr[MAX_SERVER_STR_LEN + 1]; // Server string 412 UINT ServerVer; // Server version 413 UINT ServerBuild; // Server build number 414 char ClientStr[MAX_CLIENT_STR_LEN + 1]; // Client string 415 UINT ClientVer; // Client version 416 UINT ClientBuild; // Client build number 417 }; 418 419 // Online or offline the HUB 420 struct RPC_SET_HUB_ONLINE 421 { 422 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 423 bool Online; // Online / offline flag 424 }; 425 426 // Get the state HUB 427 struct RPC_HUB_STATUS 428 { 429 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 430 bool Online; // Online 431 UINT HubType; // Type of HUB 432 UINT NumSessions; // Number of sessions 433 UINT NumSessionsClient; // Number of sessions (client) 434 UINT NumSessionsBridge; // Number of sessions (bridge) 435 UINT NumAccessLists; // Number of Access list entries 436 UINT NumUsers; // Number of users 437 UINT NumGroups; // Number of groups 438 UINT NumMacTables; // Number of MAC table entries 439 UINT NumIpTables; // Number of IP table entries 440 TRAFFIC Traffic; // Traffic 441 bool SecureNATEnabled; // Whether SecureNAT is enabled 442 UINT64 LastCommTime; // Last communication date and time 443 UINT64 LastLoginTime; // Last login date and time 444 UINT64 CreatedTime; // Creation date and time 445 UINT NumLogin; // Number of logins 446 }; 447 448 // HUB log settings 449 struct RPC_HUB_LOG 450 { 451 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 452 HUB_LOG LogSetting; // Log Settings 453 }; 454 455 // Add CA to HUB * 456 struct RPC_HUB_ADD_CA 457 { 458 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 459 X *Cert; // Certificate 460 }; 461 462 // CA enumeration items of HUB 463 struct RPC_HUB_ENUM_CA_ITEM 464 { 465 UINT Key; // Certificate key 466 wchar_t SubjectName[MAX_SIZE]; // Issued to 467 wchar_t IssuerName[MAX_SIZE]; // Issuer 468 UINT64 Expires; // Expiration date 469 }; 470 471 // CA enumeration of HUB * 472 struct RPC_HUB_ENUM_CA 473 { 474 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 475 UINT NumCa; // CA number 476 RPC_HUB_ENUM_CA_ITEM *Ca; // CA 477 }; 478 479 // Get the CA of HUB * 480 struct RPC_HUB_GET_CA 481 { 482 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 483 UINT Key; // Certificate key 484 X *Cert; // Certificate 485 }; 486 487 // Delete the CA of HUB 488 struct RPC_HUB_DELETE_CA 489 { 490 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 491 UINT Key; // Certificate key to be deleted 492 }; 493 494 // Create and set of link * 495 struct RPC_CREATE_LINK 496 { 497 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 498 bool Online; // Online flag 499 CLIENT_OPTION *ClientOption; // Client Option 500 CLIENT_AUTH *ClientAuth; // Client authentication data 501 POLICY Policy; // Policy 502 bool CheckServerCert; // Validate the server certificate 503 X *ServerCert; // Server certificate 504 }; 505 506 // Enumeration items of link 507 struct RPC_ENUM_LINK_ITEM 508 { 509 wchar_t AccountName[MAX_ACCOUNT_NAME_LEN + 1]; // Account name 510 bool Online; // Online flag 511 bool Connected; // Connection completion flag 512 UINT LastError; // The error that last occurred 513 UINT64 ConnectedTime; // Connection completion time 514 char Hostname[MAX_HOST_NAME_LEN + 1]; // Host name 515 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 516 }; 517 518 // Enumeration of the link * 519 struct RPC_ENUM_LINK 520 { 521 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 522 UINT NumLink; // Number of links 523 RPC_ENUM_LINK_ITEM *Links; // Link List 524 }; 525 526 // Get the link state * 527 struct RPC_LINK_STATUS 528 { 529 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 530 wchar_t AccountName[MAX_ACCOUNT_NAME_LEN + 1]; // Account name 531 RPC_CLIENT_GET_CONNECTION_STATUS Status; // Status 532 }; 533 534 // Specify the Link 535 struct RPC_LINK 536 { 537 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 538 wchar_t AccountName[MAX_ACCOUNT_NAME_LEN + 1]; // Account name 539 }; 540 541 // Rename link 542 struct RPC_RENAME_LINK 543 { 544 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 545 wchar_t OldAccountName[MAX_ACCOUNT_NAME_LEN + 1]; // Old account name 546 wchar_t NewAccountName[MAX_ACCOUNT_NAME_LEN + 1]; // New account name 547 }; 548 549 // Enumeration of the access list * 550 struct RPC_ENUM_ACCESS_LIST 551 { 552 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 553 UINT NumAccess; // Number of Access list entries 554 ACCESS *Accesses; // Access list 555 }; 556 557 // Add to Access List 558 struct RPC_ADD_ACCESS 559 { 560 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 561 ACCESS Access; // Access list 562 }; 563 564 // Delete the access list 565 struct RPC_DELETE_ACCESS 566 { 567 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 568 UINT Id; // ID 569 }; 570 571 // Create, configure, and get the user * 572 struct RPC_SET_USER 573 { 574 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 575 char Name[MAX_USERNAME_LEN + 1]; // User name 576 char GroupName[MAX_USERNAME_LEN + 1]; // Group name 577 wchar_t Realname[MAX_SIZE]; // Real name 578 wchar_t Note[MAX_SIZE]; // Note 579 UINT64 CreatedTime; // Creation date and time 580 UINT64 UpdatedTime; // Updating date 581 UINT64 ExpireTime; // Expiration date 582 UINT AuthType; // Authentication method 583 void *AuthData; // Authentication data 584 UINT NumLogin; // Number of logins 585 TRAFFIC Traffic; // Traffic data 586 POLICY *Policy; // Policy 587 }; 588 589 // Enumeration item of user 590 struct RPC_ENUM_USER_ITEM 591 { 592 char Name[MAX_USERNAME_LEN + 1]; // User name 593 char GroupName[MAX_USERNAME_LEN + 1]; // Group name 594 wchar_t Realname[MAX_SIZE]; // Real name 595 wchar_t Note[MAX_SIZE]; // Note 596 UINT AuthType; // Authentication method 597 UINT NumLogin; // Number of logins 598 UINT64 LastLoginTime; // Last login date and time 599 bool DenyAccess; // Access denied 600 bool IsTrafficFilled; // Flag of whether the traffic variable is set 601 TRAFFIC Traffic; // Traffic 602 bool IsExpiresFilled; // Flag of whether expiration date variable is set 603 UINT64 Expires; // Expiration date 604 }; 605 606 // Enumeration of user 607 struct RPC_ENUM_USER 608 { 609 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 610 UINT NumUser; // Number of users 611 RPC_ENUM_USER_ITEM *Users; // User 612 }; 613 614 // Create, configure, and get the group * 615 struct RPC_SET_GROUP 616 { 617 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 618 char Name[MAX_USERNAME_LEN + 1]; // User name 619 wchar_t Realname[MAX_SIZE]; // Real name 620 wchar_t Note[MAX_SIZE]; // Note 621 TRAFFIC Traffic; // Traffic data 622 POLICY *Policy; // Policy 623 }; 624 625 // Enumeration items in the group 626 struct RPC_ENUM_GROUP_ITEM 627 { 628 char Name[MAX_USERNAME_LEN + 1]; // User name 629 wchar_t Realname[MAX_SIZE]; // Real name 630 wchar_t Note[MAX_SIZE]; // Note 631 UINT NumUsers; // Number of users 632 bool DenyAccess; // Access denied 633 }; 634 635 // Group enumeration 636 struct RPC_ENUM_GROUP 637 { 638 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 639 UINT NumGroup; // Number of groups 640 RPC_ENUM_GROUP_ITEM *Groups; // Group 641 }; 642 643 // Deleting a user or group 644 struct RPC_DELETE_USER 645 { 646 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 647 char Name[MAX_USERNAME_LEN + 1]; // User or group name 648 }; 649 650 // Enumeration items of session 651 struct RPC_ENUM_SESSION_ITEM 652 { 653 char Name[MAX_SESSION_NAME_LEN + 1]; // Session name 654 bool RemoteSession; // Remote session 655 char RemoteHostname[MAX_HOST_NAME_LEN + 1]; // Remote server name 656 char Username[MAX_USERNAME_LEN + 1]; // User name 657 UINT Ip; // IP address (IPv4) 658 IP ClientIP; // IP address (IPv4 / IPv6) 659 char Hostname[MAX_HOST_NAME_LEN + 1]; // Host name 660 UINT MaxNumTcp; // Maximum number of TCP connections 661 UINT CurrentNumTcp; // Number of currentl TCP connections 662 UINT64 PacketSize; // Packet size 663 UINT64 PacketNum; // Number of packets 664 bool LinkMode; // Link mode 665 bool SecureNATMode; // SecureNAT mode 666 bool BridgeMode; // Bridge mode 667 bool Layer3Mode; // Layer 3 mode 668 bool Client_BridgeMode; // Client is bridge mode 669 bool Client_MonitorMode; // Client is monitoring mode 670 UINT VLanId; // VLAN ID 671 UCHAR UniqueId[16]; // Unique ID 672 bool IsDormantEnabled; // Is the dormant state enabled 673 bool IsDormant; // Is in the dormant state 674 UINT64 LastCommDormant; // Last comm interval in the dormant state 675 UINT64 CreatedTime; // Creation date and time 676 UINT64 LastCommTime; // Last communication date and time 677 }; 678 679 // Disconnect the session 680 struct RPC_DELETE_SESSION 681 { 682 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 683 char Name[MAX_SESSION_NAME_LEN + 1]; // Session name 684 }; 685 686 // Enumeration items of the MAC table 687 struct RPC_ENUM_MAC_TABLE_ITEM 688 { 689 UINT Key; // Key 690 char SessionName[MAX_SESSION_NAME_LEN + 1]; // Session name 691 UCHAR MacAddress[6]; // MAC address 692 UCHAR Padding[2]; 693 UINT64 CreatedTime; // Creation date and time 694 UINT64 UpdatedTime; // Updating date 695 bool RemoteItem; // Remote items 696 char RemoteHostname[MAX_HOST_NAME_LEN + 1]; // Remote host name 697 UINT VlanId; // VLAN ID 698 }; 699 700 // Enumeration of the MAC table 701 struct RPC_ENUM_MAC_TABLE 702 { 703 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 704 UINT NumMacTable; // Number of tables 705 RPC_ENUM_MAC_TABLE_ITEM *MacTables; // MAC table 706 }; 707 708 // Enumeration items of IP table 709 struct RPC_ENUM_IP_TABLE_ITEM 710 { 711 UINT Key; // Key 712 char SessionName[MAX_SESSION_NAME_LEN + 1]; // Session name 713 UINT Ip; // IPv4 address 714 IP IpV6; // IPv6 address 715 IP IpAddress; // IPv4 / IPv6 Address 716 bool DhcpAllocated; // Assigned by the DHCP 717 UINT64 CreatedTime; // Creation date and time 718 UINT64 UpdatedTime; // Updating date 719 bool RemoteItem; // Remote items 720 char RemoteHostname[MAX_HOST_NAME_LEN + 1]; // Remote host name 721 }; 722 723 // Enumeration of IP table 724 struct RPC_ENUM_IP_TABLE 725 { 726 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 727 UINT NumIpTable; // Number of tables 728 RPC_ENUM_IP_TABLE_ITEM *IpTables; // MAC table 729 }; 730 731 // Delete the table 732 struct RPC_DELETE_TABLE 733 { 734 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 735 UINT Key; // Key 736 }; 737 738 // KEEP setting 739 struct RPC_KEEP 740 { 741 bool UseKeepConnect; // Keep connected to the Internet 742 char KeepConnectHost[MAX_HOST_NAME_LEN + 1]; // Host name 743 UINT KeepConnectPort; // Port number 744 UINT KeepConnectProtocol; // Protocol 745 UINT KeepConnectInterval; // Interval 746 }; 747 748 // Ethernet enumeration item 749 struct RPC_ENUM_ETH_ITEM 750 { 751 char DeviceName[MAX_SIZE]; // Device name 752 wchar_t NetworkConnectionName[MAX_SIZE];// Network connection name 753 }; 754 755 // Ethernet enumeration 756 struct RPC_ENUM_ETH 757 { 758 UINT NumItem; // Number of items 759 RPC_ENUM_ETH_ITEM *Items; // Item 760 }; 761 762 // Bridge item 763 struct RPC_LOCALBRIDGE 764 { 765 char DeviceName[MAX_SIZE]; // Device name 766 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 767 bool Online; // Online flag 768 bool Active; // Running flag 769 bool TapMode; // Tap mode 770 }; 771 772 // Bridge enumeration 773 struct RPC_ENUM_LOCALBRIDGE 774 { 775 UINT NumItem; // Number of items 776 RPC_LOCALBRIDGE *Items; // Item 777 }; 778 779 // Bridge support information 780 struct RPC_BRIDGE_SUPPORT 781 { 782 bool IsBridgeSupportedOs; // Whether the OS supports the bridge 783 bool IsWinPcapNeeded; // Whether WinPcap is necessary 784 }; 785 786 // Config operation 787 struct RPC_CONFIG 788 { 789 char FileName[MAX_PATH]; // File name 790 char *FileData; // File data 791 }; 792 793 // Administration options list 794 struct RPC_ADMIN_OPTION 795 { 796 char HubName[MAX_HUBNAME_LEN + 1]; // Virtual HUB name 797 UINT NumItem; // Count 798 ADMIN_OPTION *Items; // Data 799 }; 800 801 // Layer-3 switch 802 struct RPC_L3SW 803 { 804 char Name[MAX_HUBNAME_LEN + 1]; // L3 switch name 805 }; 806 807 // Layer-3 switch enumeration 808 struct RPC_ENUM_L3SW_ITEM 809 { 810 char Name[MAX_HUBNAME_LEN + 1]; // Name 811 UINT NumInterfaces; // Number of interfaces 812 UINT NumTables; // Routing table number 813 bool Active; // In operation 814 bool Online; // Online 815 }; 816 struct RPC_ENUM_L3SW 817 { 818 UINT NumItem; 819 RPC_ENUM_L3SW_ITEM *Items; 820 }; 821 822 // Layer-3 interface 823 struct RPC_L3IF 824 { 825 char Name[MAX_HUBNAME_LEN + 1]; // L3 switch name 826 char HubName[MAX_HUBNAME_LEN + 1]; // Virtual HUB name 827 UINT IpAddress; // IP address 828 UINT SubnetMask; // Subnet mask 829 }; 830 831 // Layer-3 interface enumeration 832 struct RPC_ENUM_L3IF 833 { 834 char Name[MAX_HUBNAME_LEN + 1]; // L3 switch name 835 UINT NumItem; 836 RPC_L3IF *Items; 837 }; 838 839 // Routing table 840 struct RPC_L3TABLE 841 { 842 char Name[MAX_HUBNAME_LEN + 1]; // L3 switch name 843 UINT NetworkAddress; // Network address 844 UINT SubnetMask; // Subnet mask 845 UINT GatewayAddress; // Gateway address 846 UINT Metric; // Metric 847 }; 848 849 // Routing table enumeration 850 struct RPC_ENUM_L3TABLE 851 { 852 char Name[MAX_HUBNAME_LEN + 1]; // L3 switch name 853 UINT NumItem; 854 RPC_L3TABLE *Items; 855 }; 856 857 // CRL entry 858 struct RPC_CRL 859 { 860 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 861 UINT Key; // Key 862 CRL *Crl; // CRL body 863 }; 864 865 // CRL enumeration 866 struct RPC_ENUM_CRL_ITEM 867 { 868 UINT Key; // Key 869 wchar_t CrlInfo[MAX_SIZE]; // Information 870 }; 871 struct RPC_ENUM_CRL 872 { 873 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 874 UINT NumItem; // Number of items 875 RPC_ENUM_CRL_ITEM *Items; // List 876 }; 877 878 // AC list 879 struct RPC_AC_LIST 880 { 881 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 882 LIST *o; // List body 883 bool InternalFlag1; 884 }; 885 886 // Log file enumeration 887 struct RPC_ENUM_LOG_FILE_ITEM 888 { 889 char ServerName[MAX_HOST_NAME_LEN + 1]; // Server name 890 char FilePath[MAX_PATH]; // File Path 891 UINT FileSize; // File size 892 UINT64 UpdatedTime; // Updating date 893 }; 894 struct RPC_ENUM_LOG_FILE 895 { 896 UINT NumItem; // Number of items 897 RPC_ENUM_LOG_FILE_ITEM *Items; // List 898 }; 899 900 // Read a Log file 901 struct RPC_READ_LOG_FILE 902 { 903 char ServerName[MAX_HOST_NAME_LEN + 1]; // Server name 904 char FilePath[MAX_PATH]; // File Path 905 UINT Offset; // Offset 906 BUF *Buffer; // Buffer 907 }; 908 909 // Download information 910 struct DOWNLOAD_PROGRESS 911 { 912 void *Param; // User define data 913 UINT TotalSize; // The total file size 914 UINT CurrentSize; // Size which has loaded 915 UINT ProgressPercent; // Percent Complete 916 }; 917 918 // Enumerate the license keys 919 struct RPC_ENUM_LICENSE_KEY_ITEM 920 { 921 UINT Id; // ID 922 char LicenseKey[LICENSE_KEYSTR_LEN + 1]; // License key 923 char LicenseId[LICENSE_LICENSEID_STR_LEN + 1]; // License ID 924 char LicenseName[LICENSE_MAX_PRODUCT_NAME_LEN + 1]; // License name 925 UINT64 Expires; // Expiration date 926 UINT Status; // Situation 927 UINT ProductId; // Product ID 928 UINT64 SystemId; // System ID 929 UINT SerialId; // Serial ID 930 }; 931 struct RPC_ENUM_LICENSE_KEY 932 { 933 UINT NumItem; // Number of items 934 RPC_ENUM_LICENSE_KEY_ITEM *Items; // List 935 }; 936 937 // License status of the server 938 struct RPC_LICENSE_STATUS 939 { 940 UINT EditionId; // Edition ID 941 char EditionStr[LICENSE_MAX_PRODUCT_NAME_LEN + 1]; // Edition name 942 UINT64 SystemId; // System ID 943 UINT64 SystemExpires; // System expiration date 944 UINT NumClientConnectLicense; // Maximum number of concurrent client connections 945 UINT NumBridgeConnectLicense; // Available number of concurrent bridge connections 946 947 // v3.0 948 bool NeedSubscription; // Subscription system is enabled 949 UINT64 SubscriptionExpires; // Subscription expiration date 950 bool IsSubscriptionExpired; // Whether the subscription is expired 951 UINT NumUserCreationLicense; // Maximum number of users 952 bool AllowEnterpriseFunction; // Operation of the enterprise function 953 UINT64 ReleaseDate; // Release date 954 }; 955 956 // Enumeration of VLAN support status of physical LAN card 957 struct RPC_ENUM_ETH_VLAN_ITEM 958 { 959 char DeviceName[MAX_SIZE]; // Device name 960 char Guid[MAX_SIZE]; // GUID 961 char DeviceInstanceId[MAX_SIZE]; // Device Instance ID 962 char DriverName[MAX_SIZE]; // Driver file name 963 char DriverType[MAX_SIZE]; // Type of driver 964 bool Support; // Check whether it is supported 965 bool Enabled; // Whether it is enabled 966 }; 967 struct RPC_ENUM_ETH_VLAN 968 { 969 UINT NumItem; // Number of items 970 RPC_ENUM_ETH_VLAN_ITEM *Items; // List 971 }; 972 973 // Message 974 struct RPC_MSG 975 { 976 char HubName[MAX_HUBNAME_LEN + 1]; // HUB Name 977 wchar_t *Msg; // Message 978 }; 979 980 // EtherIP setting list 981 struct RPC_ENUM_ETHERIP_ID 982 { 983 UINT NumItem; 984 ETHERIP_ID *IdList; 985 }; 986 987 // Set the special listener 988 struct RPC_SPECIAL_LISTENER 989 { 990 bool VpnOverIcmpListener; // VPN over ICMP 991 bool VpnOverDnsListener; // VPN over DNS 992 }; 993 994 // Get / Set the Azure state 995 struct RPC_AZURE_STATUS 996 { 997 bool IsEnabled; // Whether enabled 998 bool IsConnected; // Whether it's connected 999 }; 1000 1001 1002 // Constants 1003 #define ADMIN_RPC_MAX_POST_SIZE_BY_SERVER_ADMIN MAX_PACK_SIZE 1004 #define ADMIN_RPC_MAX_POST_SIZE_BY_HUB_ADMIN (8 * 1024 * 1024) 1005 1006 1007 // Function prototype 1008 UINT AdminAccept(CONNECTION *c, PACK *p); 1009 void HashAdminPassword(void *hash, char *password); 1010 SESSION *AdminConnectMain(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name, void *hWnd, bool *empty_password); 1011 RPC *AdminConnect(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err); 1012 RPC *AdminConnectEx(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name); 1013 RPC *AdminConnectEx2(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name, void *hWnd); 1014 void AdminDisconnect(RPC *rpc); 1015 UINT AdminReconnect(RPC *rpc); 1016 UINT AdminCheckPassword(CEDAR *c, void *random, void *secure_password, char *hubname, bool accept_empty_password, bool *is_password_empty); 1017 PACK *AdminDispatch(RPC *rpc, char *name, PACK *p); 1018 PACK *AdminCall(RPC *rpc, char *function_name, PACK *p); 1019 void SiEnumLocalSession(SERVER *s, char *hubname, RPC_ENUM_SESSION *t); 1020 void CopyOsInfo(OS_INFO *dst, OS_INFO *info); 1021 CAPSLIST *ScGetCapsEx(RPC *rpc); 1022 UINT SiEnumMacTable(SERVER *s, char *hubname, RPC_ENUM_MAC_TABLE *t); 1023 UINT SiEnumIpTable(SERVER *s, char *hubname, RPC_ENUM_IP_TABLE *t); 1024 void SiEnumLocalLogFileList(SERVER *s, char *hubname, RPC_ENUM_LOG_FILE *t); 1025 void SiReadLocalLogFile(SERVER *s, char *filepath, UINT offset, RPC_READ_LOG_FILE *t); 1026 typedef bool (DOWNLOAD_PROC)(DOWNLOAD_PROGRESS *progress); 1027 BUF *DownloadFileFromServer(RPC *r, char *server_name, char *filepath, UINT total_size, DOWNLOAD_PROC *proc, void *param); 1028 bool CheckAdminSourceAddress(SOCK *sock, char *hubname); 1029 void SiEnumSessionMain(SERVER *s, RPC_ENUM_SESSION *t); 1030 bool SiIsEmptyPassword(void *hash_password); 1031 void JsonRpcProcPost(CONNECTION *c, SOCK *s, HTTP_HEADER *h, UINT post_data_size); 1032 void JsonRpcProcGet(CONNECTION *c, SOCK *s, HTTP_HEADER *h, char *url_target); 1033 void JsonRpcProcOptions(CONNECTION *c, SOCK *s, HTTP_HEADER *h, char *url_target); 1034 JSON_VALUE *JsonRpcProcRequestObject(ADMIN *admin, CONNECTION *c, SOCK *s, JSON_VALUE *json_req, char *method_name); 1035 JSON_VALUE *JsonRpcNewError(int code, wchar_t *message); 1036 JSON_VALUE *JsonRpcNewResponse(PACK *p); 1037 bool HttpParseBasicAuthHeader(HTTP_HEADER *h, char *username, UINT username_size, char *password, UINT password_size); 1038 ADMIN *JsonRpcAuthLogin(CEDAR *c, SOCK *sock, HTTP_HEADER *h); 1039 JSON_VALUE *QueryStringToJsonListValue(char *qs); 1040 JSON_VALUE *ConstructDummyJsonRpcRequest(char *method_name, JSON_VALUE *p); 1041 void AdminWebProcPost(CONNECTION *c, SOCK *s, HTTP_HEADER *h, UINT post_data_size, char *url_target); 1042 void AdminWebProcGet(CONNECTION *c, SOCK *s, HTTP_HEADER *h, char *url_target); 1043 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); 1044 BUF *AdminWebProcessServerSideInclude(BUF *src_txt, char *filename, UINT depth); 1045 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, HTTP_HEADER *request_headers); 1046 bool AdminWebSend404Error(SOCK *s, HTTP_HEADER *request_headers); 1047 bool AdminWebSend302Redirect(SOCK *s, char *url, char *query_string, HTTP_HEADER *request_headers); 1048 BUF *AdminWebTryFindAndReadFile(char *vroot, char *proot, char *url, char *ret_filename, UINT ret_filename_size, bool *is_index_html); 1049 BUF *AdminWebTryOneFile(char *filename, char *ret_filename, UINT ret_filename_size); 1050 bool AdminWebSendUnauthorized(SOCK *s, HTTP_HEADER *http_request_headers); 1051 1052 UINT StTest(ADMIN *a, RPC_TEST *t); 1053 UINT StGetServerInfo(ADMIN *a, RPC_SERVER_INFO *t); 1054 UINT StGetServerStatus(ADMIN *a, RPC_SERVER_STATUS *t); 1055 UINT StCreateListener(ADMIN *a, RPC_LISTENER *t); 1056 UINT StEnumListener(ADMIN *a, RPC_LISTENER_LIST *t); 1057 UINT StDeleteListener(ADMIN *a, RPC_LISTENER *t); 1058 UINT StEnableListener(ADMIN *a, RPC_LISTENER *t); 1059 UINT StSetServerPassword(ADMIN *a, RPC_SET_PASSWORD *t); 1060 UINT StSetFarmSetting(ADMIN *a, RPC_FARM *t); 1061 UINT StGetFarmSetting(ADMIN *a, RPC_FARM *t); 1062 UINT StGetFarmInfo(ADMIN *a, RPC_FARM_INFO *t); 1063 UINT StEnumFarmMember(ADMIN *a, RPC_ENUM_FARM *t); 1064 UINT StGetFarmConnectionStatus(ADMIN *a, RPC_FARM_CONNECTION_STATUS *t); 1065 UINT StSetServerCert(ADMIN *a, RPC_KEY_PAIR *t); 1066 UINT StGetServerCert(ADMIN *a, RPC_KEY_PAIR *t); 1067 UINT StGetServerCipher(ADMIN *a, RPC_STR *t); 1068 UINT StSetServerCipher(ADMIN *a, RPC_STR *t); 1069 UINT StCreateHub(ADMIN *a, RPC_CREATE_HUB *t); 1070 UINT StSetHub(ADMIN *a, RPC_CREATE_HUB *t); 1071 UINT StGetHub(ADMIN *a, RPC_CREATE_HUB *t); 1072 UINT StEnumHub(ADMIN *a, RPC_ENUM_HUB *t); 1073 UINT StDeleteHub(ADMIN *a, RPC_DELETE_HUB *t); 1074 UINT StGetHubRadius(ADMIN *a, RPC_RADIUS *t); 1075 UINT StSetHubRadius(ADMIN *a, RPC_RADIUS *t); 1076 UINT StEnumConnection(ADMIN *a, RPC_ENUM_CONNECTION *t); 1077 UINT StDisconnectConnection(ADMIN *a, RPC_DISCONNECT_CONNECTION *t); 1078 UINT StGetConnectionInfo(ADMIN *a, RPC_CONNECTION_INFO *t); 1079 UINT StSetHubOnline(ADMIN *a, RPC_SET_HUB_ONLINE *t); 1080 UINT StGetHubStatus(ADMIN *a, RPC_HUB_STATUS *t); 1081 UINT StSetHubLog(ADMIN *a, RPC_HUB_LOG *t); 1082 UINT StGetHubLog(ADMIN *a, RPC_HUB_LOG *t); 1083 UINT StAddCa(ADMIN *a, RPC_HUB_ADD_CA *t); 1084 UINT StEnumCa(ADMIN *a, RPC_HUB_ENUM_CA *t); 1085 UINT StGetCa(ADMIN *a, RPC_HUB_GET_CA *t); 1086 UINT StDeleteCa(ADMIN *a, RPC_HUB_DELETE_CA *t); 1087 UINT StCreateLink(ADMIN *a, RPC_CREATE_LINK *t); 1088 UINT StEnumLink(ADMIN *a, RPC_ENUM_LINK *t); 1089 UINT StGetLinkStatus(ADMIN *a, RPC_LINK_STATUS *t); 1090 UINT StSetLinkOnline(ADMIN *a, RPC_LINK *t); 1091 UINT StSetLinkOffline(ADMIN *a, RPC_LINK *t); 1092 UINT StDeleteLink(ADMIN *a, RPC_LINK *t); 1093 UINT StRenameLink(ADMIN *a, RPC_RENAME_LINK *t); 1094 UINT StAddAccess(ADMIN *a, RPC_ADD_ACCESS *t); 1095 UINT StDeleteAccess(ADMIN *a, RPC_DELETE_ACCESS *t); 1096 UINT StEnumAccess(ADMIN *a, RPC_ENUM_ACCESS_LIST *t); 1097 UINT StCreateUser(ADMIN *a, RPC_SET_USER *t); 1098 UINT StSetUser(ADMIN *a, RPC_SET_USER *t); 1099 UINT StGetUser(ADMIN *a, RPC_SET_USER *t); 1100 UINT StDeleteUser(ADMIN *a, RPC_DELETE_USER *t); 1101 UINT StEnumUser(ADMIN *a, RPC_ENUM_USER *t); 1102 UINT StCreateGroup(ADMIN *a, RPC_SET_GROUP *t); 1103 UINT StSetGroup(ADMIN *a, RPC_SET_GROUP *t); 1104 UINT StGetGroup(ADMIN *a, RPC_SET_GROUP *t); 1105 UINT StDeleteGroup(ADMIN *a, RPC_DELETE_USER *t); 1106 UINT StEnumGroup(ADMIN *a, RPC_ENUM_GROUP *t); 1107 UINT StEnumSession(ADMIN *a, RPC_ENUM_SESSION *t); 1108 UINT StGetSessionStatus(ADMIN *a, RPC_SESSION_STATUS *t); 1109 UINT StDeleteSession(ADMIN *a, RPC_DELETE_SESSION *t); 1110 UINT StEnumMacTable(ADMIN *a, RPC_ENUM_MAC_TABLE *t); 1111 UINT StDeleteMacTable(ADMIN *a, RPC_DELETE_TABLE *t); 1112 UINT StEnumIpTable(ADMIN *a, RPC_ENUM_IP_TABLE *t); 1113 UINT StDeleteIpTable(ADMIN *a, RPC_DELETE_TABLE *t); 1114 UINT StGetLink(ADMIN *a, RPC_CREATE_LINK *t); 1115 UINT StSetLink(ADMIN *a, RPC_CREATE_LINK *t); 1116 UINT StSetAccessList(ADMIN *a, RPC_ENUM_ACCESS_LIST *t); 1117 UINT StSetKeep(ADMIN *a, RPC_KEEP *t); 1118 UINT StGetKeep(ADMIN *a, RPC_KEEP *t); 1119 UINT StEnableSecureNAT(ADMIN *a, RPC_HUB *t); 1120 UINT StDisableSecureNAT(ADMIN *a, RPC_HUB *t); 1121 UINT StSetSecureNATOption(ADMIN *a, VH_OPTION *t); 1122 UINT StGetSecureNATOption(ADMIN *a, VH_OPTION *t); 1123 UINT StEnumNAT(ADMIN *a, RPC_ENUM_NAT *t); 1124 UINT StEnumDHCP(ADMIN *a, RPC_ENUM_DHCP *t); 1125 UINT StGetSecureNATStatus(ADMIN *a, RPC_NAT_STATUS *t); 1126 UINT StEnumEthernet(ADMIN *a, RPC_ENUM_ETH *t); 1127 UINT StAddLocalBridge(ADMIN *a, RPC_LOCALBRIDGE *t); 1128 UINT StDeleteLocalBridge(ADMIN *a, RPC_LOCALBRIDGE *t); 1129 UINT StEnumLocalBridge(ADMIN *a, RPC_ENUM_LOCALBRIDGE *t); 1130 UINT StGetBridgeSupport(ADMIN *a, RPC_BRIDGE_SUPPORT *t); 1131 UINT StRebootServer(ADMIN *a, RPC_TEST *t); 1132 UINT StGetCaps(ADMIN *a, CAPSLIST *t); 1133 UINT StGetConfig(ADMIN *a, RPC_CONFIG *t); 1134 UINT StSetConfig(ADMIN *a, RPC_CONFIG *t); 1135 UINT StGetDefaultHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t); 1136 UINT StGetHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t); 1137 UINT StSetHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t); 1138 UINT StGetHubExtOptions(ADMIN *a, RPC_ADMIN_OPTION *t); 1139 UINT StSetHubExtOptions(ADMIN *a, RPC_ADMIN_OPTION *t); 1140 UINT StAddL3Switch(ADMIN *a, RPC_L3SW *t); 1141 UINT StDelL3Switch(ADMIN *a, RPC_L3SW *t); 1142 UINT StEnumL3Switch(ADMIN *a, RPC_ENUM_L3SW *t); 1143 UINT StStartL3Switch(ADMIN *a, RPC_L3SW *t); 1144 UINT StStopL3Switch(ADMIN *a, RPC_L3SW *t); 1145 UINT StAddL3If(ADMIN *a, RPC_L3IF *t); 1146 UINT StDelL3If(ADMIN *a, RPC_L3IF *t); 1147 UINT StEnumL3If(ADMIN *a, RPC_ENUM_L3IF *t); 1148 UINT StAddL3Table(ADMIN *a, RPC_L3TABLE *t); 1149 UINT StDelL3Table(ADMIN *a, RPC_L3TABLE *t); 1150 UINT StEnumL3Table(ADMIN *a, RPC_ENUM_L3TABLE *t); 1151 UINT StEnumCrl(ADMIN *a, RPC_ENUM_CRL *t); 1152 UINT StAddCrl(ADMIN *a, RPC_CRL *t); 1153 UINT StDelCrl(ADMIN *a, RPC_CRL *t); 1154 UINT StGetCrl(ADMIN *a, RPC_CRL *t); 1155 UINT StSetCrl(ADMIN *a, RPC_CRL *t); 1156 UINT StSetAcList(ADMIN *a, RPC_AC_LIST *t); 1157 UINT StGetAcList(ADMIN *a, RPC_AC_LIST *t); 1158 UINT StEnumLogFile(ADMIN *a, RPC_ENUM_LOG_FILE *t); 1159 UINT StReadLogFile(ADMIN *a, RPC_READ_LOG_FILE *t); 1160 UINT StAddLicenseKey(ADMIN *a, RPC_TEST *t); 1161 UINT StDelLicenseKey(ADMIN *a, RPC_TEST *t); 1162 UINT StEnumLicenseKey(ADMIN *a, RPC_ENUM_LICENSE_KEY *t); 1163 UINT StGetLicenseStatus(ADMIN *a, RPC_LICENSE_STATUS *t); 1164 UINT StSetSysLog(ADMIN *a, SYSLOG_SETTING *t); 1165 UINT StGetSysLog(ADMIN *a, SYSLOG_SETTING *t); 1166 UINT StEnumEthVLan(ADMIN *a, RPC_ENUM_ETH_VLAN *t); 1167 UINT StSetEnableEthVLan(ADMIN *a, RPC_TEST *t); 1168 UINT StSetHubMsg(ADMIN *a, RPC_MSG *t); 1169 UINT StGetHubMsg(ADMIN *a, RPC_MSG *t); 1170 UINT StCrash(ADMIN *a, RPC_TEST *t); 1171 UINT StGetAdminMsg(ADMIN *a, RPC_MSG *t); 1172 UINT StFlush(ADMIN *a, RPC_TEST *t); 1173 UINT StDebug(ADMIN *a, RPC_TEST *t); 1174 UINT StSetIPsecServices(ADMIN *a, IPSEC_SERVICES *t); 1175 UINT StGetIPsecServices(ADMIN *a, IPSEC_SERVICES *t); 1176 UINT StAddEtherIpId(ADMIN *a, ETHERIP_ID *t); 1177 UINT StGetEtherIpId(ADMIN *a, ETHERIP_ID *t); 1178 UINT StDeleteEtherIpId(ADMIN *a, ETHERIP_ID *t); 1179 UINT StEnumEtherIpId(ADMIN *a, RPC_ENUM_ETHERIP_ID *t); 1180 UINT StSetOpenVpnSstpConfig(ADMIN *a, OPENVPN_SSTP_CONFIG *t); 1181 UINT StGetOpenVpnSstpConfig(ADMIN *a, OPENVPN_SSTP_CONFIG *t); 1182 UINT StGetDDnsClientStatus(ADMIN *a, DDNS_CLIENT_STATUS *t); 1183 UINT StChangeDDnsClientHostname(ADMIN *a, RPC_TEST *t); 1184 UINT StRegenerateServerCert(ADMIN *a, RPC_TEST *t); 1185 UINT StMakeOpenVpnConfigFile(ADMIN *a, RPC_READ_LOG_FILE *t); 1186 UINT StSetSpecialListener(ADMIN *a, RPC_SPECIAL_LISTENER *t); 1187 UINT StGetSpecialListener(ADMIN *a, RPC_SPECIAL_LISTENER *t); 1188 UINT StGetAzureStatus(ADMIN *a, RPC_AZURE_STATUS *t); 1189 UINT StSetAzureStatus(ADMIN *a, RPC_AZURE_STATUS *t); 1190 UINT StGetDDnsInternetSetting(ADMIN *a, INTERNET_SETTING *t); 1191 UINT StSetDDnsInternetSetting(ADMIN *a, INTERNET_SETTING *t); 1192 UINT StSetVgsConfig(ADMIN *a, VGS_CONFIG *t); 1193 UINT StGetVgsConfig(ADMIN *a, VGS_CONFIG *t); 1194 1195 UINT ScTest(RPC *r, RPC_TEST *t); 1196 UINT ScGetServerInfo(RPC *r, RPC_SERVER_INFO *t); 1197 UINT ScGetServerStatus(RPC *r, RPC_SERVER_STATUS *t); 1198 UINT ScCreateListener(RPC *r, RPC_LISTENER *t); 1199 UINT ScEnumListener(RPC *r, RPC_LISTENER_LIST *t); 1200 UINT ScDeleteListener(RPC *r, RPC_LISTENER *t); 1201 UINT ScEnableListener(RPC *r, RPC_LISTENER *t); 1202 UINT ScSetServerPassword(RPC *r, RPC_SET_PASSWORD *t); 1203 UINT ScSetFarmSetting(RPC *r, RPC_FARM *t); 1204 UINT ScGetFarmSetting(RPC *r, RPC_FARM *t); 1205 UINT ScGetFarmInfo(RPC *r, RPC_FARM_INFO *t); 1206 UINT ScEnumFarmMember(RPC *r, RPC_ENUM_FARM *t); 1207 UINT ScGetFarmConnectionStatus(RPC *r, RPC_FARM_CONNECTION_STATUS *t); 1208 UINT ScSetServerCert(RPC *r, RPC_KEY_PAIR *t); 1209 UINT ScGetServerCert(RPC *r, RPC_KEY_PAIR *t); 1210 UINT ScGetServerCipher(RPC *r, RPC_STR *t); 1211 UINT ScSetServerCipher(RPC *r, RPC_STR *t); 1212 UINT ScCreateHub(RPC *r, RPC_CREATE_HUB *t); 1213 UINT ScSetHub(RPC *r, RPC_CREATE_HUB *t); 1214 UINT ScGetHub(RPC *r, RPC_CREATE_HUB *t); 1215 UINT ScEnumHub(RPC *r, RPC_ENUM_HUB *t); 1216 UINT ScDeleteHub(RPC *r, RPC_DELETE_HUB *t); 1217 UINT ScGetHubRadius(RPC *r, RPC_RADIUS *t); 1218 UINT ScSetHubRadius(RPC *r, RPC_RADIUS *t); 1219 UINT ScEnumConnection(RPC *r, RPC_ENUM_CONNECTION *t); 1220 UINT ScDisconnectConnection(RPC *r, RPC_DISCONNECT_CONNECTION *t); 1221 UINT ScGetConnectionInfo(RPC *r, RPC_CONNECTION_INFO *t); 1222 UINT ScSetHubOnline(RPC *r, RPC_SET_HUB_ONLINE *t); 1223 UINT ScGetHubStatus(RPC *r, RPC_HUB_STATUS *t); 1224 UINT ScSetHubLog(RPC *r, RPC_HUB_LOG *t); 1225 UINT ScGetHubLog(RPC *r, RPC_HUB_LOG *t); 1226 UINT ScAddCa(RPC *r, RPC_HUB_ADD_CA *t); 1227 UINT ScEnumCa(RPC *r, RPC_HUB_ENUM_CA *t); 1228 UINT ScGetCa(RPC *r, RPC_HUB_GET_CA *t); 1229 UINT ScDeleteCa(RPC *r, RPC_HUB_DELETE_CA *t); 1230 UINT ScCreateLink(RPC *r, RPC_CREATE_LINK *t); 1231 UINT ScEnumLink(RPC *r, RPC_ENUM_LINK *t); 1232 UINT ScGetLinkStatus(RPC *r, RPC_LINK_STATUS *t); 1233 UINT ScSetLinkOnline(RPC *r, RPC_LINK *t); 1234 UINT ScSetLinkOffline(RPC *r, RPC_LINK *t); 1235 UINT ScDeleteLink(RPC *r, RPC_LINK *t); 1236 UINT ScRenameLink(RPC *r, RPC_RENAME_LINK *t); 1237 UINT ScAddAccess(RPC *r, RPC_ADD_ACCESS *t); 1238 UINT ScDeleteAccess(RPC *r, RPC_DELETE_ACCESS *t); 1239 UINT ScEnumAccess(RPC *r, RPC_ENUM_ACCESS_LIST *t); 1240 UINT ScCreateUser(RPC *r, RPC_SET_USER *t); 1241 UINT ScSetUser(RPC *r, RPC_SET_USER *t); 1242 UINT ScGetUser(RPC *r, RPC_SET_USER *t); 1243 UINT ScDeleteUser(RPC *r, RPC_DELETE_USER *t); 1244 UINT ScEnumUser(RPC *r, RPC_ENUM_USER *t); 1245 UINT ScCreateGroup(RPC *r, RPC_SET_GROUP *t); 1246 UINT ScSetGroup(RPC *r, RPC_SET_GROUP *t); 1247 UINT ScGetGroup(RPC *r, RPC_SET_GROUP *t); 1248 UINT ScDeleteGroup(RPC *r, RPC_DELETE_USER *t); 1249 UINT ScEnumGroup(RPC *r, RPC_ENUM_GROUP *t); 1250 UINT ScEnumSession(RPC *r, RPC_ENUM_SESSION *t); 1251 UINT ScGetSessionStatus(RPC *r, RPC_SESSION_STATUS *t); 1252 UINT ScDeleteSession(RPC *r, RPC_DELETE_SESSION *t); 1253 UINT ScEnumMacTable(RPC *r, RPC_ENUM_MAC_TABLE *t); 1254 UINT ScDeleteMacTable(RPC *r, RPC_DELETE_TABLE *t); 1255 UINT ScEnumIpTable(RPC *r, RPC_ENUM_IP_TABLE *t); 1256 UINT ScDeleteIpTable(RPC *r, RPC_DELETE_TABLE *t); 1257 UINT ScGetLink(RPC *a, RPC_CREATE_LINK *t); 1258 UINT ScSetLink(RPC *a, RPC_CREATE_LINK *t); 1259 UINT ScSetAccessList(RPC *r, RPC_ENUM_ACCESS_LIST *t); 1260 UINT ScSetKeep(RPC *r, RPC_KEEP *t); 1261 UINT ScGetKeep(RPC *r, RPC_KEEP *t); 1262 UINT ScEnableSecureNAT(RPC *r, RPC_HUB *t); 1263 UINT ScDisableSecureNAT(RPC *r, RPC_HUB *t); 1264 UINT ScSetSecureNATOption(RPC *r, VH_OPTION *t); 1265 UINT ScGetSecureNATOption(RPC *r, VH_OPTION *t); 1266 UINT ScEnumNAT(RPC *r, RPC_ENUM_NAT *t); 1267 UINT ScEnumDHCP(RPC *r, RPC_ENUM_DHCP *t); 1268 UINT ScGetSecureNATStatus(RPC *r, RPC_NAT_STATUS *t); 1269 UINT ScEnumEthernet(RPC *r, RPC_ENUM_ETH *t); 1270 UINT ScAddLocalBridge(RPC *r, RPC_LOCALBRIDGE *t); 1271 UINT ScDeleteLocalBridge(RPC *r, RPC_LOCALBRIDGE *t); 1272 UINT ScEnumLocalBridge(RPC *r, RPC_ENUM_LOCALBRIDGE *t); 1273 UINT ScGetBridgeSupport(RPC *r, RPC_BRIDGE_SUPPORT *t); 1274 UINT ScRebootServer(RPC *r, RPC_TEST *t); 1275 UINT ScGetCaps(RPC *r, CAPSLIST *t); 1276 UINT ScGetConfig(RPC *r, RPC_CONFIG *t); 1277 UINT ScSetConfig(RPC *r, RPC_CONFIG *t); 1278 UINT ScGetDefaultHubAdminOptions(RPC *r, RPC_ADMIN_OPTION *t); 1279 UINT ScGetHubAdminOptions(RPC *r, RPC_ADMIN_OPTION *t); 1280 UINT ScSetHubAdminOptions(RPC *r, RPC_ADMIN_OPTION *t); 1281 UINT ScGetHubExtOptions(RPC *r, RPC_ADMIN_OPTION *t); 1282 UINT ScSetHubExtOptions(RPC *r, RPC_ADMIN_OPTION *t); 1283 UINT ScAddL3Switch(RPC *r, RPC_L3SW *t); 1284 UINT ScDelL3Switch(RPC *r, RPC_L3SW *t); 1285 UINT ScEnumL3Switch(RPC *r, RPC_ENUM_L3SW *t); 1286 UINT ScStartL3Switch(RPC *r, RPC_L3SW *t); 1287 UINT ScStopL3Switch(RPC *r, RPC_L3SW *t); 1288 UINT ScAddL3If(RPC *r, RPC_L3IF *t); 1289 UINT ScDelL3If(RPC *r, RPC_L3IF *t); 1290 UINT ScEnumL3If(RPC *r, RPC_ENUM_L3IF *t); 1291 UINT ScAddL3Table(RPC *r, RPC_L3TABLE *t); 1292 UINT ScDelL3Table(RPC *r, RPC_L3TABLE *t); 1293 UINT ScEnumL3Table(RPC *r, RPC_ENUM_L3TABLE *t); 1294 UINT ScEnumCrl(RPC *r, RPC_ENUM_CRL *t); 1295 UINT ScAddCrl(RPC *r, RPC_CRL *t); 1296 UINT ScDelCrl(RPC *r, RPC_CRL *t); 1297 UINT ScGetCrl(RPC *r, RPC_CRL *t); 1298 UINT ScSetCrl(RPC *r, RPC_CRL *t); 1299 UINT ScSetAcList(RPC *r, RPC_AC_LIST *t); 1300 UINT ScGetAcList(RPC *r, RPC_AC_LIST *t); 1301 UINT ScEnumLogFile(RPC *r, RPC_ENUM_LOG_FILE *t); 1302 UINT ScReadLogFile(RPC *r, RPC_READ_LOG_FILE *t); 1303 UINT ScAddLicenseKey(RPC *r, RPC_TEST *t); 1304 UINT ScDelLicenseKey(RPC *r, RPC_TEST *t); 1305 UINT ScEnumLicenseKey(RPC *r, RPC_ENUM_LICENSE_KEY *t); 1306 UINT ScGetLicenseStatus(RPC *r, RPC_LICENSE_STATUS *t); 1307 UINT ScSetSysLog(RPC *r, SYSLOG_SETTING *t); 1308 UINT ScGetSysLog(RPC *r, SYSLOG_SETTING *t); 1309 UINT ScEnumEthVLan(RPC *r, RPC_ENUM_ETH_VLAN *t); 1310 UINT ScSetEnableEthVLan(RPC *r, RPC_TEST *t); 1311 UINT ScSetHubMsg(RPC *r, RPC_MSG *t); 1312 UINT ScGetHubMsg(RPC *r, RPC_MSG *t); 1313 UINT ScCrash(RPC *r, RPC_TEST *t); 1314 UINT ScGetAdminMsg(RPC *r, RPC_MSG *t); 1315 UINT ScFlush(RPC *r, RPC_TEST *t); 1316 UINT ScDebug(RPC *r, RPC_TEST *t); 1317 UINT ScSetIPsecServices(RPC *r, IPSEC_SERVICES *t); 1318 UINT ScGetIPsecServices(RPC *r, IPSEC_SERVICES *t); 1319 UINT ScAddEtherIpId(RPC *r, ETHERIP_ID *t); 1320 UINT ScGetEtherIpId(RPC *r, ETHERIP_ID *t); 1321 UINT ScDeleteEtherIpId(RPC *r, ETHERIP_ID *t); 1322 UINT ScEnumEtherIpId(RPC *r, RPC_ENUM_ETHERIP_ID *t); 1323 UINT ScSetOpenVpnSstpConfig(RPC *r, OPENVPN_SSTP_CONFIG *t); 1324 UINT ScGetOpenVpnSstpConfig(RPC *r, OPENVPN_SSTP_CONFIG *t); 1325 UINT ScGetDDnsClientStatus(RPC *r, DDNS_CLIENT_STATUS *t); 1326 UINT ScChangeDDnsClientHostname(RPC *r, RPC_TEST *t); 1327 UINT ScRegenerateServerCert(RPC *r, RPC_TEST *t); 1328 UINT ScMakeOpenVpnConfigFile(RPC *r, RPC_READ_LOG_FILE *t); 1329 UINT ScSetSpecialListener(RPC *r, RPC_SPECIAL_LISTENER *t); 1330 UINT ScGetSpecialListener(RPC *r, RPC_SPECIAL_LISTENER *t); 1331 UINT ScGetAzureStatus(RPC *r, RPC_AZURE_STATUS *t); 1332 UINT ScSetAzureStatus(RPC *r, RPC_AZURE_STATUS *t); 1333 UINT ScGetDDnsInternetSetting(RPC *r, INTERNET_SETTING *t); 1334 UINT ScSetDDnsInternetSetting(RPC *r, INTERNET_SETTING *t); 1335 UINT ScSetVgsConfig(RPC *r, VGS_CONFIG *t); 1336 UINT ScGetVgsConfig(RPC *r, VGS_CONFIG *t); 1337 1338 void InRpcTest(RPC_TEST *t, PACK *p); 1339 void OutRpcTest(PACK *p, RPC_TEST *t); 1340 void FreeRpcTest(RPC_TEST *t); 1341 void InRpcServerInfo(RPC_SERVER_INFO *t, PACK *p); 1342 void OutRpcServerInfo(PACK *p, RPC_SERVER_INFO *t); 1343 void FreeRpcServerInfo(RPC_SERVER_INFO *t); 1344 void InRpcServerStatus(RPC_SERVER_STATUS *t, PACK *p); 1345 void OutRpcServerStatus(PACK *p, RPC_SERVER_STATUS *t); 1346 void InRpcListener(RPC_LISTENER *t, PACK *p); 1347 void OutRpcListener(PACK *p, RPC_LISTENER *t); 1348 void InRpcListenerList(RPC_LISTENER_LIST *t, PACK *p); 1349 void OutRpcListenerList(PACK *p, RPC_LISTENER_LIST *t); 1350 void FreeRpcListenerList(RPC_LISTENER_LIST *t); 1351 void InRpcStr(RPC_STR *t, PACK *p); 1352 void OutRpcStr(PACK *p, RPC_STR *t); 1353 void FreeRpcStr(RPC_STR *t); 1354 void InRpcSetPassword(RPC_SET_PASSWORD *t, PACK *p); 1355 void OutRpcSetPassword(PACK *p, RPC_SET_PASSWORD *t); 1356 void InRpcFarm(RPC_FARM *t, PACK *p); 1357 void OutRpcFarm(PACK *p, RPC_FARM *t); 1358 void FreeRpcFarm(RPC_FARM *t); 1359 void InRpcFarmHub(RPC_FARM_HUB *t, PACK *p); 1360 void OutRpcFarmHub(PACK *p, RPC_FARM_HUB *t); 1361 void InRpcFarmInfo(RPC_FARM_INFO *t, PACK *p); 1362 void OutRpcFarmInfo(PACK *p, RPC_FARM_INFO *t); 1363 void FreeRpcFarmInfo(RPC_FARM_INFO *t); 1364 void InRpcEnumFarm(RPC_ENUM_FARM *t, PACK *p); 1365 void OutRpcEnumFarm(PACK *p, RPC_ENUM_FARM *t); 1366 void FreeRpcEnumFarm(RPC_ENUM_FARM *t); 1367 void InRpcFarmConnectionStatus(RPC_FARM_CONNECTION_STATUS *t, PACK *p); 1368 void OutRpcFarmConnectionStatus(PACK *p, RPC_FARM_CONNECTION_STATUS *t); 1369 void InRpcHubOption(RPC_HUB_OPTION *t, PACK *p); 1370 void OutRpcHubOption(PACK *p, RPC_HUB_OPTION *t); 1371 void InRpcRadius(RPC_RADIUS *t, PACK *p); 1372 void OutRpcRadius(PACK *p, RPC_RADIUS *t); 1373 void InRpcHub(RPC_HUB *t, PACK *p); 1374 void OutRpcHub(PACK *p, RPC_HUB *t); 1375 void InRpcCreateHub(RPC_CREATE_HUB *t, PACK *p); 1376 void OutRpcCreateHub(PACK *p, RPC_CREATE_HUB *t); 1377 void InRpcEnumHub(RPC_ENUM_HUB *t, PACK *p); 1378 void OutRpcEnumHub(PACK *p, RPC_ENUM_HUB *t); 1379 void FreeRpcEnumHub(RPC_ENUM_HUB *t); 1380 void InRpcDeleteHub(RPC_DELETE_HUB *t, PACK *p); 1381 void OutRpcDeleteHub(PACK *p, RPC_DELETE_HUB *t); 1382 void InRpcEnumConnection(RPC_ENUM_CONNECTION *t, PACK *p); 1383 void OutRpcEnumConnection(PACK *p, RPC_ENUM_CONNECTION *t); 1384 void FreeRpcEnumConnetion(RPC_ENUM_CONNECTION *t); 1385 void InRpcDisconnectConnection(RPC_DISCONNECT_CONNECTION *t, PACK *p); 1386 void OutRpcDisconnectConnection(PACK *p, RPC_DISCONNECT_CONNECTION *t); 1387 void InRpcConnectionInfo(RPC_CONNECTION_INFO *t, PACK *p); 1388 void OutRpcConnectionInfo(PACK *p, RPC_CONNECTION_INFO *t); 1389 void InRpcSetHubOnline(RPC_SET_HUB_ONLINE *t, PACK *p); 1390 void OutRpcSetHubOnline(PACK *p, RPC_SET_HUB_ONLINE *t); 1391 void InRpcHubStatus(RPC_HUB_STATUS *t, PACK *p); 1392 void OutRpcHubStatus(PACK *p, RPC_HUB_STATUS *t); 1393 void InRpcHubLog(RPC_HUB_LOG *t, PACK *p); 1394 void OutRpcHubLog(PACK *p, RPC_HUB_LOG *t); 1395 void InRpcHubAddCa(RPC_HUB_ADD_CA *t, PACK *p); 1396 void OutRpcHubAddCa(PACK *p, RPC_HUB_ADD_CA *t); 1397 void FreeRpcHubAddCa(RPC_HUB_ADD_CA *t); 1398 void InRpcHubEnumCa(RPC_HUB_ENUM_CA *t, PACK *p); 1399 void OutRpcHubEnumCa(PACK *p, RPC_HUB_ENUM_CA *t); 1400 void FreeRpcHubEnumCa(RPC_HUB_ENUM_CA *t); 1401 void InRpcHubGetCa(RPC_HUB_GET_CA *t, PACK *p); 1402 void OutRpcHubGetCa(PACK *p, RPC_HUB_GET_CA *t); 1403 void FreeRpcHubGetCa(RPC_HUB_GET_CA *t); 1404 void InRpcHubDeleteCa(RPC_HUB_DELETE_CA *t, PACK *p); 1405 void OutRpcHubDeleteCa(PACK *p, RPC_HUB_DELETE_CA *t); 1406 void InRpcCreateLink(RPC_CREATE_LINK *t, PACK *p); 1407 void OutRpcCreateLink(PACK *p, RPC_CREATE_LINK *t); 1408 void FreeRpcCreateLink(RPC_CREATE_LINK *t); 1409 void InRpcEnumLink(RPC_ENUM_LINK *t, PACK *p); 1410 void OutRpcEnumLink(PACK *p, RPC_ENUM_LINK *t); 1411 void FreeRpcEnumLink(RPC_ENUM_LINK *t); 1412 void InRpcLinkStatus(RPC_LINK_STATUS *t, PACK *p); 1413 void OutRpcLinkStatus(PACK *p, RPC_LINK_STATUS *t); 1414 void FreeRpcLinkStatus(RPC_LINK_STATUS *t); 1415 void InRpcLink(RPC_LINK *t, PACK *p); 1416 void OutRpcLink(PACK *p, RPC_LINK *t); 1417 void InRpcAccessEx(ACCESS *a, PACK *p, UINT index); 1418 void InRpcAccess(ACCESS *a, PACK *p); 1419 void OutRpcAccessEx(PACK *p, ACCESS *a, UINT index, UINT total); 1420 void OutRpcAccess(PACK *p, ACCESS *a); 1421 void InRpcEnumAccessList(RPC_ENUM_ACCESS_LIST *a, PACK *p); 1422 void OutRpcEnumAccessList(PACK *p, RPC_ENUM_ACCESS_LIST *a); 1423 void FreeRpcEnumAccessList(RPC_ENUM_ACCESS_LIST *a); 1424 void *InRpcAuthData(PACK *p, UINT *authtype, char *username); 1425 void OutRpcAuthData(PACK *p, void *authdata, UINT authtype); 1426 void FreeRpcAuthData(void *authdata, UINT authtype); 1427 void InRpcSetUser(RPC_SET_USER *t, PACK *p); 1428 void OutRpcSetUser(PACK *p, RPC_SET_USER *t); 1429 void FreeRpcSetUser(RPC_SET_USER *t); 1430 void InRpcEnumUser(RPC_ENUM_USER *t, PACK *p); 1431 void OutRpcEnumUser(PACK *p, RPC_ENUM_USER *t); 1432 void FreeRpcEnumUser(RPC_ENUM_USER *t); 1433 void InRpcSetGroup(RPC_SET_GROUP *t, PACK *p); 1434 void OutRpcSetGroup(PACK *p, RPC_SET_GROUP *t); 1435 void InRpcEnumGroup(RPC_ENUM_GROUP *t, PACK *p); 1436 void OutRpcEnumGroup(PACK *p, RPC_ENUM_GROUP *t); 1437 void FreeRpcEnumGroup(RPC_ENUM_GROUP *t); 1438 void InRpcDeleteUser(RPC_DELETE_USER *t, PACK *p); 1439 void OutRpcDeleteUser(PACK *p, RPC_DELETE_USER *t); 1440 void InRpcEnumSession(RPC_ENUM_SESSION *t, PACK *p); 1441 void OutRpcEnumSession(PACK *p, RPC_ENUM_SESSION *t); 1442 void FreeRpcEnumSession(RPC_ENUM_SESSION *t); 1443 void InRpcNodeInfo(NODE_INFO *t, PACK *p); 1444 void OutRpcNodeInfo(PACK *p, NODE_INFO *t); 1445 void InRpcSessionStatus(RPC_SESSION_STATUS *t, PACK *p); 1446 void OutRpcSessionStatus(PACK *p, RPC_SESSION_STATUS *t); 1447 void FreeRpcSessionStatus(RPC_SESSION_STATUS *t); 1448 void InRpcDeleteSession(RPC_DELETE_SESSION *t, PACK *p); 1449 void OutRpcDeleteSession(PACK *p, RPC_DELETE_SESSION *t); 1450 void InRpcEnumMacTable(RPC_ENUM_MAC_TABLE *t, PACK *p); 1451 void OutRpcEnumMacTable(PACK *p, RPC_ENUM_MAC_TABLE *t); 1452 void FreeRpcEnumMacTable(RPC_ENUM_MAC_TABLE *t); 1453 void InRpcEnumIpTable(RPC_ENUM_IP_TABLE *t, PACK *p); 1454 void OutRpcEnumIpTable(PACK *p, RPC_ENUM_IP_TABLE *t); 1455 void FreeRpcEnumIpTable(RPC_ENUM_IP_TABLE *t); 1456 void InRpcDeleteTable(RPC_DELETE_TABLE *t, PACK *p); 1457 void OutRpcDeleteTable(PACK *p, RPC_DELETE_TABLE *t); 1458 void InRpcMemInfo(MEMINFO *t, PACK *p); 1459 void OutRpcMemInfo(PACK *p, MEMINFO *t); 1460 void InRpcKeyPair(RPC_KEY_PAIR *t, PACK *p); 1461 void OutRpcKeyPair(PACK *p, RPC_KEY_PAIR *t); 1462 void FreeRpcKeyPair(RPC_KEY_PAIR *t); 1463 void InRpcAddAccess(RPC_ADD_ACCESS *t, PACK *p); 1464 void OutRpcAddAccess(PACK *p, RPC_ADD_ACCESS *t); 1465 void InRpcDeleteAccess(RPC_DELETE_ACCESS *t, PACK *p); 1466 void OutRpcDeleteAccess(PACK *p, RPC_DELETE_ACCESS *t); 1467 void FreeRpcSetGroup(RPC_SET_GROUP *t); 1468 void AdjoinRpcEnumSession(RPC_ENUM_SESSION *dest, RPC_ENUM_SESSION *src); 1469 void AdjoinRpcEnumMacTable(RPC_ENUM_MAC_TABLE *dest, RPC_ENUM_MAC_TABLE *src); 1470 void AdjoinRpcEnumIpTable(RPC_ENUM_IP_TABLE *dest, RPC_ENUM_IP_TABLE *src); 1471 void InRpcKeep(RPC_KEEP *t, PACK *p); 1472 void OutRpcKeep(PACK *p, RPC_KEEP *t); 1473 void InRpcOsInfo(OS_INFO *t, PACK *p); 1474 void OutRpcOsInfo(PACK *p, OS_INFO *t); 1475 void FreeRpcOsInfo(OS_INFO *t); 1476 void InRpcEnumEth(RPC_ENUM_ETH *t, PACK *p); 1477 void OutRpcEnumEth(PACK *p, RPC_ENUM_ETH *t); 1478 void FreeRpcEnumEth(RPC_ENUM_ETH *t); 1479 void InRpcLocalBridge(RPC_LOCALBRIDGE *t, PACK *p); 1480 void OutRpcLocalBridge(PACK *p, RPC_LOCALBRIDGE *t); 1481 void InRpcEnumLocalBridge(RPC_ENUM_LOCALBRIDGE *t, PACK *p); 1482 void OutRpcEnumLocalBridge(PACK *p, RPC_ENUM_LOCALBRIDGE *t); 1483 void FreeRpcEnumLocalBridge(RPC_ENUM_LOCALBRIDGE *t); 1484 void InRpcBridgeSupport(RPC_BRIDGE_SUPPORT *t, PACK *p); 1485 void OutRpcBridgeSupport(PACK *p, RPC_BRIDGE_SUPPORT *t); 1486 void InRpcConfig(RPC_CONFIG *t, PACK *p); 1487 void OutRpcConfig(PACK *p, RPC_CONFIG *t); 1488 void FreeRpcConfig(RPC_CONFIG *t); 1489 void InRpcAdminOption(RPC_ADMIN_OPTION *t, PACK *p); 1490 void OutRpcAdminOption(PACK *p, RPC_ADMIN_OPTION *t); 1491 void FreeRpcAdminOption(RPC_ADMIN_OPTION *t); 1492 void InRpcEnumL3Table(RPC_ENUM_L3TABLE *t, PACK *p); 1493 void OutRpcEnumL3Table(PACK *p, RPC_ENUM_L3TABLE *t); 1494 void FreeRpcEnumL3Table(RPC_ENUM_L3TABLE *t); 1495 void InRpcL3Table(RPC_L3TABLE *t, PACK *p); 1496 void OutRpcL3Table(PACK *p, RPC_L3TABLE *t); 1497 void InRpcEnumL3If(RPC_ENUM_L3IF *t, PACK *p); 1498 void OutRpcEnumL3If(PACK *p, RPC_ENUM_L3IF *t); 1499 void FreeRpcEnumL3If(RPC_ENUM_L3IF *t); 1500 void InRpcL3If(RPC_L3IF *t, PACK *p); 1501 void OutRpcL3If(PACK *p, RPC_L3IF *t); 1502 void InRpcL3Sw(RPC_L3SW *t, PACK *p); 1503 void OutRpcL3Sw(PACK *p, RPC_L3SW *t); 1504 void InRpcEnumL3Sw(RPC_ENUM_L3SW *t, PACK *p); 1505 void OutRpcEnumL3Sw(PACK *p, RPC_ENUM_L3SW *t); 1506 void FreeRpcEnumL3Sw(RPC_ENUM_L3SW *t); 1507 void InRpcCrl(RPC_CRL *t, PACK *p); 1508 void OutRpcCrl(PACK *p, RPC_CRL *t); 1509 void FreeRpcCrl(RPC_CRL *t); 1510 void InRpcEnumCrl(RPC_ENUM_CRL *t, PACK *p); 1511 void OutRpcEnumCrl(PACK *p, RPC_ENUM_CRL *t); 1512 void FreeRpcEnumCrl(RPC_ENUM_CRL *t); 1513 void InRpcInt(RPC_INT *t, PACK *p); 1514 void OutRpcInt(PACK *p, RPC_INT *t); 1515 void InRpcAcList(RPC_AC_LIST *t, PACK *p); 1516 void OutRpcAcList(PACK *p, RPC_AC_LIST *t); 1517 void FreeRpcAcList(RPC_AC_LIST *t); 1518 void InRpcEnumLogFile(RPC_ENUM_LOG_FILE *t, PACK *p); 1519 void OutRpcEnumLogFile(PACK *p, RPC_ENUM_LOG_FILE *t); 1520 void FreeRpcEnumLogFile(RPC_ENUM_LOG_FILE *t); 1521 void AdjoinRpcEnumLogFile(RPC_ENUM_LOG_FILE *t, RPC_ENUM_LOG_FILE *src); 1522 void InRpcReadLogFile(RPC_READ_LOG_FILE *t, PACK *p); 1523 void OutRpcReadLogFile(PACK *p, RPC_READ_LOG_FILE *t); 1524 void FreeRpcReadLogFile(RPC_READ_LOG_FILE *t); 1525 void InRpcRenameLink(RPC_RENAME_LINK *t, PACK *p); 1526 void OutRpcRenameLink(PACK *p, RPC_RENAME_LINK *t); 1527 void InRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY *t, PACK *p); 1528 void OutRpcEnumLicenseKey(PACK *p, RPC_ENUM_LICENSE_KEY *t); 1529 void FreeRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY *t); 1530 void InRpcLicenseStatus(RPC_LICENSE_STATUS *t, PACK *p); 1531 void OutRpcLicenseStatus(PACK *p, RPC_LICENSE_STATUS *t); 1532 void InRpcEnumEthVLan(RPC_ENUM_ETH_VLAN *t, PACK *p); 1533 void OutRpcEnumEthVLan(PACK *p, RPC_ENUM_ETH_VLAN *t); 1534 void FreeRpcEnumEthVLan(RPC_ENUM_ETH_VLAN *t); 1535 void InRpcMsg(RPC_MSG *t, PACK *p); 1536 void OutRpcMsg(PACK *p, RPC_MSG *t); 1537 void FreeRpcMsg(RPC_MSG *t); 1538 void InRpcWinVer(RPC_WINVER *t, PACK *p); 1539 void OutRpcWinVer(PACK *p, RPC_WINVER *t); 1540 void InIPsecServices(IPSEC_SERVICES *t, PACK *p); 1541 void OutIPsecServices(PACK *p, IPSEC_SERVICES *t); 1542 void InRpcEnumEtherIpId(RPC_ENUM_ETHERIP_ID *t, PACK *p); 1543 void OutRpcEnumEtherIpId(PACK *p, RPC_ENUM_ETHERIP_ID *t); 1544 void FreeRpcEnumEtherIpId(RPC_ENUM_ETHERIP_ID *t); 1545 void InEtherIpId(ETHERIP_ID *t, PACK *p); 1546 void OutEtherIpId(PACK *p, ETHERIP_ID *t); 1547 void InOpenVpnSstpConfig(OPENVPN_SSTP_CONFIG *t, PACK *p); 1548 void OutOpenVpnSstpConfig(PACK *p, OPENVPN_SSTP_CONFIG *t); 1549 void InDDnsClientStatus(DDNS_CLIENT_STATUS *t, PACK *p); 1550 void OutDDnsClientStatus(PACK *p, DDNS_CLIENT_STATUS *t); 1551 void InRpcSpecialListener(RPC_SPECIAL_LISTENER *t, PACK *p); 1552 void OutRpcSpecialListener(PACK *p, RPC_SPECIAL_LISTENER *t); 1553 void InRpcAzureStatus(RPC_AZURE_STATUS *t, PACK *p); 1554 void OutRpcAzureStatus(PACK *p, RPC_AZURE_STATUS *t); 1555 void InRpcInternetSetting(INTERNET_SETTING *t, PACK *p); 1556 void OutRpcInternetSetting(PACK *p, INTERNET_SETTING *t); 1557 1558 #endif // ADMIN_H 1559 1560 1561