1 // SoftEther VPN Source Code - Developer Edition Master Branch
2 // Cedar Communication Module
3
4
5 // SM.c
6 // VPN Server Manager for Win32
7
8 #ifdef OS_WIN32
9
10 #include "SM.h"
11 #include "SMInner.h"
12
13 #include "AzureClient.h"
14 #include "CMInner.h"
15 #include "Console.h"
16 #include "Database.h"
17 #include "Layer3.h"
18 #include "NMInner.h"
19 #include "Proto_PPP.h"
20 #include "Radius.h"
21 #include "Remote.h"
22 #include "Server.h"
23
24 #include "Mayaqua/Cfg.h"
25 #include "Mayaqua/FileIO.h"
26 #include "Mayaqua/Internat.h"
27 #include "Mayaqua/Memory.h"
28 #include "Mayaqua/Microsoft.h"
29 #include "Mayaqua/Secure.h"
30 #include "Mayaqua/Str.h"
31
32 #include "../PenCore/resource.h"
33
34 #include <shellapi.h>
35 #include <shlobj.h>
36
37 // Global variable
38 static SM *sm = NULL;
39 static bool link_create_now = false;
40
41
42 // Proxy Settings dialog initialization
SmProxyDlgInit(HWND hWnd,INTERNET_SETTING * t)43 void SmProxyDlgInit(HWND hWnd, INTERNET_SETTING *t)
44 {
45 // Validate arguments
46 if (hWnd == NULL || t == NULL)
47 {
48 return;
49 }
50
51 Check(hWnd, R_DIRECT_TCP, t->ProxyType == PROXY_DIRECT);
52 Check(hWnd, R_HTTPS, t->ProxyType == PROXY_HTTP);
53 Check(hWnd, R_SOCKS, t->ProxyType == PROXY_SOCKS);
54 Check(hWnd, R_SOCKS5, t->ProxyType == PROXY_SOCKS5);
55
56 SmProxyDlgUpdate(hWnd, t);
57 }
58
59 // Proxy Settings dialog update
SmProxyDlgUpdate(HWND hWnd,INTERNET_SETTING * t)60 void SmProxyDlgUpdate(HWND hWnd, INTERNET_SETTING *t)
61 {
62 bool ok = false;
63 // Validate arguments
64 if (hWnd == NULL || t == NULL)
65 {
66 return;
67 }
68
69 if (t->ProxyType == PROXY_DIRECT)
70 {
71 ok = true;
72 }
73 else
74 {
75 if (IsEmptyStr(t->ProxyHostName) == false &&
76 t->ProxyPort != 0)
77 {
78 ok = true;
79 }
80 }
81
82 SetEnable(hWnd, IDOK, ok);
83
84 SetEnable(hWnd, B_PROXY_CONFIG, !IsChecked(hWnd, R_DIRECT_TCP));
85 }
86
87 // Proxy settings generic dialog procedure
SmProxyDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)88 UINT SmProxyDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
89 {
90 INTERNET_SETTING *t = (INTERNET_SETTING *)param;
91 CLIENT_OPTION a;
92
93 switch (msg)
94 {
95 case WM_INITDIALOG:
96 SmProxyDlgInit(hWnd, t);
97 break;
98
99 case WM_COMMAND:
100 switch (wParam)
101 {
102 case IDOK:
103 EndDialog(hWnd, 1);
104 break;
105
106 case IDCANCEL:
107 Close(hWnd);
108 break;
109
110 case R_DIRECT_TCP:
111 case R_HTTPS:
112 case R_SOCKS:
113 case R_SOCKS5:
114 if (IsChecked(hWnd, R_HTTPS))
115 {
116 t->ProxyType = PROXY_HTTP;
117 }
118 else if (IsChecked(hWnd, R_SOCKS))
119 {
120 t->ProxyType = PROXY_SOCKS;
121 }
122 else if (IsChecked(hWnd, R_SOCKS5))
123 {
124 t->ProxyType = PROXY_SOCKS5;
125 }
126 else
127 {
128 t->ProxyType = PROXY_DIRECT;
129 }
130
131 SmProxyDlgUpdate(hWnd, t);
132 break;
133
134 case B_PROXY_CONFIG:
135 Zero(&a, sizeof(a));
136
137 a.ProxyType = t->ProxyType;
138 StrCpy(a.ProxyName, sizeof(a.ProxyName), t->ProxyHostName);
139 a.ProxyPort = t->ProxyPort;
140 StrCpy(a.ProxyUsername, sizeof(a.ProxyUsername), t->ProxyUsername);
141 StrCpy(a.ProxyPassword, sizeof(a.ProxyPassword), t->ProxyPassword);
142 StrCpy(a.CustomHttpHeader, sizeof(a.CustomHttpHeader), t->CustomHttpHeader);
143
144 if (CmProxyDlg(hWnd, &a))
145 {
146 t->ProxyType = a.ProxyType;
147 StrCpy(t->ProxyHostName, sizeof(t->ProxyHostName), a.ProxyName);
148 t->ProxyPort = a.ProxyPort;
149 StrCpy(t->ProxyUsername, sizeof(t->ProxyUsername), a.ProxyUsername);
150 StrCpy(t->ProxyPassword, sizeof(t->ProxyPassword), a.ProxyPassword);
151 StrCpy(t->CustomHttpHeader, sizeof(t->CustomHttpHeader), a.CustomHttpHeader);
152 }
153
154 SmProxyDlgUpdate(hWnd, t);
155
156 break;
157 }
158 break;
159
160 case WM_CLOSE:
161 EndDialog(hWnd, 0);
162 break;
163 }
164
165 return 0;
166 }
167
168 // Proxy Settings generic dialog
SmProxy(HWND hWnd,INTERNET_SETTING * t)169 bool SmProxy(HWND hWnd, INTERNET_SETTING *t)
170 {
171 // Validate arguments
172 if (t == NULL)
173 {
174 return false;
175 }
176
177 return Dialog(hWnd, D_SM_PROXY, SmProxyDlg, t);
178 }
179
180 // VPN Azure dialog procedure
SmAzureDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)181 UINT SmAzureDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
182 {
183 SM_AZURE *a = (SM_AZURE *)param;
184
185 switch (msg)
186 {
187 case WM_INITDIALOG:
188 SmAzureDlgOnInit(hWnd, a);
189
190 SetTimer(hWnd, 1, 1000, NULL);
191 break;
192
193 case WM_COMMAND:
194 switch (wParam)
195 {
196 case B_CHANGE:
197 if (SmDDns(hWnd, a->s, false, true))
198 {
199 SmAzureDlgRefresh(hWnd, a);
200 }
201 break;
202
203 case B_WEB:
204 MsExecute(_SS("SE_VPNAZURE_URL"), NULL);
205 break;
206
207 case R_ENABLE:
208 case R_DISABLE:
209 if (IsChecked(hWnd, R_ENABLE) || IsChecked(hWnd, R_DISABLE))
210 {
211 Enable(hWnd, IDCANCEL);
212 EnableClose(hWnd);
213 }
214
215 SmAzureSetStatus(hWnd, a);
216 break;
217
218 case IDOK:
219 case IDCANCEL:
220 Close(hWnd);
221 break;
222 }
223 break;
224
225 case WM_TIMER:
226 switch (wParam)
227 {
228 case 1:
229 if (IsEnable(hWnd, 0))
230 {
231 KillTimer(hWnd, 1);
232
233 SmAzureDlgRefresh(hWnd, a);
234
235 SetTimer(hWnd, 1, 1000, NULL);
236 }
237 break;
238 }
239 break;
240
241 case WM_CLOSE:
242 EndDialog(hWnd, 0);
243 break;
244 }
245
246 return 0;
247 }
248
249 // Set the status
SmAzureSetStatus(HWND hWnd,SM_AZURE * a)250 void SmAzureSetStatus(HWND hWnd, SM_AZURE *a)
251 {
252 RPC_AZURE_STATUS st;
253 // Validate arguments
254 if (hWnd == NULL || a == NULL)
255 {
256 return;
257 }
258
259 Zero(&st, sizeof(st));
260
261 st.IsEnabled = IsChecked(hWnd, R_ENABLE);
262
263 if (CALL(hWnd, ScSetAzureStatus(a->s->Rpc, &st)) == false)
264 {
265 EndDialog(hWnd, 0);
266 return;
267 }
268
269 SmAzureDlgRefresh(hWnd, a);
270 }
271
272 // Initialize the dialog
SmAzureDlgOnInit(HWND hWnd,SM_AZURE * a)273 void SmAzureDlgOnInit(HWND hWnd, SM_AZURE *a)
274 {
275 RPC_AZURE_STATUS st;
276 UINT current_lang_id;
277 // Validate arguments
278 if (hWnd == NULL || a == NULL)
279 {
280 return;
281 }
282
283 SetIcon(hWnd, 0, ICO_AZURE);
284
285 DlgFont(hWnd, S_TITLE, 14, true);
286 DlgFont(hWnd, R_ENABLE, 0, true);
287
288 SetFont(hWnd, E_HOST, GetFont("Verdana", 10, false, false, false, false));
289
290 current_lang_id = GetCurrentLangId();
291
292 // Japanese
293 SetShow(hWnd, S_BMP_JA, current_lang_id == SE_LANG_JAPANESE);
294
295 // Chinese
296 SetShow(hWnd, S_BMP_CN, current_lang_id == SE_LANG_CHINESE_ZH);
297
298 // Other languages
299 SetShow(hWnd, S_BMP_EN, (current_lang_id != SE_LANG_JAPANESE) && (current_lang_id != SE_LANG_CHINESE_ZH));
300
301 // Apply the current settings
302 Zero(&st, sizeof(st));
303
304 if (CALL(hWnd, ScGetAzureStatus(a->s->Rpc, &st)) == false)
305 {
306 EndDialog(hWnd, 0);
307 return;
308 }
309
310 if (a->OnSetup == false || st.IsEnabled)
311 {
312 Check(hWnd, R_ENABLE, st.IsEnabled);
313 Check(hWnd, R_DISABLE, !st.IsEnabled);
314 }
315 else
316 {
317 Disable(hWnd, IDCANCEL);
318 DisableClose(hWnd);
319 }
320
321 SmAzureDlgRefresh(hWnd, a);
322 }
323
324 // Update the dialog
SmAzureDlgRefresh(HWND hWnd,SM_AZURE * a)325 void SmAzureDlgRefresh(HWND hWnd, SM_AZURE *a)
326 {
327 RPC_AZURE_STATUS st;
328 DDNS_CLIENT_STATUS ddns;
329 char tmp[MAX_SIZE];
330 // Validate arguments
331 if (hWnd == NULL || a == NULL)
332 {
333 return;
334 }
335
336 Zero(&st, sizeof(st));
337 Zero(&ddns, sizeof(ddns));
338
339 if (CALL(hWnd, ScGetAzureStatus(a->s->Rpc, &st)) == false)
340 {
341 EndDialog(hWnd, 0);
342 return;
343 }
344
345 if (CALL(hWnd, ScGetDDnsClientStatus(a->s->Rpc, &ddns)) == false)
346 {
347 EndDialog(hWnd, 0);
348 return;
349 }
350
351 if (st.IsEnabled == false)
352 {
353 SetText(hWnd, S_STATUS, _UU("SM_AZURE_STATUS_NOT_CONNECTED"));
354 Disable(hWnd, S_STATUS);
355 }
356 else
357 {
358 SetText(hWnd, S_STATUS, (st.IsConnected ? _UU("SM_AZURE_STATUS_CONNECTED") : _UU("SM_AZURE_STATUS_NOT_CONNECTED")));
359 Enable(hWnd, S_STATUS);
360 }
361
362 SetShow(hWnd, S_HOSTNAME_BORDER, st.IsEnabled);
363 SetShow(hWnd, S_HOSTNAME_INFO, st.IsEnabled);
364 SetShow(hWnd, B_CHANGE, st.IsEnabled);
365
366 if (st.IsEnabled == false || IsEmptyStr(ddns.CurrentHostName))
367 {
368 Hide(hWnd, E_HOST);
369 }
370 else
371 {
372 StrCpy(tmp, sizeof(tmp), ddns.CurrentHostName);
373 StrCat(tmp, sizeof(tmp), AZURE_DOMAIN_SUFFIX);
374
375 SetTextA(hWnd, E_HOST, tmp);
376
377 Show(hWnd, E_HOST);
378 }
379 }
380
381 // VPN Azure Setup screen
SmAzure(HWND hWnd,SM_SERVER * s,bool on_setup)382 void SmAzure(HWND hWnd, SM_SERVER *s, bool on_setup)
383 {
384 SM_AZURE a;
385 // Validate arguments
386 if (s == NULL)
387 {
388 return;
389 }
390
391 Zero(&a, sizeof(a));
392
393 a.s = s;
394 a.OnSetup = on_setup;
395
396 Dialog(hWnd, D_SM_AZURE, SmAzureDlg, &a);
397 }
398
399 // Notification screen about the bridge in VM
SmVmBridgeDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)400 UINT SmVmBridgeDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
401 {
402 switch (msg)
403 {
404 case WM_INITDIALOG:
405 DlgFont(hWnd, S_TITLE, 14, true);
406 SetIcon(hWnd, 0, ICO_NIC_ONLINE);
407 break;
408
409 case WM_COMMAND:
410 switch (wParam)
411 {
412 case IDOK:
413 case IDCANCEL:
414 Close(hWnd);
415 break;
416 }
417 break;
418
419 case WM_CLOSE:
420 EndDialog(hWnd, 0);
421 break;
422 }
423
424 return 0;
425 }
426
427 // Setting screen of VPN over ICMP, etc.
SmSpecialListener(HWND hWnd,SM_SERVER * s)428 void SmSpecialListener(HWND hWnd, SM_SERVER *s)
429 {
430 // Validate arguments
431 if (s == NULL)
432 {
433 return;
434 }
435
436 Dialog(hWnd, D_SM_SPECIALLISTENER, SmSpecialListenerDlg, s);
437 }
SmSpecialListenerDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)438 UINT SmSpecialListenerDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
439 {
440 SM_SERVER *s = (SM_SERVER *)param;
441
442 switch (msg)
443 {
444 case WM_INITDIALOG:
445 SmSpecialListenerDlgInit(hWnd, s);
446 break;
447
448 case WM_COMMAND:
449 switch (wParam)
450 {
451 case IDOK:
452 SmSpecialListenerDlgOnOk(hWnd, s);
453 break;
454
455 case IDCANCEL:
456 Close(hWnd);
457 break;
458 }
459 break;
460
461 case WM_CLOSE:
462 EndDialog(hWnd, 0);
463 break;
464 }
465
466 return 0;
467 }
SmSpecialListenerDlgInit(HWND hWnd,SM_SERVER * s)468 void SmSpecialListenerDlgInit(HWND hWnd, SM_SERVER *s)
469 {
470 RPC_SPECIAL_LISTENER t;
471 // Validate arguments
472 if (hWnd == NULL || s == NULL)
473 {
474 return;
475 }
476
477 SetIcon(hWnd, 0, ICO_SPECIALLISTENER);
478
479 DlgFont(hWnd, S_TITLE, 14, true);
480 DlgFont(hWnd, S_1, 0, true);
481 DlgFont(hWnd, R_OVER_ICMP, 0, true);
482 DlgFont(hWnd, R_OVER_DNS, 0, true);
483
484 Zero(&t, sizeof(t));
485
486 if (CALL(hWnd, ScGetSpecialListener(s->Rpc, &t)) == false)
487 {
488 Close(hWnd);
489 return;
490 }
491
492 Check(hWnd, R_OVER_ICMP, t.VpnOverIcmpListener);
493 Check(hWnd, R_OVER_DNS, t.VpnOverDnsListener);
494 }
SmSpecialListenerDlgOnOk(HWND hWnd,SM_SERVER * s)495 void SmSpecialListenerDlgOnOk(HWND hWnd, SM_SERVER *s)
496 {
497 RPC_SPECIAL_LISTENER t;
498 // Validate arguments
499 if (hWnd == NULL || s == NULL)
500 {
501 return;
502 }
503
504 Zero(&t, sizeof(t));
505
506 t.VpnOverIcmpListener = IsChecked(hWnd, R_OVER_ICMP);
507 t.VpnOverDnsListener = IsChecked(hWnd, R_OVER_DNS);
508
509 if (CALL(hWnd, ScSetSpecialListener(s->Rpc, &t)) == false)
510 {
511 return;
512 }
513
514 EndDialog(hWnd, 1);
515 }
516
517
518 // DDNS dialog
SmDDns(HWND hWnd,SM_SERVER * s,bool silent,bool no_change_cert)519 bool SmDDns(HWND hWnd, SM_SERVER *s, bool silent, bool no_change_cert)
520 {
521 SM_DDNS d;
522 // Validate arguments
523 if (s == NULL)
524 {
525 return false;
526 }
527
528 Zero(&d, sizeof(d));
529 d.s = s;
530 d.Silent = silent;
531 d.NoChangeCert = no_change_cert;
532
533 Dialog(hWnd, D_SM_DDNS, SmDDnsDlg, &d);
534
535 return d.Changed;
536 }
SmDDnsDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)537 UINT SmDDnsDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
538 {
539 SM_DDNS *d = (SM_DDNS *)param;
540 // Validate arguments
541 if (hWnd == NULL)
542 {
543 return 0;
544 }
545
546 switch (msg)
547 {
548 case WM_INITDIALOG:
549 SmDDnsDlgInit(hWnd, d);
550
551 SetTimer(hWnd, 1, 1000, NULL);
552 break;
553
554 case WM_COMMAND:
555 switch (LOWORD(wParam))
556 {
557 case E_NEWHOST:
558 SmDDnsDlgUpdate(hWnd, d);
559 break;
560 }
561
562 switch (wParam)
563 {
564 case IDOK:
565 SmDDnsDlgOnOk(hWnd, d);
566 break;
567
568 case B_RESTORE:
569 // Restore to original
570 if (d->Status.Err_IPv4 == ERR_NO_ERROR || d->Status.Err_IPv6 == ERR_NO_ERROR)
571 {
572 SetTextA(hWnd, E_NEWHOST, d->Status.CurrentHostName);
573 SmDDnsDlgUpdate(hWnd, d);
574 FocusEx(hWnd, E_NEWHOST);
575 }
576 break;
577
578 case IDCANCEL:
579 Close(hWnd);
580 break;
581
582 case B_DISABLE:
583 d->DoNotPoll = true;
584
585 OnceMsg(hWnd, _UU("SM_DISABLE_DDNS_HINT_CAPTION"), _UU("SM_DISABLE_DDNS_HINT"), false, ICO_INFORMATION);
586
587 d->DoNotPoll = false;
588 break;
589
590 case B_HINT:
591 // Hint
592 if (d->Status.Err_IPv4 == ERR_NO_ERROR || d->Status.Err_IPv6 == ERR_NO_ERROR)
593 {
594 wchar_t tmp[MAX_SIZE * 4];
595 wchar_t ipv4[MAX_SIZE], ipv6[MAX_SIZE];
596
597 StrToUni(ipv4, sizeof(ipv4), d->Status.CurrentIPv4);
598 StrToUni(ipv6, sizeof(ipv6), d->Status.CurrentIPv6);
599
600 if (UniIsEmptyStr(ipv4))
601 {
602 UniStrCpy(ipv4, sizeof(ipv4), _UU("SM_DDNS_FQDN_EMPTY"));
603 }
604
605 if (UniIsEmptyStr(ipv6))
606 {
607 UniStrCpy(ipv6, sizeof(ipv6), _UU("SM_DDNS_FQDN_EMPTY"));
608 }
609
610 UniFormat(tmp, sizeof(tmp),
611 _UU("SM_DDNS_OK_MSG"),
612 d->Status.CurrentHostName, d->Status.DnsSuffix,
613 ipv4, ipv6,
614 d->Status.CurrentHostName, d->Status.DnsSuffix,
615 d->Status.CurrentHostName, d->Status.DnsSuffix);
616
617 d->DoNotPoll = true;
618
619 OnceMsg(hWnd, _UU("SM_DDNS_OK_TITLE"), tmp, false, ICO_DISPLAY);
620
621 d->DoNotPoll = false;
622 }
623 break;
624
625 case B_HINT2:
626 // Hint2 (for DDNS key)
627 {
628 wchar_t tmp[MAX_SIZE * 4];
629 wchar_t *keystr;
630
631 keystr = GetText(hWnd, E_KEY);
632 UniFormat(tmp, sizeof(tmp), _UU("SM_DDNS_KEY_MSG"), keystr);
633 Free(keystr);
634 OnceMsg(hWnd, _UU("SM_DDNS_KEY_TITLE"), tmp, false, ICO_DISPLAY);
635 }
636 break;
637
638 case B_PROXY:
639 // Proxy settings
640 if (true)
641 {
642 INTERNET_SETTING t;
643
644 if (CALL(hWnd, ScGetDDnsInternetSetting(d->s->Rpc, &t)))
645 {
646 if (SmProxy(hWnd, &t))
647 {
648 if (CALL(hWnd, ScSetDDnsInternetSetting(d->s->Rpc, &t)))
649 {
650 SmDDnsRefresh(hWnd, d);
651 }
652 }
653 }
654 }
655 break;
656 }
657 break;
658
659 case WM_TIMER:
660 switch (wParam)
661 {
662 case 1:
663 if (IsEnable(hWnd, 0))
664 {
665 KillTimer(hWnd, 1);
666
667 SmDDnsRefresh(hWnd, d);
668
669 SetTimer(hWnd, 1, 1000, NULL);
670 }
671 break;
672 }
673 break;
674
675 case WM_CLOSE:
676 if (d->Changed || d->Silent)
677 {
678 // Check the server certificate if the host name has been changed
679 RPC_KEY_PAIR t;
680 char fqdn[MAX_SIZE];
681 bool is_vgs_enabled = false;
682
683
684 StrCpy(fqdn, sizeof(fqdn), d->Status.CurrentFqdn);
685
686 if (IsEmptyStr(fqdn) == false)
687 {
688 Zero(&t, sizeof(t));
689 if (ScGetServerCert(d->s->Rpc, &t) == ERR_NO_ERROR)
690 {
691 if (t.Cert != NULL && t.Cert->root_cert && t.Cert->subject_name != NULL && is_vgs_enabled == false)
692 {
693 char cn[MAX_SIZE];
694
695 UniToStr(cn, sizeof(cn), t.Cert->subject_name->CommonName);
696
697 if ((StrCmpi(cn, fqdn) != 0) && (d->NoChangeCert == false))
698 {
699 // Confirm whether the user want to replace the server certificate
700 if (d->Silent || (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO,
701 _UU("SM_DDNS_SERVER_CERT_MSG"),
702 fqdn, fqdn) == IDYES))
703 {
704 // Re-generate the server certificate
705 RPC_TEST tt;
706
707 Zero(&tt, sizeof(tt));
708
709 StrCpy(tt.StrValue, sizeof(tt.StrValue), fqdn);
710
711 SetText(hWnd, IDCANCEL, _UU("CM_VLAN_INSTALLING"));
712 Refresh(DlgItem(hWnd, IDCANCEL));
713 Refresh(hWnd);
714 DoEvents(NULL);
715
716 if (CALL(hWnd, ScRegenerateServerCert(d->s->Rpc, &tt)))
717 {
718 // Confirm whether the user want to save the server certificate
719 if ((d->Silent == false) && (
720 MsgBoxEx(hWnd, MB_ICONINFORMATION | MB_YESNO,
721 _UU("SM_DDNS_SERVER_CERT_OK"),
722 fqdn) == IDYES))
723 {
724 // Get the server certificate
725 RPC_KEY_PAIR t2;
726
727 Zero(&t2, sizeof(t2));
728 if (CALL(hWnd, ScGetServerCert(d->s->Rpc, &t2)))
729 {
730 wchar_t *name;
731 wchar_t defname[MAX_PATH];
732
733 StrToUni(defname, sizeof(defname), fqdn);
734 UniStrCat(defname, sizeof(defname), L".cer");
735
736 name = SaveDlg(hWnd, _UU("DLG_CERT_FILES"), _UU("DLG_SAVE_CERT"), defname, L".cer");
737
738 if (name != NULL)
739 {
740 if (XToFileW(t2.Cert, name, true))
741 {
742 MsgBox(hWnd, MB_ICONINFORMATION, _UU("DLG_CERT_SAVE_OK"));
743 }
744 else
745 {
746 MsgBox(hWnd, MB_ICONSTOP, _UU("DLG_CERT_SAVE_ERROR"));
747 }
748
749 Free(name);
750 }
751
752 FreeRpcKeyPair(&t2);
753 }
754 }
755 }
756 }
757 }
758 }
759
760 FreeRpcKeyPair(&t);
761 }
762 }
763 }
764
765 EndDialog(hWnd, 0);
766 break;
767 }
768
769 return 0;
770 }
771
772 // Get the ddns key from the server configuration file
SmDdnsGetKey(char * key,SM_DDNS * d)773 static UINT SmDdnsGetKey(char *key, SM_DDNS *d){
774 RPC_CONFIG config;
775 UINT err;
776 BUF *buf;
777 FOLDER *root, *ddnsfolder;
778 RPC *rpc;
779
780 // Validate arguments
781 if(d == NULL || d->s == NULL || key == NULL){
782 return ERR_INTERNAL_ERROR;
783 }
784
785 rpc = d->s->Rpc;
786
787 Zero(&config, sizeof(config));
788 err = ScGetConfig(d->s->Rpc, &config);
789 if(err != ERR_NO_ERROR){
790 return err;
791 }
792
793 buf = NewBufFromMemory(config.FileData, StrLen(config.FileData));
794 FreeRpcConfig(&config);
795
796 root = CfgBufTextToFolder(buf);
797 FreeBuf(buf);
798
799 ddnsfolder = CfgGetFolder(root, "DDnsClient");
800 err = CfgGetByte(ddnsfolder, "Key", key, 20);
801
802 CfgDeleteFolder(root);
803
804 return (err == 20) ? ERR_NO_ERROR : ERR_INTERNAL_ERROR;
805 }
806
SmDDnsDlgInit(HWND hWnd,SM_DDNS * d)807 void SmDDnsDlgInit(HWND hWnd, SM_DDNS *d)
808 {
809 char key[20];
810 char encodedkey[20 * 4 + 32];
811
812 // Validate arguments
813 if (hWnd == NULL || d == NULL)
814 {
815 return;
816 }
817
818 d->DoNotPoll = false;
819
820 SetIcon(hWnd, 0, ICO_DISPLAY);
821
822 DlgFont(hWnd, S_TITLE, 14, true);
823
824 DlgFont(hWnd, S_BOLD, 0, true);
825 DlgFont(hWnd, S_STATUS3, 0, true);
826 DlgFont(hWnd, S_STATUS4, 0, true);
827 DlgFont(hWnd, S_STATUS5, 0, true);
828 DlgFont(hWnd, S_STATUS6, 0, true);
829 DlgFont(hWnd, S_STATUS8, 0, true);
830
831 SetFont(hWnd, S_SUFFIX, GetFont("Verdana", 10, false, false, false, false));
832 SetFont(hWnd, E_NEWHOST, GetFont("Verdana", 10, false, false, false, false));
833
834 SetFont(hWnd, E_HOST, GetFont("Verdana", 10, false, false, false, false));
835 SetFont(hWnd, E_IPV4, GetFont("Verdana", 10, false, false, false, false));
836 SetFont(hWnd, E_IPV6, GetFont("Verdana", 10, false, false, false, false));
837 SetFont(hWnd, E_KEY, GetFont("Verdana", 8, false, false, false, false));
838
839 DlgFont(hWnd, IDOK, 0, true);
840
841 if (d->Silent)
842 {
843 Hide(hWnd, B_DISABLE);
844 }
845
846 Hide(hWnd, B_PROXY);
847
848 if(SmDdnsGetKey(key, d) == ERR_NO_ERROR){
849 encodedkey[ B64_Encode(encodedkey, key, 20) ] = 0;
850 SetTextA(hWnd, E_KEY, encodedkey);
851 }else{
852 SetText(hWnd, E_KEY, _UU("SM_DDNS_KEY_ERR"));
853 }
854
855 SmDDnsRefresh(hWnd, d);
856 }
857
SmDDnsRefresh(HWND hWnd,SM_DDNS * d)858 void SmDDnsRefresh(HWND hWnd, SM_DDNS *d)
859 {
860 DDNS_CLIENT_STATUS st;
861 INTERNET_SETTING t;
862
863 // Validate arguments
864 if (hWnd == NULL || d == NULL)
865 {
866 return;
867 }
868
869 if (d->DoNotPoll)
870 {
871 return;
872 }
873
874 Zero(&st, sizeof(st));
875 Zero(&t, sizeof(t));
876
877 // Get the status
878 if (CALL(hWnd, ScGetDDnsClientStatus(d->s->Rpc, &st)) == false)
879 {
880 Close(hWnd);
881 return;
882 }
883
884 ScGetDDnsInternetSetting(d->s->Rpc, &t);
885
886 Copy(&d->Status, &st, sizeof(st));
887
888 if (IsEmptyStr(st.CurrentFqdn) == false)
889 {
890 SetTextA(hWnd, E_HOST, st.CurrentFqdn);
891 }
892 else
893 {
894 SetText(hWnd, E_HOST, _UU("SM_DDNS_FQDN_EMPTY"));
895 }
896
897 if (st.Err_IPv4 == ERR_NO_ERROR)
898 {
899 SetTextA(hWnd, E_IPV4, st.CurrentIPv4);
900 }
901 else
902 {
903 if (st.Err_IPv4 == ERR_CONNECT_FAILED)
904 {
905 SetText(hWnd, E_IPV4, _UU("SM_DDNS_IPV4_ERROR"));
906 }
907 else
908 {
909 SetText(hWnd, E_IPV4, _E(st.Err_IPv4));
910 }
911 }
912
913 if (st.Err_IPv6 == ERR_NO_ERROR)
914 {
915 SetTextA(hWnd, E_IPV6, st.CurrentIPv6);
916 }
917 else
918 {
919 if (st.Err_IPv6 == ERR_CONNECT_FAILED)
920 {
921 SetText(hWnd, E_IPV6, _UU("SM_DDNS_IPV6_ERROR"));
922 }
923 else
924 {
925 SetText(hWnd, E_IPV6, _E(st.Err_IPv6));
926 }
927 }
928
929 if (st.Err_IPv4 == ERR_NO_ERROR || st.Err_IPv6 == ERR_NO_ERROR)
930 {
931 if (IsEmptyStr(st.DnsSuffix) == false)
932 {
933 SetTextA(hWnd, S_SUFFIX, st.DnsSuffix);
934 }
935
936 Enable(hWnd, S_STATUS6);
937 Enable(hWnd, E_NEWHOST);
938 Enable(hWnd, S_SUFFIX);
939 Enable(hWnd, S_STATUS7);
940 Enable(hWnd, B_HINT);
941 }
942 else
943 {
944 SetTextA(hWnd, S_SUFFIX, "");
945
946 Disable(hWnd, S_STATUS6);
947 Disable(hWnd, E_NEWHOST);
948 Disable(hWnd, S_SUFFIX);
949 Disable(hWnd, S_STATUS7);
950 Disable(hWnd, B_HINT);
951 }
952
953 if (GetCapsBool(d->s->CapsList, "b_support_ddns_proxy"))
954 {
955 // Show the proxy button
956 Show(hWnd, B_PROXY);
957 }
958 else
959 {
960 // Hide the proxy button
961 Hide(hWnd, B_PROXY);
962 }
963
964 SmDDnsDlgUpdate(hWnd, d);
965
966 if (d->Flag == false)
967 {
968 d->Flag = true;
969 }
970
971 if (IsEmptyStr(st.CurrentHostName) == false)
972 {
973 if (d->HostnameSetFlag == false)
974 {
975 d->HostnameSetFlag = true;
976
977 SetTextA(hWnd, E_NEWHOST, st.CurrentHostName);
978
979 FocusEx(hWnd, E_NEWHOST);
980 }
981 }
982 }
SmDDnsDlgUpdate(HWND hWnd,SM_DDNS * d)983 void SmDDnsDlgUpdate(HWND hWnd, SM_DDNS *d)
984 {
985 char tmp[MAX_SIZE];
986 bool b = false;
987
988 // Validate arguments
989 if (hWnd == NULL || d == NULL)
990 {
991 return;
992 }
993
994 if (GetTxtA(hWnd, E_NEWHOST, tmp, sizeof(tmp)))
995 {
996 Trim(tmp);
997
998 // Get whether the host name have changed
999 if (IsEmptyStr(tmp) == false)
1000 {
1001 if (StrCmpi(d->Status.CurrentHostName, tmp) != 0)
1002 {
1003 if (d->Status.Err_IPv4 == ERR_NO_ERROR || d->Status.Err_IPv6 == ERR_NO_ERROR)
1004 {
1005 b = true;
1006 }
1007 }
1008 }
1009 }
1010
1011 SetEnable(hWnd, IDOK, b);
1012 SetEnable(hWnd, B_RESTORE, b);
1013 }
SmDDnsDlgOnOk(HWND hWnd,SM_DDNS * d)1014 void SmDDnsDlgOnOk(HWND hWnd, SM_DDNS *d)
1015 {
1016 RPC_TEST t;
1017 // Validate arguments
1018 if (hWnd == NULL || d == NULL)
1019 {
1020 return;
1021 }
1022
1023 Zero(&t, sizeof(t));
1024 GetTxtA(hWnd, E_NEWHOST, t.StrValue, sizeof(t.StrValue));
1025
1026 if (CALL(hWnd, ScChangeDDnsClientHostname(d->s->Rpc, &t)) == false)
1027 {
1028 return;
1029 }
1030
1031 d->Changed = true;
1032
1033 SmDDnsRefresh(hWnd, d);
1034 FocusEx(hWnd, E_NEWHOST);
1035
1036 MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("SM_DDNS_OK_MSG2"), t.StrValue);
1037 FocusEx(hWnd, E_NEWHOST);
1038 }
1039
1040 // Open the OpenVPN dialog
SmOpenVpn(HWND hWnd,SM_SERVER * s)1041 void SmOpenVpn(HWND hWnd, SM_SERVER *s)
1042 {
1043 // Validate arguments
1044 if (s == NULL)
1045 {
1046 return;
1047 }
1048
1049 Dialog(hWnd, D_SM_OPENVPN, SmOpenVpnDlg, s);
1050 }
1051
1052 // OpenVPN dialog
SmOpenVpnDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1053 UINT SmOpenVpnDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1054 {
1055 SM_SERVER *s = (SM_SERVER *)param;
1056 // Validate arguments
1057 if (hWnd == NULL)
1058 {
1059 return 0;
1060 }
1061
1062 switch (msg)
1063 {
1064 case WM_INITDIALOG:
1065 SmOpenVpnDlgInit(hWnd, s);
1066 break;
1067
1068 case WM_COMMAND:
1069 switch (LOWORD(wParam))
1070 {
1071 case R_OPENVPN:
1072 case R_SSTP:
1073 SmOpenVpnDlgUpdate(hWnd, s);
1074 break;
1075 }
1076
1077 switch (wParam)
1078 {
1079 case IDOK:
1080 SmOpenVpnDlgOnOk(hWnd, s, false);
1081 break;
1082
1083 case B_CONFIG:
1084 // Create an OpenVPN configuration
1085 {
1086 OPENVPN_SSTP_CONFIG t2;
1087 RPC_READ_LOG_FILE t;
1088
1089 Zero(&t2, sizeof(t2));
1090
1091 if (CALL(hWnd, ScGetOpenVpnSstpConfig(s->Rpc, &t2)))
1092 {
1093 if (t2.EnableOpenVPN == false)
1094 {
1095 // Enable the OpenVPN first
1096 SmOpenVpnDlgOnOk(hWnd, s, true);
1097
1098 Disable(hWnd, IDCANCEL);
1099 }
1100 }
1101 else
1102 {
1103 break;
1104 }
1105
1106 Zero(&t, sizeof(t));
1107
1108 if (CALL(hWnd, ScMakeOpenVpnConfigFile(s->Rpc, &t)))
1109 {
1110 // Generate a file name
1111 wchar_t filename[MAX_SIZE];
1112 char safe_hostname[MAX_SIZE];
1113 SYSTEMTIME st;
1114 wchar_t *dst;
1115
1116 MakeSafeFileName(safe_hostname, sizeof(safe_hostname), s->ServerName);
1117
1118 LocalTime(&st);
1119
1120 UniFormat(filename, sizeof(filename),
1121 L"OpenVPN_Sample_Config_%S_%04u%02u%02u_%02u%02u%02u.zip",
1122 safe_hostname,
1123 st.wYear, st.wMonth, st.wDay,
1124 st.wHour, st.wMinute, st.wSecond);
1125
1126 dst = SaveDlg(hWnd, _UU("DLG_ZIP_FILER"), _UU("DLG_SAVE_OPENVPN_CONFIG"),
1127 filename, L".zip");
1128
1129 if (dst != NULL)
1130 {
1131 // Save
1132 if (DumpBufW(t.Buffer, dst) == false)
1133 {
1134 // Failure
1135 MsgBoxEx(hWnd, MB_ICONSTOP, _UU("SM_OPENVPN_CONFIG_SAVE_NG"), dst);
1136 }
1137 else
1138 {
1139 // Success
1140 if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("SM_OPENVPN_CONFIG_SAVE_OK"), dst) == IDYES)
1141 {
1142 if (MsExecuteW(dst, L"") == false)
1143 {
1144 MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("SM_OPENVPN_CONFIG_OPEN_NG"), dst);
1145 }
1146 }
1147 }
1148
1149 Free(dst);
1150 }
1151
1152 FreeRpcReadLogFile(&t);
1153 }
1154 }
1155 break;
1156
1157 case B_IPSEC:
1158 SmIPsec(hWnd, s);
1159 break;
1160
1161 case IDCANCEL:
1162 Close(hWnd);
1163 break;
1164 }
1165 break;
1166
1167 case WM_CLOSE:
1168 EndDialog(hWnd, 0);
1169 break;
1170 }
1171
1172 return 0;
1173 }
SmOpenVpnDlgInit(HWND hWnd,SM_SERVER * s)1174 void SmOpenVpnDlgInit(HWND hWnd, SM_SERVER *s)
1175 {
1176 OPENVPN_SSTP_CONFIG t;
1177 // Validate arguments
1178 if (hWnd == NULL || s == NULL)
1179 {
1180 return;
1181 }
1182
1183 Zero(&t, sizeof(t));
1184 if (CALL(hWnd, ScGetOpenVpnSstpConfig(s->Rpc, &t)) == false)
1185 {
1186 Close(hWnd);
1187 return;
1188 }
1189
1190 Check(hWnd, R_OPENVPN, t.EnableOpenVPN);
1191 Check(hWnd, R_SSTP, t.EnableSSTP);
1192
1193 SetIcon(hWnd, 0, ICO_OPENVPN);
1194
1195 DlgFont(hWnd, S_TITLE, 14, true);
1196
1197 DlgFont(hWnd, R_OPENVPN, 0, true);
1198 DlgFont(hWnd, S_TOOL, 11, true);
1199 DlgFont(hWnd, R_SSTP, 0, true);
1200
1201 SmOpenVpnDlgUpdate(hWnd, s);
1202 }
SmOpenVpnDlgUpdate(HWND hWnd,SM_SERVER * s)1203 void SmOpenVpnDlgUpdate(HWND hWnd, SM_SERVER *s)
1204 {
1205 bool b1, b2;
1206 // Validate arguments
1207 if (hWnd == NULL || s == NULL)
1208 {
1209 return;
1210 }
1211
1212 b1 = IsChecked(hWnd, R_OPENVPN);
1213 b2 = IsChecked(hWnd, R_SSTP);
1214
1215 SetEnable(hWnd, S_TOOL, b1);
1216 SetEnable(hWnd, S_TOOL2, b1);
1217 SetEnable(hWnd, B_CONFIG, b1);
1218
1219 SetEnable(hWnd, S_SSTP, b2);
1220 }
SmOpenVpnDlgOnOk(HWND hWnd,SM_SERVER * s,bool no_close)1221 void SmOpenVpnDlgOnOk(HWND hWnd, SM_SERVER *s, bool no_close)
1222 {
1223 OPENVPN_SSTP_CONFIG t;
1224 // Validate arguments
1225 if (hWnd == NULL || s == NULL)
1226 {
1227 return;
1228 }
1229
1230 Zero(&t, sizeof(t));
1231
1232 t.EnableOpenVPN = IsChecked(hWnd, R_OPENVPN);
1233 t.EnableSSTP = IsChecked(hWnd, R_SSTP);
1234
1235 if (CALL(hWnd, ScSetOpenVpnSstpConfig(s->Rpc, &t)) == false)
1236 {
1237 return;
1238 }
1239
1240 if (no_close == false)
1241 {
1242 EndDialog(hWnd, 1);
1243 }
1244 }
1245
1246 // Open the EtherIP ID edit dialog
SmEtherIpId(HWND hWnd,SM_ETHERIP_ID * t)1247 bool SmEtherIpId(HWND hWnd, SM_ETHERIP_ID *t)
1248 {
1249 // Validate arguments
1250 if (t == NULL)
1251 {
1252 return false;
1253 }
1254
1255 if (Dialog(hWnd, D_SM_ETHERIP_ID, SmEtherIpIdDlg, t) == 0)
1256 {
1257 return false;
1258 }
1259
1260 return true;
1261 }
1262
1263 // EtherIP ID edit dialog procedure
SmEtherIpIdDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1264 UINT SmEtherIpIdDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1265 {
1266 SM_ETHERIP_ID *t = (SM_ETHERIP_ID *)param;
1267 // Validate arguments
1268 if (hWnd == NULL)
1269 {
1270 return 0;
1271 }
1272
1273 switch (msg)
1274 {
1275 case WM_INITDIALOG:
1276 SmEtherIpIdDlgInit(hWnd, t);
1277 break;
1278
1279 case WM_COMMAND:
1280 switch (LOWORD(wParam))
1281 {
1282 case E_ID:
1283 case L_HUBNAME:
1284 case E_USERNAME:
1285 SmEtherIpIdDlgUpdate(hWnd, t);
1286 break;
1287 }
1288
1289 switch (wParam)
1290 {
1291 case IDOK:
1292 SmEtherIpIdDlgOnOk(hWnd, t);
1293 break;
1294
1295 case IDCANCEL:
1296 Close(hWnd);
1297 break;
1298 }
1299 break;
1300
1301 case WM_CLOSE:
1302 EndDialog(hWnd, 0);
1303 break;
1304 }
1305
1306 return 0;
1307 }
1308
1309 // Initialize the EtherIP ID edit dialog
SmEtherIpIdDlgInit(HWND hWnd,SM_ETHERIP_ID * t)1310 void SmEtherIpIdDlgInit(HWND hWnd, SM_ETHERIP_ID *t)
1311 {
1312 RPC_ENUM_HUB tt;
1313 UINT sel_index;
1314 UINT i;
1315 // Validate arguments
1316 if (hWnd == NULL || t == NULL)
1317 {
1318 return;
1319 }
1320
1321 SetIcon(hWnd, 0, ICO_KEY);
1322
1323 // Get the current data in the case of edit mode
1324 if (t->EditMode)
1325 {
1326 Zero(&t->Data, sizeof(t->Data));
1327 StrCpy(t->Data.Id, sizeof(t->Data.Id), t->EditId);
1328
1329 if (CALL(hWnd, ScGetEtherIpId(t->s->Rpc, &t->Data)) == false)
1330 {
1331 EndDialog(hWnd, 0);
1332 return;
1333 }
1334 }
1335
1336 // Enumerate the Virtual HUBs
1337 Zero(&tt, sizeof(tt));
1338 if (CALL(hWnd, ScEnumHub(t->s->Rpc, &tt)) == false)
1339 {
1340 EndDialog(hWnd, 0);
1341 return;
1342 }
1343
1344 CbReset(hWnd, L_HUBNAME);
1345 CbSetHeight(hWnd, L_HUBNAME, 18);
1346 sel_index = INFINITE;
1347
1348 for (i = 0;i < tt.NumHub;i++)
1349 {
1350 RPC_ENUM_HUB_ITEM *e = &tt.Hubs[i];
1351 UINT index;
1352
1353 index = CbAddStrA(hWnd, L_HUBNAME, e->HubName, 0);
1354 if (sel_index == INFINITE)
1355 {
1356 sel_index = index;
1357 }
1358
1359 if (t->EditMode)
1360 {
1361 if (StrCmpi(e->HubName, t->Data.HubName) == 0)
1362 {
1363 sel_index = index;
1364 }
1365 }
1366 }
1367
1368 if (sel_index != INFINITE)
1369 {
1370 CbSelectIndex(hWnd, L_HUBNAME, sel_index);
1371 }
1372
1373 if (t->EditMode)
1374 {
1375 SetTextA(hWnd, E_ID, t->Data.Id);
1376 SetTextA(hWnd, E_USERNAME, t->Data.UserName);
1377 SetTextA(hWnd, E_PASSWORD, t->Data.Password);
1378
1379 FocusEx(hWnd, E_PASSWORD);
1380 }
1381 else
1382 {
1383 Focus(hWnd, E_ID);
1384 }
1385
1386 FreeRpcEnumHub(&tt);
1387
1388 t->InitCompleted = true;
1389 SmEtherIpIdDlgUpdate(hWnd, t);
1390 }
1391
1392 // EtherIP ID edit dialog: Click the OK button
SmEtherIpIdDlgOnOk(HWND hWnd,SM_ETHERIP_ID * t)1393 void SmEtherIpIdDlgOnOk(HWND hWnd, SM_ETHERIP_ID *t)
1394 {
1395 // Validate arguments
1396 if (hWnd == NULL || t == NULL)
1397 {
1398 return;
1399 }
1400
1401 SmEtherIpIdDlgGetSetting(hWnd, t);
1402
1403 if (t->EditMode)
1404 {
1405 ETHERIP_ID d;
1406 // Delete old items
1407 Zero(&d, sizeof(d));
1408
1409 StrCpy(d.Id, sizeof(d.Id), t->EditId);
1410
1411 ScDeleteEtherIpId(t->s->Rpc, &d);
1412 }
1413
1414 if (CALL(hWnd, ScAddEtherIpId(t->s->Rpc, &t->Data)) == false)
1415 {
1416 return;
1417 }
1418
1419 if (t->EditMode == false)
1420 {
1421 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_ETHERIP_ADD_OK"));
1422 }
1423
1424 EndDialog(hWnd, 1);
1425 }
1426
1427 // EtherIP ID edit dialog: Update the controls
SmEtherIpIdDlgUpdate(HWND hWnd,SM_ETHERIP_ID * t)1428 void SmEtherIpIdDlgUpdate(HWND hWnd, SM_ETHERIP_ID *t)
1429 {
1430 bool ok = true;
1431 // Validate arguments
1432 if (hWnd == NULL || t == NULL)
1433 {
1434 return;
1435 }
1436
1437 if (t->InitCompleted == false)
1438 {
1439 return;
1440 }
1441
1442 SmEtherIpIdDlgGetSetting(hWnd, t);
1443
1444 if (IsEmptyStr(t->Data.Id) ||
1445 IsEmptyStr(t->Data.HubName) ||
1446 IsEmptyStr(t->Data.UserName))
1447 {
1448 ok = false;
1449 }
1450
1451 SetEnable(hWnd, IDOK, ok);
1452 }
1453
1454 // EtherIP ID edit dialog: Get the current settings
SmEtherIpIdDlgGetSetting(HWND hWnd,SM_ETHERIP_ID * t)1455 void SmEtherIpIdDlgGetSetting(HWND hWnd, SM_ETHERIP_ID *t)
1456 {
1457 wchar_t *ws;
1458 // Validate arguments
1459 if (hWnd == NULL || t == NULL)
1460 {
1461 return;
1462 }
1463
1464 Zero(&t->Data, sizeof(t->Data));
1465
1466 GetTxtA(hWnd, E_ID, t->Data.Id, sizeof(t->Data.Id));
1467 GetTxtA(hWnd, E_USERNAME, t->Data.UserName, sizeof(t->Data.UserName));
1468 GetTxtA(hWnd, E_PASSWORD, t->Data.Password, sizeof(t->Data.Password));
1469
1470 ws = CbGetStr(hWnd, L_HUBNAME);
1471
1472 if (ws != NULL && IsEmptyUniStr(ws) == false)
1473 {
1474 UniToStr(t->Data.HubName, sizeof(t->Data.HubName), ws);
1475 }
1476
1477 Free(ws);
1478 }
1479
1480
1481 // Open the EtherIP settings dialog
SmEtherIp(HWND hWnd,SM_SERVER * s)1482 void SmEtherIp(HWND hWnd, SM_SERVER *s)
1483 {
1484 // Validate arguments
1485 if (s == NULL)
1486 {
1487 return;
1488 }
1489
1490 Dialog(hWnd, D_SM_ETHERIP, SmEtherIpDlg, s);
1491 }
1492
1493 // EtherIP Setup dialog procedure
SmEtherIpDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1494 UINT SmEtherIpDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1495 {
1496 SM_SERVER *s = (SM_SERVER *)param;
1497 NMHDR *n;
1498 char *id;
1499 SM_ETHERIP_ID t;
1500 // Validate arguments
1501 if (hWnd == NULL)
1502 {
1503 return 0;
1504 }
1505
1506 switch (msg)
1507 {
1508 case WM_INITDIALOG:
1509 SmEtherIpDlgInit(hWnd, s);
1510 break;
1511
1512 case WM_COMMAND:
1513 switch (wParam)
1514 {
1515 case IDOK:
1516 // Edit
1517 id = LvGetSelectedStrA(hWnd, L_LIST, 0);
1518 if (id != NULL)
1519 {
1520 Zero(&t, sizeof(t));
1521 StrCpy(t.EditId, sizeof(t.EditId), id);
1522 t.EditMode = true;
1523 t.s = s;
1524
1525 if (SmEtherIpId(hWnd, &t))
1526 {
1527 SmEtherIpDlgRefresh(hWnd, s);
1528 }
1529
1530 Free(id);
1531 }
1532 break;
1533
1534 case B_ADD:
1535 // Add
1536 Zero(&t, sizeof(t));
1537 t.s = s;
1538 if (SmEtherIpId(hWnd, &t))
1539 {
1540 SmEtherIpDlgRefresh(hWnd, s);
1541 }
1542 break;
1543
1544 case B_DELETE:
1545 // Delete
1546 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("SM_CRL_DELETE_MSG")) == IDYES)
1547 {
1548 id = LvGetSelectedStrA(hWnd, L_LIST, 0);
1549 if (id != NULL)
1550 {
1551 ETHERIP_ID d;
1552
1553 Zero(&d, sizeof(d));
1554
1555 StrCpy(d.Id, sizeof(d.Id), id);
1556
1557 if (CALL(hWnd, ScDeleteEtherIpId(s->Rpc, &d)))
1558 {
1559 SmEtherIpDlgRefresh(hWnd, s);
1560 }
1561
1562 Free(id);
1563 }
1564 }
1565 break;
1566
1567 case IDCANCEL:
1568 // Close
1569 Close(hWnd);
1570 break;
1571 }
1572 break;
1573
1574 case WM_NOTIFY:
1575 n = (NMHDR *)lParam;
1576 switch (n->idFrom)
1577 {
1578 case L_LIST:
1579 switch (n->code)
1580 {
1581 case LVN_ITEMCHANGED:
1582 SmEtherIpDlgUpdate(hWnd, s);
1583 break;
1584
1585 case NM_DBLCLK:
1586 Command(hWnd, IDOK);
1587 break;
1588 }
1589 break;
1590 }
1591 break;
1592
1593 case WM_CLOSE:
1594 EndDialog(hWnd, 0);
1595 break;
1596 }
1597
1598 return 0;
1599 }
1600
1601 // EtherIP Setup dialog data update
SmEtherIpDlgRefresh(HWND hWnd,SM_SERVER * s)1602 void SmEtherIpDlgRefresh(HWND hWnd, SM_SERVER *s)
1603 {
1604 RPC_ENUM_ETHERIP_ID t;
1605 UINT i;
1606 LVB *b;
1607 // Validate arguments
1608 if (hWnd == NULL || s == NULL)
1609 {
1610 return;
1611 }
1612
1613 // Data update
1614 Zero(&t, sizeof(t));
1615
1616 if (CALL(hWnd, ScEnumEtherIpId(s->Rpc, &t)) == false)
1617 {
1618 EndDialog(hWnd, 0);
1619 return;
1620 }
1621
1622 b = LvInsertStart();
1623
1624 for (i = 0;i < t.NumItem;i++)
1625 {
1626 ETHERIP_ID *d = &t.IdList[i];
1627 wchar_t id[MAX_SIZE], hubname[MAX_SIZE], username[MAX_SIZE];
1628
1629 StrToUni(id, sizeof(id), d->Id);
1630 StrToUni(hubname, sizeof(hubname), d->HubName);
1631 StrToUni(username, sizeof(username), d->UserName);
1632
1633 LvInsertAdd(b, ICO_CASCADE, NULL, 3, id, hubname, username);
1634 }
1635
1636 LvInsertEnd(b, hWnd, L_LIST);
1637
1638 FreeRpcEnumEtherIpId(&t);
1639
1640 SmEtherIpDlgUpdate(hWnd, s);
1641 }
1642
1643 // Initialize the EtherIP settings dialog
SmEtherIpDlgInit(HWND hWnd,SM_SERVER * s)1644 void SmEtherIpDlgInit(HWND hWnd, SM_SERVER *s)
1645 {
1646 // Validate arguments
1647 if (hWnd == NULL || s == NULL)
1648 {
1649 return;
1650 }
1651
1652 SetIcon(hWnd, 0, ICO_MACHINE);
1653 DlgFont(hWnd, S_TITLE, 14, true);
1654 DlgFont(hWnd, S_BOLD, 0, true);
1655
1656 LvInit(hWnd, L_LIST);
1657 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_ETHERIP_COLUMN_0"), 205);
1658 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_ETHERIP_COLUMN_1"), 179);
1659 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_ETHERIP_COLUMN_2"), 154);
1660
1661 SmEtherIpDlgRefresh(hWnd, s);
1662 }
1663
1664 // EtherIP Settings dialog controls update
SmEtherIpDlgUpdate(HWND hWnd,SM_SERVER * s)1665 void SmEtherIpDlgUpdate(HWND hWnd, SM_SERVER *s)
1666 {
1667 // Validate arguments
1668 if (hWnd == NULL || s == NULL)
1669 {
1670 return;
1671 }
1672
1673 SetEnable(hWnd, IDOK, LvIsSingleSelected(hWnd, L_LIST));
1674 SetEnable(hWnd, B_DELETE, LvIsSingleSelected(hWnd, L_LIST));
1675 }
1676
1677 // IPsec Settings dialog procedure
SmIPsecDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1678 UINT SmIPsecDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1679 {
1680 SM_SERVER *s = (SM_SERVER *)param;
1681 // Validate arguments
1682 if (hWnd == NULL)
1683 {
1684 return 0;
1685 }
1686
1687 switch (msg)
1688 {
1689 case WM_INITDIALOG:
1690 SmIPsecDlgInit(hWnd, s);
1691 break;
1692
1693 case WM_COMMAND:
1694 switch (LOWORD(wParam))
1695 {
1696 case R_L2TP_OVER_IPSEC:
1697 case R_L2TP_RAW:
1698 case R_ETHERIP:
1699 case E_SECRET:
1700 case L_HUBNAME:
1701 SmIPsecDlgUpdate(hWnd, s);
1702 break;
1703 }
1704
1705 switch (wParam)
1706 {
1707 case IDOK:
1708 SmIPsecDlgOnOk(hWnd, s);
1709 break;
1710
1711 case IDCANCEL:
1712 Close(hWnd);
1713 break;
1714
1715 case B_DETAIL:
1716 // Advanced Settings dialog for EtherIP function
1717 SmEtherIp(hWnd, s);
1718 break;
1719 }
1720 break;
1721
1722 case WM_CLOSE:
1723 EndDialog(hWnd, 0);
1724 break;
1725 }
1726
1727 return 0;
1728 }
1729
1730 // IPsec Settings dialog: controls update
SmIPsecDlgUpdate(HWND hWnd,SM_SERVER * s)1731 void SmIPsecDlgUpdate(HWND hWnd, SM_SERVER *s)
1732 {
1733 IPSEC_SERVICES sl;
1734 bool ok = true;
1735 // Validate arguments
1736 if (hWnd == NULL || s == NULL)
1737 {
1738 return;
1739 }
1740
1741 SmIPsecDlgGetSetting(hWnd, &sl);
1742
1743 //SetEnable(hWnd, S_1, sl.L2TP_IPsec || sl.L2TP_Raw);
1744 //SetEnable(hWnd, S_2, sl.L2TP_IPsec || sl.L2TP_Raw);
1745 //SetEnable(hWnd, L_HUBNAME, sl.L2TP_IPsec || sl.L2TP_Raw);
1746
1747 SetEnable(hWnd, S_PSK, sl.L2TP_IPsec || sl.EtherIP_IPsec);
1748 SetEnable(hWnd, S_PSK2, sl.L2TP_IPsec || sl.EtherIP_IPsec);
1749 SetEnable(hWnd, E_SECRET, sl.L2TP_IPsec || sl.EtherIP_IPsec);
1750
1751 SetEnable(hWnd, B_DETAIL, sl.EtherIP_IPsec);
1752
1753 if ((sl.L2TP_IPsec || sl.EtherIP_IPsec) && IsEmptyStr(sl.IPsec_Secret))
1754 {
1755 ok = false;
1756 }
1757
1758 SetEnable(hWnd, IDOK, ok);
1759 }
1760
1761 // Get the IPsec configuration into the structure
SmIPsecDlgGetSetting(HWND hWnd,IPSEC_SERVICES * sl)1762 void SmIPsecDlgGetSetting(HWND hWnd, IPSEC_SERVICES *sl)
1763 {
1764 wchar_t *ws;
1765 // Validate arguments
1766 if (hWnd == NULL || sl == NULL)
1767 {
1768 return;
1769 }
1770
1771 Zero(sl, sizeof(IPSEC_SERVICES));
1772
1773 sl->L2TP_IPsec = IsChecked(hWnd, R_L2TP_OVER_IPSEC);
1774 sl->L2TP_Raw = IsChecked(hWnd, R_L2TP_RAW);
1775 sl->EtherIP_IPsec = IsChecked(hWnd, R_ETHERIP);
1776
1777 ws = CbGetStr(hWnd, L_HUBNAME);
1778 if (ws != NULL && IsEmptyUniStr(ws) == false)
1779 {
1780 UniToStr(sl->L2TP_DefaultHub, sizeof(sl->L2TP_DefaultHub), ws);
1781 }
1782
1783 Free(ws);
1784
1785 GetTxtA(hWnd, E_SECRET, sl->IPsec_Secret, sizeof(sl->IPsec_Secret));
1786 }
1787
1788 // IPsec Settings dialog initialization
SmIPsecDlgInit(HWND hWnd,SM_SERVER * s)1789 void SmIPsecDlgInit(HWND hWnd, SM_SERVER *s)
1790 {
1791 IPSEC_SERVICES sl;
1792 RPC_ENUM_HUB t;
1793 UINT i;
1794 UINT sel_index;
1795 // Validate arguments
1796 if (hWnd == NULL || s == NULL)
1797 {
1798 return;
1799 }
1800
1801 SetIcon(hWnd, 0, ICO_IPSEC);
1802
1803 DlgFont(hWnd, S_TITLE, 14, true);
1804 SetFont(hWnd, E_SECRET, GetFont("Verdana", 10, false, false, false, false));
1805
1806 DlgFont(hWnd, R_L2TP_OVER_IPSEC, 0, true);
1807 DlgFont(hWnd, R_L2TP_RAW, 0, true);
1808 DlgFont(hWnd, R_ETHERIP, 0, true);
1809
1810 // Get the configuration
1811 Zero(&sl, sizeof(sl));
1812 if (CALL(hWnd, ScGetIPsecServices(s->Rpc, &sl)) == false)
1813 {
1814 EndDialog(hWnd, 0);
1815 return;
1816 }
1817
1818 SetTextA(hWnd, E_SECRET, sl.IPsec_Secret);
1819
1820 Check(hWnd, R_L2TP_OVER_IPSEC, sl.L2TP_IPsec);
1821 Check(hWnd, R_L2TP_RAW, sl.L2TP_Raw);
1822 Check(hWnd, R_ETHERIP, sl.EtherIP_IPsec);
1823
1824 // Enumerate the Virtual HUBs
1825 Zero(&t, sizeof(t));
1826 if (CALL(hWnd, ScEnumHub(s->Rpc, &t)) == false)
1827 {
1828 EndDialog(hWnd, 0);
1829 return;
1830 }
1831
1832 CbReset(hWnd, L_HUBNAME);
1833 CbSetHeight(hWnd, L_HUBNAME, 18);
1834
1835 sel_index = INFINITE;
1836 for (i = 0;i < t.NumHub;i++)
1837 {
1838 RPC_ENUM_HUB_ITEM *e = &t.Hubs[i];
1839 UINT index;
1840
1841 index = CbAddStrA(hWnd, L_HUBNAME, e->HubName, 0);
1842 if (sel_index == INFINITE)
1843 {
1844 sel_index = index;
1845 }
1846
1847 if (StrCmpi(e->HubName, sl.L2TP_DefaultHub) == 0)
1848 {
1849 sel_index = index;
1850 }
1851 }
1852
1853 if (sel_index != INFINITE)
1854 {
1855 CbSelectIndex(hWnd, L_HUBNAME, sel_index);
1856 }
1857
1858 FreeRpcEnumHub(&t);
1859
1860 SmIPsecDlgUpdate(hWnd, s);
1861 }
1862
1863 // IPsec Settings dialog: on click the OK button
SmIPsecDlgOnOk(HWND hWnd,SM_SERVER * s)1864 void SmIPsecDlgOnOk(HWND hWnd, SM_SERVER *s)
1865 {
1866 IPSEC_SERVICES sl;
1867 // Validate arguments
1868 if (hWnd == NULL || s == NULL)
1869 {
1870 return;
1871 }
1872
1873 SmIPsecDlgGetSetting(hWnd, &sl);
1874
1875 // Confirm the length of the PSK
1876 if (StrLen(sl.IPsec_Secret) >= 10)
1877 {
1878 IPSEC_SERVICES sl_old;
1879 if (ScGetIPsecServices(s->Rpc, &sl_old) == ERR_NO_ERROR)
1880 {
1881 if (StrCmp(sl_old.IPsec_Secret, sl.IPsec_Secret) != 0 || ((sl_old.EtherIP_IPsec == false && sl_old.L2TP_IPsec == false)))
1882 {
1883 if (sl.EtherIP_IPsec || sl.L2TP_IPsec)
1884 {
1885 // Show a warning message if it exceeds 10 characters (Only if there is a change)
1886 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_YESNO, _UU("SM_IPSEC_PSK_TOO_LONG")) == IDYES)
1887 {
1888 FocusEx(hWnd, E_SECRET);
1889 return;
1890 }
1891 }
1892 }
1893 }
1894 }
1895
1896 if (CALL(hWnd, ScSetIPsecServices(s->Rpc, &sl)) == false)
1897 {
1898 return;
1899 }
1900
1901 EndDialog(hWnd, 1);
1902 }
1903
1904 // Start the IPsec Settings dialog
SmIPsec(HWND hWnd,SM_SERVER * s)1905 void SmIPsec(HWND hWnd, SM_SERVER *s)
1906 {
1907 // Validate arguments
1908 if (s == NULL)
1909 {
1910 return;
1911 }
1912
1913 Dialog(hWnd, D_SM_IPSEC, SmIPsecDlg, s);
1914 }
1915
1916 // Message Settings
SmHubMsg(HWND hWnd,SM_EDIT_HUB * s)1917 void SmHubMsg(HWND hWnd, SM_EDIT_HUB *s)
1918 {
1919 // Validate arguments
1920 if (s == NULL)
1921 {
1922 return;
1923 }
1924
1925 Dialog(hWnd, D_SM_MSG, SmHubMsgDlg, s);
1926 }
1927
1928 // Message dialog procedure
SmHubMsgDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1929 UINT SmHubMsgDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1930 {
1931 SM_EDIT_HUB *s = (SM_EDIT_HUB *)param;
1932 // Validate arguments
1933 if (hWnd == NULL)
1934 {
1935 return 0;
1936 }
1937
1938 switch (msg)
1939 {
1940 case WM_INITDIALOG:
1941 SmHubMsgDlgInit(hWnd, s);
1942 break;
1943
1944 case WM_COMMAND:
1945 switch (LOWORD(wParam))
1946 {
1947 case E_TEXT:
1948 SmHubMsgDlgUpdate(hWnd, s);
1949 break;
1950 }
1951
1952 switch (wParam)
1953 {
1954 case IDOK:
1955 SmHubMsgDlgOnOk(hWnd, s);
1956 break;
1957
1958 case IDCANCEL:
1959 Close(hWnd);
1960 break;
1961
1962 case C_USEMSG:
1963 SmHubMsgDlgUpdate(hWnd, s);
1964
1965 if (IsChecked(hWnd, C_USEMSG))
1966 {
1967 FocusEx(hWnd, E_TEXT);
1968 }
1969 break;
1970 }
1971
1972 break;
1973
1974 case WM_CLOSE:
1975 EndDialog(hWnd, 0);
1976 break;
1977 }
1978
1979 return 0;
1980 }
1981
1982 // Message dialog initialization
SmHubMsgDlgInit(HWND hWnd,SM_EDIT_HUB * s)1983 void SmHubMsgDlgInit(HWND hWnd, SM_EDIT_HUB *s)
1984 {
1985 RPC_MSG t;
1986 // Validate arguments
1987 if (hWnd == NULL || s == NULL)
1988 {
1989 return;
1990 }
1991
1992 SetFont(hWnd, E_TEXT, GetMeiryoFont());
1993
1994 FormatText(hWnd, S_MSG_2, s->HubName);
1995
1996 LimitText(hWnd, E_TEXT, HUB_MAXMSG_LEN);
1997
1998 Zero(&t, sizeof(t));
1999
2000 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
2001
2002 if (CALL(hWnd, ScGetHubMsg(s->p->Rpc, &t)) == false)
2003 {
2004 Close(hWnd);
2005 return;
2006 }
2007
2008 if (UniIsEmptyStr(t.Msg) == false)
2009 {
2010 SetText(hWnd, E_TEXT, t.Msg);
2011
2012 Check(hWnd, C_USEMSG, true);
2013 }
2014 else
2015 {
2016 Check(hWnd, C_USEMSG, false);
2017 }
2018
2019 FreeRpcMsg(&t);
2020
2021 SmHubMsgDlgUpdate(hWnd, s);
2022 }
2023
2024 // [OK] button
SmHubMsgDlgOnOk(HWND hWnd,SM_EDIT_HUB * s)2025 void SmHubMsgDlgOnOk(HWND hWnd, SM_EDIT_HUB *s)
2026 {
2027 RPC_MSG t;
2028 // Validate arguments
2029 if (hWnd == NULL || s == NULL)
2030 {
2031 return;
2032 }
2033
2034 Zero(&t, sizeof(t));
2035
2036 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
2037
2038 if (IsChecked(hWnd, C_USEMSG) == false)
2039 {
2040 t.Msg = CopyUniStr(L"");
2041 }
2042 else
2043 {
2044 t.Msg = GetText(hWnd, E_TEXT);
2045 }
2046
2047 if (CALL(hWnd, ScSetHubMsg(s->p->Rpc, &t)) == false)
2048 {
2049 return;
2050 }
2051
2052 FreeRpcMsg(&t);
2053
2054 EndDialog(hWnd, 1);
2055 }
2056
2057 // Message dialog update
SmHubMsgDlgUpdate(HWND hWnd,SM_EDIT_HUB * s)2058 void SmHubMsgDlgUpdate(HWND hWnd, SM_EDIT_HUB *s)
2059 {
2060 bool b = true;
2061 // Validate arguments
2062 if (hWnd == NULL || s == NULL)
2063 {
2064 return;
2065 }
2066
2067 SetEnable(hWnd, E_TEXT, IsChecked(hWnd, C_USEMSG));
2068
2069 if (IsChecked(hWnd, C_USEMSG))
2070 {
2071 wchar_t *s = GetText(hWnd, E_TEXT);
2072
2073 b = !IsEmptyUniStr(s);
2074
2075 Free(s);
2076 }
2077
2078 SetEnable(hWnd, IDOK, b);
2079 }
2080
2081 // VLAN utility
SmVLan(HWND hWnd,SM_SERVER * s)2082 void SmVLan(HWND hWnd, SM_SERVER *s)
2083 {
2084 // Validate arguments
2085 if (s == NULL)
2086 {
2087 return;
2088 }
2089
2090 Dialog(hWnd, D_SM_VLAN, SmVLanDlg, s);
2091 }
2092
2093 // VLAN dialog
SmVLanDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)2094 UINT SmVLanDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
2095 {
2096 SM_SERVER *s = (SM_SERVER *)param;
2097 NMHDR *n;
2098
2099 // Validate arguments
2100 if (hWnd == NULL)
2101 {
2102 return 0;
2103 }
2104
2105 switch (msg)
2106 {
2107 case WM_INITDIALOG:
2108 SmVLanDlgInit(hWnd, s);
2109
2110 if (LvNum(hWnd, L_LIST) == 0)
2111 {
2112 Disable(hWnd, L_LIST);
2113 SetTimer(hWnd, 1, 100, NULL);
2114 }
2115 break;
2116
2117 case WM_TIMER:
2118 switch (wParam)
2119 {
2120 case 1:
2121 KillTimer(hWnd, 1);
2122
2123 MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("SM_VLAN_NOTHING"),
2124 s->CurrentSetting->ClientOption.Hostname);
2125 break;
2126 }
2127 break;
2128
2129 case WM_COMMAND:
2130 switch (wParam)
2131 {
2132 case IDOK:
2133 case IDCANCEL:
2134 Close(hWnd);
2135 break;
2136
2137 case B_ENABLE:
2138 case B_DISABLE:
2139 {
2140 UINT i = LvGetSelected(hWnd, L_LIST);
2141 if (i != INFINITE)
2142 {
2143 char *name = LvGetStrA(hWnd, L_LIST, i, 0);
2144
2145 if (IsEmptyStr(name) == false)
2146 {
2147 RPC_TEST t;
2148
2149 Zero(&t, sizeof(t));
2150
2151 StrCpy(t.StrValue, sizeof(t.StrValue), name);
2152 t.IntValue = BOOL_TO_INT(wParam == B_ENABLE);
2153
2154 if (CALL(hWnd, ScSetEnableEthVLan(s->Rpc, &t)))
2155 {
2156 SmVLanDlgRefresh(hWnd, s);
2157
2158 if (wParam == B_ENABLE)
2159 {
2160 MsgBoxEx(hWnd, MB_ICONINFORMATION,
2161 _UU("SM_VLAN_MSG_1"),
2162 name, name, name);
2163 }
2164 else
2165 {
2166 MsgBoxEx(hWnd, MB_ICONINFORMATION,
2167 _UU("SM_VLAN_MSG_2"),
2168 name);
2169 }
2170 }
2171 }
2172
2173 Free(name);
2174 }
2175 break;
2176 }
2177 }
2178 break;
2179
2180 case WM_NOTIFY:
2181 n = (NMHDR *)lParam;
2182 switch (n->idFrom)
2183 {
2184 case L_LIST:
2185 switch (n->code)
2186 {
2187 case LVN_ITEMCHANGED:
2188 SmVLanDlgUpdate(hWnd, s);
2189 break;
2190 }
2191 break;
2192 }
2193 break;
2194
2195 case WM_CLOSE:
2196 EndDialog(hWnd, 0);
2197 break;
2198 }
2199
2200 return 0;
2201 }
2202
2203 // VLAN dialog initialization
SmVLanDlgInit(HWND hWnd,SM_SERVER * s)2204 void SmVLanDlgInit(HWND hWnd, SM_SERVER *s)
2205 {
2206 // Validate arguments
2207 if (hWnd == NULL || s == NULL)
2208 {
2209 return;
2210 }
2211
2212 LvInit(hWnd, L_LIST);
2213 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_VLAN_COLUMN_0"), 245);
2214 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_VLAN_COLUMN_1"), 75);
2215 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_VLAN_COLUMN_2"), 100);
2216 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_VLAN_COLUMN_3"), 100);
2217 LvInsertColumn(hWnd, L_LIST, 4, _UU("SM_VLAN_COLUMN_4"), 290);
2218 LvInsertColumn(hWnd, L_LIST, 5, _UU("SM_VLAN_COLUMN_5"), 430);
2219
2220 SmVLanDlgRefresh(hWnd, s);
2221 }
2222
2223 // VLAN dialog content update
SmVLanDlgRefresh(HWND hWnd,SM_SERVER * s)2224 void SmVLanDlgRefresh(HWND hWnd, SM_SERVER *s)
2225 {
2226 LVB *b;
2227 RPC_ENUM_ETH_VLAN t;
2228 UINT i;
2229 // Validate arguments
2230 if (hWnd == NULL || s == NULL)
2231 {
2232 return;
2233 }
2234
2235 Zero(&t, sizeof(t));
2236 if (CALL(hWnd, ScEnumEthVLan(s->Rpc, &t)) == false)
2237 {
2238 Close(hWnd);
2239 return;
2240 }
2241
2242 b = LvInsertStart();
2243
2244 for (i = 0;i < t.NumItem;i++)
2245 {
2246 RPC_ENUM_ETH_VLAN_ITEM *e = &t.Items[i];
2247
2248 if (e->Support)
2249 {
2250 wchar_t tmp0[MAX_SIZE];
2251 wchar_t tmp1[MAX_SIZE];
2252 wchar_t tmp2[MAX_SIZE];
2253 wchar_t *tmp3;
2254 wchar_t tmp4[MAX_SIZE];
2255 wchar_t tmp5[MAX_SIZE];
2256
2257 StrToUni(tmp0, sizeof(tmp0), e->DeviceName);
2258 StrToUni(tmp1, sizeof(tmp1), e->DriverType);
2259 StrToUni(tmp2, sizeof(tmp2), e->DriverName);
2260 tmp3 = (e->Enabled ? _UU("SM_VLAN_YES") : _UU("SM_VLAN_NO"));
2261 StrToUni(tmp4, sizeof(tmp4), e->Guid);
2262 StrToUni(tmp5, sizeof(tmp5), e->DeviceInstanceId);
2263
2264 LvInsertAdd(b,
2265 e->Enabled ? ICO_NIC_ONLINE : ICO_NIC_OFFLINE, 0, 6,
2266 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5);
2267 }
2268 }
2269
2270 LvInsertEnd(b, hWnd, L_LIST);
2271
2272 FreeRpcEnumEthVLan(&t);
2273
2274 SmVLanDlgUpdate(hWnd, s);
2275 }
2276
2277 // VLAN dialog control update
SmVLanDlgUpdate(HWND hWnd,SM_SERVER * s)2278 void SmVLanDlgUpdate(HWND hWnd, SM_SERVER *s)
2279 {
2280 // Validate arguments
2281 if (hWnd == NULL || s == NULL)
2282 {
2283 return;
2284 }
2285
2286 if (LvIsSingleSelected(hWnd, L_LIST) == false)
2287 {
2288 Disable(hWnd, B_ENABLE);
2289 Disable(hWnd, B_DISABLE);
2290 }
2291 else
2292 {
2293 UINT i = LvGetSelected(hWnd, L_LIST);
2294 if (i != INFINITE)
2295 {
2296 wchar_t *s = LvGetStr(hWnd, L_LIST, i, 3);
2297
2298 if (UniStrCmpi(s, _UU("SM_VLAN_YES")) != 0)
2299 {
2300 Enable(hWnd, B_ENABLE);
2301 Disable(hWnd, B_DISABLE);
2302 }
2303 else
2304 {
2305 Enable(hWnd, B_DISABLE);
2306 Disable(hWnd, B_ENABLE);
2307 }
2308
2309 Free(s);
2310 }
2311 }
2312 }
2313
2314 // Examine whether the current state of VPN Server / VPN Bridge is the initial state
SmSetupIsNew(SM_SERVER * s)2315 bool SmSetupIsNew(SM_SERVER *s)
2316 {
2317 RPC *rpc;
2318 bool is_bridge;
2319 char hubname[MAX_HUBNAME_LEN + 1];
2320 bool check_hub = false;
2321 // Validate arguments
2322 if (s == NULL)
2323 {
2324 return false;
2325 }
2326
2327 if (s->ServerAdminMode == false)
2328 {
2329 return false;
2330 }
2331
2332 rpc = s->Rpc;
2333 is_bridge =s->Bridge;
2334
2335 // Server type
2336 if (is_bridge == false)
2337 {
2338 bool b = false;
2339 RPC_SERVER_INFO t;
2340
2341 Zero(&t, sizeof(t));
2342 if (ScGetServerInfo(rpc, &t) == ERR_NO_ERROR)
2343 {
2344 if (t.ServerType != SERVER_TYPE_STANDALONE)
2345 {
2346 b = true;
2347 }
2348
2349 FreeRpcServerInfo(&t);
2350 }
2351 else
2352 {
2353 return false;
2354 }
2355
2356 if (b)
2357 {
2358 return false;
2359 }
2360 }
2361
2362 // Local bridge
2363 if (true)
2364 {
2365 RPC_ENUM_LOCALBRIDGE t;
2366 bool b = false;
2367
2368 Zero(&t, sizeof(t));
2369 if (ScEnumLocalBridge(rpc, &t) == ERR_NO_ERROR)
2370 {
2371 if (t.NumItem != 0)
2372 {
2373 b = true;
2374 }
2375 FreeRpcEnumLocalBridge(&t);
2376 }
2377
2378 if (b)
2379 {
2380 return false;
2381 }
2382 }
2383
2384 // Virtual HUB
2385
2386 check_hub = false;
2387
2388 if (is_bridge == false)
2389 {
2390 RPC_ENUM_HUB t;
2391 bool b = false;
2392
2393 Zero(&t, sizeof(t));
2394 if (ScEnumHub(rpc, &t) == ERR_NO_ERROR)
2395 {
2396 if (t.NumHub >= 2)
2397 {
2398 b = true;
2399 }
2400 else if (t.NumHub == 1)
2401 {
2402 if (StrCmpi(t.Hubs[0].HubName, SERVER_DEFAULT_HUB_NAME) != 0)
2403 {
2404 b = true;
2405 }
2406 else
2407 {
2408 check_hub = true;
2409 }
2410 }
2411
2412 FreeRpcEnumHub(&t);
2413 }
2414
2415 if (b)
2416 {
2417 return false;
2418 }
2419 }
2420 else
2421 {
2422 check_hub = true;
2423 }
2424
2425 // Status of the virtual HUB
2426 if (is_bridge == false)
2427 {
2428 StrCpy(hubname, sizeof(hubname), SERVER_DEFAULT_HUB_NAME);
2429 }
2430 else
2431 {
2432 StrCpy(hubname, sizeof(hubname), SERVER_DEFAULT_BRIDGE_NAME);
2433 }
2434
2435 if (check_hub)
2436 {
2437 if (true)
2438 {
2439 // Number of objects in the Virtual HUB
2440 RPC_HUB_STATUS t;
2441
2442 Zero(&t, sizeof(t));
2443 StrCpy(t.HubName, sizeof(t.HubName), hubname);
2444
2445 if (ScGetHubStatus(rpc, &t) == ERR_NO_ERROR)
2446 {
2447 if (t.NumSessions != 0 || t.NumAccessLists != 0 ||
2448 t.NumUsers != 0 || t.NumGroups != 0 ||
2449 t.NumMacTables != 0 || t.NumIpTables != 0 ||
2450 t.SecureNATEnabled)
2451 {
2452 return false;
2453 }
2454 }
2455 else
2456 {
2457 return false;
2458 }
2459 }
2460
2461 if (true)
2462 {
2463 // Cascade connection
2464 RPC_ENUM_LINK t;
2465
2466 Zero(&t, sizeof(t));
2467 StrCpy(t.HubName, sizeof(t.HubName), hubname);
2468
2469 if (ScEnumLink(rpc, &t) == ERR_NO_ERROR)
2470 {
2471 bool b = false;
2472
2473 if (t.NumLink != 0)
2474 {
2475 b = true;
2476 }
2477
2478 FreeRpcEnumLink(&t);
2479
2480 if (b)
2481 {
2482 return false;
2483 }
2484 }
2485 else
2486 {
2487 return false;
2488 }
2489 }
2490
2491 if (is_bridge == false)
2492 {
2493 // Certificate list to trust
2494 RPC_HUB_ENUM_CA t;
2495
2496 Zero(&t, sizeof(t));
2497 StrCpy(t.HubName, sizeof(t.HubName), hubname);
2498
2499 if (ScEnumCa(rpc, &t) == ERR_NO_ERROR)
2500 {
2501 bool b = false;
2502
2503 if (t.NumCa != 0)
2504 {
2505 b = true;
2506 }
2507
2508 FreeRpcHubEnumCa(&t);
2509
2510 if (b)
2511 {
2512 return false;
2513 }
2514 }
2515 else
2516 {
2517 return false;
2518 }
2519 }
2520
2521 if (is_bridge == false)
2522 {
2523 // Certificate revocation list
2524 RPC_ENUM_CRL t;
2525
2526 Zero(&t, sizeof(t));
2527 StrCpy(t.HubName, sizeof(t.HubName), hubname);
2528
2529 if (ScEnumCrl(rpc, &t) == ERR_NO_ERROR)
2530 {
2531 bool b = false;
2532
2533 if (t.NumItem != 0)
2534 {
2535 b = true;
2536 }
2537
2538 FreeRpcEnumCrl(&t);
2539
2540 if (b)
2541 {
2542 return false;
2543 }
2544 }
2545 else
2546 {
2547 return false;
2548 }
2549 }
2550
2551 if (is_bridge == false)
2552 {
2553 // Authentication server configuration
2554 RPC_RADIUS t;
2555
2556 Zero(&t, sizeof(t));
2557 StrCpy(t.HubName, sizeof(t.HubName), hubname);
2558
2559 if (ScGetHubRadius(rpc, &t) == ERR_NO_ERROR)
2560 {
2561 if (IsEmptyStr(t.RadiusServerName) == false)
2562 {
2563 return false;
2564 }
2565 }
2566 else
2567 {
2568 return false;
2569 }
2570 }
2571
2572 if (is_bridge == false)
2573 {
2574 // Virtual HUB configuration
2575 RPC_CREATE_HUB t;
2576
2577 Zero(&t, sizeof(t));
2578 StrCpy(t.HubName, sizeof(t.HubName), hubname);
2579
2580 if (ScGetHub(rpc, &t) == ERR_NO_ERROR)
2581 {
2582 if (t.HubOption.NoEnum || t.HubOption.MaxSession != 0 ||
2583 t.Online == false)
2584 {
2585 return false;
2586 }
2587 }
2588 else
2589 {
2590 return false;
2591 }
2592 }
2593
2594 if (is_bridge == false)
2595 {
2596 // IP access control list
2597 RPC_AC_LIST t;
2598
2599 Zero(&t, sizeof(t));
2600 StrCpy(t.HubName, sizeof(t.HubName), hubname);
2601
2602 if (ScGetAcList(rpc, &t) == ERR_NO_ERROR)
2603 {
2604 bool b = false;
2605 if (LIST_NUM(t.o) != 0)
2606 {
2607 b = true;
2608 }
2609 FreeRpcAcList(&t);
2610
2611 if (b)
2612 {
2613 return false;
2614 }
2615 }
2616 else
2617 {
2618 return false;
2619 }
2620 }
2621
2622 if (is_bridge == false)
2623 {
2624 // AO
2625 RPC_ADMIN_OPTION t;
2626
2627 Zero(&t, sizeof(t));
2628 StrCpy(t.HubName, sizeof(t.HubName), hubname);
2629
2630 if (ScGetHubAdminOptions(rpc, &t) == ERR_NO_ERROR)
2631 {
2632 bool b = false;
2633 UINT i;
2634
2635 for (i = 0;i < t.NumItem;i++)
2636 {
2637 if (t.Items[i].Value != 0)
2638 {
2639 b = true;
2640 }
2641 }
2642
2643 FreeRpcAdminOption(&t);
2644
2645 if (b)
2646 {
2647 return false;
2648 }
2649 }
2650 else
2651 {
2652 return false;
2653 }
2654 }
2655 }
2656
2657 // Virtual layer 3 switch
2658 if (is_bridge == false)
2659 {
2660 RPC_ENUM_L3SW t;
2661 bool b = false;
2662
2663 Zero(&t, sizeof(t));
2664 if (ScEnumL3Switch(rpc, &t) == ERR_NO_ERROR)
2665 {
2666 if (t.NumItem != 0)
2667 {
2668 b = true;
2669 }
2670
2671 FreeRpcEnumL3Sw(&t);
2672 }
2673 else
2674 {
2675 return false;
2676 }
2677
2678 if (b)
2679 {
2680 return false;
2681 }
2682 }
2683
2684 return true;
2685 }
2686
2687 // Setup procedure dialog initialization
SmSetupStepDlgInit(HWND hWnd,SM_SETUP * s)2688 void SmSetupStepDlgInit(HWND hWnd, SM_SETUP *s)
2689 {
2690 bool b;
2691 RPC_ENUM_ETH t;
2692 UINT i;
2693 RPC_BRIDGE_SUPPORT bs;
2694 // Validate arguments
2695 if (hWnd == NULL || s == NULL)
2696 {
2697 return;
2698 }
2699
2700 SetIcon(hWnd, 0, ICO_SETUP);
2701
2702 DlgFont(hWnd, S_1_1, 0, true);
2703 DlgFont(hWnd, S_2_1, 0, true);
2704 DlgFont(hWnd, S_3_1, 0, true);
2705
2706 b = false;
2707 if (s->UseRemote)
2708 {
2709 b = true;
2710 }
2711 if (s->UseSite && s->UseSiteEdge == false)
2712 {
2713 b = true;
2714 }
2715
2716 SetEnable(hWnd, S_1_1, b);
2717 SetEnable(hWnd, S_1_2, b);
2718 SetEnable(hWnd, B_USER, b);
2719
2720 b = false;
2721 if (s->UseSiteEdge)
2722 {
2723 b = true;
2724 }
2725
2726 SetEnable(hWnd, S_2_1, b);
2727 SetEnable(hWnd, S_2_2, b);
2728 SetEnable(hWnd, B_CASCADE, b);
2729
2730 CbReset(hWnd, C_DEVICE);
2731 CbSetHeight(hWnd, C_DEVICE, 18);
2732
2733 Zero(&t, sizeof(t));
2734
2735 CbAddStr(hWnd, C_DEVICE, _UU("SM_SETUP_SELECT"), 0);
2736
2737 Zero(&bs, sizeof(bs));
2738 if (CALL(hWnd, ScGetBridgeSupport(s->Rpc, &bs)) == false)
2739 {
2740 return;
2741 }
2742
2743 if (bs.IsBridgeSupportedOs)
2744 {
2745 // Enumerate the local bridges
2746 if (ScEnumEthernet(s->Rpc, &t) == ERR_NO_ERROR)
2747 {
2748 for (i = 0;i < t.NumItem;i++)
2749 {
2750 wchar_t tmp[MAX_PATH];
2751 RPC_ENUM_ETH_ITEM *e = &t.Items[i];
2752
2753 if (GetCapsBool(s->s->CapsList, "b_support_network_connection_name"))
2754 {
2755 UniFormat(tmp, sizeof(tmp), BRIDGE_NETWORK_CONNECTION_STR, e->NetworkConnectionName, e->DeviceName);
2756 }
2757 else
2758 {
2759 StrToUni(tmp, sizeof(tmp), e->DeviceName);
2760 }
2761
2762 CbAddStr(hWnd, C_DEVICE, tmp, 1);
2763 }
2764
2765 FreeRpcEnumEth(&t);
2766 }
2767 Show(hWnd, C_DEVICE);
2768 Hide(hWnd, B_SECURENAT);
2769 }
2770 else
2771 {
2772 RPC_HUB t;
2773
2774 // Enable the SecureNAT automatically if the local bridge does not work in this environment
2775 SetText(hWnd, S_3_2, _UU("SM_SETUP_STEP_SECURENAT"));
2776 SetText(hWnd, S_3_1, _UU("SM_SETUP_STEP_SECURENAT_TITLE"));
2777 Hide(hWnd, C_DEVICE);
2778 Show(hWnd, B_SECURENAT);
2779 SetIcon(hWnd, S_ICON, ICO_ROUTER);
2780
2781 Zero(&t, sizeof(t));
2782 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
2783
2784 ScEnableSecureNAT(s->Rpc, &t);
2785 }
2786
2787 s->Flag1 = false;
2788 s->Flag2 = false;
2789 }
2790
2791 // Close
SmSetupOnClose(HWND hWnd,SM_SETUP * s)2792 void SmSetupOnClose(HWND hWnd, SM_SETUP *s)
2793 {
2794 wchar_t *tmp;
2795 char name[MAX_PATH];
2796 RPC_BRIDGE_SUPPORT bs;
2797 // Validate arguments
2798 if (hWnd == NULL || s == NULL)
2799 {
2800 return;
2801 }
2802
2803 Zero(&bs, sizeof(bs));
2804 if (CALL(hWnd, ScGetBridgeSupport(s->Rpc, &bs)) == false)
2805 {
2806 return;
2807 }
2808
2809 if (bs.IsBridgeSupportedOs)
2810 {
2811 // Add a Local Bridge
2812 tmp = CbGetStr(hWnd, C_DEVICE);
2813
2814 if (tmp != NULL)
2815 {
2816 UniToStr(name, sizeof(name), tmp);
2817
2818 if (CbGetSelect(hWnd, C_DEVICE) != 0)
2819 {
2820 // Show a warning message if the VPN Server is running in a VM
2821 if (GetCapsBool(s->s->CapsList, "b_is_in_vm"))
2822 {
2823 Dialog(hWnd, D_SM_VMBRIDGE, SmVmBridgeDlg, NULL);
2824 }
2825
2826 if (GetCapsBool(s->s->CapsList, "b_support_network_connection_name") == false)
2827 {
2828 RPC_LOCALBRIDGE t;
2829
2830 Zero(&t, sizeof(t));
2831 t.Active = true;
2832 StrCpy(t.DeviceName, sizeof(t.DeviceName), name);
2833 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
2834 t.Online = true;
2835 t.TapMode = false;
2836
2837 if (CALL(hWnd, ScAddLocalBridge(s->Rpc, &t)) == false)
2838 {
2839 Free(tmp);
2840 return;
2841 }
2842 }
2843 else
2844 {
2845 RPC_ENUM_ETH tt;
2846 UINT i;
2847
2848 Zero(&tt, sizeof(tt));
2849 if (CALL(hWnd, ScEnumEthernet(s->Rpc, &tt)) == false)
2850 {
2851 Free(tmp);
2852 return;
2853 }
2854
2855 for (i = 0;i < tt.NumItem;i++)
2856 {
2857 RPC_ENUM_ETH_ITEM *ti = &tt.Items[i];
2858 wchar_t fullname[MAX_SIZE];
2859
2860 UniFormat(fullname, sizeof(fullname), BRIDGE_NETWORK_CONNECTION_STR, ti->NetworkConnectionName, ti->DeviceName);
2861
2862 if (UniStrCmpi(fullname, tmp) == 0)
2863 {
2864 RPC_LOCALBRIDGE t;
2865
2866 Zero(&t, sizeof(t));
2867 t.Active = true;
2868 StrCpy(t.DeviceName, sizeof(t.DeviceName), ti->DeviceName);
2869 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
2870 t.Online = true;
2871 t.TapMode = false;
2872
2873 if (CALL(hWnd, ScAddLocalBridge(s->Rpc, &t)) == false)
2874 {
2875 FreeRpcEnumEth(&tt);
2876 Free(tmp);
2877 return;
2878 }
2879 break;
2880 }
2881 }
2882
2883 FreeRpcEnumEth(&tt);
2884 }
2885
2886 }
2887 Free(tmp);
2888 }
2889 }
2890 else
2891 {
2892 // Enable the SecureNAT
2893 }
2894
2895 EndDialog(hWnd, 0);
2896 }
2897
2898 // Setup Procedure dialog procedure
SmSetupStepDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)2899 UINT SmSetupStepDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
2900 {
2901 SM_SETUP *s = (SM_SETUP *)param;
2902 // Validate arguments
2903 if (hWnd == NULL)
2904 {
2905 return 0;
2906 }
2907
2908 switch (msg)
2909 {
2910 case WM_INITDIALOG:
2911 // Initialize
2912 SmSetupStepDlgInit(hWnd, s);
2913 break;
2914
2915 case WM_COMMAND:
2916 switch (wParam)
2917 {
2918 case B_USER:
2919 // User creation
2920 if (true)
2921 {
2922 SM_HUB h;
2923
2924 Zero(&h, sizeof(h));
2925 h.HubName = s->HubName;
2926 h.p = s->s;
2927 h.Rpc = s->Rpc;
2928
2929 SmUserListDlgEx(hWnd, &h, NULL, s->Flag1 ? false : true);
2930
2931 s->Flag1 = true;
2932 }
2933 break;
2934
2935 case B_CASCADE:
2936 // Create a cascade connection
2937 if (true)
2938 {
2939 SM_HUB h;
2940
2941 Zero(&h, sizeof(h));
2942 h.HubName = s->HubName;
2943 h.p = s->s;
2944 h.Rpc = s->Rpc;
2945
2946 SmLinkDlgEx(hWnd, &h, s->Flag2 ? false : true);
2947 s->Flag2 = true;
2948 }
2949 break;
2950
2951 case B_SECURENAT:
2952 // Setting the SecureNAT
2953 if (true)
2954 {
2955 SM_HUB h;
2956
2957 Zero(&h, sizeof(h));
2958 h.p = s->s;
2959 h.Rpc = s->Rpc;
2960 h.HubName = s->HubName;
2961
2962 Dialog(hWnd, D_SM_SNAT, SmSNATDlgProc, &h);
2963 }
2964 break;
2965
2966 case IDCANCEL:
2967 // Close button
2968 Close(hWnd);
2969 break;
2970 }
2971 break;
2972
2973 case WM_CLOSE:
2974 // Exit
2975 SmSetupOnClose(hWnd, s);
2976 break;
2977 }
2978
2979 return 0;
2980 }
2981
2982 // Setup procedure dialog
SmSetupStep(HWND hWnd,SM_SETUP * s)2983 void SmSetupStep(HWND hWnd, SM_SETUP *s)
2984 {
2985 // Validate arguments
2986 if (s == NULL)
2987 {
2988 return;
2989 }
2990
2991 Dialog(hWnd, D_SM_SETUP_STEP, SmSetupStepDlg, s);
2992 }
2993
2994 // Initialize by setup
SmSetupInit(HWND hWnd,SM_SETUP * s)2995 bool SmSetupInit(HWND hWnd, SM_SETUP *s)
2996 {
2997 // Validate arguments
2998 if (s == NULL)
2999 {
3000 return false;
3001 }
3002
3003 if (s->IsBridge == false)
3004 {
3005 if (SmSetupDeleteAllLayer3(hWnd, s) == false)
3006 {
3007 return false;
3008 }
3009
3010 if (SmSetupDeleteAllHub(hWnd, s) == false)
3011 {
3012 return false;
3013 }
3014 }
3015 else
3016 {
3017 if (SmSetupDeleteAllObjectInBridgeHub(hWnd, s) == false)
3018 {
3019 return false;
3020 }
3021 }
3022
3023 SmSetupDeleteAllLocalBridge(hWnd, s);
3024
3025 if (s->IsBridge == false)
3026 {
3027 // Create a Virtual HUB
3028 RPC_CREATE_HUB t;
3029 char *password = "";
3030
3031 Zero(&t, sizeof(t));
3032 Sha0(t.HashedPassword, password, StrLen(password));
3033 HashPassword(t.SecurePassword, ADMINISTRATOR_USERNAME, password);
3034 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
3035 t.HubType = HUB_TYPE_STANDALONE;
3036 t.Online = true;
3037
3038 if (CALL(hWnd, ScCreateHub(s->Rpc, &t)) == false)
3039 {
3040 return false;
3041 }
3042 }
3043
3044 return true;
3045 }
3046
3047 // Remove all objects in the Virtual HUB of the VPN Bridge
SmSetupDeleteAllObjectInBridgeHub(HWND hWnd,SM_SETUP * s)3048 bool SmSetupDeleteAllObjectInBridgeHub(HWND hWnd, SM_SETUP *s)
3049 {
3050 char *hubname = SERVER_DEFAULT_BRIDGE_NAME;
3051 // Validate arguments
3052 if (hWnd == NULL || s == NULL)
3053 {
3054 return false;
3055 }
3056
3057 if (true)
3058 {
3059 RPC_ENUM_LINK t;
3060 UINT i;
3061
3062 Zero(&t, sizeof(t));
3063 StrCpy(t.HubName, sizeof(t.HubName), hubname);
3064
3065 if (CALL(hWnd, ScEnumLink(s->Rpc, &t)) == false)
3066 {
3067 return false;
3068 }
3069
3070 for (i = 0;i < t.NumLink;i++)
3071 {
3072 RPC_ENUM_LINK_ITEM *e = &t.Links[i];
3073 RPC_LINK a;
3074
3075 Zero(&a, sizeof(a));
3076 StrCpy(a.HubName, sizeof(a.HubName), hubname);
3077 UniStrCpy(a.AccountName, sizeof(a.AccountName), e->AccountName);
3078
3079 if (CALL(hWnd, ScDeleteLink(s->Rpc, &a)) == false)
3080 {
3081 FreeRpcEnumLink(&t);
3082 return false;
3083 }
3084 }
3085
3086 FreeRpcEnumLink(&t);
3087 }
3088
3089 if (true)
3090 {
3091 RPC_HUB t;
3092
3093 Zero(&t, sizeof(t));
3094 StrCpy(t.HubName, sizeof(t.HubName), hubname);
3095
3096 if (CALL(hWnd, ScDisableSecureNAT(s->Rpc, &t)) == false)
3097 {
3098 return false;
3099 }
3100 }
3101
3102 return true;
3103 }
3104
3105 // Delete all Virtual Layer 3 Switches
SmSetupDeleteAllLayer3(HWND hWnd,SM_SETUP * s)3106 bool SmSetupDeleteAllLayer3(HWND hWnd, SM_SETUP *s)
3107 {
3108 RPC_ENUM_L3SW t;
3109 UINT i;
3110 // Validate arguments
3111 if (hWnd == NULL || s == NULL)
3112 {
3113 return false;
3114 }
3115
3116 Zero(&t, sizeof(t));
3117 if(CALL(hWnd, ScEnumL3Switch(s->Rpc, &t)) == false)
3118 {
3119 return false;
3120 }
3121
3122 for (i = 0;i < t.NumItem;i++)
3123 {
3124 RPC_ENUM_L3SW_ITEM *e = &t.Items[i];
3125 RPC_L3SW tt;
3126
3127 Zero(&tt, sizeof(tt));
3128 StrCpy(tt.Name, sizeof(tt.Name), e->Name);
3129
3130 if (CALL(hWnd, ScDelL3Switch(s->Rpc, &tt)) == false)
3131 {
3132 FreeRpcEnumL3Sw(&t);
3133 return false;
3134 }
3135 }
3136
3137 FreeRpcEnumL3Sw(&t);
3138
3139 return true;
3140 }
3141
3142 // Delete all local bridges
SmSetupDeleteAllLocalBridge(HWND hWnd,SM_SETUP * s)3143 bool SmSetupDeleteAllLocalBridge(HWND hWnd, SM_SETUP *s)
3144 {
3145 RPC_ENUM_LOCALBRIDGE t;
3146 UINT i;
3147 // Validate arguments
3148 if (hWnd == NULL || s == NULL)
3149 {
3150 return false;
3151 }
3152
3153 Zero(&t, sizeof(t));
3154 if (ScEnumLocalBridge(s->Rpc, &t) != ERR_NO_ERROR)
3155 {
3156 return false;
3157 }
3158
3159 for (i = 0;i < t.NumItem;i++)
3160 {
3161 RPC_LOCALBRIDGE *e = &t.Items[i];
3162
3163 if (CALL(hWnd, ScDeleteLocalBridge(s->Rpc, e)) == false)
3164 {
3165 FreeRpcEnumLocalBridge(&t);
3166 return false;
3167 }
3168 }
3169
3170 FreeRpcEnumLocalBridge(&t);
3171
3172 return true;
3173 }
3174
3175 // Delete all Virtual HUBs
SmSetupDeleteAllHub(HWND hWnd,SM_SETUP * s)3176 bool SmSetupDeleteAllHub(HWND hWnd, SM_SETUP *s)
3177 {
3178 RPC_ENUM_HUB t;
3179 UINT i;
3180 // Validate arguments
3181 if (hWnd == NULL || s == NULL)
3182 {
3183 return false;
3184 }
3185
3186 Zero(&t, sizeof(t));
3187 if (CALL(hWnd, ScEnumHub(s->Rpc, &t)) == false)
3188 {
3189 return false;
3190 }
3191
3192 for (i = 0;i < t.NumHub;i++)
3193 {
3194 RPC_ENUM_HUB_ITEM *e = &t.Hubs[i];
3195 RPC_DELETE_HUB tt;
3196
3197 Zero(&tt, sizeof(tt));
3198 StrCpy(tt.HubName, sizeof(tt.HubName), e->HubName);
3199
3200 if (CALL(hWnd, ScDeleteHub(s->Rpc, &tt)) == false)
3201 {
3202 FreeRpcEnumHub(&t);
3203 return false;
3204 }
3205 }
3206
3207 FreeRpcEnumHub(&t);
3208
3209 return true;
3210 }
3211
3212 // Update the control of the Virtual HUB
SmSetupHubDlgUpdate(HWND hWnd,SM_SETUP * s)3213 void SmSetupHubDlgUpdate(HWND hWnd, SM_SETUP *s)
3214 {
3215 bool ok = true;
3216 char tmp[MAX_HUBNAME_LEN + 1];
3217 // Validate arguments
3218 if (hWnd == NULL || s == NULL)
3219 {
3220 return;
3221 }
3222
3223 GetTxtA(hWnd, E_HUBNAME, tmp, sizeof(tmp));
3224
3225 if (IsEmptyStr(tmp) || IsSafeStr(tmp) == false)
3226 {
3227 ok = false;
3228 }
3229
3230 SetEnable(hWnd, IDOK, ok);
3231 }
3232
3233 // Virtual HUB creation dialog
SmSetupHubDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)3234 UINT SmSetupHubDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
3235 {
3236 SM_SETUP *s = (SM_SETUP *)param;
3237 // Validate arguments
3238 if (hWnd == NULL)
3239 {
3240 return 0;
3241 }
3242
3243 switch (msg)
3244 {
3245 case WM_INITDIALOG:
3246 SetTextA(hWnd, E_HUBNAME, "VPN");
3247 FocusEx(hWnd, E_HUBNAME);
3248 SmSetupHubDlgUpdate(hWnd, s);
3249 break;
3250
3251 case WM_COMMAND:
3252 SmSetupHubDlgUpdate(hWnd, s);
3253
3254 switch (wParam)
3255 {
3256 case IDOK:
3257 GetTxtA(hWnd, E_HUBNAME, s->HubName, sizeof(s->HubName));
3258 EndDialog(hWnd, true);
3259 break;
3260
3261 case IDCANCEL:
3262 Close(hWnd);
3263 break;
3264 }
3265 break;
3266
3267 case WM_CLOSE:
3268 EndDialog(hWnd, 0);
3269 break;
3270 }
3271
3272 return 0;
3273 }
3274
3275 // Setup dialog: [Next] button
SmSetupDlgOnOk(HWND hWnd,SM_SETUP * s)3276 void SmSetupDlgOnOk(HWND hWnd, SM_SETUP *s)
3277 {
3278 // Validate arguments
3279 if (hWnd == NULL || s == NULL)
3280 {
3281 return;
3282 }
3283
3284 if (MsgBox(hWnd, MB_YESNO | MB_ICONEXCLAMATION, _UU("SM_SETUP_WARNING")) == IDNO)
3285 {
3286 return;
3287 }
3288
3289 s->UseRemote = IsChecked(hWnd, C_REMOTE);
3290 s->UseSite = IsChecked(hWnd, C_SITE);
3291 s->UseSiteEdge = IsChecked(hWnd, C_EDGE);
3292
3293 if (s->IsBridge)
3294 {
3295 StrCpy(s->HubName, sizeof(s->HubName), SERVER_DEFAULT_BRIDGE_NAME);
3296 }
3297 else
3298 {
3299 if (Dialog(hWnd, D_SM_SETUP_HUB, SmSetupHubDlg, s) == false)
3300 {
3301 return;
3302 }
3303 }
3304
3305 // Initialize (Wipe existing objects)
3306 if (SmSetupInit(hWnd, s) == false)
3307 {
3308 return;
3309 }
3310
3311 if (s->IsBridge == false)
3312 {
3313 if (GetCapsBool(s->s->CapsList, "b_support_ddns"))
3314 {
3315 if (s->UseRemote || (s->UseSite && s->UseSiteEdge == false))
3316 {
3317 DDNS_CLIENT_STATUS st;
3318
3319 Zero(&st, sizeof(st));
3320
3321 if (ScGetDDnsClientStatus(s->s->Rpc, &st) == ERR_NO_ERROR &&
3322 IsEmptyStr(st.CurrentHostName) == false)
3323 {
3324 // Display the Dynamic DNS setting screen
3325 SmDDns(hWnd, s->s, true, false);
3326 }
3327 }
3328 }
3329
3330 // Configure the IPsec if the IPsec feature is available
3331 if (GetCapsBool(s->s->CapsList, "b_support_ipsec") && s->s->IPsecMessageDisplayed == false)
3332 {
3333 // Display a message about IPsec
3334 RPC_TEST flag;
3335
3336 if (s->UseRemote || (s->UseSite && s->UseSiteEdge == false))
3337 {
3338 SmIPsec(hWnd, s->s);
3339 }
3340
3341 Zero(&flag, sizeof(flag));
3342 flag.IntValue = 9;
3343 ToStr(flag.StrValue, 1);
3344
3345 ScDebug(s->s->Rpc, &flag);
3346
3347 s->s->IPsecMessageDisplayed = true;
3348 }
3349
3350 // Configure the VPN Azure if VPN Azure feature is available
3351 if (GetCapsBool(s->s->CapsList, "b_support_azure"))
3352 {
3353 SmAzure(hWnd, s->s, true);
3354 }
3355
3356 }
3357
3358 // Execute the procedure
3359 SmSetupStep(hWnd, s);
3360
3361 // Close the dialog
3362 EndDialog(hWnd, true);
3363 }
3364
3365 // Setup dialog: initialization
SmSetupDlgInit(HWND hWnd,SM_SETUP * s)3366 void SmSetupDlgInit(HWND hWnd, SM_SETUP *s)
3367 {
3368 // Validate arguments
3369 if (hWnd == NULL || s == NULL)
3370 {
3371 return;
3372 }
3373
3374 SetIcon(hWnd, 0, ICO_SETUP);
3375 DlgFont(hWnd, S_TITLE, 14, true);
3376 DlgFont(hWnd, C_REMOTE, 0, true);
3377 DlgFont(hWnd, C_SITE, 0, true);
3378 DlgFont(hWnd, C_OTHER, 0, true);
3379
3380 if (s->IsBridge)
3381 {
3382 SetText(hWnd, B_BOLD, _UU("SM_SETUP_BRIDGE_ONLY"));
3383 SetText(hWnd, C_EDGE, _UU("SM_SETUP_BRIDGE_EDGE"));
3384
3385 Check(hWnd, C_SITE, true);
3386 Check(hWnd, C_EDGE, true);
3387 Focus(hWnd, C_SITE);
3388 }
3389
3390 SmSetupDlgUpdate(hWnd, s);
3391 }
3392
3393 // Setup dialog: update
SmSetupDlgUpdate(HWND hWnd,SM_SETUP * s)3394 void SmSetupDlgUpdate(HWND hWnd, SM_SETUP *s)
3395 {
3396 bool enable_remote = true;
3397 bool enable_site = true;
3398 bool enable_site_center = true;
3399 bool enable_detail = true;
3400 bool ok = true;
3401 // Validate arguments
3402 if (hWnd == NULL || s == NULL)
3403 {
3404 return;
3405 }
3406
3407 if (s->IsBridge)
3408 {
3409 enable_remote = false;
3410 enable_site_center = false;
3411 enable_detail = false;
3412 }
3413
3414 if (IsChecked(hWnd, C_OTHER))
3415 {
3416 ok = false;
3417 }
3418
3419 SetEnable(hWnd, C_REMOTE, enable_remote && IsChecked(hWnd, C_OTHER) == false);
3420 SetEnable(hWnd, S_REMOTE_1, enable_remote && IsChecked(hWnd, C_OTHER) == false);
3421
3422 SetEnable(hWnd, C_SITE, enable_site && IsChecked(hWnd, C_OTHER) == false);
3423 SetEnable(hWnd, S_SITE_1, enable_site && IsChecked(hWnd, C_OTHER) == false);
3424 SetEnable(hWnd, S_SITE_2, enable_site && IsChecked(hWnd, C_SITE) && IsChecked(hWnd, C_OTHER) == false);
3425 SetEnable(hWnd, C_CENTER, enable_site && enable_site_center && IsChecked(hWnd, C_SITE) && IsChecked(hWnd, C_OTHER) == false);
3426 SetEnable(hWnd, C_EDGE, enable_site && IsChecked(hWnd, C_SITE) && IsChecked(hWnd, C_OTHER) == false);
3427
3428 SetEnable(hWnd, C_OTHER, enable_detail);
3429 SetEnable(hWnd, S_OTHER, enable_detail);
3430
3431 if (IsChecked(hWnd, C_REMOTE) == false && IsChecked(hWnd, C_SITE) == false)
3432 {
3433 ok = false;
3434 }
3435
3436 if (IsChecked(hWnd, C_SITE))
3437 {
3438 if (IsChecked(hWnd, C_CENTER) == false && IsChecked(hWnd, C_EDGE) == false)
3439 {
3440 ok = false;
3441 }
3442 }
3443
3444 SetEnable(hWnd, IDOK, ok);
3445
3446 SetText(hWnd, S_INFO,
3447 IsChecked(hWnd, C_OTHER) ? _UU("SM_SETUP_INFO_2") : _UU("SM_SETUP_INFO_1"));
3448 }
3449
3450 // Setup dialog
SmSetupDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)3451 UINT SmSetupDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
3452 {
3453 SM_SETUP *s = (SM_SETUP *)param;
3454 // Validate arguments
3455 if (hWnd == NULL)
3456 {
3457 return 0;
3458 }
3459
3460 switch (msg)
3461 {
3462 case WM_INITDIALOG:
3463 SmSetupDlgInit(hWnd, s);
3464 break;
3465
3466 case WM_COMMAND:
3467 SmSetupDlgUpdate(hWnd, s);
3468
3469 switch (wParam)
3470 {
3471 case IDOK:
3472 SmSetupDlgOnOk(hWnd, s);
3473 break;
3474
3475 case IDCANCEL:
3476 Close(hWnd);
3477 break;
3478 }
3479 break;
3480
3481 case WM_CLOSE:
3482 EndDialog(hWnd, 0);
3483 break;
3484 }
3485
3486 return 0;
3487 }
3488
3489 // Setup
SmSetup(HWND hWnd,SM_SERVER * s)3490 bool SmSetup(HWND hWnd, SM_SERVER *s)
3491 {
3492 SM_SETUP ss;
3493 // Validate arguments
3494 if (s == NULL)
3495 {
3496 return false;
3497 }
3498
3499 Zero(&ss, sizeof(ss));
3500 ss.s = s;
3501 ss.IsBridge = ss.s->Bridge;
3502 ss.Rpc = s->Rpc;
3503
3504 if (Dialog(hWnd, D_SM_SETUP, SmSetupDlg, &ss) == false)
3505 {
3506 return false;
3507 }
3508
3509 return true;
3510 }
3511
3512 // License registration process
SmLicenseAddDlgOnOk(HWND hWnd,SM_SERVER * s)3513 void SmLicenseAddDlgOnOk(HWND hWnd, SM_SERVER *s)
3514 {
3515 char tmp[MAX_SIZE];
3516 // Validate arguments
3517 if (hWnd == NULL || s == NULL)
3518 {
3519 return;
3520 }
3521
3522 SmLicenseAddDlgGetText(hWnd, tmp, sizeof(tmp));
3523
3524 if (LiIsLicenseKey(tmp))
3525 {
3526 RPC_TEST t;
3527
3528 Disable(hWnd, IDOK);
3529 Disable(hWnd, IDCANCEL);
3530
3531 Zero(&t, sizeof(t));
3532 StrCpy(t.StrValue, sizeof(t.StrValue), tmp);
3533
3534 if (CALL(hWnd, ScAddLicenseKey(s->Rpc, &t)) == false)
3535 {
3536 FocusEx(hWnd, B_KEY6);
3537 }
3538 else
3539 {
3540 EndDialog(hWnd, true);
3541 }
3542
3543 Enable(hWnd, IDOK);
3544 Enable(hWnd, IDCANCEL);
3545 }
3546 }
3547
3548 // Shift treatment of text input
SmLicenseAddDlgShiftTextItem(HWND hWnd,UINT id1,UINT id2,UINT * next_focus)3549 void SmLicenseAddDlgShiftTextItem(HWND hWnd, UINT id1, UINT id2, UINT *next_focus)
3550 {
3551 char *s;
3552 // Validate arguments
3553 if (hWnd == NULL || next_focus == NULL)
3554 {
3555 return;
3556 }
3557
3558 s = GetTextA(hWnd, id1);
3559 if (StrLen(s) >= 6)
3560 {
3561 char *s2 = CopyStr(s);
3562 char tmp[MAX_SIZE];
3563 s2[6] = 0;
3564 SetTextA(hWnd, id1, s2);
3565 Free(s2);
3566
3567 if (id2 != 0)
3568 {
3569 GetTxtA(hWnd, id2, tmp, sizeof(tmp));
3570
3571 StrCat(tmp, sizeof(tmp), s + 6);
3572 ReplaceStrEx(tmp, sizeof(tmp), tmp, "-", "", false);
3573
3574 SetTextA(hWnd, id2, tmp);
3575
3576 *next_focus = id2;
3577 }
3578 else
3579 {
3580 *next_focus = IDOK;
3581 }
3582 }
3583
3584 Free(s);
3585 }
3586
3587 // Make a text from the input data
SmLicenseAddDlgGetText(HWND hWnd,char * str,UINT size)3588 void SmLicenseAddDlgGetText(HWND hWnd, char *str, UINT size)
3589 {
3590 char *k1, *k2, *k3, *k4, *k5, *k6;
3591 // Validate arguments
3592 if (hWnd == NULL || str == NULL)
3593 {
3594 return;
3595 }
3596
3597 k1 = GetTextA(hWnd, B_KEY1);
3598 k2 = GetTextA(hWnd, B_KEY2);
3599 k3 = GetTextA(hWnd, B_KEY3);
3600 k4 = GetTextA(hWnd, B_KEY4);
3601 k5 = GetTextA(hWnd, B_KEY5);
3602 k6 = GetTextA(hWnd, B_KEY6);
3603
3604 Format(str, size, "%s-%s-%s-%s-%s-%s", k1, k2, k3, k4, k5, k6);
3605
3606 Free(k1);
3607 Free(k2);
3608 Free(k3);
3609 Free(k4);
3610 Free(k5);
3611 Free(k6);
3612 }
3613
3614 // License addition dialog update
SmLicenseAddDlgUpdate(HWND hWnd,SM_SERVER * s)3615 void SmLicenseAddDlgUpdate(HWND hWnd, SM_SERVER *s)
3616 {
3617 UINT next_focus = 0;
3618 char tmp[MAX_SIZE];
3619 // Validate arguments
3620 if (s == NULL || hWnd == NULL)
3621 {
3622 return;
3623 }
3624
3625 SmLicenseAddDlgShiftTextItem(hWnd, B_KEY1, B_KEY2, &next_focus);
3626 SmLicenseAddDlgShiftTextItem(hWnd, B_KEY2, B_KEY3, &next_focus);
3627 SmLicenseAddDlgShiftTextItem(hWnd, B_KEY3, B_KEY4, &next_focus);
3628 SmLicenseAddDlgShiftTextItem(hWnd, B_KEY4, B_KEY5, &next_focus);
3629 SmLicenseAddDlgShiftTextItem(hWnd, B_KEY5, B_KEY6, &next_focus);
3630 SmLicenseAddDlgShiftTextItem(hWnd, B_KEY6, 0, &next_focus);
3631
3632 if ((IsFocus(hWnd, B_KEY1) && GetTextLen(hWnd, B_KEY1, true) <= 5) ||
3633 (IsFocus(hWnd, B_KEY2) && GetTextLen(hWnd, B_KEY2, true) <= 5) ||
3634 (IsFocus(hWnd, B_KEY3) && GetTextLen(hWnd, B_KEY3, true) <= 5) ||
3635 (IsFocus(hWnd, B_KEY4) && GetTextLen(hWnd, B_KEY4, true) <= 5) ||
3636 (IsFocus(hWnd, B_KEY5) && GetTextLen(hWnd, B_KEY5, true) <= 5) ||
3637 (IsFocus(hWnd, B_KEY6) && GetTextLen(hWnd, B_KEY6, true) <= 5))
3638 {
3639 next_focus = 0;
3640 }
3641
3642 if (next_focus != 0)
3643 {
3644 Focus(hWnd, next_focus);
3645 }
3646
3647 SmLicenseAddDlgGetText(hWnd, tmp, sizeof(tmp));
3648
3649 SetEnable(hWnd, IDOK, LiIsLicenseKey(tmp));
3650 }
3651
3652 // License addition dialog initialization
SmLicenseAddDlgInit(HWND hWnd,SM_SERVER * s)3653 void SmLicenseAddDlgInit(HWND hWnd, SM_SERVER *s)
3654 {
3655 HFONT h;
3656 // Validate arguments
3657 if (hWnd == NULL || s == NULL)
3658 {
3659 return;
3660 }
3661
3662 h = GetFont("Arial", 10, true, false, false, false);
3663 SetFont(hWnd, B_KEY1, h);
3664 SetFont(hWnd, B_KEY2, h);
3665 SetFont(hWnd, B_KEY3, h);
3666 SetFont(hWnd, B_KEY4, h);
3667 SetFont(hWnd, B_KEY5, h);
3668 SetFont(hWnd, B_KEY6, h);
3669
3670 DlgFont(hWnd, S_INFO, 10, true);
3671
3672 SmLicenseAddDlgUpdate(hWnd, s);
3673 }
3674
3675 // License addition dialog
SmLicenseAddDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)3676 UINT SmLicenseAddDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
3677 {
3678 SM_SERVER *s = (SM_SERVER *)param;
3679 // Validate arguments
3680 if (hWnd == NULL)
3681 {
3682 return 0;
3683 }
3684
3685 switch (msg)
3686 {
3687 case WM_INITDIALOG:
3688 SmLicenseAddDlgInit(hWnd, s);
3689 break;
3690
3691 case WM_COMMAND:
3692 switch (LOWORD(wParam))
3693 {
3694 case B_KEY1:
3695 case B_KEY2:
3696 case B_KEY3:
3697 case B_KEY4:
3698 case B_KEY5:
3699 case B_KEY6:
3700 switch (HIWORD(wParam))
3701 {
3702 case EN_CHANGE:
3703 SmLicenseAddDlgUpdate(hWnd, s);
3704
3705 switch (LOWORD(wParam))
3706 {
3707 case B_KEY2:
3708 if (GetTextLen(hWnd, B_KEY2, true) == 0)
3709 {
3710 FocusEx(hWnd, B_KEY1);
3711 }
3712 break;
3713 case B_KEY3:
3714 if (GetTextLen(hWnd, B_KEY3, true) == 0)
3715 {
3716 FocusEx(hWnd, B_KEY2);
3717 }
3718 break;
3719 case B_KEY4:
3720 if (GetTextLen(hWnd, B_KEY4, true) == 0)
3721 {
3722 FocusEx(hWnd, B_KEY3);
3723 }
3724 break;
3725 case B_KEY5:
3726 if (GetTextLen(hWnd, B_KEY5, true) == 0)
3727 {
3728 FocusEx(hWnd, B_KEY4);
3729 }
3730 break;
3731 case B_KEY6:
3732 if (GetTextLen(hWnd, B_KEY6, true) == 0)
3733 {
3734 FocusEx(hWnd, B_KEY5);
3735 }
3736 break;
3737 }
3738 break;
3739 }
3740 break;
3741 }
3742
3743 switch (wParam)
3744 {
3745 case IDOK:
3746 SmLicenseAddDlgOnOk(hWnd, s);
3747 break;
3748
3749 case IDCANCEL:
3750 Close(hWnd);
3751 break;
3752 }
3753 break;
3754
3755 case WM_CLOSE:
3756 EndDialog(hWnd, 0);
3757 break;
3758 }
3759
3760 return 0;
3761 }
3762
3763 // Add a license
SmLicenseAdd(HWND hWnd,SM_SERVER * s)3764 bool SmLicenseAdd(HWND hWnd, SM_SERVER *s)
3765 {
3766 // Validate arguments
3767 if (s == NULL)
3768 {
3769 return false;
3770 }
3771
3772 return Dialog(hWnd, D_SM_LICENSE_ADD, SmLicenseAddDlg, s);
3773 }
3774
3775 // License dialog initialization
SmLicenseDlgInit(HWND hWnd,SM_SERVER * s)3776 void SmLicenseDlgInit(HWND hWnd, SM_SERVER *s)
3777 {
3778 // Validate arguments
3779 if (hWnd == NULL || s == NULL)
3780 {
3781 return;
3782 }
3783
3784 SetIcon(hWnd, 0, ICO_CERT);
3785
3786 DlgFont(hWnd, S_BOLD, 0, true);
3787 DlgFont(hWnd, S_BOLD2, 0, true);
3788
3789 LvInit(hWnd, L_LIST);
3790 LvSetStyle(hWnd, L_LIST, LVS_EX_GRIDLINES);
3791 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_LICENSE_COLUMN_1"), 50);
3792 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_LICENSE_COLUMN_2"), 100);
3793 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_LICENSE_COLUMN_3"), 290);
3794 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_LICENSE_COLUMN_4"), 150);
3795 LvInsertColumn(hWnd, L_LIST, 4, _UU("SM_LICENSE_COLUMN_5"), 120);
3796 LvInsertColumn(hWnd, L_LIST, 5, _UU("SM_LICENSE_COLUMN_6"), 250);
3797 LvInsertColumn(hWnd, L_LIST, 6, _UU("SM_LICENSE_COLUMN_7"), 100);
3798 LvInsertColumn(hWnd, L_LIST, 7, _UU("SM_LICENSE_COLUMN_8"), 100);
3799 LvInsertColumn(hWnd, L_LIST, 8, _UU("SM_LICENSE_COLUMN_9"), 100);
3800
3801 LvInitEx(hWnd, L_STATUS, true);
3802 LvInsertColumn(hWnd, L_STATUS, 0, _UU("SM_STATUS_COLUMN_1"), 100);
3803 LvInsertColumn(hWnd, L_STATUS, 1, _UU("SM_STATUS_COLUMN_2"), 100);
3804
3805 SmLicenseDlgRefresh(hWnd, s);
3806 }
3807
3808 // License dialog update
SmLicenseDlgRefresh(HWND hWnd,SM_SERVER * s)3809 void SmLicenseDlgRefresh(HWND hWnd, SM_SERVER *s)
3810 {
3811 RPC_ENUM_LICENSE_KEY t;
3812 RPC_LICENSE_STATUS st;
3813 UINT i;
3814 wchar_t tmp[MAX_SIZE];
3815 LVB *b;
3816 // Validate arguments
3817 if (hWnd == NULL || s == NULL)
3818 {
3819 return;
3820 }
3821
3822 Zero(&t, sizeof(t));
3823
3824 if (CALL(hWnd, ScEnumLicenseKey(s->Rpc, &t)) == false)
3825 {
3826 Close(hWnd);
3827 return;
3828 }
3829
3830 b = LvInsertStart();
3831
3832 for (i = 0;i < t.NumItem;i++)
3833 {
3834 wchar_t tmp1[32], tmp2[LICENSE_KEYSTR_LEN + 1], tmp3[LICENSE_MAX_PRODUCT_NAME_LEN + 1],
3835 *tmp4, tmp5[128], tmp6[LICENSE_LICENSEID_STR_LEN + 1], tmp7[64],
3836 tmp8[64], tmp9[64];
3837 RPC_ENUM_LICENSE_KEY_ITEM *e = &t.Items[i];
3838
3839 UniToStru(tmp1, e->Id);
3840 StrToUni(tmp2, sizeof(tmp2), e->LicenseKey);
3841 StrToUni(tmp3, sizeof(tmp3), e->LicenseName);
3842 tmp4 = LiGetLicenseStatusStr(e->Status);
3843 if (e->Expires == 0)
3844 {
3845 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_LICENSE_NO_EXPIRES"));
3846 }
3847 else
3848 {
3849 GetDateStrEx64(tmp5, sizeof(tmp5), e->Expires, NULL);
3850 }
3851 StrToUni(tmp6, sizeof(tmp6), e->LicenseId);
3852 UniToStru(tmp7, e->ProductId);
3853 UniFormat(tmp8, sizeof(tmp8), L"%I64u", e->SystemId);
3854 UniToStru(tmp9, e->SerialId);
3855
3856 LvInsertAdd(b,
3857 e->Status == LICENSE_STATUS_OK ? ICO_PASS : ICO_DISCARD,
3858 (void *)e->Id, 9,
3859 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9);
3860 }
3861
3862 LvInsertEnd(b, hWnd, L_LIST);
3863
3864 FreeRpcEnumLicenseKey(&t);
3865
3866 Zero(&st, sizeof(st));
3867
3868 if (CALL(hWnd, ScGetLicenseStatus(s->Rpc, &st)) == false)
3869 {
3870 Close(hWnd);
3871 return;
3872 }
3873
3874 b = LvInsertStart();
3875
3876 if (st.EditionId == LICENSE_EDITION_VPN3_NO_LICENSE)
3877 {
3878 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NO_LICENSE_COLUMN"), _UU("SM_NO_LICENSE"));
3879 }
3880 else
3881 {
3882 // Product edition name
3883 StrToUni(tmp, sizeof(tmp), st.EditionStr);
3884 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_EDITION"), tmp);
3885
3886 // Release date
3887 if (st.ReleaseDate != 0)
3888 {
3889 GetDateStrEx64(tmp, sizeof(tmp), st.ReleaseDate, NULL);
3890 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_RELEASE"), tmp);
3891 }
3892
3893 // Current system ID
3894 UniFormat(tmp, sizeof(tmp), L"%I64u", st.SystemId);
3895 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_SYSTEM_ID"), tmp);
3896
3897 // Expiration date of the current product license
3898 if (st.SystemExpires == 0)
3899 {
3900 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_NO_EXPIRES"));
3901 }
3902 else
3903 {
3904 GetDateStrEx64(tmp, sizeof(tmp), st.SystemExpires, NULL);
3905 }
3906 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_EXPIRES"), tmp);
3907
3908 // Subscription (support) contract
3909 if (st.NeedSubscription == false)
3910 {
3911 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_STATUS_SUBSCRIPTION_NONEED"));
3912 }
3913 else
3914 {
3915 if (st.SubscriptionExpires == 0)
3916 {
3917 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_STATUS_SUBSCRIPTION_NONE"));
3918 }
3919 else
3920 {
3921 wchar_t dtstr[MAX_PATH];
3922
3923 GetDateStrEx64(dtstr, sizeof(dtstr), st.SubscriptionExpires, NULL);
3924
3925 UniFormat(tmp, sizeof(tmp),
3926 st.IsSubscriptionExpired ? _UU("SM_LICENSE_STATUS_SUBSCRIPTION_EXPIRED") : _UU("SM_LICENSE_STATUS_SUBSCRIPTION_VALID"),
3927 dtstr);
3928 }
3929 }
3930 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_SUBSCRIPTION"), tmp);
3931
3932 if (st.NeedSubscription == false && st.SubscriptionExpires != 0)
3933 {
3934 wchar_t dtstr[MAX_PATH];
3935
3936 GetDateStrEx64(dtstr, sizeof(dtstr), st.SubscriptionExpires, NULL);
3937
3938 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_SUBSCRIPTION_BUILD_STR"), tmp);
3939 }
3940
3941 if (st.NeedSubscription && st.SubscriptionExpires != 0)
3942 {
3943 wchar_t dtstr[MAX_PATH];
3944
3945 GetDateStrEx64(dtstr, sizeof(dtstr), st.SubscriptionExpires, NULL);
3946
3947 UniFormat(tmp, sizeof(tmp), _UU("SM_LICENSE_STATUS_SUBSCRIPTION_BUILD_STR"), dtstr);
3948
3949 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_SUBSCRIPTION_BUILD"), tmp);
3950 }
3951
3952 if (GetCapsBool(s->CapsList, "b_vpn3"))
3953 {
3954 // Maximum number of users
3955 if (st.NumUserCreationLicense == INFINITE)
3956 {
3957 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_INFINITE"));
3958 }
3959 else
3960 {
3961 UniToStru(tmp, st.NumUserCreationLicense);
3962 }
3963 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_NUM_USER"), tmp);
3964 }
3965
3966 // Available number of concurrent client connections
3967 if (st.NumClientConnectLicense == INFINITE)
3968 {
3969 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_INFINITE"));
3970 }
3971 else
3972 {
3973 UniToStru(tmp, st.NumClientConnectLicense);
3974 }
3975 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_NUM_CLIENT"), tmp);
3976
3977 // Available number of concurrent Bridge connections
3978 if (st.NumBridgeConnectLicense == INFINITE)
3979 {
3980 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_INFINITE"));
3981 }
3982 else
3983 {
3984 UniToStru(tmp, st.NumBridgeConnectLicense);
3985 }
3986 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_NUM_BRIDGE"), tmp);
3987
3988 // Availability of enterprise features
3989 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_ENTERPRISE"),
3990 st.AllowEnterpriseFunction ? _UU("SM_LICENSE_STATUS_ENTERPRISE_YES") : _UU("SM_LICENSE_STATUS_ENTERPRISE_NO"));
3991 }
3992
3993 LvInsertEnd(b, hWnd, L_STATUS);
3994
3995 if (LvNum(hWnd, L_STATUS) >= 1)
3996 {
3997 LvAutoSize(hWnd, L_STATUS);
3998 }
3999
4000 SmLicenseDlgUpdate(hWnd, s);
4001 }
4002
4003 // License dialog control update
SmLicenseDlgUpdate(HWND hWnd,SM_SERVER * s)4004 void SmLicenseDlgUpdate(HWND hWnd, SM_SERVER *s)
4005 {
4006 bool b = false;
4007 // Validate arguments
4008 if (hWnd == NULL || s == NULL)
4009 {
4010 return;
4011 }
4012
4013 b = LvIsSingleSelected(hWnd, L_LIST);
4014
4015 SetEnable(hWnd, B_DEL, b);
4016 SetEnable(hWnd, IDOK, b);
4017 }
4018
4019 // License dialog
SmLicenseDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)4020 UINT SmLicenseDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
4021 {
4022 SM_SERVER *s = (SM_SERVER *)param;
4023 NMHDR *n;
4024 // Validate arguments
4025 if (hWnd == NULL)
4026 {
4027 return 0;
4028 }
4029
4030 switch (msg)
4031 {
4032 case WM_INITDIALOG:
4033 SmLicenseDlgInit(hWnd, s);
4034 break;
4035
4036 case WM_NOTIFY:
4037 n = (NMHDR *)lParam;
4038 switch (n->code)
4039 {
4040 case LVN_ITEMCHANGED:
4041 switch (n->idFrom)
4042 {
4043 case L_LIST:
4044 case L_STATUS:
4045 SmLicenseDlgUpdate(hWnd, s);
4046 break;
4047 }
4048 break;
4049 }
4050 break;
4051
4052 case WM_COMMAND:
4053 switch (wParam)
4054 {
4055 case IDOK:
4056 if (IsEnable(hWnd, IDOK))
4057 {
4058 UINT i = LvGetSelected(hWnd, L_LIST);
4059
4060 if (i != INFINITE)
4061 {
4062 char *s = LvGetStrA(hWnd, L_LIST, i, 1);
4063 char tmp[MAX_SIZE];
4064
4065 Format(tmp, sizeof(tmp), _SS("LICENSE_SUPPORT_URL"), s);
4066 ShellExecute(hWnd, "open", tmp, NULL, NULL, SW_SHOW);
4067
4068 Free(s);
4069 }
4070 }
4071 break;
4072
4073 case B_OBTAIN:
4074 ShellExecute(hWnd, "open", _SS("LICENSE_INFO_URL"), NULL, NULL, SW_SHOW);
4075 break;
4076
4077 case B_ADD:
4078 if (SmLicenseAdd(hWnd, s))
4079 {
4080 SmLicenseDlgRefresh(hWnd, s);
4081 }
4082 break;
4083
4084 case B_DEL:
4085 if (IsEnable(hWnd, B_DEL))
4086 {
4087 UINT id = (UINT)LvGetParam(hWnd, L_LIST, LvGetSelected(hWnd, L_LIST));
4088
4089 if (id != 0)
4090 {
4091 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("SM_LICENSE_DELETE_MSG")) == IDYES)
4092 {
4093 RPC_TEST t;
4094
4095 Zero(&t, sizeof(t));
4096 t.IntValue = id;
4097
4098 if (CALL(hWnd, ScDelLicenseKey(s->Rpc, &t)))
4099 {
4100 SmLicenseDlgRefresh(hWnd, s);
4101 }
4102 }
4103 }
4104 }
4105 break;
4106
4107 case IDCANCEL:
4108 Close(hWnd);
4109 break;
4110 }
4111 break;
4112
4113 case WM_CLOSE:
4114 EndDialog(hWnd, 0);
4115 break;
4116 }
4117
4118 LvStandardHandler(hWnd, msg, wParam, lParam, L_LIST);
4119
4120 return 0;
4121 }
4122
4123 // Add or Remove license
SmLicense(HWND hWnd,SM_SERVER * s)4124 void SmLicense(HWND hWnd, SM_SERVER *s)
4125 {
4126 // Validate arguments
4127 if (s == NULL)
4128 {
4129 return;
4130 }
4131
4132 Dialog(hWnd, D_SM_LICENSE, SmLicenseDlg, s);
4133
4134 FreeCapsList(s->CapsList);
4135 s->CapsList = ScGetCapsEx(s->Rpc);
4136 }
4137
4138 // Log storing procedure
SmSaveLogProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)4139 UINT SmSaveLogProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
4140 {
4141 SM_READ_LOG_FILE *p = (SM_READ_LOG_FILE *)param;
4142 // Validate arguments
4143 if (hWnd == NULL)
4144 {
4145 return 0;
4146 }
4147
4148 switch (msg)
4149 {
4150 case WM_INITDIALOG:
4151 FormatText(hWnd, S_INFO, p->filepath);
4152 break;
4153
4154 case WM_COMMAND:
4155 switch (wParam)
4156 {
4157 case IDOK:
4158 case B_SAVE:
4159 if (p->Buffer != NULL)
4160 {
4161 char filename[MAX_PATH];
4162
4163 Format(filename, sizeof(filename), "%s_%s", p->server_name, p->filepath);
4164 ConvertSafeFileName(filename, sizeof(filename), filename);
4165
4166 if (wParam == IDOK)
4167 {
4168 // Open with an editor
4169 char fullpath[MAX_PATH];
4170
4171 Format(fullpath, sizeof(fullpath), "%s\\%s",
4172 MsGetMyTempDir(), filename);
4173
4174 if (DumpBuf(p->Buffer, fullpath) == false)
4175 {
4176 MsgBoxEx(hWnd, MB_ICONSTOP, _UU("SM_READ_SAVE_TMP_FAILED"),
4177 fullpath);
4178 }
4179 else
4180 {
4181 if (((UINT)ShellExecute(hWnd, "open", fullpath, NULL, NULL, SW_SHOWNORMAL)) > 32)
4182 {
4183 EndDialog(hWnd, true);
4184 }
4185 else
4186 {
4187 MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SM_READ_SAVE_OPEN_ERROR"), fullpath);
4188 }
4189 }
4190 }
4191 else
4192 {
4193 // Save to a file
4194 wchar_t def[MAX_PATH];
4195 wchar_t *uni_path;
4196
4197 StrToUni(def, sizeof(def), filename);
4198
4199 uni_path = SaveDlg(hWnd, _UU("SM_READ_SAVE_DLG_FILTER"), _UU("SM_READ_SAVE_DLG_TITLE"),
4200 def, L".log");
4201
4202 if (uni_path != NULL)
4203 {
4204 char path[MAX_PATH];
4205
4206 UniToStr(path, sizeof(path), uni_path);
4207 Free(uni_path);
4208
4209 if (DumpBuf(p->Buffer, path) == false)
4210 {
4211 MsgBox(hWnd, MB_ICONSTOP, _UU("SM_READ_SAVE_FAILED"));
4212 }
4213 else
4214 {
4215 EndDialog(hWnd, true);
4216 }
4217 }
4218 }
4219 }
4220 break;
4221
4222 case IDCANCEL:
4223 Close(hWnd);
4224 break;
4225 }
4226 break;
4227
4228 case WM_CLOSE:
4229 EndDialog(hWnd, false);
4230 break;
4231 }
4232
4233 return 0;
4234 }
4235
4236 // Download callback procedure
SmReadLogFileProc(DOWNLOAD_PROGRESS * g)4237 bool SmReadLogFileProc(DOWNLOAD_PROGRESS *g)
4238 {
4239 wchar_t tmp[MAX_SIZE];
4240 char size1[64], size2[64];
4241 SM_READ_LOG_FILE *p;
4242 HWND hWnd;
4243 // Validate arguments
4244 if (g == NULL)
4245 {
4246 return false;
4247 }
4248
4249 p = (SM_READ_LOG_FILE *)g->Param;
4250 hWnd = p->hWnd;
4251
4252 SetPos(hWnd, P_PROGRESS, g->ProgressPercent);
4253
4254 ToStrByte(size1, sizeof(size1), g->CurrentSize);
4255 ToStrByte(size2, sizeof(size2), g->TotalSize);
4256 UniFormat(tmp, sizeof(tmp), _UU("SM_READ_LOG_FILE_INFO_2"), size2, size1);
4257
4258 SetText(hWnd, S_INFO, tmp);
4259
4260 DoEvents(hWnd);
4261
4262 return p->cancel_flag ? false : true;
4263 }
4264
4265 // Log file download dialog procedure
SmReadLogFile(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)4266 UINT SmReadLogFile(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
4267 {
4268 SM_READ_LOG_FILE *p = (SM_READ_LOG_FILE *)param;
4269 BUF *buf;
4270 // Validate arguments
4271 if (hWnd == NULL)
4272 {
4273 return 0;
4274 }
4275
4276 switch (msg)
4277 {
4278 case WM_INITDIALOG:
4279 p->hWnd = hWnd;
4280 SetFont(hWnd, S_INFO, Font(11, true));
4281 SetText(hWnd, S_INFO, _UU("SM_READ_LOG_FILE_INFO_1"));
4282 DisableClose(hWnd);
4283 FormatText(hWnd, S_INFO2, p->filepath);
4284 SetRange(hWnd, P_PROGRESS, 0, 100);
4285
4286 SetTimer(hWnd, 1, 100, NULL);
4287 break;
4288
4289 case WM_TIMER:
4290 switch (wParam)
4291 {
4292 case 1:
4293 KillTimer(hWnd, 1);
4294 buf = DownloadFileFromServer(p->s->Rpc, p->server_name, p->filepath, p->totalsize, SmReadLogFileProc, p);
4295 if (buf == NULL)
4296 {
4297 if (p->cancel_flag == false)
4298 {
4299 // Download failure
4300 MsgBox(hWnd, MB_ICONSTOP, _UU("SM_READ_LOG_FILE_ERROR"));
4301 }
4302 EndDialog(hWnd, false);
4303 }
4304 else
4305 {
4306 // Download success
4307 p->Buffer = buf;
4308 Dialog(hWnd, D_SM_SAVE_LOG, SmSaveLogProc, p);
4309 FreeBuf(buf);
4310 EndDialog(hWnd, true);
4311 }
4312 break;
4313 }
4314 break;
4315
4316 case WM_COMMAND:
4317 switch (wParam)
4318 {
4319 case IDCANCEL:
4320 p->cancel_flag = true;
4321 break;
4322 }
4323 break;
4324 }
4325
4326 return 0;
4327 }
4328
4329 // Start the download of the log file
SmLogFileStartDownload(HWND hWnd,SM_SERVER * s,char * server_name,char * filepath,UINT totalsize)4330 void SmLogFileStartDownload(HWND hWnd, SM_SERVER *s, char *server_name, char *filepath, UINT totalsize)
4331 {
4332 SM_READ_LOG_FILE p;
4333 // Validate arguments
4334 if (hWnd == NULL || server_name == NULL || filepath == NULL || totalsize == 0)
4335 {
4336 return;
4337 }
4338
4339 Zero(&p, sizeof(p));
4340 p.filepath = filepath;
4341 p.s = s;
4342 p.server_name = server_name;
4343 p.totalsize = totalsize;
4344
4345 Dialog(hWnd, D_SM_READ_LOG_FILE, SmReadLogFile, &p);
4346 }
4347
4348 // Initialize the dialog
SmLogFileDlgInit(HWND hWnd,SM_SERVER * p)4349 void SmLogFileDlgInit(HWND hWnd, SM_SERVER *p)
4350 {
4351 // Validate arguments
4352 if (hWnd == NULL || p == NULL)
4353 {
4354 return;
4355 }
4356
4357 SetIcon(hWnd, 0, ICO_LOG2);
4358
4359 LvInit(hWnd, L_LIST);
4360
4361 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_LOG_FILE_COLUMN_1"), 250);
4362 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_LOG_FILE_COLUMN_2"), 100);
4363 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_LOG_FILE_COLUMN_3"), 130);
4364 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_LOG_FILE_COLUMN_4"), 110);
4365
4366 SmLogFileDlgRefresh(hWnd, p);
4367 }
4368
4369 // Dialog content update
SmLogFileDlgRefresh(HWND hWnd,SM_SERVER * p)4370 void SmLogFileDlgRefresh(HWND hWnd, SM_SERVER *p)
4371 {
4372 UINT i;
4373 LVB *v;
4374 RPC_ENUM_LOG_FILE t;
4375 // Validate arguments
4376 if (hWnd == NULL || p == NULL)
4377 {
4378 return;
4379 }
4380
4381 Zero(&t, sizeof(t));
4382 if (CALL(hWnd, ScEnumLogFile(p->Rpc, &t)) == false)
4383 {
4384 Close(hWnd);
4385 return;
4386 }
4387
4388 v = LvInsertStart();
4389
4390 for (i = 0;i < t.NumItem;i++)
4391 {
4392 RPC_ENUM_LOG_FILE_ITEM *e = &t.Items[i];
4393 wchar_t tmp1[MAX_PATH], tmp2[128], tmp3[128], tmp4[MAX_HOST_NAME_LEN + 1];
4394 char tmp[MAX_SIZE];
4395
4396 StrToUni(tmp1, sizeof(tmp1), e->FilePath);
4397
4398 ToStrByte(tmp, sizeof(tmp), e->FileSize);
4399 StrToUni(tmp2, sizeof(tmp2), tmp);
4400
4401 GetDateTimeStr64Uni(tmp3, sizeof(tmp3), SystemToLocal64(e->UpdatedTime));
4402
4403 StrToUni(tmp4, sizeof(tmp4), e->ServerName);
4404
4405 LvInsertAdd(v, ICO_LOG2, (void *)e->FileSize, 4, tmp1, tmp2, tmp3, tmp4);
4406 }
4407
4408 LvInsertEndEx(v, hWnd, L_LIST, true);
4409
4410 if (t.NumItem != 0)
4411 {
4412 LvAutoSize(hWnd, L_LIST);
4413 }
4414
4415 FreeRpcEnumLogFile(&t);
4416
4417 SmLogFileDlgUpdate(hWnd, p);
4418 }
4419
4420 // Update the dialog control
SmLogFileDlgUpdate(HWND hWnd,SM_SERVER * p)4421 void SmLogFileDlgUpdate(HWND hWnd, SM_SERVER *p)
4422 {
4423 // Validate arguments
4424 if (hWnd == NULL || p == NULL)
4425 {
4426 return;
4427 }
4428
4429 SetEnable(hWnd, IDOK, LvIsSingleSelected(hWnd, L_LIST));
4430 }
4431
4432 // Log file dialog procedure
SmLogFileDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)4433 UINT SmLogFileDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
4434 {
4435 NMHDR *n;
4436 SM_SERVER *p = (SM_SERVER *)param;
4437 // Validate arguments
4438 if (hWnd == NULL)
4439 {
4440 return 0;
4441 }
4442
4443 switch (msg)
4444 {
4445 case WM_INITDIALOG:
4446 SmLogFileDlgInit(hWnd, p);
4447 break;
4448
4449 case WM_COMMAND:
4450 switch (wParam)
4451 {
4452 case IDOK:
4453 if (IsEnable(hWnd, IDOK))
4454 {
4455 UINT i = LvGetSelected(hWnd, L_LIST);
4456 if (i != INFINITE)
4457 {
4458 UINT size = (UINT)LvGetParam(hWnd, L_LIST, i);
4459 char *server_name;
4460 char *filepath;
4461
4462 server_name = LvGetStrA(hWnd, L_LIST, i, 3);
4463 filepath = LvGetStrA(hWnd, L_LIST, i, 0);
4464 SmLogFileStartDownload(hWnd, p, server_name, filepath, size);
4465 Free(filepath);
4466 Free(server_name);
4467 }
4468 }
4469 break;
4470
4471 case IDCANCEL:
4472 Close(hWnd);
4473 break;
4474
4475 case B_REFRESH:
4476 SmLogFileDlgRefresh(hWnd, p);
4477 break;
4478 }
4479 break;
4480
4481 case WM_NOTIFY:
4482 n = (NMHDR *)lParam;
4483 switch (n->code)
4484 {
4485 case LVN_ITEMCHANGED:
4486 switch (n->idFrom)
4487 {
4488 case L_LIST:
4489 SmLogFileDlgUpdate(hWnd, p);
4490 break;
4491 }
4492 break;
4493 }
4494 break;
4495
4496 case WM_CLOSE:
4497 EndDialog(hWnd, false);
4498 break;
4499 }
4500
4501 LvStandardHandler(hWnd, msg, wParam, lParam, L_LIST);
4502
4503 return 0;
4504 }
4505
4506 // Initialize the dialog
SmHubEditAcDlgInit(HWND hWnd,SM_EDIT_AC * p)4507 void SmHubEditAcDlgInit(HWND hWnd, SM_EDIT_AC *p)
4508 {
4509 // Validate arguments
4510 if (hWnd == NULL || p == NULL)
4511 {
4512 return;
4513 }
4514
4515 SetEnable(hWnd, R_IPV6, GetCapsBool(p->e->s->p->CapsList, "b_support_ipv6_ac"));
4516
4517 if (p->id == 0)
4518 {
4519 UINT i, v;
4520
4521 Check(hWnd, R_SINGLE, true);
4522 Check(hWnd, R_PASS, true);
4523 Check(hWnd, R_IPV4, true);
4524
4525 v = 0;
4526
4527 for (i = 0;i < LIST_NUM(p->e->AcList);i++)
4528 {
4529 AC *ac = LIST_DATA(p->e->AcList, i);
4530
4531 v = MAX(v, ac->Priority);
4532 }
4533
4534 v += 100;
4535
4536 SetInt(hWnd, E_PRIORITY, v);
4537 }
4538 else
4539 {
4540 AC *ac = GetAc(p->e->AcList, p->id);
4541
4542 if (ac == NULL)
4543 {
4544 EndDialog(hWnd, false);
4545 return;
4546 }
4547
4548 Check(hWnd, R_SINGLE, ac->Masked == false);
4549 Check(hWnd, R_MASKED, ac->Masked);
4550 Check(hWnd, R_IPV4, IsIP4(&ac->IpAddress));
4551 Check(hWnd, R_IPV6, IsIP6(&ac->IpAddress));
4552
4553 if (IsIP4(&ac->IpAddress))
4554 {
4555 IpSet(hWnd, E_IP, IPToUINT(&ac->IpAddress));
4556 }
4557 else
4558 {
4559 char tmp[MAX_SIZE];
4560
4561 IPToStr(tmp, sizeof(tmp), &ac->IpAddress);
4562 SetTextA(hWnd, E_IPV6, tmp);
4563 }
4564
4565 if (ac->Masked)
4566 {
4567 if (IsIP4(&ac->IpAddress))
4568 {
4569 IpSet(hWnd, E_MASK, IPToUINT(&ac->SubnetMask));
4570 }
4571 else
4572 {
4573 char tmp[MAX_SIZE];
4574
4575 MaskToStrEx(tmp, sizeof(tmp), &ac->SubnetMask, false);
4576
4577 if (IsNum(tmp))
4578 {
4579 StrCatLeft(tmp, sizeof(tmp), "/");
4580 }
4581
4582 SetTextA(hWnd, E_MASKV6, tmp);
4583 }
4584 }
4585
4586 Check(hWnd, R_PASS, ac->Deny == false);
4587 Check(hWnd, R_DENY, ac->Deny);
4588 SetInt(hWnd, E_PRIORITY, ac->Priority);
4589
4590 Free(ac);
4591 }
4592
4593 Focus(hWnd, E_IP);
4594
4595 SmHubEditAcDlgUpdate(hWnd, p);
4596 }
4597
4598 // Dialog update
SmHubEditAcDlgUpdate(HWND hWnd,SM_EDIT_AC * p)4599 void SmHubEditAcDlgUpdate(HWND hWnd, SM_EDIT_AC *p)
4600 {
4601 bool b = true;
4602 char tmp[MAX_SIZE];
4603 // Validate arguments
4604 if (hWnd == NULL || p == NULL)
4605 {
4606 return;
4607 }
4608
4609 if (IsChecked(hWnd, R_SINGLE))
4610 {
4611 if (IsChecked(hWnd, R_IPV6) == false)
4612 {
4613 Show(hWnd, E_IP);
4614 Hide(hWnd, E_IPV6);
4615
4616 if (IpIsFilled(hWnd, E_IP) == false)
4617 {
4618 b = false;
4619 }
4620
4621 if (IpGet(hWnd, E_IP) == 0 || IpGet(hWnd, E_IP) == 0xffffffff)
4622 {
4623 b = false;
4624 }
4625 }
4626 else
4627 {
4628 Show(hWnd, E_IPV6);
4629 Hide(hWnd, E_IP);
4630
4631 GetTxtA(hWnd, E_IPV6, tmp, sizeof(tmp));
4632
4633 if (IsStrIPv6Address(tmp) == false)
4634 {
4635 b = false;
4636 }
4637 }
4638
4639 Hide(hWnd, S_MASK);
4640 Hide(hWnd, E_MASK);
4641 Hide(hWnd, E_MASKV6);
4642 }
4643 else
4644 {
4645 if (IsChecked(hWnd, R_IPV6) == false)
4646 {
4647 Show(hWnd, E_IP);
4648 Hide(hWnd, E_IPV6);
4649
4650 if (IpIsFilled(hWnd, E_IP) == false || IpIsFilled(hWnd, E_MASK) == false)
4651 {
4652 b = false;
4653 }
4654
4655 if (IpGet(hWnd, E_IP) == 0xffffffff)
4656 {
4657 b = false;
4658 }
4659 }
4660 else
4661 {
4662 char tmp1[MAX_SIZE], tmp2[MAX_SIZE];
4663
4664 Show(hWnd, E_IPV6);
4665 Hide(hWnd, E_IP);
4666
4667 GetTxtA(hWnd, E_IPV6, tmp1, sizeof(tmp1));
4668 GetTxtA(hWnd, E_MASKV6, tmp2, sizeof(tmp2));
4669
4670 if (!(IsIpStr6(tmp1) && IsIpMask6(tmp2)))
4671 {
4672 b = false;
4673 }
4674 }
4675
4676 Show(hWnd, S_MASK);
4677 SetShow(hWnd, E_MASK, !IsChecked(hWnd, R_IPV6));
4678 SetShow(hWnd, E_MASKV6, IsChecked(hWnd, R_IPV6));
4679 }
4680
4681 if (GetInt(hWnd, E_PRIORITY) == 0)
4682 {
4683 b = false;
4684 }
4685
4686 SetIcon(hWnd, S_ICON, IsChecked(hWnd, R_PASS) ? ICO_INTERNET : ICO_INTERNET_X);
4687
4688 SetEnable(hWnd, IDOK, b);
4689 }
4690
4691 // OK button is clicked in the dialog
SmHubEditAcDlgOnOk(HWND hWnd,SM_EDIT_AC * p)4692 void SmHubEditAcDlgOnOk(HWND hWnd, SM_EDIT_AC *p)
4693 {
4694 AC ac;
4695 char tmp[MAX_SIZE];
4696 // Validate arguments
4697 if (hWnd == NULL || p == NULL)
4698 {
4699 return;
4700 }
4701
4702 Zero(&ac, sizeof(ac));
4703 ac.Deny = IsChecked(hWnd, R_DENY);
4704 ac.Priority = GetInt(hWnd, E_PRIORITY);
4705
4706 if (IsChecked(hWnd, R_IPV6) == false)
4707 {
4708 UINTToIP(&ac.IpAddress, IpGet(hWnd, E_IP));
4709 }
4710 else
4711 {
4712 GetTxtA(hWnd, E_IPV6, tmp, sizeof(tmp));
4713
4714 StrToIP6(&ac.IpAddress, tmp);
4715 }
4716
4717 ac.Masked = IsChecked(hWnd, R_MASKED);
4718
4719 if (ac.Masked)
4720 {
4721 if (IsChecked(hWnd, R_IPV6) == false)
4722 {
4723 UINTToIP(&ac.SubnetMask, IpGet(hWnd, E_MASK));
4724 }
4725 else
4726 {
4727 GetTxtA(hWnd, E_MASKV6, tmp, sizeof(tmp));
4728
4729 StrToMask6(&ac.SubnetMask, tmp);
4730 }
4731 }
4732
4733 if (p->id != 0)
4734 {
4735 SetAc(p->e->AcList, p->id, &ac);
4736 }
4737 else
4738 {
4739 AddAc(p->e->AcList, &ac);
4740 }
4741
4742 EndDialog(hWnd, true);
4743 }
4744
4745 // AC edit dialog
SmHubEditAcDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)4746 UINT SmHubEditAcDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
4747 {
4748 SM_EDIT_AC *p = (SM_EDIT_AC *)param;
4749 // Validate arguments
4750 if (hWnd == NULL)
4751 {
4752 return 0;
4753 }
4754
4755 switch (msg)
4756 {
4757 case WM_INITDIALOG:
4758 SmHubEditAcDlgInit(hWnd, p);
4759 break;
4760
4761 case WM_COMMAND:
4762 switch (LOWORD(wParam))
4763 {
4764 case R_SINGLE:
4765 case R_MASKED:
4766 case E_IP:
4767 case E_MASK:
4768 case R_PASS:
4769 case R_DENY:
4770 case E_PRIORITY:
4771 case R_IPV4:
4772 case R_IPV6:
4773 case E_IPV6:
4774 case E_MASKV6:
4775 SmHubEditAcDlgUpdate(hWnd, p);
4776 break;
4777 }
4778
4779 switch (wParam)
4780 {
4781 case R_IPV4:
4782 case R_IPV6:
4783 case R_SINGLE:
4784 case R_MASKED:
4785 if (IsChecked(hWnd, R_IPV6) == false)
4786 {
4787 if (IpIsFilled(hWnd, E_IP))
4788 {
4789 Focus(hWnd, E_MASK);
4790 }
4791 else
4792 {
4793 Focus(hWnd, E_IP);
4794 }
4795 }
4796 else
4797 {
4798 char tmp[MAX_SIZE];
4799
4800 GetTxtA(hWnd, E_IPV6, tmp, sizeof(tmp));
4801
4802 if (IsStrIPv6Address(tmp))
4803 {
4804 FocusEx(hWnd, E_MASKV6);
4805 }
4806 else
4807 {
4808 FocusEx(hWnd, E_IPV6);
4809 }
4810 }
4811 break;
4812
4813 case IDOK:
4814 SmHubEditAcDlgOnOk(hWnd, p);
4815 break;
4816
4817 case IDCANCEL:
4818 Close(hWnd);
4819 break;
4820 }
4821 break;
4822
4823 case WM_CLOSE:
4824 EndDialog(hWnd, false);
4825 break;
4826 }
4827
4828 return 0;
4829 }
4830
4831 // Initialize the dialog
SmHubAcDlgInit(HWND hWnd,SM_EDIT_AC_LIST * p)4832 void SmHubAcDlgInit(HWND hWnd, SM_EDIT_AC_LIST *p)
4833 {
4834 // Validate arguments
4835 if (hWnd == NULL || p == NULL)
4836 {
4837 return;
4838 }
4839
4840 SetIcon(hWnd, 0, ICO_INTERNET);
4841
4842 FormatText(hWnd, S_TITLE, p->s->HubName);
4843
4844 LvInit(hWnd, L_LIST);
4845 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_AC_COLUMN_1"), 40);
4846 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_AC_COLUMN_2"), 80);
4847 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_AC_COLUMN_3"), 90);
4848 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_AC_COLUMN_4"), 170);
4849
4850 SmHubAcDlgRefresh(hWnd, p);
4851 }
4852
4853 // Update the dialog control
SmHubAcDlgUpdate(HWND hWnd,SM_EDIT_AC_LIST * p)4854 void SmHubAcDlgUpdate(HWND hWnd, SM_EDIT_AC_LIST *p)
4855 {
4856 bool b;
4857 // Validate arguments
4858 if (hWnd == NULL || p == NULL)
4859 {
4860 return;
4861 }
4862
4863 b = LvIsSingleSelected(hWnd, L_LIST);
4864
4865 SetEnable(hWnd, IDOK, b);
4866 SetEnable(hWnd, B_DELETE, b);
4867 }
4868
4869 // Dialog content update
SmHubAcDlgRefresh(HWND hWnd,SM_EDIT_AC_LIST * p)4870 void SmHubAcDlgRefresh(HWND hWnd, SM_EDIT_AC_LIST *p)
4871 {
4872 UINT i;
4873 LVB *v;
4874 // Validate arguments
4875 if (hWnd == NULL || p == NULL)
4876 {
4877 return;
4878 }
4879
4880 v = LvInsertStart();
4881
4882 for (i = 0;i < LIST_NUM(p->AcList);i++)
4883 {
4884 wchar_t tmp1[32], *tmp2, tmp3[MAX_SIZE], tmp4[32];
4885 char *tmp_str;
4886 AC *ac = LIST_DATA(p->AcList, i);
4887
4888 UniToStru(tmp1, ac->Id);
4889 tmp2 = ac->Deny ? _UU("SM_AC_DENY") : _UU("SM_AC_PASS");
4890 tmp_str = GenerateAcStr(ac);
4891 StrToUni(tmp3, sizeof(tmp3), tmp_str);
4892
4893 Free(tmp_str);
4894
4895 UniToStru(tmp4, ac->Priority);
4896
4897 LvInsertAdd(v, ac->Deny ? ICO_INTERNET_X : ICO_INTERNET,
4898 (void *)ac->Id, 4, tmp1, tmp4, tmp2, tmp3);
4899 }
4900
4901 LvInsertEnd(v, hWnd, L_LIST);
4902 LvSortEx(hWnd, L_LIST, 0, false, true);
4903
4904
4905 SmHubAcDlgUpdate(hWnd, p);
4906 }
4907
4908 // Access control list editing dialog
SmHubAcDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)4909 UINT SmHubAcDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
4910 {
4911 NMHDR *n;
4912 SM_EDIT_AC_LIST *p = (SM_EDIT_AC_LIST *)param;
4913 // Validate arguments
4914 if (hWnd == NULL)
4915 {
4916 return 0;
4917 }
4918
4919 switch (msg)
4920 {
4921 case WM_INITDIALOG:
4922 SmHubAcDlgInit(hWnd, p);
4923 break;
4924
4925 case WM_COMMAND:
4926 switch (wParam)
4927 {
4928 case IDOK:
4929 if (IsEnable(hWnd, IDOK))
4930 {
4931 SM_EDIT_AC s;
4932 Zero(&s, sizeof(s));
4933
4934 s.e = p;
4935 s.id = (UINT)LvGetParam(hWnd, L_LIST, LvGetSelected(hWnd, L_LIST));
4936
4937 if (Dialog(hWnd, D_SM_AC, SmHubEditAcDlgProc, &s))
4938 {
4939 SmHubAcDlgRefresh(hWnd, p);
4940 }
4941 }
4942 break;
4943
4944 case B_ADD:
4945 if (IsEnable(hWnd, B_ADD))
4946 {
4947 SM_EDIT_AC s;
4948 Zero(&s, sizeof(s));
4949
4950 s.e = p;
4951
4952 if (Dialog(hWnd, D_SM_AC, SmHubEditAcDlgProc, &s))
4953 {
4954 SmHubAcDlgRefresh(hWnd, p);
4955 }
4956 }
4957 break;
4958
4959 case B_DELETE:
4960 if (IsEnable(hWnd, B_DELETE))
4961 {
4962 UINT id = (UINT)LvGetParam(hWnd, L_LIST, LvGetSelected(hWnd, L_LIST));
4963
4964 if (DelAc(p->AcList, id))
4965 {
4966 SmHubAcDlgRefresh(hWnd, p);
4967 }
4968 }
4969 break;
4970
4971 case B_SAVE:
4972 if (IsEnable(hWnd, B_SAVE))
4973 {
4974 RPC_AC_LIST t;
4975
4976 Zero(&t, sizeof(t));
4977 StrCpy(t.HubName, sizeof(t.HubName), p->s->HubName);
4978 t.o = CloneAcList(p->AcList);
4979
4980 if (CALL(hWnd, ScSetAcList(p->s->p->Rpc, &t)))
4981 {
4982 EndDialog(hWnd, true);
4983 }
4984
4985 FreeRpcAcList(&t);
4986 }
4987 break;
4988
4989 case IDCANCEL:
4990 Close(hWnd);
4991 break;
4992 }
4993 break;
4994
4995 case WM_NOTIFY:
4996 n = (NMHDR *)lParam;
4997 switch (n->code)
4998 {
4999 case LVN_ITEMCHANGED:
5000 switch (n->idFrom)
5001 {
5002 case L_LIST:
5003 SmHubAcDlgUpdate(hWnd, p);
5004 break;
5005 }
5006 break;
5007 }
5008 break;
5009
5010 case WM_CLOSE:
5011 EndDialog(hWnd, false);
5012 break;
5013 }
5014
5015 LvStandardHandler(hWnd, msg, wParam, lParam, L_LIST);
5016
5017 return 0;
5018 }
5019
5020 // Access control list editing
SmHubAc(HWND hWnd,SM_EDIT_HUB * s)5021 void SmHubAc(HWND hWnd, SM_EDIT_HUB *s)
5022 {
5023 SM_EDIT_AC_LIST p;
5024 RPC_AC_LIST t;
5025 // Validate arguments
5026 if (hWnd == NULL || s == NULL)
5027 {
5028 return;
5029 }
5030
5031 Zero(&t, sizeof(t));
5032 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
5033
5034 if (CALL(hWnd, ScGetAcList(s->p->Rpc, &t)) == false)
5035 {
5036 return;
5037 }
5038
5039 Zero(&p, sizeof(p));
5040 p.s = s;
5041 p.AcList = CloneAcList(t.o);
5042
5043 FreeRpcAcList(&t);
5044
5045 Dialog(hWnd, D_SM_AC_LIST, SmHubAcDlgProc, &p);
5046
5047 FreeAcList(p.AcList);
5048 }
5049
5050 // Initialize the dialog
SmEditCrlDlgInit(HWND hWnd,SM_EDIT_CRL * c)5051 void SmEditCrlDlgInit(HWND hWnd, SM_EDIT_CRL *c)
5052 {
5053 // Validate arguments
5054 if (hWnd == NULL || c == NULL)
5055 {
5056 return;
5057 }
5058
5059 if (c->NewCrl == false)
5060 {
5061 RPC_CRL t;
5062 CRL *crl;
5063
5064 Zero(&t, sizeof(t));
5065 StrCpy(t.HubName, sizeof(t.HubName), c->s->HubName);
5066 t.Key = c->Key;
5067
5068 if (CALL(hWnd, ScGetCrl(c->s->Rpc, &t)) == false)
5069 {
5070 EndDialog(hWnd, false);
5071 return;
5072 }
5073
5074 crl = t.Crl;
5075
5076 SmEditCrlDlgSetName(hWnd, crl->Name);
5077 SmEditCrlDlgSetSerial(hWnd, crl->Serial);
5078 SmEditCrlDlgSetHash(hWnd, crl->DigestMD5, crl->DigestSHA1);
5079
5080 FreeRpcCrl(&t);
5081 }
5082
5083 SmEditCrlDlgUpdate(hWnd, c);
5084 }
5085
5086 // Update the controls
SmEditCrlDlgUpdate(HWND hWnd,SM_EDIT_CRL * c)5087 void SmEditCrlDlgUpdate(HWND hWnd, SM_EDIT_CRL *c)
5088 {
5089 bool b = true;
5090 // Validate arguments
5091 if (hWnd == NULL || c == NULL)
5092 {
5093 return;
5094 }
5095
5096 SetEnable(hWnd, E_CN, IsChecked(hWnd, R_CN));
5097 SetEnable(hWnd, E_O, IsChecked(hWnd, R_O));
5098 SetEnable(hWnd, E_OU, IsChecked(hWnd, R_OU));
5099 SetEnable(hWnd, E_C, IsChecked(hWnd, R_C));
5100 SetEnable(hWnd, E_ST, IsChecked(hWnd, R_ST));
5101 SetEnable(hWnd, E_L, IsChecked(hWnd, R_L));
5102 SetEnable(hWnd, E_SERI, IsChecked(hWnd, R_SERI));
5103 SetEnable(hWnd, E_MD5_HASH, IsChecked(hWnd, R_MD5_HASH));
5104 SetEnable(hWnd, E_SHA1_HASH, IsChecked(hWnd, R_SHA1_HASH));
5105
5106 if (IsChecked(hWnd, R_CN))
5107 {
5108 if (IsEmpty(hWnd, E_CN))
5109 {
5110 b = false;
5111 }
5112 }
5113
5114 if (IsChecked(hWnd, R_O))
5115 {
5116 if (IsEmpty(hWnd, E_O))
5117 {
5118 b = false;
5119 }
5120 }
5121
5122 if (IsChecked(hWnd, R_OU))
5123 {
5124 if (IsEmpty(hWnd, E_OU))
5125 {
5126 b = false;
5127 }
5128 }
5129
5130 if (IsChecked(hWnd, R_C))
5131 {
5132 if (IsEmpty(hWnd, E_C))
5133 {
5134 b = false;
5135 }
5136 }
5137
5138 if (IsChecked(hWnd, R_ST))
5139 {
5140 if (IsEmpty(hWnd, E_ST))
5141 {
5142 b = false;
5143 }
5144 }
5145
5146 if (IsChecked(hWnd, R_L))
5147 {
5148 if (IsEmpty(hWnd, E_L))
5149 {
5150 b = false;
5151 }
5152 }
5153
5154 if (IsChecked(hWnd, R_SERI))
5155 {
5156 char tmp[MAX_SIZE];
5157 BUF *buf;
5158
5159 GetTxtA(hWnd, E_SERI, tmp, sizeof(tmp));
5160 buf = StrToBin(tmp);
5161
5162 if (buf->Size == 0)
5163 {
5164 b = false;
5165 }
5166
5167 FreeBuf(buf);
5168 }
5169
5170 if (IsChecked(hWnd, R_MD5_HASH))
5171 {
5172 char tmp[MAX_SIZE];
5173 BUF *buf;
5174
5175 GetTxtA(hWnd, E_MD5_HASH, tmp, sizeof(tmp));
5176 buf = StrToBin(tmp);
5177
5178 if (buf->Size != MD5_SIZE)
5179 {
5180 b = false;
5181 }
5182
5183 FreeBuf(buf);
5184 }
5185
5186 if (IsChecked(hWnd, R_SHA1_HASH))
5187 {
5188 char tmp[MAX_SIZE];
5189 BUF *buf;
5190
5191 GetTxtA(hWnd, E_SHA1_HASH, tmp, sizeof(tmp));
5192 buf = StrToBin(tmp);
5193
5194 if (buf->Size != SHA1_SIZE)
5195 {
5196 b = false;
5197 }
5198
5199 FreeBuf(buf);
5200 }
5201
5202 SetEnable(hWnd, IDOK, b);
5203 }
5204
5205 // On click the OK button
SmEditCrlDlgOnOk(HWND hWnd,SM_EDIT_CRL * c)5206 void SmEditCrlDlgOnOk(HWND hWnd, SM_EDIT_CRL *c)
5207 {
5208 CRL *crl;
5209 NAME *n;
5210 RPC_CRL t;
5211 bool empty = true;
5212 // Validate arguments
5213 if (hWnd == NULL || c == NULL)
5214 {
5215 return;
5216 }
5217
5218 crl = ZeroMalloc(sizeof(CRL));
5219 crl->Name = ZeroMalloc(sizeof(NAME));
5220 n = crl->Name;
5221
5222 if (IsChecked(hWnd, R_CN))
5223 {
5224 n->CommonName = GetText(hWnd, E_CN);
5225 empty = false;
5226 }
5227
5228 if (IsChecked(hWnd, R_O))
5229 {
5230 n->Organization = GetText(hWnd, E_O);
5231 empty = false;
5232 }
5233
5234 if (IsChecked(hWnd, R_OU))
5235 {
5236 n->Unit = GetText(hWnd, E_OU);
5237 empty = false;
5238 }
5239
5240 if (IsChecked(hWnd, R_C))
5241 {
5242 n->Country = GetText(hWnd, E_C);
5243 empty = false;
5244 }
5245
5246 if (IsChecked(hWnd, R_ST))
5247 {
5248 n->State = GetText(hWnd, E_ST);
5249 empty = false;
5250 }
5251
5252 if (IsChecked(hWnd, R_L))
5253 {
5254 n->Local = GetText(hWnd, E_L);
5255 empty = false;
5256 }
5257
5258 if (IsChecked(hWnd, R_SERI))
5259 {
5260 char tmp[MAX_SIZE];
5261 BUF *b;
5262
5263 GetTxtA(hWnd, E_SERI, tmp, sizeof(tmp));
5264 b = StrToBin(tmp);
5265
5266 if (b != NULL && b->Size >= 1)
5267 {
5268 crl->Serial = NewXSerial(b->Buf, b->Size);
5269 }
5270
5271 FreeBuf(b);
5272
5273 empty = false;
5274 }
5275
5276 if (IsChecked(hWnd, R_MD5_HASH))
5277 {
5278 char tmp[MAX_SIZE];
5279 BUF *b;
5280
5281 GetTxtA(hWnd, E_MD5_HASH, tmp, sizeof(tmp));
5282 b = StrToBin(tmp);
5283
5284 if (b != NULL && b->Size == MD5_SIZE)
5285 {
5286 Copy(crl->DigestMD5, b->Buf, MD5_SIZE);
5287 }
5288
5289 FreeBuf(b);
5290
5291 empty = false;
5292 }
5293
5294 if (IsChecked(hWnd, R_SHA1_HASH))
5295 {
5296 char tmp[MAX_SIZE];
5297 BUF *b;
5298
5299 GetTxtA(hWnd, E_SHA1_HASH, tmp, sizeof(tmp));
5300 b = StrToBin(tmp);
5301
5302 if (b != NULL && b->Size == SHA1_SIZE)
5303 {
5304 Copy(crl->DigestSHA1, b->Buf, SHA1_SIZE);
5305 }
5306
5307 FreeBuf(b);
5308
5309 empty = false;
5310 }
5311
5312 if (empty)
5313 {
5314 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, _UU("SM_CRL_EMPTY_MSG")) == IDNO)
5315 {
5316 return;
5317 }
5318 }
5319
5320 if (c->NewCrl)
5321 {
5322 Zero(&t, sizeof(t));
5323 StrCpy(t.HubName, sizeof(t.HubName), c->s->HubName);
5324 t.Crl = crl;
5325
5326 if (CALL(hWnd, ScAddCrl(c->s->Rpc, &t)))
5327 {
5328 EndDialog(hWnd, true);
5329 }
5330
5331 FreeRpcCrl(&t);
5332 }
5333 else
5334 {
5335 Zero(&t, sizeof(t));
5336 StrCpy(t.HubName, sizeof(t.HubName), c->s->HubName);
5337 t.Crl = crl;
5338 t.Key = c->Key;
5339
5340 if (CALL(hWnd, ScSetCrl(c->s->Rpc, &t)))
5341 {
5342 EndDialog(hWnd, true);
5343 }
5344
5345 FreeRpcCrl(&t);
5346 }
5347 }
5348
5349 // Read the certificate
SmEditCrlDlgOnLoad(HWND hWnd,SM_EDIT_CRL * c)5350 void SmEditCrlDlgOnLoad(HWND hWnd, SM_EDIT_CRL *c)
5351 {
5352 X *x;
5353 // Validate arguments
5354 if (hWnd == NULL || c == NULL)
5355 {
5356 return;
5357 }
5358
5359 if (CmLoadXFromFileOrSecureCard(hWnd, &x))
5360 {
5361 UCHAR md5[MD5_SIZE], sha1[SHA1_SIZE];
5362
5363 SmEditCrlDlgSetName(hWnd, x->subject_name);
5364 SmEditCrlDlgSetSerial(hWnd, x->serial);
5365 GetXDigest(x, md5, false);
5366 GetXDigest(x, sha1, true);
5367 SmEditCrlDlgSetHash(hWnd, md5, sha1);
5368
5369 FreeX(x);
5370
5371 SmEditCrlDlgUpdate(hWnd, c);
5372 }
5373 }
5374
5375 // Set the hash information to the dialog
SmEditCrlDlgSetHash(HWND hWnd,UCHAR * hash_md5,UCHAR * hash_sha1)5376 void SmEditCrlDlgSetHash(HWND hWnd, UCHAR *hash_md5, UCHAR *hash_sha1)
5377 {
5378 char tmp[MAX_SIZE];
5379 // Validate arguments
5380 if (hWnd == NULL)
5381 {
5382 return;
5383 }
5384
5385 if (hash_md5 != NULL && IsZero(hash_md5, MD5_SIZE) == false)
5386 {
5387 Check(hWnd, R_MD5_HASH, true);
5388 BinToStrEx(tmp, sizeof(tmp), hash_md5, MD5_SIZE);
5389 SetTextA(hWnd, E_MD5_HASH, tmp);
5390 }
5391 else
5392 {
5393 Check(hWnd, R_MD5_HASH, false);
5394 }
5395
5396 if (hash_sha1 != NULL && IsZero(hash_sha1, SHA1_SIZE) == false)
5397 {
5398 Check(hWnd, R_SHA1_HASH, true);
5399 BinToStrEx(tmp, sizeof(tmp), hash_sha1, SHA1_SIZE);
5400 SetTextA(hWnd, E_SHA1_HASH, tmp);
5401 }
5402 else
5403 {
5404 Check(hWnd, R_SHA1_HASH, false);
5405 }
5406 }
5407
5408 // Set the serial number to the dialog
SmEditCrlDlgSetSerial(HWND hWnd,X_SERIAL * serial)5409 void SmEditCrlDlgSetSerial(HWND hWnd, X_SERIAL *serial)
5410 {
5411 char tmp[MAX_SIZE];
5412 // Validate arguments
5413 if (hWnd == NULL || serial == NULL)
5414 {
5415 return;
5416 }
5417
5418 BinToStrEx(tmp, sizeof(tmp), serial->data, serial->size);
5419
5420 Check(hWnd, R_SERI, true);
5421
5422 SetTextA(hWnd, E_SERI, tmp);
5423 }
5424
5425 // Set the name situation to the dialog
SmEditCrlDlgSetName(HWND hWnd,NAME * name)5426 void SmEditCrlDlgSetName(HWND hWnd, NAME *name)
5427 {
5428 // Validate arguments
5429 if (hWnd == NULL || name == NULL)
5430 {
5431 return;
5432 }
5433
5434 // CN
5435 if (UniIsEmptyStr(name->CommonName))
5436 {
5437 Check(hWnd, R_CN, false);
5438 }
5439 else
5440 {
5441 Check(hWnd, R_CN, true);
5442 SetText(hWnd, E_CN, name->CommonName);
5443 }
5444
5445 // O
5446 if (UniIsEmptyStr(name->Organization))
5447 {
5448 Check(hWnd, R_O, false);
5449 }
5450 else
5451 {
5452 Check(hWnd, R_O, true);
5453 SetText(hWnd, E_O, name->Organization);
5454 }
5455
5456 // OU
5457 if (UniIsEmptyStr(name->Unit))
5458 {
5459 Check(hWnd, R_OU, false);
5460 }
5461 else
5462 {
5463 Check(hWnd, R_OU, true);
5464 SetText(hWnd, E_OU, name->Unit);
5465 }
5466
5467 // C
5468 if (UniIsEmptyStr(name->Country))
5469 {
5470 Check(hWnd, R_C, false);
5471 }
5472 else
5473 {
5474 Check(hWnd, R_C, true);
5475 SetText(hWnd, E_C, name->Country);
5476 }
5477
5478 // ST
5479 if (UniIsEmptyStr(name->State))
5480 {
5481 Check(hWnd, R_ST, false);
5482 }
5483 else
5484 {
5485 Check(hWnd, R_ST, true);
5486 SetText(hWnd, E_ST, name->State);
5487 }
5488
5489 // L
5490 if (UniIsEmptyStr(name->Local))
5491 {
5492 Check(hWnd, R_L, false);
5493 }
5494 else
5495 {
5496 Check(hWnd, R_L, true);
5497 SetText(hWnd, E_L, name->Local);
5498 }
5499 }
5500
5501 // CRL edit dialog procedure
SmEditCrlDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)5502 UINT SmEditCrlDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
5503 {
5504 SM_EDIT_CRL *c = (SM_EDIT_CRL *)param;
5505 // Validate arguments
5506 if (hWnd == NULL)
5507 {
5508 return 0;
5509 }
5510
5511 switch (msg)
5512 {
5513 case WM_INITDIALOG:
5514 SmEditCrlDlgInit(hWnd, c);
5515 break;
5516
5517 case WM_COMMAND:
5518 switch (LOWORD(wParam))
5519 {
5520 case R_CN:
5521 case E_CN:
5522 case R_O:
5523 case E_O:
5524 case R_OU:
5525 case E_OU:
5526 case R_C:
5527 case E_C:
5528 case R_ST:
5529 case E_ST:
5530 case R_L:
5531 case E_L:
5532 case R_SERI:
5533 case E_SERI:
5534 case R_MD5_HASH:
5535 case E_MD5_HASH:
5536 case R_SHA1_HASH:
5537 case E_SHA1_HASH:
5538 SmEditCrlDlgUpdate(hWnd, c);
5539 break;
5540 }
5541
5542 switch (wParam)
5543 {
5544 case B_LOAD:
5545 SmEditCrlDlgOnLoad(hWnd, c);
5546 break;
5547
5548 case IDOK:
5549 SmEditCrlDlgOnOk(hWnd, c);
5550 break;
5551
5552 case IDCANCEL:
5553 Close(hWnd);
5554 break;
5555
5556 case R_CN:
5557 FocusEx(hWnd, E_CN);
5558 break;
5559
5560 case R_O:
5561 FocusEx(hWnd, E_O);
5562 break;
5563
5564 case R_OU:
5565 FocusEx(hWnd, E_OU);
5566 break;
5567
5568 case R_C:
5569 FocusEx(hWnd, E_C);
5570 break;
5571
5572 case R_ST:
5573 FocusEx(hWnd, E_ST);
5574 break;
5575
5576 case R_L:
5577 FocusEx(hWnd, E_L);
5578 break;
5579
5580 case R_SERI:
5581 FocusEx(hWnd, E_SERI);
5582 break;
5583
5584 case R_MD5_HASH:
5585 FocusEx(hWnd, E_MD5_HASH);
5586 break;
5587
5588 case R_SHA1_HASH:
5589 FocusEx(hWnd, E_SHA1_HASH);
5590 break;
5591 }
5592 break;
5593
5594 case WM_CLOSE:
5595 EndDialog(hWnd, false);
5596 break;
5597 }
5598
5599 return 0;
5600 }
5601
5602 // Initialize the dialog
SmCrlDlgInit(HWND hWnd,SM_HUB * s)5603 void SmCrlDlgInit(HWND hWnd, SM_HUB *s)
5604 {
5605 // Validate arguments
5606 if (hWnd == NULL || s == NULL)
5607 {
5608 return;
5609 }
5610
5611 SetIcon(hWnd, 0, ICO_CERT_X);
5612
5613 LvInit(hWnd, L_LIST);
5614 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_CRL_COLUMN_1"), 555);
5615
5616 SmCrlDlgRefresh(hWnd, s);
5617 }
5618
5619 // Update the control
SmCrlDlgUpdate(HWND hWnd,SM_HUB * s)5620 void SmCrlDlgUpdate(HWND hWnd, SM_HUB *s)
5621 {
5622 // Validate arguments
5623 if (hWnd == NULL || s == NULL)
5624 {
5625 return;
5626 }
5627
5628 SetEnable(hWnd, IDOK, LvIsSingleSelected(hWnd, L_LIST));
5629 SetEnable(hWnd, B_DELETE, LvIsSingleSelected(hWnd, L_LIST));
5630 }
5631
5632 // Content update
SmCrlDlgRefresh(HWND hWnd,SM_HUB * s)5633 void SmCrlDlgRefresh(HWND hWnd, SM_HUB *s)
5634 {
5635 UINT i;
5636 RPC_ENUM_CRL t;
5637 LVB *v;
5638 // Validate arguments
5639 if (hWnd == NULL || s == NULL)
5640 {
5641 return;
5642 }
5643
5644 Zero(&t, sizeof(t));
5645 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
5646
5647 if (CALL(hWnd, ScEnumCrl(s->Rpc, &t)) == false)
5648 {
5649 EndDialog(hWnd, false);
5650 return;
5651 }
5652
5653 v = LvInsertStart();
5654
5655 for (i = 0;i < t.NumItem;i++)
5656 {
5657 RPC_ENUM_CRL_ITEM *e = &t.Items[i];
5658 LvInsertAdd(v, ICO_CERT_X, (void *)e->Key, 1, e->CrlInfo);
5659 }
5660
5661 LvInsertEndEx(v, hWnd, L_LIST, true);
5662
5663 if (t.NumItem >= 1)
5664 {
5665 LvAutoSize(hWnd, L_LIST);
5666 }
5667
5668 FreeRpcEnumCrl(&t);
5669
5670 SmCrlDlgUpdate(hWnd, s);
5671 }
5672
5673 // Certificate revocation list dialog procedure
SmCrlDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)5674 UINT SmCrlDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
5675 {
5676 SM_EDIT_CRL c;
5677 SM_HUB *s = (SM_HUB *)param;
5678 NMHDR *n;
5679 // Validate arguments
5680 if (hWnd == NULL)
5681 {
5682 return 0;
5683 }
5684
5685 switch (msg)
5686 {
5687 case WM_INITDIALOG:
5688 SmCrlDlgInit(hWnd, s);
5689 break;
5690
5691 case WM_COMMAND:
5692 switch (wParam)
5693 {
5694 case B_ADD:
5695 Zero(&c, sizeof(c));
5696 c.NewCrl = true;
5697 c.s = s;
5698
5699 if (Dialog(hWnd, D_SM_EDIT_CRL, SmEditCrlDlgProc, &c))
5700 {
5701 SmCrlDlgRefresh(hWnd, s);
5702 }
5703 break;
5704
5705 case B_DELETE:
5706 if (IsEnable(hWnd, B_DELETE))
5707 {
5708 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("SM_CRL_DELETE_MSG")) == IDYES)
5709 {
5710 RPC_CRL t;
5711
5712 Zero(&t, sizeof(t));
5713 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
5714 t.Key = (UINT)LvGetParam(hWnd, L_LIST, LvGetSelected(hWnd, L_LIST));
5715
5716 if (CALL(hWnd, ScDelCrl(s->Rpc, &t)))
5717 {
5718 SmCrlDlgRefresh(hWnd, s);
5719 }
5720
5721 FreeRpcCrl(&t);
5722 }
5723 }
5724 break;
5725
5726 case IDOK:
5727 if (IsEnable(hWnd, IDOK))
5728 {
5729 SM_EDIT_CRL c;
5730
5731 Zero(&c, sizeof(c));
5732 c.NewCrl = false;
5733 c.s = s;
5734 c.Key = (UINT)LvGetParam(hWnd, L_LIST, LvGetSelected(hWnd, L_LIST));
5735
5736 if (Dialog(hWnd, D_SM_EDIT_CRL, SmEditCrlDlgProc, &c))
5737 {
5738 SmCrlDlgRefresh(hWnd, s);
5739 }
5740 }
5741 break;
5742
5743 case IDCANCEL:
5744 Close(hWnd);
5745 break;
5746 }
5747 break;
5748
5749 case WM_CLOSE:
5750 EndDialog(hWnd, 0);
5751 break;
5752
5753 case WM_NOTIFY:
5754 n = (NMHDR *)lParam;
5755 switch (n->code)
5756 {
5757 case LVN_ITEMCHANGED:
5758 switch (n->idFrom)
5759 {
5760 case L_LIST:
5761 SmCrlDlgUpdate(hWnd, s);
5762 break;
5763 }
5764 break;
5765 }
5766 break;
5767 }
5768
5769 LvStandardHandler(hWnd, msg, wParam, lParam, L_LIST);
5770
5771 return 0;
5772 }
5773
5774 // Smart Card Manager
SmSecureManager(HWND hWnd)5775 void SmSecureManager(HWND hWnd)
5776 {
5777 UINT id = SmGetCurrentSecureIdFromReg();
5778
5779 if (id == 0)
5780 {
5781 id = SmSelectSecureId(hWnd);
5782 }
5783
5784 if (id == 0)
5785 {
5786 return;
5787 }
5788
5789 CmSecureManager(hWnd, id);
5790 }
5791
5792 // Initialize the dialog
SmSelectKeyPairDlgInit(HWND hWnd,SM_SECURE_KEYPAIR * k)5793 void SmSelectKeyPairDlgInit(HWND hWnd, SM_SECURE_KEYPAIR *k)
5794 {
5795 SECURE_DEVICE *dev;
5796 // Validate arguments
5797 if (hWnd == NULL || k == NULL)
5798 {
5799 return;
5800 }
5801
5802 dev = GetSecureDevice(k->Id);
5803 if (dev != NULL)
5804 {
5805 FormatText(hWnd, S_INFO, dev->DeviceName);
5806 }
5807
5808 LvInit(hWnd, L_CERT);
5809 LvInsertColumn(hWnd, L_CERT, 0, _UU("SEC_MGR_COLUMN1"), 200);
5810 LvInsertColumn(hWnd, L_CERT, 1, _UU("SEC_MGR_COLUMN2"), 110);
5811
5812 LvInit(hWnd, L_KEY);
5813 LvInsertColumn(hWnd, L_KEY, 0, _UU("SEC_MGR_COLUMN1"), 200);
5814 LvInsertColumn(hWnd, L_KEY, 1, _UU("SEC_MGR_COLUMN2"), 110);
5815
5816 SetEnable(hWnd, L_CERT, k->UseCert);
5817 SetEnable(hWnd, B_BOLD1, k->UseCert);
5818 SetEnable(hWnd, L_KEY, k->UseKey);
5819 SetEnable(hWnd, B_BOLD2, k->UseKey);
5820
5821 SetFont(hWnd, B_BOLD1, Font(0, true));
5822 SetFont(hWnd, B_BOLD2, Font(0, true));
5823
5824 SmSelectKeyPairDlgUpdate(hWnd, k);
5825 }
5826
5827 // Update the dialog control
SmSelectKeyPairDlgUpdate(HWND hWnd,SM_SECURE_KEYPAIR * k)5828 void SmSelectKeyPairDlgUpdate(HWND hWnd, SM_SECURE_KEYPAIR *k)
5829 {
5830 bool ok = true;
5831 // Validate arguments
5832 if (hWnd == NULL || k == NULL)
5833 {
5834 return;
5835 }
5836
5837 if (k->UseCert)
5838 {
5839 if (LvIsSingleSelected(hWnd, L_CERT) == false)
5840 {
5841 ok = false;
5842 }
5843 else
5844 {
5845 char *name = LvGetSelectedStrA(hWnd, L_CERT, 0);
5846 if (name != NULL)
5847 {
5848 if (LvIsSingleSelected(hWnd, L_KEY) == false)
5849 {
5850 if ((k->Flag++) == 0)
5851 {
5852 LvSelect(hWnd, L_KEY, LvSearchStrA(hWnd, L_KEY, 0, name));
5853 }
5854 }
5855 Free(name);
5856 }
5857 }
5858 }
5859
5860 if (k->UseKey)
5861 {
5862 if (LvIsSingleSelected(hWnd, L_KEY) == false)
5863 {
5864 ok = false;
5865 }
5866 else
5867 {
5868 char *name = LvGetSelectedStrA(hWnd, L_KEY, 0);
5869 if (name != NULL)
5870 {
5871 if (LvIsSingleSelected(hWnd, L_CERT) == false)
5872 {
5873 if ((k->Flag++) == 0)
5874 {
5875 LvSelect(hWnd, L_CERT, LvSearchStrA(hWnd, L_CERT, 0, name));
5876 }
5877 }
5878 Free(name);
5879 }
5880 }
5881 }
5882
5883 SetEnable(hWnd, IDOK, ok);
5884 }
5885
5886 // Update the contents
SmSelectKeyPairDlgRefresh(HWND hWnd,SM_SECURE_KEYPAIR * k)5887 void SmSelectKeyPairDlgRefresh(HWND hWnd, SM_SECURE_KEYPAIR *k)
5888 {
5889 bool ret;
5890 LIST *o;
5891 WINUI_SECURE_BATCH batch[] =
5892 {
5893 {WINUI_SECURE_ENUM_OBJECTS, NULL, false, NULL, NULL, NULL, NULL, NULL, NULL},
5894 };
5895 // Validate arguments
5896 if (hWnd == NULL || k == NULL)
5897 {
5898 return;
5899 }
5900
5901 ret = SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), k->Id, k->BitmapId);
5902
5903 if (ret == false)
5904 {
5905 Close(hWnd);
5906 return;
5907 }
5908
5909 o = batch[0].EnumList;
5910 if (o != NULL)
5911 {
5912 if (k->UseCert)
5913 {
5914 CmSecureManagerDlgPrintListEx(hWnd, L_CERT, o, SEC_X);
5915 }
5916
5917 if (k->UseKey)
5918 {
5919 CmSecureManagerDlgPrintListEx(hWnd, L_KEY, o, SEC_K);
5920 }
5921
5922 FreeEnumSecObject(o);
5923 }
5924
5925 // Update the control
5926 SmSelectKeyPairDlgUpdate(hWnd, k);
5927 }
5928
5929 // Key pair import dialog procedure
SmSelectKeyPairDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)5930 UINT SmSelectKeyPairDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
5931 {
5932 NMHDR *n;
5933 SM_SECURE_KEYPAIR *k = (SM_SECURE_KEYPAIR *)param;
5934 char *s1, *s2;
5935 // Validate arguments
5936 if (hWnd == NULL)
5937 {
5938 return 0;
5939 }
5940
5941 switch (msg)
5942 {
5943 case WM_INITDIALOG:
5944 SmSelectKeyPairDlgInit(hWnd, k);
5945
5946 SetTimer(hWnd, 1, 1, NULL);
5947 SetTimer(hWnd, 2, 100, NULL);
5948 break;
5949
5950 case WM_TIMER:
5951 switch (wParam)
5952 {
5953 case 1:
5954 KillTimer(hWnd, 1);
5955 SmSelectKeyPairDlgRefresh(hWnd, k);
5956 break;
5957
5958 case 2:
5959 SmSelectKeyPairDlgUpdate(hWnd, k);
5960 break;
5961 }
5962 break;
5963
5964 case WM_COMMAND:
5965 switch (wParam)
5966 {
5967 case IDOK:
5968 s1 = LvGetSelectedStrA(hWnd, L_CERT, 0);
5969 s2 = LvGetSelectedStrA(hWnd, L_KEY, 0);
5970 if (k->UseCert)
5971 {
5972 StrCpy(k->CertName, sizeof(k->CertName), s1);
5973 }
5974 if (k->UseKey)
5975 {
5976 StrCpy(k->KeyName, sizeof(k->KeyName), s2);
5977 }
5978 Free(s1);
5979 Free(s2);
5980 EndDialog(hWnd, true);
5981 break;
5982
5983 case IDCANCEL:
5984 Close(hWnd);
5985 break;
5986 }
5987 break;
5988
5989 case WM_CLOSE:
5990 EndDialog(hWnd, 0);
5991 break;
5992
5993 case WM_NOTIFY:
5994 n = (NMHDR *)lParam;
5995 switch (n->idFrom)
5996 {
5997 case L_CERT:
5998 case L_KEY:
5999 switch (n->code)
6000 {
6001 case LVN_ITEMCHANGED:
6002 SmSelectKeyPairDlgUpdate(hWnd, k);
6003 break;
6004 }
6005 break;
6006 }
6007 break;
6008 }
6009
6010 return 0;
6011 }
6012
6013 // Read a key pair from the smart card
SmSelectKeyPair(HWND hWnd,char * cert_name,UINT cert_name_size,char * key_name,UINT key_name_size)6014 bool SmSelectKeyPair(HWND hWnd, char *cert_name, UINT cert_name_size, char *key_name, UINT key_name_size)
6015 {
6016 return SmSelectKeyPairEx(hWnd, cert_name, cert_name_size, key_name, key_name_size, 0);
6017 }
SmSelectKeyPairEx(HWND hWnd,char * cert_name,UINT cert_name_size,char * key_name,UINT key_name_size,UINT bitmap_id)6018 bool SmSelectKeyPairEx(HWND hWnd, char *cert_name, UINT cert_name_size, char *key_name, UINT key_name_size, UINT bitmap_id)
6019 {
6020 SM_SECURE_KEYPAIR p;
6021 // Validate arguments
6022 if (hWnd == NULL || (cert_name == NULL && key_name == NULL))
6023 {
6024 return false;
6025 }
6026
6027 Zero(&p, sizeof(p));
6028 p.Id = SmGetCurrentSecureId(hWnd);
6029 if (p.Id == 0)
6030 {
6031 return false;
6032 }
6033
6034 p.UseCert = (cert_name == NULL) ? false : true;
6035 p.UseKey = (key_name == NULL) ? false : true;
6036 p.BitmapId = bitmap_id;
6037
6038 if (Dialog(hWnd, D_SM_SELECT_KEYPAIR, SmSelectKeyPairDlg, &p) == false)
6039 {
6040 return false;
6041 }
6042
6043 if (p.UseCert)
6044 {
6045 StrCpy(cert_name, cert_name_size, p.CertName);
6046 }
6047 if (p.UseKey)
6048 {
6049 StrCpy(key_name, key_name_size, p.KeyName);
6050 }
6051
6052 return true;
6053 }
6054
6055 // Make the user select the smart card number
SmSelectSecureId(HWND hWnd)6056 UINT SmSelectSecureId(HWND hWnd)
6057 {
6058 UINT id = MsRegReadInt(REG_CURRENT_USER, SECURE_MANAGER_KEY, "DeviceId");
6059 UINT ret;
6060
6061 if (id != 0 && CheckSecureDeviceId(id) == false)
6062 {
6063 id = 0;
6064 }
6065
6066 ret = CmSelectSecure(hWnd, id);
6067 if (ret == 0)
6068 {
6069 return 0;
6070 }
6071
6072 SmWriteSelectSecureIdReg(ret);
6073
6074 return ret;
6075 }
6076
6077 // Write the current smart card number to the registry
SmWriteSelectSecureIdReg(UINT id)6078 void SmWriteSelectSecureIdReg(UINT id)
6079 {
6080 MsRegWriteInt(REG_CURRENT_USER, SECURE_MANAGER_KEY, "DeviceId", id);
6081 }
6082
6083 // Get the current smart card number
SmGetCurrentSecureId(HWND hWnd)6084 UINT SmGetCurrentSecureId(HWND hWnd)
6085 {
6086 // Load the current settings
6087 UINT id = MsRegReadInt(REG_CURRENT_USER, SECURE_MANAGER_KEY, "DeviceId");
6088
6089 // Check whether it's valid
6090 if (id == 0 || CheckSecureDeviceId(id) == false)
6091 {
6092 // Select a smart card device number if it's invalid
6093 id = SmSelectSecureId(hWnd);
6094 }
6095
6096 return id;
6097 }
6098
6099 // Get the current smart card number from the registry
SmGetCurrentSecureIdFromReg()6100 UINT SmGetCurrentSecureIdFromReg()
6101 {
6102 // Load the current settings
6103 UINT id = MsRegReadInt(REG_CURRENT_USER, SECURE_MANAGER_KEY, "DeviceId");
6104
6105 // Check whether normal
6106 if (id == 0 || CheckSecureDeviceId(id) == false)
6107 {
6108 id = 0;
6109 }
6110
6111 return id;
6112 }
6113
6114 // Get whether the specified L3 switch started
SmL3IsSwActive(SM_SERVER * s,char * name)6115 bool SmL3IsSwActive(SM_SERVER *s, char *name)
6116 {
6117 bool ret = false;
6118 UINT i;
6119 RPC_ENUM_L3SW t;
6120 // Validate arguments
6121 if (s == NULL || name == NULL)
6122 {
6123 return false;
6124 }
6125
6126 Zero(&t, sizeof(t));
6127 if (ScEnumL3Switch(s->Rpc, &t) == ERR_NO_ERROR)
6128 {
6129 for (i = 0;i < t.NumItem;i++)
6130 {
6131 RPC_ENUM_L3SW_ITEM *e = &t.Items[i];
6132 if (StrCmpi(e->Name, name) == 0)
6133 {
6134 if (e->Active)
6135 {
6136 ret = true;
6137 break;
6138 }
6139 }
6140 }
6141 FreeRpcEnumL3Sw(&t);
6142 }
6143
6144 return ret;
6145 }
6146
6147 // Initialize the dialog
SmL3SwTableDlgInit(HWND hWnd,SM_L3SW * w)6148 void SmL3SwTableDlgInit(HWND hWnd, SM_L3SW *w)
6149 {
6150 // Validate arguments
6151 if (hWnd == NULL || w == NULL)
6152 {
6153 return;
6154 }
6155
6156 SmL3SwTableDlgUpdate(hWnd, w);
6157 }
6158
6159 // Update the control
SmL3SwTableDlgUpdate(HWND hWnd,SM_L3SW * w)6160 void SmL3SwTableDlgUpdate(HWND hWnd, SM_L3SW *w)
6161 {
6162 bool b = true;
6163 UINT ip;
6164 // Validate arguments
6165 if (hWnd == NULL || w == NULL)
6166 {
6167 return;
6168 }
6169
6170 if (IpIsFilled(hWnd, E_NETWORK) == false ||
6171 IpIsFilled(hWnd, E_MASK) == false ||
6172 IpIsFilled(hWnd, E_GATEWAY) == false)
6173 {
6174 b = false;
6175 }
6176
6177 ip = IpGet(hWnd, E_GATEWAY);
6178 if (ip == 0 || ip == 0xffffffff)
6179 {
6180 b = false;
6181 }
6182
6183 if (GetInt(hWnd, E_METRIC) == 0)
6184 {
6185 b = false;
6186 }
6187
6188 if (IsNetworkAddress32(IpGet(hWnd, E_NETWORK), IpGet(hWnd, E_MASK)) == false)
6189 {
6190 b = false;
6191 }
6192
6193 SetEnable(hWnd, IDOK, b);
6194 }
6195
SmL3SwTableDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)6196 UINT SmL3SwTableDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
6197 {
6198 SM_L3SW *w = (SM_L3SW *)param;
6199 RPC_L3TABLE t;
6200
6201 if (hWnd == NULL)
6202 {
6203 return 0;
6204 }
6205
6206 switch (msg)
6207 {
6208 case WM_INITDIALOG:
6209 SmL3SwTableDlgInit(hWnd, w);
6210 break;
6211
6212 case WM_COMMAND:
6213 switch (LOWORD(wParam))
6214 {
6215 case E_NETWORK:
6216 case E_MASK:
6217 case E_GATEWAY:
6218 case E_METRIC:
6219 SmL3SwTableDlgUpdate(hWnd, w);
6220 break;
6221 }
6222
6223 switch (wParam)
6224 {
6225 case IDOK:
6226 Zero(&t, sizeof(t));
6227 StrCpy(t.Name, sizeof(t.Name), w->SwitchName);
6228 t.NetworkAddress = IpGet(hWnd, E_NETWORK);
6229 t.SubnetMask = IpGet(hWnd, E_MASK);
6230 t.GatewayAddress = IpGet(hWnd, E_GATEWAY);
6231 t.Metric = GetInt(hWnd, E_METRIC);
6232
6233 if (CALL(hWnd, ScAddL3Table(w->s->Rpc, &t)))
6234 {
6235 EndDialog(hWnd, 1);
6236 }
6237 break;
6238
6239 case IDCANCEL:
6240 Close(hWnd);
6241 break;
6242 }
6243 break;
6244
6245 case WM_CLOSE:
6246 EndDialog(hWnd, 0);
6247 break;
6248 }
6249
6250 return 0;
6251 }
6252
6253 // Initialize the dialog
SmL3SwIfDlgInit(HWND hWnd,SM_L3SW * w)6254 void SmL3SwIfDlgInit(HWND hWnd, SM_L3SW *w)
6255 {
6256 RPC_ENUM_HUB t;
6257 UINT i;
6258 // Validate arguments
6259 if (hWnd == NULL || w == NULL)
6260 {
6261 return;
6262 }
6263
6264 Zero(&t, sizeof(t));
6265
6266 if (CALL(hWnd, ScEnumHub(w->s->Rpc, &t)) == false)
6267 {
6268 Close(hWnd);
6269 return;
6270 }
6271
6272 CbReset(hWnd, E_HUBNAME);
6273 CbSetHeight(hWnd, E_HUBNAME, 18);
6274
6275 for (i = 0;i < t.NumHub;i++)
6276 {
6277 RPC_ENUM_HUB_ITEM *e = &t.Hubs[i];
6278
6279 if (e->HubType != HUB_TYPE_FARM_DYNAMIC)
6280 {
6281 CbAddStrA(hWnd, E_HUBNAME, e->HubName, 0);
6282 }
6283 }
6284
6285 FreeRpcEnumHub(&t);
6286
6287 SetTextA(hWnd, E_HUBNAME, "");
6288
6289 SmL3SwIfDlgUpdate(hWnd, w);
6290 }
6291
6292 // Update the control
SmL3SwIfDlgUpdate(HWND hWnd,SM_L3SW * w)6293 void SmL3SwIfDlgUpdate(HWND hWnd, SM_L3SW *w)
6294 {
6295 bool b = true;
6296 // Validate arguments
6297 if (hWnd == NULL || w == NULL)
6298 {
6299 return;
6300 }
6301
6302 if (IsEmpty(hWnd, E_HUBNAME))
6303 {
6304 b = false;
6305 }
6306
6307 if (IpIsFilled(hWnd, E_IP) == false || IpIsFilled(hWnd, E_MASK) == false)
6308 {
6309 b = false;
6310 }
6311
6312 if (IpGet(hWnd, E_IP) == 0 || IpGet(hWnd, E_IP) == 0xffffffff)
6313 {
6314 b = false;
6315 }
6316
6317 if (IsSubnetMask32(IpGet(hWnd, E_MASK)) == false)
6318 {
6319 b = false;
6320 }
6321
6322 SetEnable(hWnd, IDOK, b);
6323 }
6324
6325 // Dialog for adding a virtual interface
SmL3SwIfDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)6326 UINT SmL3SwIfDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
6327 {
6328 SM_L3SW *w = (SM_L3SW *)param;
6329 char *hubname;
6330 // Validate arguments
6331 if (hWnd == NULL)
6332 {
6333 return 0;
6334 }
6335
6336 switch (msg)
6337 {
6338 case WM_INITDIALOG:
6339 SmL3SwIfDlgInit(hWnd, w);
6340
6341 SetTimer(hWnd, 1, 250, NULL);
6342 break;
6343
6344 case WM_TIMER:
6345 switch (wParam)
6346 {
6347 case 1:
6348 if (IsEnable(hWnd, 0))
6349 {
6350 SmL3SwIfDlgUpdate(hWnd, w);
6351 }
6352 break;
6353 }
6354 break;
6355
6356 case WM_COMMAND:
6357 switch (LOWORD(wParam))
6358 {
6359 case E_HUBNAME:
6360 case E_IP:
6361 case E_MASK:
6362 SmL3SwIfDlgUpdate(hWnd, w);
6363 break;
6364 }
6365
6366 switch (wParam)
6367 {
6368 case IDOK:
6369 hubname = GetTextA(hWnd, E_HUBNAME);
6370 if (hubname != NULL)
6371 {
6372 RPC_L3IF t;
6373 Zero(&t, sizeof(t));
6374 StrCpy(t.HubName, sizeof(t.HubName), hubname);
6375 t.IpAddress = IpGet(hWnd, E_IP);
6376 t.SubnetMask = IpGet(hWnd, E_MASK);
6377 StrCpy(t.Name, sizeof(t.Name), w->SwitchName);
6378
6379 if (CALL(hWnd, ScAddL3If(w->s->Rpc, &t)))
6380 {
6381 EndDialog(hWnd, 1);
6382 }
6383
6384 Free(hubname);
6385 }
6386 break;
6387
6388 case IDCANCEL:
6389 Close(hWnd);
6390 break;
6391 }
6392 break;
6393
6394 case WM_CLOSE:
6395 EndDialog(hWnd, 0);
6396 break;
6397 }
6398
6399 return 0;
6400 }
6401
6402 // Initialize
SmL3SwDlgInit(HWND hWnd,SM_L3SW * w)6403 void SmL3SwDlgInit(HWND hWnd, SM_L3SW *w)
6404 {
6405 // Validate arguments
6406 if (hWnd == NULL || w == NULL)
6407 {
6408 return;
6409 }
6410
6411 SetIcon(hWnd, 0, ICO_SWITCH_OFFLINE);
6412
6413 FormatText(hWnd, 0, w->SwitchName);
6414
6415 SetFont(hWnd, S_BOLD1, Font(0, true));
6416 SetFont(hWnd, S_BOLD2, Font(0, true));
6417
6418 LvInit(hWnd, L_IF);
6419 LvInsertColumn(hWnd, L_IF, 0, _UU("SM_L3_SW_IF_COLUMN1"), 150);
6420 LvInsertColumn(hWnd, L_IF, 1, _UU("SM_L3_SW_IF_COLUMN2"), 150);
6421 LvInsertColumn(hWnd, L_IF, 2, _UU("SM_L3_SW_IF_COLUMN3"), 180);
6422
6423 LvInit(hWnd, L_TABLE);
6424 LvInsertColumn(hWnd, L_TABLE, 0, _UU("SM_L3_SW_TABLE_COLUMN1"), 130);
6425 LvInsertColumn(hWnd, L_TABLE, 1, _UU("SM_L3_SW_TABLE_COLUMN2"), 130);
6426 LvInsertColumn(hWnd, L_TABLE, 2, _UU("SM_L3_SW_TABLE_COLUMN3"), 130);
6427 LvInsertColumn(hWnd, L_TABLE, 3, _UU("SM_L3_SW_TABLE_COLUMN4"), 100);
6428
6429 w->Enable = SmL3IsSwActive(w->s, w->SwitchName) ? false : true;
6430
6431 SmL3SwDlgRefresh(hWnd, w);
6432 }
6433
6434 // Update the control
SmL3SwDlgUpdate(HWND hWnd,SM_L3SW * w)6435 void SmL3SwDlgUpdate(HWND hWnd, SM_L3SW *w)
6436 {
6437 // Validate arguments
6438 if (hWnd == NULL || w == NULL)
6439 {
6440 return;
6441 }
6442
6443 SetEnable(hWnd, B_ADD_IF, w->s->ServerAdminMode && w->Enable);
6444 SetEnable(hWnd, B_ADD_TABLE, w->s->ServerAdminMode && w->Enable);
6445 SetEnable(hWnd, B_DEL_IF, LvIsSingleSelected(hWnd, L_IF) && w->s->ServerAdminMode && w->Enable);
6446 SetEnable(hWnd, B_DEL_TABLE, LvIsSingleSelected(hWnd, L_TABLE) && w->s->ServerAdminMode && w->Enable);
6447 SetEnable(hWnd, B_START, w->s->ServerAdminMode && w->Enable);
6448 SetEnable(hWnd, B_STOP, w->s->ServerAdminMode && (w->Enable == false));
6449 }
6450
6451 // Content update
SmL3SwDlgRefresh(HWND hWnd,SM_L3SW * w)6452 void SmL3SwDlgRefresh(HWND hWnd, SM_L3SW *w)
6453 {
6454 UINT i;
6455 wchar_t tmp1[MAX_SIZE];
6456 wchar_t tmp2[MAX_SIZE];
6457 wchar_t tmp3[MAX_SIZE];
6458 wchar_t tmp4[MAX_SIZE];
6459 // Validate arguments
6460 if (hWnd == NULL || w == NULL)
6461 {
6462 return;
6463 }
6464
6465 // Virtual interface list
6466 {
6467 RPC_ENUM_L3IF t;
6468 LVB *v;
6469
6470 Zero(&t, sizeof(t));
6471 StrCpy(t.Name, sizeof(t.Name), w->SwitchName);
6472
6473 if (CALL(hWnd, ScEnumL3If(w->s->Rpc, &t)) == false)
6474 {
6475 Close(hWnd);
6476 return;
6477 }
6478
6479 v = LvInsertStart();
6480
6481 for (i = 0;i < t.NumItem;i++)
6482 {
6483 RPC_L3IF *e = &t.Items[i];
6484
6485 IPToUniStr32(tmp1, sizeof(tmp1), e->IpAddress);
6486 IPToUniStr32(tmp2, sizeof(tmp2), e->SubnetMask);
6487 StrToUni(tmp3, sizeof(tmp3), e->HubName);
6488
6489 LvInsertAdd(v, ICO_NIC_ONLINE, NULL, 3, tmp1, tmp2, tmp3);
6490 }
6491
6492 LvReset(hWnd, L_IF);
6493
6494 LvInsertEnd(v, hWnd, L_IF);
6495
6496 FreeRpcEnumL3If(&t);
6497 }
6498
6499 // Routing Table Entry List
6500 {
6501 RPC_ENUM_L3TABLE t;
6502 LVB *v;
6503
6504 Zero(&t, sizeof(t));
6505 StrCpy(t.Name, sizeof(t.Name), w->SwitchName);
6506
6507 if (CALL(hWnd, ScEnumL3Table(w->s->Rpc, &t)) == false)
6508 {
6509 Close(hWnd);
6510 return;
6511 }
6512
6513 v = LvInsertStart();
6514
6515 for (i = 0;i < t.NumItem;i++)
6516 {
6517 RPC_L3TABLE *e = &t.Items[i];
6518
6519 IPToUniStr32(tmp1, sizeof(tmp1), e->NetworkAddress);
6520 IPToUniStr32(tmp2, sizeof(tmp2), e->SubnetMask);
6521 IPToUniStr32(tmp3, sizeof(tmp3), e->GatewayAddress);
6522 UniToStru(tmp4, e->Metric);
6523
6524 LvInsertAdd(v, ICO_PROTOCOL, NULL, 4, tmp1, tmp2, tmp3, tmp4);
6525 }
6526
6527 LvReset(hWnd, L_TABLE);
6528
6529 LvInsertEnd(v, hWnd, L_TABLE);
6530
6531 FreeRpcEnumL3Table(&t);
6532 }
6533
6534 SmL3SwDlgUpdate(hWnd, w);
6535 }
6536
6537 // Edit dialog of L3 switch
SmL3SwDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)6538 UINT SmL3SwDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
6539 {
6540 SM_L3SW *w = (SM_L3SW *)param;
6541 NMHDR *n;
6542 // Validate arguments
6543 if (hWnd == NULL)
6544 {
6545 return 0;
6546 }
6547
6548 switch (msg)
6549 {
6550 case WM_INITDIALOG:
6551 SmL3SwDlgInit(hWnd, w);
6552
6553 SetTimer(hWnd, 1, 1000, NULL);
6554 break;
6555
6556 case WM_TIMER:
6557 switch (wParam)
6558 {
6559 case 1:
6560 if (IsEnable(hWnd, 0))
6561 {
6562 KillTimer(hWnd, 1);
6563 w->Enable = SmL3IsSwActive(w->s, w->SwitchName) ? false : true;
6564 SmL3SwDlgUpdate(hWnd, w);
6565 SetTimer(hWnd, 1, 1000, NULL);
6566 }
6567 break;
6568 }
6569 break;
6570
6571 case WM_COMMAND:
6572 switch (wParam)
6573 {
6574 case B_START:
6575 if (IsEnable(hWnd, B_START))
6576 {
6577 RPC_L3SW t;
6578
6579 Zero(&t, sizeof(t));
6580 StrCpy(t.Name, sizeof(t.Name), w->SwitchName);
6581
6582 if (CALL(hWnd, ScStartL3Switch(w->s->Rpc, &t)))
6583 {
6584 SmL3SwDlgUpdate(hWnd, w);
6585 }
6586 }
6587 break;
6588
6589 case B_STOP:
6590 if (IsEnable(hWnd, B_STOP))
6591 {
6592 RPC_L3SW t;
6593
6594 Zero(&t, sizeof(t));
6595 StrCpy(t.Name, sizeof(t.Name), w->SwitchName);
6596
6597 if (CALL(hWnd, ScStopL3Switch(w->s->Rpc, &t)))
6598 {
6599 SmL3SwDlgUpdate(hWnd, w);
6600 }
6601 }
6602 break;
6603
6604 case B_ADD_IF:
6605 if (Dialog(hWnd, D_SM_L3_SW_IF, SmL3SwIfDlg, w))
6606 {
6607 SmL3SwDlgRefresh(hWnd, w);
6608 }
6609 break;
6610
6611 case B_DEL_IF:
6612 if (LvIsSingleSelected(hWnd, L_IF))
6613 {
6614 RPC_L3IF t;
6615 char *tmp1, *tmp2, *tmp3;
6616
6617 tmp1 = LvGetSelectedStrA(hWnd, L_IF, 0);
6618 tmp2 = LvGetSelectedStrA(hWnd, L_IF, 1);
6619 tmp3 = LvGetSelectedStrA(hWnd, L_IF, 2);
6620
6621 Zero(&t, sizeof(t));
6622 StrCpy(t.Name, sizeof(t.Name), w->SwitchName);
6623 t.IpAddress = StrToIP32(tmp1);
6624 t.SubnetMask = StrToIP32(tmp2);
6625 StrCpy(t.HubName, sizeof(t.HubName), tmp3);
6626
6627 if (CALL(hWnd, ScDelL3If(w->s->Rpc, &t)))
6628 {
6629 SmL3SwDlgRefresh(hWnd, w);
6630 }
6631
6632 Free(tmp1);
6633 Free(tmp2);
6634 Free(tmp3);
6635 }
6636 break;
6637
6638 case B_ADD_TABLE:
6639 if (Dialog(hWnd, D_SM_L3_SW_TABLE, SmL3SwTableDlg, w))
6640 {
6641 SmL3SwDlgRefresh(hWnd, w);
6642 }
6643 break;
6644
6645 case B_DEL_TABLE:
6646 if (LvIsSingleSelected(hWnd, L_TABLE))
6647 {
6648 RPC_L3TABLE t;
6649 char *tmp1, *tmp2, *tmp3, *tmp4;
6650
6651 tmp1 = LvGetSelectedStrA(hWnd, L_TABLE, 0);
6652 tmp2 = LvGetSelectedStrA(hWnd, L_TABLE, 1);
6653 tmp3 = LvGetSelectedStrA(hWnd, L_TABLE, 2);
6654 tmp4 = LvGetSelectedStrA(hWnd, L_TABLE, 3);
6655
6656 Zero(&t, sizeof(t));
6657 StrCpy(t.Name, sizeof(t.Name), w->SwitchName);
6658 t.NetworkAddress = StrToIP32(tmp1);
6659 t.SubnetMask = StrToIP32(tmp2);
6660 t.GatewayAddress = StrToIP32(tmp3);
6661 t.Metric = ToInt(tmp4);
6662
6663 if (CALL(hWnd, ScDelL3Table(w->s->Rpc, &t)))
6664 {
6665 SmL3SwDlgRefresh(hWnd, w);
6666 }
6667
6668 Free(tmp1);
6669 Free(tmp2);
6670 Free(tmp3);
6671 Free(tmp4);
6672 }
6673 break;
6674
6675 case IDCANCEL:
6676 Close(hWnd);
6677 break;
6678 }
6679 break;
6680
6681 case WM_CLOSE:
6682 EndDialog(hWnd, 0);
6683 break;
6684
6685 case WM_NOTIFY:
6686 n = (NMHDR *)lParam;
6687 switch (n->idFrom)
6688 {
6689 case L_IF:
6690 case L_TABLE:
6691 switch (n->code)
6692 {
6693 case LVN_ITEMCHANGED:
6694 SmL3SwDlgUpdate(hWnd, w);
6695 break;
6696 }
6697 break;
6698 }
6699 break;
6700 }
6701
6702 return 0;
6703 }
6704
6705 // Update the control
SmL3AddDlgUpdate(HWND hWnd,SM_SERVER * s)6706 void SmL3AddDlgUpdate(HWND hWnd, SM_SERVER *s)
6707 {
6708 char *tmp;
6709 // Validate arguments
6710 if (hWnd == NULL || s == NULL)
6711 {
6712 return;
6713 }
6714
6715 tmp = GetTextA(hWnd, E_NAME);
6716
6717 SetEnable(hWnd, IDOK, IsEmptyStr(tmp) == false && IsSafeStr(tmp));
6718
6719 Free(tmp);
6720 }
6721
6722 // The dialog box to create a new L3 switch
SmL3AddDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)6723 UINT SmL3AddDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
6724 {
6725 SM_SERVER *s = (SM_SERVER *)param;
6726 RPC_L3SW t;
6727 // Validate arguments
6728 if (hWnd == NULL)
6729 {
6730 return 0;
6731 }
6732
6733 switch (msg)
6734 {
6735 case WM_INITDIALOG:
6736 LimitText(hWnd, E_NAME, MAX_HUBNAME_LEN);
6737 SmL3AddDlgUpdate(hWnd, s);
6738 break;
6739
6740 case WM_COMMAND:
6741 switch (LOWORD(wParam))
6742 {
6743 case E_NAME:
6744 SmL3AddDlgUpdate(hWnd, s);
6745 break;
6746 }
6747
6748 switch (wParam)
6749 {
6750 case IDOK:
6751 Zero(&t, sizeof(t));
6752 GetTxtA(hWnd, E_NAME, t.Name, sizeof(t.Name));
6753 if (CALL(hWnd, ScAddL3Switch(s->Rpc, &t)))
6754 {
6755 EndDialog(hWnd, 1);
6756 }
6757 break;
6758
6759 case IDCANCEL:
6760 Close(hWnd);
6761 break;
6762 }
6763 break;
6764
6765 case WM_CLOSE:
6766 EndDialog(hWnd, 0);
6767 break;
6768 }
6769
6770 return 0;
6771 }
6772
6773 // Initialize the dialog
SmL3DlgInit(HWND hWnd,SM_SERVER * s)6774 void SmL3DlgInit(HWND hWnd, SM_SERVER *s)
6775 {
6776 // Validate arguments
6777 if (hWnd == NULL || s == NULL)
6778 {
6779 return;
6780 }
6781
6782 SetFont(hWnd, S_BOLD, Font(0, true));
6783
6784 SetIcon(hWnd, 0, ICO_SWITCH);
6785
6786 LvInit(hWnd, L_LIST);
6787 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_L3_SW_COLUMN1"), 150);
6788 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_L3_SW_COLUMN2"), 120);
6789 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_L3_SW_COLUMN3"), 100);
6790 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_L3_SW_COLUMN4"), 100);
6791
6792 SmL3DlgRefresh(hWnd, s);
6793 }
6794
6795 // Update the dialog control
SmL3DlgUpdate(HWND hWnd,SM_SERVER * s)6796 void SmL3DlgUpdate(HWND hWnd, SM_SERVER *s)
6797 {
6798 bool b = false;
6799 bool active = false;
6800 // Validate arguments
6801 if (hWnd == NULL || s == NULL)
6802 {
6803 return;
6804 }
6805
6806 if (LvIsSingleSelected(hWnd, L_LIST))
6807 {
6808 wchar_t *tmp;
6809 UINT i;
6810 b = true;
6811 i = LvGetSelected(hWnd, L_LIST);
6812 if (i != INFINITE)
6813 {
6814 tmp = LvGetStr(hWnd, L_LIST, i, 1);
6815 if (UniStrCmpi(tmp, _UU("SM_L3_SW_ST_F_F")) != 0)
6816 {
6817 active = true;
6818 }
6819 Free(tmp);
6820 }
6821 }
6822
6823 SetEnable(hWnd, B_START, b && (active == false));
6824 SetEnable(hWnd, B_STOP, b && (active != false));
6825 SetEnable(hWnd, IDOK, b);
6826 SetEnable(hWnd, B_DELETE, b);
6827 }
6828
6829 // Dialog content update
SmL3DlgRefresh(HWND hWnd,SM_SERVER * s)6830 void SmL3DlgRefresh(HWND hWnd, SM_SERVER *s)
6831 {
6832 RPC_ENUM_L3SW t;
6833 UINT i;
6834 LVB *v;
6835 // Validate arguments
6836 if (hWnd == NULL || s == NULL)
6837 {
6838 return;
6839 }
6840
6841 Zero(&t, sizeof(t));
6842 if (CALL(hWnd, ScEnumL3Switch(s->Rpc, &t)) == false)
6843 {
6844 Close(hWnd);
6845 return;
6846 }
6847
6848 v = LvInsertStart();
6849
6850 for (i = 0;i < t.NumItem;i++)
6851 {
6852 RPC_ENUM_L3SW_ITEM *e = &t.Items[i];
6853 wchar_t tmp1[MAX_SIZE], *tmp2, tmp3[64], tmp4[64];
6854
6855 StrToUni(tmp1, sizeof(tmp1), e->Name);
6856 if (e->Active == false)
6857 {
6858 tmp2 = _UU("SM_L3_SW_ST_F_F");
6859 }
6860 else if (e->Online == false)
6861 {
6862 tmp2 = _UU("SM_L3_SW_ST_T_F");
6863 }
6864 else
6865 {
6866 tmp2 = _UU("SM_L3_SW_ST_T_T");
6867 }
6868 UniToStru(tmp3, e->NumInterfaces);
6869 UniToStru(tmp4, e->NumTables);
6870
6871 LvInsertAdd(v, e->Active ? ICO_SWITCH : ICO_SWITCH_OFFLINE, NULL,
6872 4, tmp1, tmp2, tmp3, tmp4);
6873 }
6874
6875 LvInsertEnd(v, hWnd, L_LIST);
6876
6877 FreeRpcEnumL3Sw(&t);
6878
6879 SmL3DlgUpdate(hWnd, s);
6880 }
6881
6882 // L3 dialog procedure
SmL3Dlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)6883 UINT SmL3Dlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
6884 {
6885 NMHDR *n;
6886 SM_SERVER *s = (SM_SERVER *)param;
6887 RPC_L3SW t;
6888 char *name;
6889 // Validate arguments
6890 if (hWnd == NULL)
6891 {
6892 return 0;
6893 }
6894
6895 switch (msg)
6896 {
6897 case WM_INITDIALOG:
6898 SmL3DlgInit(hWnd, s);
6899
6900 SetTimer(hWnd, 1, 1000, NULL);
6901 break;
6902
6903 case WM_TIMER:
6904 switch (wParam)
6905 {
6906 case 1:
6907 if (IsEnable(hWnd, 0))
6908 {
6909 KillTimer(hWnd, 1);
6910 SmL3DlgRefresh(hWnd, s);
6911 SetTimer(hWnd, 1, 1000, NULL);
6912 }
6913 break;
6914 }
6915 break;
6916
6917 case WM_COMMAND:
6918 switch (wParam)
6919 {
6920 case B_ADD:
6921 // Add
6922 if (Dialog(hWnd, D_SM_L3_ADD, SmL3AddDlg, s))
6923 {
6924 SmL3DlgRefresh(hWnd, s);
6925 }
6926 break;
6927
6928 case B_START:
6929 // Operation start
6930 name = LvGetSelectedStrA(hWnd, L_LIST, 0);
6931 if (name != NULL)
6932 {
6933 Zero(&t, sizeof(t));
6934 StrCpy(t.Name, sizeof(t.Name), name);
6935
6936 if (CALL(hWnd, ScStartL3Switch(s->Rpc, &t)))
6937 {
6938 SmL3DlgRefresh(hWnd, s);
6939 }
6940
6941 Free(name);
6942 }
6943 break;
6944
6945 case B_STOP:
6946 // Operation stop
6947 name = LvGetSelectedStrA(hWnd, L_LIST, 0);
6948 if (name != NULL)
6949 {
6950 Zero(&t, sizeof(t));
6951 StrCpy(t.Name, sizeof(t.Name), name);
6952
6953 if (CALL(hWnd, ScStopL3Switch(s->Rpc, &t)))
6954 {
6955 SmL3DlgRefresh(hWnd, s);
6956 }
6957
6958 Free(name);
6959 }
6960 break;
6961
6962 case IDOK:
6963 // Edit
6964 if (IsEnable(hWnd, IDOK))
6965 {
6966 name = LvGetSelectedStrA(hWnd, L_LIST, 0);
6967 if (name != NULL)
6968 {
6969 SM_L3SW w;
6970 Zero(&w, sizeof(w));
6971 w.s = s;
6972 w.SwitchName = name;
6973
6974 Dialog(hWnd, D_SM_L3_SW, SmL3SwDlg, &w);
6975
6976 Free(name);
6977 }
6978 }
6979 break;
6980
6981 case B_DELETE:
6982 // Delete
6983 name = LvGetSelectedStrA(hWnd, L_LIST, 0);
6984 if (name != NULL)
6985 {
6986 if (MsgBoxEx(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2,
6987 _UU("SM_L3_SW_DEL_MSG"), name) == IDYES)
6988 {
6989 Zero(&t, sizeof(t));
6990 StrCpy(t.Name, sizeof(t.Name), name);
6991
6992 if (CALL(hWnd, ScDelL3Switch(s->Rpc, &t)))
6993 {
6994 SmL3DlgRefresh(hWnd, s);
6995 }
6996 }
6997
6998 Free(name);
6999 }
7000 break;
7001
7002 case IDCANCEL:
7003 // Close
7004 Close(hWnd);
7005 break;
7006 }
7007 break;
7008
7009 case WM_NOTIFY:
7010 n = (NMHDR *)lParam;
7011 switch (n->idFrom)
7012 {
7013 case L_LIST:
7014 switch (n->code)
7015 {
7016 case LVN_ITEMCHANGED:
7017 SmL3DlgUpdate(hWnd, s);
7018 break;
7019
7020 case NM_DBLCLK:
7021 Command(hWnd, IDOK);
7022 break;
7023 }
7024 break;
7025 }
7026 break;
7027
7028 case WM_CLOSE:
7029 EndDialog(hWnd, 0);
7030 break;
7031 }
7032
7033 return 0;
7034 }
7035
7036 // L3 dialog
SmL3(HWND hWnd,SM_SERVER * s)7037 void SmL3(HWND hWnd, SM_SERVER *s)
7038 {
7039 // Validate arguments
7040 if (s == NULL)
7041 {
7042 return;
7043 }
7044
7045 Dialog(hWnd, D_SM_L3, SmL3Dlg, s);
7046 }
7047
7048 // Dialog for management option value
SmHubAdminOptionValueDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)7049 UINT SmHubAdminOptionValueDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
7050 {
7051 SM_EDIT_AO *a = (SM_EDIT_AO *)param;
7052 UINT i;
7053 char tmp[MAX_SIZE];
7054 // Validate arguments
7055 if (hWnd == NULL)
7056 {
7057 return 0;
7058 }
7059
7060 switch (msg)
7061 {
7062 case WM_INITDIALOG:
7063 CbReset(hWnd, C_NAME);
7064 for (i = 0;i < a->DefaultOptions.NumItem;i++)
7065 {
7066 wchar_t tmp[MAX_PATH];
7067 StrToUni(tmp, sizeof(tmp), a->DefaultOptions.Items[i].Name);
7068 CbAddStr(hWnd, C_NAME, tmp, 0);
7069 }
7070 if (a->NewMode == false)
7071 {
7072 char tmp[MAX_SIZE];
7073
7074 SetTextA(hWnd, C_NAME, a->Name);
7075 ToStr(tmp, a->Value);
7076
7077 SetTextA(hWnd, E_VALUE, tmp);
7078 }
7079 else
7080 {
7081 SetTextA(hWnd, C_NAME, "");
7082 }
7083 SmHubAdminOptionValueDlgUpdate(hWnd, a);
7084 if (a->NewMode == false)
7085 {
7086 FocusEx(hWnd, E_VALUE);
7087 Disable(hWnd, C_NAME);
7088 }
7089 else
7090 {
7091 FocusEx(hWnd, C_NAME);
7092 }
7093
7094 SetTimer(hWnd, 1, 100, NULL);
7095 break;
7096
7097 case WM_TIMER:
7098 if (IsEnable(hWnd, 0))
7099 {
7100 SmHubAdminOptionValueDlgUpdate(hWnd, a);
7101 }
7102 break;
7103
7104 case WM_COMMAND:
7105 switch (wParam)
7106 {
7107 case IDOK:
7108 if (a->NewMode)
7109 {
7110 GetTxtA(hWnd, C_NAME, a->Name, sizeof(a->Name));
7111 }
7112
7113 GetTxtA(hWnd, E_VALUE, tmp, sizeof(tmp));
7114 a->Value = ToInt(tmp);
7115
7116 Trim(a->Name);
7117
7118 if (StartWith(a->Name, "no") || StartWith(a->Name, "allow") || StartWith(a->Name, "deny")
7119 || StartWith(a->Name, "filter") || StartWith(a->Name, "fix") || StartWith(a->Name, "force")
7120 || StartWith(a->Name, "use") || StartWith(a->Name, "b_") || StartWith(a->Name, "is")
7121 || StartWith(a->Name, "manage") || StartWith(a->Name, "yield")
7122 || StartWith(a->Name, "permit") || StartWith(a->Name, "yes") || StartWith(a->Name, "ok")
7123 || StartWith(a->Name, "do") || StartWith(a->Name, "only") || StartWith(a->Name, "disable"))
7124 {
7125 if (StrCmpi(tmp, "0") != 0 && StrCmpi(tmp, "1") != 0)
7126 {
7127 MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("SM_TRUE_OR_FALSE"));
7128 FocusEx(hWnd, E_VALUE);
7129 break;
7130 }
7131 }
7132
7133 EndDialog(hWnd, true);
7134 break;
7135
7136 case IDCANCEL:
7137 Close(hWnd);
7138 break;
7139 }
7140
7141 SmHubAdminOptionValueDlgUpdate(hWnd, a);
7142
7143 break;
7144
7145 case WM_CLOSE:
7146 EndDialog(hWnd, false);
7147 break;
7148 }
7149
7150 return 0;
7151 }
7152
7153 // Update the dialog controls for management option value
SmHubAdminOptionValueDlgUpdate(HWND hWnd,SM_EDIT_AO * a)7154 void SmHubAdminOptionValueDlgUpdate(HWND hWnd, SM_EDIT_AO *a)
7155 {
7156 char tmp[MAX_SIZE];
7157 // Validate arguments
7158 if (hWnd == NULL || a == NULL)
7159 {
7160 return;
7161 }
7162
7163 GetTxtA(hWnd, C_NAME, tmp, sizeof(tmp));
7164
7165 SetEnable(hWnd, IDOK, IsEmpty(hWnd, C_NAME) == false && IsEmpty(hWnd, E_VALUE) == false &&
7166 IsSafeStr(tmp));
7167 }
7168
7169 // Initialize
SmHubAdminOptionDlgInit(HWND hWnd,SM_EDIT_AO * a)7170 void SmHubAdminOptionDlgInit(HWND hWnd, SM_EDIT_AO *a)
7171 {
7172 UINT i;
7173 // Validate arguments
7174 if (hWnd == NULL || a == NULL)
7175 {
7176 return;
7177 }
7178
7179 SetIcon(hWnd, 0, ICO_USER_ADMIN);
7180
7181 if (a->e->p->ServerAdminMode)
7182 {
7183 a->CanChange = true;
7184 }
7185 else
7186 {
7187 if (a->ExtOption == false)
7188 {
7189 for (i = 0;i < a->CurrentOptions.NumItem;i++)
7190 {
7191 if (StrCmpi(a->CurrentOptions.Items[i].Name, "allow_hub_admin_change_option") == 0)
7192 {
7193 if (a->CurrentOptions.Items[i].Value != 0)
7194 {
7195 a->CanChange = true;
7196 }
7197 }
7198 }
7199 }
7200 else
7201 {
7202 a->CanChange = true;
7203 }
7204 }
7205
7206 FormatText(hWnd, S_INFO, a->e->HubName);
7207
7208 DlgFont(hWnd, S_BOLD, 0, true);
7209
7210 LvInit(hWnd, L_LIST);
7211 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_AO_COLUMN_1"), 260);
7212 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_AO_COLUMN_2"), 100);
7213
7214 for (i = 0;i < a->CurrentOptions.NumItem;i++)
7215 {
7216 ADMIN_OPTION *e = &a->CurrentOptions.Items[i];
7217 wchar_t tmp1[MAX_SIZE];
7218 wchar_t tmp2[MAX_SIZE];
7219
7220 StrToUni(tmp1, sizeof(tmp1), e->Name);
7221 UniToStru(tmp2, e->Value);
7222
7223 LvInsert(hWnd, L_LIST, ICO_LOG, NULL, 2, tmp1, tmp2);
7224
7225 }
7226
7227 if (a->ExtOption)
7228 {
7229 SetIcon(hWnd, S_ICON, ICO_LINK2);
7230 SetIcon(hWnd, 0, ICO_LINK2);
7231
7232 SetText(hWnd, 0, _UU("SM_HUBEXT_OPTION_TITLE"));
7233 SetText(hWnd, S_STATIC1, _UU("SM_HUBEXT_OPTION_STATIC1"));
7234 SetText(hWnd, S_STATIC2, _UU("SM_HUBEXT_OPTION_STATIC2"));
7235 }
7236
7237 // Update the control
7238 SmHubAdminOptionDlgUpdate(hWnd, a);
7239 }
7240
7241 // Update the control
SmHubAdminOptionDlgUpdate(HWND hWnd,SM_EDIT_AO * a)7242 void SmHubAdminOptionDlgUpdate(HWND hWnd, SM_EDIT_AO *a)
7243 {
7244 bool b = false;
7245 wchar_t *helpstr;
7246 // Validate arguments
7247 if (hWnd == NULL || a == NULL)
7248 {
7249 return;
7250 }
7251
7252 helpstr = _UU("HUB_AO_CLICK");
7253
7254 SetEnable(hWnd, IDOK, a->CanChange);
7255 SetEnable(hWnd, B_ADD, a->CanChange);
7256 SetEnable(hWnd, B_EDIT, a->CanChange && (LvIsMasked(hWnd, L_LIST) && LvIsMultiMasked(hWnd, L_LIST) == false));
7257
7258 if (LvIsMasked(hWnd, L_LIST) && LvIsMultiMasked(hWnd, L_LIST) == false)
7259 {
7260 UINT i;
7261 i = LvGetSelected(hWnd, L_LIST);
7262
7263 if (a->CanChange)
7264 {
7265
7266 b = true;
7267
7268 if (i != INFINITE)
7269 {
7270 char *name = LvGetStrA(hWnd, L_LIST, i, 0);
7271 if (name != NULL)
7272 {
7273 UINT j;
7274
7275 for (j = 0;j < a->DefaultOptions.NumItem;j++)
7276 {
7277 if (StrCmpi(a->DefaultOptions.Items[j].Name, name) == 0)
7278 {
7279 b = false;
7280 }
7281 }
7282 Free(name);
7283 }
7284 }
7285 }
7286
7287 if (i != INFINITE)
7288 {
7289 char *name = LvGetStrA(hWnd, L_LIST, i, 0);
7290 if (name != NULL)
7291 {
7292 helpstr = GetHubAdminOptionHelpString(name);
7293 }
7294 Free(name);
7295 }
7296 }
7297 SetEnable(hWnd, B_DELETE, b);
7298
7299 SetText(hWnd, E_HELP, helpstr);
7300 }
7301
7302 // Save
SmHubAdminOptionDlgOk(HWND hWnd,SM_EDIT_AO * a)7303 void SmHubAdminOptionDlgOk(HWND hWnd, SM_EDIT_AO *a)
7304 {
7305 UINT i, num;
7306 RPC_ADMIN_OPTION t;
7307 // Validate arguments
7308 if (hWnd == NULL || a == NULL)
7309 {
7310 return;
7311 }
7312
7313 num = LvNum(hWnd, L_LIST);
7314
7315 Zero(&t, sizeof(t));
7316
7317 StrCpy(t.HubName, sizeof(t.HubName), a->e->HubName);
7318 t.NumItem = num;
7319 t.Items = ZeroMalloc(sizeof(ADMIN_OPTION) * num);
7320
7321 for (i = 0;i < num;i++)
7322 {
7323 char *name = LvGetStrA(hWnd, L_LIST, i, 0);
7324 char *s_value = LvGetStrA(hWnd, L_LIST, i, 1);
7325 ADMIN_OPTION *a = &t.Items[i];
7326
7327 StrCpy(a->Name, sizeof(a->Name), name);
7328 a->Value = ToInt(s_value);
7329
7330 Free(name);
7331 Free(s_value);
7332 }
7333
7334 if (a->ExtOption == false)
7335 {
7336 if (CALL(hWnd, ScSetHubAdminOptions(a->e->p->Rpc, &t)))
7337 {
7338 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_AO_SET_OK"));
7339 EndDialog(hWnd, true);
7340 }
7341 }
7342 else
7343 {
7344 if (CALL(hWnd, ScSetHubExtOptions(a->e->p->Rpc, &t)))
7345 {
7346 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_EXT_OPTION_SET_OK"));
7347 EndDialog(hWnd, true);
7348 }
7349 }
7350
7351 FreeRpcAdminOption(&t);
7352 }
7353
7354 // Virtual HUB Management Options dialog
SmHubAdminOptionDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)7355 UINT SmHubAdminOptionDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
7356 {
7357 SM_EDIT_AO *a = (SM_EDIT_AO *)param;
7358 NMHDR *n;
7359 UINT i;
7360 // Validate arguments
7361 if (hWnd == NULL)
7362 {
7363 return 0;
7364 }
7365
7366 switch (msg)
7367 {
7368 case WM_INITDIALOG:
7369 SmHubAdminOptionDlgInit(hWnd, a);
7370 break;
7371
7372 case WM_COMMAND:
7373 switch (wParam)
7374 {
7375 case B_ADD:
7376 a->NewMode = true;
7377 StrCpy(a->Name, sizeof(a->Name), "");
7378 a->Value = 0;
7379 if (Dialog(hWnd, D_SM_AO_VALUE, SmHubAdminOptionValueDlg,
7380 a))
7381 {
7382 wchar_t tmp1[MAX_SIZE];
7383 wchar_t tmp2[MAX_SIZE];
7384 StrToUni(tmp1, sizeof(tmp1), a->Name);
7385 UniToStru(tmp2, a->Value);
7386
7387 LvInsert(hWnd, L_LIST, ICO_LOG, NULL, 2, tmp1, tmp2);
7388 }
7389 break;
7390
7391 case B_EDIT:
7392 i = LvGetSelected(hWnd, L_LIST);
7393 if (i != INFINITE && a->CanChange)
7394 {
7395 char *name, *value;
7396 name = LvGetStrA(hWnd, L_LIST, i, 0);
7397 value = LvGetStrA(hWnd, L_LIST, i, 1);
7398 a->NewMode = false;
7399 StrCpy(a->Name, sizeof(a->Name), name);
7400 a->Value = ToInt(value);
7401
7402 if (Dialog(hWnd, D_SM_AO_VALUE, SmHubAdminOptionValueDlg,
7403 a))
7404 {
7405 char tmp[MAX_PATH];
7406 ToStr(tmp, a->Value);
7407 LvSetItemA(hWnd, L_LIST, i, 1, tmp);
7408 }
7409
7410 Free(name);
7411 Free(value);
7412 }
7413 break;
7414
7415 case B_DELETE:
7416 i = LvGetSelected(hWnd, L_LIST);
7417 if (i != INFINITE)
7418 {
7419 LvDeleteItem(hWnd, L_LIST, i);
7420 }
7421 break;
7422
7423 case IDCANCEL:
7424 Close(hWnd);
7425 break;
7426
7427 case IDOK:
7428 SmHubAdminOptionDlgOk(hWnd, a);
7429 break;
7430 }
7431 break;
7432
7433 case WM_NOTIFY:
7434 n = (NMHDR *)lParam;
7435 switch (n->idFrom)
7436 {
7437 case L_LIST:
7438 switch (n->code)
7439 {
7440 case LVN_ITEMCHANGED:
7441 SmHubAdminOptionDlgUpdate(hWnd, a);
7442 break;
7443
7444 case NM_DBLCLK:
7445 Command(hWnd, B_EDIT);
7446 break;
7447 }
7448 break;
7449 }
7450 break;
7451
7452 case WM_CLOSE:
7453 EndDialog(hWnd, 0);
7454 break;
7455 }
7456
7457 return 0;
7458 }
7459
7460 // Virtual HUB extended options
SmHubExtOption(HWND hWnd,SM_EDIT_HUB * e)7461 void SmHubExtOption(HWND hWnd, SM_EDIT_HUB *e)
7462 {
7463 SM_EDIT_AO a;
7464 // Validate arguments
7465 if (hWnd == NULL || e == NULL)
7466 {
7467 return;
7468 }
7469
7470 Zero(&a, sizeof(a));
7471 a.e = e;
7472 a.ExtOption = true;
7473
7474 StrCpy(a.CurrentOptions.HubName, sizeof(a.CurrentOptions.HubName), e->HubName);
7475
7476 // Get the current options on the server
7477 if (CALL(hWnd, ScGetHubExtOptions(e->p->Rpc, &a.CurrentOptions)) == false)
7478 {
7479 return;
7480 }
7481
7482 Dialog(hWnd, D_SM_ADMIN_OPTION, SmHubAdminOptionDlg, &a);
7483
7484 FreeRpcAdminOption(&a.CurrentOptions);
7485 FreeRpcAdminOption(&a.DefaultOptions);
7486 }
7487
7488 // Virtual HUB management options
SmHubAdminOption(HWND hWnd,SM_EDIT_HUB * e)7489 void SmHubAdminOption(HWND hWnd, SM_EDIT_HUB *e)
7490 {
7491 SM_EDIT_AO a;
7492 // Validate arguments
7493 if (hWnd == NULL || e == NULL)
7494 {
7495 return;
7496 }
7497
7498 Zero(&a, sizeof(a));
7499 a.e = e;
7500
7501 StrCpy(a.CurrentOptions.HubName, sizeof(a.CurrentOptions.HubName), e->HubName);
7502
7503 // Get the current options on the server
7504 if (CALL(hWnd, ScGetHubAdminOptions(e->p->Rpc, &a.CurrentOptions)) == false)
7505 {
7506 return;
7507 }
7508
7509 ScGetDefaultHubAdminOptions(e->p->Rpc, &a.DefaultOptions);
7510
7511 Dialog(hWnd, D_SM_ADMIN_OPTION, SmHubAdminOptionDlg, &a);
7512
7513 FreeRpcAdminOption(&a.CurrentOptions);
7514 FreeRpcAdminOption(&a.DefaultOptions);
7515 }
7516
7517 // Initialize
SmConfigDlgInit(HWND hWnd,SM_CONFIG * c)7518 void SmConfigDlgInit(HWND hWnd, SM_CONFIG *c)
7519 {
7520 wchar_t *tmp;
7521 UINT tmp_size;
7522 // Validate arguments
7523 if (hWnd == NULL || c == NULL)
7524 {
7525 return;
7526 }
7527
7528 Focus(hWnd, IDCANCEL);
7529
7530 SetIcon(hWnd, 0, ICO_MACHINE);
7531
7532 SetFont(hWnd, E_CONFIG, GetFont(_SS("DEFAULT_FONT_2"), 0, false, false,
7533 false, false));
7534
7535 FormatText(hWnd, IDC_INFO, c->s->ServerName);
7536
7537 // Convert from UTF-8 to Unicode
7538 tmp_size = CalcUtf8ToUni(c->Config.FileData, StrLen(c->Config.FileData)) + 1;
7539 tmp = ZeroMalloc(tmp_size);
7540 Utf8ToUni(tmp, tmp_size, c->Config.FileData, StrLen(c->Config.FileData));
7541
7542 SetText(hWnd, E_CONFIG, tmp);
7543
7544 Free(tmp);
7545 }
7546
7547 // Config edit dialog
SmConfigDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)7548 UINT SmConfigDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
7549 {
7550 SM_CONFIG *c = (SM_CONFIG *)param;
7551 char *filename;
7552 wchar_t *filename_unicode;
7553 wchar_t tmp[MAX_SIZE];
7554 // Validate arguments
7555 if (hWnd == NULL)
7556 {
7557 return 0;
7558 }
7559
7560 switch (msg)
7561 {
7562 case WM_INITDIALOG:
7563 SmConfigDlgInit(hWnd, c);
7564 break;
7565
7566 case WM_COMMAND:
7567 switch (wParam)
7568 {
7569 case B_EXPORT:
7570 StrToUni(tmp, sizeof(tmp), c->Config.FileName);
7571 filename_unicode = SaveDlg(hWnd, _UU("DLG_CONFIG_FILES"), _UU("DLG_SAVE_CONFIG"), tmp, L".config");
7572 if (filename_unicode != NULL)
7573 {
7574 BUF *b = NewBuf();
7575 filename = CopyUniToStr(filename_unicode);
7576 WriteBuf(b, c->Config.FileData, StrLen(c->Config.FileData));
7577 if (DumpBuf(b, filename))
7578 {
7579 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_CONFIG_SAVED"));
7580 }
7581 else
7582 {
7583 MsgBox(hWnd, MB_ICONSTOP, _UU("SM_CONFIG_SAVE_FAILED"));
7584 }
7585 FreeBuf(b);
7586 Free(filename);
7587 Free(filename_unicode);
7588 }
7589 break;
7590
7591 case B_IMPORT:
7592 filename_unicode = OpenDlg(hWnd, _UU("DLG_CONFIG_FILES"), _UU("DLG_OPEN_CONFIG"));
7593 if (filename_unicode != NULL)
7594 {
7595 BUF *b;
7596 filename = CopyUniToStr(filename_unicode);
7597 b = ReadDump(filename);
7598 if (b != NULL)
7599 {
7600 RPC_CONFIG t;
7601
7602 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("SM_CONFIG_CONFIRM")) == IDYES)
7603 {
7604 Zero(&t, sizeof(t));
7605 t.FileData = ZeroMalloc(b->Size + 1);
7606 Copy(t.FileData, b->Buf, b->Size);
7607
7608 if (CALL(hWnd, ScSetConfig(c->s->Rpc, &t)))
7609 {
7610 // Success
7611 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_CONFIG_WRITE_OK"));
7612 _exit(0);
7613 }
7614
7615 FreeRpcConfig(&t);
7616
7617 FreeRpcConfig(&t);
7618 FreeBuf(b);
7619 }
7620 }
7621 else
7622 {
7623 MsgBox(hWnd, MB_ICONSTOP, _UU("SM_CONFIG_OPEN_FAILED"));
7624 }
7625 Free(filename);
7626 Free(filename_unicode);
7627 }
7628 break;
7629
7630 case IDCANCEL:
7631 Close(hWnd);
7632 break;
7633
7634 case B_FACTORY:
7635 if (MsgBox(hWnd, MB_ICONWARNING | MB_YESNO | MB_DEFBUTTON2, _UU("SM_FACTORY_DEFAULT_WARNING")) == IDYES)
7636 {
7637 RPC_TEST t;
7638 UINT ret;
7639
7640 Zero(&t, sizeof(t));
7641
7642 t.IntValue = 1;
7643 ret = ScRebootServer(c->s->Rpc, &t);
7644
7645 if (ret == ERR_DISCONNECTED || ret == ERR_NO_ERROR)
7646 {
7647 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_FACTORY_DEFAULT_PERFORMED"));
7648
7649 exit(0);
7650 }
7651 else
7652 {
7653 CALL(hWnd, ret);
7654 }
7655 }
7656 break;
7657 }
7658 break;
7659
7660 case WM_CLOSE:
7661 EndDialog(hWnd, 0);
7662 break;
7663 }
7664
7665 return 0;
7666 }
7667
7668 // Show the config edit dialog
SmConfig(HWND hWnd,SM_SERVER * s)7669 void SmConfig(HWND hWnd, SM_SERVER *s)
7670 {
7671 SM_CONFIG c;
7672 // Validate arguments
7673 if (hWnd == NULL || s == NULL)
7674 {
7675 return;
7676 }
7677
7678 Zero(&c, sizeof(c));
7679
7680 c.s = s;
7681
7682 // Get current config from the server
7683 if (CALL(hWnd, ScGetConfig(s->Rpc, &c.Config)) == false)
7684 {
7685 return;
7686 }
7687
7688 // Show the dialog
7689 Dialog(hWnd, D_SM_CONFIG, SmConfigDlg, &c);
7690
7691 // Release
7692 FreeRpcConfig(&c.Config);
7693 }
7694
7695 // Bridge dialog initialization
SmBridgeDlgInit(HWND hWnd,SM_SERVER * s)7696 UINT SmBridgeDlgInit(HWND hWnd, SM_SERVER *s)
7697 {
7698 UINT i;
7699 RPC_ENUM_ETH t;
7700 RPC_SERVER_INFO si;
7701 UINT num = 0;
7702 // Validate arguments
7703 if (hWnd == NULL || s == NULL)
7704 {
7705 return 0;
7706 }
7707
7708 LvInit(hWnd, L_LIST);
7709 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_BRIDGE_COLUMN_1"), 50);
7710 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_BRIDGE_COLUMN_2"), 145);
7711 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_BRIDGE_COLUMN_3"), 300);
7712 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_BRIDGE_COLUMN_4"), 100);
7713
7714 SmBridgeDlgRefresh(hWnd, s);
7715
7716 SetShow(hWnd, B_VLAN, GetCapsBool(s->CapsList, "b_support_eth_vlan"));
7717
7718 SetIcon(hWnd, 0, ICO_BRIDGE);
7719
7720 // Get the server information
7721 Zero(&si, sizeof(si));
7722 ScGetServerInfo(s->Rpc, &si);
7723 if (GetCapsBool(s->CapsList, "b_tap_supported") == false)
7724 {
7725 // Tap does not supported
7726 Hide(hWnd, R_TAP);
7727 Hide(hWnd, S_TAP_1);
7728 Hide(hWnd, E_TAPNAME);
7729 Hide(hWnd, S_TAP_2);
7730 Hide(hWnd, R_BRIDGE);
7731 Hide(hWnd, S_STATIC5);
7732 }
7733 Check(hWnd, R_BRIDGE, true);
7734 FreeRpcServerInfo(&si);
7735
7736 // Enumerate the Ethernet devices
7737 Zero(&t, sizeof(t));
7738 ScEnumEthernet(s->Rpc, &t);
7739
7740 CbReset(hWnd, E_NICNAME);
7741 CbSetHeight(hWnd, E_NICNAME, 18);
7742
7743 num = t.NumItem;
7744
7745 for (i = 0;i < t.NumItem;i++)
7746 {
7747 RPC_ENUM_ETH_ITEM *e = &t.Items[i];
7748 if (GetCapsBool(s->CapsList, "b_support_network_connection_name"))
7749 {
7750 wchar_t ncname[MAX_SIZE * 2];
7751 UniFormat(ncname, sizeof(ncname), BRIDGE_NETWORK_CONNECTION_STR, e->NetworkConnectionName, e->DeviceName);
7752 CbAddStr(hWnd, E_NICNAME, ncname, 0);
7753 }
7754 else
7755 {
7756 wchar_t *s = CopyStrToUni(e->DeviceName);
7757 CbAddStr(hWnd, E_NICNAME, s, 0);
7758 Free(s);
7759 }
7760 }
7761
7762 FreeRpcEnumEth(&t);
7763
7764 // Enumerate the Virtual HUBs
7765 {
7766 RPC_ENUM_HUB t;
7767 Zero(&t, sizeof(t));
7768
7769 ScEnumHub(s->Rpc, &t);
7770
7771 CbReset(hWnd, E_HUBNAME);
7772 CbSetHeight(hWnd, E_HUBNAME, 18);
7773
7774 for (i = 0;i < t.NumHub;i++)
7775 {
7776 RPC_ENUM_HUB_ITEM *e = &t.Hubs[i];
7777 wchar_t *s = CopyStrToUni(e->HubName);
7778
7779 if (e->HubType != HUB_TYPE_FARM_DYNAMIC)
7780 {
7781 CbAddStr(hWnd, E_HUBNAME, s, 0);
7782 }
7783 Free(s);
7784 }
7785
7786 SetText(hWnd, E_HUBNAME, L"");
7787
7788 FreeRpcEnumHub(&t);
7789 }
7790
7791 if (s->Bridge)
7792 {
7793 SetTextA(hWnd, E_HUBNAME, "BRIDGE");
7794 }
7795
7796 Focus(hWnd, E_HUBNAME);
7797
7798 SmBridgeDlgUpdate(hWnd, s);
7799
7800 SetTimer(hWnd, 1, 1000, NULL);
7801
7802 return num;
7803 }
7804
7805 // Bridge dialog control update
SmBridgeDlgUpdate(HWND hWnd,SM_SERVER * s)7806 void SmBridgeDlgUpdate(HWND hWnd, SM_SERVER *s)
7807 {
7808 bool ok = true;
7809 // Validate arguments
7810 if (hWnd == NULL || s == NULL)
7811 {
7812 return;
7813 }
7814
7815 if (LvIsMasked(hWnd, L_LIST) && LvIsMultiMasked(hWnd, L_LIST) == false)
7816 {
7817 Enable(hWnd, B_DELETE);
7818 }
7819 else
7820 {
7821 Disable(hWnd, B_DELETE);
7822 }
7823
7824 if (IsEmpty(hWnd, E_HUBNAME))
7825 {
7826 ok = false;
7827 }
7828
7829 if (IsChecked(hWnd, R_TAP) == false)
7830 {
7831 // Bridge mode
7832 Enable(hWnd, S_ETH_1);
7833 Enable(hWnd, E_NICNAME);
7834 Disable(hWnd, S_TAP_1);
7835 Disable(hWnd, S_TAP_2);
7836 Disable(hWnd, E_TAPNAME);
7837 SetText(hWnd, S_INFO, _UU("SM_BRIDGE_INFO_1"));
7838 SetIcon(hWnd, S_ICON, ICO_NIC_ONLINE);
7839 if (IsEmpty(hWnd, E_NICNAME))
7840 {
7841 ok = false;
7842 }
7843 }
7844 else
7845 {
7846 char tmp[MAX_SIZE];
7847 // Tap mode
7848 Disable(hWnd, S_ETH_1);
7849 Disable(hWnd, E_NICNAME);
7850 Enable(hWnd, S_TAP_1);
7851 Enable(hWnd, S_TAP_2);
7852 Enable(hWnd, E_TAPNAME);
7853 SetText(hWnd, S_INFO, _UU("SM_BRIDGE_INFO_2"));
7854 SetIcon(hWnd, S_ICON, ICO_PROTOCOL);
7855 GetTxtA(hWnd, E_TAPNAME, tmp, sizeof(tmp));
7856 if (IsEmptyStr(tmp))
7857 {
7858 ok = false;
7859 }
7860 else
7861 {
7862 if (IsSafeStr(tmp) == false)
7863 {
7864 ok = false;
7865 }
7866 if (StrLen(tmp) >= 12)
7867 {
7868 ok = false;
7869 }
7870 }
7871 }
7872
7873 SetEnable(hWnd, IDOK, ok);
7874 }
7875
7876 // Bridge dialog update
SmBridgeDlgRefresh(HWND hWnd,SM_SERVER * s)7877 void SmBridgeDlgRefresh(HWND hWnd, SM_SERVER *s)
7878 {
7879 LVB *lvb;
7880 RPC_ENUM_LOCALBRIDGE t;
7881 UINT i;
7882 // Validate arguments
7883 if (hWnd == NULL || s == NULL)
7884 {
7885 return;
7886 }
7887
7888 lvb = LvInsertStart();
7889
7890 Zero(&t, sizeof(t));
7891
7892 ScEnumLocalBridge(s->Rpc, &t);
7893
7894 for (i = 0;i < t.NumItem;i++)
7895 {
7896 RPC_LOCALBRIDGE *e = &t.Items[i];
7897 wchar_t name[MAX_SIZE];
7898 wchar_t nic[MAX_SIZE];
7899 wchar_t hub[MAX_SIZE];
7900 wchar_t *status = _UU("SM_BRIDGE_OFFLINE");
7901
7902 UniToStru(name, i + 1);
7903 StrToUni(nic, sizeof(nic), e->DeviceName);
7904 StrToUni(hub, sizeof(hub), e->HubName);
7905
7906 if (e->Online)
7907 {
7908 status = e->Active ? _UU("SM_BRIDGE_ONLINE") : _UU("SM_BRIDGE_ERROR");
7909 }
7910
7911 LvInsertAdd(lvb, e->TapMode == false ? (e->Active ? ICO_NIC_ONLINE : ICO_NIC_OFFLINE) : ICO_PROTOCOL,
7912 NULL, 4, name, hub, nic, status);
7913 }
7914
7915 FreeRpcEnumLocalBridge(&t);
7916
7917 LvInsertEnd(lvb, hWnd, L_LIST);
7918
7919 SmBridgeDlgUpdate(hWnd, s);
7920 }
7921
7922 // Add a Local Bridge
SmBridgeDlgOnOk(HWND hWnd,SM_SERVER * s)7923 void SmBridgeDlgOnOk(HWND hWnd, SM_SERVER *s)
7924 {
7925 char nic[MAX_SIZE];
7926 char hub[MAX_SIZE];
7927 RPC_LOCALBRIDGE t;
7928 bool tapmode = false;
7929 // Validate arguments
7930 if (hWnd == NULL || s == NULL)
7931 {
7932 return;
7933 }
7934
7935 GetTxtA(hWnd, E_HUBNAME, hub, sizeof(hub));
7936
7937 Zero(nic, sizeof(nic));
7938
7939 if (IsChecked(hWnd, R_TAP) == false)
7940 {
7941 wchar_t nctmp[MAX_SIZE * 2];
7942 if(GetCapsBool(s->CapsList, "b_support_network_connection_name") && GetTxt(hWnd, E_NICNAME, nctmp, sizeof(nctmp)))
7943 {
7944 RPC_ENUM_ETH et;
7945 UINT i;
7946 Zero(&et, sizeof(et));
7947 ScEnumEthernet(s->Rpc, &et);
7948 for(i = 0; i < et.NumItem; i++)
7949 {
7950 RPC_ENUM_ETH_ITEM *e = &et.Items[i];
7951 if(UniIsEmptyStr(e->NetworkConnectionName) == false)
7952 {
7953 wchar_t ncname[MAX_SIZE * 2];
7954 UniFormat(ncname, sizeof(ncname), BRIDGE_NETWORK_CONNECTION_STR, e->NetworkConnectionName, e->DeviceName);
7955 if(UniStrCmp(ncname, nctmp) == 0)
7956 {
7957 StrCpy(nic, sizeof(nic), e->DeviceName);
7958 break;
7959 }
7960 }
7961 }
7962 FreeRpcEnumEth(&et);
7963
7964 if (IsEmptyStr(nic))
7965 {
7966 GetTxtA(hWnd, E_NICNAME, nic, sizeof(nic));
7967 }
7968 }
7969 else
7970 {
7971 GetTxtA(hWnd, E_NICNAME, nic, sizeof(nic));
7972 }
7973 }
7974 else
7975 {
7976 tapmode = true;
7977 GetTxtA(hWnd, E_TAPNAME, nic, sizeof(nic));
7978 }
7979
7980 Trim(hub);
7981 Trim(nic);
7982
7983 Zero(&t, sizeof(t));
7984 StrCpy(t.DeviceName, sizeof(t.DeviceName), nic);
7985 StrCpy(t.HubName, sizeof(t.HubName), hub);
7986 t.TapMode = tapmode;
7987
7988 if (InStrEx(t.DeviceName, "vpn", false) || InStrEx(t.DeviceName, "tun", false)
7989 || InStrEx(t.DeviceName, "tap", false))
7990 {
7991 // Trying to make a local bridge to the VPN device
7992 if (MsgBoxEx(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2,
7993 _UU("SM_BRIDGE_VPN"),
7994 t.DeviceName) == IDNO)
7995 {
7996 return;
7997 }
7998 }
7999
8000 // Show a warning message if the VPN Server is running in a VM
8001 if (GetCapsBool(s->CapsList, "b_is_in_vm"))
8002 {
8003 Dialog(hWnd, D_SM_VMBRIDGE, SmVmBridgeDlg, NULL);
8004 }
8005
8006 // Warning for such as Intel LAN cards
8007 if (tapmode == false)
8008 {
8009 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_BRIDGE_INTEL"));
8010 }
8011
8012 if (CALL(hWnd, ScAddLocalBridge(s->Rpc, &t)) == false)
8013 {
8014 Focus(hWnd, E_HUBNAME);
8015 return;
8016 }
8017
8018 SetText(hWnd, E_HUBNAME, L"");
8019 Focus(hWnd, E_HUBNAME);
8020
8021 if (tapmode)
8022 {
8023 SetTextA(hWnd, E_TAPNAME, "");
8024 }
8025
8026 SmBridgeDlgRefresh(hWnd, s);
8027
8028 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_BRIDGE_OK"));
8029 }
8030
8031 // Bridge dialog procedure
SmBridgeDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)8032 UINT SmBridgeDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
8033 {
8034 NMHDR *n;
8035 SM_SERVER *s = (SM_SERVER *)param;
8036 UINT i;
8037 UINT num;
8038 // Validate arguments
8039 if (hWnd == NULL)
8040 {
8041 return 0;
8042 }
8043
8044 switch (msg)
8045 {
8046 case WM_INITDIALOG:
8047 num = SmBridgeDlgInit(hWnd, s);
8048
8049 if (num == 0)
8050 {
8051 SetTimer(hWnd, 2, 500, NULL);
8052 }
8053 break;
8054
8055 case WM_COMMAND:
8056 switch (LOWORD(wParam))
8057 {
8058 case E_HUBNAME:
8059 case E_NICNAME:
8060 case R_BRIDGE:
8061 case R_TAP:
8062 case E_TAPNAME:
8063 SmBridgeDlgUpdate(hWnd, s);
8064 break;
8065 }
8066
8067 switch (wParam)
8068 {
8069 case R_BRIDGE:
8070 Focus(hWnd, E_NICNAME);
8071 break;
8072
8073 case R_TAP:
8074 FocusEx(hWnd, E_TAPNAME);
8075 break;
8076
8077 case IDOK:
8078 // Add
8079 SmBridgeDlgOnOk(hWnd, s);
8080 break;
8081
8082 case IDCANCEL:
8083 // Close
8084 Close(hWnd);
8085 break;
8086
8087 case B_VLAN:
8088 // VLAN utility
8089 SmVLan(hWnd, s);
8090 break;
8091
8092 case B_DELETE:
8093 // Delete
8094 i = LvGetSelected(hWnd, L_LIST);
8095 if (i != INFINITE)
8096 {
8097 wchar_t *nic, *hub;
8098 wchar_t tmp[MAX_SIZE];
8099 RPC_LOCALBRIDGE t;
8100
8101 hub = LvGetStr(hWnd, L_LIST, i, 1);
8102 nic = LvGetStr(hWnd, L_LIST, i, 2);
8103
8104 UniFormat(tmp, sizeof(tmp), _UU("SM_BRIDGE_DELETE"),
8105 hub, nic);
8106
8107 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, tmp) == IDYES)
8108 {
8109 Zero(&t, sizeof(t));
8110 UniToStr(t.DeviceName, sizeof(t.DeviceName), nic);
8111 UniToStr(t.HubName, sizeof(t.HubName), hub);
8112
8113 if (CALL(hWnd, ScDeleteLocalBridge(s->Rpc, &t)))
8114 {
8115 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_BRIDGE_DELETE_OK"));
8116 SmBridgeDlgRefresh(hWnd, s);
8117 }
8118 }
8119
8120 Free(hub);
8121 Free(nic);
8122 }
8123 break;
8124 }
8125 break;
8126
8127 case WM_TIMER:
8128 switch (wParam)
8129 {
8130 case 1:
8131 if (IsEnable(hWnd, 0))
8132 {
8133 KillTimer(hWnd, 1);
8134 SmBridgeDlgRefresh(hWnd, s);
8135 SetTimer(hWnd, 1, 1000, NULL);
8136 }
8137 break;
8138
8139 case 2:
8140 KillTimer(hWnd, 2);
8141
8142 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_NO_BRIDGE_NICS"));
8143 break;
8144 }
8145 break;
8146
8147 case WM_NOTIFY:
8148 n = (NMHDR *)lParam;
8149 switch (n->code)
8150 {
8151 case LVN_ITEMCHANGED:
8152 switch (n->idFrom)
8153 {
8154 case L_LIST:
8155 SmBridgeDlgUpdate(hWnd, s);
8156 break;
8157 }
8158 break;
8159 }
8160 break;
8161
8162 case WM_CLOSE:
8163 EndDialog(hWnd, false);
8164 break;
8165 }
8166
8167 return 0;
8168 }
8169
8170 // Installation of WinPcap
SmInstallWinPcap(HWND hWnd,SM_SERVER * s)8171 void SmInstallWinPcap(HWND hWnd, SM_SERVER *s)
8172 {
8173 wchar_t temp_name[MAX_SIZE];
8174 IO *io;
8175 BUF *buf;
8176
8177 // Ask whether the user want to start the installation
8178 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("SM_BRIDGE_WPCAP_INSTALL")) == IDNO)
8179 {
8180 return;
8181 }
8182
8183 // Generate a temporary file name
8184 UniFormat(temp_name, sizeof(temp_name), L"%s\\winpcap_installer.exe", MsGetTempDirW());
8185
8186 // Read from hamcore
8187 buf = ReadDump("|winpcap_installer.exe");
8188 if (buf == NULL)
8189 {
8190 RES_ERROR:
8191 MsgBox(hWnd, MB_ICONSTOP, _UU("SM_BRIDGE_RESOURCE"));
8192 return;
8193 }
8194
8195 // Write to a temporary file
8196 io = FileCreateW(temp_name);
8197 if (io == NULL)
8198 {
8199 FreeBuf(buf);
8200 goto RES_ERROR;
8201 }
8202
8203 FileWrite(io, buf->Buf, buf->Size);
8204 FileClose(io);
8205
8206 FreeBuf(buf);
8207
8208 // Run
8209 if (RunW(temp_name, NULL, false, true) == false)
8210 {
8211 // Failure
8212 FileDeleteW(temp_name);
8213 goto RES_ERROR;
8214 }
8215
8216 FileDeleteW(temp_name);
8217
8218 if (s == NULL)
8219 {
8220 return;
8221 }
8222
8223 // Need to restart the service
8224 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("SM_BRIDGE_WPCAP_REBOOT2")) == IDNO)
8225 {
8226 // Not restart
8227 }
8228 else
8229 {
8230 // Restart
8231 RPC_TEST t;
8232 Zero(&t, sizeof(t));
8233 ScRebootServer(s->Rpc, &t);
8234
8235 SleepThread(500);
8236
8237 Zero(&t, sizeof(t));
8238 CALL(hWnd, ScTest(s->Rpc, &t));
8239 }
8240 }
8241
8242 // Bridge dialog
SmBridgeDlg(HWND hWnd,SM_SERVER * s)8243 void SmBridgeDlg(HWND hWnd, SM_SERVER *s)
8244 {
8245 RPC_BRIDGE_SUPPORT t;
8246 // Validate arguments
8247 if (hWnd == NULL || s == NULL)
8248 {
8249 return;
8250 }
8251
8252 // Examine the bridge support status of the server side first
8253 Zero(&t, sizeof(t));
8254 if (CALLEX(hWnd, ScGetBridgeSupport(s->Rpc, &t)) != ERR_NO_ERROR)
8255 {
8256 // Not supported because it is old version
8257 MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("SM_BRIDGE_TOO_OLD_VER"));
8258 return;
8259 }
8260
8261 if (t.IsBridgeSupportedOs == false)
8262 {
8263 // OS does not support the bridge
8264 MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("SM_BRIDGE_UNSUPPORTED"));
8265 return;
8266 }
8267
8268 if (t.IsWinPcapNeeded)
8269 {
8270 if (IsLocalHostIP(&s->Rpc->Sock->RemoteIP) == false)
8271 {
8272 // WinPcap is required, but can not do anything because it is in remote control mode
8273 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_BRIDGE_WPCAP_REMOTE"));
8274 return;
8275 }
8276 else
8277 {
8278 // WinPcap is required, and it's in local management mode
8279 if (MsIsAdmin())
8280 {
8281 // The user is an Administrators
8282 SmInstallWinPcap(hWnd, s);
8283 return;
8284 }
8285 else
8286 {
8287 // The user is a non-Administrators
8288 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_BRIDGE_WPCAP_ROOT"));
8289 return;
8290 }
8291 }
8292 }
8293
8294 Dialog(hWnd, D_SM_BRIDGE, SmBridgeDlgProc, s);
8295 }
8296
8297 // SecureNAT screen update
SmSNATDlgUpdate(HWND hWnd,SM_HUB * s)8298 void SmSNATDlgUpdate(HWND hWnd, SM_HUB *s)
8299 {
8300 bool b;
8301 RPC_HUB_STATUS t;
8302 // Validate arguments
8303 if (hWnd == NULL || s == NULL)
8304 {
8305 return;
8306 }
8307
8308 Zero(&t, sizeof(t));
8309 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
8310 if (CALL(hWnd, ScGetHubStatus(s->Rpc, &t)) == false)
8311 {
8312 Close(hWnd);
8313 return;
8314 }
8315
8316 b = t.SecureNATEnabled;
8317
8318 if (b)
8319 {
8320 Disable(hWnd, B_ENABLE);
8321 Enable(hWnd, B_DISABLE);
8322 Enable(hWnd, B_NAT);
8323 Enable(hWnd, B_DHCP);
8324 Enable(hWnd, B_STATUS);
8325 }
8326 else
8327 {
8328 Enable(hWnd, B_ENABLE);
8329 Disable(hWnd, B_DISABLE);
8330 Disable(hWnd, B_NAT);
8331 Disable(hWnd, B_DHCP);
8332 Disable(hWnd, B_STATUS);
8333 }
8334 }
8335
8336 // SecureNAT configuration screen
SmSNATDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)8337 UINT SmSNATDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
8338 {
8339 SM_HUB *s = (SM_HUB *)param;
8340 RPC_HUB t;
8341 // Validate arguments
8342 if (hWnd == NULL)
8343 {
8344 return 0;
8345 }
8346
8347 switch (msg)
8348 {
8349 case WM_INITDIALOG:
8350 SetIcon(hWnd, 0, ICO_ROUTER);
8351 DlgFont(hWnd, S_WARNING, (_GETLANG() == 0 || _GETLANG() == 2) ? 13 : 10, true);
8352 FormatText(hWnd, S_TITLE, s->HubName);
8353 SmSNATDlgUpdate(hWnd, s);
8354
8355 SetTimer(hWnd, 1, 1000, NULL);
8356 break;
8357
8358 case WM_TIMER:
8359 if (wParam == 1)
8360 {
8361 if (IsEnable(hWnd, 0))
8362 {
8363 KillTimer(hWnd, 1);
8364
8365 SmSNATDlgUpdate(hWnd, s);
8366
8367 SetTimer(hWnd, 1, 1000, NULL);
8368 }
8369 }
8370 break;
8371
8372 case WM_COMMAND:
8373 switch (wParam)
8374 {
8375 case IDCANCEL:
8376 Close(hWnd);
8377 break;
8378
8379 case B_ENABLE:
8380 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_OKCANCEL | MB_DEFBUTTON2,
8381 _UU("SM_SECURE_NAT_MSG")) == IDOK)
8382 {
8383 Zero(&t, sizeof(t));
8384 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
8385 CALL(hWnd, ScEnableSecureNAT(s->Rpc, &t));
8386 SmSNATDlgUpdate(hWnd, s);
8387 }
8388 break;
8389
8390 case B_DISABLE:
8391 Zero(&t, sizeof(t));
8392 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
8393 CALL(hWnd, ScDisableSecureNAT(s->Rpc, &t));
8394 SmSNATDlgUpdate(hWnd, s);
8395 break;
8396
8397 case B_CONFIG:
8398 NmEditVhOption(hWnd, s);
8399 break;
8400
8401 case B_NAT:
8402 NmNat(hWnd, s);
8403 break;
8404
8405 case B_DHCP:
8406 NmDhcp(hWnd, s);
8407 break;
8408
8409 case B_STATUS:
8410 SmStatusDlg(hWnd, s->p, s, false, true, _UU("SM_SNAT_STATUS"), ICO_ROUTER,
8411 NULL, NmStatus);
8412 break;
8413 }
8414 break;
8415
8416 case WM_CLOSE:
8417 EndDialog(hWnd, 0);
8418 break;
8419 }
8420
8421 return 0;
8422 }
8423
8424 // Initialize
SmCreateCertDlgInit(HWND hWnd,SM_CERT * s)8425 void SmCreateCertDlgInit(HWND hWnd, SM_CERT *s)
8426 {
8427 UINT cert_sign;
8428 UINT cert_days;
8429 char *reg_o, *reg_ou, *reg_c, *reg_st, *reg_l;
8430 UINT bits[] = {1024, 1536, 2048, 3072, 4096 };
8431 UINT i;
8432 UINT last_bit;
8433 // Validate arguments
8434 if (hWnd == NULL || s == NULL)
8435 {
8436 return;
8437 }
8438
8439 SetTextA(hWnd, E_CN, s->default_cn);
8440
8441 last_bit = MsRegReadInt(REG_CURRENT_USER, SM_CERT_REG_KEY, "Bits");
8442 if (last_bit == 0)
8443 {
8444 last_bit = 2048;
8445 }
8446
8447 CbReset(hWnd, C_BITS);
8448 for (i = 0;i < sizeof(bits) / sizeof(bits[0]);i++)
8449 {
8450 char tmp[MAX_PATH];
8451 UINT index;
8452
8453 ToStr(tmp, bits[i]);
8454
8455 index = CbAddStrA(hWnd, C_BITS, tmp, bits[i]);
8456 }
8457
8458 CbSelect(hWnd, C_BITS, 1024);
8459 CbSelect(hWnd, C_BITS, last_bit);
8460
8461 reg_o = MsRegReadStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "O");
8462 reg_ou = MsRegReadStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "OU");
8463 reg_c = MsRegReadStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "C");
8464 reg_st = MsRegReadStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "ST");
8465 reg_l = MsRegReadStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "L");
8466 SetTextA(hWnd, E_O, reg_o);
8467 SetTextA(hWnd, E_OU, reg_ou);
8468 SetTextA(hWnd, E_C, reg_c);
8469 SetTextA(hWnd, E_ST, reg_st);
8470 SetTextA(hWnd, E_L, reg_l);
8471 Free(reg_o);
8472 Free(reg_ou);
8473 Free(reg_c);
8474 Free(reg_st);
8475 Free(reg_l);
8476
8477 LimitText(hWnd, E_C, 2);
8478
8479 cert_sign = MsRegReadInt(REG_CURRENT_USER, SM_CERT_REG_KEY, "Sign");
8480 cert_days = MsRegReadInt(REG_CURRENT_USER, SM_CERT_REG_KEY, "Days");
8481
8482 Check(hWnd, R_ROOT_CERT, cert_sign ? false : true);
8483 Check(hWnd, R_SIGNED_CERT, cert_sign ? true : false);
8484
8485 if (cert_days == 0)
8486 {
8487 cert_days = 3650;
8488 }
8489
8490 SetIntEx(hWnd, E_EXPIRE, cert_days);
8491
8492 SmCreateCertDlgUpdate(hWnd, s);
8493
8494 if (s->root_only)
8495 {
8496 Disable(hWnd, R_SIGNED_CERT);
8497 }
8498
8499 // Font
8500 SetFont(hWnd, E_CN, GetFont("Verdana", 0, false, false, false, false));
8501 SetFont(hWnd, E_O, GetFont("Verdana", 0, false, false, false, false));
8502 SetFont(hWnd, E_OU, GetFont("Verdana", 0, false, false, false, false));
8503 SetFont(hWnd, E_C, GetFont("Verdana", 0, false, false, false, false));
8504 SetFont(hWnd, E_ST, GetFont("Verdana", 0, false, false, false, false));
8505 SetFont(hWnd, E_L, GetFont("Verdana", 0, false, false, false, false));
8506 SetFont(hWnd, E_SERIAL, GetFont("Verdana", 0, false, false, false, false));
8507 SetFont(hWnd, E_EXPIRE, GetFont("Verdana", 0, false, false, false, false));
8508 SetFont(hWnd, C_BITS, GetFont("Verdana", 0, false, false, false, false));
8509
8510 FocusEx(hWnd, E_CN);
8511 }
8512
8513 // Update
SmCreateCertDlgUpdate(HWND hWnd,SM_CERT * s)8514 void SmCreateCertDlgUpdate(HWND hWnd, SM_CERT *s)
8515 {
8516 bool ok = true;
8517 bool b;
8518 UINT i;
8519 // Validate arguments
8520 if (hWnd == NULL || s == NULL)
8521 {
8522 return;
8523 }
8524
8525 if (IsEmpty(hWnd, E_CN) && IsEmpty(hWnd, E_O) && IsEmpty(hWnd, E_OU) &&
8526 IsEmpty(hWnd, E_ST) && IsEmpty(hWnd, E_L))
8527 {
8528 ok = false;
8529 }
8530
8531 i = GetInt(hWnd, E_EXPIRE);
8532 if (i == 0 || i >= (365 * 30))
8533 {
8534 ok = false;
8535 }
8536
8537 b = IsChecked(hWnd, R_SIGNED_CERT);
8538
8539 SetEnable(hWnd, S_LOAD_1, b);
8540 SetEnable(hWnd, B_LOAD, b);
8541 SetEnable(hWnd, S_LOAD_2, b);
8542
8543 if (b && (s->root_k == NULL || s->root_x == NULL))
8544 {
8545 ok = false;
8546 }
8547
8548 SetEnable(hWnd, IDOK, ok);
8549 }
8550
8551 // [OK] button
SmCreateCertDlgOnOk(HWND hWnd,SM_CERT * s)8552 void SmCreateCertDlgOnOk(HWND hWnd, SM_CERT *s)
8553 {
8554 wchar_t cn[MAX_SIZE], o[MAX_SIZE], ou[MAX_SIZE], c[MAX_SIZE], st[MAX_SIZE], l[MAX_SIZE];
8555 char *reg_o, *reg_ou, *reg_c, *reg_st, *reg_l;
8556 UINT days;
8557 bool sign;
8558 char serial[MAX_SIZE * 2];
8559 X *x;
8560 K *pub;
8561 K *pri;
8562 NAME *n;
8563 X_SERIAL *x_serial;
8564 BUF *buf;
8565 UINT bits;
8566 // Validate arguments
8567 if (hWnd == NULL || s == NULL)
8568 {
8569 return;
8570 }
8571
8572 GetTxt(hWnd, E_CN, cn, sizeof(cn));
8573 GetTxt(hWnd, E_O, o, sizeof(o));
8574 GetTxt(hWnd, E_OU, ou, sizeof(ou));
8575 GetTxt(hWnd, E_C, c, sizeof(c));
8576 GetTxt(hWnd, E_ST, st, sizeof(st));
8577 GetTxt(hWnd, E_L, l, sizeof(l));
8578 GetTxtA(hWnd, E_SERIAL, serial, sizeof(serial));
8579
8580 bits = CbGetSelect(hWnd, C_BITS);
8581 if (bits == INFINITE)
8582 {
8583 bits = 1024;
8584 }
8585
8586 buf = StrToBin(serial);
8587 if (buf == NULL)
8588 {
8589 return;
8590 }
8591
8592 if (buf->Size > 1)
8593 {
8594 x_serial = NewXSerial(buf->Buf, buf->Size);
8595 }
8596 else
8597 {
8598 x_serial = NULL;
8599 }
8600
8601 FreeBuf(buf);
8602
8603 n = NewName(UniStrLen(cn) ? cn : NULL,
8604 UniStrLen(o) ? o : NULL,
8605 UniStrLen(ou) ? ou : NULL,
8606 UniStrLen(c) ? c : NULL,
8607 UniStrLen(st) ? st : NULL,
8608 UniStrLen(l) ? l : NULL);
8609
8610 days = GetInt(hWnd, E_EXPIRE);
8611
8612 sign = IsChecked(hWnd, R_SIGNED_CERT);
8613
8614 MsRegWriteInt(REG_CURRENT_USER, SM_CERT_REG_KEY, "Sign", sign);
8615 MsRegWriteInt(REG_CURRENT_USER, SM_CERT_REG_KEY, "Days", days);
8616 MsRegWriteInt(REG_CURRENT_USER, SM_CERT_REG_KEY, "Bits", bits);
8617
8618 RsaGen(&pri, &pub, bits);
8619
8620 if (sign == false)
8621 {
8622 x = NewRootX(pub, pri, n, days, x_serial);
8623 }
8624 else
8625 {
8626 x = NewX(pub, s->root_k, s->root_x, n, days, x_serial);
8627 }
8628
8629 FreeName(n);
8630
8631 FreeXSerial(x_serial);
8632
8633 if (x == NULL)
8634 {
8635 FreeX(x);
8636 FreeK(pub);
8637 FreeK(pri);
8638 return;
8639 }
8640
8641 if (s->do_not_save == false)
8642 {
8643 if (SmSaveKeyPairDlg(hWnd, x, pri) == false)
8644 {
8645 FreeX(x);
8646 FreeK(pub);
8647 FreeK(pri);
8648 return;
8649 }
8650 }
8651
8652 s->x = x;
8653 s->k = pri;
8654 FreeK(pub);
8655
8656 reg_o = GetTextA(hWnd, E_O);
8657 reg_ou = GetTextA(hWnd, E_OU);
8658 reg_c = GetTextA(hWnd, E_C);
8659 reg_st = GetTextA(hWnd, E_ST);
8660 reg_l = GetTextA(hWnd, E_L);
8661 MsRegWriteStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "O", reg_o);
8662 MsRegWriteStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "OU", reg_ou);
8663 MsRegWriteStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "C", reg_c);
8664 MsRegWriteStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "ST", reg_st);
8665 MsRegWriteStr(REG_CURRENT_USER, SM_CERT_REG_KEY, "L", reg_l);
8666 Free(reg_o);
8667 Free(reg_ou);
8668 Free(reg_c);
8669 Free(reg_st);
8670 Free(reg_l);
8671
8672 EndDialog(hWnd, true);
8673 }
8674
8675 // Certificate creation screen
SmCreateCertDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)8676 UINT SmCreateCertDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
8677 {
8678 SM_CERT *s = (SM_CERT *)param;
8679 // Validate arguments
8680 if (hWnd == NULL)
8681 {
8682 return 0;
8683 }
8684
8685 switch (msg)
8686 {
8687 case WM_INITDIALOG:
8688 // Initialize
8689 SmCreateCertDlgInit(hWnd, s);
8690 break;
8691
8692 case WM_COMMAND:
8693 switch (LOWORD(wParam))
8694 {
8695 case R_ROOT_CERT:
8696 case R_SIGNED_CERT:
8697 case B_LOAD:
8698 case E_CN:
8699 case E_O:
8700 case E_OU:
8701 case E_C:
8702 case E_ST:
8703 case E_L:
8704 case E_EXPIRE:
8705 SmCreateCertDlgUpdate(hWnd, s);
8706 break;
8707 }
8708
8709 switch (wParam)
8710 {
8711 case IDOK:
8712 // [OK] button
8713 SmCreateCertDlgOnOk(hWnd, s);
8714 break;
8715
8716 case R_ROOT_CERT:
8717 if (IsChecked(hWnd, R_ROOT_CERT))
8718 {
8719 FocusEx(hWnd, E_CN);
8720 }
8721 break;
8722
8723 case B_LOAD:
8724 // Read a certificate
8725 if (1)
8726 {
8727 X *x;
8728 K *k;
8729 if (CmLoadXAndK(hWnd, &x, &k))
8730 {
8731 wchar_t tmp[MAX_SIZE];
8732 FreeX(s->root_x);
8733 FreeK(s->root_k);
8734 s->root_x = x;
8735 s->root_k = k;
8736
8737 SmGetCertInfoStr(tmp, sizeof(tmp), x);
8738 SetText(hWnd, S_LOAD_2, tmp);
8739 SmCreateCertDlgUpdate(hWnd, s);
8740 }
8741 }
8742 break;
8743
8744 case IDCANCEL:
8745 // Cancel button
8746 Close(hWnd);
8747 break;
8748 }
8749 break;
8750
8751 case WM_CLOSE:
8752 EndDialog(hWnd, false);
8753 break;
8754 }
8755
8756 return 0;
8757 }
8758
8759 // Certificate tool
SmCreateCert(HWND hWnd,X ** x,K ** k,bool do_not_save,char * default_cn,bool root_only)8760 bool SmCreateCert(HWND hWnd, X **x, K **k, bool do_not_save, char *default_cn, bool root_only)
8761 {
8762 bool ret;
8763 SM_CERT s;
8764 Zero(&s, sizeof(s));
8765
8766 if (default_cn == NULL)
8767 {
8768 default_cn = "";
8769 }
8770
8771 s.default_cn = default_cn;
8772
8773 s.do_not_save = do_not_save;
8774
8775 s.root_only = root_only;
8776
8777 ret = Dialog(hWnd, D_SM_CREATE_CERT, SmCreateCertDlgProc, &s);
8778
8779 if (ret)
8780 {
8781 if (x != NULL)
8782 {
8783 *x = CloneX(s.x);
8784 }
8785
8786 if (k != NULL)
8787 {
8788 *k = CloneK(s.k);
8789 }
8790 }
8791
8792 FreeX(s.x);
8793 FreeK(s.k);
8794 FreeX(s.root_x);
8795 FreeK(s.root_k);
8796
8797 return ret;
8798 }
8799
8800 // Initialize
SmIpTableDlgInit(HWND hWnd,SM_TABLE * s)8801 void SmIpTableDlgInit(HWND hWnd, SM_TABLE *s)
8802 {
8803 // Validate arguments
8804 if (hWnd == NULL || s == NULL)
8805 {
8806 return;
8807 }
8808
8809 SetIcon(hWnd, 0, ICO_PROTOCOL);
8810 FormatText(hWnd, S_TITLE, s->Hub->HubName);
8811
8812 if (s->SessionName != NULL)
8813 {
8814 wchar_t tmp[MAX_SIZE];
8815 wchar_t tmp2[MAX_SIZE];
8816 GetTxt(hWnd, S_TITLE, tmp, sizeof(tmp));
8817 UniFormat(tmp2, sizeof(tmp2), _UU("SM_SESSION_FILTER"), s->SessionName);
8818 UniStrCat(tmp, sizeof(tmp), tmp2);
8819 SetText(hWnd, S_TITLE, tmp);
8820 }
8821
8822 LvInit(hWnd, L_TABLE);
8823 LvInsertColumn(hWnd, L_TABLE, 0, _UU("SM_IP_COLUMN_1"), 190);
8824 LvInsertColumn(hWnd, L_TABLE, 1, _UU("SM_IP_COLUMN_2"), 140);
8825 LvInsertColumn(hWnd, L_TABLE, 2, _UU("SM_IP_COLUMN_3"), 133);
8826 LvInsertColumn(hWnd, L_TABLE, 3, _UU("SM_IP_COLUMN_4"), 133);
8827 LvInsertColumn(hWnd, L_TABLE, 4, _UU("SM_IP_COLUMN_5"), 133);
8828 LvSetStyle(hWnd, L_TABLE, LVS_EX_GRIDLINES);
8829
8830 SmIpTableDlgRefresh(hWnd, s);
8831 }
8832
8833 // Update the control
SmIpTableDlgUpdate(HWND hWnd,SM_TABLE * s)8834 void SmIpTableDlgUpdate(HWND hWnd, SM_TABLE *s)
8835 {
8836 bool ok = true;
8837 // Validate arguments
8838 if (hWnd == NULL || s == NULL)
8839 {
8840 return;
8841 }
8842
8843 if (LvIsSelected(hWnd, L_TABLE) == false || LvIsMultiMasked(hWnd, L_TABLE))
8844 {
8845 ok = false;
8846 }
8847
8848 SetEnable(hWnd, B_DELETE, ok);
8849 }
8850
8851 // Content update
SmIpTableDlgRefresh(HWND hWnd,SM_TABLE * s)8852 void SmIpTableDlgRefresh(HWND hWnd, SM_TABLE *s)
8853 {
8854 UINT i;
8855 RPC_ENUM_IP_TABLE t;
8856 UINT old_selected = 0;
8857 // Validate arguments
8858 if (hWnd == NULL || s == NULL)
8859 {
8860 return;
8861 }
8862
8863 Zero(&t, sizeof(t));
8864 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
8865
8866 if (CALL(hWnd, ScEnumIpTable(s->Rpc, &t)) == false)
8867 {
8868 EndDialog(hWnd, false);
8869 return;
8870 }
8871
8872 i = LvGetSelected(hWnd, L_TABLE);
8873 if (i != INFINITE)
8874 {
8875 old_selected = (UINT)LvGetParam(hWnd, L_TABLE, i);
8876 }
8877
8878 LvReset(hWnd, L_TABLE);
8879
8880 for (i = 0;i < t.NumIpTable;i++)
8881 {
8882 char str[MAX_SIZE];
8883 wchar_t tmp1[MAX_SIZE];
8884 wchar_t tmp2[MAX_SIZE];
8885 wchar_t tmp3[MAX_SIZE];
8886 wchar_t tmp4[MAX_SIZE];
8887 wchar_t tmp5[MAX_SIZE];
8888 RPC_ENUM_IP_TABLE_ITEM *e = &t.IpTables[i];
8889
8890 if (s->SessionName == NULL || StrCmpi(e->SessionName, s->SessionName) == 0)
8891 {
8892 StrToUni(tmp1, sizeof(tmp1), e->SessionName);
8893
8894 if (e->DhcpAllocated == false)
8895 {
8896 IPToStr(str, sizeof(str), &e->IpV6);
8897 StrToUni(tmp2, sizeof(tmp2), str);
8898 }
8899 else
8900 {
8901 IPToStr(str, sizeof(str), &e->IpV6);
8902 UniFormat(tmp2, sizeof(tmp2), _UU("SM_MAC_IP_DHCP"), str);
8903 }
8904
8905 GetDateTimeStr64Uni(tmp3, sizeof(tmp3), SystemToLocal64(e->CreatedTime));
8906
8907 GetDateTimeStr64Uni(tmp4, sizeof(tmp4), SystemToLocal64(e->UpdatedTime));
8908
8909 if (StrLen(e->RemoteHostname) == 0)
8910 {
8911 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_MACIP_LOCAL"));
8912 }
8913 else
8914 {
8915 UniFormat(tmp5, sizeof(tmp5), _UU("SM_MACIP_SERVER"), e->RemoteHostname);
8916 }
8917
8918 LvInsert(hWnd, L_TABLE, e->DhcpAllocated ? ICO_PROTOCOL_DHCP : ICO_PROTOCOL, (void *)e->Key, 5,
8919 tmp1, tmp2, tmp3, tmp4, tmp5);
8920 }
8921 }
8922
8923 FreeRpcEnumIpTable(&t);
8924
8925 if (old_selected != 0)
8926 {
8927 LvSelect(hWnd, L_TABLE, LvSearchParam(hWnd, L_TABLE, (void *)old_selected));
8928 }
8929
8930 SmIpTableDlgUpdate(hWnd, s);
8931 }
8932
8933 // IP address table dialog procedure
SmIpTableDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)8934 UINT SmIpTableDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
8935 {
8936 SM_TABLE *s = (SM_TABLE *)param;
8937 NMHDR *n;
8938 UINT i;
8939 // Validate arguments
8940 if (hWnd == NULL)
8941 {
8942 return 0;
8943 }
8944
8945 switch (msg)
8946 {
8947 case WM_INITDIALOG:
8948 // Initialize
8949 SmIpTableDlgInit(hWnd, s);
8950 break;
8951
8952 case WM_COMMAND:
8953 switch (wParam)
8954 {
8955 case B_DELETE:
8956 // Delete
8957 i = LvGetSelected(hWnd, L_TABLE);
8958 if (i != INFINITE)
8959 {
8960 RPC_DELETE_TABLE t;
8961 UINT key = (UINT)LvGetParam(hWnd, L_TABLE, i);
8962
8963 Zero(&t, sizeof(t));
8964 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
8965 t.Key = key;
8966 if (CALL(hWnd, ScDeleteIpTable(s->Rpc, &t)))
8967 {
8968 LvDeleteItem(hWnd, L_TABLE, i);
8969 }
8970 }
8971 break;
8972
8973 case B_REFRESH:
8974 // Update
8975 SmIpTableDlgRefresh(hWnd, s);
8976 break;
8977
8978 case IDCANCEL:
8979 // Cancel button
8980 Close(hWnd);
8981 break;
8982 }
8983 break;
8984
8985 case WM_NOTIFY:
8986 n = (NMHDR *)lParam;
8987 switch (n->idFrom)
8988 {
8989 case L_TABLE:
8990 switch (n->code)
8991 {
8992 case LVN_ITEMCHANGED:
8993 SmIpTableDlgUpdate(hWnd, s);
8994 break;
8995 }
8996 break;
8997 }
8998 break;
8999
9000 case WM_CLOSE:
9001 EndDialog(hWnd, false);
9002 break;
9003 }
9004
9005 LvStandardHandler(hWnd, msg, wParam, lParam, L_TABLE);
9006
9007 return 0;
9008 }
9009
9010 // IP address table dialog
SmIpTableDlg(HWND hWnd,SM_HUB * s,char * session_name)9011 void SmIpTableDlg(HWND hWnd, SM_HUB *s, char *session_name)
9012 {
9013 SM_TABLE t;
9014 // Validate arguments
9015 if (hWnd == NULL || s == NULL)
9016 {
9017 return;
9018 }
9019
9020 Zero(&t, sizeof(t));
9021 t.Hub = s;
9022 t.Rpc = s->Rpc;
9023 t.SessionName = session_name;
9024
9025 Dialog(hWnd, D_SM_IP, SmIpTableDlgProc, &t);
9026 }
9027
9028
9029 // Initialize
SmMacTableDlgInit(HWND hWnd,SM_TABLE * s)9030 void SmMacTableDlgInit(HWND hWnd, SM_TABLE *s)
9031 {
9032 UINT i = 0;
9033 // Validate arguments
9034 if (hWnd == NULL || s == NULL)
9035 {
9036 return;
9037 }
9038
9039 SetIcon(hWnd, 0, ICO_NIC_ONLINE);
9040 FormatText(hWnd, S_TITLE, s->Hub->HubName);
9041
9042 if (s->SessionName != NULL)
9043 {
9044 wchar_t tmp[MAX_SIZE];
9045 wchar_t tmp2[MAX_SIZE];
9046 GetTxt(hWnd, S_TITLE, tmp, sizeof(tmp));
9047 UniFormat(tmp2, sizeof(tmp2), _UU("SM_SESSION_FILTER"), s->SessionName);
9048 UniStrCat(tmp, sizeof(tmp), tmp2);
9049 SetText(hWnd, S_TITLE, tmp);
9050 }
9051
9052 LvInit(hWnd, L_TABLE);
9053 LvInsertColumn(hWnd, L_TABLE, i++, _UU("SM_MAC_COLUMN_1"), 190);
9054 if (GetCapsBool(s->Hub->p->CapsList, "b_support_vlan"))
9055 {
9056 LvInsertColumn(hWnd, L_TABLE, i++, _UU("SM_MAC_COLUMN_1A"), 65);
9057 }
9058 LvInsertColumn(hWnd, L_TABLE, i++, _UU("SM_MAC_COLUMN_2"), 140);
9059 LvInsertColumn(hWnd, L_TABLE, i++, _UU("SM_MAC_COLUMN_3"), 133);
9060 LvInsertColumn(hWnd, L_TABLE, i++, _UU("SM_MAC_COLUMN_4"), 133);
9061 LvInsertColumn(hWnd, L_TABLE, i++, _UU("SM_MAC_COLUMN_5"), 133);
9062 LvSetStyle(hWnd, L_TABLE, LVS_EX_GRIDLINES);
9063
9064 SmMacTableDlgRefresh(hWnd, s);
9065 }
9066
9067 // Update the control
SmMacTableDlgUpdate(HWND hWnd,SM_TABLE * s)9068 void SmMacTableDlgUpdate(HWND hWnd, SM_TABLE *s)
9069 {
9070 bool ok = true;
9071 // Validate arguments
9072 if (hWnd == NULL || s == NULL)
9073 {
9074 return;
9075 }
9076
9077 if (LvIsSelected(hWnd, L_TABLE) == false || LvIsMultiMasked(hWnd, L_TABLE))
9078 {
9079 ok = false;
9080 }
9081
9082 SetEnable(hWnd, B_DELETE, ok);
9083 }
9084
9085 // Content update
SmMacTableDlgRefresh(HWND hWnd,SM_TABLE * s)9086 void SmMacTableDlgRefresh(HWND hWnd, SM_TABLE *s)
9087 {
9088 UINT i;
9089 RPC_ENUM_MAC_TABLE t;
9090 UINT old_selected = 0;
9091 // Validate arguments
9092 if (hWnd == NULL || s == NULL)
9093 {
9094 return;
9095 }
9096
9097 Zero(&t, sizeof(t));
9098 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
9099
9100 if (CALL(hWnd, ScEnumMacTable(s->Rpc, &t)) == false)
9101 {
9102 EndDialog(hWnd, false);
9103 return;
9104 }
9105
9106 i = LvGetSelected(hWnd, L_TABLE);
9107 if (i != INFINITE)
9108 {
9109 old_selected = (UINT)LvGetParam(hWnd, L_TABLE, i);
9110 }
9111
9112 LvReset(hWnd, L_TABLE);
9113
9114 for (i = 0;i < t.NumMacTable;i++)
9115 {
9116 char str[MAX_SIZE];
9117 wchar_t tmp1[MAX_SIZE];
9118 wchar_t tmp2[MAX_SIZE];
9119 wchar_t tmp3[MAX_SIZE];
9120 wchar_t tmp4[MAX_SIZE];
9121 wchar_t tmp5[MAX_SIZE];
9122 wchar_t tmp6[MAX_SIZE];
9123 RPC_ENUM_MAC_TABLE_ITEM *e = &t.MacTables[i];
9124
9125 if (s->SessionName == NULL || StrCmpi(e->SessionName, s->SessionName) == 0)
9126 {
9127 StrToUni(tmp1, sizeof(tmp1), e->SessionName);
9128
9129 MacToStr(str, sizeof(str), e->MacAddress);
9130 StrToUni(tmp2, sizeof(tmp2), str);
9131
9132 GetDateTimeStr64Uni(tmp3, sizeof(tmp3), SystemToLocal64(e->CreatedTime));
9133
9134 GetDateTimeStr64Uni(tmp4, sizeof(tmp4), SystemToLocal64(e->UpdatedTime));
9135
9136 if (StrLen(e->RemoteHostname) == 0)
9137 {
9138 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_MACIP_LOCAL"));
9139 }
9140 else
9141 {
9142 UniFormat(tmp5, sizeof(tmp5), _UU("SM_MACIP_SERVER"), e->RemoteHostname);
9143 }
9144
9145 UniToStru(tmp6, e->VlanId);
9146 if (e->VlanId == 0)
9147 {
9148 UniStrCpy(tmp6, sizeof(tmp6), _UU("CM_ST_NONE"));
9149 }
9150
9151 if (GetCapsBool(s->Hub->p->CapsList, "b_support_vlan"))
9152 {
9153 LvInsert(hWnd, L_TABLE, ICO_NIC_ONLINE, (void *)e->Key, 6,
9154 tmp1, tmp6, tmp2, tmp3, tmp4, tmp5);
9155 }
9156 else
9157 {
9158 LvInsert(hWnd, L_TABLE, ICO_NIC_ONLINE, (void *)e->Key, 5,
9159 tmp1, tmp2, tmp3, tmp4, tmp5);
9160 }
9161 }
9162 }
9163
9164 FreeRpcEnumMacTable(&t);
9165
9166 if (old_selected != 0)
9167 {
9168 LvSelect(hWnd, L_TABLE, LvSearchParam(hWnd, L_TABLE, (void *)old_selected));
9169 }
9170
9171 SmMacTableDlgUpdate(hWnd, s);
9172 }
9173
9174 // MAC address table dialog procedure
SmMacTableDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)9175 UINT SmMacTableDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
9176 {
9177 SM_TABLE *s = (SM_TABLE *)param;
9178 NMHDR *n;
9179 UINT i;
9180 // Validate arguments
9181 if (hWnd == NULL)
9182 {
9183 return 0;
9184 }
9185
9186 switch (msg)
9187 {
9188 case WM_INITDIALOG:
9189 // Initialize
9190 SmMacTableDlgInit(hWnd, s);
9191 break;
9192
9193 case WM_COMMAND:
9194 switch (wParam)
9195 {
9196 case B_DELETE:
9197 // Delete
9198 i = LvGetSelected(hWnd, L_TABLE);
9199 if (i != INFINITE)
9200 {
9201 RPC_DELETE_TABLE t;
9202 UINT key = (UINT)LvGetParam(hWnd, L_TABLE, i);
9203
9204 Zero(&t, sizeof(t));
9205 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
9206 t.Key = key;
9207 if (CALL(hWnd, ScDeleteMacTable(s->Rpc, &t)))
9208 {
9209 LvDeleteItem(hWnd, L_TABLE, i);
9210 }
9211 }
9212 break;
9213
9214 case B_REFRESH:
9215 // Update
9216 SmMacTableDlgRefresh(hWnd, s);
9217 break;
9218
9219 case IDCANCEL:
9220 // Cancel button
9221 Close(hWnd);
9222 break;
9223 }
9224 break;
9225
9226 case WM_NOTIFY:
9227 n = (NMHDR *)lParam;
9228 switch (n->idFrom)
9229 {
9230 case L_TABLE:
9231 switch (n->code)
9232 {
9233 case LVN_ITEMCHANGED:
9234 SmMacTableDlgUpdate(hWnd, s);
9235 break;
9236 }
9237 break;
9238 }
9239 break;
9240
9241 case WM_CLOSE:
9242 EndDialog(hWnd, false);
9243 break;
9244 }
9245
9246 LvStandardHandler(hWnd, msg, wParam, lParam, L_TABLE);
9247
9248 return 0;
9249 }
9250
9251 // MAC address table dialog
SmMacTableDlg(HWND hWnd,SM_HUB * s,char * session_name)9252 void SmMacTableDlg(HWND hWnd, SM_HUB *s, char *session_name)
9253 {
9254 SM_TABLE t;
9255 // Validate arguments
9256 if (hWnd == NULL || s == NULL)
9257 {
9258 return;
9259 }
9260
9261 Zero(&t, sizeof(t));
9262 t.Hub = s;
9263 t.Rpc = s->Rpc;
9264 t.SessionName = session_name;
9265
9266 Dialog(hWnd, D_SM_MAC, SmMacTableDlgProc, &t);
9267 }
9268
9269 // Initialize
SmSessionDlgInit(HWND hWnd,SM_HUB * s)9270 void SmSessionDlgInit(HWND hWnd, SM_HUB *s)
9271 {
9272 // Validate arguments
9273 if (hWnd == NULL || s == NULL)
9274 {
9275 return;
9276 }
9277
9278 SetIcon(hWnd, 0, ICO_VPN);
9279 FormatText(hWnd, 0, s->HubName);
9280 FormatText(hWnd, S_TITLE, s->HubName);
9281
9282 LvInit(hWnd, L_LIST);
9283 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_SESS_COLUMN_1"), 176);
9284 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_SESS_COLUMN_8"), 58);
9285 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_SESS_COLUMN_2"), 62);
9286 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_SESS_COLUMN_3"), 78);
9287 LvInsertColumn(hWnd, L_LIST, 4, _UU("SM_SESS_COLUMN_4"), 122);
9288 LvInsertColumn(hWnd, L_LIST, 5, _UU("SM_SESS_COLUMN_5"), 68);
9289 LvInsertColumn(hWnd, L_LIST, 6, _UU("SM_SESS_COLUMN_6"), 100);
9290 LvInsertColumn(hWnd, L_LIST, 7, _UU("SM_SESS_COLUMN_7"), 100);
9291 LvSetStyle(hWnd, L_LIST, LVS_EX_GRIDLINES);
9292
9293 if (s->p->ServerType == SERVER_TYPE_FARM_CONTROLLER && GetCapsBool(s->p->CapsList, "b_support_cluster_admin") == false)
9294 {
9295 Show(hWnd, S_FARM_INFO_1);
9296 Show(hWnd, S_FARM_INFO_2);
9297 }
9298
9299 SmSessionDlgRefresh(hWnd, s);
9300 }
9301
9302 // Update the control
SmSessionDlgUpdate(HWND hWnd,SM_HUB * s)9303 void SmSessionDlgUpdate(HWND hWnd, SM_HUB *s)
9304 {
9305 bool ok = true;
9306 bool ok2 = true;
9307 // Validate arguments
9308 if (hWnd == NULL || s == NULL)
9309 {
9310 return;
9311 }
9312
9313 if (LvIsSelected(hWnd, L_LIST) == false || LvIsMultiMasked(hWnd, L_LIST))
9314 {
9315 ok = false;
9316 ok2 = false;
9317 }
9318 else
9319 {
9320 UINT i = LvGetSelected(hWnd, L_LIST);
9321 if (i != INFINITE)
9322 {
9323 void *p = LvGetParam(hWnd, L_LIST, i);
9324 if (((bool)p) != false)
9325 {
9326 if (GetCapsBool(s->p->CapsList, "b_support_cluster_admin") == false)
9327 {
9328 ok = false;
9329 }
9330 }
9331 }
9332 }
9333
9334 if (s->p->ServerInfo.ServerBuildInt < 2844)
9335 {
9336 // Old version doesn't support for remote management of the sessions
9337 ok2 = ok;
9338 }
9339
9340 SetEnable(hWnd, IDOK, ok2);
9341 SetEnable(hWnd, B_DISCONNECT, ok2);
9342 SetEnable(hWnd, B_SESSION_IP_TABLE, ok);
9343 SetEnable(hWnd, B_SESSION_MAC_TABLE, ok);
9344 }
9345
9346 // Update the list
SmSessionDlgRefresh(HWND hWnd,SM_HUB * s)9347 void SmSessionDlgRefresh(HWND hWnd, SM_HUB *s)
9348 {
9349 LVB *b;
9350 UINT i;
9351 wchar_t *old_select;
9352 RPC_ENUM_SESSION t;
9353 // Validate arguments
9354 if (hWnd == NULL || s == NULL)
9355 {
9356 return;
9357 }
9358
9359 Zero(&t, sizeof(t));
9360 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
9361
9362 if (CALL(hWnd, ScEnumSession(s->Rpc, &t)) == false)
9363 {
9364 EndDialog(hWnd, false);
9365 return;
9366 }
9367
9368 old_select = LvGetSelectedStr(hWnd, L_LIST, 0);
9369
9370 LvReset(hWnd, L_LIST);
9371
9372 b = LvInsertStart();
9373
9374 for (i = 0;i < t.NumSession;i++)
9375 {
9376 RPC_ENUM_SESSION_ITEM *e = &t.Sessions[i];
9377 wchar_t tmp1[MAX_SIZE];
9378 wchar_t *tmp2;
9379 wchar_t tmp3[MAX_SIZE];
9380 wchar_t tmp4[MAX_SIZE];
9381 wchar_t tmp5[MAX_SIZE];
9382 wchar_t tmp6[MAX_SIZE];
9383 wchar_t tmp7[MAX_SIZE];
9384 wchar_t tmp8[MAX_SIZE];
9385 bool free_tmp2 = false;
9386 UINT icon;
9387
9388 StrToUni(tmp1, sizeof(tmp1), e->Name);
9389
9390 tmp2 = _UU("SM_SESS_NORMAL");
9391 icon = ICO_VPN;
9392 if (s->p->ServerType != SERVER_TYPE_STANDALONE)
9393 {
9394 if (e->RemoteSession)
9395 {
9396 tmp2 = ZeroMalloc(MAX_SIZE);
9397 UniFormat(tmp2, MAX_SIZE, _UU("SM_SESS_REMOTE"), e->RemoteHostname);
9398 icon = ICO_VPN;
9399 free_tmp2 = true;
9400 }
9401 else
9402 {
9403 if (StrLen(e->RemoteHostname) == 0)
9404 {
9405 tmp2 = _UU("SM_SESS_LOCAL");
9406 }
9407 else
9408 {
9409 tmp2 = ZeroMalloc(MAX_SIZE);
9410 UniFormat(tmp2, MAX_SIZE, _UU("SM_SESS_LOCAL_2"), e->RemoteHostname);
9411 free_tmp2 = true;
9412 }
9413 }
9414 }
9415 if (e->LinkMode)
9416 {
9417 if (free_tmp2)
9418 {
9419 Free(tmp2);
9420 free_tmp2 = false;
9421 }
9422 tmp2 = _UU("SM_SESS_LINK");
9423 icon = ICO_CASCADE;
9424 }
9425 else if (e->SecureNATMode)
9426 {
9427 /*if (free_tmp2)
9428 {
9429 Free(tmp2);
9430 free_tmp2 = false;
9431 }
9432 tmp2 = _UU("SM_SESS_SNAT");*/
9433 icon = ICO_ROUTER;
9434 }
9435 else if (e->BridgeMode)
9436 {
9437 icon = ICO_BRIDGE;
9438 }
9439 else if (e->Layer3Mode)
9440 {
9441 icon = ICO_SWITCH;
9442 }
9443
9444 StrToUni(tmp3, sizeof(tmp3), e->Username);
9445
9446 StrToUni(tmp4, sizeof(tmp4), e->Hostname);
9447 if (e->LinkMode)
9448 {
9449 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_SESS_LINK_HOSTNAME"));
9450 }
9451 else if (e->SecureNATMode)
9452 {
9453 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_SESS_SNAT_HOSTNAME"));
9454 }
9455 else if (e->BridgeMode)
9456 {
9457 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_SESS_BRIDGE_HOSTNAME"));
9458 }
9459 else if (StartWith(e->Username, L3_USERNAME))
9460 {
9461 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_SESS_LAYER3_HOSTNAME"));
9462 }
9463
9464 UniFormat(tmp5, sizeof(tmp5), L"%u / %u", e->CurrentNumTcp, e->MaxNumTcp);
9465 if (e->LinkMode)
9466 {
9467 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_SESS_LINK_TCP"));
9468 }
9469 else if (e->SecureNATMode)
9470 {
9471 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_SESS_SNAT_TCP"));
9472 }
9473 else if (e->BridgeMode)
9474 {
9475 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_SESS_BRIDGE_TCP"));
9476 }
9477
9478 if (e->VLanId == 0)
9479 {
9480 UniStrCpy(tmp8, sizeof(tmp8), _UU("CM_ST_NO_VLAN"));
9481 }
9482 else
9483 {
9484 UniToStru(tmp8, e->VLanId);
9485 }
9486
9487 UniToStr3(tmp6, sizeof(tmp6), e->PacketSize);
9488 UniToStr3(tmp7, sizeof(tmp7), e->PacketNum);
9489
9490 if (icon == ICO_VPN)
9491 {
9492 if (e->Client_BridgeMode)
9493 {
9494 icon = ICO_SESSION_BRIDGE;
9495 }
9496 else if (e->Client_MonitorMode)
9497 {
9498 icon = ICO_SESSION_MONITOR;
9499 }
9500 }
9501
9502 if (e->IsDormantEnabled && e->IsDormant)
9503 {
9504 icon = ICO_TRAY0;
9505 }
9506
9507 LvInsertAdd(b, icon, (void *)(e->RemoteSession), 8, tmp1, tmp8, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);
9508
9509 if (free_tmp2)
9510 {
9511 Free(tmp2);
9512 }
9513 }
9514
9515 LvInsertEnd(b, hWnd, L_LIST);
9516
9517 if (old_select != NULL && UniStrLen(old_select) != 0)
9518 {
9519 UINT i = LvSearchStr(hWnd, L_LIST, 0, old_select);
9520 if (i != INFINITE)
9521 {
9522 LvSelect(hWnd, L_LIST, i);
9523 }
9524 }
9525
9526 Free(old_select);
9527
9528 FreeRpcEnumSession(&t);
9529
9530 SmSessionDlgUpdate(hWnd, s);
9531 }
9532
9533 // Display the NODE_INFO
SmPrintNodeInfo(LVB * b,NODE_INFO * info)9534 void SmPrintNodeInfo(LVB *b, NODE_INFO *info)
9535 {
9536 wchar_t tmp[MAX_SIZE];
9537 char str[MAX_SIZE];
9538 // Validate arguments
9539 if (b == NULL || info == NULL)
9540 {
9541 return;
9542 }
9543
9544 StrToUni(tmp, sizeof(tmp), info->ClientProductName);
9545 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_NAME"), tmp);
9546
9547 UniFormat(tmp, sizeof(tmp), L"%u.%02u", Endian32(info->ClientProductVer) / 100, Endian32(info->ClientProductVer) % 100);
9548 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_VER"), tmp);
9549
9550 UniFormat(tmp, sizeof(tmp), L"Build %u", Endian32(info->ClientProductBuild));
9551 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_BUILD"), tmp);
9552
9553 StrToUni(tmp, sizeof(tmp), info->ClientOsName);
9554 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_OS_NAME"), tmp);
9555
9556 StrToUni(tmp, sizeof(tmp), info->ClientOsVer);
9557 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_OS_VER"), tmp);
9558
9559 StrToUni(tmp, sizeof(tmp), info->ClientOsProductId);
9560 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_OS_PID"), tmp);
9561
9562 StrToUni(tmp, sizeof(tmp), info->ClientHostname);
9563 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_HOST"), tmp);
9564
9565 IPToStr4or6(str, sizeof(str), info->ClientIpAddress, info->ClientIpAddress6);
9566 StrToUni(tmp, sizeof(tmp), str);
9567 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_IP"), tmp);
9568
9569 UniToStru(tmp, Endian32(info->ClientPort));
9570 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_CLIENT_PORT"), tmp);
9571
9572 StrToUni(tmp, sizeof(tmp), info->ServerHostname);
9573 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_SERVER_HOST"), tmp);
9574
9575 IPToStr4or6(str, sizeof(str), info->ServerIpAddress, info->ServerIpAddress6);
9576 StrToUni(tmp, sizeof(tmp), str);
9577 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_SERVER_IP"), tmp);
9578
9579 UniToStru(tmp, Endian32(info->ServerPort));
9580 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_SERVER_PORT"), tmp);
9581
9582 if (StrLen(info->ProxyHostname) != 0)
9583 {
9584 StrToUni(tmp, sizeof(tmp), info->ProxyHostname);
9585 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_PROXY_HOSTNAME"), tmp);
9586
9587 IPToStr4or6(str, sizeof(str), info->ProxyIpAddress, info->ProxyIpAddress6);
9588 StrToUni(tmp, sizeof(tmp), str);
9589 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_PROXY_IP"), tmp);
9590
9591 UniToStru(tmp, Endian32(info->ProxyPort));
9592 LvInsertAdd(b, 0, NULL, 2, _UU("SM_NODE_PROXY_PORT"), tmp);
9593 }
9594 }
9595
9596 // Update the session status
SmRefreshSessionStatus(HWND hWnd,SM_SERVER * s,void * param)9597 bool SmRefreshSessionStatus(HWND hWnd, SM_SERVER *s, void *param)
9598 {
9599 LVB *b;
9600 SM_SESSION_STATUS *status = (SM_SESSION_STATUS *)param;
9601 RPC_SESSION_STATUS t;
9602 wchar_t tmp[MAX_SIZE];
9603 char str[MAX_SIZE];
9604 // Validate arguments
9605 if (hWnd == NULL || s == NULL || param == NULL)
9606 {
9607 return false;
9608 }
9609
9610 Zero(&t, sizeof(t));
9611 StrCpy(t.HubName, sizeof(t.HubName), status->Hub->HubName);
9612 StrCpy(t.Name, sizeof(t.Name), status->SessionName);
9613
9614 if (CALL(hWnd, ScGetSessionStatus(s->Rpc, &t)) == false)
9615 {
9616 return false;
9617 }
9618
9619 b = LvInsertStart();
9620
9621 if (t.ClientIp != 0)
9622 {
9623 IPToStr4or6(str, sizeof(str), t.ClientIp, t.ClientIp6);
9624 StrToUni(tmp, sizeof(tmp), str);
9625 LvInsertAdd(b, 0, NULL, 2, _UU("SM_CLIENT_IP"), tmp);
9626 }
9627
9628 if (StrLen(t.ClientHostName) != 0)
9629 {
9630 StrToUni(tmp, sizeof(tmp), t.ClientHostName);
9631 LvInsertAdd(b, 0, NULL, 2, _UU("SM_CLIENT_HOSTNAME"), tmp);
9632 }
9633
9634 StrToUni(tmp, sizeof(tmp), t.Username);
9635 LvInsertAdd(b, 0, NULL, 2, _UU("SM_SESS_STATUS_USERNAME"), tmp);
9636
9637 if (StrCmpi(t.Username, LINK_USER_NAME_PRINT) != 0 && StrCmpi(t.Username, SNAT_USER_NAME_PRINT) != 0 && StrCmpi(t.Username, BRIDGE_USER_NAME_PRINT) != 0)
9638 {
9639 StrToUni(tmp, sizeof(tmp), t.RealUsername);
9640 LvInsertAdd(b, 0, NULL, 2, _UU("SM_SESS_STATUS_REALUSER"), tmp);
9641 }
9642
9643 if (IsEmptyStr(t.GroupName) == false)
9644 {
9645 StrToUni(tmp, sizeof(tmp), t.GroupName);
9646 LvInsertAdd(b, 0, NULL, 2, _UU("SM_SESS_STATUS_GROUPNAME"), tmp);
9647 }
9648
9649 CmPrintStatusToListViewEx(b, &t.Status, true);
9650
9651 if (StrCmpi(t.Username, LINK_USER_NAME_PRINT) != 0 && StrCmpi(t.Username, SNAT_USER_NAME_PRINT) != 0 && StrCmpi(t.Username, BRIDGE_USER_NAME_PRINT) != 0 &&
9652 StartWith(t.Username, L3_USERNAME) == false)
9653 {
9654 SmPrintNodeInfo(b, &t.NodeInfo);
9655 }
9656
9657 LvInsertEnd(b, hWnd, L_STATUS);
9658
9659 FreeRpcSessionStatus(&t);
9660
9661 return true;
9662 }
9663
9664 // Session Management dialog procedure
SmSessionDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)9665 UINT SmSessionDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
9666 {
9667 SM_HUB *s = (SM_HUB *)param;
9668 wchar_t *tmp;
9669 wchar_t tmp2[MAX_SIZE];
9670 char name[MAX_SIZE];
9671 NMHDR *n;
9672 SM_SESSION_STATUS status;
9673 // Validate arguments
9674 if (hWnd == NULL)
9675 {
9676 return 0;
9677 }
9678
9679 tmp = LvGetSelectedStr(hWnd, L_LIST, 0);
9680 UniToStr(name, sizeof(name), tmp);
9681
9682 switch (msg)
9683 {
9684 case WM_INITDIALOG:
9685 // Initialize
9686 SmSessionDlgInit(hWnd, s);
9687 break;
9688
9689 case WM_COMMAND:
9690 switch (wParam)
9691 {
9692 case IDOK:
9693 if (IsEnable(hWnd, IDOK))
9694 {
9695 // Session status display
9696 UniFormat(tmp2, sizeof(tmp2), _UU("SM_SESS_STATUS_CAPTION"), name);
9697 Zero(&status, sizeof(status));
9698 status.Hub = s;
9699 status.SessionName = name;
9700 SmStatusDlg(hWnd, s->p, &status, true, true, tmp2, ICO_VPN,
9701 NULL, SmRefreshSessionStatus);
9702 }
9703 break;
9704
9705 case B_DISCONNECT:
9706 // Disconnect
9707 if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
9708 _UU("SM_SESS_DISCONNECT_MSG"), name) == IDYES)
9709 {
9710 RPC_DELETE_SESSION t;
9711 Zero(&t, sizeof(t));
9712 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
9713 StrCpy(t.Name, sizeof(t.Name), name);
9714
9715 if (CALL(hWnd, ScDeleteSession(s->Rpc, &t)))
9716 {
9717 SmSessionDlgRefresh(hWnd, s);
9718 }
9719 }
9720 break;
9721
9722 case B_REFRESH:
9723 // Update
9724 SmSessionDlgRefresh(hWnd, s);
9725 break;
9726
9727 case B_SESSION_IP_TABLE:
9728 // IP table
9729 SmIpTableDlg(hWnd, s, name);
9730 break;
9731
9732 case B_SESSION_MAC_TABLE:
9733 // MAC table
9734 SmMacTableDlg(hWnd, s, name);
9735 break;
9736
9737 case B_MAC_TABLE:
9738 // MAC Table List
9739 SmMacTableDlg(hWnd, s, NULL);
9740 break;
9741
9742 case B_IP_TABLE:
9743 // IP Table List
9744 SmIpTableDlg(hWnd, s, NULL);
9745 break;
9746
9747 case IDCANCEL:
9748 // Cancel button
9749 Close(hWnd);
9750 break;
9751 }
9752 break;
9753
9754 case WM_NOTIFY:
9755 n = (NMHDR *)lParam;
9756 switch (n->code)
9757 {
9758 case LVN_ITEMCHANGED:
9759 switch (n->idFrom)
9760 {
9761 case L_LIST:
9762 SmSessionDlgUpdate(hWnd, s);
9763 break;
9764 }
9765 break;
9766 }
9767 break;
9768
9769 case WM_CLOSE:
9770 EndDialog(hWnd, false);
9771 break;
9772 }
9773
9774 Free(tmp);
9775
9776 LvStandardHandler(hWnd, msg, wParam, lParam, L_LIST);
9777
9778 return 0;
9779 }
9780
9781 // Session Management dialog
SmSessionDlg(HWND hWnd,SM_HUB * s)9782 void SmSessionDlg(HWND hWnd, SM_HUB *s)
9783 {
9784 // Validate arguments
9785 if (hWnd == NULL || s == NULL)
9786 {
9787 return;
9788 }
9789
9790 Dialog(hWnd, D_SM_SESSION, SmSessionDlgProc, s);
9791 }
9792
9793 // Certificate List Update
SmCaDlgRefresh(HWND hWnd,SM_HUB * s)9794 void SmCaDlgRefresh(HWND hWnd, SM_HUB *s)
9795 {
9796 LVB *b;
9797 UINT i;
9798 RPC_HUB_ENUM_CA t;
9799 // Validate arguments
9800 if (hWnd == NULL || s == NULL)
9801 {
9802 return;
9803 }
9804
9805 Zero(&t, sizeof(t));
9806 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
9807 if (CALL(hWnd, ScEnumCa(s->Rpc, &t)) == false)
9808 {
9809 EndDialog(hWnd, false);
9810 return;
9811 }
9812
9813 b = LvInsertStart();
9814
9815 for (i = 0;i < t.NumCa;i++)
9816 {
9817 wchar_t tmp[MAX_SIZE];
9818 RPC_HUB_ENUM_CA_ITEM *e = &t.Ca[i];
9819
9820 GetDateStrEx64(tmp, sizeof(tmp), SystemToLocal64(e->Expires), NULL);
9821
9822 LvInsertAdd(b, ICO_SERVER_CERT, (void *)e->Key, 3,
9823 e->SubjectName, e->IssuerName, tmp);
9824 }
9825
9826 LvInsertEnd(b, hWnd, L_CERT);
9827
9828 FreeRpcHubEnumCa(&t);
9829
9830 SmCaDlgUpdate(hWnd, s);
9831 }
9832
9833 // Initialize
SmCaDlgInit(HWND hWnd,SM_HUB * s)9834 void SmCaDlgInit(HWND hWnd, SM_HUB *s)
9835 {
9836 // Validate arguments
9837 if (hWnd == NULL || s == NULL)
9838 {
9839 return;
9840 }
9841
9842 SetIcon(hWnd, 0, ICO_SERVER_CERT);
9843
9844 LvInit(hWnd, L_CERT);
9845 LvInsertColumn(hWnd, L_CERT, 0, _UU("CM_CERT_COLUMN_1"), 190);
9846 LvInsertColumn(hWnd, L_CERT, 1, _UU("CM_CERT_COLUMN_2"), 190);
9847 LvInsertColumn(hWnd, L_CERT, 2, _UU("CM_CERT_COLUMN_3"), 160);
9848
9849 SmCaDlgRefresh(hWnd, s);
9850 }
9851
9852 // Update the control
SmCaDlgUpdate(HWND hWnd,SM_HUB * s)9853 void SmCaDlgUpdate(HWND hWnd, SM_HUB *s)
9854 {
9855 // Validate arguments
9856 if (hWnd == NULL || s == NULL)
9857 {
9858 return;
9859 }
9860
9861 SetEnable(hWnd, B_DELETE, LvIsSelected(hWnd, L_CERT));
9862 SetEnable(hWnd, IDOK, LvIsSelected(hWnd, L_CERT));
9863 }
9864
9865 // OK
SmCaDlgOnOk(HWND hWnd,SM_HUB * s)9866 void SmCaDlgOnOk(HWND hWnd, SM_HUB *s)
9867 {
9868 // Validate arguments
9869 if (hWnd == NULL || s == NULL)
9870 {
9871 return;
9872 }
9873 }
9874
9875 // CA Adding dialog
SmCaDlgAdd(HWND hWnd,SM_HUB * s)9876 bool SmCaDlgAdd(HWND hWnd, SM_HUB *s)
9877 {
9878 X *x;
9879 RPC_HUB_ADD_CA t;
9880 // Validate arguments
9881 if (hWnd == NULL || s == NULL)
9882 {
9883 return false;
9884 }
9885
9886 if (CmLoadXFromFileOrSecureCard(hWnd, &x) == false)
9887 {
9888 return false;
9889 }
9890
9891 Zero(&t, sizeof(t));
9892 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
9893 t.Cert = x;
9894
9895 if (CALL(hWnd, ScAddCa(s->Rpc, &t)) == false)
9896 {
9897 return false;
9898 }
9899
9900 FreeRpcHubAddCa(&t);
9901
9902 return true;
9903 }
9904
9905 // CA List dialog procedure
SmCaDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)9906 UINT SmCaDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
9907 {
9908 NMHDR *n;
9909 SM_HUB *s = (SM_HUB *)param;
9910 UINT i, key;
9911 // Validate arguments
9912 if (hWnd == NULL)
9913 {
9914 return 0;
9915 }
9916
9917 switch (msg)
9918 {
9919 case WM_INITDIALOG:
9920 // Initialize
9921 SmCaDlgInit(hWnd, s);
9922 break;
9923
9924 case WM_COMMAND:
9925 switch (wParam)
9926 {
9927 case B_IMPORT:
9928 // Add
9929 if (SmCaDlgAdd(hWnd, s))
9930 {
9931 SmCaDlgRefresh(hWnd, s);
9932 }
9933 break;
9934
9935 case B_DELETE:
9936 // Delete
9937 i = LvGetSelected(hWnd, L_CERT);
9938 if (i != INFINITE)
9939 {
9940 key = (UINT)LvGetParam(hWnd, L_CERT, i);
9941 if (key != 0)
9942 {
9943 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
9944 _UU("CM_CERT_DELETE_MSG")) == IDYES)
9945 {
9946 RPC_HUB_DELETE_CA t;
9947 Zero(&t, sizeof(t));
9948 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
9949 t.Key = key;
9950
9951 if (CALL(hWnd, ScDeleteCa(s->Rpc, &t)))
9952 {
9953 SmCaDlgRefresh(hWnd, s);
9954 }
9955 }
9956 }
9957 }
9958 break;
9959
9960 case IDOK:
9961 // Display
9962 i = LvGetSelected(hWnd, L_CERT);
9963 if (i != INFINITE)
9964 {
9965 key = (UINT)LvGetParam(hWnd, L_CERT, i);
9966 if (key != 0)
9967 {
9968 RPC_HUB_GET_CA t;
9969 Zero(&t, sizeof(t));
9970 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
9971 t.Key = key;
9972
9973 if (CALL(hWnd, ScGetCa(s->Rpc, &t)))
9974 {
9975 CertDlg(hWnd, t.Cert, NULL, true);
9976 FreeRpcHubGetCa(&t);
9977 }
9978 }
9979 }
9980 break;
9981
9982 case IDCANCEL:
9983 // Cancel button
9984 Close(hWnd);
9985 break;
9986 }
9987 break;
9988
9989 case WM_NOTIFY:
9990 n = (NMHDR *)lParam;
9991 switch (n->idFrom)
9992 {
9993 case L_CERT:
9994 switch (n->code)
9995 {
9996 case LVN_ITEMCHANGED:
9997 SmCaDlgUpdate(hWnd, s);
9998 break;
9999 }
10000 break;
10001 }
10002 break;
10003
10004 case WM_CLOSE:
10005 EndDialog(hWnd, false);
10006 break;
10007 }
10008
10009 LvStandardHandler(hWnd, msg, wParam, lParam, L_CERT);
10010
10011 return 0;
10012 }
10013
10014 // CA List dialog box
SmCaDlg(HWND hWnd,SM_HUB * s)10015 void SmCaDlg(HWND hWnd, SM_HUB *s)
10016 {
10017 // Validate arguments
10018 if (hWnd == NULL || s == NULL)
10019 {
10020 return;
10021 }
10022
10023 Dialog(hWnd, D_SM_CA, SmCaDlgProc, s);
10024 }
10025
10026 // Initialize
SmLogDlgInit(HWND hWnd,SM_HUB * s)10027 void SmLogDlgInit(HWND hWnd, SM_HUB *s)
10028 {
10029 RPC_HUB_LOG t;
10030 // Validate arguments
10031 if (hWnd == NULL || s == NULL)
10032 {
10033 return;
10034 }
10035
10036 SetIcon(hWnd, 0, ICO_LOG2);
10037
10038 FormatText(hWnd, S_TITLE, s->HubName);
10039
10040 CbSetHeight(hWnd, C_SEC_SWITCH, 18);
10041 CbSetHeight(hWnd, C_PACKET_SWITCH, 18);
10042
10043 // Initialize the control
10044 CbAddStr(hWnd, C_SEC_SWITCH, _UU("SM_LOG_SWITCH_0"), 0);
10045 CbAddStr(hWnd, C_SEC_SWITCH, _UU("SM_LOG_SWITCH_1"), 1);
10046 CbAddStr(hWnd, C_SEC_SWITCH, _UU("SM_LOG_SWITCH_2"), 2);
10047 CbAddStr(hWnd, C_SEC_SWITCH, _UU("SM_LOG_SWITCH_3"), 3);
10048 CbAddStr(hWnd, C_SEC_SWITCH, _UU("SM_LOG_SWITCH_4"), 4);
10049 CbAddStr(hWnd, C_SEC_SWITCH, _UU("SM_LOG_SWITCH_5"), 5);
10050 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_0"), 0);
10051 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_1"), 1);
10052 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_2"), 2);
10053 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_3"), 3);
10054 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_4"), 4);
10055 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_5"), 5);
10056
10057 // Get the log settings
10058 Zero(&t, sizeof(t));
10059 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10060 if (CALL(hWnd, ScGetHubLog(s->Rpc, &t)) == false)
10061 {
10062 EndDialog(hWnd, false);
10063 return;
10064 }
10065
10066 Check(hWnd, B_SEC, t.LogSetting.SaveSecurityLog);
10067 CbSelect(hWnd, C_SEC_SWITCH, t.LogSetting.SecurityLogSwitchType);
10068
10069 Check(hWnd, B_PACKET, t.LogSetting.SavePacketLog);
10070 CbSelect(hWnd, C_PACKET_SWITCH, t.LogSetting.PacketLogSwitchType);
10071
10072 Check(hWnd, B_PACKET_0_0, t.LogSetting.PacketLogConfig[0] == 0);
10073 Check(hWnd, B_PACKET_0_1, t.LogSetting.PacketLogConfig[0] == 1);
10074 Check(hWnd, B_PACKET_0_2, t.LogSetting.PacketLogConfig[0] == 2);
10075
10076 Check(hWnd, B_PACKET_1_0, t.LogSetting.PacketLogConfig[1] == 0);
10077 Check(hWnd, B_PACKET_1_1, t.LogSetting.PacketLogConfig[1] == 1);
10078 Check(hWnd, B_PACKET_1_2, t.LogSetting.PacketLogConfig[1] == 2);
10079
10080 Check(hWnd, B_PACKET_2_0, t.LogSetting.PacketLogConfig[2] == 0);
10081 Check(hWnd, B_PACKET_2_1, t.LogSetting.PacketLogConfig[2] == 1);
10082 Check(hWnd, B_PACKET_2_2, t.LogSetting.PacketLogConfig[2] == 2);
10083
10084 Check(hWnd, B_PACKET_3_0, t.LogSetting.PacketLogConfig[3] == 0);
10085 Check(hWnd, B_PACKET_3_1, t.LogSetting.PacketLogConfig[3] == 1);
10086 Check(hWnd, B_PACKET_3_2, t.LogSetting.PacketLogConfig[3] == 2);
10087
10088 Check(hWnd, B_PACKET_4_0, t.LogSetting.PacketLogConfig[4] == 0);
10089 Check(hWnd, B_PACKET_4_1, t.LogSetting.PacketLogConfig[4] == 1);
10090 Check(hWnd, B_PACKET_4_2, t.LogSetting.PacketLogConfig[4] == 2);
10091
10092 Check(hWnd, B_PACKET_5_0, t.LogSetting.PacketLogConfig[5] == 0);
10093 Check(hWnd, B_PACKET_5_1, t.LogSetting.PacketLogConfig[5] == 1);
10094 Check(hWnd, B_PACKET_5_2, t.LogSetting.PacketLogConfig[5] == 2);
10095
10096 Check(hWnd, B_PACKET_6_0, t.LogSetting.PacketLogConfig[6] == 0);
10097 Check(hWnd, B_PACKET_6_1, t.LogSetting.PacketLogConfig[6] == 1);
10098 Check(hWnd, B_PACKET_6_2, t.LogSetting.PacketLogConfig[6] == 2);
10099
10100 Check(hWnd, B_PACKET_7_0, t.LogSetting.PacketLogConfig[7] == 0);
10101 Check(hWnd, B_PACKET_7_1, t.LogSetting.PacketLogConfig[7] == 1);
10102 Check(hWnd, B_PACKET_7_2, t.LogSetting.PacketLogConfig[7] == 2);
10103
10104 SmLogDlgUpdate(hWnd, s);
10105 }
10106
10107 // Update the control
SmLogDlgUpdate(HWND hWnd,SM_HUB * s)10108 void SmLogDlgUpdate(HWND hWnd, SM_HUB *s)
10109 {
10110 bool b;
10111 // Validate arguments
10112 if (hWnd == NULL || s == NULL)
10113 {
10114 return;
10115 }
10116
10117 b = IsChecked(hWnd, B_SEC);
10118 SetEnable(hWnd, S_SEC, b);
10119 SetEnable(hWnd, C_SEC_SWITCH, b);
10120
10121 b = IsChecked(hWnd, B_PACKET);
10122 SetEnable(hWnd, S_PACKET, b);
10123 SetEnable(hWnd, C_PACKET_SWITCH, b);
10124 SetEnable(hWnd, S_PACKET_0, b);
10125 SetEnable(hWnd, S_PACKET_1, b);
10126 SetEnable(hWnd, S_PACKET_2, b);
10127 SetEnable(hWnd, S_PACKET_3, b);
10128 SetEnable(hWnd, S_PACKET_4, b);
10129 SetEnable(hWnd, S_PACKET_5, b);
10130 SetEnable(hWnd, S_PACKET_6, b);
10131 SetEnable(hWnd, S_PACKET_7, b);
10132 SetEnable(hWnd, B_PACKET_0_0, b); SetEnable(hWnd, B_PACKET_0_1, b); SetEnable(hWnd, B_PACKET_0_2, b);
10133 SetEnable(hWnd, B_PACKET_1_0, b); SetEnable(hWnd, B_PACKET_1_1, b); SetEnable(hWnd, B_PACKET_1_2, b);
10134 SetEnable(hWnd, B_PACKET_2_0, b); SetEnable(hWnd, B_PACKET_2_1, b); SetEnable(hWnd, B_PACKET_2_2, b);
10135 SetEnable(hWnd, B_PACKET_3_0, b); SetEnable(hWnd, B_PACKET_3_1, b); SetEnable(hWnd, B_PACKET_3_2, b);
10136 SetEnable(hWnd, B_PACKET_4_0, b); SetEnable(hWnd, B_PACKET_4_1, b); SetEnable(hWnd, B_PACKET_4_2, b);
10137 SetEnable(hWnd, B_PACKET_5_0, b); SetEnable(hWnd, B_PACKET_5_1, b); SetEnable(hWnd, B_PACKET_5_2, b);
10138 SetEnable(hWnd, B_PACKET_6_0, b); SetEnable(hWnd, B_PACKET_6_1, b); SetEnable(hWnd, B_PACKET_6_2, b);
10139 SetEnable(hWnd, B_PACKET_7_0, b); SetEnable(hWnd, B_PACKET_7_1, b); SetEnable(hWnd, B_PACKET_7_2, b);
10140 }
10141
10142 // OK
SmLogDlgOnOk(HWND hWnd,SM_HUB * s)10143 void SmLogDlgOnOk(HWND hWnd, SM_HUB *s)
10144 {
10145 HUB_LOG g;
10146 RPC_HUB_LOG t;
10147 // Validate arguments
10148 if (hWnd == NULL || s == NULL)
10149 {
10150 return;
10151 }
10152
10153 Zero(&g, sizeof(g));
10154 g.SaveSecurityLog = IsChecked(hWnd, B_SEC);
10155 g.SavePacketLog = IsChecked(hWnd, B_PACKET);
10156 g.SecurityLogSwitchType = CbGetSelect(hWnd, C_SEC_SWITCH);
10157 g.PacketLogSwitchType = CbGetSelect(hWnd, C_PACKET_SWITCH);
10158
10159 g.PacketLogConfig[0] = IsChecked(hWnd, B_PACKET_0_0) ? 0 : IsChecked(hWnd, B_PACKET_0_1) ? 1 : 2;
10160 g.PacketLogConfig[1] = IsChecked(hWnd, B_PACKET_1_0) ? 0 : IsChecked(hWnd, B_PACKET_1_1) ? 1 : 2;
10161 g.PacketLogConfig[2] = IsChecked(hWnd, B_PACKET_2_0) ? 0 : IsChecked(hWnd, B_PACKET_2_1) ? 1 : 2;
10162 g.PacketLogConfig[3] = IsChecked(hWnd, B_PACKET_3_0) ? 0 : IsChecked(hWnd, B_PACKET_3_1) ? 1 : 2;
10163 g.PacketLogConfig[4] = IsChecked(hWnd, B_PACKET_4_0) ? 0 : IsChecked(hWnd, B_PACKET_4_1) ? 1 : 2;
10164 g.PacketLogConfig[5] = IsChecked(hWnd, B_PACKET_5_0) ? 0 : IsChecked(hWnd, B_PACKET_5_1) ? 1 : 2;
10165 g.PacketLogConfig[6] = IsChecked(hWnd, B_PACKET_6_0) ? 0 : IsChecked(hWnd, B_PACKET_6_1) ? 1 : 2;
10166 g.PacketLogConfig[7] = IsChecked(hWnd, B_PACKET_7_0) ? 0 : IsChecked(hWnd, B_PACKET_7_1) ? 1 : 2;
10167
10168 Zero(&t, sizeof(t));
10169 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10170 Copy(&t.LogSetting, &g, sizeof(HUB_LOG));
10171
10172 if (CALL(hWnd, ScSetHubLog(s->Rpc, &t)) == false)
10173 {
10174 return;
10175 }
10176
10177 EndDialog(hWnd, true);
10178 }
10179
10180 // Log storage settings dialog
SmLogDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)10181 UINT SmLogDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
10182 {
10183 SM_HUB *s = (SM_HUB *)param;
10184 // Validate arguments
10185 if (hWnd == NULL)
10186 {
10187 return 0;
10188 }
10189
10190 switch (msg)
10191 {
10192 case WM_INITDIALOG:
10193 // Initialize
10194 SmLogDlgInit(hWnd, s);
10195 break;
10196
10197 case WM_COMMAND:
10198 switch (LOWORD(wParam))
10199 {
10200 case B_SEC:
10201 case B_PACKET:
10202 SmLogDlgUpdate(hWnd, s);
10203 break;
10204 }
10205
10206 switch (wParam)
10207 {
10208 case IDOK:
10209 // [OK] button
10210 SmLogDlgOnOk(hWnd, s);
10211 break;
10212
10213 case IDCANCEL:
10214 // Cancel button
10215 Close(hWnd);
10216 break;
10217 }
10218 break;
10219
10220 case WM_CLOSE:
10221 EndDialog(hWnd, false);
10222 break;
10223 }
10224
10225 return 0;
10226 }
10227
10228 // Show the status of the cascade connection
SmRefreshLinkStatus(HWND hWnd,SM_SERVER * s,void * param)10229 bool SmRefreshLinkStatus(HWND hWnd, SM_SERVER *s, void *param)
10230 {
10231 SM_LINK *k = (SM_LINK *)param;
10232 RPC_LINK_STATUS t;
10233 LVB *b;
10234 // Validate arguments
10235 if (hWnd == NULL || s == NULL || param == NULL)
10236 {
10237 return false;
10238 }
10239
10240 Zero(&t, sizeof(t));
10241 StrCpy(t.HubName, sizeof(t.HubName), k->Hub->HubName);
10242 UniStrCpy(t.AccountName, sizeof(t.AccountName), k->AccountName);
10243
10244 if (CALL(hWnd, ScGetLinkStatus(s->Rpc, &t)) == false)
10245 {
10246 return false;
10247 }
10248
10249 b = LvInsertStart();
10250
10251 CmPrintStatusToListView(b, &t.Status);
10252
10253 LvInsertEnd(b, hWnd, L_STATUS);
10254
10255 FreeRpcLinkStatus(&t);
10256
10257 return true;
10258 }
10259
10260 // Edit the link
SmLinkEdit(HWND hWnd,SM_HUB * s,wchar_t * name)10261 bool SmLinkEdit(HWND hWnd, SM_HUB *s, wchar_t *name)
10262 {
10263 CM_ACCOUNT a;
10264 RPC_CREATE_LINK t;
10265 bool ret = false;
10266 // Validate arguments
10267 if (hWnd == NULL || s == NULL || name == NULL)
10268 {
10269 return false;
10270 }
10271
10272 Zero(&a, sizeof(a));
10273 Zero(&t, sizeof(t));
10274
10275 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10276 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
10277 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), name);
10278
10279 if (CALL(hWnd, ScGetLink(s->Rpc, &t)) == false)
10280 {
10281 return false;
10282 }
10283
10284 a.Hub = s;
10285 a.EditMode = true;
10286 a.LinkMode = true;
10287 a.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
10288 a.OnlineFlag = t.Online;
10289 Copy(a.ClientOption, t.ClientOption, sizeof(CLIENT_OPTION));
10290 a.ClientAuth = CopyClientAuth(t.ClientAuth);
10291 Copy(&a.Policy, &t.Policy, sizeof(POLICY));
10292 a.CheckServerCert = t.CheckServerCert;
10293 a.ServerCert = CloneX(t.ServerCert);
10294 a.HideTrustCert = GetCapsBool(s->p->CapsList, "b_support_config_hub");
10295 FreeRpcCreateLink(&t);
10296
10297 a.PolicyVer = s->p->PolicyVer;
10298
10299 if (GetCapsBool(s->p->CapsList, "b_support_cascade_client_cert") == false)
10300 {
10301 a.HideClientCertAuth = true;
10302 }
10303
10304 a.HideSecureAuth = true;
10305
10306 ret = CmEditAccountDlg(hWnd, &a);
10307
10308 FreeX(a.ServerCert);
10309 Free(a.ClientOption);
10310 CiFreeClientAuth(a.ClientAuth);
10311
10312 return ret;
10313 }
10314
10315 // Create a new link
SmLinkCreate(HWND hWnd,SM_HUB * s)10316 bool SmLinkCreate(HWND hWnd, SM_HUB *s)
10317 {
10318 return SmLinkCreateEx(hWnd, s, false);
10319 }
SmLinkCreateEx(HWND hWnd,SM_HUB * s,bool connectNow)10320 bool SmLinkCreateEx(HWND hWnd, SM_HUB *s, bool connectNow)
10321 {
10322 CM_ACCOUNT a;
10323 bool ret = false;;
10324 // Validate arguments
10325 if (hWnd == NULL || s == NULL)
10326 {
10327 return false;
10328 }
10329
10330 Zero(&a, sizeof(a));
10331
10332 a.Hub = s;
10333 a.EditMode = false;
10334 a.LinkMode = true;
10335 a.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
10336 a.OnlineFlag = false;
10337 a.ClientAuth = ZeroMalloc(sizeof(CLIENT_AUTH));
10338 a.ClientAuth->AuthType = CLIENT_AUTHTYPE_PASSWORD;
10339 Copy(&a.Policy, GetDefaultPolicy(), sizeof(POLICY));
10340 a.ClientOption->Port = 443; // Default port number
10341 a.ClientOption->NumRetry = INFINITE;
10342 a.ClientOption->RetryInterval = 15;
10343 a.ClientOption->MaxConnection = 8;
10344 a.ClientOption->UseEncrypt = true;
10345 a.ClientOption->HalfConnection = false;
10346 a.ClientOption->AdditionalConnectionInterval = 1;
10347 a.ClientOption->RequireBridgeRoutingMode = true;
10348 a.Link_ConnectNow = connectNow;
10349
10350 a.PolicyVer = s->p->PolicyVer;
10351
10352 if (GetCapsBool(s->p->CapsList, "b_support_cascade_client_cert") == false)
10353 {
10354 a.HideClientCertAuth = true;
10355 }
10356
10357 a.HideSecureAuth = true;
10358
10359 ret = CmEditAccountDlg(hWnd, &a);
10360
10361 FreeX(a.ServerCert);
10362 Free(a.ClientOption);
10363 CiFreeClientAuth(a.ClientAuth);
10364
10365 return ret;
10366 }
10367
10368 // Initialize
SmLinkDlgInit(HWND hWnd,SM_HUB * s)10369 void SmLinkDlgInit(HWND hWnd, SM_HUB *s)
10370 {
10371 // Validate arguments
10372 if (hWnd == NULL || s == NULL)
10373 {
10374 return;
10375 }
10376
10377 SetIcon(hWnd, 0, ICO_LINK);
10378
10379 FormatText(hWnd, 0, s->HubName);
10380
10381 LvInit(hWnd, L_LINK);
10382
10383 LvInsertColumn(hWnd, L_LINK, 0, _UU("SM_LINK_COLUMN_1"), 120);
10384 LvInsertColumn(hWnd, L_LINK, 1, _UU("SM_LINK_COLUMN_2"), 150);
10385 LvInsertColumn(hWnd, L_LINK, 2, _UU("SM_LINK_COLUMN_3"), 180);
10386 LvInsertColumn(hWnd, L_LINK, 3, _UU("SM_LINK_COLUMN_4"), 130);
10387 LvInsertColumn(hWnd, L_LINK, 4, _UU("SM_LINK_COLUMN_5"), 130);
10388
10389 LvSetStyle(hWnd, L_LINK, LVS_EX_GRIDLINES);
10390
10391 SmLinkDlgRefresh(hWnd, s);
10392 }
10393
10394 // Update the controls
SmLinkDlgUpdate(HWND hWnd,SM_HUB * s)10395 void SmLinkDlgUpdate(HWND hWnd, SM_HUB *s)
10396 {
10397 bool ok = true;
10398 bool online = false;
10399 // Validate arguments
10400 if (hWnd == NULL || s == NULL)
10401 {
10402 return;
10403 }
10404
10405 if (LvIsSelected(hWnd, L_LINK) == false || LvIsMultiMasked(hWnd, L_LINK))
10406 {
10407 ok = false;
10408 }
10409 else
10410 {
10411 online = (bool)LvGetParam(hWnd, L_LINK, LvGetSelected(hWnd, L_LINK));
10412 }
10413
10414 SetEnable(hWnd, B_EDIT, ok);
10415 SetEnable(hWnd, B_ONLINE, ok && (online == false));
10416 SetEnable(hWnd, B_OFFLINE, ok && online);
10417 SetEnable(hWnd, IDOK, ok && online);
10418 SetEnable(hWnd, B_DELETE, ok);
10419 SetEnable(hWnd, B_RENAME, ok);
10420 }
10421
10422 // Content update
SmLinkDlgRefresh(HWND hWnd,SM_HUB * s)10423 void SmLinkDlgRefresh(HWND hWnd, SM_HUB *s)
10424 {
10425 LVB *b;
10426 RPC_ENUM_LINK t;
10427 UINT i;
10428 // Validate arguments
10429 if (hWnd == NULL || s == NULL)
10430 {
10431 return;
10432 }
10433
10434 Zero(&t, sizeof(t));
10435 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10436 if (CALL(hWnd, ScEnumLink(s->Rpc, &t)) == false)
10437 {
10438 EndDialog(hWnd, false);
10439 return;
10440 }
10441
10442 b = LvInsertStart();
10443
10444 for (i = 0;i < t.NumLink;i++)
10445 {
10446 RPC_ENUM_LINK_ITEM *e = &t.Links[i];
10447 wchar_t tmp1[MAX_SIZE];
10448 wchar_t tmp2[MAX_SIZE];
10449 wchar_t tmp3[MAX_SIZE];
10450 wchar_t tmp4[MAX_SIZE];
10451 UINT icon = ICO_CASCADE;
10452
10453 GetDateTimeStrEx64(tmp1, sizeof(tmp1), SystemToLocal64(e->ConnectedTime), NULL);
10454 StrToUni(tmp2, sizeof(tmp2), e->Hostname);
10455 StrToUni(tmp3, sizeof(tmp3), e->HubName);
10456
10457 if (e->Online == false)
10458 {
10459 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_LINK_STATUS_OFFLINE"));
10460 }
10461 else
10462 {
10463 if (e->Connected)
10464 {
10465 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_LINK_STATUS_ONLINE"));
10466 }
10467 else
10468 {
10469 if (e->LastError != 0)
10470 {
10471 UniFormat(tmp4, sizeof(tmp4), _UU("SM_LINK_STATUS_ERROR"), e->LastError, _E(e->LastError));
10472 }
10473 else
10474 {
10475 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_LINK_CONNECTING"));
10476 }
10477 }
10478 }
10479
10480 if (e->Online == false)
10481 {
10482 icon = ICO_CASCADE_OFFLINE;
10483 }
10484 else
10485 {
10486 if (e->Connected == false && e->LastError != 0)
10487 {
10488 icon = ICO_CASCADE_ERROR;
10489 }
10490 else
10491 {
10492 icon = ICO_CASCADE;
10493 }
10494 }
10495
10496 LvInsertAdd(b,
10497 icon, (void *)e->Online, 5,
10498 e->AccountName, tmp4, tmp1, tmp2, tmp3);
10499 }
10500
10501 LvInsertEnd(b, hWnd, L_LINK);
10502
10503 FreeRpcEnumLink(&t);
10504
10505 SmLinkDlgUpdate(hWnd, s);
10506 }
10507
10508
10509 // Link List dialog procedure
SmLinkDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)10510 UINT SmLinkDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
10511 {
10512 SM_HUB *s = (SM_HUB *)param;
10513 wchar_t *str;
10514 NMHDR *n;
10515 NMLVDISPINFOW *disp_info;
10516 NMLVKEYDOWN *key;
10517 // Validate arguments
10518 if (hWnd == NULL)
10519 {
10520 return 0;
10521 }
10522
10523 str = LvGetSelectedStr(hWnd, L_LINK, 0);
10524
10525 switch (msg)
10526 {
10527 case WM_INITDIALOG:
10528 // Initialize
10529 SmLinkDlgInit(hWnd, s);
10530
10531 if (link_create_now)
10532 {
10533 if (SmLinkCreateEx(hWnd, s, true))
10534 {
10535 SmLinkDlgRefresh(hWnd, s);
10536 }
10537 }
10538
10539 SetTimer(hWnd, 1, 1000, NULL);
10540 break;
10541
10542 case WM_TIMER:
10543 switch (wParam)
10544 {
10545 case 1:
10546 if (IsEnable(hWnd, 0))
10547 {
10548 KillTimer(hWnd, 1);
10549 SmLinkDlgRefresh(hWnd, s);
10550 SetTimer(hWnd, 1, 1000, NULL);
10551 }
10552 break;
10553 }
10554 break;
10555
10556 case WM_COMMAND:
10557 switch (wParam)
10558 {
10559 case B_CREATE:
10560 // Create new
10561 if (SmLinkCreate(hWnd, s))
10562 {
10563 SmLinkDlgRefresh(hWnd, s);
10564 }
10565 break;
10566
10567 case B_EDIT:
10568 // Edit
10569 if (str != NULL)
10570 {
10571 if (SmLinkEdit(hWnd, s, str))
10572 {
10573 SmLinkDlgRefresh(hWnd, s);
10574 }
10575 }
10576 break;
10577
10578 case B_ONLINE:
10579 // Online
10580 if (str != NULL)
10581 {
10582 RPC_LINK t;
10583 Zero(&t, sizeof(t));
10584 UniStrCpy(t.AccountName, sizeof(t.AccountName), str);
10585 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10586
10587 if (CALL(hWnd, ScSetLinkOnline(s->Rpc, &t)))
10588 {
10589 SmLinkDlgRefresh(hWnd, s);
10590 }
10591 }
10592 break;
10593
10594 case B_OFFLINE:
10595 // Offline
10596 if (str != NULL)
10597 {
10598 RPC_LINK t;
10599 Zero(&t, sizeof(t));
10600 UniStrCpy(t.AccountName, sizeof(t.AccountName), str);
10601 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10602
10603 if (MsgBoxEx(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2,
10604 _UU("SM_LINK_OFFLINE_MSG"), t.AccountName) == IDYES)
10605 {
10606 if (CALL(hWnd, ScSetLinkOffline(s->Rpc, &t)))
10607 {
10608 SmLinkDlgRefresh(hWnd, s);
10609 }
10610 }
10611 }
10612 break;
10613
10614 case IDOK:
10615 // Status
10616 if (str != NULL)
10617 {
10618 wchar_t tmp[MAX_SIZE];
10619 SM_LINK t;
10620 Zero(&t, sizeof(t));
10621 t.Hub = s;
10622 t.AccountName = str;
10623 UniFormat(tmp, sizeof(tmp), _UU("SM_LINK_STATUS_CAPTION"), str);
10624 SmStatusDlg(hWnd, s->p, &t, true, true, tmp,
10625 ICO_CASCADE, NULL, SmRefreshLinkStatus);
10626 }
10627 break;
10628
10629 case B_DELETE:
10630 // Delete
10631 if (str != NULL)
10632 {
10633 RPC_LINK t;
10634 Zero(&t, sizeof(t));
10635 UniStrCpy(t.AccountName, sizeof(t.AccountName), str);
10636 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10637
10638 if (MsgBoxEx(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2,
10639 _UU("SM_LINK_DELETE_MSG"), t.AccountName) == IDYES)
10640 {
10641 if (CALL(hWnd, ScDeleteLink(s->Rpc, &t)))
10642 {
10643 SmLinkDlgRefresh(hWnd, s);
10644 }
10645 }
10646 }
10647 break;
10648
10649 case B_REFRESH:
10650 // Update
10651 SmLinkDlgRefresh(hWnd, s);
10652 break;
10653
10654 case IDCANCEL:
10655 // Cancel button
10656 Close(hWnd);
10657 break;
10658
10659 case B_RENAME:
10660 // Change the name
10661 Focus(hWnd, L_LINK);
10662 LvRename(hWnd, L_LINK, LvGetSelected(hWnd, L_LINK));
10663 break;
10664 }
10665 break;
10666
10667 case WM_NOTIFY:
10668 n = (NMHDR *)lParam;
10669 switch (n->idFrom)
10670 {
10671 case L_LINK:
10672 switch (n->code)
10673 {
10674 case LVN_ITEMCHANGED:
10675 // Change the selection state
10676 SmLinkDlgUpdate(hWnd, s);
10677 break;
10678
10679 case LVN_ENDLABELEDITW:
10680 // Change the name
10681 disp_info = (NMLVDISPINFOW *)n;
10682 if (disp_info->item.pszText != NULL)
10683 {
10684 wchar_t *new_name = disp_info->item.pszText;
10685 wchar_t *old_name = LvGetStr(hWnd, L_LINK, disp_info->item.iItem, 0);
10686
10687 if (old_name != NULL)
10688 {
10689 if (UniStrCmp(new_name, old_name) != 0 && UniIsEmptyStr(new_name) == false)
10690 {
10691 RPC_RENAME_LINK t;
10692 Zero(&t, sizeof(t));
10693 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10694 UniStrCpy(t.OldAccountName, sizeof(t.OldAccountName), old_name);
10695 UniStrCpy(t.NewAccountName, sizeof(t.NewAccountName), new_name);
10696 if (CALL(hWnd, ScRenameLink(s->Rpc, &t)))
10697 {
10698 SmLinkDlgRefresh(hWnd, s);
10699 }
10700 }
10701
10702 Free(old_name);
10703 }
10704 }
10705 break;
10706
10707 case LVN_KEYDOWN:
10708 // Keypress
10709 key = (NMLVKEYDOWN *)n;
10710 if (key != NULL)
10711 {
10712 bool ctrl, alt;
10713 UINT code = key->wVKey;
10714 ctrl = (GetKeyState(VK_CONTROL) & 0x8000) == 0 ? false : true;
10715 alt = (GetKeyState(VK_MENU) & 0x8000) == 0 ? false : true;
10716
10717 if (code == VK_F2)
10718 {
10719 Command(hWnd, B_RENAME);
10720 }
10721 }
10722 break;
10723 }
10724 break;
10725 }
10726 break;
10727
10728 case WM_CLOSE:
10729 EndDialog(hWnd, false);
10730 break;
10731 }
10732
10733 Free(str);
10734
10735 LvStandardHandler(hWnd, msg, wParam, lParam, L_LINK);
10736
10737 return 0;
10738 }
10739
10740 // Link List dialog
SmLinkDlg(HWND hWnd,SM_HUB * s)10741 void SmLinkDlg(HWND hWnd, SM_HUB *s)
10742 {
10743 SmLinkDlgEx(hWnd, s, false);
10744 }
SmLinkDlgEx(HWND hWnd,SM_HUB * s,bool createNow)10745 void SmLinkDlgEx(HWND hWnd, SM_HUB *s, bool createNow)
10746 {
10747 // Validate arguments
10748 if (hWnd == NULL || s == NULL)
10749 {
10750 return;
10751 }
10752
10753 link_create_now = createNow;
10754
10755 Dialog(hWnd, D_SM_LINK, SmLinkDlgProc, s);
10756 }
10757
10758 // Initialize
SmRadiusDlgInit(HWND hWnd,SM_HUB * s)10759 void SmRadiusDlgInit(HWND hWnd, SM_HUB *s)
10760 {
10761 RPC_RADIUS t;
10762 // Validate arguments
10763 if (hWnd == NULL || s == NULL)
10764 {
10765 return;
10766 }
10767
10768 SetIcon(hWnd, 0, ICO_TOWER);
10769
10770 FormatText(hWnd, S_TITLE, s->HubName);
10771 FormatText(hWnd, S_RADIUS_7, RADIUS_RETRY_INTERVAL, RADIUS_RETRY_TIMEOUT);
10772
10773 Zero(&t, sizeof(t));
10774 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10775
10776 if (CALL(hWnd, ScGetHubRadius(s->Rpc, &t)) == false)
10777 {
10778 EndDialog(hWnd, false);
10779 return;
10780 }
10781
10782 Check(hWnd, R_USE_RADIUS, StrLen(t.RadiusServerName) != 0);
10783
10784 if (StrLen(t.RadiusServerName) != 0)
10785 {
10786 SetTextA(hWnd, E_HOSTNAME, t.RadiusServerName);
10787 SetIntEx(hWnd, E_PORT, t.RadiusPort);
10788 SetTextA(hWnd, E_SECRET1, t.RadiusSecret);
10789 SetTextA(hWnd, E_SECRET2, t.RadiusSecret);
10790 SetIntEx(hWnd, E_RADIUS_RETRY_INTERVAL, t.RadiusRetryInterval);
10791 FocusEx(hWnd, E_HOSTNAME);
10792 }
10793 else
10794 {
10795 SetInt(hWnd, E_PORT, RADIUS_DEFAULT_PORT);
10796 SetInt(hWnd, E_RADIUS_RETRY_INTERVAL, RADIUS_RETRY_INTERVAL);
10797 }
10798
10799 SmRadiusDlgUpdate(hWnd, s);
10800 }
10801
10802 // Update the control
SmRadiusDlgUpdate(HWND hWnd,SM_HUB * s)10803 void SmRadiusDlgUpdate(HWND hWnd, SM_HUB *s)
10804 {
10805 bool ok = true;
10806 bool b, b1;
10807 char tmp1[MAX_SIZE];
10808 char tmp2[MAX_SIZE];
10809 // Validate arguments
10810 if (hWnd == NULL || s == NULL)
10811 {
10812 return;
10813 }
10814
10815 b1 = GetCapsBool(s->p->CapsList, "b_support_radius_retry_interval_and_several_servers");
10816 if(b1 == false)
10817 {
10818 Hide(hWnd, S_RADIUS_7);
10819 Hide(hWnd, S_RADIUS_8);
10820 Hide(hWnd, S_RADIUS_9);
10821 Hide(hWnd, E_RADIUS_RETRY_INTERVAL);
10822 }
10823
10824 b = IsChecked(hWnd, R_USE_RADIUS);
10825
10826 SetEnable(hWnd, S_RADIUS_1, b);
10827 SetEnable(hWnd, S_RADIUS_2, b);
10828 SetEnable(hWnd, S_RADIUS_3, b);
10829 SetEnable(hWnd, S_RADIUS3, b);
10830 SetEnable(hWnd, S_RADIUS_4, b);
10831 SetEnable(hWnd, S_RADIUS_5, b);
10832 SetEnable(hWnd, S_RADIUS_6, b);
10833 SetEnable(hWnd, S_RADIUS_7, b);
10834 SetEnable(hWnd, S_RADIUS_8, b);
10835 SetEnable(hWnd, S_RADIUS_9, b);
10836 SetEnable(hWnd, E_HOSTNAME, b);
10837 SetEnable(hWnd, E_PORT, b);
10838 SetEnable(hWnd, E_SECRET1, b);
10839 SetEnable(hWnd, E_SECRET2, b);
10840 SetEnable(hWnd, E_RADIUS_RETRY_INTERVAL, b);
10841
10842 if (b)
10843 {
10844 UINT p, m;
10845 GetTxtA(hWnd, E_SECRET1, tmp1, sizeof(tmp1));
10846 GetTxtA(hWnd, E_SECRET2, tmp2, sizeof(tmp2));
10847
10848 if (StrCmp(tmp1, tmp2) != 0)
10849 {
10850 ok = false;
10851 }
10852
10853 if (IsEmpty(hWnd, E_HOSTNAME))
10854 {
10855 ok = false;
10856 }
10857
10858 p = GetInt(hWnd, E_PORT);
10859
10860 if (p == 0 || p >= 65536)
10861 {
10862 ok = false;
10863 }
10864
10865 m = GetInt(hWnd, E_RADIUS_RETRY_INTERVAL);
10866 if (m > RADIUS_RETRY_TIMEOUT || m < RADIUS_RETRY_INTERVAL)
10867 {
10868 ok = false;
10869 }
10870 }
10871
10872 SetEnable(hWnd, IDOK, ok);
10873 }
10874
10875 // [OK] button
SmRadiusDlgOnOk(HWND hWnd,SM_HUB * s)10876 void SmRadiusDlgOnOk(HWND hWnd, SM_HUB *s)
10877 {
10878 RPC_RADIUS t;
10879 // Validate arguments
10880 if (hWnd == NULL || s == NULL)
10881 {
10882 return;
10883 }
10884
10885 Zero(&t, sizeof(t));
10886 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
10887
10888 if (IsChecked(hWnd, R_USE_RADIUS))
10889 {
10890 GetTxtA(hWnd, E_HOSTNAME, t.RadiusServerName, sizeof(t.RadiusServerName));
10891 t.RadiusPort = GetInt(hWnd, E_PORT);
10892 GetTxtA(hWnd, E_SECRET1,t.RadiusSecret, sizeof(t.RadiusSecret));
10893 t.RadiusRetryInterval = GetInt(hWnd, E_RADIUS_RETRY_INTERVAL);
10894 }
10895
10896 if (CALL(hWnd, ScSetHubRadius(s->Rpc, &t)) == false)
10897 {
10898 return;
10899 }
10900
10901 EndDialog(hWnd, true);
10902 }
10903
10904
10905 // Radius dialog procedure
SmRadiusDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)10906 UINT SmRadiusDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
10907 {
10908 SM_HUB *s = (SM_HUB *)param;
10909 // Validate arguments
10910 if (hWnd == NULL)
10911 {
10912 return 0;
10913 }
10914
10915 switch (msg)
10916 {
10917 case WM_INITDIALOG:
10918 // Initialize
10919 SmRadiusDlgInit(hWnd, s);
10920 break;
10921
10922 case WM_COMMAND:
10923 switch (LOWORD(wParam))
10924 {
10925 case E_HOSTNAME:
10926 case E_PORT:
10927 case E_SECRET1:
10928 case E_SECRET2:
10929 case E_RADIUS_RETRY_INTERVAL:
10930 case R_USE_RADIUS:
10931 SmRadiusDlgUpdate(hWnd, s);
10932 break;
10933 }
10934
10935 switch (wParam)
10936 {
10937 case IDOK:
10938 // [OK] button
10939 SmRadiusDlgOnOk(hWnd, s);
10940 break;
10941
10942 case IDCANCEL:
10943 // Cancel button
10944 Close(hWnd);
10945 break;
10946
10947 case R_USE_RADIUS:
10948 if (IsChecked(hWnd, R_USE_RADIUS))
10949 {
10950 FocusEx(hWnd, E_HOSTNAME);
10951 }
10952 break;
10953 }
10954 break;
10955
10956 case WM_CLOSE:
10957 EndDialog(hWnd, false);
10958 break;
10959 }
10960
10961 return 0;
10962 }
10963
10964 // Radius Setup dialog
SmRadiusDlg(HWND hWnd,SM_HUB * s)10965 void SmRadiusDlg(HWND hWnd, SM_HUB *s)
10966 {
10967 // Validate arguments
10968 if (hWnd == NULL || s == NULL)
10969 {
10970 return;
10971 }
10972
10973 Dialog(hWnd, D_SM_RADIUS, SmRadiusDlgProc, s);
10974 }
10975
10976
10977 // Initialize
SmEditAccessInit(HWND hWnd,SM_EDIT_ACCESS * s)10978 void SmEditAccessInit(HWND hWnd, SM_EDIT_ACCESS *s)
10979 {
10980 ACCESS *a;
10981 wchar_t tmp[MAX_SIZE];
10982 // Validate arguments
10983 if (hWnd == NULL || s == NULL)
10984 {
10985 return;
10986 }
10987
10988 SetIcon(hWnd, 0, ICO_PASS);
10989
10990 GetTxt(hWnd, 0, tmp, sizeof(tmp));
10991
10992 UniStrCat(tmp, sizeof(tmp), s->Access->IsIPv6 ? L" (IPv6)" : L" (IPv4)");
10993
10994 SetText(hWnd, 0, tmp);
10995
10996 s->Inited = false;
10997 a = s->Access;
10998
10999 SetText(hWnd, E_NOTE, a->Note);
11000
11001 Check(hWnd, R_DISCARD, a->Discard);
11002 Check(hWnd, R_PASS, a->Discard == false);
11003 SetIntEx(hWnd, E_PRIORITY, a->Priority);
11004
11005 if (a->IsIPv6 == false)
11006 {
11007 // IPv4
11008 if (a->SrcIpAddress == 0 && a->SrcSubnetMask == 0)
11009 {
11010 Check(hWnd, R_SRC_ALL, true);
11011 }
11012 else
11013 {
11014 IpSet(hWnd, E_SRC_IP, a->SrcIpAddress);
11015 IpSet(hWnd, E_SRC_MASK, a->SrcSubnetMask);
11016 }
11017
11018 if (a->DestIpAddress == 0 && a->DestSubnetMask == 0)
11019 {
11020 Check(hWnd, R_DST_ALL, true);
11021 }
11022 else
11023 {
11024 IpSet(hWnd, E_DST_IP, a->DestIpAddress);
11025 IpSet(hWnd, E_DST_MASK, a->DestSubnetMask);
11026 }
11027 }
11028 else
11029 {
11030 // IPv6
11031 if (IsZeroIP6Addr(&a->SrcIpAddress6) && IsZeroIP6Addr(&a->SrcSubnetMask6))
11032 {
11033 Check(hWnd, R_SRC_ALL, true);
11034 }
11035 else
11036 {
11037 char tmp[MAX_SIZE];
11038
11039 IP6AddrToStr(tmp, sizeof(tmp), &a->SrcIpAddress6);
11040 SetTextA(hWnd, E_SRC_IP_V6, tmp);
11041
11042 Mask6AddrToStrEx(tmp, sizeof(tmp), &a->SrcSubnetMask6, false);
11043
11044 if (IsNum(tmp))
11045 {
11046 StrCatLeft(tmp, sizeof(tmp), "/");
11047 }
11048
11049 SetTextA(hWnd, E_SRC_MASK_V6, tmp);
11050 }
11051
11052 if (IsZeroIP6Addr(&a->DestIpAddress6) && IsZeroIP6Addr(&a->DestSubnetMask6))
11053 {
11054 Check(hWnd, R_DST_ALL, true);
11055 }
11056 else
11057 {
11058 char tmp[MAX_SIZE];
11059
11060 IP6AddrToStr(tmp, sizeof(tmp), &a->DestIpAddress6);
11061 SetTextA(hWnd, E_DST_IP_V6, tmp);
11062
11063 Mask6AddrToStrEx(tmp, sizeof(tmp), &a->DestSubnetMask6, false);
11064
11065 if (IsNum(tmp))
11066 {
11067 StrCatLeft(tmp, sizeof(tmp), "/");
11068 }
11069
11070 SetTextA(hWnd, E_DST_MASK_V6, tmp);
11071 }
11072 }
11073
11074 CbSetHeight(hWnd, C_PROTOCOL, 18);
11075 CbAddStr(hWnd, C_PROTOCOL, _UU("SM_ACCESS_PROTO_1"), 0);
11076 CbAddStr(hWnd, C_PROTOCOL, _UU("SM_ACCESS_PROTO_2"), 0);
11077 CbAddStr(hWnd, C_PROTOCOL, _UU("SM_ACCESS_PROTO_3"), 0);
11078 CbAddStr(hWnd, C_PROTOCOL, _UU("SM_ACCESS_PROTO_4"), 0);
11079 CbAddStr(hWnd, C_PROTOCOL, _UU("SM_ACCESS_PROTO_5"), 0);
11080 CbAddStr(hWnd, C_PROTOCOL, _UU("SM_ACCESS_PROTO_6"), 0);
11081
11082 switch (a->Protocol)
11083 {
11084 case 0:
11085 CbSelectIndex(hWnd, C_PROTOCOL, 0);
11086 break;
11087 case 6:
11088 CbSelectIndex(hWnd, C_PROTOCOL, 1);
11089 break;
11090 case 17:
11091 CbSelectIndex(hWnd, C_PROTOCOL, 2);
11092 break;
11093 case 1:
11094 CbSelectIndex(hWnd, C_PROTOCOL, 3);
11095 break;
11096 case 58:
11097 CbSelectIndex(hWnd, C_PROTOCOL, 4);
11098 break;
11099 default:
11100 CbSelectIndex(hWnd, C_PROTOCOL, 5);
11101 break;
11102 }
11103
11104 SetIntEx(hWnd, E_IP_PROTO, a->Protocol);
11105
11106 SetIntEx(hWnd, E_SRC_PORT_1, a->SrcPortStart);
11107 SetIntEx(hWnd, E_SRC_PORT_2, a->SrcPortEnd);
11108 SetIntEx(hWnd, E_DST_PORT_1, a->DestPortStart);
11109 SetIntEx(hWnd, E_DST_PORT_2, a->DestPortEnd);
11110
11111 SetTextA(hWnd, E_USERNAME1, a->SrcUsername);
11112 SetTextA(hWnd, E_USERNAME2, a->DestUsername);
11113
11114 if(a->CheckSrcMac != false)
11115 {
11116 char mac[MAX_SIZE], mask[MAX_SIZE];
11117 MacToStr(mac, sizeof(mac), a->SrcMacAddress);
11118 MacToStr(mask, sizeof(mask), a->SrcMacMask);
11119 SetTextA(hWnd, E_SRC_MAC, mac);
11120 SetTextA(hWnd, E_SRC_MAC_MASK, mask);
11121 }
11122 if(a->CheckDstMac != false)
11123 {
11124 char mac[MAX_SIZE], mask[MAX_SIZE];
11125 MacToStr(mac, sizeof(mac), a->DstMacAddress);
11126 MacToStr(mask, sizeof(mask), a->DstMacMask);
11127 SetTextA(hWnd, E_DST_MAC, mac);
11128 SetTextA(hWnd, E_DST_MAC_MASK, mask);
11129 }
11130 Check(hWnd, R_CHECK_SRC_MAC, !a->CheckSrcMac);
11131 Check(hWnd, R_CHECK_DST_MAC, !a->CheckDstMac);
11132
11133 Check(hWnd, R_CHECK_TCP_STATE, a->CheckTcpState);
11134 if(a->CheckTcpState != false)
11135 {
11136 Check(hWnd, R_ESTABLISHED, a->Established);
11137 Check(hWnd, R_UNESTABLISHED, !a->Established);
11138 }
11139
11140 if (GetCapsBool(s->Hub->p->CapsList, "b_support_acl_group") == false)
11141 {
11142 SetText(hWnd, S_STATIC11, _UU("D_SM_EDIT_ACCESS@STATIC11_OLD"));
11143 SetText(hWnd, S_STATIC12, _UU("D_SM_EDIT_ACCESS@STATIC12_OLD"));
11144 SetText(hWnd, S_STATIC15, _UU("D_SM_EDIT_ACCESS@STATIC15_OLD"));
11145 }
11146
11147 SetEnable(hWnd, R_REDIRECT, GetCapsBool(s->Hub->p->CapsList, "b_support_redirect_url_acl"));
11148 Check(hWnd, R_REDIRECT, (IsEmptyStr(a->RedirectUrl) ? false : true));
11149
11150 s->Inited = true;
11151
11152 SmEditAccessUpdate(hWnd, s);
11153 }
11154
11155 // HTTP Redirection Settings dialog
SmRedirect(HWND hWnd,SM_EDIT_ACCESS * s)11156 void SmRedirect(HWND hWnd, SM_EDIT_ACCESS *s)
11157 {
11158 // Validate arguments
11159 if (s == NULL)
11160 {
11161 return;
11162 }
11163
11164 Dialog(hWnd, D_SM_REDIRECT, SmRedirectDlg, s);
11165 }
SmRedirectDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)11166 UINT SmRedirectDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
11167 {
11168 SM_EDIT_ACCESS *s = (SM_EDIT_ACCESS *)param;
11169 char tmp[MAX_REDIRECT_URL_LEN + 1];
11170
11171 switch (msg)
11172 {
11173 case WM_INITDIALOG:
11174 SmRedirectDlgInit(hWnd, s);
11175 break;
11176
11177 case WM_COMMAND:
11178 switch (LOWORD(wParam))
11179 {
11180 case E_URL:
11181 SmRedirectDlgUpdate(hWnd, s);
11182 break;
11183 }
11184
11185 switch (wParam)
11186 {
11187 case IDOK:
11188 GetTxtA(hWnd, E_URL, tmp, sizeof(tmp));
11189
11190 if (StartWith(tmp, "http://") == false &&
11191 StartWith(tmp, "https://") == false)
11192 {
11193 MsgBox(hWnd, MB_ICONEXCLAMATION, _UU("SM_ADVANCED_REDIRECT_URL_MSG"));
11194
11195 FocusEx(hWnd, E_URL);
11196 break;
11197 }
11198
11199 StrCpy(s->Access->RedirectUrl, sizeof(s->Access->RedirectUrl), tmp);
11200
11201 EndDialog(hWnd, 1);
11202 break;
11203
11204 case IDCANCEL:
11205 Close(hWnd);
11206 break;
11207
11208 case B_HINT:
11209 OnceMsg(hWnd, _UU("SM_ADVANCED_REDIRECT_URL_HINT_TITLE"),
11210 _UU("SM_ADVANCED_REDIRECT_URL_HINT"), false, ICO_INTERNET);
11211 break;
11212 }
11213 break;
11214
11215 case WM_CLOSE:
11216 EndDialog(hWnd, 0);
11217 break;
11218 }
11219
11220 return 0;
11221 }
SmRedirectDlgInit(HWND hWnd,SM_EDIT_ACCESS * s)11222 void SmRedirectDlgInit(HWND hWnd, SM_EDIT_ACCESS *s)
11223 {
11224 ACCESS *a;
11225 // Validate arguments
11226 if (hWnd == NULL || s == NULL)
11227 {
11228 return;
11229 }
11230
11231 a = s->Access;
11232
11233 DlgFont(hWnd, S_BOLD, 0, true);
11234 DlgFont(hWnd, S_BOLD2, 0, true);
11235
11236 SetFont(hWnd, E_SAMPLE1, GetFont("Verdana", 0, false, false, false, false));
11237 SetFont(hWnd, E_SAMPLE2, GetFont("Verdana", 0, false, false, false, false));
11238 SetFont(hWnd, E_URL, GetFont("Verdana", 10, false, false, false, false));
11239
11240 SetTextA(hWnd, E_SAMPLE1, "http://www.google.com/about/");
11241 SetTextA(hWnd, E_SAMPLE2, "http://www.google.com/search?q=<INFO>|secret");
11242
11243 SetTextA(hWnd, E_URL, s->Access->RedirectUrl);
11244
11245 if (IsEmpty(hWnd, E_URL))
11246 {
11247 SetTextA(hWnd, E_URL, "http://");
11248
11249 SetCursorOnRight(hWnd, E_URL);
11250 Focus(hWnd, E_URL);
11251 }
11252 else
11253 {
11254 FocusEx(hWnd, E_URL);
11255 }
11256
11257 SmRedirectDlgUpdate(hWnd, s);
11258 }
SmRedirectDlgUpdate(HWND hWnd,SM_EDIT_ACCESS * s)11259 void SmRedirectDlgUpdate(HWND hWnd, SM_EDIT_ACCESS *s)
11260 {
11261 char tmp[MAX_REDIRECT_URL_LEN + 1];
11262 bool ok = true;
11263 // Validate arguments
11264 if (hWnd == NULL || s == NULL)
11265 {
11266 return;
11267 }
11268
11269 GetTxtA(hWnd, E_URL, tmp, sizeof(tmp));
11270
11271 if (IsEmptyStr(tmp))
11272 {
11273 ok = false;
11274 }
11275
11276 SetEnable(hWnd, IDOK, ok);
11277 }
11278
11279 // Update the control
SmEditAccessUpdate(HWND hWnd,SM_EDIT_ACCESS * s)11280 void SmEditAccessUpdate(HWND hWnd, SM_EDIT_ACCESS *s)
11281 {
11282 bool ok = true;
11283 bool tcp;
11284 bool b;
11285 bool check_srcmac, check_dstmac, support_mac;
11286 bool check_state, support_check_state;
11287 char srcmac[MAX_SIZE], srcmac_mask[MAX_SIZE], dstmac[MAX_SIZE], dstmac_mask[MAX_SIZE];
11288 char tmp[MAX_SIZE];
11289 wchar_t unitmp[MAX_SIZE];
11290 ACCESS *a;
11291 // Validate arguments
11292 if (hWnd == NULL || s == NULL)
11293 {
11294 return;
11295 }
11296
11297 if (s->Inited == false)
11298 {
11299 return;
11300 }
11301
11302 a = s->Access;
11303
11304 GetTxt(hWnd, E_NOTE, a->Note, sizeof(a->Note));
11305
11306 a->Discard = IsChecked(hWnd, R_DISCARD);
11307
11308 a->Priority = GetInt(hWnd, E_PRIORITY);
11309 if (a->Priority == 0)
11310 {
11311 ok = false;
11312 }
11313
11314
11315 b = IsChecked(hWnd, R_SRC_ALL) ? false : true;
11316 if (b == false)
11317 {
11318 if (a->IsIPv6 == false)
11319 {
11320 a->SrcIpAddress = 0;
11321 a->SrcSubnetMask = 0;
11322 }
11323 else
11324 {
11325 Zero(&a->SrcIpAddress6, sizeof(IPV6_ADDR));
11326 Zero(&a->SrcSubnetMask6, sizeof(IPV6_ADDR));
11327 }
11328 }
11329 else
11330 {
11331 if (a->IsIPv6 == false)
11332 {
11333 if (IpIsFilled(hWnd, E_SRC_IP) == false || IpIsFilled(hWnd, E_SRC_MASK) == false)
11334 {
11335 ok = false;
11336 }
11337 else
11338 {
11339 a->SrcIpAddress = IpGet(hWnd, E_SRC_IP);
11340 a->SrcSubnetMask = IpGet(hWnd, E_SRC_MASK);
11341 }
11342 }
11343 else
11344 {
11345 char tmp1[MAX_SIZE];
11346 char tmp2[MAX_SIZE];
11347
11348 GetTxtA(hWnd, E_SRC_IP_V6, tmp1, sizeof(tmp1));
11349 GetTxtA(hWnd, E_SRC_MASK_V6, tmp2, sizeof(tmp2));
11350
11351 if (StrToIP6Addr(&a->SrcIpAddress6, tmp1) == false ||
11352 StrToMask6Addr(&a->SrcSubnetMask6, tmp2) == false)
11353 {
11354 ok = false;
11355 }
11356 }
11357 }
11358 SetEnable(hWnd, S_SRC_IP_1, b);
11359 SetEnable(hWnd, S_SRC_IP_2, b);
11360 SetEnable(hWnd, S_SRC_IP_3, b);
11361 SetEnable(hWnd, E_SRC_IP, b);
11362 SetEnable(hWnd, E_SRC_MASK, b);
11363 SetEnable(hWnd, E_SRC_IP_V6, b);
11364 SetEnable(hWnd, E_SRC_MASK_V6, b);
11365
11366 b = IsChecked(hWnd, R_DST_ALL) ? false : true;
11367 if (b == false)
11368 {
11369 if (a->IsIPv6 == false)
11370 {
11371 a->DestIpAddress = 0;
11372 a->DestSubnetMask = 0;
11373 }
11374 else
11375 {
11376 Zero(&a->DestIpAddress6, sizeof(IPV6_ADDR));
11377 Zero(&a->DestSubnetMask6, sizeof(IPV6_ADDR));
11378 }
11379 }
11380 else
11381 {
11382 if (a->IsIPv6 == false)
11383 {
11384 if (IpIsFilled(hWnd, E_DST_IP) == false || IpIsFilled(hWnd, E_DST_MASK) == false)
11385 {
11386 ok = false;
11387 }
11388 else
11389 {
11390 a->DestIpAddress = IpGet(hWnd, E_DST_IP);
11391 a->DestSubnetMask = IpGet(hWnd, E_DST_MASK);
11392 }
11393 }
11394 else
11395 {
11396 char tmp1[MAX_SIZE];
11397 char tmp2[MAX_SIZE];
11398
11399 GetTxtA(hWnd, E_DST_IP_V6, tmp1, sizeof(tmp1));
11400 GetTxtA(hWnd, E_DST_MASK_V6, tmp2, sizeof(tmp2));
11401
11402 if (StrToIP6Addr(&a->DestIpAddress6, tmp1) == false ||
11403 StrToMask6Addr(&a->DestSubnetMask6, tmp2) == false)
11404 {
11405 ok = false;
11406 }
11407 }
11408 }
11409 SetEnable(hWnd, S_IP_DST_1, b);
11410 SetEnable(hWnd, S_IP_DST_2, b);
11411 SetEnable(hWnd, S_IP_DST_3, b);
11412 SetEnable(hWnd, E_DST_IP, b);
11413 SetEnable(hWnd, E_DST_MASK, b);
11414 SetEnable(hWnd, E_DST_IP_V6, b);
11415 SetEnable(hWnd, E_DST_MASK_V6, b);
11416
11417 a->Protocol = GetInt(hWnd, C_PROTOCOL);
11418
11419 GetTxtA(hWnd, C_PROTOCOL, tmp, sizeof(tmp));
11420 GetTxt(hWnd, C_PROTOCOL, unitmp, sizeof(unitmp));
11421
11422 if (UniStrCmpi(unitmp, _UU("SM_ACCESS_PROTO_6")) == 0 || StrCmpi(tmp, _SS("SM_ACCESS_PROTO_6")) == 0)
11423 {
11424 a->Protocol = GetInt(hWnd, E_IP_PROTO);
11425
11426 if (IsEmpty(hWnd, E_IP_PROTO))
11427 {
11428 ok = false;
11429 }
11430
11431 Enable(hWnd, S_PROTOID);
11432 Enable(hWnd, E_IP_PROTO);
11433 }
11434 else
11435 {
11436 Disable(hWnd, E_IP_PROTO);
11437 Disable(hWnd, S_PROTOID);
11438 }
11439
11440 tcp = false;
11441 if (a->Protocol == 17 || a->Protocol == 6)
11442 {
11443 tcp = true;
11444 }
11445
11446 SetEnable(hWnd, S_TCP_1, tcp);
11447 SetEnable(hWnd, S_TCP_2, tcp);
11448 SetEnable(hWnd, S_TCP_3, tcp);
11449 SetEnable(hWnd, S_TCP_4, tcp);
11450 SetEnable(hWnd, S_TCP_5, tcp);
11451 SetEnable(hWnd, S_TCP_6, tcp);
11452 SetEnable(hWnd, S_TCP_7, tcp);
11453 SetEnable(hWnd, E_SRC_PORT_1, tcp);
11454 SetEnable(hWnd, E_SRC_PORT_2, tcp);
11455 SetEnable(hWnd, E_DST_PORT_1, tcp);
11456 SetEnable(hWnd, E_DST_PORT_2, tcp);
11457
11458 if (tcp == false)
11459 {
11460 a->SrcPortEnd = a->SrcPortStart = a->DestPortEnd = a->DestPortStart = 0;
11461 }
11462 else
11463 {
11464 a->SrcPortStart = GetInt(hWnd, E_SRC_PORT_1);
11465 a->SrcPortEnd = GetInt(hWnd, E_SRC_PORT_2);
11466 a->DestPortStart = GetInt(hWnd, E_DST_PORT_1);
11467 a->DestPortEnd = GetInt(hWnd, E_DST_PORT_2);
11468
11469 if (a->SrcPortStart != 0)
11470 {
11471 if (a->SrcPortEnd != 0)
11472 {
11473 if (a->SrcPortStart > a->SrcPortEnd)
11474 {
11475 ok = false;
11476 }
11477 }
11478 }
11479 else
11480 {
11481 if (a->SrcPortEnd != 0)
11482 {
11483 ok = false;
11484 }
11485 }
11486
11487 if (a->DestPortStart != 0)
11488 {
11489 if (a->DestPortEnd != 0)
11490 {
11491 if (a->DestPortStart > a->DestPortEnd)
11492 {
11493 ok = false;
11494 }
11495 }
11496 }
11497 else
11498 {
11499 if (a->DestPortEnd != 0)
11500 {
11501 ok = false;
11502 }
11503 }
11504
11505 if (a->DestPortEnd < a->DestPortStart)
11506 {
11507 a->DestPortEnd = a->DestPortStart;
11508 }
11509
11510 if (a->SrcPortEnd < a->SrcPortStart)
11511 {
11512 a->SrcPortEnd = a->SrcPortStart;
11513 }
11514 }
11515
11516 a->SrcUsernameHash = a->DestUsernameHash = 0;
11517 GetTxtA(hWnd, E_USERNAME1, a->SrcUsername, sizeof(a->SrcUsername));
11518 GetTxtA(hWnd, E_USERNAME2, a->DestUsername, sizeof(a->DestUsername));
11519
11520 if (StartWith(a->SrcUsername, ACCESS_LIST_INCLUDED_PREFIX) == false &&
11521 StartWith(a->SrcUsername, ACCESS_LIST_EXCLUDED_PREFIX) == false)
11522 {
11523 MakeSimpleUsernameRemoveNtDomain(a->SrcUsername, sizeof(a->SrcUsername), a->SrcUsername);
11524 }
11525
11526 if (StartWith(a->DestUsername, ACCESS_LIST_INCLUDED_PREFIX) == false &&
11527 StartWith(a->DestUsername, ACCESS_LIST_EXCLUDED_PREFIX) == false)
11528 {
11529 MakeSimpleUsernameRemoveNtDomain(a->DestUsername, sizeof(a->DestUsername), a->DestUsername);
11530 }
11531
11532 Trim(a->SrcUsername);
11533 /*
11534 if (StrLen(a->SrcUsername) != 0)
11535 {
11536 if (IsUserName(a->SrcUsername) == false)
11537 {
11538 ok = false;
11539 }
11540 }*/
11541
11542 Trim(a->DestUsername);
11543 /*
11544 if (StrLen(a->DestUsername) != 0)
11545 {
11546 if (IsUserName(a->DestUsername) == false)
11547 {
11548 ok = false;
11549 }
11550 }*/
11551
11552 support_mac = GetCapsBool(s->Hub->p->CapsList, "b_support_check_mac");
11553
11554 // Set the source MAC address
11555 check_srcmac = a->CheckSrcMac = support_mac && (IsChecked(hWnd, R_CHECK_SRC_MAC) ? false : true);
11556 if(check_srcmac == false)
11557 {
11558 Zero(a->SrcMacAddress, sizeof(a->SrcMacAddress));
11559 Zero(a->SrcMacMask, sizeof(a->SrcMacMask));
11560 }
11561 else
11562 {
11563 GetTxtA(hWnd, E_SRC_MAC, srcmac, sizeof(srcmac));
11564 GetTxtA(hWnd, E_SRC_MAC_MASK, srcmac_mask, sizeof(srcmac_mask));
11565 Trim(srcmac);
11566 Trim(srcmac_mask);
11567 if(StrLen(srcmac) != 0 && StrLen(srcmac_mask) != 0)
11568 {
11569 UCHAR mac[6], mask[6];
11570 if(StrToMac(mac, srcmac) && StrToMac(mask, srcmac_mask))
11571 {
11572 Copy(a->SrcMacAddress, mac, 6);
11573 Copy(a->SrcMacMask, mask, 6);
11574 }
11575 else
11576 {
11577 ok = false;
11578 }
11579 }
11580 else
11581 {
11582 ok = false;
11583 }
11584 }
11585 SetEnable(hWnd, S_CHECK_SRC_MAC, support_mac);
11586 SetEnable(hWnd, R_CHECK_SRC_MAC, support_mac);
11587 SetEnable(hWnd, S_SRC_MAC, check_srcmac);
11588 SetEnable(hWnd, S_SRC_MAC_MASK, check_srcmac);
11589 SetEnable(hWnd, E_SRC_MAC, check_srcmac);
11590 SetEnable(hWnd, E_SRC_MAC_MASK, check_srcmac);
11591
11592 // Set the destination MAC address
11593 check_dstmac = a->CheckDstMac = support_mac && (IsChecked(hWnd, R_CHECK_DST_MAC) ? false : true);
11594 if(check_dstmac == false)
11595 {
11596 Zero(a->DstMacAddress, sizeof(a->DstMacAddress));
11597 Zero(a->DstMacMask, sizeof(a->DstMacMask));
11598 }
11599 else
11600 {
11601 GetTxtA(hWnd, E_DST_MAC, dstmac, sizeof(dstmac));
11602 GetTxtA(hWnd, E_DST_MAC_MASK, dstmac_mask, sizeof(dstmac_mask));
11603 Trim(dstmac);
11604 Trim(dstmac_mask);
11605 if(StrLen(dstmac) != 0 && StrLen(dstmac_mask) != 0)
11606 {
11607 UCHAR mac[6], mask[6];
11608 if(StrToMac(mac, dstmac) && StrToMac(mask, dstmac_mask))
11609 {
11610 Copy(a->DstMacAddress, mac, 6);
11611 Copy(a->DstMacMask, mask, 6);
11612 }
11613 else
11614 {
11615 ok = false;
11616 }
11617 }
11618 else
11619 {
11620 ok = false;
11621 }
11622 }
11623 SetEnable(hWnd, S_CHECK_DST_MAC, support_mac);
11624 SetEnable(hWnd, R_CHECK_DST_MAC, support_mac);
11625 SetEnable(hWnd, S_DST_MAC, check_dstmac);
11626 SetEnable(hWnd, S_DST_MAC_MASK, check_dstmac);
11627 SetEnable(hWnd, E_DST_MAC, check_dstmac);
11628 SetEnable(hWnd, E_DST_MAC_MASK, check_dstmac);
11629
11630 SetEnable(hWnd, S_MAC_NOTE, check_srcmac || check_dstmac);
11631
11632 // Status of the TCP connection
11633 support_check_state = GetCapsBool(s->Hub->p->CapsList, "b_support_check_tcp_state") && a->Protocol == 6;
11634 SetEnable(hWnd, R_CHECK_TCP_STATE, support_check_state);
11635 check_state = a->CheckTcpState = support_check_state && IsChecked(hWnd, R_CHECK_TCP_STATE);
11636
11637 a->Established = IsChecked(hWnd, R_ESTABLISHED) && check_state;
11638 SetEnable(hWnd, R_ESTABLISHED, check_state);
11639 SetEnable(hWnd, R_UNESTABLISHED, check_state);
11640 if(check_state != false && IsChecked(hWnd, R_ESTABLISHED) == false && IsChecked(hWnd, R_UNESTABLISHED) == false)
11641 {
11642 ok = false;
11643 }
11644
11645 // Settings button such as delay
11646 SetEnable(hWnd, B_SIMULATION, a->Discard == false && GetCapsBool(s->Hub->p->CapsList, "b_support_ex_acl"));
11647
11648 // HTTP redirection settings button
11649 SetEnable(hWnd, B_REDIRECT, IsChecked(hWnd, R_REDIRECT) && (a->Discard == false) && GetCapsBool(s->Hub->p->CapsList, "b_support_redirect_url_acl"));
11650 SetEnable(hWnd, R_REDIRECT, (a->Discard == false) && GetCapsBool(s->Hub->p->CapsList, "b_support_redirect_url_acl"));
11651
11652 if (IsChecked(hWnd, R_REDIRECT) && (a->Discard == false) && GetCapsBool(s->Hub->p->CapsList, "b_support_redirect_url_acl"))
11653 {
11654 if (IsEmptyStr(a->RedirectUrl))
11655 {
11656 ok = false;
11657 }
11658 }
11659
11660 SetEnable(hWnd, IDOK, ok);
11661 }
11662
11663 // OK Click
SmEditAccessOnOk(HWND hWnd,SM_EDIT_ACCESS * s)11664 void SmEditAccessOnOk(HWND hWnd, SM_EDIT_ACCESS *s)
11665 {
11666 ACCESS *a;
11667 // Validate arguments
11668 if (hWnd == NULL || s == NULL)
11669 {
11670 return;
11671 }
11672
11673 a = s->Access;
11674
11675 SmEditAccessUpdate(hWnd, s);
11676
11677 if (IsChecked(hWnd, R_REDIRECT) == false || (a->Discard) || GetCapsBool(s->Hub->p->CapsList, "b_support_redirect_url_acl") == false)
11678 {
11679 // Disable the HTTP redirection
11680 ClearStr(a->RedirectUrl, sizeof(a->RedirectUrl));
11681 }
11682
11683 EndDialog(hWnd, true);
11684 }
11685
11686
11687 // Access list editing dialog
SmEditAccessDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)11688 UINT SmEditAccessDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
11689 {
11690 SM_EDIT_ACCESS *s = (SM_EDIT_ACCESS *)param;
11691 UINT ico;
11692 ACCESS *a;
11693 char tmp[MAX_SIZE];
11694 // Validate arguments
11695 if (hWnd == NULL)
11696 {
11697 return 0;
11698 }
11699
11700 switch (msg)
11701 {
11702 case WM_INITDIALOG:
11703 // Initialize
11704 SmEditAccessInit(hWnd, s);
11705
11706 goto REFRESH_ICON;
11707
11708 case WM_COMMAND:
11709 switch (LOWORD(wParam))
11710 {
11711 case R_PASS:
11712 case R_DISCARD:
11713 case E_PRIORITY:
11714 case R_SRC_ALL:
11715 case E_SRC_IP:
11716 case E_SRC_MASK:
11717 case R_DST_ALL:
11718 case E_DST_MASK:
11719 case E_SRC_IP_V6:
11720 case E_SRC_MASK_V6:
11721 case E_DST_MASK_V6:
11722 case E_DST_IP_V6:
11723 case C_PROTOCOL:
11724 case E_SRC_PORT_1:
11725 case E_SRC_PORT_2:
11726 case E_DST_PORT_1:
11727 case E_DST_PORT_2:
11728 case E_USERNAME1:
11729 case E_USERNAME2:
11730 case E_IP_PROTO:
11731 case R_CHECK_SRC_MAC:
11732 case E_SRC_MAC:
11733 case E_SRC_MAC_MASK:
11734 case R_CHECK_DST_MAC:
11735 case E_DST_MAC:
11736 case E_DST_MAC_MASK:
11737 case R_CHECK_TCP_STATE:
11738 case R_ESTABLISHED:
11739 case R_UNESTABLISHED:
11740 case R_REDIRECT:
11741 SmEditAccessUpdate(hWnd, s);
11742 break;
11743 }
11744
11745 switch (wParam)
11746 {
11747 case B_USER1:
11748 if (GetTxtA(hWnd, E_USERNAME1, tmp, sizeof(tmp)))
11749 {
11750 char *ret = SmSelectUserDlgEx(hWnd, s->Hub, tmp, GetCapsBool(s->Hub->p->CapsList, "b_support_acl_group"));
11751 if (ret == NULL)
11752 {
11753 SetTextA(hWnd, E_USERNAME1, "");
11754 }
11755 else
11756 {
11757 SetTextA(hWnd, E_USERNAME1, ret);
11758 Free(ret);
11759 }
11760 FocusEx(hWnd, E_USERNAME1);
11761 }
11762 break;
11763
11764 case B_USER2:
11765 if (GetTxtA(hWnd, E_USERNAME2, tmp, sizeof(tmp)))
11766 {
11767 char *ret = SmSelectUserDlgEx(hWnd, s->Hub, tmp, GetCapsBool(s->Hub->p->CapsList, "b_support_acl_group"));
11768 if (ret == NULL)
11769 {
11770 SetTextA(hWnd, E_USERNAME2, "");
11771 }
11772 else
11773 {
11774 SetTextA(hWnd, E_USERNAME2, ret);
11775 Free(ret);
11776 }
11777 FocusEx(hWnd, E_USERNAME2);
11778 }
11779 break;
11780
11781 case IDOK:
11782 // [OK] button
11783 SmEditAccessOnOk(hWnd, s);
11784 break;
11785
11786 case IDCANCEL:
11787 // Cancel button
11788 Close(hWnd);
11789 break;
11790
11791 case R_SRC_ALL:
11792 if (IsChecked(hWnd, R_SRC_ALL) == false)
11793 {
11794 if (s->Access->IsIPv6)
11795 {
11796 FocusEx(hWnd, E_SRC_IP_V6);
11797 }
11798 else
11799 {
11800 Focus(hWnd, E_SRC_IP);
11801 }
11802 }
11803 break;
11804
11805 case R_DST_ALL:
11806 if (IsChecked(hWnd, R_DST_ALL) == false)
11807 {
11808 if (s->Access->IsIPv6)
11809 {
11810 FocusEx(hWnd, E_DST_IP_V6);
11811 }
11812 else
11813 {
11814 Focus(hWnd, E_DST_IP);
11815 }
11816 }
11817 break;
11818 case R_CHECK_SRC_MAC:
11819 if(IsChecked(hWnd, R_CHECK_SRC_MAC) == false)
11820 {
11821 Focus(hWnd, E_SRC_MAC);
11822 }
11823 break;
11824 case R_CHECK_DST_MAC:
11825 if(IsChecked(hWnd, R_CHECK_DST_MAC) == false)
11826 {
11827 Focus(hWnd, E_DST_MAC);
11828 }
11829 break;
11830
11831 case R_PASS:
11832 case R_DISCARD:
11833 REFRESH_ICON:
11834 a = s->Access;
11835 if (a->Discard == false && a->Active == false)
11836 {
11837 ico = ICO_PASS_DISABLE;
11838 }
11839 else if (a->Discard == false && a->Active)
11840 {
11841 ico = ICO_PASS;
11842 }
11843 else if (a->Discard && a->Active == false)
11844 {
11845 ico = ICO_DISCARD_DISABLE;
11846 }
11847 else
11848 {
11849 ico = ICO_DISCARD;
11850 }
11851
11852 SetIcon(hWnd, S_ICON, ico);
11853 break;
11854
11855 case B_SIMULATION:
11856 // Simulation
11857 Dialog(hWnd, D_SM_SIMULATION, SmSimulationDlg, s);
11858 break;
11859
11860 case B_REDIRECT:
11861 // Set the URL to redirect to
11862 SmRedirect(hWnd, s);
11863 SmEditAccessUpdate(hWnd, s);
11864 break;
11865 }
11866 break;
11867
11868 case WM_CLOSE:
11869 EndDialog(hWnd, false);
11870 break;
11871 }
11872
11873 return 0;
11874 }
11875
11876 // Delay, jitter, packet-loss dialog
SmSimulationDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)11877 UINT SmSimulationDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
11878 {
11879 SM_EDIT_ACCESS *s = (SM_EDIT_ACCESS *)param;
11880 // Validate arguments
11881 if (hWnd == NULL)
11882 {
11883 return 0;
11884 }
11885
11886 switch (msg)
11887 {
11888 case WM_INITDIALOG:
11889 SmSimulationInit(hWnd, s);
11890 break;
11891
11892 case WM_COMMAND:
11893 switch (LOWORD(wParam))
11894 {
11895 case E_DELAY:
11896 case E_JITTER:
11897 case E_LOSS:
11898 SmSimulationUpdate(hWnd, s);
11899 break;
11900 }
11901
11902 switch (wParam)
11903 {
11904 case IDOK:
11905 SmSimulationOnOk(hWnd, s);
11906 break;
11907
11908 case IDCANCEL:
11909 Close(hWnd);
11910 break;
11911
11912 case C_DELAY:
11913 SmSimulationUpdate(hWnd, s);
11914 if (IsChecked(hWnd, C_DELAY))
11915 {
11916 FocusEx(hWnd, E_DELAY);
11917 }
11918 break;
11919
11920 case C_JITTER:
11921 SmSimulationUpdate(hWnd, s);
11922 if (IsChecked(hWnd, C_JITTER))
11923 {
11924 FocusEx(hWnd, E_JITTER);
11925 }
11926 break;
11927
11928 case C_LOSS:
11929 SmSimulationUpdate(hWnd, s);
11930 if (IsChecked(hWnd, C_LOSS))
11931 {
11932 FocusEx(hWnd, E_LOSS);
11933 }
11934 break;
11935 }
11936 break;
11937
11938 case WM_CLOSE:
11939 EndDialog(hWnd, false);
11940 break;
11941 }
11942
11943 return 0;
11944 }
11945
11946 // Update of delay, jitter, packet-loss dialog
SmSimulationUpdate(HWND hWnd,SM_EDIT_ACCESS * s)11947 void SmSimulationUpdate(HWND hWnd, SM_EDIT_ACCESS *s)
11948 {
11949 bool b1, b2, b3;
11950 bool ok = true;
11951 // Validate arguments
11952 if (hWnd == NULL || s == NULL)
11953 {
11954 return;
11955 }
11956
11957 b1 = IsChecked(hWnd, C_DELAY);
11958 b2 = IsChecked(hWnd, C_JITTER);
11959 b3 = IsChecked(hWnd, C_LOSS);
11960
11961 SetEnable(hWnd, S_DELAY, b1);
11962 SetEnable(hWnd, S_DELAY2, b1);
11963 SetEnable(hWnd, E_DELAY, b1);
11964
11965 SetEnable(hWnd, C_JITTER, b1);
11966
11967 if (b1 == false)
11968 {
11969 b2 = false;
11970 }
11971
11972 SetEnable(hWnd, S_JITTER, b2);
11973 SetEnable(hWnd, S_JITTER2, b2);
11974 SetEnable(hWnd, E_JITTER, b2);
11975
11976 SetEnable(hWnd, S_LOSS, b3);
11977 SetEnable(hWnd, S_LOSS2, b3);
11978 SetEnable(hWnd, E_LOSS, b3);
11979
11980 if (b1)
11981 {
11982 UINT i = GetInt(hWnd, E_DELAY);
11983 if (i == 0 || i > HUB_ACCESSLIST_DELAY_MAX)
11984 {
11985 ok = false;
11986 }
11987 }
11988
11989 if (b2)
11990 {
11991 UINT i = GetInt(hWnd, E_JITTER);
11992 if (i == 0 || i > HUB_ACCESSLIST_JITTER_MAX)
11993 {
11994 ok = false;
11995 }
11996 }
11997
11998 if (b3)
11999 {
12000 UINT i = GetInt(hWnd, E_LOSS);
12001 if (i == 0 || i > HUB_ACCESSLIST_LOSS_MAX)
12002 {
12003 ok = false;
12004 }
12005 }
12006
12007 SetEnable(hWnd, IDOK, ok);
12008 }
12009
12010 // Initialization of delay, jitter, packet-loss dialog
SmSimulationInit(HWND hWnd,SM_EDIT_ACCESS * s)12011 void SmSimulationInit(HWND hWnd, SM_EDIT_ACCESS *s)
12012 {
12013 ACCESS *a;
12014 // Validate arguments
12015 if (hWnd == NULL || s == NULL)
12016 {
12017 return;
12018 }
12019
12020 a = s->Access;
12021
12022 Check(hWnd, C_DELAY, a->Delay != 0);
12023 Check(hWnd, C_JITTER, a->Jitter != 0);
12024 Check(hWnd, C_LOSS, a->Loss != 0);
12025
12026 SetIntEx(hWnd, E_DELAY, a->Delay);
12027 if (a->Delay != 0)
12028 {
12029 SetIntEx(hWnd, E_JITTER, a->Jitter);
12030 }
12031 SetIntEx(hWnd, E_LOSS, a->Loss);
12032
12033 SmSimulationUpdate(hWnd, s);
12034
12035 if (a->Delay != 0)
12036 {
12037 FocusEx(hWnd, E_DELAY);
12038 }
12039 else
12040 {
12041 Focus(hWnd, C_DELAY);
12042 }
12043 }
12044
12045 // Saving of delay, jitter, packet-loss dialog
SmSimulationOnOk(HWND hWnd,SM_EDIT_ACCESS * s)12046 void SmSimulationOnOk(HWND hWnd, SM_EDIT_ACCESS *s)
12047 {
12048 ACCESS *a;
12049 // Validate arguments
12050 if (hWnd == NULL || s == NULL)
12051 {
12052 return;
12053 }
12054
12055 a = s->Access;
12056
12057 a->Jitter = a->Loss = a->Delay = 0;
12058
12059 if (IsChecked(hWnd, C_DELAY))
12060 {
12061 a->Delay = GetInt(hWnd, E_DELAY);
12062 }
12063
12064 if (IsChecked(hWnd, C_JITTER))
12065 {
12066 a->Jitter = GetInt(hWnd, E_JITTER);
12067 }
12068
12069 if (IsChecked(hWnd, C_LOSS))
12070 {
12071 a->Loss = GetInt(hWnd, E_LOSS);
12072 }
12073
12074 EndDialog(hWnd, 1);
12075 }
12076
12077 // Edit the access list
SmEditAccess(HWND hWnd,SM_ACCESS_LIST * s,ACCESS * a)12078 bool SmEditAccess(HWND hWnd, SM_ACCESS_LIST *s, ACCESS *a)
12079 {
12080 SM_EDIT_ACCESS edit;
12081 bool ret;
12082 UINT i;
12083 // Validate arguments
12084 if (hWnd == NULL || s == NULL)
12085 {
12086 return false;
12087 }
12088
12089 Zero(&edit, sizeof(edit));
12090 edit.AccessList = s;
12091 edit.EditMode = true;
12092 edit.Access = ZeroMalloc(sizeof(ACCESS));
12093 edit.Hub = s->Hub;
12094 Copy(edit.Access, a, sizeof(ACCESS));
12095
12096 if (edit.Access->IsIPv6 == false)
12097 {
12098 ret = Dialog(hWnd, D_SM_EDIT_ACCESS, SmEditAccessDlg, &edit);
12099 }
12100 else
12101 {
12102 ret = Dialog(hWnd, D_SM_EDIT_ACCESS_V6, SmEditAccessDlg, &edit);
12103 }
12104
12105 if (ret)
12106 {
12107 Copy(a, edit.Access, sizeof(ACCESS));
12108 Free(edit.Access);
12109 Sort(s->AccessList);
12110
12111 // Reassign the ID
12112 for (i = 0;i < LIST_NUM(s->AccessList);i++)
12113 {
12114 ACCESS *a = LIST_DATA(s->AccessList, i);
12115 a->Id = (i + 1);
12116 }
12117 }
12118 else
12119 {
12120 Free(edit.Access);
12121 }
12122
12123 return ret;
12124 }
12125
12126 // Clone of the access list
SmCloneAccess(HWND hWnd,SM_ACCESS_LIST * s,ACCESS * t)12127 bool SmCloneAccess(HWND hWnd, SM_ACCESS_LIST *s, ACCESS *t)
12128 {
12129 SM_EDIT_ACCESS edit;
12130 bool ret;
12131 UINT i;
12132 // Validate arguments
12133 if (hWnd == NULL || s == NULL || t == NULL)
12134 {
12135 return false;
12136 }
12137
12138 Zero(&edit, sizeof(edit));
12139 edit.AccessList = s;
12140 edit.Access = Clone(t, sizeof(ACCESS));
12141 edit.Access->Priority = 0;
12142 edit.Hub = s->Hub;
12143
12144 // Generate a number that does not duplicate with other and is larger than the priority of the cloning original
12145 for (edit.Access->Priority = t->Priority;edit.Access->Priority != INFINITE;edit.Access->Priority++)
12146 {
12147 bool exists = false;
12148
12149 for (i = 0;i < LIST_NUM(s->AccessList);i++)
12150 {
12151 ACCESS *a = LIST_DATA(s->AccessList, i);
12152
12153 if (a->Priority == edit.Access->Priority)
12154 {
12155 exists = true;
12156 break;
12157 }
12158 }
12159
12160 if (exists == false)
12161 {
12162 break;
12163 }
12164 }
12165
12166 if (edit.Access->IsIPv6 == false)
12167 {
12168 ret = Dialog(hWnd, D_SM_EDIT_ACCESS, SmEditAccessDlg, &edit);
12169 }
12170 else
12171 {
12172 ret = Dialog(hWnd, D_SM_EDIT_ACCESS_V6, SmEditAccessDlg, &edit);
12173 }
12174
12175 if (ret)
12176 {
12177 Insert(s->AccessList, edit.Access);
12178
12179 // Reassign the ID
12180 for (i = 0;i < LIST_NUM(s->AccessList);i++)
12181 {
12182 ACCESS *a = LIST_DATA(s->AccessList, i);
12183 a->Id = (i + 1);
12184 }
12185 }
12186 else
12187 {
12188 Free(edit.Access);
12189 }
12190
12191 return ret;
12192 }
12193
12194 // Add to Access List
SmAddAccess(HWND hWnd,SM_ACCESS_LIST * s,bool ipv6)12195 bool SmAddAccess(HWND hWnd, SM_ACCESS_LIST *s, bool ipv6)
12196 {
12197 SM_EDIT_ACCESS edit;
12198 bool ret;
12199 UINT i;
12200 // Validate arguments
12201 if (hWnd == NULL || s == NULL)
12202 {
12203 return false;
12204 }
12205
12206 Zero(&edit, sizeof(edit));
12207 edit.AccessList = s;
12208 edit.Access = ZeroMalloc(sizeof(ACCESS));
12209 edit.Access->Active = true;
12210 edit.Access->Priority = 0;
12211 edit.Access->IsIPv6 = ipv6;
12212 edit.Hub = s->Hub;
12213
12214 // Get the new priority
12215 for (i = 0;i < LIST_NUM(s->AccessList);i++)
12216 {
12217 ACCESS *a = LIST_DATA(s->AccessList, i);
12218 edit.Access->Priority = MAX(edit.Access->Priority, a->Priority);
12219 }
12220
12221 if (edit.Access->Priority == 0)
12222 {
12223 edit.Access->Priority = 900;
12224 }
12225
12226 edit.Access->Priority += 100;
12227
12228 if (edit.Access->IsIPv6 == false)
12229 {
12230 ret = Dialog(hWnd, D_SM_EDIT_ACCESS, SmEditAccessDlg, &edit);
12231 }
12232 else
12233 {
12234 ret = Dialog(hWnd, D_SM_EDIT_ACCESS_V6, SmEditAccessDlg, &edit);
12235 }
12236
12237 if (ret)
12238 {
12239 Insert(s->AccessList, edit.Access);
12240
12241 // Reassign the ID
12242 for (i = 0;i < LIST_NUM(s->AccessList);i++)
12243 {
12244 ACCESS *a = LIST_DATA(s->AccessList, i);
12245 a->Id = (i + 1);
12246 }
12247 }
12248 else
12249 {
12250 Free(edit.Access);
12251 }
12252
12253 return ret;
12254 }
12255
12256 // Initialize
SmAccessListInit(HWND hWnd,SM_ACCESS_LIST * s)12257 void SmAccessListInit(HWND hWnd, SM_ACCESS_LIST *s)
12258 {
12259 // Validate arguments
12260 if (hWnd == NULL || s == NULL)
12261 {
12262 return;
12263 }
12264
12265 SetIcon(hWnd, 0, ICO_PASS);
12266 FormatText(hWnd, S_TITLE, s->Hub->HubName);
12267
12268 LvInit(hWnd, L_ACCESS_LIST);
12269 LvInsertColumn(hWnd, L_ACCESS_LIST, 0, _UU("SM_ACCESS_COLUMN_0"), 60);
12270 LvInsertColumn(hWnd, L_ACCESS_LIST, 1, _UU("SM_ACCESS_COLUMN_1"), 60);
12271 LvInsertColumn(hWnd, L_ACCESS_LIST, 2, _UU("SM_ACCESS_COLUMN_2"), 60);
12272 LvInsertColumn(hWnd, L_ACCESS_LIST, 3, _UU("SM_ACCESS_COLUMN_3"), 70);
12273 LvInsertColumn(hWnd, L_ACCESS_LIST, 4, _UU("SM_ACCESS_COLUMN_4"), 150);
12274 LvInsertColumn(hWnd, L_ACCESS_LIST, 5, _UU("SM_ACCESS_COLUMN_5"), 600);
12275
12276 LvSetStyle(hWnd, L_ACCESS_LIST, LVS_EX_GRIDLINES);
12277
12278 SetEnable(hWnd, B_ADD_V6, GetCapsBool(s->Hub->p->CapsList, "b_support_ipv6_acl"));
12279
12280 SmAccessListRefresh(hWnd, s);
12281 }
12282
12283 // Update the control
SmAccessListUpdate(HWND hWnd,SM_ACCESS_LIST * s)12284 void SmAccessListUpdate(HWND hWnd, SM_ACCESS_LIST *s)
12285 {
12286 bool ok = true;
12287 UINT max_access_lists = 0;
12288 // Validate arguments
12289 if (hWnd == NULL || s == NULL)
12290 {
12291 return;
12292 }
12293
12294 if (LvIsSelected(hWnd, L_ACCESS_LIST) == false || LvIsMultiMasked(hWnd, L_ACCESS_LIST))
12295 {
12296 ok = false;
12297 }
12298
12299 SetEnable(hWnd, IDOK, ok);
12300 SetEnable(hWnd, B_DELETE, ok);
12301 SetEnable(hWnd, B_CLONE, ok);
12302
12303 if (ok == false)
12304 {
12305 SetEnable(hWnd, B_ENABLE, false);
12306 SetEnable(hWnd, B_DISABLE, false);
12307 }
12308 else
12309 {
12310 ACCESS *a = LvGetParam(hWnd, L_ACCESS_LIST, LvGetSelected(hWnd, L_ACCESS_LIST));
12311
12312 if (a != NULL)
12313 {
12314 SetEnable(hWnd, B_ENABLE, (a->Active == false));
12315 SetEnable(hWnd, B_DISABLE, (a->Active == true));
12316 }
12317 else
12318 {
12319 SetEnable(hWnd, B_ENABLE, false);
12320 SetEnable(hWnd, B_DISABLE, false);
12321 }
12322 }
12323
12324 max_access_lists = GetCapsInt(s->Hub->p->CapsList, "i_max_access_lists");
12325
12326 SetEnable(hWnd, B_CREATE, LIST_NUM(s->AccessList) < max_access_lists);
12327 }
12328
12329 // Content update
SmAccessListRefresh(HWND hWnd,SM_ACCESS_LIST * s)12330 void SmAccessListRefresh(HWND hWnd, SM_ACCESS_LIST *s)
12331 {
12332 LVB *b;
12333 UINT i;
12334 // Validate arguments
12335 if (hWnd == NULL || s == NULL)
12336 {
12337 return;
12338 }
12339
12340 b = LvInsertStart();
12341
12342 Sort(s->AccessList);
12343
12344 for (i = 0;i < LIST_NUM(s->AccessList);i++)
12345 {
12346 ACCESS *a = LIST_DATA(s->AccessList, i);
12347 char tmp[MAX_SIZE];
12348 UINT ico = ICO_PASS;
12349 wchar_t tmp3[MAX_SIZE];
12350 wchar_t tmp1[MAX_SIZE];
12351 wchar_t tmp2[MAX_SIZE];
12352 GetAccessListStr(tmp, sizeof(tmp), a);
12353 UniToStru(tmp1, a->Priority);
12354 StrToUni(tmp2, sizeof(tmp2), tmp);
12355
12356 if (a->Discard == false && a->Active == false)
12357 {
12358 ico = ICO_PASS_DISABLE;
12359 }
12360 else if (a->Discard == false && a->Active)
12361 {
12362 ico = ICO_PASS;
12363 }
12364 else if (a->Discard && a->Active == false)
12365 {
12366 ico = ICO_DISCARD_DISABLE;
12367 }
12368 else
12369 {
12370 ico = ICO_DISCARD;
12371 }
12372
12373 UniToStru(tmp3, a->Id);
12374
12375 LvInsertAdd(b, ico, (void *)a, 6,
12376 tmp3,
12377 a->Discard ? _UU("SM_ACCESS_DISCARD") : _UU("SM_ACCESS_PASS"),
12378 a->Active ? _UU("SM_ACCESS_ENABLE") : _UU("SM_ACCESS_DISABLE"),
12379 tmp1,
12380 a->Note,
12381 tmp2);
12382 }
12383
12384 LvInsertEnd(b, hWnd, L_ACCESS_LIST);
12385 LvSortEx(hWnd, L_ACCESS_LIST, 0, false, true);
12386
12387 SmAccessListUpdate(hWnd, s);
12388 }
12389
12390 // Access List dialog procedure
SmAccessListProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)12391 UINT SmAccessListProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
12392 {
12393 SM_ACCESS_LIST *s = (SM_ACCESS_LIST *)param;
12394 NMHDR *n;
12395 ACCESS *a;
12396 // Validate arguments
12397 if (hWnd == NULL)
12398 {
12399 return 0;
12400 }
12401
12402 switch (msg)
12403 {
12404 case WM_INITDIALOG:
12405 // Initialize
12406 SmAccessListInit(hWnd, s);
12407 break;
12408
12409 case WM_COMMAND:
12410 switch (wParam)
12411 {
12412 case B_ADD:
12413 // Add (IPv4)
12414 if (SmAddAccess(hWnd, s, false))
12415 {
12416 SmAccessListRefresh(hWnd, s);
12417 }
12418 break;
12419
12420 case B_ADD_V6:
12421 // Add (IPv6)
12422 if (SmAddAccess(hWnd, s, true))
12423 {
12424 SmAccessListRefresh(hWnd, s);
12425 }
12426 break;
12427
12428 case IDOK:
12429 // Edit
12430 a = LvGetParam(hWnd, L_ACCESS_LIST, LvGetSelected(hWnd, L_ACCESS_LIST));
12431 if (a != NULL)
12432 {
12433 if (SmEditAccess(hWnd, s, a))
12434 {
12435 SmAccessListRefresh(hWnd, s);
12436 }
12437 }
12438 break;
12439
12440 case B_CLONE:
12441 // Create by cloning
12442 a = LvGetParam(hWnd, L_ACCESS_LIST, LvGetSelected(hWnd, L_ACCESS_LIST));
12443 if (a != NULL)
12444 {
12445 if (SmCloneAccess(hWnd, s, a))
12446 {
12447 SmAccessListRefresh(hWnd, s);
12448 }
12449 }
12450 break;
12451
12452 case B_ENABLE:
12453 a = LvGetParam(hWnd, L_ACCESS_LIST, LvGetSelected(hWnd, L_ACCESS_LIST));
12454 if (a != NULL)
12455 {
12456 a->Active = true;
12457 SmAccessListRefresh(hWnd, s);
12458 }
12459 break;
12460
12461 case B_DISABLE:
12462 a = LvGetParam(hWnd, L_ACCESS_LIST, LvGetSelected(hWnd, L_ACCESS_LIST));
12463 if (a != NULL)
12464 {
12465 a->Active = false;
12466 SmAccessListRefresh(hWnd, s);
12467 }
12468 break;
12469
12470 case B_DELETE:
12471 // Delete
12472 a = LvGetParam(hWnd, L_ACCESS_LIST, LvGetSelected(hWnd, L_ACCESS_LIST));
12473 if (a != NULL)
12474 {
12475 UINT i;
12476 if (IsInList(s->AccessList, a))
12477 {
12478 Delete(s->AccessList, a);
12479 Free(a);
12480 // Reassign the ID
12481 for (i = 0;i < LIST_NUM(s->AccessList);i++)
12482 {
12483 ACCESS *a = LIST_DATA(s->AccessList, i);
12484 a->Id = (i + 1);
12485 }
12486 SmAccessListRefresh(hWnd, s);
12487 }
12488 }
12489 break;
12490
12491 case B_SAVE:
12492 // Save
12493 {
12494 UINT i;
12495 bool ok;
12496 // Save the access list
12497 RPC_ENUM_ACCESS_LIST t;
12498 Zero(&t, sizeof(t));
12499 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
12500 t.NumAccess = LIST_NUM(s->AccessList);
12501 t.Accesses = ZeroMalloc(sizeof(ACCESS) * t.NumAccess);
12502 for (i = 0;i < LIST_NUM(s->AccessList);i++)
12503 {
12504 ACCESS *access = LIST_DATA(s->AccessList, i);
12505 Copy(&t.Accesses[i], access, sizeof(ACCESS));
12506 }
12507
12508 ok = CALL(hWnd, ScSetAccessList(s->Rpc, &t));
12509 FreeRpcEnumAccessList(&t);
12510 if (ok)
12511 {
12512 EndDialog(hWnd, true);
12513 }
12514 }
12515 break;
12516
12517 case IDCANCEL:
12518 // Cancel button
12519 Close(hWnd);
12520 break;
12521 }
12522 break;
12523
12524 case WM_NOTIFY:
12525 n = (NMHDR *)lParam;
12526 switch (n->idFrom)
12527 {
12528 case L_ACCESS_LIST:
12529 switch (n->code)
12530 {
12531 case LVN_ITEMCHANGED:
12532 SmAccessListUpdate(hWnd, s);
12533 break;
12534 }
12535 break;
12536 }
12537 break;
12538
12539 case WM_CLOSE:
12540 EndDialog(hWnd, false);
12541 break;
12542 }
12543
12544 LvStandardHandler(hWnd, msg, wParam, lParam, L_ACCESS_LIST);
12545
12546 return 0;
12547 }
12548
12549
12550 // Access List dialog
SmAccessListDlg(HWND hWnd,SM_HUB * s)12551 void SmAccessListDlg(HWND hWnd, SM_HUB *s)
12552 {
12553 SM_ACCESS_LIST a;
12554 UINT i;
12555 RPC_ENUM_ACCESS_LIST t;
12556 bool ret;
12557 // Validate arguments
12558 if (hWnd == NULL || s == NULL)
12559 {
12560 return;
12561 }
12562
12563 Zero(&a, sizeof(a));
12564 a.Hub = s;
12565 a.Rpc = s->Rpc;
12566
12567 // Get the access list
12568 Zero(&t, sizeof(t));
12569 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
12570 if (CALL(hWnd, ScEnumAccess(s->Rpc, &t)) == false)
12571 {
12572 return;
12573 }
12574
12575 a.AccessList = NewListFast(CmpAccessList);
12576 // Add to the list
12577 for (i = 0;i < t.NumAccess;i++)
12578 {
12579 ACCESS *access = ZeroMalloc(sizeof(ACCESS));
12580 Copy(access, &t.Accesses[i], sizeof(ACCESS));
12581
12582 Add(a.AccessList, access);
12583 }
12584
12585 // Sort
12586 Sort(a.AccessList);
12587 FreeRpcEnumAccessList(&t);
12588
12589 // Show the dialog
12590 ret = Dialog(hWnd, D_SM_ACCESS_LIST, SmAccessListProc, &a);
12591
12592 for (i = 0;i < LIST_NUM(a.AccessList);i++)
12593 {
12594 ACCESS *access = LIST_DATA(a.AccessList, i);
12595 Free(access);
12596 }
12597 ReleaseList(a.AccessList);
12598 }
12599
12600 // Initialize
SmEditGroupDlgInit(HWND hWnd,SM_EDIT_GROUP * g)12601 void SmEditGroupDlgInit(HWND hWnd, SM_EDIT_GROUP *g)
12602 {
12603 RPC_SET_GROUP *group;
12604 LVB *b;
12605 // Validate arguments
12606 if (hWnd == NULL || g == NULL)
12607 {
12608 return;
12609 }
12610
12611 SetIcon(hWnd, 0, ICO_GROUP);
12612
12613 group = &g->SetGroup;
12614
12615 if (g->EditMode == false)
12616 {
12617 SetText(hWnd, 0, _UU("SM_EDIT_GROUP_CAPTION_1"));
12618 }
12619 else
12620 {
12621 wchar_t tmp[MAX_SIZE];
12622 UniFormat(tmp, sizeof(tmp), _UU("SM_EDIT_GROUP_CAPTION_2"), group->Name);
12623 SetText(hWnd, 0, tmp);
12624 }
12625
12626 SetTextA(hWnd, E_GROUPNAME, group->Name);
12627 SetText(hWnd, E_REALNAME, group->Realname);
12628 SetText(hWnd, E_NOTE, group->Note);
12629
12630 g->Inited = true;
12631
12632 if (g->EditMode == false)
12633 {
12634 Disable(hWnd, L_STATUS);
12635 }
12636 else
12637 {
12638 LvInit(hWnd, L_STATUS);
12639 LvInsertColumn(hWnd, L_STATUS, 0, _UU("SM_STATUS_COLUMN_1"), 0);
12640 LvInsertColumn(hWnd, L_STATUS, 1, _UU("SM_STATUS_COLUMN_2"), 0);
12641 LvSetStyle(hWnd, L_STATUS, LVS_EX_GRIDLINES);
12642
12643 b = LvInsertStart();
12644
12645 SmInsertTrafficInfo(b, &group->Traffic);
12646
12647 LvInsertEnd(b, hWnd, L_STATUS);
12648
12649 LvAutoSize(hWnd, L_STATUS);
12650 }
12651
12652 Check(hWnd, R_POLICY, group->Policy != NULL);
12653
12654 if (g->EditMode)
12655 {
12656 Disable(hWnd, E_GROUPNAME);
12657 FocusEx(hWnd, E_REALNAME);
12658 }
12659
12660 SmEditGroupDlgUpdate(hWnd, g);
12661 }
12662
12663 // Update
SmEditGroupDlgUpdate(HWND hWnd,SM_EDIT_GROUP * g)12664 void SmEditGroupDlgUpdate(HWND hWnd, SM_EDIT_GROUP *g)
12665 {
12666 bool ok = true;
12667 RPC_SET_GROUP *group;
12668 // Validate arguments
12669 if (hWnd == NULL || g == NULL)
12670 {
12671 return;
12672 }
12673
12674 if (g->Inited == false)
12675 {
12676 return;
12677 }
12678
12679 group = &g->SetGroup;
12680
12681 GetTxtA(hWnd, E_GROUPNAME, group->Name, sizeof(group->Name));
12682 Trim(group->Name);
12683
12684 if (IsUserName(group->Name) == false)
12685 {
12686 ok = false;
12687 }
12688
12689 GetTxt(hWnd, E_REALNAME, group->Realname, sizeof(group->Realname));
12690 UniTrim(group->Realname);
12691
12692 GetTxt(hWnd, E_NOTE, group->Note, sizeof(group->Note));
12693 UniTrim(group->Note);
12694
12695 SetEnable(hWnd, B_POLICY, IsChecked(hWnd, R_POLICY));
12696
12697 if (IsChecked(hWnd, R_POLICY))
12698 {
12699 if (group->Policy == NULL)
12700 {
12701 ok = false;
12702 }
12703 }
12704
12705 SetEnable(hWnd, IDOK, ok);
12706 }
12707
12708 // OK
SmEditGroupDlgOnOk(HWND hWnd,SM_EDIT_GROUP * g)12709 void SmEditGroupDlgOnOk(HWND hWnd, SM_EDIT_GROUP *g)
12710 {
12711 RPC_SET_GROUP *group;
12712 RPC_SET_GROUP t;
12713 // Validate arguments
12714 if (hWnd == NULL || g == NULL)
12715 {
12716 return;
12717 }
12718
12719 SmEditGroupDlgUpdate(hWnd, g);
12720
12721 group = &g->SetGroup;
12722
12723 if (IsChecked(hWnd, R_POLICY) == false)
12724 {
12725 if (group->Policy != NULL)
12726 {
12727 Free(group->Policy);
12728 group->Policy = NULL;
12729 }
12730 }
12731
12732 Zero(&t, sizeof(t));
12733 Copy(&t, group, sizeof(RPC_SET_GROUP));
12734
12735 t.Policy = ClonePolicy(group->Policy);
12736
12737 if (g->EditMode == false)
12738 {
12739 if (CALL(hWnd, ScCreateGroup(g->Rpc, &t)) == false)
12740 {
12741 FocusEx(hWnd, E_GROUPNAME);
12742 return;
12743 }
12744 }
12745 else
12746 {
12747 if (CALL(hWnd, ScSetGroup(g->Rpc, &t)) == false)
12748 {
12749 return;
12750 }
12751 }
12752
12753 FreeRpcSetGroup(&t);
12754
12755 if (g->EditMode == false)
12756 {
12757 MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("SM_GROUP_CREATED"), group->Name);
12758 }
12759
12760 EndDialog(hWnd, true);
12761 }
12762
12763 // Group editing dialog procedure
SmEditGroupDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)12764 UINT SmEditGroupDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
12765 {
12766 SM_EDIT_GROUP *g = (SM_EDIT_GROUP *)param;
12767 wchar_t tmp[MAX_SIZE];
12768 NMHDR *n;
12769 // Validate arguments
12770 if (hWnd == NULL)
12771 {
12772 return 0;
12773 }
12774
12775 switch (msg)
12776 {
12777 case WM_INITDIALOG:
12778 // Initialize
12779 SmEditGroupDlgInit(hWnd, g);
12780 break;
12781
12782 case WM_COMMAND:
12783 switch (LOWORD(wParam))
12784 {
12785 case E_GROUPNAME:
12786 case E_REALNAME:
12787 case E_NOTE:
12788 case R_POLICY:
12789 SmEditGroupDlgUpdate(hWnd, g);
12790 break;
12791 }
12792
12793 switch (wParam)
12794 {
12795 case IDOK:
12796 // [OK] button
12797 SmEditGroupDlgOnOk(hWnd, g);
12798 break;
12799
12800 case IDCANCEL:
12801 // Cancel button
12802 Close(hWnd);
12803 break;
12804
12805 case R_POLICY:
12806 if (IsChecked(hWnd, R_POLICY))
12807 {
12808 Focus(hWnd, B_POLICY);
12809 }
12810 break;
12811
12812 case B_POLICY:
12813 // Security policy
12814 UniFormat(tmp, sizeof(tmp), _UU("SM_GROUP_POLICY_CAPTION"), g->SetGroup.Name);
12815 if (g->SetGroup.Policy == NULL)
12816 {
12817 POLICY *p = ClonePolicy(GetDefaultPolicy());
12818 if (SmPolicyDlgEx2(hWnd, p, tmp, false, g->p->PolicyVer))
12819 {
12820 g->SetGroup.Policy = p;
12821 SmEditGroupDlgUpdate(hWnd, g);
12822 }
12823 else
12824 {
12825 Free(p);
12826 }
12827 }
12828 else
12829 {
12830 SmPolicyDlgEx2(hWnd, g->SetGroup.Policy, tmp, false, g->p->PolicyVer);
12831 }
12832 break;
12833 }
12834 break;
12835
12836 case WM_NOTIFY:
12837 n = (NMHDR *)lParam;
12838 switch (n->idFrom)
12839 {
12840 case L_STATUS:
12841 switch (n->code)
12842 {
12843 case LVN_ITEMCHANGED:
12844 SmEditGroupDlgUpdate(hWnd, g);
12845 break;
12846 }
12847 break;
12848 }
12849 break;
12850
12851 case WM_CLOSE:
12852 EndDialog(hWnd, false);
12853 break;
12854 }
12855
12856 return 0;
12857 }
12858
12859 // Group editing dialog
SmEditGroupDlg(HWND hWnd,SM_GROUP * s,char * name)12860 bool SmEditGroupDlg(HWND hWnd, SM_GROUP *s, char *name)
12861 {
12862 SM_EDIT_GROUP g;
12863 RPC_SET_GROUP *group;
12864 bool ret;
12865 // Validate arguments
12866 if (hWnd == NULL || s == NULL)
12867 {
12868 return false;
12869 }
12870
12871 Zero(&g, sizeof(g));
12872 g.EditMode = true;
12873 g.Hub = s->Hub;
12874 g.p = s->p;
12875 g.Rpc = s->Rpc;
12876
12877 group = &g.SetGroup;
12878
12879 StrCpy(group->Name, sizeof(group->Name), name);
12880 StrCpy(group->HubName, sizeof(group->HubName), s->Hub->HubName);
12881
12882 if (CALL(hWnd, ScGetGroup(s->Rpc, group)) == false)
12883 {
12884 return false;
12885 }
12886
12887 ret = Dialog(hWnd, D_SM_EDIT_GROUP, SmEditGroupDlgProc, &g);
12888
12889 FreeRpcSetGroup(group);
12890
12891 return ret;
12892 }
12893
12894 // Group creation dialog
SmCreateGroupDlg(HWND hWnd,SM_GROUP * s)12895 bool SmCreateGroupDlg(HWND hWnd, SM_GROUP *s)
12896 {
12897 SM_EDIT_GROUP g;
12898 RPC_SET_GROUP *group;
12899 bool ret;
12900 // Validate arguments
12901 if (hWnd == NULL || s == NULL)
12902 {
12903 return false;
12904 }
12905
12906 Zero(&g, sizeof(g));
12907 g.EditMode = false;
12908 g.Hub = s->Hub;
12909 g.p = s->p;
12910 g.Rpc = s->Rpc;
12911
12912 group = &g.SetGroup;
12913
12914 StrCpy(group->HubName, sizeof(group->HubName), s->Hub->HubName);
12915
12916 ret = Dialog(hWnd, D_SM_EDIT_GROUP, SmEditGroupDlgProc, &g);
12917
12918 FreeRpcSetGroup(group);
12919
12920 return ret;
12921 }
12922
12923 // Initialize
SmGroupListDlgInit(HWND hWnd,SM_GROUP * s)12924 void SmGroupListDlgInit(HWND hWnd, SM_GROUP *s)
12925 {
12926 if (hWnd == NULL || s == NULL)
12927 {
12928 return;
12929 }
12930
12931 SetIcon(hWnd, 0, ICO_GROUP);
12932
12933 // Initialize the column
12934 LvInit(hWnd, L_GROUP);
12935 LvInsertColumn(hWnd, L_GROUP, 0, _UU("SM_GROUPLIST_NAME"), 130);
12936 LvInsertColumn(hWnd, L_GROUP, 1, _UU("SM_GROUPLIST_REALNAME"), 130);
12937 LvInsertColumn(hWnd, L_GROUP, 2, _UU("SM_GROUPLIST_NOTE"), 170);
12938 LvInsertColumn(hWnd, L_GROUP, 3, _UU("SM_GROUPLIST_NUMUSERS"), 80);
12939 LvSetStyle(hWnd, L_GROUP, LVS_EX_GRIDLINES);
12940
12941 FormatText(hWnd, S_TITLE, s->Hub->HubName);
12942
12943 SmGroupListDlgRefresh(hWnd, s);
12944
12945 if (s->SelectMode)
12946 {
12947 SetStyle(hWnd, L_GROUP, LVS_SINGLESEL);
12948 }
12949
12950 if (s->SelectMode)
12951 {
12952 wchar_t tmp[MAX_SIZE];
12953 SetText(hWnd, IDOK, _UU("SM_SELECT_GROUP"));
12954
12955 if (s->SelectedGroupName != NULL)
12956 {
12957 UINT i;
12958 StrToUni(tmp, sizeof(tmp), s->SelectedGroupName);
12959 i = LvSearchStr(hWnd, L_GROUP, 0, tmp);
12960 if (i != INFINITE)
12961 {
12962 LvSelect(hWnd, L_GROUP, i);
12963 }
12964 }
12965 }
12966 }
12967
12968 // Update the controls
SmGroupListDlgUpdate(HWND hWnd,SM_GROUP * s)12969 void SmGroupListDlgUpdate(HWND hWnd, SM_GROUP *s)
12970 {
12971 bool ok = true;
12972 if (hWnd == NULL || s == NULL)
12973 {
12974 return;
12975 }
12976
12977 if (LvIsSelected(hWnd, L_GROUP) == false || LvIsMultiMasked(hWnd, L_GROUP))
12978 {
12979 ok = false;
12980 }
12981
12982 SetEnable(hWnd, IDOK, ok);
12983 SetEnable(hWnd, B_USER, ok);
12984 SetEnable(hWnd, B_STATUS, ok);
12985
12986 if (s->SelectMode == false)
12987 {
12988 SetEnable(hWnd, B_DELETE, ok);
12989 }
12990 else
12991 {
12992 SetEnable(hWnd, B_DELETE, false);
12993 SetEnable(hWnd, B_USER, false);
12994 SetText(hWnd, IDCANCEL, _UU("SM_SELECT_NO_GROUP"));
12995 }
12996 }
12997
12998 // Content update
SmGroupListDlgRefresh(HWND hWnd,SM_GROUP * s)12999 void SmGroupListDlgRefresh(HWND hWnd, SM_GROUP *s)
13000 {
13001 RPC_ENUM_GROUP t;
13002 UINT i;
13003 LVB *b;
13004 if (hWnd == NULL || s == NULL)
13005 {
13006 return;
13007 }
13008
13009 Zero(&t, sizeof(t));
13010 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
13011
13012 if (CALL(hWnd, ScEnumGroup(s->Rpc, &t)) == false)
13013 {
13014 return;
13015 }
13016
13017 b = LvInsertStart();
13018
13019 for (i = 0;i < t.NumGroup;i++)
13020 {
13021 wchar_t tmp1[MAX_SIZE];
13022 wchar_t tmp2[MAX_SIZE];
13023 RPC_ENUM_GROUP_ITEM *e = &t.Groups[i];
13024
13025 StrToUni(tmp1, sizeof(tmp1), e->Name);
13026 UniToStru(tmp2, e->NumUsers);
13027
13028 LvInsertAdd(b, e->DenyAccess == false ? ICO_GROUP : ICO_GROUP_DENY,
13029 NULL, 4, tmp1, e->Realname, e->Note, tmp2);
13030 }
13031
13032 LvInsertEnd(b, hWnd, L_GROUP);
13033
13034 SmGroupListDlgUpdate(hWnd, s);
13035
13036 FreeRpcEnumGroup(&t);
13037 }
13038
13039 // Group List dialog procedure
SmGroupListDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)13040 UINT SmGroupListDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
13041 {
13042 SM_GROUP *s = (SM_GROUP *)param;
13043 NMHDR *n;
13044 wchar_t *tmp;
13045 // Validate arguments
13046 if (hWnd == NULL)
13047 {
13048 return 0;
13049 }
13050
13051 switch (msg)
13052 {
13053 case WM_INITDIALOG:
13054 // Initialize
13055 SmGroupListDlgInit(hWnd, s);
13056 break;
13057
13058 case WM_COMMAND:
13059 switch (wParam)
13060 {
13061 case B_CREATE:
13062 // Create new
13063 if (SmCreateGroupDlg(hWnd, s))
13064 {
13065 SmGroupListDlgRefresh(hWnd, s);
13066 }
13067 break;
13068
13069 case IDOK:
13070 // Edit
13071 tmp = LvGetSelectedStr(hWnd, L_GROUP, 0);
13072 if (tmp != NULL)
13073 {
13074 char name[MAX_SIZE];
13075 UniToStr(name, sizeof(name), tmp);
13076
13077 if (s->SelectMode == false)
13078 {
13079 if (SmEditGroupDlg(hWnd, s, name))
13080 {
13081 SmGroupListDlgRefresh(hWnd, s);
13082 }
13083 }
13084 else
13085 {
13086 s->SelectedGroupName = CopyStr(name);
13087 EndDialog(hWnd, true);
13088 }
13089 Free(tmp);
13090 }
13091 break;
13092
13093 case B_DELETE:
13094 // Delete
13095 tmp = LvGetSelectedStr(hWnd, L_GROUP, 0);
13096 if (tmp != NULL)
13097 {
13098 char name[MAX_SIZE];
13099 RPC_DELETE_USER t;
13100 UniToStr(name, sizeof(name), tmp);
13101
13102 if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
13103 _UU("SM_GROUP_DELETE_MSG"), name) == IDYES)
13104 {
13105 Zero(&t, sizeof(t));
13106 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
13107 StrCpy(t.Name, sizeof(t.Name), name);
13108
13109 if (CALL(hWnd, ScDeleteGroup(s->Rpc, &t)))
13110 {
13111 SmGroupListDlgRefresh(hWnd, s);
13112 }
13113 }
13114
13115 Free(tmp);
13116 }
13117 break;
13118
13119 case B_USER:
13120 // Member List
13121 tmp = LvGetSelectedStr(hWnd, L_GROUP, 0);
13122 if (tmp != NULL)
13123 {
13124 char name[MAX_SIZE];
13125 UniToStr(name, sizeof(name), tmp);
13126 SmUserListDlgEx(hWnd, s->Hub, name, false);
13127 Free(tmp);
13128 }
13129 break;
13130
13131 case B_REFRESH:
13132 // Update to the latest information
13133 SmGroupListDlgRefresh(hWnd, s);
13134 break;
13135
13136 case IDCANCEL:
13137 // Cancel button
13138 Close(hWnd);
13139 break;
13140 }
13141 break;
13142
13143 case WM_NOTIFY:
13144 n = (NMHDR *)lParam;
13145 switch (n->idFrom)
13146 {
13147 case L_GROUP:
13148 switch (n->code)
13149 {
13150 case LVN_ITEMCHANGED:
13151 SmGroupListDlgUpdate(hWnd, s);
13152 break;
13153 }
13154 break;
13155 }
13156 break;
13157
13158 case WM_CLOSE:
13159 EndDialog(hWnd, false);
13160 break;
13161 }
13162
13163 LvStandardHandler(hWnd, msg, wParam, lParam, L_GROUP);
13164
13165 return 0;
13166 }
13167
13168 // Group List dialog (selection mode)
SmSelectGroupDlg(HWND hWnd,SM_HUB * s,char * default_name)13169 char *SmSelectGroupDlg(HWND hWnd, SM_HUB *s, char *default_name)
13170 {
13171 SM_GROUP g;
13172 // Validate arguments
13173 if (hWnd == NULL || s == NULL)
13174 {
13175 return NULL;
13176 }
13177
13178 Zero(&g, sizeof(g));
13179 g.Hub = s;
13180 g.p = s->p;
13181 g.Rpc = s->Rpc;
13182 g.SelectMode = true;
13183 g.SelectedGroupName = default_name;
13184
13185 if (Dialog(hWnd, D_SM_GROUP, SmGroupListDlgProc, &g) == false)
13186 {
13187 return NULL;
13188 }
13189
13190 return g.SelectedGroupName;
13191 }
13192
13193 // Group List dialog
SmGroupListDlg(HWND hWnd,SM_HUB * s)13194 void SmGroupListDlg(HWND hWnd, SM_HUB *s)
13195 {
13196 SM_GROUP g;
13197 // Validate arguments
13198 if (hWnd == NULL || s == NULL)
13199 {
13200 return;
13201 }
13202
13203 Zero(&g, sizeof(g));
13204 g.Hub = s;
13205 g.p = s->p;
13206 g.Rpc = s->Rpc;
13207 g.SelectMode = false;
13208
13209 Dialog(hWnd, D_SM_GROUP, SmGroupListDlgProc, &g);
13210 }
13211
13212 // Update the user information
SmRefreshUserInfo(HWND hWnd,SM_SERVER * s,void * param)13213 bool SmRefreshUserInfo(HWND hWnd, SM_SERVER *s, void *param)
13214 {
13215 RPC_SET_USER t;
13216 SM_USER_INFO *p = (SM_USER_INFO *)param;
13217 LVB *b;
13218 wchar_t tmp[MAX_SIZE];
13219 char *username;
13220
13221 // Validate arguments
13222 if (hWnd == NULL || s == NULL || param == NULL)
13223 {
13224 return false;
13225 }
13226
13227 username = p->Username;
13228
13229 Zero(&t, sizeof(t));
13230 StrCpy(t.HubName, sizeof(t.HubName), p->Hub->HubName);
13231 StrCpy(t.Name, sizeof(t.Name), username);
13232
13233 if (CALL(hWnd, ScGetUser(s->Rpc, &t)) == false)
13234 {
13235 return false;
13236 }
13237
13238 b = LvInsertStart();
13239
13240 StrToUni(tmp, sizeof(tmp), t.Name);
13241 LvInsertAdd(b, ICO_USER, NULL, 2, _UU("SM_USERINFO_NAME"), tmp);
13242
13243 if (StrLen(t.GroupName) != 0)
13244 {
13245 StrToUni(tmp, sizeof(tmp), t.GroupName);
13246 LvInsertAdd(b, ICO_GROUP, NULL, 2, _UU("SM_USERINFO_GROUP"), tmp);
13247 }
13248
13249 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.CreatedTime), NULL);
13250 LvInsertAdd(b, ICO_USER_ADMIN, NULL, 2, _UU("SM_USERINFO_CREATE"), tmp);
13251
13252 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.UpdatedTime), NULL);
13253 LvInsertAdd(b, ICO_USER_ADMIN, NULL, 2, _UU("SM_USERINFO_UPDATE"), tmp);
13254
13255 if (t.ExpireTime != 0)
13256 {
13257 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.ExpireTime), NULL);
13258 LvInsertAdd(b, ICO_WARNING, NULL, 2, _UU("SM_USERINFO_EXPIRE"), tmp);
13259 }
13260
13261 SmInsertTrafficInfo(b, &t.Traffic);
13262
13263 UniToStru(tmp, t.NumLogin);
13264 LvInsertAdd(b, ICO_LINK, NULL, 2, _UU("SM_USERINFO_NUMLOGIN"), tmp);
13265
13266 LvInsertEnd(b, hWnd, L_STATUS);
13267
13268 FreeRpcSetUser(&t);
13269
13270 return true;
13271 }
13272
13273 // Initialize
SmPolicyDlgInit(HWND hWnd,SM_POLICY * s)13274 void SmPolicyDlgInit(HWND hWnd, SM_POLICY *s)
13275 {
13276 CM_POLICY cp;
13277 // Validate arguments
13278 if (hWnd == NULL || s == NULL)
13279 {
13280 return;
13281 }
13282
13283 SetIcon(hWnd, 0, ICO_MACHINE);
13284 SetText(hWnd, 0, s->Caption);
13285 SetText(hWnd, S_TITLE, s->Caption);
13286 DlgFont(hWnd, S_BOLD, 10, true);
13287 DlgFont(hWnd, S_BOLD2, 10, true);
13288
13289 DlgFont(hWnd, S_POLICY_TITLE, 11, false);
13290 DlgFont(hWnd, E_POLICY_DESCRIPTION, 10, false);
13291
13292 Zero(&cp, sizeof(cp));
13293 cp.Policy = s->Policy;
13294 cp.Extension = true;
13295
13296 LvInit(hWnd, L_POLICY);
13297 LvInsertColumn(hWnd, L_POLICY, 0, _UU("POL_TITLE_STR"), 250);
13298 LvInsertColumn(hWnd, L_POLICY, 1, _UU("POL_VALUE_STR"), 150);
13299 LvSetStyle(hWnd, L_POLICY, LVS_EX_GRIDLINES);
13300
13301 CmPolicyDlgPrintEx2(hWnd, &cp, s->CascadeMode, s->Ver);
13302
13303 LvSelect(hWnd, L_POLICY, 0);
13304
13305 s->Inited = true;
13306 SmPolicyDlgUpdate(hWnd, s);
13307 }
13308
13309 // Update
SmPolicyDlgUpdate(HWND hWnd,SM_POLICY * s)13310 void SmPolicyDlgUpdate(HWND hWnd, SM_POLICY *s)
13311 {
13312 bool ok = true;
13313 bool value_changed = false;
13314 UINT i;
13315 // Validate arguments
13316 if (hWnd == NULL || s == NULL)
13317 {
13318 return;
13319 }
13320
13321 if (s->Inited == false)
13322 {
13323 return;
13324 }
13325
13326 i = LvGetSelected(hWnd, L_POLICY);
13327 if (i != INFINITE)
13328 {
13329 i = (UINT)LvGetParam(hWnd, L_POLICY, i);
13330 }
13331 if (i == INFINITE || i >= NUM_POLICY_ITEM)
13332 {
13333 SetText(hWnd, S_POLICY_TITLE, _UU("SM_POLICY_INIT_TITLE"));
13334 SetText(hWnd, E_POLICY_DESCRIPTION, L"");
13335 Disable(hWnd, S_POLICY_TITLE);
13336 Disable(hWnd, S_BOLD);
13337 Hide(hWnd, S_BOLD2);
13338 Hide(hWnd, R_ENABLE);
13339 Hide(hWnd, R_DISABLE);
13340 Hide(hWnd, R_DEFINE);
13341 Hide(hWnd, E_VALUE);
13342 Hide(hWnd, S_TANI);
13343 Hide(hWnd, S_LIMIT);
13344 }
13345 else
13346 {
13347 POLICY_ITEM *item = &policy_item[i];
13348 bool changed = false;
13349 wchar_t *tmp = GetText(hWnd, S_POLICY_TITLE);
13350 if (UniStrCmp(tmp, GetPolicyTitle(i)) != 0)
13351 {
13352 changed = true;
13353 }
13354 Free(tmp);
13355 SetText(hWnd, S_POLICY_TITLE, GetPolicyTitle(i));
13356 SetText(hWnd, E_POLICY_DESCRIPTION, GetPolicyDescription(i));
13357 Enable(hWnd, S_POLICY_TITLE);
13358 Enable(hWnd, S_BOLD);
13359 Show(hWnd, S_BOLD2);
13360
13361 if (item->TypeInt == false)
13362 {
13363 Show(hWnd, R_ENABLE);
13364 Show(hWnd, R_DISABLE);
13365 Hide(hWnd, R_DEFINE);
13366 Hide(hWnd, E_VALUE);
13367 Hide(hWnd, S_TANI);
13368 Hide(hWnd, S_LIMIT);
13369
13370 if (changed)
13371 {
13372 if (POLICY_BOOL(s->Policy, i))
13373 {
13374 Check(hWnd, R_ENABLE, true);
13375 Check(hWnd, R_DISABLE, false);
13376 }
13377 else
13378 {
13379 Check(hWnd, R_ENABLE, false);
13380 Check(hWnd, R_DISABLE, true);
13381 }
13382 }
13383
13384 if ((!(POLICY_BOOL(s->Policy, i))) != (!(IsChecked(hWnd, R_ENABLE))))
13385 {
13386 POLICY_BOOL(s->Policy, i) = IsChecked(hWnd, R_ENABLE);
13387 value_changed = true;
13388 }
13389 }
13390 else
13391 {
13392 wchar_t tmp[MAX_SIZE];
13393 UINT value;
13394 if (item->AllowZero)
13395 {
13396 if (changed)
13397 {
13398 Check(hWnd, R_DEFINE, POLICY_INT(s->Policy, i) != 0);
13399 Enable(hWnd, R_DEFINE);
13400 SetIntEx(hWnd, E_VALUE, POLICY_INT(s->Policy, i));
13401 }
13402
13403 SetEnable(hWnd, E_VALUE, IsChecked(hWnd, R_DEFINE));
13404 SetEnable(hWnd, S_TANI, IsChecked(hWnd, R_DEFINE));
13405 SetEnable(hWnd, S_LIMIT, IsChecked(hWnd, R_DEFINE));
13406 }
13407 else
13408 {
13409 if (changed)
13410 {
13411 Check(hWnd, R_DEFINE, true);
13412 Disable(hWnd, R_DEFINE);
13413 SetInt(hWnd, E_VALUE, POLICY_INT(s->Policy, i));
13414 }
13415
13416 SetEnable(hWnd, E_VALUE, IsChecked(hWnd, R_DEFINE));
13417 SetEnable(hWnd, S_TANI, IsChecked(hWnd, R_DEFINE));
13418 SetEnable(hWnd, S_LIMIT, IsChecked(hWnd, R_DEFINE));
13419 }
13420
13421 UniReplaceStrEx(tmp, sizeof(tmp), _UU(policy_item[i].FormatStr),
13422 L"%u ", L"", false);
13423 UniReplaceStrEx(tmp, sizeof(tmp), tmp,
13424 L"%u", L"", false);
13425
13426 SetText(hWnd, S_TANI, tmp);
13427
13428 UniFormat(tmp, sizeof(tmp), _UU("SM_LIMIT_STR"), policy_item[i].MinValue, policy_item[i].MaxValue);
13429 SetText(hWnd, S_LIMIT, tmp);
13430
13431 Hide(hWnd, R_ENABLE);
13432 Hide(hWnd, R_DISABLE);
13433 Show(hWnd, E_VALUE);
13434 Show(hWnd, R_DEFINE);
13435 Show(hWnd, S_TANI);
13436 Show(hWnd, S_LIMIT);
13437
13438 value = GetInt(hWnd, E_VALUE);
13439
13440 if (item->AllowZero && (IsChecked(hWnd, R_DEFINE) == false))
13441 {
13442 value = 0;
13443 }
13444 else
13445 {
13446 if (value < policy_item[i].MinValue || value > policy_item[i].MaxValue)
13447 {
13448 ok = false;
13449 }
13450 }
13451
13452 if (ok)
13453 {
13454 if (POLICY_INT(s->Policy, i) != value)
13455 {
13456 POLICY_INT(s->Policy, i) = value;
13457 value_changed = true;
13458 }
13459 }
13460 }
13461 }
13462
13463 SetEnable(hWnd, IDOK, ok);
13464 SetEnable(hWnd, L_POLICY, ok);
13465
13466 if (value_changed)
13467 {
13468 CM_POLICY cp;
13469 Zero(&cp, sizeof(cp));
13470 cp.Policy = s->Policy;
13471 cp.Extension = true;
13472
13473 CmPolicyDlgPrintEx(hWnd, &cp, s->CascadeMode);
13474 }
13475 }
13476
13477 // Confirmation
SmPolicyDlgOk(HWND hWnd,SM_POLICY * s)13478 void SmPolicyDlgOk(HWND hWnd, SM_POLICY *s)
13479 {
13480 // Validate arguments
13481 if (hWnd == NULL || s == NULL)
13482 {
13483 return;
13484 }
13485
13486 EndDialog(hWnd, true);
13487 }
13488
13489 // Policy dialog box procedure
SmPolicyDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)13490 UINT SmPolicyDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
13491 {
13492 SM_POLICY *s = (SM_POLICY *)param;
13493 NMHDR *n;
13494 // Validate arguments
13495 if (hWnd == NULL)
13496 {
13497 return 0;
13498 }
13499
13500 switch (msg)
13501 {
13502 case WM_INITDIALOG:
13503 // Initialize
13504 SmPolicyDlgInit(hWnd, s);
13505 break;
13506
13507 case WM_COMMAND:
13508 switch (LOWORD(wParam))
13509 {
13510 case R_DEFINE:
13511 case R_ENABLE:
13512 case R_DISABLE:
13513 case E_VALUE:
13514 SmPolicyDlgUpdate(hWnd, s);
13515 break;
13516 }
13517
13518 switch (wParam)
13519 {
13520 case IDOK:
13521 // [OK] button
13522 SmPolicyDlgOk(hWnd, s);
13523 break;
13524
13525 case IDCANCEL:
13526 // Cancel button
13527 Close(hWnd);
13528 break;
13529
13530 case R_DEFINE:
13531 if (IsChecked(hWnd, R_DEFINE))
13532 {
13533 FocusEx(hWnd, E_VALUE);
13534 }
13535 break;
13536 }
13537 break;
13538
13539 case WM_NOTIFY:
13540 n = (NMHDR *)lParam;
13541 switch (n->idFrom)
13542 {
13543 case L_POLICY:
13544 switch (n->code)
13545 {
13546 case LVN_ITEMCHANGED:
13547 SmPolicyDlgUpdate(hWnd, s);
13548 break;
13549 }
13550 break;
13551 }
13552 break;
13553
13554 case WM_CLOSE:
13555 EndDialog(hWnd, false);
13556 break;
13557 }
13558
13559 return 0;
13560 }
13561
13562 // Show Policies dialog box
SmPolicyDlg(HWND hWnd,POLICY * p,wchar_t * caption)13563 bool SmPolicyDlg(HWND hWnd, POLICY *p, wchar_t *caption)
13564 {
13565 return SmPolicyDlgEx(hWnd, p, caption, false);
13566 }
SmPolicyDlgEx(HWND hWnd,POLICY * p,wchar_t * caption,bool cascade_mode)13567 bool SmPolicyDlgEx(HWND hWnd, POLICY *p, wchar_t *caption, bool cascade_mode)
13568 {
13569 return SmPolicyDlgEx2(hWnd, p, caption, cascade_mode, POLICY_CURRENT_VERSION);
13570 }
SmPolicyDlgEx2(HWND hWnd,POLICY * p,wchar_t * caption,bool cascade_mode,UINT ver)13571 bool SmPolicyDlgEx2(HWND hWnd, POLICY *p, wchar_t *caption, bool cascade_mode, UINT ver)
13572 {
13573 SM_POLICY s;
13574 bool ret;
13575 // Validate arguments
13576 if (hWnd == NULL || p == NULL)
13577 {
13578 return false;
13579 }
13580
13581 if (caption == NULL)
13582 {
13583 caption = _UU("SM_POLICY_DEF_CAPTION");
13584 }
13585
13586 Zero(&s, sizeof(s));
13587 s.Caption = caption;
13588 s.Policy = ClonePolicy(p);
13589 s.CascadeMode = cascade_mode;
13590 s.Ver = ver;
13591
13592 ret = Dialog(hWnd, D_SM_POLICY, SmPolicyDlgProc, &s);
13593
13594 if (ret)
13595 {
13596 Copy(p, s.Policy, sizeof(POLICY));
13597 }
13598
13599 Free(s.Policy);
13600
13601 return ret;
13602 }
13603
13604 // Edit user confirmed
SmEditUserDlgOk(HWND hWnd,SM_EDIT_USER * s)13605 void SmEditUserDlgOk(HWND hWnd, SM_EDIT_USER *s)
13606 {
13607 RPC_SET_USER t;
13608 RPC_SET_USER *u;
13609 // Validate arguments
13610 if (hWnd == NULL || s == NULL)
13611 {
13612 return;
13613 }
13614
13615 SmEditUserDlgUpdate(hWnd, s);
13616
13617 Zero(&t, sizeof(t));
13618 u = &s->SetUser;
13619
13620 StrCpy(t.HubName, sizeof(t.HubName), u->HubName);
13621 StrCpy(t.Name, sizeof(t.Name), u->Name);
13622 StrCpy(t.GroupName, sizeof(t.GroupName), u->GroupName);
13623 UniStrCpy(t.Realname, sizeof(t.Realname), u->Realname);
13624 UniStrCpy(t.Note, sizeof(t.Note), u->Note);
13625 t.ExpireTime = u->ExpireTime;
13626 t.AuthType = u->AuthType;
13627 t.AuthData = CopyAuthData(u->AuthData, t.AuthType);
13628
13629 if (IsChecked(hWnd, R_POLICY))
13630 {
13631 t.Policy = ClonePolicy(u->Policy);
13632 }
13633 else
13634 {
13635 t.Policy = NULL;
13636 }
13637
13638 if (s->EditMode == false)
13639 {
13640 if (CALL(hWnd, ScCreateUser(s->Rpc, &t)) == false)
13641 {
13642 FocusEx(hWnd, E_USERNAME);
13643 return;
13644 }
13645 FreeRpcSetUser(&t);
13646
13647 MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("SM_USER_CREATE_OK"), u->Name);
13648 }
13649 else
13650 {
13651 if (CALL(hWnd, ScSetUser(s->Rpc, &t)) == false)
13652 {
13653 FocusEx(hWnd, E_REALNAME);
13654 return;
13655 }
13656 FreeRpcSetUser(&t);
13657 }
13658
13659 EndDialog(hWnd, true);
13660 }
13661
13662 // Edit user initialization
SmEditUserDlgInit(HWND hWnd,SM_EDIT_USER * s)13663 void SmEditUserDlgInit(HWND hWnd, SM_EDIT_USER *s)
13664 {
13665 RPC_SET_USER *u;
13666 wchar_t tmp[MAX_SIZE];
13667 UINT i;
13668 UINT icons[6] = {ICO_PASS, ICO_KEY, ICO_CERT, ICO_SERVER_CERT,
13669 ICO_TOWER, ICO_LINK};
13670 RECT rect;
13671
13672 // Validate arguments
13673 if (hWnd == NULL || s == NULL)
13674 {
13675 return;
13676 }
13677
13678 SetIcon(hWnd, 0, ICO_USER);
13679
13680 u = &s->SetUser;
13681
13682 // Initialize the column
13683 LvInit(hWnd, L_AUTH);
13684 LvSetStyle(hWnd, L_AUTH, LVS_EX_GRIDLINES);
13685
13686 GetClientRect(DlgItem(hWnd, L_AUTH), &rect);
13687 LvInsertColumn(hWnd, L_AUTH, 0, L"Name", rect.right - rect.left);
13688
13689 for (i = 0;i < 6;i++)
13690 {
13691 LvInsert(hWnd, L_AUTH, icons[i], (void *)i, 1, SmGetAuthTypeStr(i));
13692 }
13693
13694 // User name, etc.
13695 SetTextA(hWnd, E_USERNAME, u->Name);
13696 SetText(hWnd, E_REALNAME, u->Realname);
13697 SetText(hWnd, E_NOTE, u->Note);
13698
13699
13700 // Expiration date
13701 if (u->ExpireTime == 0)
13702 {
13703 SYSTEMTIME st;
13704 Check(hWnd, R_EXPIRES, false);
13705 GetLocalTime(&st);
13706 UINT64ToSystem(&st, SystemToUINT64(&st) + (60 * 60 * 24 * 1000));
13707 st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
13708 DateTime_SetSystemtime(DlgItem(hWnd, E_EXPIRES_DATE), GDT_VALID, &st);
13709 DateTime_SetSystemtime(DlgItem(hWnd, E_EXPIRES_TIME), GDT_VALID, &st);
13710 }
13711 else
13712 {
13713 SYSTEMTIME st;
13714 UINT64ToSystem(&st, SystemToLocal64(u->ExpireTime));
13715 Check(hWnd, R_EXPIRES, true);
13716 DateTime_SetSystemtime(DlgItem(hWnd, E_EXPIRES_DATE), GDT_VALID, &st);
13717 DateTime_SetSystemtime(DlgItem(hWnd, E_EXPIRES_TIME), GDT_VALID, &st);
13718 }
13719
13720 if (GetCurrentOsLangId() == SE_LANG_JAPANESE || GetCurrentOsLangId() == SE_LANG_CHINESE_ZH)
13721 {
13722 SetStyle(hWnd, E_EXPIRES_DATE, DTS_LONGDATEFORMAT);
13723 }
13724 else
13725 {
13726 SetStyle(hWnd, E_EXPIRES_DATE, DTS_SHORTDATEFORMAT);
13727 }
13728
13729 SetWindowLong(DlgItem(hWnd, E_EXPIRES_TIME), GWL_STYLE, WS_CHILDWINDOW | WS_VISIBLE | WS_TABSTOP | DTS_RIGHTALIGN | DTS_TIMEFORMAT | DTS_UPDOWN);
13730
13731 // Group name
13732 SetTextA(hWnd, E_GROUP, u->GroupName);
13733
13734 // Authentication method
13735 LvSelect(hWnd, L_AUTH, u->AuthType);
13736
13737 SetText(hWnd, S_CERT_INFO, _UU("SM_EDIT_USER_CERT_INFO"));
13738
13739 switch (u->AuthType)
13740 {
13741 case AUTHTYPE_PASSWORD:
13742 if (s->EditMode)
13743 {
13744 SetTextA(hWnd, E_PASSWORD1, HIDDEN_PASSWORD);
13745 SetTextA(hWnd, E_PASSWORD2, HIDDEN_PASSWORD);
13746 }
13747 break;
13748
13749 case AUTHTYPE_USERCERT:
13750 SmGetCertInfoStr(tmp, sizeof(tmp), ((AUTHUSERCERT *)u->AuthData)->UserX);
13751 break;
13752
13753 case AUTHTYPE_ROOTCERT:
13754 if (u->AuthData != NULL)
13755 {
13756 AUTHROOTCERT *c = (AUTHROOTCERT *)u->AuthData;
13757 if (c->CommonName != NULL && UniStrLen(c->CommonName) != 0)
13758 {
13759 Check(hWnd, R_CN, true);
13760 SetText(hWnd, E_CN, c->CommonName);
13761 }
13762 else
13763 {
13764 Check(hWnd, R_CN, false);
13765 }
13766 if (c->Serial != NULL && c->Serial->size != 0)
13767 {
13768 X_SERIAL *s = c->Serial;
13769 char *tmp;
13770 UINT tmp_size = s->size * 3 + 1;
13771 tmp = ZeroMalloc(tmp_size);
13772 BinToStrEx(tmp, tmp_size, s->data, s->size);
13773 SetTextA(hWnd, E_SERIAL, tmp);
13774 Free(tmp);
13775 Check(hWnd, R_SERIAL, true);
13776 }
13777 else
13778 {
13779 Check(hWnd, R_SERIAL, false);
13780 }
13781 }
13782 break;
13783
13784 case AUTHTYPE_RADIUS:
13785 if (u->AuthData != NULL)
13786 {
13787 AUTHRADIUS *r = (AUTHRADIUS *)u->AuthData;
13788 if (UniStrLen(r->RadiusUsername) != 0)
13789 {
13790 Check(hWnd, R_SET_RADIUS_USERNAME, true);
13791 SetText(hWnd, E_RADIUS_USERNAME, r->RadiusUsername);
13792 }
13793 else
13794 {
13795 Check(hWnd, R_SET_RADIUS_USERNAME, false);
13796 }
13797 }
13798 break;
13799
13800 case AUTHTYPE_NT:
13801 if (u->AuthData != NULL)
13802 {
13803 AUTHNT *n = (AUTHNT *)u->AuthData;
13804 if (UniStrLen(n->NtUsername) != 0)
13805 {
13806 Check(hWnd, R_SET_RADIUS_USERNAME, true);
13807 SetText(hWnd, E_RADIUS_USERNAME, n->NtUsername);
13808 }
13809 else
13810 {
13811 Check(hWnd, R_SET_RADIUS_USERNAME, false);
13812 }
13813 }
13814 break;
13815 }
13816
13817 if (u->Policy != NULL)
13818 {
13819 Check(hWnd, R_POLICY, true);
13820 }
13821
13822 s->Inited = true;
13823
13824 SmEditUserDlgUpdate(hWnd, s);
13825
13826 if (s->EditMode == false)
13827 {
13828 Focus(hWnd, E_USERNAME);
13829 SetText(hWnd, 0, _UU("SM_EDIT_USER_CAPTION_1"));
13830 }
13831 else
13832 {
13833 wchar_t tmp[MAX_SIZE];
13834 UniFormat(tmp, sizeof(tmp), _UU("SM_EDIT_USER_CAPTION_2"), s->SetUser.Name);
13835 SetText(hWnd, 0, tmp);
13836
13837 Disable(hWnd, E_USERNAME);
13838 FocusEx(hWnd, E_REALNAME);
13839 }
13840
13841 SetShow(hWnd, S_HINT, (s->EditMode ? false : true));
13842 }
13843
13844 // User edit control update
SmEditUserDlgUpdate(HWND hWnd,SM_EDIT_USER * s)13845 void SmEditUserDlgUpdate(HWND hWnd, SM_EDIT_USER *s)
13846 {
13847 RPC_SET_USER *u;
13848 bool ok = true;
13849 UINT old_authtype;
13850 char tmp1[MAX_SIZE];
13851 char tmp2[MAX_SIZE];
13852 bool authtype_changed = false;
13853 // Validate arguments
13854 if (hWnd == NULL || s == NULL)
13855 {
13856 return;
13857 }
13858
13859 if (s->Inited == false)
13860 {
13861 return;
13862 }
13863
13864 u = &s->SetUser;
13865
13866 // User name
13867 GetTxtA(hWnd, E_USERNAME, u->Name, sizeof(u->Name));
13868 Trim(u->Name);
13869 if (StrLen(u->Name) == 0 || IsUserName(u->Name) == false)
13870 {
13871 ok = false;
13872 }
13873
13874 // Real name
13875 GetTxt(hWnd, E_REALNAME, u->Realname, sizeof(u->Realname));
13876 UniTrim(u->Realname);
13877
13878 // Note
13879 GetTxt(hWnd, E_NOTE, u->Note, sizeof(u->Note));
13880 UniTrim(u->Realname);
13881
13882 // Group
13883 GetTxtA(hWnd, E_GROUP, u->GroupName, sizeof(u->GroupName));
13884 Trim(u->GroupName);
13885
13886 // Expiration date
13887 if (IsChecked(hWnd, R_EXPIRES) == false)
13888 {
13889 u->ExpireTime = 0;
13890 Disable(hWnd, E_EXPIRES_DATE);
13891 Disable(hWnd, E_EXPIRES_TIME);
13892 }
13893 else
13894 {
13895 SYSTEMTIME st1, st2;
13896 Enable(hWnd, E_EXPIRES_DATE);
13897 Enable(hWnd, E_EXPIRES_TIME);
13898 DateTime_GetSystemtime(DlgItem(hWnd, E_EXPIRES_DATE), &st1);
13899 DateTime_GetSystemtime(DlgItem(hWnd, E_EXPIRES_TIME), &st2);
13900 st1.wHour = st2.wHour;
13901 st1.wMinute = st2.wMinute;
13902 st1.wSecond = st2.wSecond;
13903 st1.wMilliseconds = st2.wMilliseconds;
13904 u->ExpireTime = LocalToSystem64(SystemToUINT64(&st1));
13905 }
13906
13907 // Authentication method
13908 old_authtype = u->AuthType;
13909 u->AuthType = LvGetSelected(hWnd, L_AUTH);
13910
13911 if (StrCmpi(u->Name, "*") == 0)
13912 {
13913 if (u->AuthType != AUTHTYPE_RADIUS && u->AuthType != AUTHTYPE_NT)
13914 {
13915 ok = false;
13916 }
13917 }
13918
13919 if (u->AuthType == INFINITE)
13920 {
13921 ok = false;
13922 u->AuthType = 0;
13923 }
13924 if (old_authtype != u->AuthType)
13925 {
13926 authtype_changed = true;
13927 }
13928
13929 if (authtype_changed)
13930 {
13931 FreeAuthData(old_authtype, u->AuthData);
13932 u->AuthData = NULL;
13933 switch (u->AuthType)
13934 {
13935 case AUTHTYPE_ANONYMOUS:
13936 u->AuthData = NULL;
13937 break;
13938
13939 case AUTHTYPE_PASSWORD:
13940 u->AuthData = NewPasswordAuthData("", "");
13941 GetTxtA(hWnd, E_PASSWORD1, tmp1, sizeof(tmp1));
13942 if (StrCmp(tmp1, HIDDEN_PASSWORD) == 0)
13943 {
13944 SetTextA(hWnd, E_PASSWORD1, "");
13945 }
13946 GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
13947 if (StrCmp(tmp2, HIDDEN_PASSWORD) == 0)
13948 {
13949 SetTextA(hWnd, E_PASSWORD2, "");
13950 }
13951 break;
13952
13953 case AUTHTYPE_USERCERT:
13954 u->AuthData = NewUserCertAuthData(NULL);
13955 SetText(hWnd, S_CERT_INFO, _UU("SM_EDIT_USER_CERT_INFO"));
13956 break;
13957
13958 case AUTHTYPE_ROOTCERT:
13959 u->AuthData = NewRootCertAuthData(NULL, NULL);
13960 break;
13961
13962 case AUTHTYPE_NT:
13963 u->AuthData = NewNTAuthData(L"");
13964 break;
13965
13966 case AUTHTYPE_RADIUS:
13967 u->AuthData = NewRadiusAuthData(L"");
13968 break;
13969 }
13970 }
13971
13972 SetEnable(hWnd, S_RADIUS_3, (u->AuthType == AUTHTYPE_RADIUS) || (u->AuthType == AUTHTYPE_NT));
13973 SetEnable(hWnd, R_SET_RADIUS_USERNAME, (u->AuthType == AUTHTYPE_RADIUS) || (u->AuthType == AUTHTYPE_NT));
13974 SetEnable(hWnd, S_RADIUS_1, (u->AuthType == AUTHTYPE_RADIUS) || (u->AuthType == AUTHTYPE_NT));
13975
13976 if (StrCmp(u->Name, "*") == 0)
13977 {
13978 Check(hWnd, R_SET_RADIUS_USERNAME, false);
13979 Disable(hWnd, R_SET_RADIUS_USERNAME);
13980 }
13981
13982 if ((u->AuthType == AUTHTYPE_RADIUS) || (u->AuthType == AUTHTYPE_NT))
13983 {
13984 SetEnable(hWnd, E_RADIUS_USERNAME, IsChecked(hWnd, R_SET_RADIUS_USERNAME));
13985 SetEnable(hWnd, S_RADIUS_2, IsChecked(hWnd, R_SET_RADIUS_USERNAME));
13986 }
13987 else
13988 {
13989 SetEnable(hWnd, E_RADIUS_USERNAME, false);
13990 SetEnable(hWnd, S_RADIUS_2, false);
13991 }
13992
13993 SetEnable(hWnd, S_PASSWORD_1, u->AuthType == AUTHTYPE_PASSWORD);
13994 SetEnable(hWnd, S_PASSWORD_2, u->AuthType == AUTHTYPE_PASSWORD);
13995 SetEnable(hWnd, S_PASSWORD_3, u->AuthType == AUTHTYPE_PASSWORD);
13996 SetEnable(hWnd, E_PASSWORD1, u->AuthType == AUTHTYPE_PASSWORD);
13997 SetEnable(hWnd, E_PASSWORD2, u->AuthType == AUTHTYPE_PASSWORD);
13998
13999 SetEnable(hWnd, S_USER_CERT_1, u->AuthType == AUTHTYPE_USERCERT);
14000 SetEnable(hWnd, S_CERT_INFO, u->AuthType == AUTHTYPE_USERCERT);
14001 SetEnable(hWnd, B_LOAD_CERT, u->AuthType == AUTHTYPE_USERCERT);
14002
14003 if (u->AuthType == AUTHTYPE_USERCERT)
14004 {
14005 SetEnable(hWnd, B_VIEW_CERT, ((AUTHUSERCERT *)u->AuthData)->UserX != NULL);
14006 }
14007 else
14008 {
14009 SetEnable(hWnd, B_VIEW_CERT, false);
14010 }
14011
14012 SetEnable(hWnd, S_ROOT_CERT_1, u->AuthType == AUTHTYPE_ROOTCERT);
14013 SetEnable(hWnd, S_ROOT_CERT_2, u->AuthType == AUTHTYPE_ROOTCERT);
14014 SetEnable(hWnd, S_ROOT_CERT_3, u->AuthType == AUTHTYPE_ROOTCERT);
14015 SetEnable(hWnd, R_CN, u->AuthType == AUTHTYPE_ROOTCERT);
14016 SetEnable(hWnd, R_SERIAL, u->AuthType == AUTHTYPE_ROOTCERT);
14017
14018 if (u->AuthType == AUTHTYPE_ROOTCERT)
14019 {
14020 SetEnable(hWnd, E_CN, IsChecked(hWnd, R_CN));
14021 SetEnable(hWnd, E_SERIAL, IsChecked(hWnd, R_SERIAL));
14022 }
14023 else
14024 {
14025 Disable(hWnd, E_CN);
14026 Disable(hWnd, E_SERIAL);
14027 }
14028
14029 switch (u->AuthType)
14030 {
14031 case AUTHTYPE_PASSWORD:
14032 GetTxtA(hWnd, E_PASSWORD1, tmp1, sizeof(tmp1));
14033 GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
14034 if (StrCmp(tmp1, tmp2) != 0)
14035 {
14036 ok = false;
14037 }
14038 else
14039 {
14040 if (StrCmp(tmp1, HIDDEN_PASSWORD) != 0)
14041 {
14042 HashPassword(((AUTHPASSWORD *)u->AuthData)->HashedKey, u->Name, tmp1);
14043 GenerateNtPasswordHash(((AUTHPASSWORD *)u->AuthData)->NtLmSecureHash, tmp1);
14044 }
14045 }
14046 break;
14047
14048 case AUTHTYPE_USERCERT:
14049 if (((AUTHUSERCERT *)u->AuthData)->UserX == NULL)
14050 {
14051 ok = false;
14052 }
14053 break;
14054
14055 case AUTHTYPE_ROOTCERT:
14056 Free(((AUTHROOTCERT *)u->AuthData)->CommonName);
14057 ((AUTHROOTCERT *)u->AuthData)->CommonName = NULL;
14058 if (IsChecked(hWnd, R_CN) && (IsEmpty(hWnd, E_CN) == false))
14059 {
14060 ((AUTHROOTCERT *)u->AuthData)->CommonName = GetText(hWnd, E_CN);
14061 UniTrim(((AUTHROOTCERT *)u->AuthData)->CommonName);
14062 }
14063 if (IsChecked(hWnd, R_CN) && ((AUTHROOTCERT *)u->AuthData)->CommonName == NULL)
14064 {
14065 ok = false;
14066 }
14067 FreeXSerial(((AUTHROOTCERT *)u->AuthData)->Serial);
14068 ((AUTHROOTCERT *)u->AuthData)->Serial = NULL;
14069 if (IsChecked(hWnd, R_SERIAL))
14070 {
14071 char *serial_str = GetTextA(hWnd, E_SERIAL);
14072 if (serial_str != NULL)
14073 {
14074 BUF *b = StrToBin(serial_str);
14075 if (b->Size >= 1)
14076 {
14077 ((AUTHROOTCERT *)u->AuthData)->Serial = NewXSerial(b->Buf, b->Size);
14078 }
14079 FreeBuf(b);
14080 Free(serial_str);
14081 }
14082 }
14083 if (IsChecked(hWnd, R_SERIAL) && ((AUTHROOTCERT *)u->AuthData)->Serial == NULL)
14084 {
14085 ok = false;
14086 }
14087 break;
14088
14089 case AUTHTYPE_RADIUS:
14090 Free(((AUTHRADIUS *)u->AuthData)->RadiusUsername);
14091 ((AUTHRADIUS *)u->AuthData)->RadiusUsername = NULL;
14092 if (IsChecked(hWnd, R_SET_RADIUS_USERNAME) && (IsEmpty(hWnd, E_RADIUS_USERNAME) == false))
14093 {
14094 ((AUTHRADIUS *)u->AuthData)->RadiusUsername = GetText(hWnd, E_RADIUS_USERNAME);
14095 }
14096 if (IsChecked(hWnd, R_SET_RADIUS_USERNAME) && ((AUTHRADIUS *)u->AuthData)->RadiusUsername == NULL)
14097 {
14098 ok = false;
14099 }
14100 break;
14101
14102 case AUTHTYPE_NT:
14103 Free(((AUTHNT *)u->AuthData)->NtUsername);
14104 ((AUTHNT *)u->AuthData)->NtUsername = NULL;
14105 if (IsChecked(hWnd, R_SET_RADIUS_USERNAME) && (IsEmpty(hWnd, E_RADIUS_USERNAME) == false))
14106 {
14107 ((AUTHNT *)u->AuthData)->NtUsername = GetText(hWnd, E_RADIUS_USERNAME);
14108 }
14109 if (IsChecked(hWnd, R_SET_RADIUS_USERNAME) && ((AUTHNT *)u->AuthData)->NtUsername == NULL)
14110 {
14111 ok = false;
14112 }
14113 break;
14114 }
14115
14116 SetEnable(hWnd, B_POLICY, IsChecked(hWnd, R_POLICY));
14117 if (IsChecked(hWnd, R_POLICY))
14118 {
14119 if (u->Policy == NULL)
14120 {
14121 ok = false;
14122 }
14123 }
14124
14125 SetEnable(hWnd, IDOK, ok);
14126 }
14127
14128 // Edit User dialog procedure
SmEditUserDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)14129 UINT SmEditUserDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
14130 {
14131 SM_EDIT_USER *s = (SM_EDIT_USER *)param;
14132 NMHDR *n;
14133 POLICY *policy;
14134 X *x = NULL;
14135 wchar_t tmp[MAX_SIZE];
14136 char name[MAX_SIZE];
14137 char *ret;
14138 // Validate arguments
14139 if (hWnd == NULL)
14140 {
14141 return 0;
14142 }
14143
14144 switch (msg)
14145 {
14146 case WM_INITDIALOG:
14147 // Initialize
14148 SmEditUserDlgInit(hWnd, s);
14149 break;
14150
14151 case WM_COMMAND:
14152 switch (LOWORD(wParam))
14153 {
14154 case E_USERNAME:
14155 case E_REALNAME:
14156 case E_NOTE:
14157 case R_EXPIRES:
14158 case E_EXPIRES_DATE:
14159 case E_EXPIRES_TIME:
14160 case E_GROUP:
14161 case L_AUTH:
14162 case R_SET_RADIUS_USERNAME:
14163 case E_RADIUS_USERNAME:
14164 case R_POLICY:
14165 case E_PASSWORD1:
14166 case E_PASSWORD2:
14167 case R_CN:
14168 case E_CN:
14169 case R_SERIAL:
14170 case E_SERIAL:
14171 SmEditUserDlgUpdate(hWnd, s);
14172 break;
14173 }
14174
14175 switch (wParam)
14176 {
14177 case IDOK:
14178 // [OK] button
14179 SmEditUserDlgOk(hWnd, s);
14180 break;
14181
14182 case IDCANCEL:
14183 // Cancel button
14184 Close(hWnd);
14185 break;
14186
14187 case B_POLICY:
14188 UniFormat(tmp, sizeof(tmp), _UU("SM_EDIT_USER_POL_DLG"), s->SetUser.Name);
14189 // Policy
14190 if (s->SetUser.Policy == NULL)
14191 {
14192 policy = ClonePolicy(GetDefaultPolicy());
14193 if (SmPolicyDlgEx2(hWnd, policy, tmp, false, s->p->PolicyVer))
14194 {
14195 s->SetUser.Policy = policy;
14196 SmEditUserDlgUpdate(hWnd, s);
14197 }
14198 else
14199 {
14200 Free(policy);
14201 }
14202 }
14203 else
14204 {
14205 SmPolicyDlgEx2(hWnd, s->SetUser.Policy, tmp, false, s->p->PolicyVer);
14206 }
14207 break;
14208
14209 case B_GROUP:
14210 // Browse for a Group
14211 GetTxtA(hWnd, E_GROUP, name, sizeof(name));
14212 Trim(name);
14213 ret = SmSelectGroupDlg(hWnd, s->Hub, StrLen(name) == 0 ? NULL : name);
14214 if (ret != NULL)
14215 {
14216 SetTextA(hWnd, E_GROUP, ret);
14217 Free(ret);
14218 }
14219 else
14220 {
14221 SetTextA(hWnd, E_GROUP, "");
14222 }
14223 FocusEx(hWnd, E_GROUP);
14224 break;
14225
14226 case B_LOAD_CERT:
14227 // Specify the certificate
14228 if (CmLoadXFromFileOrSecureCard(hWnd, &x))
14229 {
14230 UPDATE_CERT:
14231 if (s->SetUser.AuthType == AUTHTYPE_USERCERT)
14232 {
14233 wchar_t tmp[MAX_SIZE];
14234 FreeX(((AUTHUSERCERT *)s->SetUser.AuthData)->UserX);
14235 ((AUTHUSERCERT *)s->SetUser.AuthData)->UserX = x;
14236 SmGetCertInfoStr(tmp, sizeof(tmp), x);
14237 SetText(hWnd, S_CERT_INFO, tmp);
14238 SmEditUserDlgUpdate(hWnd, s);
14239 }
14240 else
14241 {
14242 if (x != NULL)
14243 {
14244 FreeX(x);
14245 x = NULL;
14246 }
14247 }
14248 }
14249 break;
14250
14251 case B_VIEW_CERT:
14252 // Show the certificate
14253 if (s->SetUser.AuthType == AUTHTYPE_USERCERT)
14254 {
14255 CertDlg(hWnd, ((AUTHUSERCERT *)s->SetUser.AuthData)->UserX, NULL, true);
14256 }
14257 break;
14258
14259 case B_CREATE:
14260 // Create
14261 GetTxtA(hWnd, E_USERNAME, name, sizeof(name));
14262 Trim(name);
14263 if (SmCreateCert(hWnd, &x, NULL, false, name, false))
14264 {
14265 if (s->SetUser.AuthType != AUTHTYPE_USERCERT)
14266 {
14267 LvSelect(hWnd, L_AUTH, 2);
14268 }
14269 goto UPDATE_CERT;
14270 }
14271 break;
14272
14273 case R_SET_RADIUS_USERNAME:
14274 if (IsChecked(hWnd, R_SET_RADIUS_USERNAME))
14275 {
14276 FocusEx(hWnd, E_RADIUS_USERNAME);
14277 }
14278 break;
14279
14280 case R_EXPIRES:
14281 if (IsChecked(hWnd, R_EXPIRES))
14282 {
14283 Focus(hWnd, E_EXPIRES_DATE);
14284 }
14285 break;
14286
14287 case R_POLICY:
14288 if (IsChecked(hWnd, R_POLICY))
14289 {
14290 Focus(hWnd, B_POLICY);
14291 }
14292 break;
14293
14294 case R_CN:
14295 if (IsChecked(hWnd, R_CN))
14296 {
14297 Focus(hWnd, E_CN);
14298 }
14299 break;
14300
14301 case R_SERIAL:
14302 if (IsChecked(hWnd, R_SERIAL))
14303 {
14304 Focus(hWnd, E_SERIAL);
14305 }
14306 break;
14307 }
14308 break;
14309
14310 case WM_NOTIFY:
14311 n = (NMHDR *)lParam;
14312 switch (n->idFrom)
14313 {
14314 case L_AUTH:
14315 switch (n->code)
14316 {
14317 case LVN_ITEMCHANGED:
14318 SmEditUserDlgUpdate(hWnd, s);
14319 break;
14320 }
14321 break;
14322 }
14323 break;
14324
14325 case WM_CLOSE:
14326 EndDialog(hWnd, false);
14327 break;
14328 }
14329
14330 return 0;
14331 }
14332
14333 // User editing dialog
SmEditUserDlg(HWND hWnd,SM_HUB * s,char * username)14334 bool SmEditUserDlg(HWND hWnd, SM_HUB *s, char *username)
14335 {
14336 SM_EDIT_USER e;
14337 bool ret;
14338 // Validate arguments
14339 if (hWnd == NULL || s == NULL || username == NULL)
14340 {
14341 return false;
14342 }
14343
14344 Zero(&e, sizeof(e));
14345 e.p = s->p;
14346 e.Rpc = s->Rpc;
14347 e.Hub = s;
14348
14349 // Get the User
14350 StrCpy(e.SetUser.HubName, sizeof(e.SetUser.HubName), e.Hub->HubName);
14351 StrCpy(e.SetUser.Name, sizeof(e.SetUser.Name), username);
14352
14353 if (CALL(hWnd, ScGetUser(s->Rpc, &e.SetUser)) == false)
14354 {
14355 return false;
14356 }
14357
14358 e.EditMode = true;
14359
14360 ret = Dialog(hWnd, D_SM_EDIT_USER, SmEditUserDlgProc, &e);
14361
14362 FreeRpcSetUser(&e.SetUser);
14363
14364 return ret;
14365 }
14366
14367 // New user creation dialog
SmCreateUserDlg(HWND hWnd,SM_HUB * s)14368 bool SmCreateUserDlg(HWND hWnd, SM_HUB *s)
14369 {
14370 SM_EDIT_USER e;
14371 bool ret;
14372 // Validate arguments
14373 if (hWnd == NULL || s == NULL)
14374 {
14375 return false;
14376 }
14377
14378 Zero(&e, sizeof(e));
14379 e.EditMode = false;
14380 e.p = s->p;
14381 e.Rpc = s->Rpc;
14382 e.Hub = s;
14383
14384 // Set up a new user
14385 StrCpy(e.SetUser.HubName, sizeof(e.SetUser.HubName), e.Hub->HubName);
14386 e.SetUser.AuthType = CLIENT_AUTHTYPE_PASSWORD;
14387 e.SetUser.AuthData = NewPasswordAuthData("", "");
14388
14389 ret = Dialog(hWnd, D_SM_EDIT_USER, SmEditUserDlgProc, &e);
14390
14391 FreeRpcSetUser(&e.SetUser);
14392
14393 return ret;
14394 }
14395
14396 // Get a string of user authentication method
SmGetAuthTypeStr(UINT id)14397 wchar_t *SmGetAuthTypeStr(UINT id)
14398 {
14399 return GetAuthTypeStr(id);
14400 }
14401
14402 // User list initialization
SmUserListInit(HWND hWnd,SM_USER * s)14403 void SmUserListInit(HWND hWnd, SM_USER *s)
14404 {
14405 wchar_t tmp1[MAX_SIZE];
14406 wchar_t tmp2[MAX_SIZE];
14407 // Validate arguments
14408 if (hWnd == NULL || s == NULL)
14409 {
14410 return;
14411 }
14412
14413 SetIcon(hWnd, 0, ICO_USER);
14414
14415 // Initialize the column
14416 LvInit(hWnd, L_USER);
14417 LvSetStyle(hWnd, L_USER, LVS_EX_GRIDLINES);
14418 LvInsertColumn(hWnd, L_USER, 0, _UU("SM_USER_COLUMN_1"), 120);
14419 LvInsertColumn(hWnd, L_USER, 1, _UU("SM_USER_COLUMN_2"), 100);
14420 LvInsertColumn(hWnd, L_USER, 2, _UU("SM_USER_COLUMN_3"), 100);
14421 LvInsertColumn(hWnd, L_USER, 3, _UU("SM_USER_COLUMN_4"), 130);
14422 LvInsertColumn(hWnd, L_USER, 4, _UU("SM_USER_COLUMN_5"), 100);
14423 LvInsertColumn(hWnd, L_USER, 5, _UU("SM_USER_COLUMN_6"), 90);
14424 LvInsertColumn(hWnd, L_USER, 6, _UU("SM_USER_COLUMN_7"), 120);
14425 LvInsertColumn(hWnd, L_USER, 7, _UU("SM_LICENSE_COLUMN_5"), 120);
14426 LvInsertColumn(hWnd, L_USER, 8, _UU("SM_SESS_COLUMN_6"), 100);
14427 LvInsertColumn(hWnd, L_USER, 9, _UU("SM_SESS_COLUMN_7"), 100);
14428
14429 FormatText(hWnd, S_TITLE, s->Hub->HubName);
14430
14431 if (s->GroupName != NULL)
14432 {
14433 GetTxt(hWnd, 0, tmp1, sizeof(tmp1));
14434 UniFormat(tmp2, sizeof(tmp2), _UU("SM_GROUP_MEMBER_STR"), s->GroupName);
14435 UniStrCat(tmp1, sizeof(tmp1), tmp2);
14436 SetText(hWnd, S_TITLE, tmp1);
14437 Disable(hWnd, B_CREATE);
14438 }
14439
14440 if (s->SelectMode)
14441 {
14442 SetStyle(hWnd, L_USER, LVS_SINGLESEL);
14443 }
14444
14445 SmUserListRefresh(hWnd, s);
14446
14447 if (s->SelectMode)
14448 {
14449 wchar_t tmp[MAX_SIZE];
14450 UINT i;
14451 StrToUni(tmp, sizeof(tmp), s->SelectedName);
14452 i = LvSearchStr(hWnd, L_USER, 0, tmp);
14453 if (i != INFINITE)
14454 {
14455 LvSelect(hWnd, L_USER, i);
14456 }
14457
14458 if (s->AllowGroup)
14459 {
14460 SetText(hWnd, B_DELETE, _UU("SM_SELECT_ALT_GROUP"));
14461 }
14462 }
14463 }
14464
14465 // User list update
SmUserListRefresh(HWND hWnd,SM_USER * s)14466 void SmUserListRefresh(HWND hWnd, SM_USER *s)
14467 {
14468 LVB *b;
14469 RPC_ENUM_USER t;
14470 UINT i;
14471 // Validate arguments
14472 if (hWnd == NULL || s == NULL)
14473 {
14474 return;
14475 }
14476
14477 Zero(&t, sizeof(t));
14478
14479 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
14480 if (CALL(hWnd, ScEnumUser(s->Rpc, &t)) == false)
14481 {
14482 EndDialog(hWnd, false);
14483 return;
14484 }
14485
14486 b = LvInsertStart();
14487
14488 for (i = 0;i < t.NumUser;i++)
14489 {
14490 RPC_ENUM_USER_ITEM *e = &t.Users[i];
14491 wchar_t name[MAX_SIZE];
14492 wchar_t group[MAX_SIZE];
14493 wchar_t num[MAX_SIZE];
14494 wchar_t time[MAX_SIZE];
14495 wchar_t exp[MAX_SIZE];
14496 wchar_t num1[64], num2[64];
14497
14498 if (s->GroupName != NULL)
14499 {
14500 if (StrCmpi(s->GroupName, e->GroupName) != 0)
14501 {
14502 continue;
14503 }
14504 }
14505
14506 StrToUni(name, sizeof(name), e->Name);
14507
14508 if (StrLen(e->GroupName) != 0)
14509 {
14510 StrToUni(group, sizeof(group), e->GroupName);
14511 }
14512 else
14513 {
14514 UniStrCpy(group, sizeof(group), _UU("SM_NO_GROUP"));
14515 }
14516
14517 UniToStru(num, e->NumLogin);
14518
14519 GetDateTimeStrEx64(time, sizeof(time), SystemToLocal64(e->LastLoginTime), NULL);
14520
14521 if (e->IsExpiresFilled == false)
14522 {
14523 UniStrCpy(exp, sizeof(exp), _UU("CM_ST_NONE"));
14524 }
14525 else
14526 {
14527 if (e->Expires == 0)
14528 {
14529 UniStrCpy(exp, sizeof(exp), _UU("SM_LICENSE_NO_EXPIRES"));
14530 }
14531 else
14532 {
14533 GetDateTimeStrEx64(exp, sizeof(exp), SystemToLocal64(e->Expires), NULL);
14534 }
14535 }
14536
14537 if (e->IsTrafficFilled == false)
14538 {
14539 UniStrCpy(num1, sizeof(num1), _UU("CM_ST_NONE"));
14540 UniStrCpy(num2, sizeof(num2), _UU("CM_ST_NONE"));
14541 }
14542 else
14543 {
14544 UniToStr3(num1, sizeof(num1),
14545 e->Traffic.Recv.BroadcastBytes + e->Traffic.Recv.UnicastBytes +
14546 e->Traffic.Send.BroadcastBytes + e->Traffic.Send.UnicastBytes);
14547
14548 UniToStr3(num2, sizeof(num2),
14549 e->Traffic.Recv.BroadcastCount + e->Traffic.Recv.UnicastCount +
14550 e->Traffic.Send.BroadcastBytes + e->Traffic.Send.UnicastCount);
14551 }
14552
14553 LvInsertAdd(b, e->DenyAccess ? ICO_USER_DENY : ICO_USER, NULL, 10,
14554 name, e->Realname, group, e->Note, SmGetAuthTypeStr(e->AuthType),
14555 num, time, exp, num1, num2);
14556 }
14557
14558 LvInsertEnd(b, hWnd, L_USER);
14559
14560 FreeRpcEnumUser(&t);
14561
14562 SmUserListUpdate(hWnd, s);
14563 }
14564
14565 // User list control update
SmUserListUpdate(HWND hWnd,SM_USER * s)14566 void SmUserListUpdate(HWND hWnd, SM_USER *s)
14567 {
14568 bool b = true;
14569 // Validate arguments
14570 if (hWnd == NULL || s == NULL)
14571 {
14572 return;
14573 }
14574
14575 if (LvIsSelected(hWnd, L_USER) == false || LvIsMultiMasked(hWnd, L_USER))
14576 {
14577 b = false;
14578 }
14579
14580 if (s->SelectMode)
14581 {
14582 SetText(hWnd, IDOK, _UU("SM_SELECT_USER"));
14583 SetText(hWnd, IDCANCEL, _UU("SM_SELECT_NO"));
14584 SetText(hWnd, S_TITLE, _UU("SM_PLEASE_SELECT"));
14585 }
14586
14587 SetEnable(hWnd, IDOK, b);
14588
14589 SetEnable(hWnd, B_STATUS, b);
14590 SetEnable(hWnd, B_DELETE, (b && s->SelectedName == false) || s->AllowGroup);
14591 SetEnable(hWnd, B_CREATE, s->SelectedName == false);
14592 }
14593
14594 // User List dialog procedure
SmUserListProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)14595 UINT SmUserListProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
14596 {
14597 SM_USER *s = (SM_USER *)param;
14598 NMHDR *n;
14599 wchar_t *str;
14600 // Validate arguments
14601 if (hWnd == NULL)
14602 {
14603 return 0;
14604 }
14605
14606 switch (msg)
14607 {
14608 case WM_INITDIALOG:
14609 // Initialize
14610 SmUserListInit(hWnd, s);
14611
14612 if (s->CreateNow)
14613 {
14614 // Create instantly
14615 if (IsEnable(hWnd, B_CREATE))
14616 {
14617 Command(hWnd, B_CREATE);
14618 }
14619 }
14620 break;
14621
14622 case WM_COMMAND:
14623 switch (wParam)
14624 {
14625 case IDOK:
14626 if (s->SelectMode == false)
14627 {
14628 // Property
14629 str = LvGetSelectedStr(hWnd, L_USER, 0);
14630 if (str != NULL)
14631 {
14632 char name[MAX_SIZE];
14633 UniToStr(name, sizeof(name), str);
14634
14635 if (SmEditUserDlg(hWnd, s->Hub, name))
14636 {
14637 SmUserListRefresh(hWnd, s);
14638 }
14639
14640 Free(str);
14641 }
14642 }
14643 else
14644 {
14645 // The user has been chosen
14646 str = LvGetSelectedStr(hWnd, L_USER, 0);
14647 if (str != NULL)
14648 {
14649 char name[MAX_SIZE];
14650 UniToStr(name, sizeof(name), str);
14651
14652 s->SelectedName = CopyStr(name);
14653
14654 EndDialog(hWnd, true);
14655
14656 Free(str);
14657 }
14658 }
14659 break;
14660
14661 case B_CREATE:
14662 // Create new
14663 if (SmCreateUserDlg(hWnd, s->Hub))
14664 {
14665 SmUserListRefresh(hWnd, s);
14666 }
14667 break;
14668
14669 case B_DELETE:
14670 if (s->AllowGroup)
14671 {
14672 // Group selection
14673 EndDialog(hWnd, INFINITE);
14674 }
14675 else
14676 {
14677 // Delete
14678 str = LvGetSelectedStr(hWnd, L_USER, 0);
14679 if (str != NULL)
14680 {
14681 RPC_DELETE_USER t;
14682 char name[MAX_SIZE];
14683 UniToStr(name, sizeof(name), str);
14684
14685 Zero(&t, sizeof(t));
14686 StrCpy(t.HubName, sizeof(t.HubName), s->Hub->HubName);
14687 StrCpy(t.Name, sizeof(t.Name), name);
14688
14689 if (MsgBoxEx(hWnd, MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION,
14690 _UU("SM_USER_DELETE_MSG"), str) == IDYES)
14691 {
14692 if (CALL(hWnd, ScDeleteUser(s->Rpc, &t)))
14693 {
14694 SmUserListRefresh(hWnd, s);
14695 }
14696 }
14697
14698 Free(str);
14699 }
14700 }
14701 break;
14702
14703 case B_STATUS:
14704 // Display the User Information
14705 str = LvGetSelectedStr(hWnd, L_USER, 0);
14706 if (str != NULL)
14707 {
14708 char name[MAX_SIZE];
14709 wchar_t tmp[MAX_SIZE];
14710 SM_USER_INFO info;
14711 UniToStr(name, sizeof(name), str);
14712
14713 UniFormat(tmp, sizeof(tmp), _UU("SM_USERINFO_CAPTION"), name);
14714
14715 Zero(&info, sizeof(info));
14716 info.p = s->p;
14717 info.Rpc = s->Rpc;
14718 info.Hub = s->Hub;
14719 info.Username = name;
14720
14721 SmStatusDlg(hWnd, s->p, &info, false, true, tmp, ICO_USER, NULL, SmRefreshUserInfo);
14722
14723 Free(str);
14724 }
14725 break;
14726 break;
14727
14728 case B_REFRESH:
14729 // Update
14730 SmUserListRefresh(hWnd, s);
14731 break;
14732
14733 case IDCANCEL:
14734 // Cancel button
14735 Close(hWnd);
14736 break;
14737 }
14738 break;
14739
14740 case WM_NOTIFY:
14741 n = (NMHDR *)lParam;
14742 switch (n->idFrom)
14743 {
14744 case L_USER:
14745 switch (n->code)
14746 {
14747 case LVN_ITEMCHANGED:
14748 // Update the control
14749 SmUserListUpdate(hWnd, s);
14750 break;
14751 }
14752 break;
14753 }
14754 break;
14755
14756 case WM_CLOSE:
14757 EndDialog(hWnd, false);
14758 break;
14759 }
14760
14761 LvStandardHandler(hWnd, msg, wParam, lParam, L_USER);
14762
14763 return 0;
14764 }
14765
14766 // User List dialog (selection)
SmSelectUserDlg(HWND hWnd,SM_HUB * s,char * default_name)14767 char *SmSelectUserDlg(HWND hWnd, SM_HUB *s, char *default_name)
14768 {
14769 return SmSelectUserDlgEx(hWnd, s, default_name, false);
14770 }
SmSelectUserDlgEx(HWND hWnd,SM_HUB * s,char * default_name,bool allow_group)14771 char *SmSelectUserDlgEx(HWND hWnd, SM_HUB *s, char *default_name, bool allow_group)
14772 {
14773 UINT ret;
14774 SM_USER user;
14775 // Validate arguments
14776 if (hWnd == NULL || s == NULL)
14777 {
14778 return NULL;
14779 }
14780
14781 Zero(&user, sizeof(user));
14782 user.Hub = s;
14783 user.p = s->p;
14784 user.Rpc = s->Rpc;
14785 user.GroupName = NULL;
14786 user.SelectedName = default_name;
14787 user.SelectMode = true;
14788 user.AllowGroup = allow_group;
14789
14790 ret = Dialog(hWnd, D_SM_USER, SmUserListProc, &user);
14791
14792 if (ret == 0)
14793 {
14794 return NULL;
14795 }
14796 else if (ret == INFINITE)
14797 {
14798 // Select a Group
14799 return SmSelectGroupDlg(hWnd, s, default_name);
14800 }
14801 else
14802 {
14803 return user.SelectedName;
14804 }
14805 }
14806
14807 // User List dialog (filtered by group name)
SmUserListDlgEx(HWND hWnd,SM_HUB * s,char * groupname,bool create)14808 void SmUserListDlgEx(HWND hWnd, SM_HUB *s, char *groupname, bool create)
14809 {
14810 SM_USER user;
14811 // Validate arguments
14812 if (hWnd == NULL || s == NULL)
14813 {
14814 return;
14815 }
14816
14817 Zero(&user, sizeof(user));
14818 user.Hub = s;
14819 user.p = s->p;
14820 user.Rpc = s->Rpc;
14821 user.GroupName = groupname;
14822 user.CreateNow = create;
14823
14824 Dialog(hWnd, D_SM_USER, SmUserListProc, &user);
14825 }
14826
14827 // User List dialog
SmUserListDlg(HWND hWnd,SM_HUB * s)14828 void SmUserListDlg(HWND hWnd, SM_HUB *s)
14829 {
14830 SmUserListDlgEx(hWnd, s, NULL, false);
14831 }
14832
14833 // Initialize
SmHubDlgInit(HWND hWnd,SM_HUB * s)14834 void SmHubDlgInit(HWND hWnd, SM_HUB *s)
14835 {
14836 CAPSLIST *caps;
14837 bool support_user, support_group, support_accesslist, support_cascade,
14838 support_log, support_config_hub, support_secure_nat, support_config_radius;
14839 // Validate arguments
14840 if (hWnd == NULL || s == NULL)
14841 {
14842 return;
14843 }
14844
14845 FormatText(hWnd, 0, s->HubName);
14846 FormatText(hWnd, S_TITLE, s->HubName);
14847 SetIcon(hWnd, 0, ICO_HUB);
14848 DlgFont(hWnd, S_TITLE, 15, true);
14849
14850 LvInit(hWnd, L_STATUS);
14851 LvSetStyle(hWnd, L_STATUS, LVS_EX_GRIDLINES);
14852 LvInsertColumn(hWnd, L_STATUS, 0, _UU("SM_STATUS_COLUMN_1"), 0);
14853 LvInsertColumn(hWnd, L_STATUS, 1, _UU("SM_STATUS_COLUMN_2"), 0);
14854
14855 caps = s->p->CapsList;
14856
14857 support_user = GetCapsInt(caps, "i_max_users_per_hub") == 0 ? false : true;
14858 support_group = GetCapsInt(caps, "i_max_groups_per_hub") == 0 ? false : true;
14859 support_accesslist = GetCapsInt(caps, "i_max_access_lists") == 0 ? false : true;
14860 support_cascade = GetCapsBool(caps, "b_support_cascade");
14861 support_log = GetCapsBool(caps, "b_support_config_log");
14862 support_config_hub = GetCapsBool(caps, "b_support_config_hub");
14863 support_secure_nat = GetCapsBool(caps, "b_support_securenat");
14864 support_config_radius = GetCapsBool(caps, "b_support_radius");
14865
14866 SetEnable(hWnd, B_USER, support_user);
14867 SetEnable(hWnd, S_USER, support_user);
14868
14869 SetEnable(hWnd, B_GROUP, support_group);
14870 SetEnable(hWnd, S_GROUP, support_group);
14871
14872 SetEnable(hWnd, B_ACCESS, support_accesslist);
14873 SetEnable(hWnd, S_ACCESS, support_accesslist);
14874
14875 SetEnable(hWnd, B_PROPERTY, s->p->ServerType != SERVER_TYPE_FARM_MEMBER);
14876 SetEnable(hWnd, S_PROPERTY, s->p->ServerType != SERVER_TYPE_FARM_MEMBER);
14877
14878 SetEnable(hWnd, B_RADIUS, support_config_radius);
14879 SetEnable(hWnd, S_RADIUS, support_config_radius);
14880
14881 SetEnable(hWnd, B_LINK, support_cascade);
14882 SetEnable(hWnd, S_LINK, support_cascade);
14883
14884 SetEnable(hWnd, B_LOG, support_log);
14885 SetEnable(hWnd, S_LOG, support_log);
14886
14887 SetEnable(hWnd, B_CA, support_config_hub);
14888 SetEnable(hWnd, S_CA, support_config_hub);
14889
14890 SetEnable(hWnd, B_SNAT, support_secure_nat);
14891 SetEnable(hWnd, S_SNAT, support_secure_nat);
14892
14893 SetEnable(hWnd, B_CRL, GetCapsBool(caps, "b_support_crl"));
14894
14895 SetEnable(hWnd, B_LOG_FILE, GetCapsBool(caps, "b_support_read_log"));
14896
14897 SmHubDlgRefresh(hWnd, s);
14898 }
14899
14900 // Update the control
SmHubDlgUpdate(HWND hWnd,SM_HUB * s)14901 void SmHubDlgUpdate(HWND hWnd, SM_HUB *s)
14902 {
14903 // Validate arguments
14904 if (hWnd == NULL || s == NULL)
14905 {
14906 return;
14907 }
14908 }
14909
14910 // Content update
SmHubDlgRefresh(HWND hWnd,SM_HUB * s)14911 void SmHubDlgRefresh(HWND hWnd, SM_HUB *s)
14912 {
14913 // Validate arguments
14914 if (hWnd == NULL || s == NULL)
14915 {
14916 return;
14917 }
14918
14919 SmRefreshHubStatus(hWnd, s->p, (void *)s->HubName);
14920 LvAutoSize(hWnd, L_STATUS);
14921
14922 SmHubDlgUpdate(hWnd, s);
14923 }
14924
14925 // HUB management dialog
SmHubDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)14926 UINT SmHubDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
14927 {
14928 SM_HUB *s = (SM_HUB *)param;
14929 // Validate arguments
14930 if (hWnd == NULL)
14931 {
14932 return 0;
14933 }
14934
14935 switch (msg)
14936 {
14937 case WM_INITDIALOG:
14938 // Initialize
14939 SmHubDlgInit(hWnd, s);
14940 break;
14941
14942 case WM_COMMAND:
14943 switch (wParam)
14944 {
14945 case B_USER:
14946 // User
14947 SmUserListDlg(hWnd, s);
14948 SmHubDlgRefresh(hWnd, s);
14949 break;
14950
14951 case B_GROUP:
14952 // Group
14953 SmGroupListDlg(hWnd, s);
14954 SmHubDlgRefresh(hWnd, s);
14955 break;
14956
14957 case B_ACCESS:
14958 // Access list
14959 SmAccessListDlg(hWnd, s);
14960 SmHubDlgRefresh(hWnd, s);
14961 break;
14962
14963 case B_PROPERTY:
14964 // Property
14965 if (SmEditHubDlg(hWnd, s->p, s->HubName))
14966 {
14967 SmHubDlgRefresh(hWnd, s);
14968 }
14969 break;
14970
14971 case B_RADIUS:
14972 // Radius
14973 SmRadiusDlg(hWnd, s);
14974 SmHubDlgRefresh(hWnd, s);
14975 break;
14976
14977 case B_LINK:
14978 // Cascade
14979 SmLinkDlg(hWnd, s);
14980 SmHubDlgRefresh(hWnd, s);
14981 break;
14982
14983 case B_SESSION:
14984 // Session
14985 SmSessionDlg(hWnd, s);
14986 SmHubDlgRefresh(hWnd, s);
14987 break;
14988
14989 case B_LOG:
14990 // Log
14991 Dialog(hWnd, D_SM_LOG, SmLogDlg, s);
14992 SmHubDlgRefresh(hWnd, s);
14993 break;
14994
14995 case B_CA:
14996 // CA
14997 SmCaDlg(hWnd, s);
14998 SmHubDlgRefresh(hWnd, s);
14999 break;
15000
15001 case IDCANCEL:
15002 // Cancel button
15003 Close(hWnd);
15004 break;
15005
15006 case B_REFRESH:
15007 // Update
15008 SmHubDlgRefresh(hWnd, s);
15009 break;
15010
15011 case B_SNAT:
15012 // SecureNAT
15013 Dialog(hWnd, D_SM_SNAT, SmSNATDlgProc, s);
15014 SmHubDlgRefresh(hWnd, s);
15015 break;
15016
15017 case B_CRL:
15018 // Certificate revocation list
15019 Dialog(hWnd, D_SM_CRL, SmCrlDlgProc, s);
15020 break;
15021
15022 case B_LOG_FILE:
15023 // Log file
15024 Dialog(hWnd, D_SM_LOG_FILE, SmLogFileDlgProc, s->p);
15025 break;
15026 }
15027 break;
15028
15029 case WM_CLOSE:
15030 EndDialog(hWnd, false);
15031 break;
15032 }
15033
15034 return 0;
15035 }
15036
15037 // Management of HUB
SmHubDlg(HWND hWnd,SM_HUB * s)15038 void SmHubDlg(HWND hWnd, SM_HUB *s)
15039 {
15040 // Validate arguments
15041 if (hWnd == NULL || s == NULL)
15042 {
15043 return;
15044 }
15045
15046 Dialog(hWnd, D_SM_HUB, SmHubDlgProc, s);
15047 }
15048
15049 // Change the server password
SmChangeServerPasswordDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)15050 UINT SmChangeServerPasswordDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
15051 {
15052 SM_SERVER *p = (SM_SERVER *)param;
15053 char tmp1[MAX_SIZE];
15054 char tmp2[MAX_SIZE];
15055 UCHAR hash[SHA1_SIZE];
15056 RPC_SET_PASSWORD t;
15057 SETTING *setting;
15058 // Validate arguments
15059 if (hWnd == NULL)
15060 {
15061 return 0;
15062 }
15063
15064 switch (msg)
15065 {
15066 case WM_INITDIALOG:
15067 // Initialize
15068 SetIcon(hWnd, 0, ICO_USER_ADMIN);
15069 FormatText(hWnd, 0, p->ServerName);
15070 FormatText(hWnd, S_TITLE, p->ServerName);
15071 Focus(hWnd, E_PASSWORD1);
15072 break;
15073
15074 case WM_COMMAND:
15075 switch (LOWORD(wParam))
15076 {
15077 case E_PASSWORD1:
15078 case E_PASSWORD2:
15079 GetTxtA(hWnd, E_PASSWORD1, tmp1, sizeof(tmp1));
15080 GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
15081
15082 if (StrLen(tmp1) == 0 || StrLen(tmp2) == 0)
15083 {
15084 Disable(hWnd, IDOK);
15085 }
15086 else
15087 {
15088 Enable(hWnd, IDOK);
15089 }
15090 break;
15091 }
15092
15093 switch (wParam)
15094 {
15095 case IDOK:
15096 // [OK] button
15097 GetTxtA(hWnd, E_PASSWORD1, tmp1, sizeof(tmp1));
15098 GetTxtA(hWnd, E_PASSWORD2, tmp2, sizeof(tmp2));
15099 if (StrCmp(tmp1, tmp2) != 0)
15100 {
15101 MsgBox(hWnd, MB_ICONSTOP, _UU("SM_CHANGE_PASSWORD_1"));
15102 FocusEx(hWnd, E_PASSWORD2);
15103 break;
15104 }
15105 if (StrLen(tmp1) == 0)
15106 {
15107 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, _UU("SM_CHANGE_PASSWORD_2")) == IDNO)
15108 {
15109 Focus(hWnd, E_PASSWORD1);
15110 break;
15111 }
15112 }
15113 Zero(&t, sizeof(t));
15114 Sha0(t.HashedPassword, tmp1, StrLen(tmp1));
15115 Copy(hash, t.HashedPassword, sizeof(hash));
15116 if (CALL(hWnd, ScSetServerPassword(p->Rpc, &t)) == false)
15117 {
15118 break;
15119 }
15120 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SM_CHANGE_PASSWORD_3"));
15121
15122 // Change the password for the connection setting
15123 setting = SmGetSetting(p->CurrentSetting->Title);
15124 if (setting != NULL && sm->TempSetting == NULL)
15125 {
15126 if (IsZero(setting->HashedPassword, SHA1_SIZE) == false)
15127 {
15128 Copy(setting->HashedPassword, hash, SHA1_SIZE);
15129 SmWriteSettingList();
15130 }
15131 }
15132
15133 EndDialog(hWnd, true);
15134 break;
15135
15136 case IDCANCEL:
15137 // Cancel button
15138 Close(hWnd);
15139 break;
15140 }
15141 break;
15142
15143 case WM_CLOSE:
15144 EndDialog(hWnd, false);
15145 break;
15146 }
15147
15148 return 0;
15149 }
15150
15151 // Update the status of the connection to the server farm controller
SmRefreshFarmConnectionInfo(HWND hWnd,SM_SERVER * p,void * param)15152 bool SmRefreshFarmConnectionInfo(HWND hWnd, SM_SERVER *p, void *param)
15153 {
15154 RPC_FARM_CONNECTION_STATUS t;
15155 LVB *b;
15156 wchar_t tmp[MAX_SIZE];
15157 char str[MAX_SIZE];
15158 // Validate arguments
15159 if (hWnd == NULL || p == NULL)
15160 {
15161 return false;
15162 }
15163
15164 Zero(&t, sizeof(t));
15165 if (CALL(hWnd, ScGetFarmConnectionStatus(p->Rpc, &t)) == false)
15166 {
15167 return false;
15168 }
15169
15170 b = LvInsertStart();
15171
15172 if (t.Online == false)
15173 {
15174 LvInsertAdd(b, ICO_FARM, NULL, 2, _UU("SM_FC_IP"), _UU("SM_FC_NOT_CONNECTED"));
15175
15176 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_FC_PORT"), _UU("SM_FC_NOT_CONNECTED"));
15177 }
15178 else
15179 {
15180 IPToStr32(str, sizeof(str), t.Ip);
15181 StrToUni(tmp, sizeof(tmp), str);
15182 LvInsertAdd(b, ICO_FARM, NULL, 2, _UU("SM_FC_IP"), tmp);
15183
15184 UniToStru(tmp, t.Port);
15185 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_FC_PORT"), tmp);
15186 }
15187
15188 LvInsertAdd(b,
15189 t.Online ? ICO_SERVER_ONLINE_EX : ICO_PROTOCOL_X, NULL, 2,
15190 _UU("SM_FC_STATUS"),
15191 t.Online ? _UU("SM_FC_ONLINE") : _UU("SM_FC_OFFLINE"));
15192
15193 if (t.Online == false)
15194 {
15195 UniFormat(tmp, sizeof(tmp), _UU("SM_FC_ERROR_TAG"), _E(t.LastError), t.LastError);
15196 LvInsertAdd(b, ICO_STOP, NULL, 2,
15197 _UU("SM_FC_LAST_ERROR"), tmp);
15198 }
15199
15200 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.StartedTime), NULL);
15201 LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("SM_FC_START_TIME"), tmp);
15202
15203 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.FirstConnectedTime), NULL);
15204 LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("SM_FC_FIRST_TIME"), tmp);
15205
15206 //if (t.Online == false)
15207 {
15208 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.CurrentConnectedTime), NULL);
15209 LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("SM_FC_CURRENT_TIME"), tmp);
15210 }
15211
15212 UniToStru(tmp, t.NumTry);
15213 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_FC_NUM_TRY"), tmp);
15214
15215 UniToStru(tmp, t.NumConnected);
15216 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_FC_NUM_CONNECTED"), tmp);
15217
15218 UniToStru(tmp, t.NumFailed);
15219 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_FC_NUM_FAILED"), tmp);
15220
15221 LvInsertEnd(b, hWnd, L_STATUS);
15222
15223 return true;
15224 }
15225
15226 // Initialize
SmFarmMemberDlgInit(HWND hWnd,SM_SERVER * p)15227 void SmFarmMemberDlgInit(HWND hWnd, SM_SERVER *p)
15228 {
15229 // Validate arguments
15230 if (hWnd == NULL || p == NULL)
15231 {
15232 return;
15233 }
15234
15235 SetIcon(hWnd, 0, ICO_FARM);
15236
15237 FormatText(hWnd, S_TITLE, p->ServerName);
15238
15239 // Initialize the column
15240 LvInit(hWnd, L_FARM_MEMBER);
15241 LvSetStyle(hWnd, L_FARM_MEMBER, LVS_EX_GRIDLINES);
15242 LvInsertColumn(hWnd, L_FARM_MEMBER, 0, _UU("SM_FM_COLUMN_1"), 90);
15243 LvInsertColumn(hWnd, L_FARM_MEMBER, 1, _UU("SM_FM_COLUMN_2"), 150);
15244 LvInsertColumn(hWnd, L_FARM_MEMBER, 2, _UU("SM_FM_COLUMN_3"), 140);
15245 LvInsertColumn(hWnd, L_FARM_MEMBER, 3, _UU("SM_FM_COLUMN_4"), 60);
15246 LvInsertColumn(hWnd, L_FARM_MEMBER, 4, _UU("SM_FM_COLUMN_5"), 80);
15247 LvInsertColumn(hWnd, L_FARM_MEMBER, 5, _UU("SM_FM_COLUMN_6"), 80);
15248 LvInsertColumn(hWnd, L_FARM_MEMBER, 6, _UU("SM_FM_COLUMN_7"), 80);
15249 LvInsertColumn(hWnd, L_FARM_MEMBER, 7, _UU("SM_FM_COLUMN_8"), 160);
15250 LvInsertColumn(hWnd, L_FARM_MEMBER, 8, _UU("SM_FM_COLUMN_9"), 160);
15251
15252 SmFarmMemberDlgRefresh(hWnd, p);
15253 }
15254
15255 // Update
SmFarmMemberDlgUpdate(HWND hWnd,SM_SERVER * p)15256 void SmFarmMemberDlgUpdate(HWND hWnd, SM_SERVER *p)
15257 {
15258 // Validate arguments
15259 if (hWnd == NULL || p == NULL)
15260 {
15261 return;
15262 }
15263
15264 SetEnable(hWnd, IDOK, LvIsSelected(hWnd, L_FARM_MEMBER) && (LvIsMultiMasked(hWnd, L_FARM_MEMBER) == false));
15265 SetEnable(hWnd, B_CERT, LvIsSelected(hWnd, L_FARM_MEMBER) && (LvIsMultiMasked(hWnd, L_FARM_MEMBER) == false));
15266 }
15267
15268 // Content update
SmFarmMemberDlgRefresh(HWND hWnd,SM_SERVER * p)15269 void SmFarmMemberDlgRefresh(HWND hWnd, SM_SERVER *p)
15270 {
15271 RPC_ENUM_FARM t;
15272 UINT i;
15273 // Validate arguments
15274 if (hWnd == NULL || p == NULL)
15275 {
15276 return;
15277 }
15278
15279 Zero(&t, sizeof(t));
15280 if (CALL(hWnd, ScEnumFarmMember(p->Rpc, &t)) == false)
15281 {
15282 EndDialog(hWnd, false);
15283 return;
15284 }
15285
15286 LvReset(hWnd, L_FARM_MEMBER);
15287
15288 for (i = 0;i < t.NumFarm;i++)
15289 {
15290 RPC_ENUM_FARM_ITEM *e = &t.Farms[i];
15291 wchar_t tmp1[MAX_SIZE];
15292 wchar_t tmp2[MAX_SIZE];
15293 wchar_t tmp3[64];
15294 wchar_t tmp4[64];
15295 wchar_t tmp5[64];
15296 wchar_t tmp6[64];
15297 wchar_t tmp7[64];
15298 wchar_t tmp8[64];
15299
15300 GetDateTimeStrEx64(tmp1, sizeof(tmp1), SystemToLocal64(e->ConnectedTime), NULL);
15301 StrToUni(tmp2, sizeof(tmp2), e->Hostname);
15302 UniToStru(tmp3, e->Point);
15303 UniToStru(tmp4, e->NumSessions);
15304 UniToStru(tmp5, e->NumTcpConnections);
15305 UniToStru(tmp6, e->NumHubs);
15306 UniToStru(tmp7, e->AssignedClientLicense);
15307 UniToStru(tmp8, e->AssignedBridgeLicense);
15308
15309 LvInsert(hWnd, L_FARM_MEMBER, e->Controller ? ICO_FARM : ICO_TOWER, (void *)e->Id, 9,
15310 e->Controller ? _UU("SM_FM_CONTROLLER") : _UU("SM_FM_MEMBER"),
15311 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8);
15312 }
15313
15314 FreeRpcEnumFarm(&t);
15315
15316 SmFarmMemberDlgUpdate(hWnd, p);
15317 }
15318
15319 // [OK] button
SmFarmMemberDlgOnOk(HWND hWnd,SM_SERVER * p)15320 void SmFarmMemberDlgOnOk(HWND hWnd, SM_SERVER *p)
15321 {
15322 // Validate arguments
15323 if (hWnd == NULL || p == NULL)
15324 {
15325 return;
15326 }
15327
15328 }
15329
15330 // Display the farm member certificate
SmFarmMemberCert(HWND hWnd,SM_SERVER * p,UINT id)15331 void SmFarmMemberCert(HWND hWnd, SM_SERVER *p, UINT id)
15332 {
15333 RPC_FARM_INFO t;
15334 // Validate arguments
15335 if (hWnd == NULL || p == NULL || id == 0)
15336 {
15337 return;
15338 }
15339
15340 Zero(&t, sizeof(t));
15341 t.Id = id;
15342
15343 if (CALL(hWnd, ScGetFarmInfo(p->Rpc, &t)) == false)
15344 {
15345 return;
15346 }
15347
15348 CertDlg(hWnd, t.ServerCert, NULL, true);
15349
15350 FreeRpcFarmInfo(&t);
15351 }
15352
15353 // Update the farm member information
SmRefreshFarmMemberInfo(HWND hWnd,SM_SERVER * p,void * param)15354 bool SmRefreshFarmMemberInfo(HWND hWnd, SM_SERVER *p, void *param)
15355 {
15356 RPC_FARM_INFO t;
15357 UINT id = (UINT)param;
15358 LVB *b;
15359 UINT i;
15360 wchar_t tmp[MAX_SIZE];
15361 char str[MAX_SIZE];
15362 // Validate arguments
15363 if (hWnd == NULL || p == NULL || id == 0)
15364 {
15365 return false;
15366 }
15367
15368 Zero(&t, sizeof(t));
15369 t.Id = id;
15370
15371 if (CALL(hWnd, ScGetFarmInfo(p->Rpc, &t)) == false)
15372 {
15373 return false;
15374 }
15375
15376 b = LvInsertStart();
15377
15378 LvInsertAdd(b, ICO_FARM, NULL, 2, _UU("SM_FMINFO_TYPE"),
15379 t.Controller ? _UU("SM_FARM_CONTROLLER") : _UU("SM_FARM_MEMBER"));
15380
15381 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.ConnectedTime), NULL);
15382 LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("SM_FMINFO_CONNECT_TIME"), tmp);
15383
15384 IPToStr32(str, sizeof(str), t.Ip);
15385 StrToUni(tmp, sizeof(tmp), str);
15386 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_FMINFO_IP"), tmp);
15387
15388 StrToUni(tmp, sizeof(tmp), t.Hostname);
15389 LvInsertAdd(b, ICO_TOWER, NULL, 2, _UU("SM_FMINFO_HOSTNAME"), tmp);
15390
15391 UniToStru(tmp, t.Point);
15392 LvInsertAdd(b, ICO_TEST, NULL, 2, _UU("SM_FMINFO_POINT"), tmp);
15393
15394 UniToStru(tmp, t.Weight);
15395 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_FMINFO_WEIGHT"), tmp);
15396
15397 UniToStru(tmp, t.NumPort);
15398 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_FMINFO_NUM_PORT"), tmp);
15399
15400 for (i = 0;i < t.NumPort;i++)
15401 {
15402 wchar_t tmp2[MAX_SIZE];
15403 UniFormat(tmp, sizeof(tmp), _UU("SM_FMINFO_PORT"), i + 1);
15404 UniToStru(tmp2, t.Ports[i]);
15405 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, tmp, tmp2);
15406 }
15407
15408 UniToStru(tmp, t.NumFarmHub);
15409 LvInsertAdd(b, ICO_HUB_OFFLINE, NULL, 2, _UU("SM_FMINFO_NUM_HUB"), tmp);
15410
15411 for (i = 0;i < t.NumFarmHub;i++)
15412 {
15413 wchar_t tmp2[MAX_SIZE];
15414 UniFormat(tmp, sizeof(tmp), _UU("SM_FMINFO_HUB"), i + 1);
15415 UniFormat(tmp2, sizeof(tmp2),
15416 t.FarmHubs[i].DynamicHub ? _UU("SM_FMINFO_HUB_TAG_2") : _UU("SM_FMINFO_HUB_TAG_1"),
15417 t.FarmHubs[i].HubName);
15418 LvInsertAdd(b, ICO_HUB, NULL, 2, tmp, tmp2);
15419 }
15420
15421 UniToStru(tmp, t.NumSessions);
15422 LvInsertAdd(b, ICO_VPN, NULL, 2, _UU("SM_FMINFO_NUM_SESSION"), tmp);
15423
15424 UniToStru(tmp, t.NumTcpConnections);
15425 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_FMINFO_NUN_CONNECTION"), tmp);
15426
15427 LvInsertEnd(b, hWnd, L_STATUS);
15428
15429 FreeRpcFarmInfo(&t);
15430
15431 return true;
15432 }
15433
15434 // Farm Member List dialog
SmFarmMemberDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)15435 UINT SmFarmMemberDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
15436 {
15437 SM_SERVER *p = (SM_SERVER *)param;
15438 NMHDR *n;
15439 UINT i;
15440 // Validate arguments
15441 if (hWnd == NULL)
15442 {
15443 return 0;
15444 }
15445
15446 switch (msg)
15447 {
15448 case WM_INITDIALOG:
15449 // Initialize
15450 SmFarmMemberDlgInit(hWnd, p);
15451 break;
15452
15453 case WM_COMMAND:
15454 switch (wParam)
15455 {
15456 case IDOK:
15457 // Display the information of farm members
15458 i = LvGetSelected(hWnd, L_FARM_MEMBER);
15459 if (i != INFINITE)
15460 {
15461 SmStatusDlg(hWnd, p, LvGetParam(hWnd, L_FARM_MEMBER, i), false, true,
15462 _UU("SM_FMINFO_CAPTION"), ICO_FARM, NULL, SmRefreshFarmMemberInfo);
15463 }
15464 break;
15465
15466 case B_CERT:
15467 // Show the Server Certificate
15468 i = LvGetSelected(hWnd, L_FARM_MEMBER);
15469 if (i != INFINITE)
15470 {
15471 SmFarmMemberCert(hWnd, p, (UINT)LvGetParam(hWnd, L_FARM_MEMBER, i));
15472 }
15473 break;
15474
15475 case IDCANCEL:
15476 // Cancel button
15477 Close(hWnd);
15478 break;
15479
15480 case B_REFRESH:
15481 // Update
15482 SmFarmMemberDlgRefresh(hWnd, p);
15483 break;
15484 }
15485 break;
15486
15487 case WM_NOTIFY:
15488 n = (NMHDR *)lParam;
15489 switch (n->code)
15490 {
15491 case LVN_ITEMCHANGED:
15492 switch (n->idFrom)
15493 {
15494 case L_FARM_MEMBER:
15495 SmFarmMemberDlgUpdate(hWnd, p);
15496 break;
15497 }
15498 break;
15499 }
15500 break;
15501
15502 case WM_CLOSE:
15503 EndDialog(hWnd, false);
15504 break;
15505 }
15506
15507 LvStandardHandler(hWnd, msg, wParam, lParam, L_FARM_MEMBER);
15508
15509 return 0;
15510 }
15511
15512 // Initialize the dialog
SmFarmDlgInit(HWND hWnd,SM_SERVER * p)15513 void SmFarmDlgInit(HWND hWnd, SM_SERVER *p)
15514 {
15515 RPC_FARM t;
15516 // Validate arguments
15517 if (hWnd == NULL || p == NULL)
15518 {
15519 return;
15520 }
15521
15522 SetIcon(hWnd, 0, ICO_FARM);
15523
15524 // Get the current settings
15525 Zero(&t, sizeof(t));
15526 if (CALL(hWnd, ScGetFarmSetting(p->Rpc, &t)) == false)
15527 {
15528 EndDialog(hWnd, false);
15529 return;
15530 }
15531
15532 if (t.Weight == 0)
15533 {
15534 t.Weight = FARM_DEFAULT_WEIGHT;
15535 }
15536
15537 FormatText(hWnd, S_TITLE, p->ServerName);
15538 DlgFont(hWnd, S_CURRENT, 11, true);
15539
15540 SetText(hWnd, S_CURRENT, GetServerTypeStr(t.ServerType));
15541
15542 switch (t.ServerType)
15543 {
15544 case SERVER_TYPE_FARM_CONTROLLER:
15545 Check(hWnd, R_CONTROLLER, true);
15546 break;
15547
15548 case SERVER_TYPE_FARM_MEMBER:
15549 Check(hWnd, R_MEMBER, true);
15550 break;
15551
15552 default:
15553 Check(hWnd, R_STANDALONE, true);
15554 break;
15555 }
15556
15557 SetInt(hWnd, E_WEIGHT, t.Weight);
15558
15559 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
15560 {
15561 Check(hWnd, R_CONTROLLER_ONLY, t.ControllerOnly);
15562 }
15563
15564 if (t.ServerType == SERVER_TYPE_FARM_MEMBER)
15565 {
15566 char tmp[MAX_PUBLIC_PORT_NUM * 8];
15567 UINT i;
15568 if (t.PublicIp != 0)
15569 {
15570 IpSet(hWnd, E_IP, t.PublicIp);
15571 }
15572 StrCpy(tmp, sizeof(tmp), "");
15573 if (t.NumPort != 0)
15574 {
15575 for (i = 0;i < t.NumPort;i++)
15576 {
15577 Format(tmp, sizeof(tmp), "%s%u", tmp, t.Ports[i]);
15578 if (i != (t.NumPort - 1))
15579 {
15580 StrCat(tmp, sizeof(tmp), ", ");
15581 }
15582 }
15583 SetTextA(hWnd, E_PORT, tmp);
15584 }
15585 SetTextA(hWnd, E_CONTROLLER, t.ControllerName);
15586 SetIntEx(hWnd, E_CONTROLLER_PORT, t.ControllerPort);
15587 SetTextA(hWnd, E_PASSWORD, HIDDEN_PASSWORD);
15588 }
15589 else
15590 {
15591 // Write the port list
15592 RPC_LISTENER_LIST t;
15593 char tmp[MAX_PUBLIC_PORT_NUM * 8];
15594 Zero(&t, sizeof(t));
15595 StrCpy(tmp, sizeof(tmp), "");
15596 if (CALL(hWnd, ScEnumListener(p->Rpc, &t)))
15597 {
15598 UINT i;
15599 if (t.NumPort != 0)
15600 {
15601 for (i = 0;i < t.NumPort;i++)
15602 {
15603 Format(tmp, sizeof(tmp), "%s%u", tmp, t.Ports[i]);
15604 if (i != (t.NumPort - 1))
15605 {
15606 StrCat(tmp, sizeof(tmp), ", ");
15607 }
15608 }
15609 SetTextA(hWnd, E_PORT, tmp);
15610 }
15611 FreeRpcListenerList(&t);
15612 }
15613 }
15614
15615 SmFarmDlgUpdate(hWnd, p);
15616
15617 FreeRpcFarm(&t);
15618
15619 Focus(hWnd, IDOK);
15620 }
15621
15622 // Dialog update
SmFarmDlgUpdate(HWND hWnd,SM_SERVER * p)15623 void SmFarmDlgUpdate(HWND hWnd, SM_SERVER *p)
15624 {
15625 bool ok = true;
15626 bool farm_member_control = false;
15627 char *s;
15628 // Validate arguments
15629 if (hWnd == NULL || p == NULL)
15630 {
15631 return;
15632 }
15633
15634 if (IsChecked(hWnd, R_MEMBER))
15635 {
15636 LIST *o;
15637 UINT i = IpGetFilledNum(hWnd, E_IP);
15638 if (i != 0 && i != 4)
15639 {
15640 ok = false;
15641 }
15642
15643 s = GetTextA(hWnd, E_PORT);
15644 o = StrToPortList(s, true);
15645 if (o == NULL)
15646 {
15647 ok = false;
15648 }
15649 else
15650 {
15651 ReleaseList(o);
15652 }
15653 Free(s);
15654
15655 if (IsEmpty(hWnd, E_CONTROLLER))
15656 {
15657 ok = false;
15658 }
15659
15660 i = GetInt(hWnd, E_CONTROLLER_PORT);
15661 if (i == 0 || i >= 65536)
15662 {
15663 ok = false;
15664 }
15665
15666 farm_member_control = true;
15667 }
15668
15669 if (IsChecked(hWnd, R_STANDALONE))
15670 {
15671 Disable(hWnd, S_1);
15672 Disable(hWnd, S_2);
15673 Disable(hWnd, E_WEIGHT);
15674 }
15675 else
15676 {
15677 Enable(hWnd, S_1);
15678 Enable(hWnd, S_2);
15679 Enable(hWnd, E_WEIGHT);
15680 }
15681
15682 if (IsChecked(hWnd, R_CONTROLLER))
15683 {
15684 Enable(hWnd, R_CONTROLLER_ONLY);
15685 }
15686 else
15687 {
15688 Disable(hWnd, R_CONTROLLER_ONLY);
15689 }
15690
15691 if (IsChecked(hWnd, R_CONTROLLER) || IsChecked(hWnd, R_MEMBER))
15692 {
15693 if (GetInt(hWnd, E_WEIGHT) == 0)
15694 {
15695 ok = false;
15696 }
15697 }
15698
15699 SetEnable(hWnd, S_IP_1, farm_member_control);
15700 SetEnable(hWnd, E_IP, farm_member_control);
15701 SetEnable(hWnd, S_IP_2, farm_member_control);
15702 SetEnable(hWnd, S_PORT_1, farm_member_control);
15703 SetEnable(hWnd, E_PORT, farm_member_control);
15704 SetEnable(hWnd, S_PORT_2, farm_member_control);
15705 SetEnable(hWnd, S_PORT_3, farm_member_control);
15706 SetEnable(hWnd, E_CONTROLLER, farm_member_control);
15707 SetEnable(hWnd, S_CONTROLLER, farm_member_control);
15708 SetEnable(hWnd, E_CONTROLLER_PORT, farm_member_control);
15709 SetEnable(hWnd, S_CONTROLLER_PORT, farm_member_control);
15710 SetEnable(hWnd, S_PASSWORD, farm_member_control);
15711 SetEnable(hWnd, E_PASSWORD, farm_member_control);
15712 SetEnable(hWnd, IDOK, ok);
15713 }
15714
15715 // [OK] button
SmFarmDlgOnOk(HWND hWnd,SM_SERVER * p)15716 void SmFarmDlgOnOk(HWND hWnd, SM_SERVER *p)
15717 {
15718 // Validate arguments
15719 if (hWnd == NULL || p == NULL)
15720 {
15721 return;
15722 }
15723
15724 // Display the message
15725 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_OKCANCEL | MB_DEFBUTTON2,
15726 _UU("SM_FARM_REBOOT_MSG")) == IDOK)
15727 {
15728 RPC_FARM t;
15729 Zero(&t, sizeof(t));
15730 t.ServerType = SERVER_TYPE_STANDALONE;
15731 if (IsChecked(hWnd, R_CONTROLLER))
15732 {
15733 t.ServerType = SERVER_TYPE_FARM_CONTROLLER;
15734 }
15735 if (IsChecked(hWnd, R_MEMBER))
15736 {
15737 t.ServerType = SERVER_TYPE_FARM_MEMBER;
15738 }
15739
15740 t.ControllerOnly = IsChecked(hWnd, R_CONTROLLER_ONLY);
15741 t.Weight = GetInt(hWnd, E_WEIGHT);
15742
15743 if (t.ServerType == SERVER_TYPE_FARM_MEMBER)
15744 {
15745 char *s;
15746 char pass[MAX_SIZE];
15747 t.PublicIp = IpGet(hWnd, E_IP);
15748 s = GetTextA(hWnd, E_PORT);
15749 if (s != NULL)
15750 {
15751 LIST *o = StrToPortList(s, true);
15752 if (o != NULL)
15753 {
15754 UINT i;
15755 t.NumPort = LIST_NUM(o);
15756 t.Ports = ZeroMalloc(sizeof(UINT) * t.NumPort);
15757 for (i = 0;i < t.NumPort;i++)
15758 {
15759 t.Ports[i] = (UINT)LIST_DATA(o, i);
15760 }
15761 ReleaseList(o);
15762 }
15763 Free(s);
15764 }
15765 GetTxtA(hWnd, E_CONTROLLER, t.ControllerName, sizeof(t.ControllerName));
15766 t.ControllerPort = GetInt(hWnd, E_CONTROLLER_PORT);
15767 GetTxtA(hWnd, E_PASSWORD, pass, sizeof(pass));
15768 if (StrCmp(pass, HIDDEN_PASSWORD) != 0)
15769 {
15770 Sha0(t.MemberPassword, pass, StrLen(pass));
15771 }
15772 }
15773
15774 // Configuration update
15775 if (CALL(hWnd, ScSetFarmSetting(p->Rpc, &t)) == false)
15776 {
15777 return;
15778 }
15779
15780 FreeRpcFarm(&t);
15781
15782 EndDialog(hWnd, true);
15783 }
15784 }
15785
15786 // Server farm dialog procedure
SmFarmDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)15787 UINT SmFarmDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
15788 {
15789 SM_SERVER *p = (SM_SERVER *)param;
15790 // Validate arguments
15791 if (hWnd == NULL)
15792 {
15793 return 0;
15794 }
15795
15796 switch (msg)
15797 {
15798 case WM_INITDIALOG:
15799 // Initialize
15800 SmFarmDlgInit(hWnd, p);
15801 break;
15802
15803 case WM_COMMAND:
15804 switch (LOWORD(wParam))
15805 {
15806 case R_STANDALONE:
15807 case R_CONTROLLER:
15808 case R_MEMBER:
15809 case E_IP:
15810 case E_PORT:
15811 case E_CONTROLLER:
15812 case E_CONTROLLER_PORT:
15813 case E_PASSWORD:
15814 case R_CONTROLLER_ONLY:
15815 case E_WEIGHT:
15816 SmFarmDlgUpdate(hWnd, p);
15817 break;
15818 }
15819
15820 switch (wParam)
15821 {
15822 case IDOK:
15823 // [OK] button
15824 SmFarmDlgOnOk(hWnd, p);
15825 break;
15826
15827 case IDCANCEL:
15828 // Cancel button
15829 Close(hWnd);
15830 break;
15831
15832 case R_MEMBER:
15833 if (IsChecked(hWnd, R_MEMBER))
15834 {
15835 Focus(hWnd, E_IP);
15836 }
15837 break;
15838 }
15839 break;
15840
15841 case WM_CLOSE:
15842 EndDialog(hWnd, false);
15843 break;
15844 }
15845
15846 return 0;
15847 }
15848
15849 // Server farm configuration
SmFarmDlg(HWND hWnd,SM_SERVER * p)15850 bool SmFarmDlg(HWND hWnd, SM_SERVER *p)
15851 {
15852 // Validate arguments
15853 if (hWnd == NULL || p == NULL)
15854 {
15855 return false;
15856 }
15857
15858 return Dialog(hWnd, D_SM_FARM, SmFarmDlgProc, p);
15859 }
15860
15861 // Update the connection information
SmRefreshConnectionStatus(HWND hWnd,SM_SERVER * p,void * param)15862 bool SmRefreshConnectionStatus(HWND hWnd, SM_SERVER *p, void *param)
15863 {
15864 RPC_CONNECTION_INFO t;
15865 SM_CONNECTION_INFO *info = (SM_CONNECTION_INFO *)param;
15866 LVB *b;
15867 wchar_t tmp[MAX_SIZE];
15868 // Validate arguments
15869 if (hWnd == NULL || p == NULL || param == NULL)
15870 {
15871 return false;
15872 }
15873
15874 Zero(&t, sizeof(t));
15875 StrCpy(t.Name, sizeof(t.Name), info->ConnectionName);
15876 if (CALL(hWnd, ScGetConnectionInfo(p->Rpc, &t)) == false)
15877 {
15878 return false;
15879 }
15880
15881 b = LvInsertStart();
15882
15883 StrToUni(tmp, sizeof(tmp), t.Name);
15884 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_CONNINFO_NAME"), tmp);
15885
15886 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_CONNINFO_TYPE"), SmGetConnectionTypeStr(t.Type));
15887
15888 StrToUni(tmp, sizeof(tmp), t.Hostname);
15889 LvInsertAdd(b, ICO_FARM, NULL, 2, _UU("SM_CONNINFO_HOSTNAME"), tmp);
15890
15891 UniToStru(tmp, t.Port);
15892 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_CONNINFO_PORT"), tmp);
15893
15894 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.ConnectedTime), NULL);
15895 LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("SM_CONNINFO_TIME"), tmp);
15896
15897 StrToUni(tmp, sizeof(tmp), t.ServerStr);
15898 LvInsertAdd(b, ICO_VPNSERVER, NULL, 2, _UU("SM_CONNINFO_SERVER_STR"), tmp);
15899
15900 UniFormat(tmp, sizeof(tmp), L"%u.%02u", t.ServerVer / 100, t.ServerVer % 100);
15901 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_CONNINFO_SERVER_VER"), tmp);
15902
15903 UniToStru(tmp, t.ServerBuild);
15904 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_CONNINFO_SERVER_BUILD"), tmp);
15905
15906 if (StrLen(t.ClientStr) != 0)
15907 {
15908 StrToUni(tmp, sizeof(tmp), t.ClientStr);
15909 LvInsertAdd(b, ICO_VPN, NULL, 2, _UU("SM_CONNINFO_CLIENT_STR"), tmp);
15910
15911 UniFormat(tmp, sizeof(tmp), L"%u.%02u", t.ClientVer / 100, t.ClientVer % 100);
15912 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_CONNINFO_CLIENT_VER"), tmp);
15913
15914 UniToStru(tmp, t.ClientBuild);
15915 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_CONNINFO_CLIENT_BUILD"), tmp);
15916 }
15917
15918 LvInsertEnd(b, hWnd, L_STATUS);
15919
15920 return true;
15921 }
15922
15923 // Initialize
SmConnectionDlgInit(HWND hWnd,SM_SERVER * p)15924 void SmConnectionDlgInit(HWND hWnd, SM_SERVER *p)
15925 {
15926 // Validate arguments
15927 if (hWnd == NULL || p == NULL)
15928 {
15929 return;
15930 }
15931
15932 SetIcon(hWnd, 0, ICO_PROTOCOL);
15933 FormatText(hWnd, S_TITLE, p->ServerName);
15934
15935 // Initialize the column
15936 LvInit(hWnd, L_LIST);
15937 LvSetStyle(hWnd, L_LIST, LVS_EX_GRIDLINES);
15938 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_CONN_COLUMN_1"), 90);
15939 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_CONN_COLUMN_2"), 150);
15940 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_CONN_COLUMN_3"), 200);
15941 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_CONN_COLUMN_4"), 80);
15942
15943 SmConnectionDlgRefresh(hWnd, p);
15944 SmConnectionDlgUpdate(hWnd, p);
15945 }
15946
15947 // Update
SmConnectionDlgRefresh(HWND hWnd,SM_SERVER * p)15948 void SmConnectionDlgRefresh(HWND hWnd, SM_SERVER *p)
15949 {
15950 LVB *b;
15951 UINT i;
15952 RPC_ENUM_CONNECTION t;
15953 // Validate arguments
15954 if (hWnd == NULL || p == NULL)
15955 {
15956 return;
15957 }
15958
15959 Zero(&t, sizeof(t));
15960 if (CALL(hWnd, ScEnumConnection(p->Rpc, &t)) == false)
15961 {
15962 EndDialog(hWnd, false);
15963 return;
15964 }
15965
15966 b = LvInsertStart();
15967
15968 for (i = 0;i < t.NumConnection;i++)
15969 {
15970 wchar_t tmp[MAX_SIZE];
15971 wchar_t name[MAX_SIZE];
15972 wchar_t datetime[MAX_SIZE];
15973 RPC_ENUM_CONNECTION_ITEM *e = &t.Connections[i];
15974
15975 StrToUni(name, sizeof(name), e->Name);
15976 UniFormat(tmp, sizeof(tmp), _UU("SM_HOSTNAME_AND_PORT"), e->Hostname, e->Port);
15977 GetDateTimeStrEx64(datetime, sizeof(datetime), SystemToLocal64(e->ConnectedTime), NULL);
15978
15979 LvInsertAdd(b, ICO_PROTOCOL, NULL, 4, name, tmp, datetime,
15980 SmGetConnectionTypeStr(e->Type));
15981 }
15982
15983 LvInsertEnd(b, hWnd, L_LIST);
15984
15985 FreeRpcEnumConnection(&t);
15986 }
15987
15988 // Update the control
SmConnectionDlgUpdate(HWND hWnd,SM_SERVER * p)15989 void SmConnectionDlgUpdate(HWND hWnd, SM_SERVER *p)
15990 {
15991 bool b = false;
15992 // Validate arguments
15993 if (hWnd == NULL || p == NULL)
15994 {
15995 return;
15996 }
15997
15998 if (LvIsSelected(hWnd, L_LIST) && (LvIsMultiMasked(hWnd, L_LIST) == false))
15999 {
16000 b = true;
16001 }
16002
16003 SetEnable(hWnd, IDOK, b);
16004 SetEnable(hWnd, B_DISCONNECT, b && p->ServerAdminMode);
16005 }
16006
16007 // Connection List procedure
SmConnectionDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)16008 UINT SmConnectionDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
16009 {
16010 SM_SERVER *p = (SM_SERVER *)param;
16011 NMHDR *n;
16012 wchar_t *s;
16013 // Validate arguments
16014 if (hWnd == NULL)
16015 {
16016 return 0;
16017 }
16018
16019 switch (msg)
16020 {
16021 case WM_INITDIALOG:
16022 // Initialize
16023 SmConnectionDlgInit(hWnd, p);
16024 break;
16025
16026 case WM_COMMAND:
16027 switch (wParam)
16028 {
16029 case IDOK:
16030 // Show the connection information
16031 s = LvGetSelectedStr(hWnd, L_LIST, 0);
16032 if (s != NULL)
16033 {
16034 wchar_t caption[MAX_SIZE];
16035 SM_CONNECTION_INFO info;
16036 UniFormat(caption, sizeof(caption), _UU("SM_CONNINFO_CAPTION"),
16037 s);
16038 Zero(&info, sizeof(info));
16039 info.ConnectionName = CopyUniToStr(s);
16040 info.p = p;
16041 SmStatusDlg(hWnd, p, &info, false, false, caption, ICO_PROTOCOL,
16042 NULL, SmRefreshConnectionStatus);
16043 Free(info.ConnectionName);
16044 Free(s);
16045 }
16046 break;
16047
16048 case B_DISCONNECT:
16049 // Disconnect
16050 s = LvGetSelectedStr(hWnd, L_LIST, 0);
16051 if (s != NULL)
16052 {
16053 if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
16054 _UU("SM_CONN_DISCONNECT_MSG"), s) == IDYES)
16055 {
16056 char tmp[MAX_SIZE];
16057 RPC_DISCONNECT_CONNECTION t;
16058
16059 UniToStr(tmp, sizeof(tmp), s);
16060 Zero(&t, sizeof(t));
16061 StrCpy(t.Name, sizeof(t.Name), tmp);
16062
16063 if (CALL(hWnd, ScDisconnectConnection(p->Rpc, &t)))
16064 {
16065 SmConnectionDlgRefresh(hWnd, p);
16066 }
16067 }
16068 Free(s);
16069 }
16070 break;
16071
16072 case B_REFRESH:
16073 // Update to the latest state
16074 SmConnectionDlgRefresh(hWnd, p);
16075 break;
16076
16077 case IDCANCEL:
16078 // Cancel button
16079 Close(hWnd);
16080 break;
16081 }
16082 break;
16083
16084 case WM_NOTIFY:
16085 n = (NMHDR *)lParam;
16086 switch (n->idFrom)
16087 {
16088 case L_LIST:
16089 switch (n->code)
16090 {
16091 case LVN_ITEMCHANGED:
16092 SmConnectionDlgUpdate(hWnd, p);
16093 break;
16094 }
16095 break;
16096 }
16097 break;
16098
16099 case WM_CLOSE:
16100 EndDialog(hWnd, false);
16101 break;
16102 }
16103
16104 LvStandardHandler(hWnd, msg, wParam, lParam, L_LIST);
16105
16106 return 0;
16107 }
16108
16109 // Display the connection list
SmConnectionDlg(HWND hWnd,SM_SERVER * p)16110 void SmConnectionDlg(HWND hWnd, SM_SERVER *p)
16111 {
16112 // Validate arguments
16113 if (hWnd == NULL || p == NULL)
16114 {
16115 return;
16116 }
16117
16118 Dialog(hWnd, D_SM_CONNECTION, SmConnectionDlgProc, p);
16119 }
16120
16121 // Get the connection type string
SmGetConnectionTypeStr(UINT type)16122 wchar_t *SmGetConnectionTypeStr(UINT type)
16123 {
16124 return GetConnectionTypeStr(type);
16125 }
16126
16127 // Update the server information
SmRefreshServerInfo(HWND hWnd,SM_SERVER * p,void * param)16128 bool SmRefreshServerInfo(HWND hWnd, SM_SERVER *p, void *param)
16129 {
16130 RPC_SERVER_INFO t;
16131 LVB *b;
16132 wchar_t tmp[MAX_SIZE];
16133 // Validate arguments
16134 if (hWnd == NULL || p == NULL)
16135 {
16136 return false;
16137 }
16138
16139 Zero(&t, sizeof(t));
16140 if (CALL(hWnd, ScGetServerInfo(p->Rpc, &t)) == false)
16141 {
16142 return false;
16143 }
16144
16145 b = LvInsertStart();
16146
16147 // Product name
16148 StrToUni(tmp, sizeof(tmp), t.ServerProductName);
16149 LvInsertAdd(b, ICO_VPNSERVER, NULL, 2, _UU("SM_INFO_PRODUCT_NAME"), tmp);
16150
16151 // Version
16152 StrToUni(tmp, sizeof(tmp), t.ServerVersionString);
16153 LvInsertAdd(b, ICO_INFORMATION, NULL, 2, _UU("SM_INFO_VERSION"), tmp);
16154
16155 // Build
16156 StrToUni(tmp, sizeof(tmp), t.ServerBuildInfoString);
16157 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_INFO_BUILD"), tmp);
16158
16159 // Host name
16160 StrToUni(tmp, sizeof(tmp), t.ServerHostName);
16161 LvInsertAdd(b, ICO_TOWER, NULL, 2, _UU("SM_INFO_HOSTNAME"), tmp);
16162
16163 // Type
16164 LvInsertAdd(b, t.ServerType == SERVER_TYPE_STANDALONE ? ICO_SERVER_ONLINE : ICO_FARM, 0,
16165 2, _UU("SM_ST_SERVER_TYPE"),
16166 GetServerTypeStr(t.ServerType));
16167
16168 // OS
16169 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsSystemName);
16170 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_SYSTEM_NAME"), tmp);
16171
16172 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsProductName);
16173 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_PRODUCT_NAME"), tmp);
16174
16175 if (t.OsInfo.OsServicePack != 0)
16176 {
16177 UniFormat(tmp, sizeof(tmp), _UU("SM_OS_SP_TAG"), t.OsInfo.OsServicePack);
16178 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_SERVICE_PACK"), tmp);
16179 }
16180
16181 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsVendorName);
16182 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_VENDER_NAME"), tmp);
16183
16184 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsVersion);
16185 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_VERSION"), tmp);
16186
16187 StrToUni(tmp, sizeof(tmp), t.OsInfo.KernelName);
16188 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_KERNEL_NAME"), tmp);
16189
16190 StrToUni(tmp, sizeof(tmp), t.OsInfo.KernelVersion);
16191 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_OS_KERNEL_VERSION"), tmp);
16192
16193 SmAddServerCaps(b, p->CapsList);
16194
16195 LvInsertEnd(b, hWnd, L_STATUS);
16196
16197 FreeRpcServerInfo(&t);
16198
16199 return true;
16200 }
16201
16202 // Display the Caps of the server on the screen
SmAddServerCaps(LVB * b,CAPSLIST * t)16203 void SmAddServerCaps(LVB *b, CAPSLIST *t)
16204 {
16205 UINT i;
16206 // Validate arguments
16207 if (b == NULL || t == NULL)
16208 {
16209 return;
16210 }
16211
16212 for (i = 0;i < LIST_NUM(t->CapsList);i++)
16213 {
16214 CAPS *c = LIST_DATA(t->CapsList, i);
16215 wchar_t title[MAX_SIZE];
16216 char name[256];
16217
16218 Format(name, sizeof(name), "CT_%s", c->Name);
16219
16220 UniStrCpy(title, sizeof(title), _UU(name));
16221
16222 if (UniIsEmptyStr(title))
16223 {
16224 UniFormat(title, sizeof(title), L"%S", (StrLen(c->Name) >= 2) ? c->Name + 2 : c->Name);
16225 }
16226
16227 if (StartWith(c->Name, "b_"))
16228 {
16229 bool icon_pass = c->Value == 0 ? false : true;
16230 if (StrCmpi(c->Name, "b_must_install_pcap") == 0)
16231 {
16232 // Invert only the item of WinPcap
16233 icon_pass = !icon_pass;
16234 }
16235 LvInsertAdd(b, icon_pass == false ? ICO_DISCARD : ICO_PASS,
16236 NULL, 2, title, c->Value == 0 ? _UU("CAPS_NO") : _UU("CAPS_YES"));
16237 }
16238 else
16239 {
16240 wchar_t str[64];
16241 UniToStru(str, c->Value);
16242 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, title, str);
16243 }
16244 }
16245 }
16246
16247 // Update the server state
SmRefreshServerStatus(HWND hWnd,SM_SERVER * p,void * param)16248 bool SmRefreshServerStatus(HWND hWnd, SM_SERVER *p, void *param)
16249 {
16250 RPC_SERVER_STATUS t;
16251 LVB *b;
16252 wchar_t tmp[MAX_SIZE];
16253 char str[MAX_SIZE];
16254 // Validate arguments
16255 if (hWnd == NULL || p == NULL)
16256 {
16257 return false;
16258 }
16259
16260 Zero(&t, sizeof(t));
16261 if (CALL(hWnd, ScGetServerStatus(p->Rpc, &t)) == false)
16262 {
16263 return false;
16264 }
16265
16266 b = LvInsertStart();
16267
16268 // Type of server
16269 LvInsertAdd(b, t.ServerType == SERVER_TYPE_STANDALONE ? ICO_SERVER_ONLINE : ICO_FARM, 0,
16270 2, _UU("SM_ST_SERVER_TYPE"),
16271 GetServerTypeStr(t.ServerType));
16272
16273 // Number of TCP connections
16274 UniToStru(tmp, t.NumTcpConnections);
16275 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_ST_NUM_TCP"), tmp);
16276
16277 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
16278 {
16279 // Number of Local TCP connections
16280 UniToStru(tmp, t.NumTcpConnectionsLocal);
16281 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_ST_NUM_TCP_LOCAL"), tmp);
16282
16283 // Number of remote TCP connections
16284 UniToStru(tmp, t.NumTcpConnectionsRemote);
16285 LvInsertAdd(b, ICO_PROTOCOL, NULL, 2, _UU("SM_ST_NUM_TCP_REMOTE"), tmp);
16286 }
16287
16288 // Number of Virtual HUBs
16289 UniToStru(tmp, t.NumHubTotal);
16290 LvInsertAdd(b, ICO_HUB, NULL, 2, _UU("SM_ST_NUM_HUB_TOTAL"), tmp);
16291
16292 if (t.ServerType != SERVER_TYPE_STANDALONE)
16293 {
16294 // Number of static HUBs
16295 UniToStru(tmp, t.NumHubStatic);
16296 LvInsertAdd(b, ICO_HUB, NULL, 2, _UU("SM_ST_NUM_HUB_STATIC"), tmp);
16297
16298 // Number of Dynamic HUBs
16299 UniToStru(tmp, t.NumHubDynamic);
16300 LvInsertAdd(b, ICO_HUB, NULL, 2, _UU("SM_ST_NUM_HUB_DYNAMIC"), tmp);
16301 }
16302
16303 // Number of sessions
16304 UniToStru(tmp, t.NumSessionsTotal);
16305 LvInsertAdd(b, ICO_VPN, NULL, 2, _UU("SM_ST_NUM_SESSION_TOTAL"), tmp);
16306
16307 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
16308 {
16309 // Number of local sessions
16310 UniToStru(tmp, t.NumSessionsLocal);
16311 LvInsertAdd(b, ICO_VPN, NULL, 2, _UU("SM_ST_NUM_SESSION_LOCAL"), tmp);
16312
16313 // Number of local sessions
16314 UniToStru(tmp, t.NumSessionsRemote);
16315 LvInsertAdd(b, ICO_VPN, NULL, 2, _UU("SM_ST_NUM_SESSION_REMOTE"), tmp);
16316 }
16317
16318 // Number of MAC table entries
16319 UniToStru(tmp, t.NumMacTables);
16320 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_ST_NUM_MAC_TABLE"), tmp);
16321
16322 // Number of IP table entries
16323 UniToStru(tmp, t.NumIpTables);
16324 LvInsertAdd(b, ICO_MACHINE, NULL, 2, _UU("SM_ST_NUM_IP_TABLE"), tmp);
16325
16326 // Number of users
16327 UniToStru(tmp, t.NumUsers);
16328 LvInsertAdd(b, ICO_USER, NULL, 2, _UU("SM_ST_NUM_USERS"), tmp);
16329
16330 // Number of groups
16331 UniToStru(tmp, t.NumGroups);
16332 LvInsertAdd(b, ICO_GROUP, NULL, 2, _UU("SM_ST_NUM_GROUPS"), tmp);
16333
16334 // Number of assigned licenses
16335 UniToStru(tmp, t.AssignedClientLicenses);
16336 LvInsertAdd(b, ICO_CERT, NULL, 2, _UU("SM_ST_CLIENT_LICENSE"), tmp);
16337 UniToStru(tmp, t.AssignedBridgeLicenses);
16338 LvInsertAdd(b, ICO_CERT, NULL, 2, _UU("SM_ST_BRIDGE_LICENSE"), tmp);
16339
16340 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
16341 {
16342 UniToStru(tmp, t.AssignedClientLicensesTotal);
16343 LvInsertAdd(b, ICO_CERT, NULL, 2, _UU("SM_ST_CLIENT_LICENSE_EX"), tmp);
16344 UniToStru(tmp, t.AssignedBridgeLicensesTotal);
16345 LvInsertAdd(b, ICO_CERT, NULL, 2, _UU("SM_ST_BRIDGE_LICENSE_EX"), tmp);
16346 }
16347
16348 // Traffic
16349 SmInsertTrafficInfo(b, &t.Traffic);
16350
16351 // Server start-up time
16352 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.StartTime), NULL);
16353 LvInsertAdd(b, ICO_NULL, NULL, 2, _UU("SM_ST_START_TIME"), tmp);
16354
16355 // Current time
16356 GetDateTimeStrMilli64(str, sizeof(str), SystemToLocal64(t.CurrentTime));
16357 StrToUni(tmp, sizeof(tmp), str);
16358 LvInsertAdd(b, ICO_NULL, NULL, 2, _UU("SM_ST_CURRENT_TIME"), tmp);
16359
16360 // Tick value
16361 UniFormat(tmp, sizeof(tmp), L"%I64u", t.CurrentTick);
16362 LvInsertAdd(b, ICO_NULL, NULL, 2, _UU("SM_ST_CURRENT_TICK"), tmp);
16363
16364 // Memory information
16365 if (t.MemInfo.TotalMemory != 0)
16366 {
16367 char vv[128];
16368
16369 ToStr3(vv, sizeof(vv), t.MemInfo.TotalMemory);
16370 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
16371 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_TOTAL_MEMORY"), tmp);
16372
16373 ToStr3(vv, sizeof(vv), t.MemInfo.UsedMemory);
16374 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
16375 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_USED_MEMORY"), tmp);
16376
16377 ToStr3(vv, sizeof(vv), t.MemInfo.FreeMemory);
16378 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
16379 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_FREE_MEMORY"), tmp);
16380
16381 ToStr3(vv, sizeof(vv), t.MemInfo.TotalPhys);
16382 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
16383 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_TOTAL_PHYS"), tmp);
16384
16385 ToStr3(vv, sizeof(vv), t.MemInfo.UsedPhys);
16386 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
16387 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_USED_PHYS"), tmp);
16388
16389 ToStr3(vv, sizeof(vv), t.MemInfo.FreePhys);
16390 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
16391 LvInsertAdd(b, ICO_MEMORY, NULL, 2, _UU("SM_ST_FREE_PHYS"), tmp);
16392 }
16393
16394 LvInsertEnd(b, hWnd, L_STATUS);
16395
16396 return true;
16397 }
16398
16399 // Initialize
SmSaveKeyPairDlgInit(HWND hWnd,SM_SAVE_KEY_PAIR * s)16400 void SmSaveKeyPairDlgInit(HWND hWnd, SM_SAVE_KEY_PAIR *s)
16401 {
16402 UINT current;
16403 // Validate arguments
16404 if (hWnd == NULL || s == NULL)
16405 {
16406 return;
16407 }
16408
16409 current = MsRegReadInt(REG_CURRENT_USER, SM_REG_KEY, "SavePkcs12");
16410
16411 if (current == 1)
16412 {
16413 Check(hWnd, R_PKCS12, true);
16414 }
16415 else if (current == 2)
16416 {
16417 Check(hWnd, R_SECURE, true);
16418 }
16419 else
16420 {
16421 Check(hWnd, R_X509_AND_KEY, true);
16422 }
16423
16424 if (MsIsWine())
16425 {
16426 Disable(hWnd, R_SECURE);
16427 }
16428
16429 SmSaveKeyPairDlgUpdate(hWnd, s);
16430 }
16431
16432 // Update
SmSaveKeyPairDlgUpdate(HWND hWnd,SM_SAVE_KEY_PAIR * s)16433 void SmSaveKeyPairDlgUpdate(HWND hWnd, SM_SAVE_KEY_PAIR *s)
16434 {
16435 SECURE_DEVICE *dev;
16436 bool ok = true;
16437 wchar_t tmp[MAX_SIZE];
16438 // Validate arguments
16439 if (hWnd == NULL || s == NULL)
16440 {
16441 return;
16442 }
16443
16444 dev = GetSecureDevice(SmGetCurrentSecureIdFromReg());
16445 if (dev == NULL)
16446 {
16447 UniStrCpy(tmp, sizeof(tmp), _UU("SEC_CURRENT_NO_DEVICE"));
16448 }
16449 else
16450 {
16451 UniFormat(tmp, sizeof(tmp), _UU("SEC_CURRENT_DEVICE"), dev->DeviceName);
16452 }
16453
16454 SetText(hWnd, S_INFO, tmp);
16455
16456 if (IsChecked(hWnd, R_USE_PASS))
16457 {
16458 char *s1, *s2;
16459 s1 = GetTextA(hWnd, E_PASS1);
16460 s2 = GetTextA(hWnd, E_PASS2);
16461 if (StrCmp(s1, s2) != 0)
16462 {
16463 ok = false;
16464 }
16465 Free(s1);
16466 Free(s2);
16467 }
16468
16469 if (IsChecked(hWnd, R_SECURE))
16470 {
16471 if (dev == NULL)
16472 {
16473 ok = false;
16474 }
16475 }
16476
16477 SetEnable(hWnd, B_SELECT, IsChecked(hWnd, R_SECURE));
16478 SetEnable(hWnd, B_SECURE_MANAGER, IsChecked(hWnd, R_SECURE));
16479 SetEnable(hWnd, S_INFO, IsChecked(hWnd, R_SECURE));
16480
16481 SetEnable(hWnd, E_PASS1, IsChecked(hWnd, R_USE_PASS) && (IsChecked(hWnd, R_SECURE) == false));
16482 SetEnable(hWnd, E_PASS2, IsChecked(hWnd, R_USE_PASS) && (IsChecked(hWnd, R_SECURE) == false));
16483 SetEnable(hWnd, S_PASS1, IsChecked(hWnd, R_USE_PASS) && (IsChecked(hWnd, R_SECURE) == false));
16484 SetEnable(hWnd, S_PASS2, IsChecked(hWnd, R_USE_PASS) && (IsChecked(hWnd, R_SECURE) == false));
16485 SetEnable(hWnd, R_USE_PASS, (IsChecked(hWnd, R_SECURE) == false));
16486 SetEnable(hWnd, S_PASS3, (IsChecked(hWnd, R_SECURE) == false));
16487 SetEnable(hWnd, S_PASS4, (IsChecked(hWnd, R_SECURE) == false));
16488
16489 SetEnable(hWnd, IDOK, ok);
16490 }
16491
16492 // [OK] button
SmSaveKeyPairDlgOnOk(HWND hWnd,SM_SAVE_KEY_PAIR * s)16493 void SmSaveKeyPairDlgOnOk(HWND hWnd, SM_SAVE_KEY_PAIR *s)
16494 {
16495 UINT pkcs12;
16496 char pass[MAX_SIZE];
16497 char *password;
16498 // Validate arguments
16499 if (hWnd == NULL || s == NULL)
16500 {
16501 return;
16502 }
16503
16504 pkcs12 = 0;
16505
16506 if (IsChecked(hWnd, R_PKCS12))
16507 {
16508 pkcs12 = 1;
16509 }
16510 else if (IsChecked(hWnd, R_SECURE))
16511 {
16512 pkcs12 = 2;
16513 }
16514 MsRegWriteInt(REG_CURRENT_USER, SM_REG_KEY, "SavePkcs12", pkcs12);
16515
16516 if (pkcs12 != 2)
16517 {
16518 GetTxtA(hWnd, E_PASS1, pass, sizeof(pass));
16519
16520 if (StrLen(pass) != 0)
16521 {
16522 password = pass;
16523 }
16524 else
16525 {
16526 password = NULL;
16527 }
16528
16529 if (pkcs12 == false)
16530 {
16531 // Write to the X509 and KEY
16532 wchar_t *x509_name, *key_name;
16533 x509_name = SaveDlg(hWnd, _UU("DLG_CERT_FILES"), _UU("DLG_SAVE_CERT"), NULL, L".cer");
16534 if (x509_name == NULL)
16535 {
16536 // Cancel
16537 return;
16538 }
16539 else
16540 {
16541 wchar_t default_key_name[MAX_SIZE];
16542 UniReplaceStrEx(default_key_name, sizeof(default_key_name), x509_name,
16543 L".cer", L"", false);
16544 UniReplaceStrEx(default_key_name, sizeof(default_key_name), default_key_name,
16545 L".crt", L"", false);
16546 UniStrCat(default_key_name, sizeof(default_key_name), L".key");
16547 key_name = SaveDlg(hWnd, _UU("DLG_KEY_FILTER"), _UU("DLG_SAVE_KEY"),
16548 default_key_name, L".key");
16549 if (key_name == NULL)
16550 {
16551 // Cancel
16552 Free(x509_name);
16553 return;
16554 }
16555 else
16556 {
16557 bool ok = true;
16558 wchar_t filename1[MAX_SIZE];
16559 wchar_t filename2[MAX_SIZE];
16560
16561 UniStrCpy(filename1, sizeof(filename1), x509_name);
16562 UniStrCpy(filename2, sizeof(filename2), key_name);
16563
16564 // Save the certificate
16565 if (XToFileW(s->Cert, filename1, true) == false)
16566 {
16567 MsgBox(hWnd, MB_ICONSTOP, _UU("DLG_CERT_SAVE_ERROR"));
16568 ok = false;
16569 }
16570 else
16571 {
16572 if (KToFileW(s->Key, filename2, true, password) == false)
16573 {
16574 MsgBox(hWnd, MB_ICONSTOP, _UU("DLG_KEY_SAVE_ERROR"));
16575 ok = false;
16576 }
16577 }
16578
16579 if (ok)
16580 {
16581 MsgBox(hWnd, MB_ICONINFORMATION, _UU("DLG_KEY_PAIR_SAVE_OK"));
16582 EndDialog(hWnd, true);
16583 }
16584
16585 Free(key_name);
16586 }
16587 Free(x509_name);
16588 }
16589 }
16590 else
16591 {
16592 // Write to the PKCS#12
16593 wchar_t *name = SaveDlg(hWnd, _UU("DLG_PKCS12_FILTER"), _UU("DLG_SAVE_P12"), NULL, L".p12");
16594 if (name == NULL)
16595 {
16596 // Cancel
16597 return;
16598 }
16599 else
16600 {
16601 P12 *p12;
16602 wchar_t filename[MAX_SIZE];
16603 UniStrCpy(filename, sizeof(filename), name);
16604
16605 // Convert to PKCS#12
16606 p12 = NewP12(s->Cert, s->Key, pass);
16607 if (p12 == NULL)
16608 {
16609 // Failure
16610 MsgBox(hWnd, MB_ICONSTOP, _UU("DLG_KEY_PAIR_SAVE_ERROR"));
16611 }
16612 else
16613 {
16614 // Save
16615 if (P12ToFileW(p12, filename) == false)
16616 {
16617 // Failure
16618 MsgBox(hWnd, MB_ICONSTOP, _UU("DLG_KEY_PAIR_SAVE_ERROR"));
16619 }
16620 else
16621 {
16622 // Success
16623 MsgBox(hWnd, MB_ICONINFORMATION, _UU("DLG_KEY_PAIR_SAVE_OK"));
16624 EndDialog(hWnd, true);
16625 }
16626 FreeP12(p12);
16627 }
16628
16629 Free(name);
16630 }
16631 }
16632 }
16633 else
16634 {
16635 char default_name[MAX_SIZE];
16636 char *object_name;
16637 bool ok = false;
16638 X *x;
16639 K *k;
16640 WINUI_SECURE_BATCH batch[] =
16641 {
16642 {WINUI_SECURE_WRITE_CERT, NULL, true, NULL, NULL, NULL, NULL, NULL, NULL},
16643 {WINUI_SECURE_WRITE_KEY, NULL, true, NULL, NULL, NULL, NULL, NULL, NULL},
16644 };
16645
16646 x = s->Cert;
16647 k = s->Key;
16648
16649 // Generate the default name
16650 GetPrintNameFromXA(default_name, sizeof(default_name), x);
16651 ConvertSafeFileName(default_name, sizeof(default_name), default_name);
16652
16653 object_name = StringDlgA(hWnd, _UU("SEC_OBJECT_NAME_TITLE"),
16654 _UU("SEC_OBJECT_NAME_INFO"), default_name, ICO_CERT, false, false);
16655
16656 if (object_name != NULL)
16657 {
16658 // Write and enumerate
16659 batch[0].InputX = x;
16660 batch[0].Name = object_name;
16661 batch[1].InputK = k;
16662 batch[1].Name = object_name;
16663
16664 if (SecureDeviceWindow(hWnd, batch, sizeof(batch) / sizeof(batch[0]), SmGetCurrentSecureIdFromReg(), 0) == false)
16665 {
16666 // Failure
16667 }
16668 else
16669 {
16670 ok = true;
16671 }
16672
16673 Free(object_name);
16674 }
16675
16676 if (ok)
16677 {
16678 MsgBox(hWnd, MB_ICONINFORMATION, _UU("SEC_NEW_CERT_IMPORT_OK"));
16679
16680 EndDialog(hWnd, true);
16681 }
16682 }
16683 }
16684
16685 // Saving dialog box of the certificate and private key
SmSaveKeyPairDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)16686 UINT SmSaveKeyPairDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
16687 {
16688 SM_SAVE_KEY_PAIR *s = (SM_SAVE_KEY_PAIR *)param;
16689 // Validate arguments
16690 if (hWnd == NULL)
16691 {
16692 return 0;
16693 }
16694
16695 switch (msg)
16696 {
16697 case WM_INITDIALOG:
16698 // Initialize
16699 SmSaveKeyPairDlgInit(hWnd, s);
16700 break;
16701
16702 case WM_COMMAND:
16703 switch (LOWORD(wParam))
16704 {
16705 case E_PASS1:
16706 case E_PASS2:
16707 case R_USE_PASS:
16708 case R_SECURE:
16709 case R_X509_AND_KEY:
16710 case R_PKCS12:
16711 SmSaveKeyPairDlgUpdate(hWnd, s);
16712 break;
16713 }
16714
16715 switch (wParam)
16716 {
16717 case IDOK:
16718 // [OK] button
16719 SmSaveKeyPairDlgOnOk(hWnd, s);
16720 break;
16721
16722 case IDCANCEL:
16723 // Cancel button
16724 Close(hWnd);
16725 break;
16726
16727 case R_USE_PASS:
16728 if (IsChecked(hWnd, R_USE_PASS))
16729 {
16730 FocusEx(hWnd, E_PASS1);
16731 }
16732 break;
16733
16734 case B_SELECT:
16735 SmSelectSecureId(hWnd);
16736 SmSaveKeyPairDlgUpdate(hWnd, s);
16737 break;
16738
16739 case B_SECURE_MANAGER:
16740 CmSecureManagerEx(hWnd, SmGetCurrentSecureId(hWnd), true);
16741 SmSaveKeyPairDlgUpdate(hWnd, s);
16742 break;
16743 }
16744 break;
16745
16746 case WM_CLOSE:
16747 EndDialog(hWnd, false);
16748 break;
16749 }
16750
16751 return 0;
16752 }
16753
16754 // Save the certificate and private key
SmSaveKeyPairDlg(HWND hWnd,X * x,K * k)16755 bool SmSaveKeyPairDlg(HWND hWnd, X *x, K *k)
16756 {
16757 SM_SAVE_KEY_PAIR s;
16758 // Validate arguments
16759 if (hWnd == NULL || x == NULL || k == NULL)
16760 {
16761 return false;
16762 }
16763
16764 Zero(&s, sizeof(s));
16765 s.Cert = x;
16766 s.Key = k;
16767
16768 return Dialog(hWnd, D_SM_SAVE_KEY_PAIR, SmSaveKeyPairDlgProc, &s);
16769 }
16770
16771 // OK is clicked on the SSL related dialog
SmSslDlgOnOk(HWND hWnd,SM_SSL * s)16772 void SmSslDlgOnOk(HWND hWnd, SM_SSL *s)
16773 {
16774 char *name;
16775 RPC_KEEP t;
16776 // Validate arguments
16777 if (hWnd == NULL || s == NULL)
16778 {
16779 return;
16780 }
16781
16782 if (s->p->ServerAdminMode == false)
16783 {
16784 EndDialog(hWnd, false);
16785 return;
16786 }
16787
16788 name = GetTextA(hWnd, C_CIPHER);
16789 if (name == NULL)
16790 {
16791 return;
16792 }
16793 else
16794 {
16795 RPC_STR t;
16796 Zero(&t, sizeof(t));
16797 t.String = name;
16798
16799 // Set the encryption algorithm
16800 if (CALL(hWnd, ScSetServerCipher(s->p->Rpc, &t)) == false)
16801 {
16802 Focus(hWnd, C_CIPHER);
16803 return;
16804 }
16805 FreeRpcStr(&t);
16806 }
16807
16808 if (s->SetCertAndKey)
16809 {
16810 // Set the certificate
16811 RPC_KEY_PAIR t;
16812 Zero(&t, sizeof(t));
16813
16814 t.Cert = CloneX(s->Cert);
16815 t.Key = CloneK(s->Key);
16816
16817 if (CALL(hWnd, ScSetServerCert(s->p->Rpc, &t)) == false)
16818 {
16819 return;
16820 }
16821
16822 if (t.Flag1 == 0)
16823 {
16824 // Show the warning message
16825 MsgBox(hWnd, MB_ICONWARNING, _UU("SM_CERT_NEED_ROOT"));
16826 }
16827
16828 FreeRpcKeyPair(&t);
16829
16830 MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_CERT_SET_MSG"));
16831 }
16832
16833 Zero(&t, sizeof(t));
16834 t.UseKeepConnect = IsChecked(hWnd, R_USE_KEEP_CONNECT);
16835 GetTxtA(hWnd, E_HOSTNAME, t.KeepConnectHost, sizeof(t.KeepConnectHost));
16836 t.KeepConnectPort = GetInt(hWnd, E_PORT);
16837 t.KeepConnectInterval = GetInt(hWnd, E_INTERVAL);
16838 t.KeepConnectProtocol = IsChecked(hWnd, R_UDP) ? 1 : 0;
16839
16840 CALL(hWnd, ScSetKeep(s->p->Rpc, &t));
16841
16842 if (GetCapsBool(s->p->CapsList, "b_support_syslog"))
16843 {
16844 if (s->p->ServerAdminMode)
16845 {
16846 SYSLOG_SETTING set;
16847
16848 Zero(&set, sizeof(set));
16849 GetTxtA(hWnd, E_SYSLOG_HOSTNAME, set.Hostname, sizeof(set.Hostname));
16850 set.Port = GetInt(hWnd, E_SYSLOG_PORT);
16851 set.SaveType = CbGetSelect(hWnd, C_SYSLOG);
16852
16853 if (CALL(hWnd, ScSetSysLog(s->p->Rpc, &set)) == false)
16854 {
16855 return;
16856 }
16857 }
16858 }
16859
16860 EndDialog(hWnd, true);
16861 }
16862
16863 // SSL related dialog initialization
SmSslDlgInit(HWND hWnd,SM_SSL * s)16864 void SmSslDlgInit(HWND hWnd, SM_SSL *s)
16865 {
16866 UINT i;
16867 TOKEN_LIST *cipher_list;
16868 RPC_KEEP t;
16869 bool private_key_exportable = false;
16870 // Validate arguments
16871 if (hWnd == NULL || s == NULL)
16872 {
16873 return;
16874 }
16875
16876 if (s->p != NULL)
16877 {
16878 RPC_STR t;
16879 Zero(&t, sizeof(t));
16880
16881 SetFont(hWnd, C_CIPHER, GetFont("Tahoma", 8, false, false, false, false));
16882 CbSetHeight(hWnd, C_CIPHER, 18);
16883
16884 // Get the list of available encryption algorithms from the server
16885 if (ScGetServerCipherList(s->p->Rpc, &t) == ERR_NO_ERROR)
16886 {
16887 cipher_list = ParseToken(t.String, ";");
16888
16889 FreeRpcStr(&t);
16890 Zero(&t, sizeof(t));
16891
16892 for (i = 0; i < cipher_list->NumTokens; i++)
16893 {
16894 wchar_t tmp[MAX_SIZE];
16895 char *name = cipher_list->Token[i];
16896 StrToUni(tmp, sizeof(tmp), name);
16897 CbAddStr(hWnd, C_CIPHER, tmp, 0);
16898 }
16899
16900 FreeToken(cipher_list);
16901 }
16902
16903 // Get the current encryption algorithm's name from the server
16904 if (CALL(hWnd, ScGetServerCipher(s->p->Rpc, &t)))
16905 {
16906 wchar_t tmp[MAX_SIZE];
16907 StrToUni(tmp, sizeof(tmp), t.String);
16908 SetText(hWnd, C_CIPHER, tmp);
16909 FreeRpcStr(&t);
16910 }
16911 else
16912 {
16913 EndDialog(hWnd, 0);
16914 return;
16915 }
16916 }
16917
16918 if (s->p != NULL)
16919 {
16920 wchar_t tmp[MAX_SIZE];
16921 // Get the SSL certificate and private key from the server
16922 RPC_KEY_PAIR t;
16923 s->SetCertAndKey = false;
16924 Zero(&t, sizeof(t));
16925 if (CALL(hWnd, ScGetServerCert(s->p->Rpc, &t)))
16926 {
16927 // Copy the certificate and key
16928 s->Cert = CloneX(t.Cert);
16929 s->Key = CloneK(t.Key);
16930
16931 if (t.Key != NULL)
16932 {
16933 private_key_exportable = true;
16934 }
16935
16936 FreeRpcKeyPair(&t);
16937 }
16938 else
16939 {
16940 EndDialog(hWnd, 0);
16941 return;
16942 }
16943
16944 // Show the Certificate Information
16945 SmGetCertInfoStr(tmp, sizeof(tmp), s->Cert);
16946 SetText(hWnd, S_CERT_INFO, tmp);
16947 }
16948
16949 // Password change
16950 SetEnable(hWnd, B_PASSWORD, s->p->ServerAdminMode);
16951 SetEnable(hWnd, S_INFO4, s->p->ServerAdminMode);
16952
16953 // Enable / disable the button
16954 SetEnable(hWnd, B_IMPORT, s->p->ServerAdminMode);
16955 SetEnable(hWnd, B_EXPORT, s->p->ServerAdminMode && private_key_exportable);
16956 SetEnable(hWnd, B_REGENERATE, s->p->ServerAdminMode);
16957 SetEnable(hWnd, R_USE_KEEP_CONNECT, s->p->ServerAdminMode);
16958 SetEnable(hWnd, B_UPDATE_CONFIG, s->p->Update != NULL);
16959
16960 if (s->p->ServerAdminMode && GetCapsBool(s->p->CapsList, "b_support_special_listener"))
16961 {
16962 SetEnable(hWnd, B_SPECIALLISTENER, true);
16963 SetEnable(hWnd, S_INFO5, true);
16964 }
16965 else
16966 {
16967 SetEnable(hWnd, B_SPECIALLISTENER, false);
16968 SetEnable(hWnd, S_INFO5, false);
16969 }
16970
16971 if (s->p->ServerAdminMode == false)
16972 {
16973 Disable(hWnd, C_CIPHER);
16974 }
16975
16976 if (CALL(hWnd, ScGetKeep(s->p->Rpc, &t)))
16977 {
16978 Check(hWnd, R_USE_KEEP_CONNECT, t.UseKeepConnect);
16979 SetTextA(hWnd, E_HOSTNAME, t.KeepConnectHost);
16980 SetIntEx(hWnd, E_PORT, t.KeepConnectPort);
16981 SetInt(hWnd, E_INTERVAL, t.KeepConnectInterval);
16982 Check(hWnd, R_TCP, t.KeepConnectProtocol == 0);
16983 Check(hWnd, R_UDP, t.KeepConnectProtocol != 0);
16984 }
16985
16986 CbSetHeight(hWnd, C_SYSLOG, 18);
16987 CbReset(hWnd, C_SYSLOG);
16988 CbAddStr(hWnd, C_SYSLOG, _UU("SM_SYSLOG_0"), SYSLOG_NONE);
16989 CbAddStr(hWnd, C_SYSLOG, _UU("SM_SYSLOG_1"), SYSLOG_SERVER_LOG);
16990 CbAddStr(hWnd, C_SYSLOG, _UU("SM_SYSLOG_2"), SYSLOG_SERVER_AND_HUB_SECURITY_LOG);
16991 CbAddStr(hWnd, C_SYSLOG, _UU("SM_SYSLOG_3"), SYSLOG_SERVER_AND_HUB_ALL_LOG);
16992
16993 if (GetCapsBool(s->p->CapsList, "b_support_syslog"))
16994 {
16995 SYSLOG_SETTING set;
16996
16997 SetEnable(hWnd, C_SYSLOG, s->p->ServerAdminMode);
16998 SetEnable(hWnd, E_SYSLOG_HOSTNAME, s->p->ServerAdminMode);
16999 SetEnable(hWnd, E_SYSLOG_PORT, s->p->ServerAdminMode);
17000 SetEnable(hWnd, S_01, s->p->ServerAdminMode);
17001 SetEnable(hWnd, S_02, s->p->ServerAdminMode);
17002
17003 Zero(&set, sizeof(set));
17004
17005 if (CALL(hWnd, ScGetSysLog(s->p->Rpc, &set)))
17006 {
17007 SetTextA(hWnd, E_SYSLOG_HOSTNAME, set.Hostname);
17008 SetInt(hWnd, E_SYSLOG_PORT, set.Port == 0 ? SYSLOG_PORT : set.Port);
17009 CbSelect(hWnd, C_SYSLOG, set.SaveType);
17010 }
17011 }
17012 else
17013 {
17014 Disable(hWnd, C_SYSLOG);
17015 Disable(hWnd, E_SYSLOG_HOSTNAME);
17016 Disable(hWnd, E_SYSLOG_PORT);
17017 Disable(hWnd, S_01);
17018 Disable(hWnd, S_02);
17019 }
17020
17021 SmSslDlgUpdate(hWnd, s);
17022 }
17023
17024 // SSL related dialog control update
SmSslDlgUpdate(HWND hWnd,SM_SSL * s)17025 void SmSslDlgUpdate(HWND hWnd, SM_SSL *s)
17026 {
17027 bool ok = true;
17028 bool b;
17029 // Validate arguments
17030 if (hWnd == NULL || s == NULL)
17031 {
17032 return;
17033 }
17034
17035 if (IsChecked(hWnd, R_USE_KEEP_CONNECT))
17036 {
17037 UINT i;
17038 b = true;
17039 if (IsEmpty(hWnd, E_HOSTNAME))
17040 {
17041 ok = false;
17042 }
17043 i = GetInt(hWnd, E_PORT);
17044 if (i == 0 || i >= 65536)
17045 {
17046 ok = false;
17047 }
17048 i = GetInt(hWnd, E_INTERVAL);
17049 if (i < 5 || i > 600)
17050 {
17051 ok = false;
17052 }
17053 }
17054 else
17055 {
17056 b = false;
17057 }
17058
17059 if (IsEnable(hWnd, C_SYSLOG))
17060 {
17061 UINT i = CbGetSelect(hWnd, C_SYSLOG);
17062
17063 SetEnable(hWnd, E_SYSLOG_HOSTNAME, i != SYSLOG_NONE);
17064 SetEnable(hWnd, E_SYSLOG_PORT, i != SYSLOG_NONE);
17065 SetEnable(hWnd, S_01, i != SYSLOG_NONE);
17066 SetEnable(hWnd, S_02, i != SYSLOG_NONE);
17067 }
17068
17069 SetEnable(hWnd, S_HOSTNAME, b);
17070 SetEnable(hWnd, E_HOSTNAME, b);
17071 SetEnable(hWnd, S_PORT, b);
17072 SetEnable(hWnd, E_PORT, b);
17073 SetEnable(hWnd, S_INTERVAL, b);
17074 SetEnable(hWnd, E_INTERVAL, b);
17075 SetEnable(hWnd, S_INTERVAL2, b);
17076 SetEnable(hWnd, S_PROTOCOL, b);
17077 SetEnable(hWnd, R_TCP, b);
17078 SetEnable(hWnd, R_UDP, b);
17079 SetEnable(hWnd, S_INFO, b);
17080
17081 SetEnable(hWnd, IDOK, ok);
17082 }
17083
17084 // Get the certificate information string
SmGetCertInfoStr(wchar_t * str,UINT size,X * x)17085 void SmGetCertInfoStr(wchar_t *str, UINT size, X *x)
17086 {
17087 wchar_t subject[MAX_SIZE];
17088 wchar_t issuer[MAX_SIZE];
17089 wchar_t date[MAX_SIZE];
17090 // Validate arguments
17091 if (x == NULL || str == NULL)
17092 {
17093 if (str != NULL)
17094 {
17095 str[0] = 0;
17096 }
17097 return;
17098 }
17099
17100 GetPrintNameFromName(subject, sizeof(subject), x->subject_name);
17101 GetPrintNameFromName(issuer, sizeof(issuer), x->issuer_name);
17102 GetDateStrEx64(date, sizeof(date), x->notAfter, NULL);
17103
17104 UniFormat(str, size, _UU("CM_CERT_INFO"), subject, issuer, date);
17105 }
17106
17107 // Regenerate the server certificate
SmRegenerateServerCert(HWND hWnd,SM_SERVER * server,char * default_cn,X ** x,K ** k,bool root_only)17108 bool SmRegenerateServerCert(HWND hWnd, SM_SERVER *server, char *default_cn, X **x, K **k, bool root_only)
17109 {
17110 char defcn[MAX_SIZE];
17111 // Validate arguments
17112 if (server == NULL || x == NULL || k == NULL)
17113 {
17114 return false;
17115 }
17116
17117 Zero(defcn, sizeof(defcn));
17118 if (IsEmptyStr(default_cn) == false)
17119 {
17120 StrCpy(defcn, sizeof(defcn), default_cn);
17121 }
17122
17123 if (IsEmptyStr(defcn))
17124 {
17125 // If default CN is not specified, copy from the setting of the DDNS server
17126 DDNS_CLIENT_STATUS t;
17127
17128 Zero(&t, sizeof(t));
17129
17130 if (ScGetDDnsClientStatus(server->Rpc, &t) == ERR_NO_ERROR)
17131 {
17132 if (IsEmptyStr(t.CurrentFqdn) == false)
17133 {
17134 StrCpy(defcn, sizeof(defcn), t.CurrentFqdn);
17135 }
17136 }
17137 }
17138
17139 if (IsEmptyStr(defcn))
17140 {
17141 // Copy from the certificate information of the current server
17142 RPC_KEY_PAIR t;
17143
17144 Zero(&t, sizeof(t));
17145
17146 if (ScGetServerCert(server->Rpc, &t) == ERR_NO_ERROR)
17147 {
17148 if (t.Cert != NULL)
17149 {
17150 if (t.Cert->subject_name != NULL)
17151 {
17152 UniToStr(defcn, sizeof(defcn), t.Cert->subject_name->CommonName);
17153 }
17154 }
17155
17156 FreeRpcKeyPair(&t);
17157 }
17158 }
17159
17160 if (IsEmptyStr(defcn))
17161 {
17162 // Copy from the destination server name of the current connection settings
17163 StrCpy(defcn, sizeof(defcn), server->ServerName);
17164 }
17165
17166 // Create a new certificate in the Certificate Creation Tool
17167 if (SmCreateCert(hWnd, x, k, true, defcn, root_only) == false)
17168 {
17169 return false;
17170 }
17171
17172 return true;
17173 }
17174
17175 // SSL related dialog procedure
SmSslDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)17176 UINT SmSslDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
17177 {
17178 SM_SSL *s = (SM_SSL *)param;
17179 X *x;
17180 K *k;
17181 // Validate arguments
17182 if (hWnd == NULL)
17183 {
17184 return 0;
17185 }
17186
17187 switch (msg)
17188 {
17189 case WM_INITDIALOG:
17190 // Initialize
17191 SmSslDlgInit(hWnd, s);
17192 break;
17193
17194 case WM_COMMAND:
17195 switch (LOWORD(wParam))
17196 {
17197 case R_USE_KEEP_CONNECT:
17198 case E_HOSTNAME:
17199 case E_PORT:
17200 case E_INTERVAL:
17201 case R_TCP:
17202 case R_UDP:
17203 case C_SYSLOG:
17204 case E_SYSLOG_HOSTNAME:
17205 case E_SYSLOG_PORT:
17206 SmSslDlgUpdate(hWnd, s);
17207 break;
17208 }
17209
17210 switch (wParam)
17211 {
17212 case IDOK:
17213 // [OK] button
17214 SmSslDlgOnOk(hWnd, s);
17215 break;
17216
17217 case IDCANCEL:
17218 // Cancel button
17219 Close(hWnd);
17220 break;
17221
17222 case B_UPDATE_CONFIG:
17223 // Update notification setting
17224 ConfigUpdateUi(s->p->Update, hWnd);
17225 break;
17226
17227 case B_IMPORT:
17228 // Import
17229 if (CmLoadXAndK(hWnd, &x, &k))
17230 {
17231 wchar_t tmp[MAX_SIZE];
17232
17233 LABEL_APPLY_NEW_CERT:
17234 FreeX(s->Cert);
17235 FreeK(s->Key);
17236 s->Cert = x;
17237 s->Key = k;
17238 s->SetCertAndKey = true;
17239 // Show the Certificate Information
17240 SmGetCertInfoStr(tmp, sizeof(tmp), s->Cert);
17241 SetText(hWnd, S_CERT_INFO, tmp);
17242 }
17243 break;
17244
17245 case B_EXPORT:
17246 // Export
17247 SmSaveKeyPairDlg(hWnd, s->Cert, s->Key);
17248 break;
17249
17250 case B_VIEW:
17251 // Show the certificate
17252 CertDlg(hWnd, s->Cert, NULL, true);
17253 break;
17254
17255 case B_SPECIALLISTENER:
17256 // Special listener configuration
17257 SmSpecialListener(hWnd, s->p);
17258 break;
17259
17260 case B_REGENERATE:
17261 // Regenerating the certificate
17262 if (SmRegenerateServerCert(hWnd, s->p, NULL, &x, &k, false))
17263 {
17264 // Confirmation message
17265 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_YESNO, _UU("SM_REGENERATE_CERT_MSG")) == IDYES)
17266 {
17267 goto LABEL_APPLY_NEW_CERT;
17268 }
17269 else
17270 {
17271 FreeX(x);
17272 FreeK(k);
17273 }
17274 }
17275 break;
17276
17277 case B_PASSWORD:
17278 // Password change
17279 Dialog(hWnd, D_SM_CHANGE_PASSWORD, SmChangeServerPasswordDlg, s->p);
17280 break;
17281
17282 case R_USE_KEEP_CONNECT:
17283 if (IsChecked(hWnd, R_USE_KEEP_CONNECT))
17284 {
17285 FocusEx(hWnd, E_HOSTNAME);
17286 }
17287 break;
17288 }
17289 break;
17290
17291 case WM_CLOSE:
17292 EndDialog(hWnd, false);
17293 break;
17294 }
17295
17296 return 0;
17297 }
17298
17299 // Display the SSL related dialog
SmSslDlg(HWND hWnd,SM_SERVER * p)17300 void SmSslDlg(HWND hWnd, SM_SERVER *p)
17301 {
17302 SM_SSL s;
17303 // Validate arguments
17304 if (hWnd == NULL || p == NULL)
17305 {
17306 return;
17307 }
17308
17309 Zero(&s, sizeof(s));
17310 s.p = p;
17311
17312 Dialog(hWnd, D_SM_SSL, SmSslDlgProc, &s);
17313
17314 // Cleanup
17315 FreeX(s.Cert);
17316 FreeK(s.Key);
17317 }
17318
17319 // Listener creation dialog procedure
SmCreateListenerDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)17320 UINT SmCreateListenerDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
17321 {
17322 UINT port;
17323 RPC_LISTENER t;
17324 SM_SERVER *p = (SM_SERVER *)param;
17325 // Validate arguments
17326 if (hWnd == NULL)
17327 {
17328 return 0;
17329 }
17330
17331 switch (msg)
17332 {
17333 case WM_INITDIALOG:
17334 Focus(hWnd, E_PORT);
17335 Disable(hWnd, IDOK);
17336 break;
17337
17338 case WM_COMMAND:
17339 switch (LOWORD(wParam))
17340 {
17341 case E_PORT:
17342 port = GetInt(hWnd, E_PORT);
17343 if (port == 0 || port >= 65536)
17344 {
17345 Disable(hWnd, IDOK);
17346 }
17347 else
17348 {
17349 Enable(hWnd, IDOK);
17350 }
17351 break;
17352 }
17353
17354 switch (wParam)
17355 {
17356 case IDOK:
17357 port = GetInt(hWnd, E_PORT);
17358 Zero(&t, sizeof(t));
17359 t.Enable = true;
17360 t.Port = port;
17361 if (CALL(hWnd, ScCreateListener(p->Rpc, &t)))
17362 {
17363 EndDialog(hWnd, true);
17364 }
17365 break;
17366 case IDCANCEL:
17367 Close(hWnd);
17368 }
17369 break;
17370
17371 case WM_CLOSE:
17372 EndDialog(hWnd, false);
17373 break;
17374 }
17375
17376 return 0;
17377 }
17378
17379 // Listener creation dialog
SmCreateListenerDlg(HWND hWnd,SM_SERVER * p)17380 bool SmCreateListenerDlg(HWND hWnd, SM_SERVER *p)
17381 {
17382 // Validate arguments
17383 if (hWnd == NULL || p == NULL)
17384 {
17385 return false;
17386 }
17387
17388 return Dialog(hWnd, D_SM_CREATE_LISTENER, SmCreateListenerDlgProc, p);
17389 }
17390
17391 // HUB edit OK button
SmEditHubOnOk(HWND hWnd,SM_EDIT_HUB * s)17392 void SmEditHubOnOk(HWND hWnd, SM_EDIT_HUB *s)
17393 {
17394 RPC_CREATE_HUB t;
17395 char pass1[MAX_SIZE];
17396 char pass2[MAX_SIZE];
17397 char hubname[MAX_HUBNAME_LEN + 1];
17398 // Validate arguments
17399 if (hWnd == NULL || s == NULL)
17400 {
17401 return;
17402 }
17403
17404 Zero(&t, sizeof(t));
17405 if (s->EditMode)
17406 {
17407 StrCpy(hubname, sizeof(hubname), s->HubName);
17408 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
17409 }
17410 else
17411 {
17412 GetTxtA(hWnd, E_HUBNAME, t.HubName, sizeof(t.HubName));
17413 StrCpy(hubname, sizeof(hubname), t.HubName);
17414 }
17415
17416 GetTxtA(hWnd, E_PASSWORD1, pass1, sizeof(pass1));
17417 GetTxtA(hWnd, E_PASSWORD2, pass2, sizeof(pass2));
17418
17419 if (s->EditMode == false || StrCmp(pass1, HIDDEN_PASSWORD) != 0)
17420 {
17421 Sha0(t.HashedPassword, pass1, StrLen(pass1));
17422 HashPassword(t.SecurePassword, ADMINISTRATOR_USERNAME, pass1);
17423 }
17424
17425 if (IsChecked(hWnd, R_LIMIT_MAX_SESSION))
17426 {
17427 t.HubOption.MaxSession = GetInt(hWnd, E_MAX_SESSION);
17428 }
17429
17430 t.Online = IsChecked(hWnd, R_ONLINE);
17431
17432 if (s->p->ServerType == SERVER_TYPE_FARM_CONTROLLER)
17433 {
17434 t.HubType = HUB_TYPE_FARM_STATIC;
17435 if (IsChecked(hWnd, R_DYNAMIC))
17436 {
17437 t.HubType = HUB_TYPE_FARM_DYNAMIC;
17438 }
17439 }
17440
17441 t.HubOption.NoEnum = IsChecked(hWnd, R_NO_ENUM);
17442
17443 if (s->EditMode == false)
17444 {
17445 if (CALL(hWnd, ScCreateHub(s->p->Rpc, &t)))
17446 {
17447 MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("CM_EDIT_HUB_CREATED"), hubname);
17448 EndDialog(hWnd, true);
17449 }
17450 }
17451 else
17452 {
17453 if (CALL(hWnd, ScSetHub(s->p->Rpc, &t)))
17454 {
17455 EndDialog(hWnd, true);
17456 }
17457 }
17458 }
17459
17460 // HUB editing update
SmEditHubUpdate(HWND hWnd,SM_EDIT_HUB * s)17461 void SmEditHubUpdate(HWND hWnd, SM_EDIT_HUB *s)
17462 {
17463 bool ok = true;
17464 char *s1, *s2;
17465 char hubname[MAX_HUBNAME_LEN + 1];
17466 // Validate arguments
17467 if (hWnd == NULL || s == NULL)
17468 {
17469 return;
17470 }
17471
17472 s1 = GetTextA(hWnd, E_PASSWORD1);
17473 s2 = GetTextA(hWnd, E_PASSWORD2);
17474 if (StrCmp(s1, s2) != 0)
17475 {
17476 ok = false;
17477 }
17478 Free(s1);
17479 Free(s2);
17480
17481 GetTxtA(hWnd, E_HUBNAME, hubname, sizeof(hubname));
17482 Trim(hubname);
17483 if (StrLen(hubname) == 0 ||
17484 IsSafeStr(hubname) == false)
17485 {
17486 ok = false;
17487 }
17488
17489 if (IsChecked(hWnd, R_LIMIT_MAX_SESSION))
17490 {
17491 Enable(hWnd, E_MAX_SESSION);
17492 Enable(hWnd, S_MAX_SESSION_1);
17493 Enable(hWnd, S_MAX_SESSION_2);
17494 if (GetInt(hWnd, E_MAX_SESSION) == 0)
17495 {
17496 ok = false;
17497 }
17498 }
17499 else
17500 {
17501 Disable(hWnd, E_MAX_SESSION);
17502 Disable(hWnd, S_MAX_SESSION_1);
17503 Disable(hWnd, S_MAX_SESSION_2);
17504 }
17505
17506 SetEnable(hWnd, IDOK, ok);
17507 }
17508
17509 // HUB editing initialization
SmEditHubInit(HWND hWnd,SM_EDIT_HUB * s)17510 void SmEditHubInit(HWND hWnd, SM_EDIT_HUB *s)
17511 {
17512 RPC_CREATE_HUB t;
17513 bool b = false;
17514 bool support_extoption = false;
17515 // Validate arguments
17516 if (hWnd == NULL || s == NULL)
17517 {
17518 return;
17519 }
17520
17521 SetIcon(hWnd, 0, ICO_HUB);
17522
17523 Zero(&t, sizeof(t));
17524
17525 if (s->EditMode == false)
17526 {
17527 // Create new
17528 SetText(hWnd, 0, _UU("CM_EDIT_HUB_1"));
17529 FocusEx(hWnd, E_HUBNAME);
17530
17531 if (s->p->ServerType == SERVER_TYPE_STANDALONE)
17532 {
17533 // Stand-alone mode
17534 Disable(hWnd, R_STATIC);
17535 Disable(hWnd, R_DYNAMIC);
17536 SetText(hWnd, S_FARM_INFO, _UU("CM_EDIT_HUB_STANDALONE"));
17537 }
17538 else
17539 {
17540 Check(hWnd, R_STATIC, true);
17541 }
17542
17543 Check(hWnd, R_ONLINE, true);
17544
17545 Hide(hWnd, B_ACL);
17546 Hide(hWnd, S_ACL);
17547 Hide(hWnd, S_ACL_2);
17548 Hide(hWnd, S_ACL_3);
17549 Hide(hWnd, S_MSG_1);
17550 Hide(hWnd, S_MSG_4);
17551 Hide(hWnd, S_MSG_2);
17552 Hide(hWnd, B_MSG);
17553 }
17554 else
17555 {
17556 // Edit
17557 wchar_t tmp[MAX_SIZE];
17558 UniFormat(tmp, sizeof(tmp), _UU("CM_EDIT_HUB_2"), s->HubName);
17559 SetText(hWnd, 0, tmp);
17560 SetTextA(hWnd, E_HUBNAME, s->HubName);
17561 Disable(hWnd, E_HUBNAME);
17562
17563 if (s->p->ServerType == SERVER_TYPE_STANDALONE)
17564 {
17565 // Stand-alone mode
17566 Disable(hWnd, R_STATIC);
17567 Disable(hWnd, R_DYNAMIC);
17568 SetText(hWnd, S_FARM_INFO, _UU("CM_EDIT_HUB_STANDALONE"));
17569 }
17570
17571 if (s->p->ServerType == SERVER_TYPE_FARM_CONTROLLER)
17572 {
17573 // Controller
17574 if (GetCapsBool(s->p->CapsList, "b_cluster_hub_type_fixed"))
17575 {
17576 Disable(hWnd, R_STATIC);
17577 Disable(hWnd, R_DYNAMIC);
17578 SetText(hWnd, S_FARM_INFO, _UU("CM_EDIT_HUB_TYPE_FIXED"));
17579 }
17580 }
17581
17582 // Get the HUB information
17583 StrCpy(t.HubName, sizeof(t.HubName), s->HubName);
17584 if (CALL(hWnd, ScGetHub(s->p->Rpc, &t)) == false)
17585 {
17586 EndDialog(hWnd, false);
17587 return;
17588 }
17589
17590 SetTextA(hWnd, E_PASSWORD1, HIDDEN_PASSWORD);
17591 SetTextA(hWnd, E_PASSWORD2, HIDDEN_PASSWORD);
17592
17593 if (t.HubOption.MaxSession == 0)
17594 {
17595 Check(hWnd, R_LIMIT_MAX_SESSION, false);
17596 }
17597 else
17598 {
17599 Check(hWnd, R_LIMIT_MAX_SESSION, true);
17600 }
17601
17602 Check(hWnd, R_NO_ENUM, t.HubOption.NoEnum);
17603
17604 SetIntEx(hWnd, E_MAX_SESSION, t.HubOption.MaxSession);
17605
17606 Check(hWnd, R_ONLINE, t.Online);
17607 Check(hWnd, R_OFFLINE, t.Online ? false : true);
17608
17609 Check(hWnd, R_STATIC, t.HubType == HUB_TYPE_FARM_STATIC);
17610 Check(hWnd, R_DYNAMIC, t.HubType == HUB_TYPE_FARM_DYNAMIC);
17611
17612 SetShow(hWnd, B_ACL, GetCapsBool(s->p->CapsList, "b_support_ac"));
17613 SetShow(hWnd, S_ACL, GetCapsBool(s->p->CapsList, "b_support_ac"));
17614 SetShow(hWnd, S_ACL_2, GetCapsBool(s->p->CapsList, "b_support_ac"));
17615 SetShow(hWnd, S_ACL_3, GetCapsBool(s->p->CapsList, "b_support_ac"));
17616
17617 SetShow(hWnd, S_MSG_1, GetCapsBool(s->p->CapsList, "b_support_msg"));
17618 SetShow(hWnd, S_MSG_4, GetCapsBool(s->p->CapsList, "b_support_msg"));
17619 SetShow(hWnd, S_MSG_2, GetCapsBool(s->p->CapsList, "b_support_msg"));
17620 SetShow(hWnd, B_MSG, GetCapsBool(s->p->CapsList, "b_support_msg"));
17621 }
17622
17623 // Advanced options
17624 if (s->EditMode)
17625 {
17626 support_extoption = GetCapsBool(s->p->CapsList, "b_support_hub_ext_options");
17627 }
17628
17629 SetEnable(hWnd, S_STATIC, support_extoption);
17630 SetEnable(hWnd, B_EXTOPTION, support_extoption);
17631
17632 SetEnable(hWnd, R_NO_ENUM, GetCapsBool(s->p->CapsList, "b_support_hide_hub"));
17633
17634 SmEditHubUpdate(hWnd, s);
17635
17636 if (s->EditMode)
17637 {
17638 Focus(hWnd, IDOK);
17639 }
17640
17641 if (s->EditMode)
17642 {
17643 if (GetCapsBool(s->p->CapsList, "b_support_hub_admin_option"))
17644 {
17645 b = true;
17646 }
17647 }
17648
17649 SetShow(hWnd, S_AO_1, b);
17650 SetShow(hWnd, S_AO_2, b);
17651 SetShow(hWnd, S_AO_3, b);
17652 SetShow(hWnd, B_ADMINOPTION, b);
17653 }
17654
17655 // HUB edit procedure
SmEditHubProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)17656 UINT SmEditHubProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
17657 {
17658 SM_EDIT_HUB *s = (SM_EDIT_HUB *)param;
17659 // Validate arguments
17660 if (hWnd == NULL)
17661 {
17662 return 0;
17663 }
17664
17665 switch (msg)
17666 {
17667 case WM_INITDIALOG:
17668 SmEditHubInit(hWnd, s);
17669 break;
17670
17671 case WM_COMMAND:
17672 switch (LOWORD(wParam))
17673 {
17674 case E_PASSWORD1:
17675 case E_PASSWORD2:
17676 case E_HUBNAME:
17677 case R_LIMIT_MAX_SESSION:
17678 case E_MAX_SESSION:
17679 SmEditHubUpdate(hWnd, s);
17680 break;
17681 }
17682
17683 switch (wParam)
17684 {
17685 case IDOK:
17686 SmEditHubOnOk(hWnd, s);
17687 break;
17688
17689 case IDCANCEL:
17690 Close(hWnd);
17691 break;
17692
17693 case R_LIMIT_MAX_SESSION:
17694 if (IsChecked(hWnd, R_LIMIT_MAX_SESSION))
17695 {
17696 FocusEx(hWnd, E_MAX_SESSION);
17697 }
17698 break;
17699
17700 case B_ADMINOPTION:
17701 SmHubAdminOption(hWnd, s);
17702 break;
17703
17704 case B_EXTOPTION:
17705 SmHubExtOption(hWnd, s);
17706 break;
17707
17708 case B_ACL:
17709 SmHubAc(hWnd, s);
17710 break;
17711
17712 case B_MSG:
17713 SmHubMsg(hWnd, s);
17714 break;
17715 }
17716 break;
17717
17718 case WM_CLOSE:
17719 EndDialog(hWnd, false);
17720 break;
17721 }
17722
17723 return 0;
17724 }
17725
17726 // HUB edit dialog
SmEditHubDlg(HWND hWnd,SM_SERVER * p,char * hubname)17727 bool SmEditHubDlg(HWND hWnd, SM_SERVER *p, char *hubname)
17728 {
17729 SM_EDIT_HUB s;
17730 // Validate arguments
17731 if (hWnd == NULL || p == NULL)
17732 {
17733 return false;
17734 }
17735
17736 Zero(&s, sizeof(s));
17737 s.p = p;
17738 s.EditMode = true;
17739 StrCpy(s.HubName, sizeof(s.HubName), hubname);
17740
17741 if (p->Bridge == false)
17742 {
17743 return Dialog(hWnd, D_SM_EDIT_HUB, SmEditHubProc, &s);
17744 }
17745 else
17746 {
17747 SmHubExtOption(hWnd, &s);
17748 return false;
17749 }
17750 }
17751
17752 // HUB creation dialog
SmCreateHubDlg(HWND hWnd,SM_SERVER * p)17753 bool SmCreateHubDlg(HWND hWnd, SM_SERVER *p)
17754 {
17755 SM_EDIT_HUB s;
17756 // Validate arguments
17757 if (hWnd == NULL || p == NULL)
17758 {
17759 return false;
17760 }
17761
17762 Zero(&s, sizeof(s));
17763 s.p = p;
17764 s.EditMode = false;
17765
17766 return Dialog(hWnd, D_SM_EDIT_HUB, SmEditHubProc, &s);
17767 }
17768
17769 // Display the status of the virtual HUB
SmRefreshHubStatus(HWND hWnd,SM_SERVER * p,void * param)17770 bool SmRefreshHubStatus(HWND hWnd, SM_SERVER *p, void *param)
17771 {
17772 RPC_HUB_STATUS t;
17773 // Validate arguments
17774 if (hWnd == NULL || p == NULL || param == NULL)
17775 {
17776 return false;
17777 }
17778
17779 Zero(&t, sizeof(RPC_HUB_STATUS));
17780 StrCpy(t.HubName, sizeof(t.HubName), (char *)param);
17781 if (CALL(hWnd, ScGetHubStatus(p->Rpc, &t)))
17782 {
17783 wchar_t *s;
17784 wchar_t tmp[MAX_SIZE];
17785 LVB *b = LvInsertStart();
17786
17787 // HUB name
17788 s = CopyStrToUni((char *)param);
17789 LvInsertAdd(b, ICO_HUB, 0, 2, _UU("SM_HUB_STATUS_HUBNAME"), s);
17790 Free(s);
17791
17792 // Online
17793 LvInsertAdd(b, t.Online ? ICO_PROTOCOL : ICO_PROTOCOL_X, 0, 2, _UU("SM_HUB_STATUS_ONLINE"),
17794 t.Online ? _UU("SM_HUB_ONLINE") : _UU("SM_HUB_OFFLINE"));
17795
17796 // Type of HUB
17797 LvInsertAdd(b, t.HubType == HUB_TYPE_STANDALONE ? ICO_TOWER : ICO_FARM, 0, 2, _UU("SM_HUB_TYPE"),
17798 GetHubTypeStr(t.HubType));
17799
17800 if (t.HubType == HUB_TYPE_STANDALONE)
17801 {
17802 // Enable / Disable the SecureNAT
17803 LvInsertAdd(b, ICO_ROUTER, NULL, 2, _UU("SM_HUB_SECURE_NAT"),
17804 t.SecureNATEnabled ? _UU("SM_HUB_SECURE_NAT_YES") : _UU("SM_HUB_SECURE_NAT_NO"));
17805 }
17806
17807 // Other values
17808 UniToStru(tmp, t.NumSessions);
17809 LvInsertAdd(b, ICO_PROTOCOL, 0, 2, _UU("SM_HUB_NUM_SESSIONS"), tmp);
17810 if (t.NumSessionsClient != 0 || t.NumSessionsBridge != 0)
17811 {
17812 UniToStru(tmp, t.NumSessionsClient);
17813 LvInsertAdd(b, ICO_PROTOCOL, 0, 2, _UU("SM_HUB_NUM_SESSIONS_CLIENT"), tmp);
17814 UniToStru(tmp, t.NumSessionsBridge);
17815 LvInsertAdd(b, ICO_PROTOCOL, 0, 2, _UU("SM_HUB_NUM_SESSIONS_BRIDGE"), tmp);
17816 }
17817
17818 UniToStru(tmp, t.NumAccessLists);
17819 LvInsertAdd(b, ICO_DISCARD, 0, 2, _UU("SM_HUB_NUM_ACCESSES"), tmp);
17820
17821 if (p->ServerType != SERVER_TYPE_FARM_MEMBER)
17822 {
17823 UniToStru(tmp, t.NumUsers);
17824 LvInsertAdd(b, ICO_USER, 0, 2, _UU("SM_HUB_NUM_USERS"), tmp);
17825 UniToStru(tmp, t.NumGroups);
17826 LvInsertAdd(b, ICO_GROUP, 0, 2, _UU("SM_HUB_NUM_GROUPS"), tmp);
17827 }
17828
17829 UniToStru(tmp, t.NumMacTables);
17830 LvInsertAdd(b, ICO_MACHINE, 0, 2, _UU("SM_HUB_NUM_MAC_TABLES"), tmp);
17831 UniToStru(tmp, t.NumIpTables);
17832 LvInsertAdd(b, ICO_MACHINE, 0, 2, _UU("SM_HUB_NUM_IP_TABLES"), tmp);
17833
17834 // Usage status
17835 UniToStru(tmp, t.NumLogin);
17836 LvInsertAdd(b, ICO_KEY, NULL, 2, _UU("SM_HUB_NUM_LOGIN"), tmp);
17837
17838 if (t.LastLoginTime != 0)
17839 {
17840 GetDateTimeStr64Uni(tmp, sizeof(tmp), SystemToLocal64(t.LastLoginTime));
17841 }
17842 else
17843 {
17844 UniStrCpy(tmp, sizeof(tmp), _UU("COMMON_UNKNOWN"));
17845 }
17846 LvInsertAdd(b, ICO_DATETIME, NULL, 2, _UU("SM_HUB_LAST_LOGIN_TIME"), tmp);
17847
17848 if (t.LastCommTime != 0)
17849 {
17850 GetDateTimeStr64Uni(tmp, sizeof(tmp), SystemToLocal64(t.LastCommTime));
17851 }
17852 else
17853 {
17854 UniStrCpy(tmp, sizeof(tmp), _UU("COMMON_UNKNOWN"));
17855 }
17856 LvInsertAdd(b, ICO_DATETIME, NULL, 2, _UU("SM_HUB_LAST_COMM_TIME"), tmp);
17857
17858 if (t.CreatedTime != 0)
17859 {
17860 GetDateTimeStr64Uni(tmp, sizeof(tmp), SystemToLocal64(t.CreatedTime));
17861 }
17862 else
17863 {
17864 UniStrCpy(tmp, sizeof(tmp), _UU("COMMON_UNKNOWN"));
17865 }
17866 LvInsertAdd(b, ICO_DATETIME, NULL, 2, _UU("SM_HUB_CREATED_TIME"), tmp);
17867
17868 // Traffic information
17869 SmInsertTrafficInfo(b, &t.Traffic);
17870
17871 LvInsertEnd(b, hWnd, L_STATUS);
17872 }
17873 else
17874 {
17875 return false;
17876 }
17877
17878 return true;
17879 }
17880
17881 // Add a traffic information to LVB
SmInsertTrafficInfo(LVB * b,TRAFFIC * t)17882 void SmInsertTrafficInfo(LVB *b, TRAFFIC *t)
17883 {
17884 wchar_t tmp[MAX_SIZE];
17885 char vv[128];
17886 // Validate arguments
17887 if (b == NULL || t == NULL)
17888 {
17889 return;
17890 }
17891
17892 // Transmission information
17893 ToStr3(vv, sizeof(vv), t->Send.UnicastCount);
17894 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_NUM_PACKET_STR"), vv);
17895 LvInsertAdd(b, ICO_INFORMATION, 0, 2, _UU("SM_ST_SEND_UCAST_NUM"), tmp);
17896
17897 ToStr3(vv, sizeof(vv), t->Send.UnicastBytes);
17898 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_SIZE_BYTE_STR"), vv);
17899 LvInsertAdd(b, ICO_INFORMATION, 0, 2, _UU("SM_ST_SEND_UCAST_SIZE"), tmp);
17900
17901 ToStr3(vv, sizeof(vv), t->Send.BroadcastCount);
17902 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_NUM_PACKET_STR"), vv);
17903 LvInsertAdd(b, ICO_INFORMATION, 0, 2, _UU("SM_ST_SEND_BCAST_NUM"), tmp);
17904
17905 ToStr3(vv, sizeof(vv), t->Send.BroadcastBytes);
17906 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_SIZE_BYTE_STR"), vv);
17907 LvInsertAdd(b, ICO_INFORMATION, 0, 2, _UU("SM_ST_SEND_BCAST_SIZE"), tmp);
17908
17909 // Reception information
17910 ToStr3(vv, sizeof(vv), t->Recv.UnicastCount);
17911 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_NUM_PACKET_STR"), vv);
17912 LvInsertAdd(b, ICO_INFORMATION, 0, 2, _UU("SM_ST_RECV_UCAST_NUM"), tmp);
17913
17914 ToStr3(vv, sizeof(vv), t->Recv.UnicastBytes);
17915 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_SIZE_BYTE_STR"), vv);
17916 LvInsertAdd(b, ICO_INFORMATION, 0, 2, _UU("SM_ST_RECV_UCAST_SIZE"), tmp);
17917
17918 ToStr3(vv, sizeof(vv), t->Recv.BroadcastCount);
17919 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_NUM_PACKET_STR"), vv);
17920 LvInsertAdd(b, ICO_INFORMATION, 0, 2, _UU("SM_ST_RECV_BCAST_NUM"), tmp);
17921
17922 ToStr3(vv, sizeof(vv), t->Recv.BroadcastBytes);
17923 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_SIZE_BYTE_STR"), vv);
17924 LvInsertAdd(b, ICO_INFORMATION, 0, 2, _UU("SM_ST_RECV_BCAST_SIZE"), tmp);
17925 }
17926
17927 // Status display dialog procedure
SmStatusDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)17928 UINT SmStatusDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
17929 {
17930 SM_STATUS *s = (SM_STATUS *)param;
17931 // Validate arguments
17932 if (hWnd == NULL)
17933 {
17934 return 0;
17935 }
17936
17937 switch (msg)
17938 {
17939 case WM_INITDIALOG:
17940 // Initialize
17941 LvInitEx(hWnd, L_STATUS, s->NoImage);
17942 LvSetStyle(hWnd, L_STATUS, LVS_EX_GRIDLINES);
17943 SetIcon(hWnd, 0, s->Icon);
17944 SetIcon(hWnd, S_ICON, s->Icon);
17945 SetText(hWnd, 0, s->Caption);
17946 SetText(hWnd, S_TITLE, s->Caption);
17947 DlgFont(hWnd, S_TITLE, 15, true);
17948 if (s->InitProc != NULL)
17949 {
17950 s->InitProc(hWnd, s->p, s->Param);
17951 }
17952 else
17953 {
17954 // Initialize the column
17955 LvInsertColumn(hWnd, L_STATUS, 0, _UU("SM_STATUS_COLUMN_1"), 0);
17956 LvInsertColumn(hWnd, L_STATUS, 1, _UU("SM_STATUS_COLUMN_2"), 0);
17957 }
17958 if (s->RefreshProc(hWnd, s->p, s->Param) == false)
17959 {
17960 Close(hWnd);
17961 }
17962 LvAutoSize(hWnd, L_STATUS);
17963 Focus(hWnd, L_STATUS);
17964
17965 if (s->show_refresh_button == false)
17966 {
17967 Hide(hWnd, IDOK);
17968 }
17969
17970 break;
17971
17972 case WM_COMMAND:
17973 switch (wParam)
17974 {
17975 case IDOK:
17976 // Update
17977 if (s->RefreshProc(hWnd, s->p, s->Param) == false)
17978 {
17979 Close(hWnd);
17980 }
17981 LvAutoSize(hWnd, L_STATUS);
17982 break;
17983
17984 case IDCANCEL:
17985 Close(hWnd);
17986 break;
17987 }
17988 break;
17989
17990 case WM_CLOSE:
17991 EndDialog(hWnd, 0);
17992 break;
17993 }
17994
17995 LvStandardHandler(hWnd, msg, wParam, lParam, L_STATUS);
17996
17997 return 0;
17998 }
17999
18000 // Status display dialog
SmStatusDlg(HWND hWnd,SM_SERVER * p,void * param,bool no_image,bool show_refresh_button,wchar_t * caption,UINT icon,SM_STATUS_INIT_PROC * init,SM_STATUS_REFRESH_PROC * refresh)18001 void SmStatusDlg(HWND hWnd, SM_SERVER *p, void *param, bool no_image, bool show_refresh_button, wchar_t *caption, UINT icon,
18002 SM_STATUS_INIT_PROC *init, SM_STATUS_REFRESH_PROC *refresh)
18003 {
18004 SM_STATUS s;
18005 // Validate arguments
18006 if (hWnd == NULL || p == NULL || refresh == NULL)
18007 {
18008 return;
18009 }
18010
18011 if (icon == 0)
18012 {
18013 icon = ICO_INFORMATION;
18014 }
18015 if (caption == NULL)
18016 {
18017 caption = _UU("SM_INFORMATION");
18018 }
18019
18020 Zero(&s, sizeof(s));
18021 s.show_refresh_button = show_refresh_button;
18022 s.p = p;
18023 s.NoImage = no_image;
18024 s.Param = param;
18025 s.Icon = icon;
18026 s.Caption = caption;
18027 s.InitProc = init;
18028 s.RefreshProc = refresh;
18029
18030 Dialog(hWnd, D_SM_STATUS, SmStatusDlgProc, &s);
18031 }
18032
18033 // Server management dialog update
SmServerDlgUpdate(HWND hWnd,SM_SERVER * p)18034 void SmServerDlgUpdate(HWND hWnd, SM_SERVER *p)
18035 {
18036 bool hub_selected = false;
18037 bool hub_selected_online = false;
18038 bool hub_selected_offline = false;
18039 bool hub_have_admin_right = false;
18040 bool listener_selected = false;
18041 bool listener_selected_enabled = false;
18042 bool listener_selected_disabled = false;
18043 bool two_or_more_listener = false;
18044 bool bridge;
18045 UINT i;
18046 // Validate arguments
18047 if (hWnd == NULL || p == NULL)
18048 {
18049 return;
18050 }
18051
18052 bridge = GetCapsBool(p->CapsList, "b_bridge");
18053
18054 hub_selected = LvIsSelected(hWnd, L_HUB);
18055
18056 if (hub_selected)
18057 {
18058 if (p->ServerAdminMode)
18059 {
18060 hub_have_admin_right = true;
18061 }
18062 i = LvGetSelected(hWnd, L_HUB);
18063 if (i != INFINITE)
18064 {
18065 wchar_t *s = LvGetStr(hWnd, L_HUB, i, 1);
18066 if (p->ServerAdminMode == false)
18067 {
18068 char *hubname = LvGetStrA(hWnd, L_HUB, i, 0);
18069 if (hubname != NULL)
18070 {
18071 if (StrCmpi(hubname, p->HubName) == 0)
18072 {
18073 hub_have_admin_right = true;
18074 }
18075 Free(hubname);
18076 }
18077 }
18078 hub_selected_online = (UniStrCmpi(s, _UU("SM_HUB_ONLINE")) == 0);
18079 hub_selected_offline = hub_selected_online ? false : true;
18080 Free(s);
18081 }
18082 }
18083
18084 listener_selected = LvIsSelected(hWnd, L_LISTENER);
18085 if (listener_selected)
18086 {
18087 wchar_t *s = LvGetSelectedStr(hWnd, L_LISTENER, 1);
18088 if (UniStrCmpi(s, _UU("CM_LISTENER_OFFLINE")) == 0)
18089 {
18090 listener_selected_disabled = true;
18091 }
18092 else
18093 {
18094 listener_selected_enabled = true;
18095 }
18096 Free(s);
18097 }
18098
18099 if (LvNum(hWnd, L_LISTENER) >= 2)
18100 {
18101 two_or_more_listener = true;
18102 }
18103
18104 SetEnable(hWnd, IDOK, bridge || (hub_selected && hub_have_admin_right));
18105 SetEnable(hWnd, B_ONLINE, bridge == false && hub_selected_offline && hub_have_admin_right && p->ServerType != SERVER_TYPE_FARM_MEMBER);
18106 SetEnable(hWnd, B_OFFLINE, bridge == false && hub_selected_online && hub_have_admin_right && p->ServerType != SERVER_TYPE_FARM_MEMBER);
18107 SetEnable(hWnd, B_HUB_STATUS, hub_selected && hub_have_admin_right);
18108 SetEnable(hWnd, B_DELETE, bridge == false && hub_selected && p->ServerAdminMode && p->ServerType != SERVER_TYPE_FARM_MEMBER);
18109 SetEnable(hWnd, B_EDIT, hub_selected && hub_have_admin_right && p->ServerType != SERVER_TYPE_FARM_MEMBER);
18110 SetEnable(hWnd, B_CREATE, bridge == false && p->ServerAdminMode && p->ServerType != SERVER_TYPE_FARM_MEMBER);
18111
18112 SetEnable(hWnd, B_CREATE_LISTENER, p->ServerAdminMode);
18113 SetEnable(hWnd, B_DELETE_LISTENER, p->ServerAdminMode && listener_selected && two_or_more_listener);
18114 SetEnable(hWnd, B_START, p->ServerAdminMode && listener_selected_disabled);
18115 SetEnable(hWnd, B_STOP, p->ServerAdminMode && listener_selected_enabled);
18116 SetEnable(hWnd, B_FARM, GetCapsBool(p->CapsList, "b_support_cluster") && p->ServerAdminMode && GetCapsBool(p->CapsList, "b_support_vgs_in_client") == false);
18117 SetEnable(hWnd, B_FARM_STATUS, GetCapsBool(p->CapsList, "b_support_cluster") && p->ServerType != SERVER_TYPE_STANDALONE);
18118 }
18119
18120 // Server management dialog initialization
SmServerDlgInit(HWND hWnd,SM_SERVER * p)18121 void SmServerDlgInit(HWND hWnd, SM_SERVER *p)
18122 {
18123 // Validate arguments
18124 if (hWnd == NULL || p == NULL)
18125 {
18126 return;
18127 }
18128
18129 // Initialize the column
18130 LvInit(hWnd, L_HUB);
18131 LvSetStyle(hWnd, L_HUB, LVS_EX_GRIDLINES);
18132 LvInsertColumn(hWnd, L_HUB, 0, _UU("SM_HUB_COLUMN_1"), 150);
18133 LvInsertColumn(hWnd, L_HUB, 1, _UU("SM_HUB_COLUMN_2"), 80);
18134 LvInsertColumn(hWnd, L_HUB, 2, _UU("SM_HUB_COLUMN_3"), 80);
18135 LvInsertColumn(hWnd, L_HUB, 3, _UU("SM_HUB_COLUMN_4"), 80);
18136 LvInsertColumn(hWnd, L_HUB, 4, _UU("SM_HUB_COLUMN_5"), 80);
18137 LvInsertColumn(hWnd, L_HUB, 5, _UU("SM_HUB_COLUMN_6"), 80);
18138 LvInsertColumn(hWnd, L_HUB, 6, _UU("SM_HUB_COLUMN_7"), 80);
18139 LvInsertColumn(hWnd, L_HUB, 7, _UU("SM_HUB_COLUMN_8"), 80);
18140 LvInsertColumn(hWnd, L_HUB, 8, _UU("SM_HUB_COLUMN_9"), 80);
18141 LvInsertColumn(hWnd, L_HUB, 9, _UU("SM_HUB_COLUMN_10"), 120);
18142 LvInsertColumn(hWnd, L_HUB, 10, _UU("SM_HUB_COLUMN_11"), 120);
18143 LvInsertColumn(hWnd, L_HUB, 11, _UU("SM_SESS_COLUMN_6"), 100);
18144 LvInsertColumn(hWnd, L_HUB, 12, _UU("SM_SESS_COLUMN_7"), 100);
18145
18146 LvInit(hWnd, L_LISTENER);
18147 LvSetStyle(hWnd, L_LISTENER, LVS_EX_GRIDLINES);
18148 LvInsertColumn(hWnd, L_LISTENER, 0, _UU("CM_LISTENER_COLUMN_1"), 90);
18149 LvInsertColumn(hWnd, L_LISTENER, 1, _UU("CM_LISTENER_COLUMN_2"), 80);
18150
18151 SmServerDlgRefresh(hWnd, p);
18152
18153 if (p->ServerAdminMode == false)
18154 {
18155 // Select the target HUB in the case of the Virtual HUB management mode
18156 wchar_t *s = CopyStrToUni(p->HubName);
18157 LvSelect(hWnd, L_HUB, LvSearchStr(hWnd, L_HUB, 0, s));
18158 Free(s);
18159 }
18160 else
18161 {
18162 // In the case of whole server management mode
18163 UINT num_hubs = LvNum(hWnd, L_HUB);
18164
18165 if (num_hubs == 1)
18166 {
18167 // Select the Virtual HUB if Virtual HUB exists only one
18168 LvSelect(hWnd, L_HUB, 0);
18169 }
18170 else
18171 {
18172 // Select the Virtual HUB the last selected if there are some virtual HUBs
18173 char tmp[MAX_SIZE];
18174 char *hubname;
18175
18176 Format(tmp, sizeof(tmp), "%s:%u:%s", p->CurrentSetting->ClientOption.Hostname,
18177 p->CurrentSetting->ClientOption.Port,
18178 p->CurrentSetting->ServerAdminMode ? "" : p->CurrentSetting->HubName);
18179
18180 hubname = MsRegReadStr(REG_CURRENT_USER, SM_LASTHUB_REG_KEY, tmp);
18181
18182 if (IsEmptyStr(hubname) == false)
18183 {
18184 LvSelect(hWnd, L_HUB, LvSearchStrA(hWnd, L_HUB, 0, hubname));
18185 }
18186
18187 Free(hubname);
18188 }
18189 }
18190
18191 Focus(hWnd, L_HUB);
18192
18193 SmServerDlgUpdate(hWnd, p);
18194
18195 if (GetCapsBool(p->CapsList, "b_bridge"))
18196 {
18197 Disable(hWnd, L_HUB);
18198 }
18199
18200 // Enable Local bridge button, etc. in the case of the Admin of the Server
18201 SetEnable(hWnd, B_BRIDGE, GetCapsBool(p->CapsList, "b_local_bridge") && p->ServerAdminMode && GetCapsBool(p->CapsList, "b_support_vgs_in_client") == false);
18202 SetEnable(hWnd, B_CONNECTION, p->ServerAdminMode);
18203
18204 // Config R/W button
18205 SetEnable(hWnd, B_CONFIG, GetCapsBool(p->CapsList, "b_support_config_rw") && p->ServerAdminMode && GetCapsBool(p->CapsList, "b_support_vgs_in_client") == false);
18206
18207 // Layer 3 button
18208 SetEnable(hWnd, B_L3, GetCapsBool(p->CapsList, "b_support_layer3") && p->ServerAdminMode && GetCapsBool(p->CapsList, "b_support_vgs_in_client") == false);
18209
18210 // License button
18211 SetShow(hWnd, B_LICENSE, GetCapsBool(p->CapsList, "b_support_license") && p->ServerAdminMode);
18212 SetShow(hWnd, S_LICENSE, GetCapsBool(p->CapsList, "b_support_license") && p->ServerAdminMode);
18213 SetShow(hWnd, S_BETA, GetCapsBool(p->CapsList, "b_beta_version") && (IsShow(hWnd, B_LICENSE) == false));
18214
18215 // IPsec button
18216 SetEnable(hWnd, B_IPSEC, GetCapsBool(p->CapsList, "b_support_ipsec") && p->ServerAdminMode);
18217
18218 // OpenVPN, SSTP button
18219 SetEnable(hWnd, B_OPENVPN, GetCapsBool(p->CapsList, "b_support_openvpn") && p->ServerAdminMode);
18220
18221 // DDNS button
18222 SetEnable(hWnd, B_DDNS, GetCapsBool(p->CapsList, "b_support_ddns") && p->ServerAdminMode);
18223
18224 // VPN Azure button
18225 SetEnable(hWnd, B_AZURE, GetCapsBool(p->CapsList, "b_support_azure") && p->ServerAdminMode);
18226
18227 DlgFont(hWnd, S_BETA, 12, false);
18228 SetFont(hWnd, E_DDNS_HOST, GetFont("Verdana", 10, false, false, false, false));
18229 SetFont(hWnd, E_AZURE_HOST, GetFont("Verdana", 10, false, false, false, false));
18230
18231 SetShow(hWnd, B_VPNGATE, false);
18232 SetShow(hWnd, S_ICO_VPNGATE, false);
18233
18234 DlgFont(hWnd, IDOK, 0, true);
18235 }
18236
18237 // Server management dialog update
SmServerDlgRefresh(HWND hWnd,SM_SERVER * p)18238 void SmServerDlgRefresh(HWND hWnd, SM_SERVER *p)
18239 {
18240 RPC_ENUM_HUB t;
18241 RPC_LISTENER_LIST t2;
18242 RPC_PORTS t3;
18243 DDNS_CLIENT_STATUS st;
18244 RPC_AZURE_STATUS sta;
18245 UINT i;
18246 // Validate arguments
18247 if (hWnd == NULL || p == NULL)
18248 {
18249 return;
18250 }
18251
18252 // Virtual HUB list update
18253 Zero(&t, sizeof(t));
18254 if (CALL(hWnd, ScEnumHub(p->Rpc, &t)))
18255 {
18256 LVB *b = LvInsertStart();
18257 for (i = 0;i < t.NumHub;i++)
18258 {
18259 RPC_ENUM_HUB_ITEM *e = &t.Hubs[i];
18260 wchar_t name[MAX_HUBNAME_LEN + 1];
18261 wchar_t s1[64], s2[64], s3[64], s4[64], s5[64];
18262 wchar_t s6[64], s7[128], s8[128];
18263 wchar_t s9[64], s10[64];
18264 UINT icon;
18265
18266 UniToStru(s1, e->NumUsers);
18267 UniToStru(s2, e->NumGroups);
18268 UniToStru(s3, e->NumSessions);
18269 UniToStru(s4, e->NumMacTables);
18270 UniToStru(s5, e->NumIpTables);
18271
18272 UniToStru(s6, e->NumLogin);
18273
18274 if (e->LastLoginTime != 0)
18275 {
18276 GetDateTimeStr64Uni(s7, sizeof(s7), SystemToLocal64(e->LastLoginTime));
18277 }
18278 else
18279 {
18280 UniStrCpy(s7, sizeof(s7), _UU("COMMON_UNKNOWN"));
18281 }
18282
18283 if (e->LastCommTime != 0)
18284 {
18285 GetDateTimeStr64Uni(s8, sizeof(s8), SystemToLocal64(e->LastCommTime));
18286 }
18287 else
18288 {
18289 UniStrCpy(s8, sizeof(s8), _UU("COMMON_UNKNOWN"));
18290 }
18291
18292 StrToUni(name, sizeof(name), e->HubName);
18293
18294 icon = ICO_HUB;
18295 if (e->Online == false)
18296 {
18297 icon = ICO_HUB_OFFLINE;
18298 }
18299
18300 if (e->IsTrafficFilled == false)
18301 {
18302 UniStrCpy(s9, sizeof(s9), _UU("CM_ST_NONE"));
18303 UniStrCpy(s10, sizeof(s10), _UU("CM_ST_NONE"));
18304 }
18305 else
18306 {
18307 UniToStr3(s9, sizeof(s9),
18308 e->Traffic.Recv.BroadcastBytes + e->Traffic.Recv.UnicastBytes +
18309 e->Traffic.Send.BroadcastBytes + e->Traffic.Send.UnicastBytes);
18310
18311 UniToStr3(s10, sizeof(s10),
18312 e->Traffic.Recv.BroadcastCount + e->Traffic.Recv.UnicastCount +
18313 e->Traffic.Send.BroadcastCount + e->Traffic.Send.UnicastCount);
18314 }
18315
18316 LvInsertAdd(b,
18317 icon,
18318 NULL,
18319 13,
18320 name,
18321 e->Online ? _UU("SM_HUB_ONLINE") : _UU("SM_HUB_OFFLINE"),
18322 GetHubTypeStr(e->HubType),
18323 s1, s2, s3, s4, s5, s6, s7, s8, s9, s10);
18324 }
18325 LvInsertEnd(b, hWnd, L_HUB);
18326 FreeRpcEnumHub(&t);
18327 }
18328
18329 // Listener list update
18330 Zero(&t2, sizeof(RPC_LISTENER_LIST));
18331 if (CALL(hWnd, ScEnumListener(p->Rpc, &t2)))
18332 {
18333 LVB *b = LvInsertStart();
18334 for (i = 0;i < t2.NumPort;i++)
18335 {
18336 wchar_t tmp[MAX_SIZE];
18337 wchar_t *status;
18338 UINT icon;
18339 UniFormat(tmp, sizeof(tmp), _UU("CM_LISTENER_TCP_PORT"), t2.Ports[i]);
18340
18341 status = _UU("CM_LISTENER_ONLINE");
18342 icon = ICO_PROTOCOL;
18343 if (t2.Errors[i])
18344 {
18345 status = _UU("CM_LISTENER_ERROR");
18346 icon = ICO_PROTOCOL_X;
18347 }
18348 else if (t2.Enables[i] == false)
18349 {
18350 status = _UU("CM_LISTENER_OFFLINE");
18351 icon = ICO_PROTOCOL_OFFLINE;
18352 }
18353
18354 LvInsertAdd(b, icon, (void *)t2.Ports[i], 2, tmp, status);
18355 }
18356 LvInsertEnd(b, hWnd, L_LISTENER);
18357 FreeRpcListenerList(&t2);
18358 }
18359
18360 // Get the UDP ports
18361 Zero(&t3, sizeof(RPC_PORTS));
18362 if (CALL(hWnd, ScGetPortsUDP(p->Rpc, &t3)))
18363 {
18364 char str[MAX_SIZE];
18365
18366 Zero(str, sizeof(str));
18367
18368 if (t3.Num > 0)
18369 {
18370 UINT i;
18371
18372 Format(str, sizeof(str), "%u", t3.Ports[0]);
18373
18374 for (i = 1; i < t3.Num; ++i)
18375 {
18376 char tmp[MAX_SIZE];
18377 Format(tmp, sizeof(tmp), ", %u", t3.Ports[i]);
18378 StrCat(str, sizeof(str), tmp);
18379 }
18380 }
18381
18382 SetTextA(hWnd, E_UDP, str);
18383 FreeRpcPorts(&t3);
18384 }
18385
18386 // Get the DDNS client state
18387 Zero(&st, sizeof(st));
18388 if (ScGetDDnsClientStatus(p->Rpc, &st) == ERR_NO_ERROR && IsEmptyStr(st.CurrentFqdn) == false)
18389 {
18390 SetTextA(hWnd, E_DDNS_HOST, st.CurrentFqdn);
18391
18392 Show(hWnd, S_DDNS);
18393 Show(hWnd, E_DDNS_HOST);
18394 }
18395 else
18396 {
18397 Hide(hWnd, S_DDNS);
18398 Hide(hWnd, E_DDNS_HOST);
18399 }
18400
18401 // VPN Azure client state acquisition
18402 Zero(&sta, sizeof(sta));
18403 if (ScGetAzureStatus(p->Rpc, &sta) == ERR_NO_ERROR && sta.IsEnabled && IsEmptyStr(st.CurrentFqdn) == false)
18404 {
18405 char tmp[MAX_SIZE];
18406
18407 StrCpy(tmp, sizeof(tmp), st.CurrentHostName);
18408 StrCat(tmp, sizeof(tmp), AZURE_DOMAIN_SUFFIX);
18409
18410 SetTextA(hWnd, E_AZURE_HOST, tmp);
18411
18412 Show(hWnd, S_AZURE);
18413 Show(hWnd, E_AZURE_HOST);
18414 }
18415 else
18416 {
18417 Hide(hWnd, S_AZURE);
18418 Hide(hWnd, E_AZURE_HOST);
18419 }
18420
18421 SmServerDlgUpdate(hWnd, p);
18422 }
18423
18424 // Server management dialog procedure
SmServerDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)18425 UINT SmServerDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
18426 {
18427 SM_SERVER *p = (SM_SERVER *)param;
18428 wchar_t *s;
18429 wchar_t tmp[MAX_SIZE];
18430 NMHDR *n;
18431 UINT i;
18432 // Validate arguments
18433 if (hWnd == NULL)
18434 {
18435 return 0;
18436 }
18437
18438 switch (msg)
18439 {
18440 case WM_INITDIALOG:
18441 FormatText(hWnd, 0, p->Title);
18442
18443 if (p->Bridge == false)
18444 {
18445 FormatText(hWnd, S_TITLE, p->ServerName);
18446 }
18447 else
18448 {
18449 UniFormat(tmp, sizeof(tmp), _UU("SM_SERVER_BRIDGE_TITLE"), p->ServerName);
18450 SetText(hWnd, S_TITLE, tmp);
18451 }
18452
18453 DlgFont(hWnd, S_TITLE, 16, 1);
18454
18455 SetIcon(hWnd, 0, p->Bridge == false ? ICO_VPNSERVER : ICO_BRIDGE);
18456
18457 SmServerDlgInit(hWnd, p);
18458
18459 SetTimer(hWnd, 1, 50, NULL);
18460
18461 break;
18462
18463 case WM_COMMAND:
18464 switch (wParam)
18465 {
18466 case IDOK:
18467 // Management
18468 if (IsEnable(hWnd, IDOK))
18469 {
18470 if (p->Bridge == false)
18471 {
18472 s = LvGetSelectedStr(hWnd, L_HUB, 0);
18473 }
18474 else
18475 {
18476 s = CopyUniStr(L"BRIDGE");
18477 }
18478 if (s != NULL)
18479 {
18480 char hubname[MAX_HUBNAME_LEN + 1];
18481 SM_HUB hub;
18482 Zero(&hub, sizeof(hub));
18483 UniToStr(hubname, sizeof(hubname), s);
18484 hub.p = p;
18485 hub.Rpc = p->Rpc;
18486 hub.HubName = hubname;
18487 SmHubDlg(hWnd, &hub);
18488 //SmServerDlgRefresh(hWnd, p);
18489 Free(s);
18490 }
18491 }
18492 break;
18493
18494 case B_ONLINE:
18495 // Online
18496 s = LvGetSelectedStr(hWnd, L_HUB, 0);
18497 if (s != NULL)
18498 {
18499 RPC_SET_HUB_ONLINE t;
18500 Zero(&t, sizeof(t));
18501 UniToStr(t.HubName, sizeof(t.HubName), s);
18502 t.Online = true;
18503 if (CALL(hWnd, ScSetHubOnline(p->Rpc, &t)))
18504 {
18505 SmServerDlgRefresh(hWnd, p);
18506 }
18507 Free(s);
18508 }
18509 break;
18510
18511 case B_OFFLINE:
18512 // Offline
18513 s = LvGetSelectedStr(hWnd, L_HUB, 0);
18514 if (s != NULL)
18515 {
18516 RPC_SET_HUB_ONLINE t;
18517 Zero(&t, sizeof(t));
18518 // Confirmation message
18519 if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
18520 _UU("CM_OFFLINE_MSG"), s) == IDYES)
18521 {
18522 UniToStr(t.HubName, sizeof(t.HubName), s);
18523 t.Online = false;
18524 if (CALL(hWnd, ScSetHubOnline(p->Rpc, &t)))
18525 {
18526 SmServerDlgRefresh(hWnd, p);
18527 }
18528 }
18529 Free(s);
18530 }
18531 break;
18532
18533 case B_HUB_STATUS:
18534 // Status of HUB
18535 s = LvGetSelectedStr(hWnd, L_HUB, 0);
18536 if (s != NULL)
18537 {
18538 wchar_t tmp[MAX_SIZE];
18539 char *hubname = CopyUniToStr(s);
18540 UniFormat(tmp, sizeof(tmp), _UU("SM_HUB_STATUS_CAPTION"), s);
18541 SmStatusDlg(hWnd, p, hubname, false, true, tmp, ICO_HUB,
18542 NULL, SmRefreshHubStatus);
18543 Free(hubname);
18544 Free(s);
18545 }
18546 break;
18547
18548 case B_CREATE:
18549 // Create a HUB
18550 if (SmCreateHubDlg(hWnd, p))
18551 {
18552 SmServerDlgRefresh(hWnd, p);
18553 }
18554 break;
18555
18556 case B_EDIT:
18557 // Edit the HUB
18558 s = LvGetSelectedStr(hWnd, L_HUB, 0);
18559 if (s != NULL)
18560 {
18561 char *name = CopyUniToStr(s);
18562 if (SmEditHubDlg(hWnd, p, name))
18563 {
18564 SmServerDlgRefresh(hWnd, p);
18565 }
18566 Free(name);
18567 Free(s);
18568 }
18569 break;
18570
18571 case B_DELETE:
18572 // Delete the HUB
18573 s = LvGetSelectedStr(hWnd, L_HUB, 0);
18574 if (s != NULL)
18575 {
18576 char *name = CopyUniToStr(s);
18577 RPC_DELETE_HUB t;
18578 Zero(&t, sizeof(t));
18579 StrCpy(t.HubName, sizeof(t.HubName), name);
18580 if (MsgBoxEx(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_DELETE_HUB_MSG"), name) == IDYES)
18581 {
18582 if (CALL(hWnd, ScDeleteHub(p->Rpc, &t)))
18583 {
18584 SmServerDlgRefresh(hWnd, p);
18585 MsgBoxEx(hWnd, MB_ICONINFORMATION, _UU("CM_HUB_DELETED_MSG"), name);
18586 }
18587 }
18588 Free(name);
18589 Free(s);
18590 }
18591 break;
18592
18593 case B_CREATE_LISTENER:
18594 // Create a listener
18595 if (SmCreateListenerDlg(hWnd, p))
18596 {
18597 SmServerDlgRefresh(hWnd, p);
18598 }
18599 break;
18600
18601 case B_DELETE_LISTENER:
18602 // Remove the listener
18603 i = LvGetSelected(hWnd, L_LISTENER);
18604 if (i != INFINITE)
18605 {
18606 UINT port = (UINT)LvGetParam(hWnd, L_LISTENER, i);
18607 if (MsgBoxEx(hWnd, MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_DELETE_LISTENER_MSG"), port) == IDYES)
18608 {
18609 RPC_LISTENER t;
18610 Zero(&t, sizeof(t));
18611 t.Enable = false;
18612 t.Port = port;
18613
18614 if (CALL(hWnd, ScDeleteListener(p->Rpc, &t)))
18615 {
18616 SmServerDlgRefresh(hWnd, p);
18617 }
18618 }
18619 }
18620 break;
18621
18622 case B_START:
18623 // Start
18624 i = LvGetSelected(hWnd, L_LISTENER);
18625 if (i != INFINITE)
18626 {
18627 UINT port = (UINT)LvGetParam(hWnd, L_LISTENER, i);
18628 RPC_LISTENER t;
18629 Zero(&t, sizeof(t));
18630 t.Enable = true;
18631 t.Port = port;
18632
18633 if (CALL(hWnd, ScEnableListener(p->Rpc, &t)))
18634 {
18635 SmServerDlgRefresh(hWnd, p);
18636 }
18637 }
18638 break;
18639
18640 case B_STOP:
18641 // Stop
18642 i = LvGetSelected(hWnd, L_LISTENER);
18643 if (i != INFINITE)
18644 {
18645 UINT port = (UINT)LvGetParam(hWnd, L_LISTENER, i);
18646 if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("CM_STOP_LISTENER_MSG"), port) == IDYES)
18647 {
18648 RPC_LISTENER t;
18649 Zero(&t, sizeof(t));
18650 t.Enable = false;
18651 t.Port = port;
18652
18653 if (CALL(hWnd, ScEnableListener(p->Rpc, &t)))
18654 {
18655 SmServerDlgRefresh(hWnd, p);
18656 }
18657 }
18658 }
18659 break;
18660
18661 case B_APPLY:
18662 {
18663 // Apply UDP ports
18664 LIST* ports;
18665 RPC_PORTS t;
18666 char tmp[MAX_SIZE];
18667
18668 GetTxtA(hWnd, E_UDP, tmp, sizeof(tmp));
18669 ports = StrToPortList(tmp, false);
18670
18671 t.Num = LIST_NUM(ports);
18672 if (t.Num > 0)
18673 {
18674 UINT i;
18675 t.Ports = Malloc(sizeof(UINT) * t.Num);
18676
18677 for (i = 0; i < t.Num; ++i)
18678 {
18679 t.Ports[i] = (UINT)LIST_DATA(ports, i);
18680 }
18681 }
18682 else
18683 {
18684 t.Ports = NULL;
18685 }
18686
18687 ReleaseList(ports);
18688
18689 if (CALL(hWnd, ScSetPortsUDP(p->Rpc, &t)))
18690 {
18691 SmServerDlgRefresh(hWnd, p);
18692 }
18693
18694 Free(t.Ports);
18695
18696 break;
18697 }
18698
18699 case B_SSL:
18700 // SSL related
18701 SmSslDlg(hWnd, p);
18702 break;
18703
18704 case B_STATUS:
18705 // Server status
18706 SmStatusDlg(hWnd, p, p, false, true, _UU("SM_SERVER_STATUS"), ICO_VPNSERVER,
18707 NULL, SmRefreshServerStatus);
18708 break;
18709
18710 case B_INFO:
18711 // Server Information
18712 SmStatusDlg(hWnd, p, p, false, false, _UU("SM_INFO_TITLE"), ICO_VPNSERVER,
18713 NULL, SmRefreshServerInfo);
18714 break;
18715
18716 case B_BRIDGE:
18717 // Local bridge configuration
18718 SmBridgeDlg(hWnd, p);
18719 SmServerDlgRefresh(hWnd, p);
18720 break;
18721
18722 case B_FARM:
18723 // Server farm
18724 if (SmFarmDlg(hWnd, p))
18725 {
18726 // Close the dialog if the server farm configuration has changed
18727 Close(hWnd);
18728 }
18729 break;
18730
18731 case B_FARM_STATUS:
18732 // Server farm status
18733 if (p->ServerType == SERVER_TYPE_FARM_CONTROLLER)
18734 {
18735 Dialog(hWnd, D_SM_FARM_MEMBER, SmFarmMemberDlgProc, p);
18736 }
18737 else if (p->ServerType == SERVER_TYPE_FARM_MEMBER)
18738 {
18739 SmStatusDlg(hWnd, p, NULL, false, true, _UU("SM_FC_STATUS_CAPTION"),
18740 ICO_FARM, NULL, SmRefreshFarmConnectionInfo);
18741 }
18742 break;
18743
18744 case B_CONNECTION:
18745 // TCP connection list
18746 SmConnectionDlg(hWnd, p);
18747 break;
18748
18749 case B_REFRESH:
18750 // Update to the latest state
18751 SmServerDlgRefresh(hWnd, p);
18752 break;
18753
18754 case B_CONFIG:
18755 // Config edit
18756 SmConfig(hWnd, p);
18757 break;
18758
18759 case B_L3:
18760 // L3 switch
18761 SmL3(hWnd, p);
18762 break;
18763
18764 case B_LICENSE:
18765 // Add or Remove license
18766 SmLicense(hWnd, p);
18767 SmServerDlgUpdate(hWnd, p);
18768 break;
18769
18770 case B_IPSEC:
18771 // IPsec Settings
18772 SmIPsec(hWnd, p);
18773 break;
18774
18775 case B_OPENVPN:
18776 // OpenVPN, SSTP setting
18777 SmOpenVpn(hWnd, p);
18778 break;
18779
18780 case B_DDNS:
18781 // DDNS setting
18782 if (SmDDns(hWnd, p, false, false))
18783 {
18784 SmServerDlgRefresh(hWnd, p);
18785 }
18786 break;
18787
18788 case B_AZURE:
18789 // VPN Azure setting
18790 SmAzure(hWnd, p, false);
18791
18792 SmServerDlgRefresh(hWnd, p);
18793 break;
18794
18795
18796 case IDCANCEL:
18797 Close(hWnd);
18798 break;
18799 }
18800 break;
18801
18802 case WM_CLOSE:
18803 {
18804 // Save the HUB that was selected last
18805 char *hubname = NULL;
18806 char tmp[MAX_SIZE];
18807
18808
18809 Format(tmp, sizeof(tmp), "%s:%u:%s", p->CurrentSetting->ClientOption.Hostname,
18810 p->CurrentSetting->ClientOption.Port,
18811 p->CurrentSetting->ServerAdminMode ? "" : p->CurrentSetting->HubName);
18812
18813 if (LvIsSingleSelected(hWnd, L_HUB))
18814 {
18815 hubname = LvGetSelectedStrA(hWnd, L_HUB, 0);
18816 }
18817
18818 if (IsEmptyStr(hubname) == false)
18819 {
18820 MsRegWriteStr(REG_CURRENT_USER, SM_LASTHUB_REG_KEY, tmp, hubname);
18821 }
18822 else
18823 {
18824 MsRegDeleteValue(REG_CURRENT_USER, SM_LASTHUB_REG_KEY, tmp);
18825 }
18826
18827 Free(hubname);
18828
18829 EndDialog(hWnd, false);
18830 }
18831 break;
18832
18833 case WM_NOTIFY:
18834 n = (NMHDR *)lParam;
18835 switch (n->idFrom)
18836 {
18837 case L_HUB:
18838 switch (n->code)
18839 {
18840 case LVN_ITEMCHANGED:
18841 SmServerDlgUpdate(hWnd, p);
18842 break;
18843 }
18844 break;
18845 case L_LISTENER:
18846 switch (n->code)
18847 {
18848 case LVN_ITEMCHANGED:
18849 SmServerDlgUpdate(hWnd, p);
18850 break;
18851 }
18852 break;
18853 }
18854 break;
18855
18856 case WM_TIMER:
18857 switch (wParam)
18858 {
18859 case 1:
18860 KillTimer(hWnd, 1);
18861
18862 if (p->ServerAdminMode)
18863 {
18864 // Prompt the registration if the license key is not registered
18865 RPC_LICENSE_STATUS t;
18866
18867 Zero(&t, sizeof(t));
18868 if (p->Bridge == false && GetCapsBool(p->CapsList, "b_support_license"))
18869 {
18870 if (ScGetLicenseStatus(p->Rpc, &t) == ERR_NO_ERROR)
18871 {
18872 if (t.EditionId == LICENSE_EDITION_VPN3_NO_LICENSE || (t.NeedSubscription && t.SubscriptionExpires == 0))
18873 {
18874 // Valid license key is not registered
18875
18876 if (MsgBox(hWnd, MB_YESNO | MB_ICONINFORMATION,
18877 _UU("SM_SETUP_NO_LICENSE_KEY")) == IDYES)
18878 {
18879 SmLicense(hWnd, p);
18880 }
18881 }
18882 }
18883 }
18884 }
18885
18886 SetTimer(hWnd, 2, 150, NULL);
18887 break;
18888
18889 case 2:
18890 // Setup
18891 KillTimer(hWnd, 2);
18892
18893 if (SmSetupIsNew(p))
18894 {
18895 if (SmSetup(hWnd, p))
18896 {
18897 SmServerDlgRefresh(hWnd, p);
18898 }
18899 }
18900
18901 SmShowIPSecMessageIfNecessary(hWnd, p);
18902
18903 SmShowCertRegenerateMessageIfNecessary(hWnd, p);
18904
18905 SetTimer(hWnd, 3, 150, NULL);
18906 break;
18907
18908 case 3:
18909 // Message for Administrators
18910 KillTimer(hWnd, 3);
18911
18912 if (UniIsEmptyStr(p->AdminMsg) == false)
18913 {
18914 wchar_t tmp[MAX_SIZE];
18915
18916 UniFormat(tmp, sizeof(tmp), _UU("SM_SERVER_ADMIN_MSG"), p->ServerName);
18917 OnceMsg(hWnd, tmp, p->AdminMsg, true, ICO_VPNSERVER);
18918 }
18919 break;
18920 }
18921 break;
18922 }
18923
18924 LvStandardHandler(hWnd, msg, wParam, lParam, L_HUB);
18925
18926 return 0;
18927 }
18928
18929 // Display the message about the cert
SmShowCertRegenerateMessageIfNecessary(HWND hWnd,SM_SERVER * p)18930 void SmShowCertRegenerateMessageIfNecessary(HWND hWnd, SM_SERVER *p)
18931 {
18932 // Validate arguments
18933 if (p == NULL)
18934 {
18935 return;
18936 }
18937
18938 if (p->ServerAdminMode && p->Bridge == false)
18939 {
18940 RPC_KEY_PAIR t;
18941
18942 Zero(&t, sizeof(t));
18943
18944 if (ScGetServerCert(p->Rpc, &t) == ERR_NO_ERROR)
18945 {
18946 if (t.Cert != NULL && t.Cert->has_basic_constraints == false)
18947 {
18948 if (t.Cert->root_cert)
18949 {
18950 if (MsRegReadInt(REG_CURRENT_USER, SM_HIDE_CERT_UPDATE_MSG_KEY, p->ServerName) == 0)
18951 {
18952 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("SM_CERT_MESSAGE")) == IDYES)
18953 {
18954 X *x;
18955 K *k;
18956
18957 // Regenerating the certificate
18958 if (SmRegenerateServerCert(hWnd, p, NULL, &x, &k, false))
18959 {
18960 // Confirmation message
18961 if (MsgBox(hWnd, MB_ICONEXCLAMATION | MB_YESNO, _UU("SM_REGENERATE_CERT_MSG")) == IDYES)
18962 {
18963 // Set the new certificate and private key
18964 RPC_KEY_PAIR t2;
18965
18966 Zero(&t2, sizeof(t2));
18967
18968 t2.Cert = CloneX(x);
18969 t2.Key = CloneK(k);
18970
18971 if (CALL(hWnd, ScSetServerCert(p->Rpc, &t2)))
18972 {
18973 FreeRpcKeyPair(&t2);
18974
18975 MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_CERT_SET_MSG"));
18976 }
18977 }
18978
18979 FreeX(x);
18980 FreeK(k);
18981 }
18982 }
18983 else
18984 {
18985 MsRegWriteInt(REG_CURRENT_USER, SM_HIDE_CERT_UPDATE_MSG_KEY, p->ServerName, 1);
18986 }
18987 }
18988 }
18989 }
18990
18991 FreeRpcKeyPair(&t);
18992 }
18993 }
18994 }
18995
18996 // Display messages about IPsec, and prompt for the setting
SmShowIPSecMessageIfNecessary(HWND hWnd,SM_SERVER * p)18997 void SmShowIPSecMessageIfNecessary(HWND hWnd, SM_SERVER *p)
18998 {
18999 // Validate arguments
19000 if (p == NULL)
19001 {
19002 return;
19003 }
19004
19005 if (GetCapsBool(p->CapsList, "b_support_vgs_in_client") == false)
19006 {
19007 if (GetCapsBool(p->CapsList, "b_support_ipsec") && p->IPsecMessageDisplayed == false)
19008 {
19009 // Display a message about IPsec
19010 RPC_TEST flag;
19011
19012 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("SM_IPSEC_SETUP_QUESTION")) == IDYES)
19013 {
19014 // Display the IPsec dialog
19015 SmIPsec(hWnd, p);
19016 }
19017
19018 Zero(&flag, sizeof(flag));
19019 flag.IntValue = 9;
19020 ToStr(flag.StrValue, 1);
19021
19022 ScDebug(p->Rpc, &flag);
19023
19024 p->IPsecMessageDisplayed = true;
19025 }
19026
19027 }
19028 }
19029
19030 // Connection
SmConnect(HWND hWnd,SETTING * s)19031 void SmConnect(HWND hWnd, SETTING *s)
19032 {
19033 SmConnectEx(hWnd, s, false);
19034 }
SmConnectEx(HWND hWnd,SETTING * s,bool is_in_client)19035 void SmConnectEx(HWND hWnd, SETTING *s, bool is_in_client)
19036 {
19037 bool ok;
19038 RPC *rpc;
19039 char *pass;
19040 bool empty_password = false;
19041 bool first_bad_password = false;
19042 // Validate arguments
19043 if (s == NULL)
19044 {
19045 return;
19046 }
19047
19048 // Disable the control
19049 Disable(hWnd, L_SETTING);
19050 Disable(hWnd, B_NEW_SETTING);
19051 Disable(hWnd, B_EDIT_SETTING);
19052 Disable(hWnd, B_DELETE);
19053 Disable(hWnd, IDOK);
19054 Disable(hWnd, B_ABOUT);
19055 Disable(hWnd, IDCANCEL);
19056 Disable(hWnd, B_SECURE_MANAGER);
19057 Disable(hWnd, B_SELECT_SECURE);
19058 Disable(hWnd, B_CERT_TOOL);
19059
19060 ok = true;
19061
19062 if (IsZero(s->HashedPassword, SHA1_SIZE))
19063 {
19064 // Password input screen
19065 ENTER_PASSWORD:
19066 pass = SmPassword(hWnd, s->ClientOption.Hostname);
19067 if (pass != NULL)
19068 {
19069 Sha0(s->HashedPassword, pass, StrLen(pass));
19070 Free(pass);
19071 ok = true;
19072 }
19073 else
19074 {
19075 ok = false;
19076 }
19077 }
19078
19079 if (ok)
19080 {
19081 UINT err = ERR_INTERNAL_ERROR;
19082 // Connection
19083 rpc = AdminConnectEx2(sm->Cedar, &s->ClientOption, s->ServerAdminMode ? "" : s->HubName, s->HashedPassword, &err, NULL,
19084 hWnd);
19085 if (rpc == NULL)
19086 {
19087 // An error has occured
19088 if (err != ERR_ACCESS_DENIED || first_bad_password)
19089 {
19090 MsgBox(hWnd, MB_ICONSTOP, _E(err));
19091 }
19092 if (err == ERR_ACCESS_DENIED)
19093 {
19094 // Password incorrect
19095 first_bad_password = true;
19096 goto ENTER_PASSWORD;
19097 }
19098 else
19099 {
19100 // Other errors
19101 }
19102 }
19103 else
19104 {
19105 UCHAR test[SHA1_SIZE];
19106 SM_SERVER p;
19107 RPC_SERVER_STATUS status;
19108 RPC_SERVER_INFO info;
19109 SETTING *setting;
19110 RPC_MSG msg;
19111 RPC_TEST flag;
19112 bool cancel = false;
19113
19114 Sha0(test, "", 0);
19115
19116 if (Cmp(test, s->HashedPassword, SHA1_SIZE) == 0 || Cmp(test, rpc->VpnServerHashedPassword, SHA1_SIZE) == 0)
19117 {
19118 empty_password = true;
19119 }
19120
19121 if (sm->TempSetting == NULL)
19122 {
19123 setting = SmGetSetting(s->Title);
19124 if (setting != NULL)
19125 {
19126 if (IsZero(setting->HashedPassword, SHA1_SIZE) == false)
19127 {
19128 Copy(setting->HashedPassword, s->HashedPassword, SHA1_SIZE);
19129 SmWriteSettingList();
19130 }
19131 }
19132 }
19133
19134 rpc->ServerAdminMode = s->ServerAdminMode;
19135 if (s->ServerAdminMode == false)
19136 {
19137 StrCpy(rpc->HubName, sizeof(rpc->HubName), s->HubName);
19138 }
19139
19140 Zero(&p, sizeof(p));
19141 p.IsInClient = is_in_client;
19142 p.CurrentSetting = s;
19143 p.Rpc = rpc;
19144 p.ServerAdminMode = rpc->ServerAdminMode;
19145 StrCpy(p.ServerName, sizeof(p.ServerName), s->ClientOption.Hostname);
19146 if (p.ServerAdminMode == false)
19147 {
19148 StrCpy(p.HubName, sizeof(p.HubName), rpc->HubName);
19149 }
19150 UniStrCpy(p.Title, sizeof(p.Title), s->Title);
19151
19152 // Get the type of server
19153 Zero(&status, sizeof(status));
19154 ScGetServerStatus(rpc, &status);
19155
19156 p.ServerType = status.ServerType;
19157
19158 Zero(&info, sizeof(info));
19159 ScGetServerInfo(rpc, &info);
19160
19161 Copy(&p.ServerInfo, &info, sizeof(RPC_SERVER_INFO));
19162 Copy(&p.ServerStatus, &status, sizeof(RPC_SERVER_STATUS));
19163
19164 // Get the Admin Msg
19165 Zero(&msg, sizeof(msg));
19166 if (ScGetAdminMsg(rpc, &msg) == ERR_NO_ERROR)
19167 {
19168 p.AdminMsg = UniCopyStr(msg.Msg);
19169 FreeRpcMsg(&msg);
19170 }
19171
19172 // IPsec related
19173 Zero(&flag, sizeof(flag));
19174 flag.IntValue = 8;
19175 if (ScDebug(rpc, &flag) == ERR_NO_ERROR)
19176 {
19177 p.IPsecMessageDisplayed = ToInt(flag.StrValue);
19178 }
19179 else
19180 {
19181 p.IPsecMessageDisplayed = true;
19182 }
19183
19184 // VGS related
19185 Zero(&flag, sizeof(flag));
19186 flag.IntValue = 10;
19187 if (ScDebug(rpc, &flag) == ERR_NO_ERROR)
19188 {
19189 p.VgsMessageDisplayed = ToInt(flag.StrValue);
19190 }
19191 else
19192 {
19193 p.VgsMessageDisplayed = true;
19194 }
19195
19196 // Get the Caps
19197 p.CapsList = ScGetCapsEx(p.Rpc);
19198
19199 p.Bridge = GetCapsBool(p.CapsList, "b_bridge");
19200
19201 if (GetCapsBool(p.CapsList, "b_support_policy_ver_3"))
19202 {
19203 p.PolicyVer = 3;
19204 }
19205 else
19206 {
19207 p.PolicyVer = 2;
19208 }
19209
19210 if (empty_password && s->ServerAdminMode)
19211 {
19212 // Make the user set a password when a password empty (In the case of server management mode)
19213 if (Dialog(hWnd, D_SM_CHANGE_PASSWORD, SmChangeServerPasswordDlg, &p) == 0)
19214 {
19215 cancel = true;
19216 }
19217 }
19218
19219 // Server management screen
19220 if (cancel == false)
19221 {
19222 // Update notification initialization
19223 WINUI_UPDATE *update = NULL;
19224
19225 if (p.ServerAdminMode && is_in_client == false)
19226 {
19227 wchar_t update_software_title[MAX_SIZE];
19228 char update_software_name[MAX_SIZE];
19229 char server_name_safe[MAX_HOST_NAME_LEN + 1];
19230 char family_name[128];
19231
19232 MakeSafeFileName(server_name_safe, sizeof(server_name_safe), p.ServerName);
19233 Format(update_software_name, sizeof(update_software_name), (p.Bridge ? NAME_OF_VPN_BRIDGE_TARGET : NAME_OF_VPN_SERVER_TARGET), server_name_safe);
19234 StrLower(update_software_name);
19235 Trim(update_software_name);
19236
19237 Zero(family_name, sizeof(family_name));
19238 StrCpy(family_name, sizeof(family_name), p.ServerInfo.ServerFamilyName);
19239
19240 if (IsEmptyStr(family_name))
19241 {
19242 if (InStr(p.ServerInfo.ServerProductName, "PacketiX"))
19243 {
19244 StrCpy(family_name, sizeof(family_name), "PacketiX");
19245 }
19246 else if (InStr(p.ServerInfo.ServerProductName, "UT-VPN") ||
19247 InStr(p.ServerInfo.ServerProductName, "SoftEther"))
19248 {
19249 StrCpy(family_name, sizeof(family_name), "softether");
19250 }
19251 }
19252
19253 if (IsEmptyStr(family_name) == false)
19254 {
19255 UniFormat(update_software_title, sizeof(update_software_title), _UU(p.Bridge ? "SM_UPDATE_CHECK_TITLE_VPNBRIDGE" : "SM_UPDATE_CHECK_TITLE_VPNSERVER"),
19256 family_name, p.ServerName);
19257
19258 update = InitUpdateUi(update_software_title, update_software_name, family_name, p.ServerInfo.ServerBuildDate,
19259 p.ServerInfo.ServerBuildInt, p.ServerInfo.ServerVerInt, NULL, false);
19260 }
19261 }
19262
19263 p.Update = update;
19264
19265 // Main screen
19266 Dialog(hWnd, D_SM_SERVER, SmServerDlgProc, &p);
19267
19268 if (p.Update != NULL)
19269 {
19270 FreeUpdateUi(p.Update);
19271 p.Update = NULL;
19272 }
19273 }
19274
19275 // Disconnect
19276 AdminDisconnect(rpc);
19277
19278 // Release the Caps
19279 FreeCapsList(p.CapsList);
19280
19281 Free(p.AdminMsg);
19282 p.AdminMsg = NULL;
19283
19284 FreeRpcServerInfo(&info);
19285 }
19286 }
19287
19288 // Enable the control
19289 Enable(hWnd, L_SETTING);
19290 Enable(hWnd, B_NEW_SETTING);
19291 Enable(hWnd, B_EDIT_SETTING);
19292 Enable(hWnd, B_DELETE);
19293 Enable(hWnd, IDOK);
19294 Enable(hWnd, B_ABOUT);
19295 Enable(hWnd, IDCANCEL);
19296
19297 if (MsIsWine() == false)
19298 {
19299 Enable(hWnd, B_SECURE_MANAGER);
19300 Enable(hWnd, B_SELECT_SECURE);
19301 }
19302
19303 Enable(hWnd, B_CERT_TOOL);
19304 }
19305
19306 // Password input dialog
SmPassword(HWND hWnd,char * server_name)19307 char *SmPassword(HWND hWnd, char *server_name)
19308 {
19309 char *ret;
19310 UI_PASSWORD_DLG p;
19311 // Validate arguments
19312 if (server_name == NULL)
19313 {
19314 return NULL;
19315 }
19316
19317 Zero(&p, sizeof(p));
19318 p.AdminMode = true;
19319 StrCpy(p.ServerName, sizeof(p.ServerName), server_name);
19320
19321 if (PasswordDlg(hWnd, &p) == false)
19322 {
19323 return NULL;
19324 }
19325
19326 ret = CopyStr(p.Password);
19327
19328 return ret;
19329 }
19330
19331 // Configuration editing dialog initialization
SmEditSettingDlgInit(HWND hWnd,SM_EDIT_SETTING * p)19332 void SmEditSettingDlgInit(HWND hWnd, SM_EDIT_SETTING *p)
19333 {
19334 SETTING *s;
19335 // Validate arguments
19336 if (hWnd == NULL || p == NULL)
19337 {
19338 return;
19339 }
19340
19341 p->Inited = false;
19342
19343 s = p->Setting;
19344
19345 // Title
19346 if (p->EditMode == false)
19347 {
19348 SetText(hWnd, 0, _UU("SM_EDIT_CAPTION_1"));
19349 }
19350 else
19351 {
19352 wchar_t tmp[MAX_SIZE];
19353 UniFormat(tmp, sizeof(tmp), _UU("SM_EDIT_CAPTION_2"), s->Title);
19354 SetText(hWnd, 0, tmp);
19355 }
19356
19357 // Connection setting name
19358 SetText(hWnd, E_ACCOUNT_NAME, s->Title);
19359
19360 // Host name
19361 SetTextA(hWnd, E_HOSTNAME, s->ClientOption.Hostname);
19362
19363 // Port number
19364 CbSetHeight(hWnd, C_PORT, 18);
19365 CbAddStr(hWnd, C_PORT, _UU("CM_PORT_1"), 0);
19366 CbAddStr(hWnd, C_PORT, _UU("CM_PORT_2"), 0);
19367 CbAddStr(hWnd, C_PORT, _UU("CM_PORT_3"), 0);
19368 CbAddStr(hWnd, C_PORT, _UU("CM_PORT_4"), 0);
19369 SetIntEx(hWnd, C_PORT, s->ClientOption.Port);
19370
19371 // Proxy Settings
19372 Check(hWnd, R_DIRECT_TCP, s->ClientOption.ProxyType == PROXY_DIRECT);
19373 Check(hWnd, R_HTTPS, s->ClientOption.ProxyType == PROXY_HTTP);
19374 Check(hWnd, R_SOCKS, s->ClientOption.ProxyType == PROXY_SOCKS);
19375 Check(hWnd, R_SOCKS5, s->ClientOption.ProxyType == PROXY_SOCKS5);
19376
19377 // Management mode setting
19378 Check(hWnd, R_SERVER_ADMIN, s->ServerAdminMode);
19379 Check(hWnd, R_HUB_ADMIN, s->ServerAdminMode == false ? true : false);
19380 CbSetHeight(hWnd, C_HUBNAME, 18);
19381 SetTextA(hWnd, C_HUBNAME, s->HubName);
19382
19383 // Password
19384 if (IsZero(s->HashedPassword, SHA1_SIZE))
19385 {
19386 Check(hWnd, R_NO_SAVE, true);
19387 }
19388 else
19389 {
19390 UCHAR test[SHA1_SIZE];
19391
19392 Sha0(test, "", 0);
19393 if (Cmp(test, s->HashedPassword, SHA1_SIZE) != 0)
19394 {
19395 SetTextA(hWnd, E_PASSWORD, HIDDEN_PASSWORD);
19396 }
19397 }
19398
19399 if (p->EditMode == false)
19400 {
19401 FocusEx(hWnd, E_ACCOUNT_NAME);
19402 }
19403 else
19404 {
19405 FocusEx(hWnd, E_HOSTNAME);
19406 }
19407
19408 p->Inited = true;
19409
19410 // Start enumerating the Virtual HUBs
19411 CmEnumHubStart(hWnd, &s->ClientOption);
19412
19413 SmEditSettingDlgUpdate(hWnd, p);
19414 }
19415
19416 // Configuration editing dialog update
SmEditSettingDlgUpdate(HWND hWnd,SM_EDIT_SETTING * p)19417 void SmEditSettingDlgUpdate(HWND hWnd, SM_EDIT_SETTING *p)
19418 {
19419 bool ok = true;
19420 UINT delete_hub_list = 0;
19421 SETTING *s;
19422 char tmp[MAX_SIZE];
19423 // Validate arguments
19424 if (hWnd == NULL || p == NULL || p->Inited == false)
19425 {
19426 return;
19427 }
19428
19429 s = p->Setting;
19430
19431 GetTxt(hWnd, E_ACCOUNT_NAME, s->Title, sizeof(s->Title));
19432 UniTrim(s->Title);
19433
19434 if (UniStrLen(s->Title) == 0)
19435 {
19436 ok = false;
19437 }
19438
19439 if (IsChecked(hWnd, R_LOCALHOST))
19440 {
19441 SetTextA(hWnd, E_HOSTNAME, "localhost");
19442 Disable(hWnd, E_HOSTNAME);
19443 }
19444 else
19445 {
19446 Enable(hWnd, E_HOSTNAME);
19447 }
19448
19449 GetTxtA(hWnd, E_HOSTNAME, tmp, sizeof(tmp));
19450 Trim(tmp);
19451
19452 if (StrCmpi(tmp, s->ClientOption.Hostname) != 0)
19453 {
19454 delete_hub_list++;
19455 }
19456
19457 StrCpy(s->ClientOption.Hostname, sizeof(s->ClientOption.Hostname), tmp);
19458
19459 if (StrLen(s->ClientOption.Hostname) == 0)
19460 {
19461 ok = false;
19462 }
19463
19464 s->ClientOption.Port = GetInt(hWnd, C_PORT);
19465 if (s->ClientOption.Port == 0)
19466 {
19467 ok = false;
19468 }
19469
19470 if (IsChecked(hWnd, R_DIRECT_TCP))
19471 {
19472 s->ClientOption.ProxyType = PROXY_DIRECT;
19473 }
19474 else if (IsChecked(hWnd, R_HTTPS))
19475 {
19476 s->ClientOption.ProxyType = PROXY_HTTP;
19477 }
19478 else
19479 {
19480 s->ClientOption.ProxyType = PROXY_SOCKS;
19481 }
19482
19483 SetEnable(hWnd, B_PROXY_CONFIG, s->ClientOption.ProxyType != PROXY_DIRECT);
19484
19485 if (s->ClientOption.ProxyType != PROXY_DIRECT)
19486 {
19487 if (StrLen(s->ClientOption.ProxyName) == 0)
19488 {
19489 ok = false;
19490 }
19491 if (s->ClientOption.ProxyPort == 0)
19492 {
19493 ok = false;
19494 }
19495 }
19496
19497 s->ServerAdminMode = IsChecked(hWnd, R_SERVER_ADMIN);
19498
19499 SetEnable(hWnd, C_HUBNAME, s->ServerAdminMode == false ? true : false);
19500 SetEnable(hWnd, S_HUBNAME, s->ServerAdminMode == false ? true : false);
19501
19502 GetTxtA(hWnd, C_HUBNAME, s->HubName, sizeof(s->HubName));
19503 Trim(s->HubName);
19504 if (StrLen(s->HubName) == 0)
19505 {
19506 if (s->ServerAdminMode == false)
19507 {
19508 ok = false;
19509 }
19510 }
19511
19512 if (IsChecked(hWnd, R_NO_SAVE))
19513 {
19514 Zero(s->HashedPassword, SHA1_SIZE);
19515 SetTextA(hWnd, E_PASSWORD, "");
19516 Disable(hWnd, E_PASSWORD);
19517 Disable(hWnd, S_PASSWORD);
19518 }
19519 else
19520 {
19521 char tmp[MAX_PASSWORD_LEN + 1];
19522 Enable(hWnd, E_PASSWORD);
19523 Enable(hWnd, S_PASSWORD);
19524 GetTxtA(hWnd, E_PASSWORD, tmp, sizeof(tmp));
19525 if (StrCmp(tmp, HIDDEN_PASSWORD) != 0)
19526 {
19527 Sha0(s->HashedPassword, tmp, StrLen(tmp));
19528 }
19529 }
19530
19531 if (delete_hub_list)
19532 {
19533 CbReset(hWnd, C_HUBNAME);
19534 }
19535
19536 SetEnable(hWnd, IDOK, ok);
19537 }
19538
19539 // Configuration Edit dialog OK button
SmEditSettingDlgOnOk(HWND hWnd,SM_EDIT_SETTING * p)19540 void SmEditSettingDlgOnOk(HWND hWnd, SM_EDIT_SETTING *p)
19541 {
19542 // Validate arguments
19543 if (hWnd == NULL || p == NULL)
19544 {
19545 return;
19546 }
19547
19548 if (p->EditMode == false)
19549 {
19550 // Register new
19551 SETTING *s = ZeroMalloc(sizeof(SETTING));
19552 Copy(s, p->Setting, sizeof(SETTING));
19553 if (SmAddSetting(s) == false)
19554 {
19555 MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SM_SETTING_EXISTS"), s->Title);
19556 Free(s);
19557 FocusEx(hWnd, E_ACCOUNT_NAME);
19558 return;
19559 }
19560 EndDialog(hWnd, true);
19561 }
19562 else
19563 {
19564 // Update registration
19565 SETTING *t = SmGetSetting(p->Setting->Title);
19566 if (t != NULL && t != p->OldSetting)
19567 {
19568 MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SM_SETTING_EXISTS"), p->Setting->Title);
19569 FocusEx(hWnd, E_ACCOUNT_NAME);
19570 return;
19571 }
19572
19573 Copy(p->OldSetting, p->Setting, sizeof(SETTING));
19574 Sort(sm->SettingList);
19575 SmWriteSettingList();
19576
19577 EndDialog(hWnd, true);
19578 }
19579 }
19580
19581 // Settings add / edit dialog
SmEditSettingDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)19582 UINT SmEditSettingDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
19583 {
19584 SM_EDIT_SETTING *p = (SM_EDIT_SETTING *)param;
19585 // Validate arguments
19586 if (hWnd == NULL)
19587 {
19588 return 0;
19589 }
19590
19591 switch (msg)
19592 {
19593 case WM_INITDIALOG:
19594 SmEditSettingDlgInit(hWnd, p);
19595 break;
19596
19597 case WM_COMMAND:
19598 switch (LOWORD(wParam))
19599 {
19600 case R_LOCALHOST:
19601 case E_ACCOUNT_NAME:
19602 case E_HOSTNAME:
19603 case C_PORT:
19604 case R_DIRECT_TCP:
19605 case R_HTTPS:
19606 case R_SOCKS:
19607 case R_SOCKS5:
19608 case R_SERVER_ADMIN:
19609 case R_HUB_ADMIN:
19610 case C_HUBNAME:
19611 case E_PASSWORD:
19612 case R_NO_SAVE:
19613 SmEditSettingDlgUpdate(hWnd, p);
19614 break;
19615 }
19616
19617 if (LOWORD(wParam) == R_LOCALHOST)
19618 {
19619 FocusEx(hWnd, E_HOSTNAME);
19620 }
19621
19622 switch (LOWORD(wParam))
19623 {
19624 case E_HOSTNAME:
19625 if (HIWORD(wParam) == EN_KILLFOCUS)
19626 {
19627 CmEnumHubStart(hWnd, &p->Setting->ClientOption);
19628 }
19629 break;
19630 case C_PORT:
19631 if (HIWORD(wParam) == CBN_KILLFOCUS)
19632 {
19633 CmEnumHubStart(hWnd, &p->Setting->ClientOption);
19634 }
19635 break;
19636 case R_DIRECT_TCP:
19637 case R_HTTPS:
19638 case R_SOCKS:
19639 case R_SOCKS5:
19640 if (HIWORD(wParam) == BN_CLICKED)
19641 {
19642 CmEnumHubStart(hWnd, &p->Setting->ClientOption);
19643 }
19644 break;
19645 }
19646
19647 switch (wParam)
19648 {
19649 case IDOK:
19650 SmEditSettingDlgOnOk(hWnd, p);
19651 break;
19652
19653 case IDCANCEL:
19654 Close(hWnd);
19655 break;
19656
19657 case B_PROXY_CONFIG:
19658 // Proxy Settings
19659 if (CmProxyDlg(hWnd, &p->Setting->ClientOption))
19660 {
19661 UINT n = GetInt(hWnd, C_PORT);
19662 if (p->Setting->ClientOption.ProxyType == PROXY_HTTP &&
19663 n != 443)
19664 {
19665 // Show a warning message if the destination port is
19666 // other than 443 in when HTTP proxy is used
19667 if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("CM_HTTP_PROXY_WARNING"), n) == IDYES)
19668 {
19669 // Change the port number to 443
19670 SetText(hWnd, C_PORT, _UU("CM_PORT_2"));
19671 }
19672 }
19673 SmEditSettingDlgUpdate(hWnd, p);
19674 CmEnumHubStart(hWnd, &p->Setting->ClientOption);
19675 }
19676 break;
19677
19678 case R_NO_SAVE:
19679 if (IsChecked(hWnd, R_NO_SAVE) == false)
19680 {
19681 FocusEx(hWnd, E_PASSWORD);
19682 }
19683 break;
19684 }
19685 break;
19686
19687 case WM_CLOSE:
19688 EndDialog(hWnd, false);
19689 break;
19690 }
19691
19692 return 0;
19693 }
19694
19695 // Show the Settings Adding dialog
SmAddSettingDlg(HWND hWnd,wchar_t * new_name,UINT new_name_size)19696 bool SmAddSettingDlg(HWND hWnd, wchar_t *new_name, UINT new_name_size)
19697 {
19698 SM_EDIT_SETTING p;
19699 SETTING s;
19700 UINT i;
19701 bool ret;
19702 // Validate arguments
19703 if (hWnd == NULL || new_name == NULL)
19704 {
19705 return false;
19706 }
19707
19708 Zero(&p, sizeof(p));
19709 Zero(&s, sizeof(s));
19710
19711 s.ClientOption.Port = 443;
19712
19713 p.EditMode = false;
19714 p.Setting = &s;
19715
19716 for (i = 1;;i++)
19717 {
19718 wchar_t tmp[MAX_SIZE];
19719 if (i == 1)
19720 {
19721 UniFormat(tmp, sizeof(tmp), _UU("CM_NEW_ACCOUNT_NAME_1"));
19722 }
19723 else
19724 {
19725 UniFormat(tmp, sizeof(tmp), _UU("CM_NEW_ACCOUNT_NAME_2"), i);
19726 }
19727
19728 if (SmGetSetting(tmp) == NULL)
19729 {
19730 UniStrCpy(s.Title, sizeof(s.Title), tmp);
19731 Sha0(s.HashedPassword, "", 0);
19732 s.ServerAdminMode = true;
19733 break;
19734 }
19735 }
19736
19737 ret = Dialog(hWnd, D_SM_EDIT_SETTING, SmEditSettingDlgProc, &p);
19738
19739 if (ret)
19740 {
19741 UniStrCpy(new_name, new_name_size, s.Title);
19742 }
19743
19744 return ret;
19745 }
19746
19747 // Show the settings edit dialog
SmEditSettingDlg(HWND hWnd)19748 bool SmEditSettingDlg(HWND hWnd)
19749 {
19750 SM_EDIT_SETTING p;
19751 SETTING s, *setting;
19752 UINT i;
19753 wchar_t *name;
19754 // Validate arguments
19755 if (hWnd == NULL)
19756 {
19757 return false;
19758 }
19759
19760 i = LvGetSelected(hWnd, L_SETTING);
19761 if (i == INFINITE)
19762 {
19763 return false;
19764 }
19765
19766 name = LvGetStr(hWnd, L_SETTING, i, 0);
19767
19768 setting = SmGetSetting(name);
19769 if (setting == NULL)
19770 {
19771 Free(name);
19772 return false;
19773 }
19774
19775 Free(name);
19776
19777 Copy(&s, setting, sizeof(SETTING));
19778
19779 Zero(&p, sizeof(p));
19780
19781 p.EditMode = true;
19782 p.OldSetting = setting;
19783 p.Setting = &s;
19784
19785 return Dialog(hWnd, D_SM_EDIT_SETTING, SmEditSettingDlgProc, &p);
19786 }
19787
19788 // Update the configuration
SmCheckNewName(SETTING * s,wchar_t * new_title)19789 bool SmCheckNewName(SETTING *s, wchar_t *new_title)
19790 {
19791 UINT i;
19792 // Validate arguments
19793 if (new_title == NULL)
19794 {
19795 return false;
19796 }
19797 if (s != NULL)
19798 {
19799 if (IsInList(sm->SettingList, s) == false)
19800 {
19801 return false;
19802 }
19803 }
19804
19805 // Check whether there is the same name in other
19806 for (i = 0;i < LIST_NUM(sm->SettingList);i++)
19807 {
19808 SETTING *t = LIST_DATA(sm->SettingList, i);
19809
19810 if (s != t)
19811 {
19812 if (UniStrCmpi(t->Title, new_title) == 0)
19813 {
19814 return false;
19815 }
19816 }
19817 }
19818
19819 return true;
19820 }
19821
19822 // Delete the configuration
SmDeleteSetting(wchar_t * title)19823 void SmDeleteSetting(wchar_t *title)
19824 {
19825 SETTING *s;
19826 // Validate arguments
19827 if (title == NULL)
19828 {
19829 return;
19830 }
19831
19832 s = SmGetSetting(title);
19833 if (s == NULL)
19834 {
19835 return;
19836 }
19837
19838 Delete(sm->SettingList, s);
19839 Free(s);
19840 Sort(sm->SettingList);
19841
19842 SmWriteSettingList();
19843 }
19844
19845 // Add the settings
SmAddSetting(SETTING * s)19846 bool SmAddSetting(SETTING *s)
19847 {
19848 // Validate arguments
19849 if (s == NULL)
19850 {
19851 return false;
19852 }
19853
19854 if (SmGetSetting(s->Title) != NULL)
19855 {
19856 return false;
19857 }
19858
19859 Insert(sm->SettingList, s);
19860
19861 SmWriteSettingList();
19862
19863 return true;
19864 }
19865
19866 // Get the configuration
SmGetSetting(wchar_t * title)19867 SETTING *SmGetSetting(wchar_t *title)
19868 {
19869 SETTING s;
19870 // Validate arguments
19871 if (title == NULL)
19872 {
19873 return NULL;
19874 }
19875
19876 Zero(&s, sizeof(SETTING));
19877 UniStrCpy(s.Title, sizeof(s.Title), title);
19878
19879 return (SETTING *)Search(sm->SettingList, &s);
19880 }
19881
19882 // Comparison of connection settings
SmCompareSetting(void * p1,void * p2)19883 int SmCompareSetting(void *p1, void *p2)
19884 {
19885 SETTING *s1, *s2;
19886 if (p1 == NULL || p2 == NULL)
19887 {
19888 return 0;
19889 }
19890 s1 = *(SETTING **)p1;
19891 s2 = *(SETTING **)p2;
19892 if (s1 == NULL || s2 == NULL)
19893 {
19894 return 0;
19895 }
19896
19897 return UniStrCmpi(s1->Title, s2->Title);
19898 }
19899
19900 // Initialize the configuration list
SmInitSettingList()19901 void SmInitSettingList()
19902 {
19903 sm->SettingList = NewList(SmCompareSetting);
19904
19905 SmLoadSettingList();
19906
19907 SmInitDefaultSettingList();
19908 }
19909
19910 // Release the configuration list
SmFreeSettingList()19911 void SmFreeSettingList()
19912 {
19913 UINT i;
19914
19915 // Write
19916 SmWriteSettingList();
19917
19918 for (i = 0;i < LIST_NUM(sm->SettingList);i++)
19919 {
19920 SETTING *s = LIST_DATA(sm->SettingList, i);
19921 Free(s);
19922 }
19923 ReleaseList(sm->SettingList);
19924
19925 sm->SettingList = NULL;
19926 }
19927
19928 // Write the configuration list
SmWriteSettingList()19929 void SmWriteSettingList()
19930 {
19931 TOKEN_LIST *t;
19932 UINT i;
19933
19934 t = MsRegEnumValue(REG_CURRENT_USER, SM_SETTING_REG_KEY);
19935 if (t != NULL)
19936 {
19937 // Remove all existing values
19938 for (i = 0;i < t->NumTokens;i++)
19939 {
19940 char *name = t->Token[i];
19941 MsRegDeleteValue(REG_CURRENT_USER, SM_SETTING_REG_KEY, name);
19942 }
19943
19944 FreeToken(t);
19945 }
19946
19947 for (i = 0;i < LIST_NUM(sm->SettingList);i++)
19948 {
19949 char name[MAX_SIZE];
19950 SETTING *s = LIST_DATA(sm->SettingList, i);
19951
19952 // Write
19953 Format(name, sizeof(name), "Setting%u", i + 1);
19954 MsRegWriteBin(REG_CURRENT_USER, SM_SETTING_REG_KEY, name, s, sizeof(SETTING));
19955 }
19956 }
19957
19958 // Load the connection list
SmLoadSettingList()19959 void SmLoadSettingList()
19960 {
19961 TOKEN_LIST *t;
19962 UINT i;
19963 char *key_name = SM_SETTING_REG_KEY;
19964
19965 t = MsRegEnumValue(REG_CURRENT_USER, key_name);
19966 if (t == NULL)
19967 {
19968 key_name = SM_SETTING_REG_KEY_OLD;
19969 t = MsRegEnumValue(REG_CURRENT_USER, key_name);
19970 if (t == NULL)
19971 {
19972 return;
19973 }
19974 }
19975
19976 for (i = 0;i < t->NumTokens;i++)
19977 {
19978 char *name = t->Token[i];
19979 BUF *b = MsRegReadBin(REG_CURRENT_USER, key_name, name);
19980 if (b != NULL)
19981 {
19982 if (b->Size == sizeof(SETTING))
19983 {
19984 SETTING *s = ZeroMalloc(sizeof(SETTING));
19985 Copy(s, b->Buf, sizeof(SETTING));
19986
19987 Add(sm->SettingList, s);
19988 }
19989 FreeBuf(b);
19990 }
19991 }
19992
19993 FreeToken(t);
19994
19995 Sort(sm->SettingList);
19996 }
19997
19998 // Initialize the default setting list
SmInitDefaultSettingList()19999 void SmInitDefaultSettingList()
20000 {
20001 if (LIST_NUM(sm->SettingList) == 0)
20002 {
20003 bool b = false;
20004 LIST *pl = MsGetProcessList();
20005
20006 if (pl != NULL)
20007 {
20008 UINT i;
20009 for (i = 0;i < LIST_NUM(pl);i++)
20010 {
20011 MS_PROCESS *p = LIST_DATA(pl, i);
20012
20013 if (UniInStr(p->ExeFilenameW, L"vpnserver.exe") || UniInStr(p->ExeFilenameW, L"vpnbridge.exe"))
20014 {
20015 b = true;
20016 }
20017
20018 if (UniInStr(p->ExeFilenameW, L"sevpnserver.exe") || UniInStr(p->ExeFilenameW, L"sevpnbridge.exe"))
20019 {
20020 b = true;
20021 }
20022
20023 if (UniInStr(p->ExeFilenameW, L"utvpnserver.exe") || UniInStr(p->ExeFilenameW, L"utvpnbridge.exe"))
20024 {
20025 b = true;
20026 }
20027 }
20028 }
20029
20030 MsFreeProcessList(pl);
20031
20032 if (b == false)
20033 {
20034 if (MsIsServiceRunning(GC_SVC_NAME_VPNSERVER) || MsIsServiceRunning(GC_SVC_NAME_VPNBRIDGE))
20035 {
20036 b = true;
20037 }
20038 }
20039
20040 if (b)
20041 {
20042 SETTING *s = ZeroMalloc(sizeof(SETTING));
20043
20044 UniStrCpy(s->Title, sizeof(s->Title), _UU("SM_LOCALHOST"));
20045 s->ServerAdminMode = true;
20046 Sha0(s->HashedPassword, "", 0);
20047 UniStrCpy(s->ClientOption.AccountName, sizeof(s->ClientOption.AccountName), s->Title);
20048 StrCpy(s->ClientOption.Hostname, sizeof(s->ClientOption.Hostname), "localhost");
20049 s->ClientOption.Port = GC_DEFAULT_PORT;
20050
20051 Add(sm->SettingList, s);
20052 }
20053 }
20054 }
20055
20056 // Main dialog initialization
SmMainDlgInit(HWND hWnd)20057 void SmMainDlgInit(HWND hWnd)
20058 {
20059 wchar_t *last_select;
20060 UINT i = INFINITE;
20061 // Validate arguments
20062 if (hWnd == NULL)
20063 {
20064 return;
20065 }
20066
20067 SetIcon(hWnd, 0, ICO_VPNSERVER);
20068
20069 LvInit(hWnd, L_SETTING);
20070 LvSetStyle(hWnd, L_SETTING, LVS_EX_GRIDLINES);
20071 LvInsertColumn(hWnd, L_SETTING, 0, _UU("SM_MAIN_COLUMN_1"), 145);
20072 LvInsertColumn(hWnd, L_SETTING, 1, _UU("SM_MAIN_COLUMN_2"), 129);
20073 LvInsertColumn(hWnd, L_SETTING, 2, _UU("SM_MAIN_COLUMN_3"), 125);
20074
20075 SmRefreshSetting(hWnd);
20076
20077 last_select = MsRegReadStrW(REG_CURRENT_USER, SM_REG_KEY, "Last Select");
20078 if (UniIsEmptyStr(last_select) == false)
20079 {
20080 i = LvSearchStr(hWnd, L_SETTING, 0, last_select);
20081 }
20082 Free(last_select);
20083
20084 if (i == INFINITE)
20085 {
20086 LvSelect(hWnd, L_SETTING, 0);
20087 }
20088 else
20089 {
20090 LvSelect(hWnd, L_SETTING, i);
20091 }
20092
20093 DlgFont(hWnd, IDOK, 10, true);
20094
20095 if (MsIsWine())
20096 {
20097 Disable(hWnd, B_SECURE_MANAGER);
20098 Disable(hWnd, B_SELECT_SECURE);
20099 }
20100
20101 Focus(hWnd, L_SETTING);
20102
20103 SmMainDlgUpdate(hWnd);
20104 }
20105
20106 // Update the configuration list
SmRefreshSetting(HWND hWnd)20107 void SmRefreshSetting(HWND hWnd)
20108 {
20109 SmRefreshSettingEx(hWnd, NULL);
20110 }
SmRefreshSettingEx(HWND hWnd,wchar_t * select_name)20111 void SmRefreshSettingEx(HWND hWnd, wchar_t *select_name)
20112 {
20113 LVB *b;
20114 UINT i;
20115 // Validate arguments
20116 if (hWnd == NULL)
20117 {
20118 return;
20119 }
20120
20121 b = LvInsertStart();
20122
20123 for (i = 0;i < LIST_NUM(sm->SettingList);i++)
20124 {
20125 wchar_t tmp[MAX_SIZE];
20126 wchar_t tmp2[MAX_SIZE];
20127 SETTING *s = LIST_DATA(sm->SettingList, i);
20128
20129 if (s->ServerAdminMode)
20130 {
20131 UniStrCpy(tmp, sizeof(tmp), _UU("SM_MODE_SERVER"));
20132 }
20133 else
20134 {
20135 UniFormat(tmp, sizeof(tmp), _UU("SM_MODE_HUB"), s->HubName);
20136 }
20137
20138 StrToUni(tmp2, sizeof(tmp2), s->ClientOption.Hostname);
20139
20140 LvInsertAdd(b,
20141 (s->ServerAdminMode ? ICO_SERVER_ONLINE : ICO_HUB),
20142 NULL,
20143 3,
20144 s->Title,
20145 tmp2,
20146 tmp);
20147 }
20148
20149 LvInsertEnd(b, hWnd, L_SETTING);
20150
20151 if (UniIsEmptyStr(select_name) == false)
20152 {
20153 LvSelect(hWnd, L_SETTING, INFINITE);
20154 LvSelect(hWnd, L_SETTING, LvSearchStr(hWnd, L_SETTING, 0, select_name));
20155 }
20156 }
20157
20158 // Main dialog update
SmMainDlgUpdate(HWND hWnd)20159 void SmMainDlgUpdate(HWND hWnd)
20160 {
20161 bool ok = true;
20162 // Validate arguments
20163 if (hWnd == NULL)
20164 {
20165 return;
20166 }
20167
20168 if (LvIsSelected(hWnd, L_SETTING) == false)
20169 {
20170 ok = false;
20171 }
20172 if (LvIsMultiMasked(hWnd, L_SETTING))
20173 {
20174 ok = false;
20175 }
20176
20177 SetEnable(hWnd, IDOK, ok);
20178 SetEnable(hWnd, B_EDIT_SETTING, ok);
20179 SetEnable(hWnd, B_DELETE, ok);
20180 }
20181
20182 // Main window procedure
SmMainDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)20183 UINT SmMainDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
20184 {
20185 NMHDR *n;
20186 NMLVDISPINFOW *info;
20187 NMLVKEYDOWN *key;
20188 wchar_t *tmp;
20189 UINT i;
20190 wchar_t new_name[MAX_SIZE];
20191 // Validate arguments
20192 if (hWnd == NULL)
20193 {
20194 return 0;
20195 }
20196
20197 switch (msg)
20198 {
20199 case WM_INITDIALOG:
20200 SmMainDlgInit(hWnd);
20201 SetTimer(hWnd, 4, 100, NULL);
20202
20203 // Updater start
20204 sm->Update = InitUpdateUi(_UU("PRODUCT_NAME_VPN_SMGR"), NAME_OF_VPN_SERVER_MANAGER, NULL, GetCurrentBuildDate(),
20205 CEDAR_VERSION_BUILD, GetCedarVersionNumber(), NULL, false);
20206 break;
20207
20208 case WM_TIMER:
20209 switch (wParam)
20210 {
20211 case 4:
20212 KillTimer(hWnd, 4);
20213 break;
20214 }
20215 break;
20216
20217 case WM_COMMAND:
20218 switch (wParam)
20219 {
20220 case IDOK:
20221 DisableUpdateUi(sm->Update);
20222
20223 // Connection
20224 i = LvGetSelected(hWnd, L_SETTING);
20225 if (i != INFINITE)
20226 {
20227 tmp = LvGetStr(hWnd, L_SETTING, i, 0);
20228 if (tmp != NULL)
20229 {
20230 SETTING *setting = SmGetSetting(tmp);
20231 if (setting != NULL)
20232 {
20233 SETTING s;
20234
20235 // Record in the registry as the last choice
20236 MsRegWriteStrW(REG_CURRENT_USER, SM_REG_KEY, "Last Select", tmp);
20237
20238 // Copy the configuration
20239 Copy(&s, setting, sizeof(SETTING));
20240 SmConnect(hWnd, &s);
20241 }
20242 Free(tmp);
20243 }
20244 }
20245 break;
20246
20247 case IDCANCEL:
20248 Close(hWnd);
20249 break;
20250
20251 case B_NEW_SETTING:
20252 DisableUpdateUi(sm->Update);
20253
20254 // Add
20255 if (SmAddSettingDlg(hWnd, new_name, sizeof(new_name)))
20256 {
20257 SmRefreshSettingEx(hWnd, new_name);
20258 }
20259 break;
20260
20261 case B_EDIT_SETTING:
20262 DisableUpdateUi(sm->Update);
20263
20264 // Edit
20265 if (SmEditSettingDlg(hWnd))
20266 {
20267 SmWriteSettingList();
20268 SmRefreshSetting(hWnd);
20269 }
20270
20271 break;
20272
20273 case B_DELETE:
20274 DisableUpdateUi(sm->Update);
20275
20276 // Delete
20277 i = LvGetSelected(hWnd, L_SETTING);
20278 if (i != INFINITE)
20279 {
20280 tmp = LvGetStr(hWnd, L_SETTING, i, 0);
20281 if (tmp != NULL)
20282 {
20283 if (MsgBoxEx(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2,
20284 _UU("SM_SETTING_DELETE_MSG"), tmp) == IDYES)
20285 {
20286 SmDeleteSetting(tmp);
20287 SmWriteSettingList();
20288 SmRefreshSetting(hWnd);
20289 }
20290 Free(tmp);
20291 }
20292 }
20293 break;
20294
20295 case B_ABOUT:
20296 // Version information
20297 AboutEx(hWnd, sm->Cedar, _UU("PRODUCT_NAME_VPN_SMGR"), sm->Update);
20298 break;
20299
20300 case B_SECURE_MANAGER:
20301 DisableUpdateUi(sm->Update);
20302
20303 // Smart Card Manager
20304 SmSecureManager(hWnd);
20305 break;
20306
20307 case B_SELECT_SECURE:
20308 DisableUpdateUi(sm->Update);
20309
20310 // Smart card selection
20311 SmSelectSecureId(hWnd);
20312 break;
20313
20314 case B_CERT_TOOL:
20315 DisableUpdateUi(sm->Update);
20316
20317 // Certificate Creation Tool
20318 SmCreateCert(hWnd, NULL, NULL, false, NULL, false);
20319 break;
20320 }
20321
20322 break;
20323
20324 case WM_CLOSE:
20325 // Updater terminate
20326 if (sm->Update != NULL)
20327 {
20328 FreeUpdateUi(sm->Update);
20329 sm->Update = NULL;
20330 }
20331
20332 EndDialog(hWnd, 0);
20333 break;
20334
20335 case WM_NOTIFY:
20336 n = (NMHDR *)lParam;
20337 switch (n->idFrom)
20338 {
20339 case L_SETTING:
20340 switch (n->code)
20341 {
20342 case NM_DBLCLK:
20343 Command(hWnd, IDOK);
20344 break;
20345
20346 case LVN_KEYDOWN:
20347 key = (NMLVKEYDOWN *)n;
20348 if (key != NULL)
20349 {
20350 UINT code = key->wVKey;
20351 switch (code)
20352 {
20353 case VK_F2:
20354 if (LvIsSelected(hWnd, L_SETTING))
20355 {
20356 LvRename(hWnd, L_SETTING, LvGetSelected(hWnd, L_SETTING));
20357 }
20358 break;
20359
20360 case VK_DELETE:
20361 Command(hWnd, B_DELETE);
20362 break;
20363
20364 case VK_RETURN:
20365 Command(hWnd, IDOK);
20366 break;
20367 }
20368 }
20369 break;
20370
20371 case LVN_ENDLABELEDITW:
20372 // Change the name
20373 info = (NMLVDISPINFOW *)n;
20374 if (info->item.pszText != NULL)
20375 {
20376 wchar_t *new_name = info->item.pszText;
20377 wchar_t *old_name = LvGetStr(hWnd, L_SETTING, info->item.iItem, 0);
20378
20379 if (old_name != NULL)
20380 {
20381 if (UniStrCmp(new_name, old_name) != 0 && UniStrLen(new_name) != 0)
20382 {
20383 // Change the name
20384 SETTING *s = SmGetSetting(old_name);
20385 if (s != NULL)
20386 {
20387 if (SmGetSetting(new_name) != NULL)
20388 {
20389 MsgBoxEx(hWnd, MB_ICONEXCLAMATION, _UU("SM_SETTING_EXISTS"),
20390 new_name);
20391 }
20392 else
20393 {
20394 UniStrCpy(s->Title, sizeof(s->Title), new_name);
20395 Sort(sm->SettingList);
20396 SmWriteSettingList();
20397 LvSetItem(hWnd, L_SETTING, info->item.iItem, 0, new_name);
20398 }
20399 }
20400 }
20401
20402 Free(old_name);
20403 }
20404 }
20405 break;
20406
20407 case LVN_ITEMCHANGED:
20408 SmMainDlgUpdate(hWnd);
20409 break;
20410 }
20411 break;
20412 }
20413 break;
20414 }
20415
20416 LvSortHander(hWnd, msg, wParam, lParam, L_SETTING);
20417
20418 return 0;
20419 }
20420
20421 // Main window
SmMainDlg()20422 void SmMainDlg()
20423 {
20424 Dialog(NULL, D_SM_MAIN, SmMainDlgProc, NULL);
20425 }
20426
20427 // Server Manager main process
MainSM()20428 void MainSM()
20429 {
20430 // MsgBoxEx(NULL, 0, L"MsIsWine: %u\n", MsIsWine());
20431
20432 if (sm->TempSetting == NULL)
20433 {
20434 // Open the main window
20435 SmMainDlg();
20436 }
20437 else
20438 {
20439 SmConnect(sm->hParentWnd, sm->TempSetting);
20440 }
20441 }
20442
20443 // Initialize
InitSM()20444 void InitSM()
20445 {
20446 InitSMEx(false);
20447 }
InitSMEx(bool from_cm)20448 void InitSMEx(bool from_cm)
20449 {
20450 if (sm != NULL)
20451 {
20452 // Already initialized
20453 return;
20454 }
20455
20456 sm = ZeroMalloc(sizeof(SM));
20457
20458 if (from_cm == false)
20459 {
20460 InitWinUi(_UU("SM_TITLE"), _SS("DEFAULT_FONT"), _II("DEFAULT_FONT_SIZE"));
20461 }
20462
20463 sm->Cedar = NewCedar(NULL, NULL);
20464
20465 if (from_cm == false)
20466 {
20467 SmInitSettingList();
20468 InitCM(false);
20469
20470 // Interpret the command line
20471 SmParseCommandLine();
20472 }
20473 }
20474
20475 // Interpret the command line
SmParseCommandLine()20476 void SmParseCommandLine()
20477 {
20478 LIST *o;
20479 CONSOLE *c = NewLocalConsole(NULL, NULL);
20480 wchar_t *cmdline;
20481 PARAM args[] =
20482 {
20483 {"[vpnserver]", NULL, NULL, NULL, NULL,},
20484 {"HUB", NULL, NULL, NULL, NULL,},
20485 {"PASSWORD", NULL, NULL, NULL, NULL,},
20486 {"TITLE", NULL, NULL, NULL, NULL,},
20487 {"HWND", NULL, NULL, NULL, NULL,},
20488 };
20489 if (c == NULL)
20490 {
20491 return;
20492 }
20493
20494 cmdline = GetCommandLineUniStr();
20495
20496 if (UniIsEmptyStr(cmdline) == false)
20497 {
20498 o = ParseCommandList(c, "vpnsmgr", cmdline, args, sizeof(args) / sizeof(args[0]));
20499 if (o != NULL)
20500 {
20501 char *host;
20502 UINT port;
20503
20504 if (ParseHostPort(GetParamStr(o, "[vpnserver]"), &host, &port, 443))
20505 {
20506 char *hub = GetParamStr(o, "HUB");
20507 char *password = GetParamStr(o, "PASSWORD");
20508 char *title = GetParamStr(o, "TITLE");
20509 char *hwndstr = GetParamStr(o, "HWND");
20510
20511 if (hub == NULL || StrCmpi(hub, "\"") == 0)
20512 {
20513 hub = CopyStr("");
20514 }
20515 if (password == NULL)
20516 {
20517 password = CopyStr("");
20518 }
20519 if (title == NULL)
20520 {
20521 title = CopyStr(host);
20522 }
20523
20524 if (IsEmptyStr(host) == false)
20525 {
20526 SETTING *s = ZeroMalloc(sizeof(SETTING));
20527 BUF *b;
20528 CLIENT_OPTION *o;
20529
20530 StrToUni(s->Title, sizeof(s->Title), title);
20531
20532 if (IsEmptyStr(hub))
20533 {
20534 s->ServerAdminMode = true;
20535 }
20536 else
20537 {
20538 s->ServerAdminMode = false;
20539 StrCpy(s->HubName, sizeof(s->HubName), hub);
20540 }
20541
20542 b = StrToBin(password);
20543 if (b == NULL || b->Size != SHA1_SIZE)
20544 {
20545 Sha0(s->HashedPassword, password, StrLen(password));
20546 }
20547 else
20548 {
20549 Copy(s->HashedPassword, b->Buf, SHA1_SIZE);
20550 }
20551 FreeBuf(b);
20552
20553 o = &s->ClientOption;
20554
20555 UniStrCpy(o->AccountName, sizeof(o->AccountName), s->Title);
20556 StrCpy(o->Hostname, sizeof(o->Hostname), host);
20557 o->Port = port;
20558 o->ProxyType = PROXY_DIRECT;
20559 StrCpy(o->DeviceName, sizeof(o->DeviceName), "DUMMY");
20560
20561 sm->TempSetting = s;
20562
20563 if (IsEmptyStr(hwndstr) == false)
20564 {
20565 sm->hParentWnd = (HWND)ToInt64(hwndstr);
20566 }
20567 }
20568
20569 Free(hwndstr);
20570 Free(title);
20571 Free(hub);
20572 Free(password);
20573 Free(host);
20574 }
20575 }
20576 }
20577
20578 Free(cmdline);
20579
20580 c->Free(c);
20581 }
20582
20583 // Release
FreeSM()20584 void FreeSM()
20585 {
20586 FreeSMEx(false);
20587 }
FreeSMEx(bool from_cm)20588 void FreeSMEx(bool from_cm)
20589 {
20590 if (sm == NULL)
20591 {
20592 // Uninitialized
20593 return;
20594 }
20595
20596 if (from_cm == false)
20597 {
20598 FreeCM();
20599
20600 SmFreeSettingList();
20601 }
20602
20603 ReleaseCedar(sm->Cedar);
20604
20605 if (from_cm == false)
20606 {
20607 FreeWinUi();
20608 }
20609
20610 if (sm->TempSetting != NULL)
20611 {
20612 Free(sm->TempSetting);
20613 }
20614
20615 Free(sm);
20616 sm = NULL;
20617 }
20618
20619 // Running the Server Manager
SMExec()20620 void SMExec()
20621 {
20622 InitSM();
20623 MainSM();
20624 FreeSM();
20625 }
20626
20627 #endif // WIN32
20628
20629
20630