1 // SoftEther VPN Source Code - Stable Edition Repository
2 // Cedar Communication Module
3 //
4 // SoftEther VPN Server, Client and Bridge are free software under the Apache License, Version 2.0.
5 //
6 // Copyright (c) Daiyuu Nobori.
7 // Copyright (c) SoftEther VPN Project, University of Tsukuba, Japan.
8 // Copyright (c) SoftEther Corporation.
9 // Copyright (c) all contributors on SoftEther VPN project in GitHub.
10 //
11 // All Rights Reserved.
12 //
13 // http://www.softether.org/
14 //
15 // This stable branch is officially managed by Daiyuu Nobori, the owner of SoftEther VPN Project.
16 // Pull requests should be sent to the Developer Edition Master Repository on https://github.com/SoftEtherVPN/SoftEtherVPN
17 //
18 // License: The Apache License, Version 2.0
19 // https://www.apache.org/licenses/LICENSE-2.0
20 //
21 // DISCLAIMER
22 // ==========
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 // SOFTWARE.
31 //
32 // THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN, UNDER
33 // JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY, MERGE, PUBLISH,
34 // DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS SOFTWARE, THAT ANY
35 // JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS SOFTWARE OR ITS CONTENTS,
36 // AGAINST US (SOFTETHER PROJECT, SOFTETHER CORPORATION, DAIYUU NOBORI OR OTHER
37 // SUPPLIERS), OR ANY JURIDICAL DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND
38 // OF USING, COPYING, MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING,
39 // AND/OR SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND
40 // CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO EXCLUSIVE
41 // JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO, JAPAN. YOU MUST WAIVE
42 // ALL DEFENSES OF LACK OF PERSONAL JURISDICTION AND FORUM NON CONVENIENS.
43 // PROCESS MAY BE SERVED ON EITHER PARTY IN THE MANNER AUTHORIZED BY APPLICABLE
44 // LAW OR COURT RULE.
45 //
46 // USE ONLY IN JAPAN. DO NOT USE THIS SOFTWARE IN ANOTHER COUNTRY UNLESS YOU HAVE
47 // A CONFIRMATION THAT THIS SOFTWARE DOES NOT VIOLATE ANY CRIMINAL LAWS OR CIVIL
48 // RIGHTS IN THAT PARTICULAR COUNTRY. USING THIS SOFTWARE IN OTHER COUNTRIES IS
49 // COMPLETELY AT YOUR OWN RISK. THE SOFTETHER VPN PROJECT HAS DEVELOPED AND
50 // DISTRIBUTED THIS SOFTWARE TO COMPLY ONLY WITH THE JAPANESE LAWS AND EXISTING
51 // CIVIL RIGHTS INCLUDING PATENTS WHICH ARE SUBJECTS APPLY IN JAPAN. OTHER
52 // COUNTRIES' LAWS OR CIVIL RIGHTS ARE NONE OF OUR CONCERNS NOR RESPONSIBILITIES.
53 // WE HAVE NEVER INVESTIGATED ANY CRIMINAL REGULATIONS, CIVIL LAWS OR
54 // INTELLECTUAL PROPERTY RIGHTS INCLUDING PATENTS IN ANY OF OTHER 200+ COUNTRIES
55 // AND TERRITORIES. BY NATURE, THERE ARE 200+ REGIONS IN THE WORLD, WITH
56 // DIFFERENT LAWS. IT IS IMPOSSIBLE TO VERIFY EVERY COUNTRIES' LAWS, REGULATIONS
57 // AND CIVIL RIGHTS TO MAKE THE SOFTWARE COMPLY WITH ALL COUNTRIES' LAWS BY THE
58 // PROJECT. EVEN IF YOU WILL BE SUED BY A PRIVATE ENTITY OR BE DAMAGED BY A
59 // PUBLIC SERVANT IN YOUR COUNTRY, THE DEVELOPERS OF THIS SOFTWARE WILL NEVER BE
60 // LIABLE TO RECOVER OR COMPENSATE SUCH DAMAGES, CRIMINAL OR CIVIL
61 // RESPONSIBILITIES. NOTE THAT THIS LINE IS NOT LICENSE RESTRICTION BUT JUST A
62 // STATEMENT FOR WARNING AND DISCLAIMER.
63 //
64 // READ AND UNDERSTAND THE 'WARNING.TXT' FILE BEFORE USING THIS SOFTWARE.
65 // SOME SOFTWARE PROGRAMS FROM THIRD PARTIES ARE INCLUDED ON THIS SOFTWARE WITH
66 // LICENSE CONDITIONS WHICH ARE DESCRIBED ON THE 'THIRD_PARTY.TXT' FILE.
67 //
68 //
69 // SOURCE CODE CONTRIBUTION
70 // ------------------------
71 //
72 // Your contribution to SoftEther VPN Project is much appreciated.
73 // Please send patches to us through GitHub.
74 // Read the SoftEther VPN Patch Acceptance Policy in advance:
75 // http://www.softether.org/5-download/src/9.patch
76 //
77 //
78 // DEAR SECURITY EXPERTS
79 // ---------------------
80 //
81 // If you find a bug or a security vulnerability please kindly inform us
82 // about the problem immediately so that we can fix the security problem
83 // to protect a lot of users around the world as soon as possible.
84 //
85 // Our e-mail address for security reports is:
86 // softether-vpn-security [at] softether.org
87 //
88 // Please note that the above e-mail address is not a technical support
89 // inquiry address. If you need technical assistance, please visit
90 // http://www.softether.org/ and ask your question on the users forum.
91 //
92 // Thank you for your cooperation.
93 //
94 //
95 // NO MEMORY OR RESOURCE LEAKS
96 // ---------------------------
97 //
98 // The memory-leaks and resource-leaks verification under the stress
99 // test has been passed before release this source code.
100
101
102 // EM.c
103 // EtherLogger Manager for Win32
104
105 #include <GlobalConst.h>
106
107 #ifdef WIN32
108
109 #define SM_C
110 #define CM_C
111 #define NM_C
112 #define EM_C
113
114 #define _WIN32_WINNT 0x0502
115 #define WINVER 0x0502
116 #include <winsock2.h>
117 #include <windows.h>
118 #include <wincrypt.h>
119 #include <wininet.h>
120 #include <shlobj.h>
121 #include <commctrl.h>
122 #include <Dbghelp.h>
123 #include <stdio.h>
124 #include <stdlib.h>
125 #include <string.h>
126 #include <wchar.h>
127 #include <stdarg.h>
128 #include <time.h>
129 #include <errno.h>
130 #include <Mayaqua/Mayaqua.h>
131 #include <Cedar/Cedar.h>
132 #include "CMInner.h"
133 #include "SMInner.h"
134 #include "NMInner.h"
135 #include "EMInner.h"
136 #include "../PenCore/resource.h"
137
138
139 // License registration process
EmLicenseAddDlgOnOk(HWND hWnd,RPC * s)140 void EmLicenseAddDlgOnOk(HWND hWnd, RPC *s)
141 {
142 }
143
144 // Shift treatment of text input
EmLicenseAddDlgShiftTextItem(HWND hWnd,UINT id1,UINT id2,UINT * next_focus)145 void EmLicenseAddDlgShiftTextItem(HWND hWnd, UINT id1, UINT id2, UINT *next_focus)
146 {
147 char *s;
148 // Validate arguments
149 if (hWnd == NULL || next_focus == NULL)
150 {
151 return;
152 }
153
154 s = GetTextA(hWnd, id1);
155 if (StrLen(s) >= 6)
156 {
157 char *s2 = CopyStr(s);
158 char tmp[MAX_SIZE];
159 s2[6] = 0;
160 SetTextA(hWnd, id1, s2);
161 Free(s2);
162
163 if (id2 != 0)
164 {
165 GetTxtA(hWnd, id2, tmp, sizeof(tmp));
166
167 StrCat(tmp, sizeof(tmp), s + 6);
168 ReplaceStrEx(tmp, sizeof(tmp), tmp, "-", "", false);
169
170 SetTextA(hWnd, id2, tmp);
171
172 *next_focus = id2;
173 }
174 else
175 {
176 *next_focus = IDOK;
177 }
178 }
179
180 Free(s);
181 }
182
183 // Make a text from the input data
EmLicenseAddDlgGetText(HWND hWnd,char * str,UINT size)184 void EmLicenseAddDlgGetText(HWND hWnd, char *str, UINT size)
185 {
186 char *k1, *k2, *k3, *k4, *k5, *k6;
187 // Validate arguments
188 if (hWnd == NULL || str == NULL)
189 {
190 return;
191 }
192
193 k1 = GetTextA(hWnd, B_KEY1);
194 k2 = GetTextA(hWnd, B_KEY2);
195 k3 = GetTextA(hWnd, B_KEY3);
196 k4 = GetTextA(hWnd, B_KEY4);
197 k5 = GetTextA(hWnd, B_KEY5);
198 k6 = GetTextA(hWnd, B_KEY6);
199
200 Format(str, size, "%s-%s-%s-%s-%s-%s", k1, k2, k3, k4, k5, k6);
201
202 Free(k1);
203 Free(k2);
204 Free(k3);
205 Free(k4);
206 Free(k5);
207 Free(k6);
208 }
209
210 // License addition dialog update
EmLicenseAddDlgUpdate(HWND hWnd,RPC * s)211 void EmLicenseAddDlgUpdate(HWND hWnd, RPC *s)
212 {
213 }
214
215 // License addition dialog initialization
EmLicenseAddDlgInit(HWND hWnd,RPC * s)216 void EmLicenseAddDlgInit(HWND hWnd, RPC *s)
217 {
218 HFONT h;
219 // Validate arguments
220 if (hWnd == NULL || s == NULL)
221 {
222 return;
223 }
224
225 h = GetFont("Arial", 10, true, false, false, false);
226 SetFont(hWnd, B_KEY1, h);
227 SetFont(hWnd, B_KEY2, h);
228 SetFont(hWnd, B_KEY3, h);
229 SetFont(hWnd, B_KEY4, h);
230 SetFont(hWnd, B_KEY5, h);
231 SetFont(hWnd, B_KEY6, h);
232
233 DlgFont(hWnd, S_INFO, 10, true);
234
235 EmLicenseAddDlgUpdate(hWnd, s);
236 }
237
238 // License addition dialog
EmLicenseAddDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)239 UINT EmLicenseAddDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
240 {
241 RPC *s = (RPC *)param;
242 // Validate arguments
243 if (hWnd == NULL)
244 {
245 return 0;
246 }
247
248 switch (msg)
249 {
250 case WM_INITDIALOG:
251 EmLicenseAddDlgInit(hWnd, s);
252 break;
253
254 case WM_COMMAND:
255 switch (LOWORD(wParam))
256 {
257 case B_KEY1:
258 case B_KEY2:
259 case B_KEY3:
260 case B_KEY4:
261 case B_KEY5:
262 case B_KEY6:
263 switch (HIWORD(wParam))
264 {
265 case EN_CHANGE:
266 EmLicenseAddDlgUpdate(hWnd, s);
267
268 switch (LOWORD(wParam))
269 {
270 case B_KEY2:
271 if (GetTextLen(hWnd, B_KEY2, true) == 0)
272 {
273 FocusEx(hWnd, B_KEY1);
274 }
275 break;
276 case B_KEY3:
277 if (GetTextLen(hWnd, B_KEY3, true) == 0)
278 {
279 FocusEx(hWnd, B_KEY2);
280 }
281 break;
282 case B_KEY4:
283 if (GetTextLen(hWnd, B_KEY4, true) == 0)
284 {
285 FocusEx(hWnd, B_KEY3);
286 }
287 break;
288 case B_KEY5:
289 if (GetTextLen(hWnd, B_KEY5, true) == 0)
290 {
291 FocusEx(hWnd, B_KEY4);
292 }
293 break;
294 case B_KEY6:
295 if (GetTextLen(hWnd, B_KEY6, true) == 0)
296 {
297 FocusEx(hWnd, B_KEY5);
298 }
299 break;
300 }
301 break;
302 }
303 break;
304 }
305
306 switch (wParam)
307 {
308 case IDOK:
309 EmLicenseAddDlgOnOk(hWnd, s);
310 break;
311
312 case IDCANCEL:
313 Close(hWnd);
314 break;
315 }
316 break;
317
318 case WM_CLOSE:
319 EndDialog(hWnd, 0);
320 break;
321 }
322
323 return 0;
324 }
325
326 // Add a license
EmLicenseAdd(HWND hWnd,RPC * s)327 bool EmLicenseAdd(HWND hWnd, RPC *s)
328 {
329 // Validate arguments
330 if (s == NULL)
331 {
332 return false;
333 }
334
335 return Dialog(hWnd, D_EM_LICENSE_ADD, EmLicenseAddDlg, s);
336 }
337
338 // License dialog initialization
EmLicenseDlgInit(HWND hWnd,RPC * s)339 void EmLicenseDlgInit(HWND hWnd, RPC *s)
340 {
341 // Validate arguments
342 if (hWnd == NULL || s == NULL)
343 {
344 return;
345 }
346
347 SetIcon(hWnd, 0, ICO_CERT);
348
349 DlgFont(hWnd, S_BOLD, 0, true);
350 DlgFont(hWnd, S_BOLD2, 0, true);
351
352 LvInit(hWnd, L_LIST);
353 LvSetStyle(hWnd, L_LIST, LVS_EX_GRIDLINES);
354 LvInsertColumn(hWnd, L_LIST, 0, _UU("SM_LICENSE_COLUMN_1"), 50);
355 LvInsertColumn(hWnd, L_LIST, 1, _UU("SM_LICENSE_COLUMN_2"), 100);
356 LvInsertColumn(hWnd, L_LIST, 2, _UU("SM_LICENSE_COLUMN_3"), 290);
357 LvInsertColumn(hWnd, L_LIST, 3, _UU("SM_LICENSE_COLUMN_4"), 150);
358 LvInsertColumn(hWnd, L_LIST, 4, _UU("SM_LICENSE_COLUMN_5"), 120);
359 LvInsertColumn(hWnd, L_LIST, 5, _UU("SM_LICENSE_COLUMN_6"), 250);
360 LvInsertColumn(hWnd, L_LIST, 6, _UU("SM_LICENSE_COLUMN_7"), 100);
361 LvInsertColumn(hWnd, L_LIST, 7, _UU("SM_LICENSE_COLUMN_8"), 100);
362 LvInsertColumn(hWnd, L_LIST, 8, _UU("SM_LICENSE_COLUMN_9"), 100);
363
364 LvInitEx(hWnd, L_STATUS, true);
365 LvInsertColumn(hWnd, L_STATUS, 0, _UU("SM_STATUS_COLUMN_1"), 100);
366 LvInsertColumn(hWnd, L_STATUS, 1, _UU("SM_STATUS_COLUMN_2"), 100);
367
368 EmLicenseDlgRefresh(hWnd, s);
369 }
370
371 // License dialog update
EmLicenseDlgRefresh(HWND hWnd,RPC * s)372 void EmLicenseDlgRefresh(HWND hWnd, RPC *s)
373 {
374 RPC_ENUM_LICENSE_KEY t;
375 RPC_EL_LICENSE_STATUS st;
376 UINT i;
377 wchar_t tmp[MAX_SIZE];
378 LVB *b;
379 // Validate arguments
380 if (hWnd == NULL || s == NULL)
381 {
382 return;
383 }
384
385 Zero(&t, sizeof(t));
386
387 if (CALL(hWnd, EcEnumLicenseKey(s, &t)) == false)
388 {
389 Close(hWnd);
390 return;
391 }
392
393 b = LvInsertStart();
394
395 for (i = 0;i < t.NumItem;i++)
396 {
397 wchar_t tmp1[32], tmp2[LICENSE_KEYSTR_LEN + 1], tmp3[LICENSE_MAX_PRODUCT_NAME_LEN + 1],
398 *tmp4, tmp5[128], tmp6[LICENSE_LICENSEID_STR_LEN + 1], tmp7[64],
399 tmp8[64], tmp9[64];
400 RPC_ENUM_LICENSE_KEY_ITEM *e = &t.Items[i];
401
402 UniToStru(tmp1, e->Id);
403 StrToUni(tmp2, sizeof(tmp2), e->LicenseKey);
404 StrToUni(tmp3, sizeof(tmp3), e->LicenseName);
405 tmp4 = LiGetLicenseStatusStr(e->Status);
406 if (e->Expires == 0)
407 {
408 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_LICENSE_NO_EXPIRES"));
409 }
410 else
411 {
412 GetDateStrEx64(tmp5, sizeof(tmp5), e->Expires, NULL);
413 }
414 StrToUni(tmp6, sizeof(tmp6), e->LicenseId);
415 UniToStru(tmp7, e->ProductId);
416 UniFormat(tmp8, sizeof(tmp8), L"%I64u", e->SystemId);
417 UniToStru(tmp9, e->SerialId);
418
419 LvInsertAdd(b,
420 e->Status == LICENSE_STATUS_OK ? ICO_PASS : ICO_DISCARD,
421 (void *)e->Id, 9,
422 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9);
423 }
424
425 LvInsertEnd(b, hWnd, L_LIST);
426
427 FreeRpcEnumLicenseKey(&t);
428
429 Zero(&st, sizeof(st));
430
431 if (CALL(hWnd, EcGetLicenseStatus(s, &st)) == false)
432 {
433 Close(hWnd);
434 return;
435 }
436
437 b = LvInsertStart();
438
439 if (st.Valid == false)
440 {
441 LvInsertAdd(b, 0, NULL, 2, _UU("EM_NO_LICENSE_COLUMN"), _UU("EM_NO_LICENSE"));
442 }
443 else
444 {
445 // Current system ID
446 UniFormat(tmp, sizeof(tmp), L"%I64u", st.SystemId);
447 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_SYSTEM_ID"), tmp);
448
449 // Expiration date of the current license product
450 if (st.SystemExpires == 0)
451 {
452 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_NO_EXPIRES"));
453 }
454 else
455 {
456 GetDateStrEx64(tmp, sizeof(tmp), st.SystemExpires, NULL);
457 }
458 LvInsertAdd(b, 0, NULL, 2, _UU("SM_LICENSE_STATUS_EXPIRES"), tmp);
459 }
460
461 LvInsertEnd(b, hWnd, L_STATUS);
462
463 if (LvNum(hWnd, L_STATUS) >= 1)
464 {
465 LvAutoSize(hWnd, L_STATUS);
466 }
467
468 EmLicenseDlgUpdate(hWnd, s);
469 }
470
471 // License dialog control update
EmLicenseDlgUpdate(HWND hWnd,RPC * s)472 void EmLicenseDlgUpdate(HWND hWnd, RPC *s)
473 {
474 bool b = false;
475 // Validate arguments
476 if (hWnd == NULL || s == NULL)
477 {
478 return;
479 }
480
481 b = LvIsSingleSelected(hWnd, L_LIST);
482
483 SetEnable(hWnd, B_DEL, b);
484 SetEnable(hWnd, IDOK, b);
485 }
486
487 // License dialog
EmLicenseDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)488 UINT EmLicenseDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
489 {
490 RPC *s = (RPC *)param;
491 NMHDR *n;
492 // Validate arguments
493 if (hWnd == NULL)
494 {
495 return 0;
496 }
497
498 switch (msg)
499 {
500 case WM_INITDIALOG:
501 EmLicenseDlgInit(hWnd, s);
502 break;
503
504 case WM_NOTIFY:
505 n = (NMHDR *)lParam;
506 switch (n->code)
507 {
508 case LVN_ITEMCHANGED:
509 switch (n->idFrom)
510 {
511 case L_LIST:
512 case L_STATUS:
513 EmLicenseDlgUpdate(hWnd, s);
514 break;
515 }
516 break;
517 }
518 break;
519
520 case WM_COMMAND:
521 switch (wParam)
522 {
523 case IDOK:
524 if (IsEnable(hWnd, IDOK))
525 {
526 UINT i = LvGetSelected(hWnd, L_LIST);
527
528 if (i != INFINITE)
529 {
530 char *s = LvGetStrA(hWnd, L_LIST, i, 5);
531 char tmp[MAX_SIZE];
532
533 Format(tmp, sizeof(tmp), _SS("LICENSE_SUPPORT_URL"), s);
534 ShellExecute(hWnd, "open", tmp, NULL, NULL, SW_SHOW);
535
536 Free(s);
537 }
538 }
539 break;
540
541 case B_OBTAIN:
542 ShellExecute(hWnd, "open", _SS("LICENSE_INFO_URL"), NULL, NULL, SW_SHOW);
543 break;
544
545 case B_ADD:
546 if (EmLicenseAdd(hWnd, s))
547 {
548 EmLicenseDlgRefresh(hWnd, s);
549 }
550 break;
551
552 case B_DEL:
553 if (IsEnable(hWnd, B_DEL))
554 {
555 UINT id = (UINT)LvGetParam(hWnd, L_LIST, LvGetSelected(hWnd, L_LIST));
556
557 if (id != 0)
558 {
559 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, _UU("SM_LICENSE_DELETE_MSG")) == IDYES)
560 {
561 RPC_TEST t;
562
563 Zero(&t, sizeof(t));
564 t.IntValue = id;
565
566 if (CALL(hWnd, EcDelLicenseKey(s, &t)))
567 {
568 EmLicenseDlgRefresh(hWnd, s);
569 }
570 }
571 }
572 }
573 break;
574
575 case IDCANCEL:
576 Close(hWnd);
577 break;
578 }
579 break;
580
581 case WM_CLOSE:
582 EndDialog(hWnd, 0);
583 break;
584 }
585
586 LvStandardHandler(hWnd, msg, wParam, lParam, L_LIST);
587
588 return 0;
589 }
590
591
592
593
594
595 // Change Password dialog
EmPasswordDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)596 UINT EmPasswordDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
597 {
598 RPC *r = (RPC *)param;
599 char pass1[MAX_PATH];
600 char pass2[MAX_PATH];
601 UCHAR hash[SHA1_SIZE];
602 RPC_SET_PASSWORD t;
603 // Validate arguments
604 if (hWnd == NULL)
605 {
606 return 0;
607 }
608
609 switch (msg)
610 {
611 case WM_INITDIALOG:
612 Focus(hWnd, E_PASSWORD1);
613 break;
614
615 case WM_COMMAND:
616 switch (wParam)
617 {
618 case IDOK:
619 GetTxtA(hWnd, E_PASSWORD1, pass1, sizeof(pass1));
620 Hash(hash, pass1, StrLen(pass1), true);
621 Zero(&t, sizeof(t));
622 Copy(t.HashedPassword, hash, SHA1_SIZE);
623 if (CALL(hWnd, EcSetPassword(r, &t)) == false)
624 {
625 break;
626 }
627 MsgBox(hWnd, MB_ICONINFORMATION, _UU("CM_PASSWORD_SET"));
628 EndDialog(hWnd, 1);
629 break;
630
631 case IDCANCEL:
632 Close(hWnd);
633 break;
634 }
635
636 switch (LOWORD(wParam))
637 {
638 case E_PASSWORD1:
639 case E_PASSWORD2:
640 GetTxtA(hWnd, E_PASSWORD1, pass1, sizeof(pass1));
641 GetTxtA(hWnd, E_PASSWORD2, pass2, sizeof(pass2));
642 SetEnable(hWnd, IDOK, StrCmp(pass1, pass2) == 0 ? true : false);
643 break;
644 }
645 break;
646
647 case WM_CLOSE:
648 EndDialog(hWnd, 0);
649 break;
650 }
651
652 return 0;
653 }
654
655 // Copy the state of the dialog to the HUB_LOG
EmDlgToHubLog(HWND hWnd,HUB_LOG * g)656 void EmDlgToHubLog(HWND hWnd, HUB_LOG *g)
657 {
658 // Validate arguments
659 if (hWnd == NULL || g == NULL)
660 {
661 return;
662 }
663
664 Zero(g, sizeof(HUB_LOG));
665 g->PacketLogSwitchType = CbGetSelect(hWnd, C_PACKET_SWITCH);
666 g->PacketLogConfig[0] = IsChecked(hWnd, B_PACKET_0_0) ? 0 : IsChecked(hWnd, B_PACKET_0_1) ? 1 : 2;
667 g->PacketLogConfig[1] = IsChecked(hWnd, B_PACKET_1_0) ? 0 : IsChecked(hWnd, B_PACKET_1_1) ? 1 : 2;
668 g->PacketLogConfig[2] = IsChecked(hWnd, B_PACKET_2_0) ? 0 : IsChecked(hWnd, B_PACKET_2_1) ? 1 : 2;
669 g->PacketLogConfig[3] = IsChecked(hWnd, B_PACKET_3_0) ? 0 : IsChecked(hWnd, B_PACKET_3_1) ? 1 : 2;
670 g->PacketLogConfig[4] = IsChecked(hWnd, B_PACKET_4_0) ? 0 : IsChecked(hWnd, B_PACKET_4_1) ? 1 : 2;
671 g->PacketLogConfig[5] = IsChecked(hWnd, B_PACKET_5_0) ? 0 : IsChecked(hWnd, B_PACKET_5_1) ? 1 : 2;
672 g->PacketLogConfig[6] = IsChecked(hWnd, B_PACKET_6_0) ? 0 : IsChecked(hWnd, B_PACKET_6_1) ? 1 : 2;
673 g->PacketLogConfig[7] = IsChecked(hWnd, B_PACKET_7_0) ? 0 : IsChecked(hWnd, B_PACKET_7_1) ? 1 : 2;
674 }
675
676 // Copy the HUB_LOG to the state of the dialog
EmHubLogToDlg(HWND hWnd,HUB_LOG * g)677 void EmHubLogToDlg(HWND hWnd, HUB_LOG *g)
678 {
679 // Validate arguments
680 if (hWnd == NULL || g == NULL)
681 {
682 return;
683 }
684
685 CbSelect(hWnd, C_PACKET_SWITCH, g->PacketLogSwitchType);
686
687 Check(hWnd, B_PACKET_0_0, g->PacketLogConfig[0] == 0);
688 Check(hWnd, B_PACKET_0_1, g->PacketLogConfig[0] == 1);
689 Check(hWnd, B_PACKET_0_2, g->PacketLogConfig[0] == 2);
690
691 Check(hWnd, B_PACKET_1_0, g->PacketLogConfig[1] == 0);
692 Check(hWnd, B_PACKET_1_1, g->PacketLogConfig[1] == 1);
693 Check(hWnd, B_PACKET_1_2, g->PacketLogConfig[1] == 2);
694
695 Check(hWnd, B_PACKET_2_0, g->PacketLogConfig[2] == 0);
696 Check(hWnd, B_PACKET_2_1, g->PacketLogConfig[2] == 1);
697 Check(hWnd, B_PACKET_2_2, g->PacketLogConfig[2] == 2);
698
699 Check(hWnd, B_PACKET_3_0, g->PacketLogConfig[3] == 0);
700 Check(hWnd, B_PACKET_3_1, g->PacketLogConfig[3] == 1);
701 Check(hWnd, B_PACKET_3_2, g->PacketLogConfig[3] == 2);
702
703 Check(hWnd, B_PACKET_4_0, g->PacketLogConfig[4] == 0);
704 Check(hWnd, B_PACKET_4_1, g->PacketLogConfig[4] == 1);
705 Check(hWnd, B_PACKET_4_2, g->PacketLogConfig[4] == 2);
706
707 Check(hWnd, B_PACKET_5_0, g->PacketLogConfig[5] == 0);
708 Check(hWnd, B_PACKET_5_1, g->PacketLogConfig[5] == 1);
709 Check(hWnd, B_PACKET_5_2, g->PacketLogConfig[5] == 2);
710
711 Check(hWnd, B_PACKET_6_0, g->PacketLogConfig[6] == 0);
712 Check(hWnd, B_PACKET_6_1, g->PacketLogConfig[6] == 1);
713 Check(hWnd, B_PACKET_6_2, g->PacketLogConfig[6] == 2);
714
715 Check(hWnd, B_PACKET_7_0, g->PacketLogConfig[7] == 0);
716 Check(hWnd, B_PACKET_7_1, g->PacketLogConfig[7] == 1);
717 Check(hWnd, B_PACKET_7_2, g->PacketLogConfig[7] == 2);
718 }
719
720 // Initialize
EmAddInit(HWND hWnd,EM_ADD * p)721 void EmAddInit(HWND hWnd, EM_ADD *p)
722 {
723 // Validate arguments
724 if (hWnd == NULL || p == NULL)
725 {
726 return;
727 }
728
729 // Initialize controls
730 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_0"), 0);
731 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_1"), 1);
732 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_2"), 2);
733 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_3"), 3);
734 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_4"), 4);
735 CbAddStr(hWnd, C_PACKET_SWITCH, _UU("SM_LOG_SWITCH_5"), 5);
736
737 if (p->NewMode)
738 {
739 // Newly creation mode
740 RPC_ENUM_DEVICE t;
741 HUB_LOG g;
742
743 Zero(&g, sizeof(g));
744 g.PacketLogSwitchType = LOG_SWITCH_DAY;
745 g.PacketLogConfig[PACKET_LOG_TCP_CONN] = g.PacketLogConfig[PACKET_LOG_DHCP] = 1;
746
747 EmHubLogToDlg(hWnd, &g);
748
749 Zero(&t, sizeof(t));
750 if (CALL(hWnd, EcEnumAllDevice(p->Rpc, &t)))
751 {
752 UINT i;
753 CbSetHeight(hWnd, C_DEVICE, 18);
754
755 for (i = 0;i < t.NumItem;i++)
756 {
757 RPC_ENUM_DEVICE_ITEM *dev = &t.Items[i];
758 wchar_t tmp[MAX_SIZE];
759
760 StrToUni(tmp, sizeof(tmp), dev->DeviceName);
761
762 CbAddStr(hWnd, C_DEVICE, tmp, 0);
763 }
764
765 FreeRpcEnumDevice(&t);
766 }
767
768 SetText(hWnd, 0, _UU("EM_ADD_NEW"));
769 }
770 else
771 {
772 // Edit mode (to obtain a configuration)
773 wchar_t tmp[MAX_PATH];
774 RPC_ADD_DEVICE t;
775 Hide(hWnd, R_PROMISCUS);
776
777 Zero(&t, sizeof(t));
778 StrCpy(t.DeviceName, sizeof(t.DeviceName), p->DeviceName);
779
780 if (CALL(hWnd, EcGetDevice(p->Rpc, &t)))
781 {
782 EmHubLogToDlg(hWnd, &t.LogSetting);
783 }
784 else
785 {
786 Close(hWnd);
787 }
788
789 StrToUni(tmp, sizeof(tmp), p->DeviceName);
790 CbAddStr(hWnd, C_DEVICE, tmp, 0);
791
792 Disable(hWnd, C_DEVICE);
793
794 SetText(hWnd, 0, _UU("EM_ADD_EDIT"));
795 }
796
797 EmAddUpdate(hWnd, p);
798 }
799
800 // [OK] button
EmAddOk(HWND hWnd,EM_ADD * p)801 void EmAddOk(HWND hWnd, EM_ADD *p)
802 {
803 RPC_ADD_DEVICE t;
804 wchar_t *tmp;
805 char *name;
806 // Validate arguments
807 if (hWnd == NULL || p == NULL)
808 {
809 return;
810 }
811
812 Zero(&t, sizeof(t));
813 EmDlgToHubLog(hWnd, &t.LogSetting);
814 tmp = CbGetStr(hWnd, C_DEVICE);
815 name = CopyUniToStr(tmp);
816
817 StrCpy(t.DeviceName, sizeof(t.DeviceName), name);
818
819 if (p->NewMode)
820 {
821 t.NoPromiscus = IsChecked(hWnd, R_PROMISCUS);
822 }
823
824 if (p->NewMode)
825 {
826 if (CALL(hWnd, EcAddDevice(p->Rpc, &t)))
827 {
828 Close(hWnd);
829 }
830 }
831 else
832 {
833 if (CALL(hWnd, EcSetDevice(p->Rpc, &t)))
834 {
835 Close(hWnd);
836 }
837 }
838
839 Free(name);
840 Free(tmp);
841 }
842
843 // Control update
EmAddUpdate(HWND hWnd,EM_ADD * p)844 void EmAddUpdate(HWND hWnd, EM_ADD *p)
845 {
846 wchar_t *tmp;
847 char *name;
848 // Validate arguments
849 if (hWnd == NULL || p == NULL)
850 {
851 return;
852 }
853
854 tmp = CbGetStr(hWnd, C_DEVICE);
855 name = CopyUniToStr(tmp);
856
857 Trim(name);
858
859 if (StrLen(name) == 0)
860 {
861 Disable(hWnd, IDOK);
862 }
863 else
864 {
865 Enable(hWnd, IDCANCEL);
866 }
867
868 Free(name);
869 Free(tmp);
870 }
871
872 // Device Add / Edit dialog
EmAddDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)873 UINT EmAddDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
874 {
875 EM_ADD *p = (EM_ADD *)param;
876 // Validate arguments
877 if (hWnd == NULL)
878 {
879 return 0;
880 }
881
882 switch (msg)
883 {
884 case WM_INITDIALOG:
885 EmAddInit(hWnd, p);
886 break;
887
888 case WM_COMMAND:
889 EmAddUpdate(hWnd, p);
890 switch (wParam)
891 {
892 case IDOK:
893 EmAddOk(hWnd, p);
894 break;
895
896 case IDCANCEL:
897 Close(hWnd);
898 break;
899 }
900 break;
901
902 case WM_CLOSE:
903 EndDialog(hWnd, 0);
904 break;
905 }
906
907 return 0;
908 }
909
910 // Add or edit
EmAdd(HWND hWnd,RPC * r,char * device_name)911 void EmAdd(HWND hWnd, RPC *r, char *device_name)
912 {
913 EM_ADD p;
914 // Validate arguments
915 if (hWnd == NULL || r == NULL)
916 {
917 return;
918 }
919
920 Zero(&p, sizeof(p));
921
922 p.Rpc = r;
923
924 if (device_name != NULL)
925 {
926 StrCpy(p.DeviceName, sizeof(p.DeviceName), device_name);
927 }
928 else
929 {
930 p.NewMode = true;
931 }
932
933 Dialog(hWnd, D_EM_ADD, EmAddDlg, &p);
934 }
935
936 // Initialize
EmMainInit(HWND hWnd,RPC * r)937 void EmMainInit(HWND hWnd, RPC *r)
938 {
939 // Validate arguments
940 if (hWnd == NULL || r == NULL)
941 {
942 return;
943 }
944
945 LvInit(hWnd, L_LIST);
946 LvInsertColumn(hWnd, L_LIST, 0, _UU("EM_MAIN_COLUMN_1"), 300);
947 LvInsertColumn(hWnd, L_LIST, 1, _UU("EM_MAIN_COLUMN_2"), 150);
948
949 SetIcon(hWnd, 0, ICO_NIC_ONLINE);
950
951 EmMainRefresh(hWnd, r);
952
953 SetTimer(hWnd, 1, 1000, NULL);
954 }
955
956 // Control update
EmMainUpdate(HWND hWnd,RPC * r)957 void EmMainUpdate(HWND hWnd, RPC *r)
958 {
959 // Validate arguments
960 if (hWnd == NULL || r == NULL)
961 {
962 return;
963 }
964
965 SetEnable(hWnd, IDOK, LvIsMasked(hWnd, L_LIST) && LvIsMultiMasked(hWnd, L_LIST) == false);
966 SetEnable(hWnd, B_DELETE, LvIsMasked(hWnd, L_LIST) && LvIsMultiMasked(hWnd, L_LIST) == false);
967 }
968
969 // Update
EmMainRefresh(HWND hWnd,RPC * r)970 void EmMainRefresh(HWND hWnd, RPC *r)
971 {
972 RPC_ENUM_DEVICE t;
973 // Validate arguments
974 if (hWnd == NULL || r == NULL)
975 {
976 return;
977 }
978
979 Zero(&t, sizeof(t));
980
981 if (CALL(hWnd, EcEnumDevice(r, &t)))
982 {
983 UINT i;
984 LVB *b;
985
986 b = LvInsertStart();
987
988 for (i = 0;i < t.NumItem;i++)
989 {
990 wchar_t tmp[MAX_PATH];
991 RPC_ENUM_DEVICE_ITEM *dev = &t.Items[i];
992
993 StrToUni(tmp, sizeof(tmp), dev->DeviceName);
994
995 LvInsertAdd(b,
996 dev->Active ? ICO_NIC_ONLINE : ICO_NIC_OFFLINE,
997 NULL,
998 2,
999 tmp,
1000 dev->Active ? _UU("EM_MAIN_OK") : _UU("EM_MAIN_ERROR"));
1001 }
1002
1003 LvInsertEnd(b, hWnd, L_LIST);
1004
1005 FreeRpcEnumDevice(&t);
1006
1007 SetShow(hWnd, B_LICENSE, t.IsLicenseSupported);
1008 }
1009 else
1010 {
1011 Close(hWnd);
1012 }
1013
1014 EmMainUpdate(hWnd, r);
1015 }
1016
1017 // Main dialog procedure
EmMainDlg(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1018 UINT EmMainDlg(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1019 {
1020 NMHDR *n;
1021 RPC *r = (RPC *)param;
1022 UINT i;
1023 char *name;
1024 // Validate arguments
1025 if (hWnd == NULL)
1026 {
1027 return 0;
1028 }
1029
1030 switch (msg)
1031 {
1032 case WM_INITDIALOG:
1033 EmMainInit(hWnd, r);
1034 break;
1035
1036 case WM_COMMAND:
1037 switch (wParam)
1038 {
1039 case IDOK:
1040 // Edit
1041 i = LvGetSelected(hWnd, L_LIST);
1042 if (i != INFINITE)
1043 {
1044 wchar_t *tmp;
1045 tmp = LvGetStr(hWnd, L_LIST, i, 0);
1046 if (tmp != NULL)
1047 {
1048 name = CopyUniToStr(tmp);
1049 EmAdd(hWnd, r, name);
1050 Free(tmp);
1051 Free(name);
1052 }
1053 }
1054 break;
1055
1056 case B_PASSWORD:
1057 // Admin password
1058 Dialog(hWnd, D_EM_PASSWORD, EmPasswordDlg, r);
1059 break;
1060
1061 case B_LICENSE:
1062 // Admin password
1063 Dialog(hWnd, D_EM_LICENSE, EmLicenseDlg, r);
1064 break;
1065
1066 case B_ADD:
1067 // Add
1068 EmAdd(hWnd, r, NULL);
1069 EmMainRefresh(hWnd, r);
1070 break;
1071
1072 case B_DELETE:
1073 // Delete
1074 i = LvGetSelected(hWnd, L_LIST);
1075 if (i != INFINITE)
1076 {
1077 wchar_t *tmp;
1078 tmp = LvGetStr(hWnd, L_LIST, i, 0);
1079 if (tmp != NULL)
1080 {
1081 RPC_DELETE_DEVICE t;
1082 wchar_t msg[MAX_SIZE];
1083 name = CopyUniToStr(tmp);
1084 UniFormat(msg, sizeof(msg), _UU("EM_DELETE_CONFIRM"), name);
1085 if (MsgBox(hWnd, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2, msg) == IDYES)
1086 {
1087 Zero(&t, sizeof(t));
1088 StrCpy(t.DeviceName, sizeof(t.DeviceName), name);
1089 if (CALL(hWnd, EcDelDevice(r, &t)))
1090 {
1091 EmMainRefresh(hWnd, r);
1092 }
1093 }
1094 Free(tmp);
1095 Free(name);
1096 }
1097 }
1098 break;
1099
1100 case IDCANCEL:
1101 Close(hWnd);
1102 break;
1103 }
1104 break;
1105
1106 case WM_TIMER:
1107 switch (wParam)
1108 {
1109 case 1:
1110 KillTimer(hWnd, 1);
1111 EmMainRefresh(hWnd, r);
1112 SetTimer(hWnd, 1, 1000, NULL);
1113 break;
1114 }
1115 break;
1116
1117 case WM_NOTIFY:
1118 n = (NMHDR *)lParam;
1119 switch (n->code)
1120 {
1121 case NM_DBLCLK:
1122 switch (n->idFrom)
1123 {
1124 case L_LIST:
1125 if (IsEnable(hWnd, IDOK))
1126 {
1127 Command(hWnd, IDOK);
1128 }
1129 break;
1130 }
1131 break;
1132 case LVN_ITEMCHANGED:
1133 switch (n->idFrom)
1134 {
1135 case L_LIST:
1136 EmMainUpdate(hWnd, r);
1137 break;
1138 }
1139 break;
1140 }
1141 break;
1142
1143 case WM_CLOSE:
1144 EndDialog(hWnd, 0);
1145 break;
1146 }
1147
1148 return 0;
1149 }
1150
1151 // Installation of WinPcap
EmInstallWinPcap(HWND hWnd,RPC * r)1152 void EmInstallWinPcap(HWND hWnd, RPC *r)
1153 {
1154 wchar_t temp_name[MAX_SIZE];
1155 HGLOBAL g;
1156 HINSTANCE h;
1157 HRSRC hr;
1158 UINT size;
1159 void *data;
1160 IO *io;
1161
1162 // Ask whether the user want to start the installation
1163 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("EM_WPCAP_INSTALL")) == IDNO)
1164 {
1165 return;
1166 }
1167
1168 // Generate a temporary file name
1169 UniFormat(temp_name, sizeof(temp_name), L"%s\\winpcap_installer.exe", MsGetTempDirW());
1170
1171 // Read from the resource
1172 h = GetUiDll();
1173 hr = FindResource(h, MAKEINTRESOURCE(BIN_WINPCAP), "BIN");
1174 if (hr == NULL)
1175 {
1176 RES_ERROR:
1177 MsgBox(hWnd, MB_ICONSTOP, _UU("EM_RESOURCE"));
1178 return;
1179 }
1180
1181 g = LoadResource(h, hr);
1182 if (g == NULL)
1183 {
1184 goto RES_ERROR;
1185 }
1186
1187 size = SizeofResource(h, hr);
1188 data = LockResource(g);
1189
1190 if (data == NULL)
1191 {
1192 goto RES_ERROR;
1193 }
1194
1195 // Write to a temporary file
1196 io = FileCreateW(temp_name);
1197 if (io == NULL)
1198 {
1199 goto RES_ERROR;
1200 }
1201
1202 FileWrite(io, data, size);
1203 FileClose(io);
1204
1205 // Run
1206 if (RunW(temp_name, NULL, false, true) == false)
1207 {
1208 // Failure
1209 FileDeleteW(temp_name);
1210 goto RES_ERROR;
1211 }
1212
1213 FileDeleteW(temp_name);
1214
1215 if (r == NULL)
1216 {
1217 return;
1218 }
1219
1220 // Message after the end
1221 if (OS_IS_WINDOWS_NT(GetOsInfo()->OsType) == false)
1222 {
1223 // Need to restart the computer
1224 MsgBox(hWnd, MB_ICONINFORMATION, _UU("EM_WPCAP_REBOOT1"));
1225 }
1226 else
1227 {
1228 // Need to restart the service
1229 if (MsgBox(hWnd, MB_ICONQUESTION | MB_YESNO, _UU("EM_WPCAP_REBOOT2")) == IDNO)
1230 {
1231 // Not restart
1232 }
1233 else
1234 {
1235 // Restart
1236 RPC_TEST t;
1237 RPC_BRIDGE_SUPPORT t2;
1238 Zero(&t, sizeof(t));
1239 EcRebootServer(r, &t);
1240
1241 SleepThread(500);
1242
1243 Zero(&t2, sizeof(t2));
1244 CALL(hWnd, EcGetBridgeSupport(r, &t2));
1245 }
1246 }
1247 }
1248
1249 // Main screen
EMMain(RPC * r)1250 void EMMain(RPC *r)
1251 {
1252 RPC_BRIDGE_SUPPORT t;
1253
1254 // Validate arguments
1255 if (r == NULL)
1256 {
1257 return;
1258 }
1259
1260 // Examine the bridge support status of the server side first
1261 Zero(&t, sizeof(t));
1262 if (CALLEX(NULL, ScGetBridgeSupport(r, &t)) == ERR_NO_ERROR)
1263 {
1264 if (t.IsBridgeSupportedOs == false)
1265 {
1266 // OS does not support the bridge
1267 MsgBox(NULL, MB_ICONEXCLAMATION, _UU("EM_UNSUPPORTED"));
1268 return;
1269 }
1270
1271 if (t.IsWinPcapNeeded)
1272 {
1273 if (r->Sock->RemoteIP.addr[0] != 127)
1274 {
1275 // WinPcap is required, but can not do anything because it is in remote management mode
1276 MsgBox(NULL, MB_ICONINFORMATION, _UU("EM_WPCAP_REMOTE"));
1277 return;
1278 }
1279 else
1280 {
1281 // WinPcap is required, and it's in local management mode
1282 if (MsIsAdmin())
1283 {
1284 // Administrators
1285 EmInstallWinPcap(NULL, r);
1286 return;
1287 }
1288 else
1289 {
1290 // Non-Administrators
1291 MsgBox(NULL, MB_ICONINFORMATION, _UU("EM_WPCAP_ROOT"));
1292 return;
1293 }
1294 }
1295 }
1296 }
1297
1298 Dialog(NULL, D_EM_MAIN, EmMainDlg, r);
1299 }
1300
1301 // Remote connection dialog procedure
EmRemoteDlgProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam,void * param)1302 UINT EmRemoteDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam, void *param)
1303 {
1304 WINUI_REMOTE *r = (WINUI_REMOTE *)param;
1305 CEDAR *c;
1306 // Validate arguments
1307 if (hWnd == NULL)
1308 {
1309 return 0;
1310 }
1311
1312 switch (msg)
1313 {
1314 case WM_INITDIALOG:
1315 RemoteDlgInit(hWnd, r);
1316 SetTimer(hWnd, 1, 100, NULL);
1317 break;
1318 case WM_TIMER:
1319 switch (wParam)
1320 {
1321 case 1:
1322 KillTimer(hWnd, 1);
1323 RemoteDlgRefresh(hWnd, r);
1324 SetTimer(hWnd, 1, 100, NULL);
1325 break;
1326 }
1327 break;
1328 case WM_COMMAND:
1329 switch (wParam)
1330 {
1331 case R_LOCAL:
1332 if (IsChecked(hWnd, R_LOCAL) == false)
1333 {
1334 SetTextA(hWnd, C_HOSTNAME, "");
1335 RemoteDlgRefresh(hWnd, r);
1336 FocusEx(hWnd, C_HOSTNAME);
1337 }
1338 else
1339 {
1340 SetTextA(hWnd, C_HOSTNAME, "localhost");
1341 RemoteDlgRefresh(hWnd, r);
1342 Focus(hWnd, IDOK);
1343 }
1344 break;
1345 case IDCANCEL:
1346 Close(hWnd);
1347 break;
1348 case IDOK:
1349 RemoteDlgOnOk(hWnd, r);
1350 break;
1351 case B_ABOUT:
1352 c = NewCedar(NULL, NULL);
1353 About(hWnd, c, _UU("PRODUCT_NAME_ELOGMGR"));
1354 ReleaseCedar(c);
1355 }
1356 switch (LOWORD(wParam))
1357 {
1358 case R_LOCAL:
1359 case C_HOSTNAME:
1360 RemoteDlgRefresh(hWnd, r);
1361 break;
1362 }
1363 break;
1364 case WM_CLOSE:
1365 FreeCandidateList(r->CandidateList);
1366 EndDialog(hWnd, false);
1367 break;
1368 }
1369
1370 return 0;
1371 }
1372
1373 // Remote connection dialog
EmRemoteDlg()1374 char *EmRemoteDlg()
1375 {
1376 WINUI_REMOTE r;
1377
1378 Zero(&r, sizeof(r));
1379 r.RegKeyName = EM_REG_KEY;
1380 r.Caption = _UU("EM_TITLE");
1381 r.Title = _UU("EM_REMOTE_TITLE");
1382 r.Icon = ICO_USER_ADMIN;
1383 r.DefaultHostname = NULL;
1384
1385 if (Dialog(NULL, D_EM_REMOTE, EmRemoteDlgProc, &r) == false)
1386 {
1387 return NULL;
1388 }
1389
1390 return r.Hostname;
1391 }
1392
1393 // Start the EtherLogger Manager
EMExec()1394 void EMExec()
1395 {
1396 char *host;
1397 char *ret;
1398 bool cancel_now = false;
1399 TOKEN_LIST *t;
1400 UINT port = EL_ADMIN_PORT;
1401 InitWinUi(_UU("EM_TITLE"), _SS("DEFAULT_FONT"), _II("DEFAULT_FONT_SIZE"));
1402
1403 while (true)
1404 {
1405 ret = EmRemoteDlg();
1406
1407 if (ret != NULL)
1408 {
1409 t = ParseToken(ret, ":");
1410 if (t->NumTokens == 1 || t->NumTokens == 2)
1411 {
1412 RPC *rpc = NULL;
1413 bool ok = false;
1414 UINT ret;
1415 host = t->Token[0];
1416 if (t->NumTokens == 2)
1417 {
1418 port = ToInt(t->Token[1]);
1419 }
1420 else
1421 {
1422 port = EL_ADMIN_PORT;
1423 }
1424
1425 // Try without a password first
1426 ret = EcConnect(host, port, "", &rpc);
1427 RETRY:
1428 if (ret != ERR_NO_ERROR && ret != ERR_AUTH_FAILED)
1429 {
1430 // Connection failed
1431 CALL(NULL, ret);
1432 }
1433 else
1434 {
1435 if (ret == ERR_NO_ERROR)
1436 {
1437 // Successful connection
1438 ok = true;
1439 }
1440 else
1441 {
1442 // Password required
1443 char *pass = SmPassword(NULL, host);
1444 if (pass == NULL)
1445 {
1446 // Cancel
1447 cancel_now = true;
1448 }
1449 else
1450 {
1451 // Retry
1452 ret = EcConnect(host, port, pass, &rpc);
1453 Free(pass);
1454 if (ret == ERR_NO_ERROR)
1455 {
1456 ok = true;
1457 }
1458 else
1459 {
1460 goto RETRY;
1461 }
1462 }
1463 }
1464 }
1465
1466 if (ok)
1467 {
1468 // Main screen
1469 EMMain(rpc);
1470
1471 // Disconnect
1472 EcDisconnect(rpc);
1473 cancel_now = true;
1474 }
1475 FreeToken(t);
1476 }
1477 Free(ret);
1478 }
1479 else
1480 {
1481 cancel_now = true;
1482 }
1483
1484 if (cancel_now)
1485 {
1486 break;
1487 }
1488 }
1489
1490 FreeWinUi();
1491 }
1492
1493 #endif // WIN32
1494