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 // NM.c
103 // VPN User-mode Router Manager for Win32
104
105 #include <GlobalConst.h>
106
107 #ifdef WIN32
108
109 #define SM_C
110 #define CM_C
111 #define NM_C
112
113 #define _WIN32_WINNT 0x0502
114 #define WINVER 0x0502
115 #include <winsock2.h>
116 #include <windows.h>
117 #include <wincrypt.h>
118 #include <wininet.h>
119 #include <shlobj.h>
120 #include <commctrl.h>
121 #include <Dbghelp.h>
122 #include <stdio.h>
123 #include <stdlib.h>
124 #include <string.h>
125 #include <wchar.h>
126 #include <stdarg.h>
127 #include <time.h>
128 #include <errno.h>
129 #include <Mayaqua/Mayaqua.h>
130 #include <Cedar/Cedar.h>
131 #include "CMInner.h"
132 #include "SMInner.h"
133 #include "NMInner.h"
134 #include "EMInner.h"
135 #include "../PenCore/resource.h"
136
137 // Global variable
138 static NM *nm = NULL;
139
140 // Dialog proc for the push routing option
NmEditPushRouteProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)141 UINT NmEditPushRouteProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
142 {
143 SM_HUB *r = (SM_HUB *)param;
144 char *str = NULL;
145 // Validate arguments
146 if (hWnd == NULL)
147 {
148 return 0;
149 }
150
151 switch (msg)
152 {
153 case WM_INITDIALOG:
154 SetTextA(hWnd, E_TEXT, r->CurrentPushRouteStr);
155 Focus(hWnd, E_TEXT);
156
157 SetIcon(hWnd, 0, ICO_PROTOCOL);
158 break;
159
160 case WM_COMMAND:
161 switch (wParam)
162 {
163 case IDOK:
164 str = GetTextA(hWnd, E_TEXT);
165 if (str != NULL)
166 {
167 bool ok = true;
168
169 if (CheckClasslessRouteTableStr(str) == false)
170 {
171 if (MsgBox(hWnd, MB_ICONWARNING | MB_OKCANCEL | MB_DEFBUTTON2, _UU("NM_PUSH_ROUTE_WARNING")) == IDCANCEL)
172 {
173 ok = false;
174 }
175 }
176
177 if (ok)
178 {
179 if (IsEmptyStr(str) == false)
180 {
181 if (GetCapsBool(r->p->CapsList, "b_suppport_push_route") == false)
182 {
183 MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("ERR_147"));
184 }
185 }
186
187 StrCpy(r->CurrentPushRouteStr, sizeof(r->CurrentPushRouteStr), str);
188
189 EndDialog(hWnd, 1);
190 }
191
192 Free(str);
193 }
194 break;
195
196 case IDCANCEL:
197 Close(hWnd);
198 break;
199 }
200 break;
201
202 case WM_CLOSE:
203 EndDialog(hWnd, 0);
204 break;
205 }
206
207 return 0;
208 }
209
210 // Edit dialog for the push routing option
NmEditPushRoute(HWND hWnd,SM_HUB * r)211 bool NmEditPushRoute(HWND hWnd, SM_HUB *r)
212 {
213 // Validate arguments
214 if (r == NULL)
215 {
216 return false;
217 }
218
219 return Dialog(hWnd, D_NM_PUSH, NmEditPushRouteProc, r);
220 }
221
222 // Change Password dialog
NmChangePasswordProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)223 UINT NmChangePasswordProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
224 {
225 RPC *r = (RPC *)param;
226 char tmp1[MAX_SIZE];
227 char tmp2[MAX_SIZE];
228 RPC_SET_PASSWORD t;
229 // Validate arguments
230 if (hWnd == NULL)
231 {
232 return 0;
233 }
234
235 switch (msg)
236 {
237 case WM_INITDIALOG:
238 FormatText(hWnd, 0, r->Sock->RemoteHostname);
239 FormatText(hWnd, S_TITLE, r->Sock->RemoteHostname);
240 break;
241
242 case WM_COMMAND:
243 GetTxtA(hWnd, E_PASSWORD1, tmp1, sizeof(tmp1));
244 GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
245 switch (LOWORD(wParam))
246 {
247 case E_PASSWORD1:
248 case E_PASSWORD2:
249 SetEnable(hWnd, IDOK, StrCmp(tmp1, tmp2) == 0);
250 break;
251 }
252
253 switch (wParam)
254 {
255 case IDOK:
256 Zero(&t, sizeof(t));
257 Hash(t.HashedPassword, tmp1, StrLen(tmp1), true);
258
259 if (CALL(hWnd, NcSetPassword(r, &t)))
260 {
261 MsgBox(hWnd, MB_ICONINFORMATION, _UU("NM_PASSWORD_MSG"));
262 EndDialog(hWnd, true);
263 }
264 break;
265
266 case IDCANCEL:
267 Close(hWnd);
268 break;
269 }
270 break;
271
272 case WM_CLOSE:
273 EndDialog(hWnd, false);
274 break;
275 }
276
277 return 0;
278 }
279
280 // Change the password
NmChangePassword(HWND hWnd,RPC * r)281 void NmChangePassword(HWND hWnd, RPC *r)
282 {
283 // Validate arguments
284 if (hWnd == NULL || r == NULL)
285 {
286 return;
287 }
288
289 Dialog(hWnd, D_NM_CHANGE_PASSWORD, NmChangePasswordProc, r);
290 }
291
292 // DHCP enumeration initialization
NmDhcpInit(HWND hWnd,SM_HUB * r)293 void NmDhcpInit(HWND hWnd, SM_HUB *r)
294 {
295 // Validate arguments
296 if (hWnd == NULL || r == NULL)
297 {
298 return;
299 }
300
301 SetIcon(hWnd, 0, ICO_INTERNET);
302
303 LvInit(hWnd, L_TABLE);
304 LvInsertColumn(hWnd, L_TABLE, 0, _UU("DHCP_DHCP_ID"), 50);
305 LvInsertColumn(hWnd, L_TABLE, 1, _UU("DHCP_LEASED_TIME"), 200);
306 LvInsertColumn(hWnd, L_TABLE, 2, _UU("DHCP_EXPIRE_TIME"), 200);
307 LvInsertColumn(hWnd, L_TABLE, 3, _UU("DHCP_MAC_ADDRESS"), 130);
308 LvInsertColumn(hWnd, L_TABLE, 4, _UU("DHCP_IP_ADDRESS"), 100);
309 LvInsertColumn(hWnd, L_TABLE, 5, _UU("DHCP_HOSTNAME"), 150);
310
311 NmDhcpRefresh(hWnd, r);
312 }
313
314 // DHCP enumeration
NmDhcpRefresh(HWND hWnd,SM_HUB * r)315 void NmDhcpRefresh(HWND hWnd, SM_HUB *r)
316 {
317 LVB *b;
318 RPC_ENUM_DHCP t;
319 UINT i;
320 // Validate arguments
321 if (hWnd == NULL || r == NULL)
322 {
323 Close(hWnd);
324 return;
325 }
326
327 Zero(&t, sizeof(t));
328
329 StrCpy(t.HubName, sizeof(t.HubName), r->HubName);
330
331 if (CALL(hWnd, ScEnumDHCP(r->Rpc, &t)) == false)
332 {
333 return;
334 }
335
336 b = LvInsertStart();
337
338 for (i = 0;i < t.NumItem;i++)
339 {
340 RPC_ENUM_DHCP_ITEM *e = &t.Items[i];
341 wchar_t tmp0[MAX_SIZE];
342 wchar_t tmp1[MAX_SIZE];
343 wchar_t tmp2[MAX_SIZE];
344 wchar_t tmp3[MAX_SIZE];
345 wchar_t tmp4[MAX_SIZE];
346 wchar_t tmp5[MAX_SIZE];
347 char str[MAX_SIZE];
348
349 // ID
350 UniToStru(tmp0, e->Id);
351
352 // Time
353 GetDateTimeStrEx64(tmp1, sizeof(tmp1), SystemToLocal64(e->LeasedTime), NULL);
354 GetDateTimeStrEx64(tmp2, sizeof(tmp2), SystemToLocal64(e->ExpireTime), NULL);
355
356 MacToStr(str, sizeof(str), e->MacAddress);
357 StrToUni(tmp3, sizeof(tmp3), str);
358
359 IPToStr32(str, sizeof(str), e->IpAddress);
360 StrToUni(tmp4, sizeof(tmp4), str);
361
362 StrToUni(tmp5, sizeof(tmp5), e->Hostname);
363
364 LvInsertAdd(b, ICO_INTERNET, NULL, 6,
365 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5);
366 }
367
368 LvInsertEnd(b, hWnd, L_TABLE);
369
370 FreeRpcEnumDhcp(&t);
371 }
372
373 // DHCP enumeration procedure
NmDhcpProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)374 UINT NmDhcpProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
375 {
376 SM_HUB *r = (SM_HUB *)param;
377 // Validate arguments
378 if (hWnd == NULL)
379 {
380 return 0;
381 }
382
383 switch (msg)
384 {
385 case WM_INITDIALOG:
386 NmDhcpInit(hWnd, r);
387 SetTimer(hWnd, 1, NM_DHCP_REFRESH_TIME, NULL);
388 break;
389
390 case WM_COMMAND:
391 switch (wParam)
392 {
393 case IDCANCEL:
394 Close(hWnd);
395 break;
396
397 case B_REFRESH:
398 NmDhcpRefresh(hWnd, r);
399 break;
400 }
401 break;
402
403 case WM_TIMER:
404 switch (wParam)
405 {
406 case 1:
407 KillTimer(hWnd, 1);
408 NmDhcpRefresh(hWnd, r);
409 SetTimer(hWnd, 1, NM_DHCP_REFRESH_TIME, NULL);
410 break;
411 }
412 break;
413
414 case WM_CLOSE:
415 EndDialog(hWnd, false);
416 break;
417 }
418
419 LvStandardHandler(hWnd, msg, wParam, lParam, L_TABLE);
420
421 return 0;
422 }
423
424 // DHCP enumeration
NmDhcp(HWND hWnd,SM_HUB * r)425 void NmDhcp(HWND hWnd, SM_HUB *r)
426 {
427 // Validate arguments
428 if (hWnd == NULL || r == NULL)
429 {
430 return;
431 }
432
433 Dialog(hWnd, D_NM_DHCP, NmDhcpProc, r);
434 }
435
436
437 // NAT enumeration initialization
NmNatInit(HWND hWnd,SM_HUB * r)438 void NmNatInit(HWND hWnd, SM_HUB *r)
439 {
440 // Validate arguments
441 if (hWnd == NULL || r == NULL)
442 {
443 return;
444 }
445
446 SetIcon(hWnd, 0, ICO_PROTOCOL);
447
448 LvInit(hWnd, L_TABLE);
449 LvInsertColumn(hWnd, L_TABLE, 0, _UU("NM_NAT_ID"), 50);
450 LvInsertColumn(hWnd, L_TABLE, 1, _UU("NM_NAT_PROTOCOL"), 80);
451 LvInsertColumn(hWnd, L_TABLE, 2, _UU("NM_NAT_SRC_HOST"), 100);
452 LvInsertColumn(hWnd, L_TABLE, 3, _UU("NM_NAT_SRC_PORT"), 80);
453 LvInsertColumn(hWnd, L_TABLE, 4, _UU("NM_NAT_DST_HOST"), 150);
454 LvInsertColumn(hWnd, L_TABLE, 5, _UU("NM_NAT_DST_PORT"), 80);
455 LvInsertColumn(hWnd, L_TABLE, 6, _UU("NM_NAT_CREATED"), 200);
456 LvInsertColumn(hWnd, L_TABLE, 7, _UU("NM_NAT_LAST_COMM"), 200);
457 LvInsertColumn(hWnd, L_TABLE, 8, _UU("NM_NAT_SIZE"), 120);
458 LvInsertColumn(hWnd, L_TABLE, 9, _UU("NM_NAT_TCP_STATUS"), 120);
459
460 NmNatRefresh(hWnd, r);
461 }
462
463 // NAT enumeration
NmNatRefresh(HWND hWnd,SM_HUB * r)464 void NmNatRefresh(HWND hWnd, SM_HUB *r)
465 {
466 LVB *b;
467 RPC_ENUM_NAT t;
468 UINT i;
469 // Validate arguments
470 if (hWnd == NULL || r == NULL)
471 {
472 return;
473 }
474
475 Zero(&t, sizeof(t));
476
477 StrCpy(t.HubName, sizeof(t.HubName), r->HubName);
478
479 if (CALL(hWnd, ScEnumNAT(r->Rpc, &t)) == false)
480 {
481 Close(hWnd);
482 return;
483 }
484
485 b = LvInsertStart();
486
487 for (i = 0;i < t.NumItem;i++)
488 {
489 RPC_ENUM_NAT_ITEM *e = &t.Items[i];
490 wchar_t tmp0[MAX_SIZE];
491 wchar_t *tmp1 = L"";
492 wchar_t tmp2[MAX_SIZE];
493 wchar_t tmp3[MAX_SIZE];
494 wchar_t tmp4[MAX_SIZE];
495 wchar_t tmp5[MAX_SIZE];
496 wchar_t tmp6[MAX_SIZE];
497 wchar_t tmp7[MAX_SIZE];
498 wchar_t tmp8[MAX_SIZE];
499 wchar_t *tmp9 = L"";
500 char v1[128], v2[128];
501
502 // ID
503 UniToStru(tmp0, e->Id);
504
505 // Protocol
506 switch (e->Protocol)
507 {
508 case NAT_TCP:
509 tmp1 = _UU("NM_NAT_PROTO_TCP");
510 break;
511 case NAT_UDP:
512 tmp1 = _UU("NM_NAT_PROTO_UDP");
513 break;
514 case NAT_DNS:
515 tmp1 = _UU("NM_NAT_PROTO_DNS");
516 break;
517 case NAT_ICMP:
518 tmp1 = _UU("NM_NAT_PROTO_ICMP");
519 break;
520 }
521
522 // Source host
523 StrToUni(tmp2, sizeof(tmp2), e->SrcHost);
524
525 // Source port
526 UniToStru(tmp3, e->SrcPort);
527
528 // Destination host
529 StrToUni(tmp4, sizeof(tmp4), e->DestHost);
530
531 // Destination port
532 UniToStru(tmp5, e->DestPort);
533
534 // Creation date and time of the session
535 GetDateTimeStrEx64(tmp6, sizeof(tmp6), SystemToLocal64(e->CreatedTime), NULL);
536
537 // Last communication date and time
538 GetDateTimeStrEx64(tmp7, sizeof(tmp7), SystemToLocal64(e->LastCommTime), NULL);
539
540 // Communication amount
541 ToStr3(v1, sizeof(v1), e->RecvSize);
542 ToStr3(v2, sizeof(v2), e->SendSize);
543 UniFormat(tmp8, sizeof(tmp8), L"%S / %S", v1, v2);
544
545 // TCP state
546 if (e->Protocol == NAT_TCP)
547 {
548 switch (e->TcpStatus)
549 {
550 case NAT_TCP_CONNECTING:
551 tmp9 = _UU("NAT_TCP_CONNECTING");
552 break;
553 case NAT_TCP_SEND_RESET:
554 tmp9 = _UU("NAT_TCP_SEND_RESET");
555 break;
556 case NAT_TCP_CONNECTED:
557 tmp9 = _UU("NAT_TCP_CONNECTED");
558 break;
559 case NAT_TCP_ESTABLISHED:
560 tmp9 = _UU("NAT_TCP_ESTABLISHED");
561 break;
562 case NAT_TCP_WAIT_DISCONNECT:
563 tmp9 = _UU("NAT_TCP_WAIT_DISCONNECT");
564 break;
565 }
566 }
567
568 LvInsertAdd(b, ICO_PROTOCOL, NULL, 10,
569 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9);
570 }
571
572 LvInsertEnd(b, hWnd, L_TABLE);
573
574 FreeRpcEnumNat(&t);
575 }
576
577 // NAT enumeration procedure
NmNatProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)578 UINT NmNatProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
579 {
580 SM_HUB *r = (SM_HUB *)param;
581 // Validate arguments
582 if (hWnd == NULL)
583 {
584 return 0;
585 }
586
587 switch (msg)
588 {
589 case WM_INITDIALOG:
590 NmNatInit(hWnd, r);
591 SetTimer(hWnd, 1, NM_NAT_REFRESH_TIME, NULL);
592 break;
593
594 case WM_COMMAND:
595 switch (wParam)
596 {
597 case IDCANCEL:
598 Close(hWnd);
599 break;
600
601 case B_REFRESH:
602 NmNatRefresh(hWnd, r);
603 break;
604 }
605 break;
606
607 case WM_TIMER:
608 switch (wParam)
609 {
610 case 1:
611 KillTimer(hWnd, 1);
612 NmNatRefresh(hWnd, r);
613 SetTimer(hWnd, 1, NM_NAT_REFRESH_TIME, NULL);
614 break;
615 }
616 break;
617
618 case WM_CLOSE:
619 EndDialog(hWnd, false);
620 break;
621 }
622
623 LvStandardHandler(hWnd, msg, wParam, lParam, L_TABLE);
624
625 return 0;
626 }
627
628 // NAT enumeration
NmNat(HWND hWnd,SM_HUB * r)629 void NmNat(HWND hWnd, SM_HUB *r)
630 {
631 // Validate arguments
632 if (hWnd == NULL || r == NULL)
633 {
634 return;
635 }
636
637 Dialog(hWnd, D_NM_NAT, NmNatProc, r);
638 }
639
640 // Show the information of the router
NmInfo(HWND hWnd,SM_SERVER * s,void * param)641 bool NmInfo(HWND hWnd, SM_SERVER *s, void *param)
642 {
643 LVB *b;
644 RPC_NAT_INFO t;
645 wchar_t tmp[MAX_SIZE];
646 // Validate arguments
647 if (hWnd == NULL || s == NULL)
648 {
649 return false;
650 }
651
652 Zero(&t, sizeof(t));
653
654 if (CALL(hWnd, NcGetInfo(s->Rpc, &t)) == false)
655 {
656 return false;
657 }
658
659 b = LvInsertStart();
660
661 StrToUni(tmp, sizeof(tmp), t.NatProductName);
662 LvInsertAdd(b, ICO_ROUTER, NULL, 2, _UU("NM_INFO_PRODUCT_NAME"), tmp);
663
664 StrToUni(tmp, sizeof(tmp), t.NatVersionString);
665 LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("NM_INFO_VERSION_STR"), tmp);
666
667 StrToUni(tmp, sizeof(tmp), t.NatBuildInfoString);
668 LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("NM_INFO_BUILD_INFO"), tmp);
669
670 StrToUni(tmp, sizeof(tmp), t.NatHostName);
671 LvInsertAdd(b, ICO_TOWER, NULL, 2, _UU("NM_INFO_HOSTNAME"), tmp);
672
673 // OS
674 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsSystemName);
675 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_SYSTEM_NAME"), tmp);
676
677 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsProductName);
678 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_PRODUCT_NAME"), tmp);
679
680 if (t.OsInfo.OsServicePack != 0)
681 {
682 UniFormat(tmp, sizeof(tmp), _UU("SM_OS_SP_TAG"), t.OsInfo.OsServicePack);
683 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_SERVICE_PACK"), tmp);
684 }
685
686 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsVendorName);
687 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_VENDER_NAME"), tmp);
688
689 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsVersion);
690 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_VERSION"), tmp);
691
692 StrToUni(tmp, sizeof(tmp), t.OsInfo.KernelName);
693 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_KERNEL_NAME"), tmp);
694
695 StrToUni(tmp, sizeof(tmp), t.OsInfo.KernelVersion);
696 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_KERNEL_VERSION"), tmp);
697
698 // Memory information
699 if (t.MemInfo.TotalMemory != 0)
700 {
701 char vv[128];
702
703 ToStr3(vv, sizeof(vv), t.MemInfo.TotalMemory);
704 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
705 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_TOTAL_MEMORY"), tmp);
706
707 ToStr3(vv, sizeof(vv), t.MemInfo.UsedMemory);
708 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
709 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_USED_MEMORY"), tmp);
710
711 ToStr3(vv, sizeof(vv), t.MemInfo.FreeMemory);
712 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
713 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_FREE_MEMORY"), tmp);
714
715 ToStr3(vv, sizeof(vv), t.MemInfo.TotalPhys);
716 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
717 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_TOTAL_PHYS"), tmp);
718
719 ToStr3(vv, sizeof(vv), t.MemInfo.UsedPhys);
720 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
721 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_USED_PHYS"), tmp);
722
723 ToStr3(vv, sizeof(vv), t.MemInfo.FreePhys);
724 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
725 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_FREE_PHYS"), tmp);
726 }
727
728 LvInsertEnd(b, hWnd, L_STATUS);
729
730 FreeRpcNatInfo(&t);
731
732 return true;
733 }
734
735 // Show the status of the router
NmStatus(HWND hWnd,SM_SERVER * s,void * param)736 bool NmStatus(HWND hWnd, SM_SERVER *s, void *param)
737 {
738 LVB *b;
739 RPC_NAT_STATUS t;
740 wchar_t tmp[MAX_SIZE];
741 SM_HUB *h = (SM_HUB *)param;
742 // Validate arguments
743 if (hWnd == NULL || s == NULL)
744 {
745 return false;
746 }
747
748 Zero(&t, sizeof(t));
749
750 StrCpy(t.HubName, sizeof(t.HubName), h->HubName);
751
752 if (CALL(hWnd, ScGetSecureNATStatus(s->Rpc, &t)) == false)
753 {
754 return false;
755 }
756
757 b = LvInsertStart();
758
759 StrToUni(tmp, sizeof(tmp), h->HubName);
760 LvInsertAdd(b, ICO_HUB, NULL, 2, _UU("SM_HUB_COLUMN_1"), tmp);
761
762 UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumTcpSessions);
763 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("NM_STATUS_TCP"), tmp);
764
765 UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumUdpSessions);
766 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("NM_STATUS_UDP"), tmp);
767
768 UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumIcmpSessions);
769 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("NM_STATUS_ICMP"), tmp);
770
771 UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumDnsSessions);
772 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("NM_STATUS_DNS"), tmp);
773
774 UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_CLIENT"), t.NumDhcpClients);
775 LvInsertAdd(b, ICO_PROTOCOL_DHCP, NULL, 2, _UU("NM_STATUS_DHCP"), tmp);
776
777 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_SNAT_IS_KERNEL"), t.IsKernelMode ? _UU("SEC_YES") : _UU("SEC_NO"));
778 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_SNAT_IS_RAW"), t.IsRawIpMode ? _UU("SEC_YES") : _UU("SEC_NO"));
779
780 LvInsertEnd(b, hWnd, L_STATUS);
781
782 FreeRpcNatStatus(&t);
783
784 return true;
785 }
786
787 // Convert the contents of the form to the VH_OPTION
NmEditVhOptionFormToVH(HWND hWnd,VH_OPTION * t)788 void NmEditVhOptionFormToVH(HWND hWnd, VH_OPTION *t)
789 {
790 char tmp[MAX_SIZE];
791 BUF *b;
792 // Validate arguments
793 if (hWnd == NULL || t == NULL)
794 {
795 return;
796 }
797
798 Zero(t, sizeof(VH_OPTION));
799
800 GetTxtA(hWnd, E_MAC, tmp, sizeof(tmp));
801 b = StrToBin(tmp);
802 if (b != NULL)
803 {
804 if (b->Size == 6)
805 {
806 Copy(t->MacAddress, b->Buf, 6);
807 }
808 FreeBuf(b);
809 }
810
811 UINTToIP(&t->Ip, IpGet(hWnd, E_IP));
812 UINTToIP(&t->Mask, IpGet(hWnd, E_MASK));
813
814 t->UseNat = IsChecked(hWnd, R_USE_NAT);
815 t->Mtu = GetInt(hWnd, E_MTU);
816 t->NatTcpTimeout = GetInt(hWnd, E_TCP);
817 t->NatUdpTimeout = GetInt(hWnd, E_UDP);
818
819 t->UseDhcp = IsChecked(hWnd, R_USE_DHCP);
820 UINTToIP(&t->DhcpLeaseIPStart, IpGet(hWnd, E_DHCP_START));
821 UINTToIP(&t->DhcpLeaseIPEnd, IpGet(hWnd, E_DHCP_END));
822 UINTToIP(&t->DhcpSubnetMask, IpGet(hWnd, E_DHCP_MASK));
823 t->DhcpExpireTimeSpan = GetInt(hWnd, E_EXPIRES);
824 UINTToIP(&t->DhcpGatewayAddress, IpGet(hWnd, E_GATEWAY));
825 UINTToIP(&t->DhcpDnsServerAddress, IpGet(hWnd, E_DNS));
826 UINTToIP(&t->DhcpDnsServerAddress2, IpGet(hWnd, E_DNS2));
827 GetTxtA(hWnd, E_DOMAIN, t->DhcpDomainName, sizeof(t->DhcpDomainName));
828 t->SaveLog = IsChecked(hWnd, R_SAVE_LOG);
829 }
830
831 // Initialize
NmEditVhOptionInit(HWND hWnd,SM_HUB * r)832 void NmEditVhOptionInit(HWND hWnd, SM_HUB *r)
833 {
834 char tmp[MAX_SIZE];
835 VH_OPTION t;
836 // Validate arguments
837 if (hWnd == NULL || r == NULL)
838 {
839 return;
840 }
841
842 SetIcon(hWnd, 0, ICO_ROUTER);
843
844 FormatText(hWnd, S_TITLE, r->HubName);
845
846 Zero(&t, sizeof(VH_OPTION));
847 StrCpy(t.HubName, sizeof(t.HubName), r->HubName);
848 if (CALL(hWnd, ScGetSecureNATOption(r->Rpc, &t)) == false)
849 {
850 EndDialog(hWnd, false);
851 return;
852 }
853
854 if (GetCapsBool(r->p->CapsList, "b_virtual_nat_disabled"))
855 {
856 SetEnable(hWnd, R_USE_NAT, false);
857 Check(hWnd, R_USE_NAT, false);
858 }
859
860 MacToStr(tmp, sizeof(tmp), t.MacAddress);
861 SetTextA(hWnd, E_MAC, tmp);
862 IpSet(hWnd, E_IP, IPToUINT(&t.Ip));
863 IpSet(hWnd, E_MASK, IPToUINT(&t.Mask));
864
865 Check(hWnd, R_USE_NAT, t.UseNat);
866 SetIntEx(hWnd, E_MTU, t.Mtu);
867 SetIntEx(hWnd, E_TCP, t.NatTcpTimeout);
868 SetIntEx(hWnd, E_UDP, t.NatUdpTimeout);
869
870 Check(hWnd, R_USE_DHCP, t.UseDhcp);
871 IpSet(hWnd, E_DHCP_START, IPToUINT(&t.DhcpLeaseIPStart));
872 IpSet(hWnd, E_DHCP_END, IPToUINT(&t.DhcpLeaseIPEnd));
873 IpSet(hWnd, E_DHCP_MASK, IPToUINT(&t.DhcpSubnetMask));
874 SetIntEx(hWnd, E_EXPIRES, t.DhcpExpireTimeSpan);
875
876 if (IPToUINT(&t.DhcpGatewayAddress) != 0)
877 {
878 IpSet(hWnd, E_GATEWAY, IPToUINT(&t.DhcpGatewayAddress));
879 }
880
881 if (IPToUINT(&t.DhcpDnsServerAddress) != 0)
882 {
883 IpSet(hWnd, E_DNS, IPToUINT(&t.DhcpDnsServerAddress));
884 }
885
886 if (IPToUINT(&t.DhcpDnsServerAddress2) != 0)
887 {
888 IpSet(hWnd, E_DNS2, IPToUINT(&t.DhcpDnsServerAddress2));
889 }
890
891 SetTextA(hWnd, E_DOMAIN, t.DhcpDomainName);
892 Check(hWnd, R_SAVE_LOG, t.SaveLog);
893
894 StrCpy(r->CurrentPushRouteStr, sizeof(r->CurrentPushRouteStr), t.DhcpPushRoutes);
895
896 if (GetCapsBool(r->p->CapsList, "b_suppport_push_route_config") == false)
897 {
898 Disable(hWnd, S_1);
899 Disable(hWnd, S_2);
900 Disable(hWnd, B_PUSH);
901 }
902
903 NmEditVhOptionUpdate(hWnd, r);
904
905 }
906
NmEditVhOptionUpdate(HWND hWnd,SM_HUB * r)907 void NmEditVhOptionUpdate(HWND hWnd, SM_HUB *r)
908 {
909 VH_OPTION t;
910 bool ok = true;
911 // Validate arguments
912 if (hWnd == NULL || r == NULL)
913 {
914 return;
915 }
916
917 NmEditVhOptionFormToVH(hWnd, &t);
918
919 if (IsZero(t.MacAddress, 6))
920 {
921 ok = false;
922 }
923
924 if (IPToUINT(&t.Ip) == 0 || IPToUINT(&t.Mask) == 0)
925 {
926 ok = false;
927 }
928
929 if (IpIsFilled(hWnd, E_IP) == false || IpIsFilled(hWnd, E_MASK) == false)
930 {
931 ok = false;
932 }
933
934 if (IsHostIPAddress4(&t.Ip) == false || IsSubnetMask4(&t.Mask) == false)
935 {
936 ok = false;
937 }
938
939 if (t.UseNat)
940 {
941 if (t.Mtu < 64 || t.Mtu > 1500)
942 {
943 ok = false;
944 }
945
946 if (t.NatTcpTimeout < (NAT_TCP_MIN_TIMEOUT / 1000) || t.NatTcpTimeout > (NAT_TCP_MAX_TIMEOUT / 1000))
947 {
948 ok = false;
949 }
950
951 if (t.NatUdpTimeout < (NAT_UDP_MIN_TIMEOUT / 1000) || t.NatUdpTimeout > (NAT_UDP_MAX_TIMEOUT / 1000))
952 {
953 ok = false;
954 }
955 }
956
957 if (t.UseDhcp)
958 {
959 if (IpIsFilled(hWnd, E_DHCP_START) == false || IpIsFilled(hWnd, E_DHCP_END) == false ||
960 IpIsFilled(hWnd, E_DHCP_MASK) == false)
961 {
962 ok = false;
963 }
964
965 if (IpGetFilledNum(hWnd, E_GATEWAY) != 0 && IpGetFilledNum(hWnd, E_GATEWAY) != 4)
966 {
967 ok = false;
968 }
969
970 if (IpGetFilledNum(hWnd, E_DNS) != 0 && IpGetFilledNum(hWnd, E_DNS) != 4)
971 {
972 ok = false;
973 }
974
975 if (IpGetFilledNum(hWnd, E_DNS2) != 0 && IpGetFilledNum(hWnd, E_DNS2) != 4)
976 {
977 ok = false;
978 }
979
980 if (IPToUINT(&t.DhcpLeaseIPStart) == 0 || IPToUINT(&t.DhcpLeaseIPEnd) == 0 ||
981 IPToUINT(&t.DhcpSubnetMask) == 0)
982 {
983 ok = false;
984 }
985
986 if (t.DhcpExpireTimeSpan < 15)
987 {
988 ok = false;
989 }
990
991 if (Endian32(IPToUINT(&t.DhcpLeaseIPStart)) > Endian32(IPToUINT(&t.DhcpLeaseIPEnd)))
992 {
993 ok = false;
994 }
995
996 if (IsHostIPAddress4(&t.DhcpLeaseIPStart) == false ||
997 IsHostIPAddress4(&t.DhcpLeaseIPEnd) == false)
998 {
999 ok = false;
1000 }
1001
1002 if (IsSubnetMask4(&t.DhcpSubnetMask) == false)
1003 {
1004 ok = false;
1005 }
1006 }
1007
1008 SetEnable(hWnd, E_MTU, t.UseNat);
1009 SetEnable(hWnd, E_TCP, t.UseNat);
1010 SetEnable(hWnd, E_UDP, t.UseNat);
1011
1012 SetEnable(hWnd, E_DHCP_START, t.UseDhcp);
1013 SetEnable(hWnd, E_DHCP_END, t.UseDhcp);
1014 SetEnable(hWnd, E_DHCP_MASK, t.UseDhcp);
1015 SetEnable(hWnd, E_EXPIRES, t.UseDhcp);
1016 SetEnable(hWnd, E_GATEWAY, t.UseDhcp);
1017 SetEnable(hWnd, E_DNS, t.UseDhcp);
1018 SetEnable(hWnd, E_DNS2, t.UseDhcp);
1019 SetEnable(hWnd, E_DOMAIN, t.UseDhcp);
1020
1021 SetEnable(hWnd, IDOK, ok);
1022 }
1023
1024 // [OK] button
NmEditVhOptionOnOk(HWND hWnd,SM_HUB * r)1025 void NmEditVhOptionOnOk(HWND hWnd, SM_HUB *r)
1026 {
1027 VH_OPTION t;
1028 // Validate arguments
1029 if (hWnd == NULL || r == NULL)
1030 {
1031 return;
1032 }
1033
1034 NmEditVhOptionFormToVH(hWnd, &t);
1035 StrCpy(t.HubName, sizeof(t.HubName), r->HubName);
1036
1037 t.ApplyDhcpPushRoutes = true;
1038 StrCpy(t.DhcpPushRoutes, sizeof(t.DhcpPushRoutes), r->CurrentPushRouteStr);
1039
1040 if (CALL(hWnd, ScSetSecureNATOption(r->Rpc, &t)))
1041 {
1042 EndDialog(hWnd, true);
1043 }
1044 }
1045
1046 // Virtual host options editing dialog
NmEditVhOptionProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1047 UINT NmEditVhOptionProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1048 {
1049 SM_HUB *r = (SM_HUB *)param;
1050 // Validate arguments
1051 if (hWnd == NULL)
1052 {
1053 return 0;
1054 }
1055
1056 switch (msg)
1057 {
1058 case WM_INITDIALOG:
1059 NmEditVhOptionInit(hWnd, r);
1060 break;
1061
1062 case WM_COMMAND:
1063 switch (LOWORD(wParam))
1064 {
1065 case E_MAC:
1066 case E_IP:
1067 case E_MASK:
1068 case R_USE_NAT:
1069 case E_MTU:
1070 case E_TCP:
1071 case E_UDP:
1072 case R_SAVE_LOG:
1073 case R_USE_DHCP:
1074 case E_DHCP_START:
1075 case E_DHCP_END:
1076 case E_DHCP_MASK:
1077 case E_EXPIRES:
1078 case E_GATEWAY:
1079 case E_DNS:
1080 case E_DNS2:
1081 case E_DOMAIN:
1082 NmEditVhOptionUpdate(hWnd, r);
1083 break;
1084 }
1085
1086 switch (wParam)
1087 {
1088 case IDOK:
1089 NmEditVhOptionOnOk(hWnd, r);
1090 break;
1091
1092 case IDCANCEL:
1093 EndDialog(hWnd, false);
1094 break;
1095
1096 case R_USE_NAT:
1097 if (IsChecked(hWnd, R_USE_NAT))
1098 {
1099 FocusEx(hWnd, E_MTU);
1100 }
1101
1102 if (IsChecked(hWnd, R_USE_DHCP))
1103 {
1104 Focus(hWnd, E_DHCP_START);
1105 }
1106 break;
1107
1108 case B_PUSH:
1109 NmEditPushRoute(hWnd, r);
1110 break;
1111 }
1112
1113 break;
1114 }
1115
1116 return 0;
1117 }
1118
1119 // Edit the virtual host option
NmEditVhOption(HWND hWnd,SM_HUB * r)1120 void NmEditVhOption(HWND hWnd, SM_HUB *r)
1121 {
1122 // Validate arguments
1123 if (hWnd == NULL || r == NULL)
1124 {
1125 return;
1126 }
1127
1128 Zero(r->CurrentPushRouteStr, sizeof(r->CurrentPushRouteStr));
1129 Dialog(hWnd, D_NM_OPTION, NmEditVhOptionProc, r);
1130 }
1131
1132 // Edit the client configuration
NmEditClientConfig(HWND hWnd,RPC * r)1133 void NmEditClientConfig(HWND hWnd, RPC *r)
1134 {
1135 CM_ACCOUNT a;
1136 RPC_CREATE_LINK t;
1137 bool ret = false;
1138 // Validate arguments
1139 if (hWnd == NULL || r == NULL)
1140 {
1141 return;
1142 }
1143
1144 Zero(&a, sizeof(a));
1145 Zero(&t, sizeof(t));
1146
1147 a.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
1148 a.NatMode = true;
1149 a.Rpc = r;
1150
1151 if (CALLEX(hWnd, NcGetClientConfig(r, &t)) != ERR_NO_ERROR)
1152 {
1153 // Create New
1154 a.ClientOption->Port = 443;
1155 a.ClientOption->RetryInterval = 15;
1156 a.ClientOption->NumRetry = INFINITE;
1157 a.ClientOption->AdditionalConnectionInterval = 1;
1158 a.ClientOption->UseEncrypt = true;
1159 a.ClientOption->NoRoutingTracking = true;
1160 a.ClientAuth = ZeroMalloc(sizeof(CLIENT_AUTH));
1161 a.ClientAuth->AuthType = CLIENT_AUTHTYPE_PASSWORD;
1162 }
1163 else
1164 {
1165 // Edit
1166 a.EditMode = true;
1167 Copy(a.ClientOption, t.ClientOption, sizeof(CLIENT_OPTION));
1168 a.ClientAuth = CopyClientAuth(t.ClientAuth);
1169
1170 FreeRpcCreateLink(&t);
1171 }
1172
1173 ret = CmEditAccountDlg(hWnd, &a);
1174
1175 Free(a.ServerCert);
1176 Free(a.ClientOption);
1177 CiFreeClientAuth(a.ClientAuth);
1178 }
1179
1180 // Initialize
NmMainDlgInit(HWND hWnd,RPC * r)1181 void NmMainDlgInit(HWND hWnd, RPC *r)
1182 {
1183 // Validate arguments
1184 if (r == NULL || hWnd == NULL)
1185 {
1186 return;
1187 }
1188
1189 SetIcon(hWnd, 0, ICO_ROUTER);
1190 FormatText(hWnd, 0, r->Sock->RemoteHostname);
1191 DlgFont(hWnd, S_STATUS, 11, true);
1192
1193 NmMainDlgRefresh(hWnd, r);
1194 }
1195
1196 // Update
NmMainDlgRefresh(HWND hWnd,RPC * r)1197 void NmMainDlgRefresh(HWND hWnd, RPC *r)
1198 {
1199 #if 0
1200 RPC_NAT_STATUS t;
1201 wchar_t tmp[MAX_SIZE];
1202 wchar_t tmp2[MAX_SIZE];
1203 // Validate arguments
1204 if (r == NULL || hWnd == NULL)
1205 {
1206 return;
1207 }
1208
1209 Zero(&t, sizeof(RPC_NAT_STATUS));
1210
1211 CALL(hWnd, NcGetStatus(r, &t));
1212
1213 if (t.Online == false)
1214 {
1215 UniStrCpy(tmp, sizeof(tmp), _UU("NM_OFFLINE"));
1216
1217 Enable(hWnd, B_CONNECT);
1218 Disable(hWnd, B_DISCONNECT);
1219 }
1220 else
1221 {
1222 if (t.Connected)
1223 {
1224 UniFormat(tmp, sizeof(tmp), _UU("NM_CONNECTED"), t.Status.ServerName);
1225 }
1226 else
1227 {
1228 if (t.LastError == ERR_NO_ERROR)
1229 {
1230 UniStrCpy(tmp, sizeof(tmp), _UU("NM_CONNECTING"));
1231 }
1232 else
1233 {
1234 UniFormat(tmp, sizeof(tmp), _UU("NM_CONNECT_ERROR"), t.LastError, _E(t.LastError));
1235 }
1236 }
1237 Disable(hWnd, B_CONNECT);
1238 Enable(hWnd, B_DISCONNECT);
1239 }
1240
1241 UniFormat(tmp2, sizeof(tmp2), _UU("NM_STATUS_TAG"), tmp);
1242
1243 SetText(hWnd, S_STATUS, tmp2);
1244
1245 FreeRpcNatStatus(&t);
1246 #endif
1247 }
1248
1249 // Main dialog procedure
NmMainDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1250 UINT NmMainDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1251 {
1252 #if 0
1253 SM_HUB *r = (SM_HUB *)param;
1254 RPC_DUMMY dummy;
1255 SM_SERVER sm;
1256 // Validate arguments
1257 if (hWnd == NULL)
1258 {
1259 return 0;
1260 }
1261
1262 switch (msg)
1263 {
1264 case WM_INITDIALOG:
1265 NmMainDlgInit(hWnd, r);
1266
1267 SetTimer(hWnd, 1, NM_REFRESH_TIME, NULL);
1268
1269 break;
1270
1271 case WM_COMMAND:
1272 switch (wParam)
1273 {
1274 case B_SETTING:
1275 // Connection setting
1276 NmEditClientConfig(hWnd, r);
1277 break;
1278
1279 case B_CONNECT:
1280 // Connection
1281 Zero(&dummy, sizeof(dummy));
1282 CALL(hWnd, NcOnline(r, &dummy));
1283 NmMainDlgRefresh(hWnd, r);
1284 break;
1285
1286 case B_DISCONNECT:
1287 // Disconnect
1288 Zero(&dummy, sizeof(dummy));
1289 CALL(hWnd, NcOffline(r, &dummy));
1290 NmMainDlgRefresh(hWnd, r);
1291 break;
1292
1293 case B_OPTION:
1294 // Operation setting
1295 NmEditVhOption(hWnd, r->Rpc);
1296 break;
1297
1298 case B_NAT:
1299 // NAT
1300 NmNat(hWnd, r);
1301 break;
1302
1303 case B_DHCP:
1304 // DHCP
1305 NmDhcp(hWnd, r);
1306 break;
1307
1308 case B_STATUS:
1309 // Status
1310 Zero(&sm, sizeof(sm));
1311 sm.Rpc = r;
1312 SmStatusDlg(hWnd, &sm, NULL, true, true, _UU("NM_STATUS"), ICO_ROUTER,
1313 NULL, NmStatus);
1314 break;
1315
1316 case B_INFO:
1317 // Information
1318 Zero(&sm, sizeof(sm));
1319 sm.Rpc = r;
1320 SmStatusDlg(hWnd, &sm, NULL, false, true, _UU("NM_INFO"), ICO_ROUTER,
1321 NULL, NmInfo);
1322 break;
1323
1324 case B_REFRESH:
1325 // Refresh
1326 NmMainDlgRefresh(hWnd, r);
1327 break;
1328
1329 case B_PASSWORD:
1330 // Change the password
1331 NmChangePassword(hWnd, r);
1332 break;
1333
1334 case B_ABOUT:
1335 // Version information
1336 About(hWnd, nm->Cedar, CEDAR_ROUTER_STR);
1337 break;
1338
1339 case IDCANCEL:
1340 Close(hWnd);
1341 break;
1342 }
1343 break;
1344
1345 case WM_TIMER:
1346 switch (wParam)
1347 {
1348 case 1:
1349 KillTimer(hWnd, 1);
1350
1351 if (IsEnable(hWnd, 0))
1352 {
1353 NmMainDlgRefresh(hWnd, r);
1354 }
1355
1356 SetTimer(hWnd, 1, NM_REFRESH_TIME, NULL);
1357 break;
1358 }
1359 break;
1360
1361 case WM_CLOSE:
1362 EndDialog(hWnd, false);
1363 break;
1364 }
1365
1366 #endif
1367
1368 return 0;
1369 }
1370
1371 // Main dialog
NmMainDlg(RPC * r)1372 void NmMainDlg(RPC *r)
1373 {
1374 // Validate arguments
1375 if (r == NULL)
1376 {
1377 return;
1378 }
1379
1380 Dialog(NULL, D_NM_MAIN, NmMainDlgProc, r);
1381 }
1382
1383 // Login dialog
NmLogin(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1384 UINT NmLogin(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1385 {
1386 NM_LOGIN *login = (NM_LOGIN *)param;
1387 char tmp[MAX_SIZE];
1388 // Validate arguments
1389 if (hWnd == NULL)
1390 {
1391 return 0;
1392 }
1393
1394 switch (msg)
1395 {
1396 case WM_INITDIALOG:
1397 FormatText(hWnd, S_TITLE, login->Hostname);
1398 break;
1399
1400 case WM_COMMAND:
1401 switch (wParam)
1402 {
1403 case IDOK:
1404 GetTxtA(hWnd, E_PASSWORD, tmp, sizeof(tmp));
1405 Hash(login->hashed_password, tmp, StrLen(tmp), true);
1406 EndDialog(hWnd, true);
1407 break;
1408
1409 case IDCANCEL:
1410 Close(hWnd);
1411 break;
1412 }
1413 break;
1414
1415 case WM_CLOSE:
1416 EndDialog(hWnd, false);
1417 break;
1418 }
1419
1420 return 0;
1421 }
1422
1423 // Connecting dialog
NmConnectDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1424 UINT NmConnectDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1425 {
1426 NM_CONNECT *t = (NM_CONNECT *)param;
1427 RPC *rpc;
1428 NM_LOGIN login;
1429 UINT err;
1430 // Validate arguments
1431 if (hWnd == NULL)
1432 {
1433 return 0;
1434 }
1435
1436 switch (msg)
1437 {
1438 case WM_INITDIALOG:
1439 FormatText(hWnd, S_TITLE, t->Hostname);
1440 SetTimer(hWnd, 1, 50, NULL);
1441 break;
1442
1443 case WM_TIMER:
1444 switch (wParam)
1445 {
1446 case 1:
1447 KillTimer(hWnd, 1);
1448
1449 while (true)
1450 {
1451 bool flag = false;
1452 RETRY_PASSWORD:
1453 // Password input dialog
1454 Zero(&login, sizeof(login));
1455 login.Hostname = t->Hostname;
1456 login.Port = t->Port;
1457 Hash(login.hashed_password, "", 0, true);
1458
1459 if (flag)
1460 {
1461 if (Dialog(hWnd, D_NM_LOGIN, NmLogin, &login) == false)
1462 {
1463 EndDialog(hWnd, false);
1464 break;
1465 }
1466 }
1467
1468 RETRY_CONNECT:
1469 Refresh(DlgItem(hWnd, S_TITLE));
1470 Refresh(hWnd);
1471 // Connection
1472 rpc = NatAdminConnect(nm->Cedar, t->Hostname, t->Port, login.hashed_password, &err);
1473 if (rpc != NULL)
1474 {
1475 t->Rpc = rpc;
1476 EndDialog(hWnd, true);
1477 break;
1478 }
1479
1480 // Error
1481 if (err == ERR_ACCESS_DENIED || err == ERR_AUTH_FAILED)
1482 {
1483 if (flag)
1484 {
1485 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_RETRYCANCEL,
1486 _E(err)) == IDCANCEL)
1487 {
1488 EndDialog(hWnd, false);
1489 break;
1490 }
1491 }
1492 flag = true;
1493 goto RETRY_PASSWORD;
1494 }
1495 else
1496 {
1497 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_RETRYCANCEL,
1498 _E(err)) == IDCANCEL)
1499 {
1500 EndDialog(hWnd, false);
1501 break;
1502 }
1503 goto RETRY_CONNECT;
1504 }
1505 }
1506 break;
1507 }
1508 break;
1509 }
1510
1511 return 0;
1512 }
1513
1514 // Connect to the User-mode NAT program
NmConnect(char * hostname,UINT port)1515 RPC *NmConnect(char *hostname, UINT port)
1516 {
1517 NM_CONNECT t;
1518 // Validate arguments
1519 if (hostname == NULL || port == 0)
1520 {
1521 return NULL;
1522 }
1523
1524 Zero(&t, sizeof(t));
1525 t.Hostname = hostname;
1526 t.Port = port;
1527
1528 Dialog(NULL, D_NM_CONNECT, NmConnectDlgProc, &t);
1529
1530 return t.Rpc;
1531 }
1532
1533 // Main process
MainNM()1534 void MainNM()
1535 {
1536 UINT port;
1537 char hostname[MAX_HOST_NAME_LEN + 1];
1538 char *tmp =
1539 RemoteDlg(NULL, NM_SETTING_REG_KEY, ICO_ROUTER,
1540 _UU("NM_TITLE"), _UU("NM_CONNECT_TITLE"), NULL);
1541 TOKEN_LIST *t;
1542
1543 Zero(hostname, sizeof(hostname));
1544
1545 if (tmp == NULL)
1546 {
1547 return;
1548 }
1549
1550 t = ParseToken(tmp, ":");
1551 port = DEFAULT_NAT_ADMIN_PORT;
1552
1553 if (t->NumTokens >= 2)
1554 {
1555 UINT i = ToInt(t->Token[1]);
1556 if (i != 0)
1557 {
1558 port = i;
1559 }
1560 }
1561 if (t->NumTokens >= 1)
1562 {
1563 RPC *rpc;
1564 StrCpy(hostname, sizeof(hostname), t->Token[0]);
1565
1566 // Connection
1567 Trim(hostname);
1568
1569 if (StrLen(hostname) != 0)
1570 {
1571 rpc = NmConnect(hostname, port);
1572 if (rpc != NULL)
1573 {
1574 // Connected
1575 NmMainDlg(rpc);
1576 NatAdminDisconnect(rpc);
1577 }
1578 }
1579 }
1580
1581 FreeToken(t);
1582
1583 Free(tmp);
1584 }
1585
1586 // Initialize
InitNM()1587 void InitNM()
1588 {
1589 if (nm != NULL)
1590 {
1591 // Already initialized
1592 return;
1593 }
1594
1595 nm = ZeroMalloc(sizeof(NM));
1596
1597 InitWinUi(_UU("NM_TITLE"), _SS("DEFAULT_FONT"), _II("DEFAULT_FONT_SIZE"));
1598
1599 nm->Cedar = NewCedar(NULL, NULL);
1600
1601 InitCM(false);
1602 InitSM();
1603 }
1604
1605 // Release
FreeNM()1606 void FreeNM()
1607 {
1608 if (nm == NULL)
1609 {
1610 // Uninitialized
1611 return;
1612 }
1613
1614 FreeSM();
1615 FreeCM();
1616
1617 ReleaseCedar(nm->Cedar);
1618
1619 FreeWinUi();
1620
1621 Free(nm);
1622 nm = NULL;
1623 }
1624
1625 // Execution of NM
NMExec()1626 void NMExec()
1627 {
1628 InitNM();
1629 MainNM();
1630 FreeNM();
1631 }
1632
1633 #endif
1634
1635