1 // SoftEther UT-VPN SourceCode
\r
3 // Copyright (C) 2004-2010 SoftEther Corporation.
\r
4 // Copyright (C) 2004-2010 University of Tsukuba, Japan.
\r
5 // Copyright (C) 2003-2010 Daiyuu Nobori.
\r
6 // All Rights Reserved.
\r
8 // http://utvpn.tsukuba.ac.jp/
\r
10 // This program is free software; you can redistribute it and/or
\r
11 // modify it under the terms of the GNU General Public License
\r
12 // version 2 as published by the Free Software Foundation.
\r
14 // This program is distributed in the hope that it will be useful,
\r
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
17 // GNU General Public License for more details.
\r
19 // You should have received a copy of the GNU General Public License version 2
\r
20 // along with this program; if not, write to the Free Software
\r
21 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
\r
23 // このファイルは GPL バージョン 2 ライセンスで公開されています。
\r
24 // 誰でもこのファイルの内容を複製、改変したり、改変したバージョンを再配布
\r
25 // することができます。ただし、原著作物を改変した場合は、原著作物の著作権表示
\r
26 // を除去することはできません。改変した著作物を配布する場合は、改変実施者の
\r
27 // 著作権表示を原著作物の著作権表示に付随して記載するようにしてください。
\r
29 // この SoftEther UT-VPN オープンソース・プロジェクトは、日本国の
\r
30 // ソフトイーサ株式会社 (SoftEther Corporation, http://www.softether.co.jp/ )
\r
31 // および筑波大学 (University of Tsukuba, http://www.tsukuba.ac.jp/ ) によって
\r
33 // 本プログラムの配布者は、本プログラムを、業としての利用以外のため、
\r
34 // および、試験または研究のために利用が行われることを想定して配布
\r
36 // SoftEther UT-VPN プロジェクトの Web サイトは http://utvpn.tsukuba.ac.jp/ に
\r
38 // 本ソフトウェアの不具合の修正、機能改良、セキュリティホールの修復などのコード
\r
39 // の改変を行った場合で、その成果物を SoftEther UT-VPN プロジェクトに提出して
\r
40 // いただける場合は、 http://utvpn.tsukuba.ac.jp/ までソースコードを送付して
\r
41 // ください。SoftEther UT-VPN プロジェクトの本体リリースまたはブランチリリース
\r
44 // GPL に基づいて原著作物が提供される本ソフトウェアの改良版を配布、販売する
\r
45 // 場合は、そのソースコードを GPL に基づいて誰にでも開示する義務が生じます。
\r
47 // 本ソフトウェアに関連する著作権、特許権、商標権はソフトイーサ株式会社
\r
48 // (SoftEther Corporation) およびその他の著作権保持者が保有しています。
\r
49 // ソフトイーサ株式会社等はこれらの権利を放棄していません。本ソフトウェアの
\r
50 // 二次著作物を配布、販売する場合は、これらの権利を侵害しないようにご注意
\r
53 // お願い: どのような通信ソフトウェアにも通常は必ず未発見の
\r
54 // セキュリティホールが潜んでいます。本ソースコードをご覧いただいた結果、
\r
55 // UT-VPN にセキュリティホールを発見された場合は、当該セキュリティホールの
\r
56 // 情報を不特定多数に開示される前に、必ず、ソフトイーサ株式会社
\r
57 // および脆弱性情報の届出を受け付ける公的機関まで通報いただき、
\r
58 // 公益保護にご協力いただきますようお願い申し上げます。
\r
60 // ソフトイーサ株式会社は、当該セキュリティホールについて迅速に対処を
\r
61 // 行い、UT-VPN および UT-VPN に関連するソフトウェアのユーザー・顧客
\r
64 // ソフトイーサへの届出先: http://www.softether.co.jp/jp/contact/
\r
65 // 日本国内の脆弱性情報届出受付公的機関:
\r
67 // http://www.ipa.go.jp/security/vuln/report/
\r
69 // 上記各事項について不明な点は、ソフトイーサ株式会社までご連絡ください。
\r
70 // 連絡先: http://www.softether.co.jp/jp/contact/
\r
72 // -----------------------------------------------
\r
75 // 新規リリース by SoftEther
\r
76 // -----------------------------------------------
\r
79 // vpncmd コマンドライン管理ユーティリティ
\r
81 #include "CedarPch.h"
\r
84 typedef bool (CHECKER_PROC_DEF)();
\r
85 typedef struct CHECKER_PROC
\r
88 CHECKER_PROC_DEF *Proc;
\r
91 static CHECKER_PROC checker_procs[] =
\r
93 {"CHECK_PROC_KERNEL", CheckKernel},
\r
94 {"CHECK_PROC_MEMORY", CheckMemory},
\r
95 {"CHECK_PROC_STRINGS", CheckStrings},
\r
96 {"CHECK_PROC_FILESYSTEM", CheckFileSystem},
\r
97 {"CHECK_PROC_THREAD", CheckThread},
\r
98 {"CHECK_PROC_NETWORK", CheckNetwork},
\r
101 typedef struct CHECK_NETWORK_1
\r
103 SOCK *ListenSocket;
\r
106 typedef struct CHECK_NETWORK_2
\r
114 // TT_RESULT を RPC に変換
\r
115 void OutRpcTtResult(PACK *p, TT_RESULT *t)
\r
117 if (p == NULL || t == NULL)
\r
122 PackAddBool(p, "Raw", t->Raw);
\r
123 PackAddBool(p, "Double", t->Double);
\r
124 PackAddInt64(p, "NumBytesUpload", t->NumBytesUpload);
\r
125 PackAddInt64(p, "NumBytesDownload", t->NumBytesDownload);
\r
126 PackAddInt64(p, "NumBytesTotal", t->NumBytesTotal);
\r
127 PackAddInt64(p, "Span", t->Span);
\r
128 PackAddInt64(p, "BpsUpload", t->BpsUpload);
\r
129 PackAddInt64(p, "BpsDownload", t->BpsDownload);
\r
130 PackAddInt64(p, "BpsTotal", t->BpsTotal);
\r
133 // RPC を TT_RESULT に変換
\r
134 void InRpcTtResult(PACK *p, TT_RESULT *t)
\r
136 if (p == NULL || t == NULL)
\r
141 Zero(t, sizeof(TT_RESULT));
\r
143 t->Raw = PackGetBool(p, "Raw");
\r
144 t->Double = PackGetBool(p, "Double");
\r
145 t->NumBytesUpload = PackGetInt64(p, "NumBytesUpload");
\r
146 t->NumBytesDownload = PackGetInt64(p, "NumBytesDownload");
\r
147 t->NumBytesTotal = PackGetInt64(p, "NumBytesTotal");
\r
148 t->Span = PackGetInt64(p, "Span");
\r
149 t->BpsUpload = PackGetInt64(p, "BpsUpload");
\r
150 t->BpsDownload = PackGetInt64(p, "BpsDownload");
\r
151 t->BpsTotal = PackGetInt64(p, "BpsTotal");
\r
155 void CheckNetworkAcceptThread(THREAD *thread, void *param)
\r
157 CHECK_NETWORK_2 *c = (CHECK_NETWORK_2 *)param;
\r
161 if (StartSSL(s, c->x, c->k))
\r
166 if (Send(s, &i, sizeof(UINT), true) == 0)
\r
179 void CheckNetworkListenThread(THREAD *thread, void *param)
\r
181 CHECK_NETWORK_1 *c = (CHECK_NETWORK_1 *)param;
\r
186 LIST *o = NewList(NULL);
\r
187 NAME *name = NewName(L"Test", L"Test", L"Test", L"JP", L"Ibaraki", L"Tsukuba");
\r
189 RsaGen(&pri, &pub, 1024);
\r
190 x = NewRootX(pub, pri, name, 1000, NULL);
\r
194 for (i = 1025;;i++)
\r
203 c->ListenSocket = s;
\r
206 NoticeThreadInit(thread);
\r
210 SOCK *new_sock = Accept(s);
\r
212 if (new_sock == NULL)
\r
221 Zero(&c, sizeof(c));
\r
226 t = NewThread(CheckNetworkAcceptThread, &c);
\r
231 for (i = 0;i < LIST_NUM(o);i++)
\r
233 THREAD *t = LIST_DATA(o, i);
\r
234 WaitThread(t, INFINITE);
\r
248 bool CheckNetwork()
\r
252 SOCK *listen_socket;
\r
257 SOCK_EVENT *se = NewSockEvent();
\r
259 Zero(&c, sizeof(c));
\r
260 t = NewThread(CheckNetworkListenThread, &c);
\r
263 listen_socket = c.ListenSocket;
\r
265 port = listen_socket->LocalPort;
\r
268 socks = ZeroMalloc(sizeof(SOCK *) * num);
\r
269 for (i = 0;i < num;i++)
\r
271 socks[i] = Connect("localhost", port);
\r
272 if (socks[i] == NULL)
\r
274 Print("Connect Failed. (%u)\n", i);
\r
279 if (StartSSL(socks[i], NULL, NULL) == false)
\r
281 ReleaseSock(socks[i]);
\r
282 Print("Connect Failed. (%u)\n", i);
\r
288 JoinSockToSockEvent(socks[i], se);
\r
297 bool all_blocked = true;
\r
299 for (i = 0;i < num;i++)
\r
305 ret = Recv(socks[i], &n, sizeof(UINT), true);
\r
308 Print("Recv Failed (Disconnected).\n", ret);
\r
312 if (ret != SOCK_LATER)
\r
314 all_blocked = false;
\r
330 WaitSockEvent(se, INFINITE);
\r
335 for (i = 0;i < num;i++)
\r
337 Disconnect(socks[i]);
\r
338 ReleaseSock(socks[i]);
\r
342 Disconnect(listen_socket);
\r
344 WaitThread(t, INFINITE);
\r
347 ReleaseSock(listen_socket);
\r
349 ReleaseSockEvent(se);
\r
354 typedef struct CHECK_THREAD_1
\r
358 THREAD *wait_thread;
\r
361 static UINT check_thread_global_1 = 0;
\r
363 #define CHECK_THREAD_INCREMENT_COUNT 32
\r
366 void CheckThread1(THREAD *thread, void *param)
\r
368 CHECK_THREAD_1 *ct1 = (CHECK_THREAD_1 *)param;
\r
370 UINT num = CHECK_THREAD_INCREMENT_COUNT;
\r
372 WaitThread(ct1->wait_thread, INFINITE);
\r
374 for (i = 0;i < num;i++)
\r
377 check_thread_global_1 = ct1->num;
\r
378 InputToNull((void *)check_thread_global_1);
\r
379 check_thread_global_1 = check_thread_global_1 + 1 + RetZero();
\r
380 ct1->num = check_thread_global_1;
\r
386 void CheckThread2(THREAD *thread, void *param)
\r
388 EVENT *e = (EVENT *)param;
\r
392 typedef struct CHECK_THREAD_3
\r
398 void CheckThread3(THREAD *thread, void *param)
\r
400 CHECK_THREAD_3 *c = (CHECK_THREAD_3 *)param;
\r
410 t = NewThread(CheckThread3, c);
\r
411 WaitThread(t, INFINITE);
\r
419 CHECK_THREAD_1 ct1;
\r
430 Zero(&ct1, sizeof(ct1));
\r
431 ct1.lock = NewLock();
\r
433 t2 = NewThread(CheckThread2, e);
\r
434 ct1.wait_thread = t2;
\r
436 threads = ZeroMalloc(sizeof(THREAD *) * num);
\r
437 for (i = 0;i < num;i++)
\r
439 threads[i] = NewThread(CheckThread1, &ct1);
\r
440 if (threads[i] == NULL)
\r
442 Print("Thread %u Create Failed.\n", i);
\r
449 for (i = 0;i < num;i++)
\r
451 WaitThread(threads[i], INFINITE);
\r
452 ReleaseThread(threads[i]);
\r
457 if (ct1.num != (num * CHECK_THREAD_INCREMENT_COUNT))
\r
459 Print("Threading: %u != %u\n", ct1.num, num * CHECK_THREAD_INCREMENT_COUNT);
\r
463 DeleteLock(ct1.lock);
\r
465 WaitThread(t2, INFINITE);
\r
472 Zero(&c, sizeof(c));
\r
474 t = NewThread(CheckThread3, &c);
\r
475 WaitThread(t, INFINITE);
\r
480 Print("Threading: %u != %u\n", c.a, num);
\r
488 bool CheckFileSystem()
\r
491 char exe[MAX_PATH];
\r
492 char exe_dir[MAX_PATH];
\r
496 GetExeName(exe, sizeof(exe));
\r
497 GetExeDir(exe_dir, sizeof(exe_dir));
\r
500 dirs = EnumDir(exe_dir);
\r
501 for (i = 0;i < dirs->NumFiles;i++)
\r
503 if (EndWith(exe, dirs->File[i]->FileName))
\r
513 Print("EnumDir Failed.\n");
\r
518 UINT size = 1234567;
\r
522 wchar_t *filename = L"/tmp/vpn_checker_tmp";
\r
524 wchar_t filename[MAX_PATH];
\r
525 CombinePathW(filename, sizeof(filename), MsGetMyTempDirW(), L"vpn_checker_tmp");
\r
528 buf = Malloc(size);
\r
529 for (i = 0;i < size;i++)
\r
534 io = FileCreateW(filename);
\r
537 Print("FileCreate Failed.\n");
\r
543 FileWrite(io, buf, size);
\r
547 io = FileOpenW(filename, false);
\r
548 if (FileSize(io) != 1234567)
\r
550 Print("FileSize Failed.\n");
\r
559 b = ReadDumpW(filename);
\r
561 for (i = 0;i < b->Size;i++)
\r
563 UCHAR c = ((UCHAR *)b->Buf)[i];
\r
565 if (c != (i % 256))
\r
567 Print("FileToBuf Failed.\n");
\r
577 FileDeleteW(filename);
\r
584 bool CheckStrings()
\r
586 wchar_t *numstr = _UU("CHECK_TEST_123456789");
\r
587 char tmp[MAX_SIZE];
\r
588 wchar_t tmp2[MAX_SIZE];
\r
593 UniStrCpy(tmp2, sizeof(tmp2), L"");
\r
596 for (i = 0;i < 64;i++)
\r
599 UniFormat(tmp2, sizeof(tmp2), L"%s,%u", tmp2, i);
\r
602 t = UniParseToken(tmp2, L",");
\r
606 for (i = 0;i < t->NumTokens;i++)
\r
608 wchar_t *s = t->Token[i];
\r
609 UINT n = UniToInt(s);
\r
618 Print("UniParseToken Failed.\n");
\r
622 if (UniToInt(numstr) != 123456789)
\r
624 Print("UniToInt Failed.\n");
\r
628 UniToStr(tmp, sizeof(tmp), numstr);
\r
629 if (ToInt(tmp) != 123456789)
\r
631 Print("UniToStr Failed.\n");
\r
635 StrToUni(tmp2, sizeof(tmp2), _SS("CHECK_TEST_TESTSTR"));
\r
636 if (UniStrCmp(_UU("CHECK_TEST_TESTSTR"), tmp2) != 0)
\r
638 Print("StrToUni Failed.\n");
\r
639 printf("[%S] [%S]\n", tmp2, _UU("CHECK_TEST_TESTSTR"));
\r
643 ReplaceStrEx(tmp, sizeof(tmp), _SS("CHECK_TEST_REPLACE1"), _SS("CHECK_TEST_REPLACE3"),
\r
644 _SS("CHECK_TEST_REPLACE4"), false);
\r
646 if (StrCmp(tmp, _SS("CHECK_TEST_REPLACE2")) != 0)
\r
648 Print("ReplaceStrEx Failed.\n");
\r
652 UniReplaceStrEx(tmp2, sizeof(tmp2), _UU("CHECK_TEST_REPLACE1"), _UU("CHECK_TEST_REPLACE3"),
\r
653 _UU("CHECK_TEST_REPLACE4"), false);
\r
655 if (UniStrCmp(tmp2, _UU("CHECK_TEST_REPLACE2")) != 0)
\r
657 Print("UniReplaceStrEx Failed.\n");
\r
667 UINT i, num, size, j;
\r
674 pp = ZeroMalloc(sizeof(void *) * num);
\r
675 for (i = 0;i < num;i++)
\r
677 pp[i] = ZeroMalloc(size);
\r
678 InputToNull(pp[i]);
\r
679 for (j = 0;j < size;j++)
\r
681 ((UCHAR *)pp[i])[j] = j % 256;
\r
686 for (i = 0;i < num;i++)
\r
688 pp[i] = ReAlloc(pp[i], size);
\r
689 for (j = old_size;j < size;j++)
\r
691 InputToNull((void *)(UINT)(((UCHAR *)pp[i])[j] = j % 256));
\r
694 for (i = 0;i < num;i++)
\r
696 for (j = 0;j < size;j++)
\r
698 if (((UCHAR *)pp[i])[j] != (j % 256))
\r
711 void InputToNull(void *p)
\r
714 if (RetZero() == 1)
\r
716 UCHAR *c = (UCHAR *)p;
\r
725 if (g_debug == 0x123455)
\r
740 UINT64 s = Tick64();
\r
741 UINT64 t = Tick64();
\r
743 for (i = 0;i < num;i++)
\r
745 UINT64 q = Tick64();
\r
748 Print("Tick64 #1 Failed.\n");
\r
757 t = (Tick64() - s);
\r
758 if (t <= 500 || t >= 2000)
\r
760 Print("Tick64 #2 Failed.\n");
\r
765 UINT64 tick1 = Tick64();
\r
767 UINT64 tick2, time2;
\r
772 time2 = LocalTime64();
\r
773 time1 = SystemToLocal64(TickToTime(tick1));
\r
784 if (s <= 500 || s >= 2000)
\r
786 Print("TickToTime Failed.\n");
\r
795 char exe[MAX_SIZE];
\r
797 GetExeName(exe, sizeof(exe));
\r
803 Print("fork Failed.\n");
\r
809 char *param = UNIX_ARG_EXIT;
\r
812 args = ZeroMalloc(sizeof(char *) * 3);
\r
823 signal(SIGHUP, SIG_IGN);
\r
830 int status = 0, ret;
\r
833 ret = waitpid(pid, &status, 0);
\r
835 if (WIFEXITED(status) == 0)
\r
838 Print("waitpid Failed: 0x%x\n", ret);
\r
854 UniPrint(_UU("CHECK_TITLE"));
\r
855 UniPrint(_UU("CHECK_NOTE"));
\r
856 for (i = 0;i < sizeof(checker_procs) / sizeof(checker_procs[0]);i++)
\r
860 CHECKER_PROC *p = &checker_procs[i];
\r
862 title = _UU(p->Title);
\r
864 UniPrint(_UU("CHECK_EXEC_TAG"), title);
\r
873 UniPrint(L" %s\n", ret ? _UU("CHECK_PASS") : _UU("CHECK_FAIL"));
\r
879 UniPrint(L"%s\n\n", _UU("CHECK_RESULT_1"));
\r
883 UniPrint(L"%s\n\n", _UU("CHECK_RESULT_2"));
\r
891 UINT PtCheck(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
894 UINT ret = ERR_NO_ERROR;
\r
896 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
899 return ERR_INVALID_PARAMETER;
\r
902 if (SystemCheck() == false)
\r
904 ret = ERR_INTERNAL_ERROR;
\r
907 FreeParamValueList(o);
\r
913 void PtMain(PT *pt)
\r
915 char prompt[MAX_SIZE];
\r
916 wchar_t tmp[MAX_SIZE];
\r
923 // 起動が完了したメッセージを表示する
\r
924 UniFormat(tmp, sizeof(tmp), _UU("CMD_UTVPNCMD_TOOLS_CONNECTED"));
\r
925 pt->Console->Write(pt->Console, tmp);
\r
926 pt->Console->Write(pt->Console, L"");
\r
933 {"About", PsAbout},
\r
934 {"MakeCert", PtMakeCert},
\r
935 {"TrafficClient", PtTrafficClient},
\r
936 {"TrafficServer", PtTrafficServer},
\r
937 {"Check", PtCheck},
\r
941 StrCpy(prompt, sizeof(prompt), "VPN Tools>");
\r
943 if (DispatchNextCmdEx(pt->Console, pt->CmdLine, prompt, cmd, sizeof(cmd) / sizeof(cmd[0]), pt) == false)
\r
947 pt->LastError = pt->Console->RetCode;
\r
949 if (pt->LastError == ERR_NO_ERROR && pt->Console->ConsoleType != CONSOLE_CSV)
\r
951 pt->Console->Write(pt->Console, _UU("CMD_MSG_OK"));
\r
952 pt->Console->Write(pt->Console, L"");
\r
955 if (pt->CmdLine != NULL)
\r
962 // VPN Tools コンテキストの作成
\r
963 PT *NewPt(CONSOLE *c, wchar_t *cmdline)
\r
972 if (UniIsEmptyStr(cmdline))
\r
977 pt = ZeroMalloc(sizeof(PT));
\r
979 pt->CmdLine = CopyUniStr(cmdline);
\r
984 // VPN Tools コンテキストの解放
\r
985 void FreePt(PT *pt)
\r
998 UINT PtConnect(CONSOLE *c, wchar_t *cmdline)
\r
1005 return ERR_INTERNAL_ERROR;
\r
1008 pt = NewPt(c, cmdline);
\r
1012 ret = pt->LastError;
\r
1019 // vpncmd コマンドの起動パス情報の初期化
\r
1020 void VpnCmdInitBootPath()
\r
1023 char exe_path[MAX_PATH];
\r
1024 char tmp[MAX_PATH];
\r
1025 GetExeName(exe_path, sizeof(exe_path));
\r
1027 if (SearchStrEx(exe_path, "ham.exe", 0, false) != INFINITE || SearchStrEx(exe_path, "ham_x64.exe", 0, false) != INFINITE || SearchStrEx(exe_path, "ham_ia64.exe", 0, false) != INFINITE)
\r
1036 // 現在インストールされている vpncmd のバージョンの取得
\r
1037 current_ver = MsRegReadInt(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_VER);
\r
1039 if ((CEDAR_BUILD >= current_ver) ||
\r
1040 MsRegIsValue(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_PATH) == false)
\r
1042 char *src_filename;
\r
1044 // vpncmdsys.exe を system32 にコピーする
\r
1047 Format(tmp, sizeof(tmp), "%s\\utvpncmd.exe", MsGetSystem32Dir());
\r
1051 Format(tmp, sizeof(tmp), "%s\\utvpncmd.exe", MsGetWindowsDir());
\r
1054 src_filename = VPNCMD_BOOTSTRAP_FILENAME;
\r
1058 src_filename = VPNCMD_BOOTSTRAP_FILENAME_X64;
\r
1063 src_filename = VPNCMD_BOOTSTRAP_FILENAME_IA64;
\r
1068 if (MsIs64BitWindows() == false || Is64())
\r
1070 if (IsFile(tmp) == false || (CEDAR_BUILD > current_ver) || MsRegIsValue(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_PATH) == false)
\r
1072 b = FileCopy(src_filename, tmp);
\r
1079 wow = MsDisableWow64FileSystemRedirection();
\r
1083 if (IsFile(tmp) == false || (CEDAR_BUILD > current_ver) || MsRegIsValue(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_PATH) == false)
\r
1085 b = FileCopy(src_filename, tmp);
\r
1089 MsRestoreWow64FileSystemRedirection(wow);
\r
1093 if (IsFile(tmp) == false || (CEDAR_BUILD > current_ver) || MsRegIsValue(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_PATH) == false)
\r
1095 b = FileCopy(src_filename, tmp);
\r
1100 // 現在実行しているプロンプトのほうがバージョンが新しいのでレジストリを上書きする
\r
1101 if (MsIs64BitWindows() == false)
\r
1103 MsRegWriteStr(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_PATH, exe_path);
\r
1104 MsRegWriteInt(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_VER, CEDAR_BUILD);
\r
1108 MsRegWriteStrEx2(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_PATH, exe_path, true, false);
\r
1109 MsRegWriteIntEx2(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_VER, CEDAR_BUILD, true, false);
\r
1111 MsRegWriteStrEx2(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_PATH, exe_path, false, true);
\r
1112 MsRegWriteIntEx2(REG_LOCAL_MACHINE, VPNCMD_BOOTSTRAP_REG_KEYNAME, VPNCMD_BOOTSTRAP_REG_VALUENAME_VER, CEDAR_BUILD, false, true);
\r
1116 #endif // OS_WIN32
\r
1120 void TtPrint(void *param, TT_PRINT_PROC *print_proc, wchar_t *str)
\r
1123 if (print_proc == NULL || str == NULL)
\r
1128 print_proc(param, str);
\r
1132 void TtGenerateRandomData(UCHAR **buf, UINT *size)
\r
1138 if (buf == NULL || size == NULL)
\r
1143 sz = TRAFFIC_BUF_SIZE;
\r
1145 for (i = 0;i < sz;i++)
\r
1147 tmp[i] = rand() % 256;
\r
1149 if (tmp[i] == '!')
\r
1159 // 通信スループット測定サーバーワーカースレッド
\r
1160 void TtsWorkerThread(THREAD *thread, void *param)
\r
1164 UCHAR *send_buf_data, *recv_buf_data;
\r
1165 bool all_sockets_blocked = false;
\r
1169 wchar_t tmp[MAX_SIZE];
\r
1170 bool dont_block_next_time = false;
\r
1171 char *ver_str = TRAFFIC_VER_STR;
\r
1173 if (thread == NULL || param == NULL)
\r
1179 TtGenerateRandomData(&send_buf_data, &buf_size);
\r
1180 TtGenerateRandomData(&recv_buf_data, &buf_size);
\r
1182 tts = (TTS *)param;
\r
1185 tts->SockEvent = NewSockEvent();
\r
1186 AddRef(tts->SockEvent->ref);
\r
1189 tts->TtsSockList = NewList(NULL);
\r
1192 NoticeThreadInit(thread);
\r
1194 o = NewList(NULL);
\r
1196 while (tts->Halt == false)
\r
1199 if (dont_block_next_time == false)
\r
1201 WaitSockEvent(tts->SockEvent, 50);
\r
1203 dont_block_next_time = false;
\r
1205 // 現在登録されているソケットについて処理する
\r
1206 LockList(tts->TtsSockList);
\r
1210 all_sockets_blocked = false;
\r
1212 // すべてのソケットがブロック状態にならない限り
\r
1214 while (all_sockets_blocked == false)
\r
1216 all_sockets_blocked = true;
\r
1218 for (i = 0;i < LIST_NUM(tts->TtsSockList);i++)
\r
1220 UINT ret = SOCK_LATER;
\r
1221 UCHAR *send_data = NULL, *recv_data = NULL;
\r
1222 UINT send_size = 0, recv_size = 0;
\r
1223 TTS_SOCK *ts = LIST_DATA(tts->TtsSockList, i);
\r
1224 bool blocked_for_this_socket = false;
\r
1226 if (ts->SockJoined == false)
\r
1228 JoinSockToSockEvent(ts->Sock, tts->SockEvent);
\r
1229 ts->SockJoined = true;
\r
1232 switch (ts->State)
\r
1236 ret = Send(ts->Sock, ver_str, TRAFFIC_VER_STR_SIZE, false);
\r
1237 if (ret != 0 && ret != SOCK_LATER)
\r
1244 // クライアントから方向を受信する
\r
1245 ret = Recv(ts->Sock, recv_buf_data, buf_size, false);
\r
1246 if (ret != 0 && ret != SOCK_LATER)
\r
1250 // 受信した 1 バイト目にデータの方向が入っている
\r
1251 c = recv_buf_data[0];
\r
1255 // 0 の場合はクライアント -> サーバー
\r
1260 // それ以外の場合はサーバー -> クライアント
\r
1268 ret = Recv(ts->Sock, recv_buf_data, buf_size, false);
\r
1270 if (ret != 0 && ret != SOCK_LATER)
\r
1272 // 受信した 1 バイト目を検査する
\r
1273 UCHAR c = recv_buf_data[0];
\r
1277 // サーバーからクライアントにサイズ情報を通知
\r
1286 ret = Send(ts->Sock, send_buf_data, buf_size, false);
\r
1290 // サーバー -> クライアントにサイズ情報を通知する
\r
1291 tmp64 = Endian64(ts->NumBytes);
\r
1293 Recv(ts->Sock, recv_buf_data, buf_size, false);
\r
1295 if (ts->LastWaitTick == 0 || ts->LastWaitTick <= Tick64())
\r
1297 ret = Send(ts->Sock, &tmp64, sizeof(tmp64), false);
\r
1299 if (ret != SOCK_LATER)
\r
1301 ts->LastWaitTick = Tick64() + 100;
\r
1309 // 切断されたのでこのソケットを削除としてマークする
\r
1312 else if (ret == SOCK_LATER)
\r
1315 blocked_for_this_socket = true;
\r
1316 dont_block_next_time = false;
\r
1320 if (ts->State == 1)
\r
1322 ts->NumBytes += (UINT64)ret;
\r
1326 if (blocked_for_this_socket == false)
\r
1328 all_sockets_blocked = false;
\r
1332 if (LIST_NUM(o) != 0)
\r
1335 // 1 つ以上のソケットが切断された
\r
1336 for (i = 0;i < LIST_NUM(o);i++)
\r
1338 TTS_SOCK *ts = LIST_DATA(o, i);
\r
1340 UniFormat(tmp, sizeof(tmp), _UU("TTS_DISCONNECTED"), ts->Id, ts->Sock->RemoteHostname);
\r
1341 TtPrint(tts->Param, tts->Print, tmp);
\r
1343 Disconnect(ts->Sock);
\r
1344 ReleaseSock(ts->Sock);
\r
1346 Delete(tts->TtsSockList, ts);
\r
1354 if (tts->NewSocketArrived || tts->Halt)
\r
1356 tts->NewSocketArrived = false;
\r
1357 all_sockets_blocked = true;
\r
1358 dont_block_next_time = true;
\r
1362 UnlockList(tts->TtsSockList);
\r
1365 LockList(tts->TtsSockList);
\r
1367 // 残留しているすべてのソケットを解放する
\r
1368 for (i = 0;i < LIST_NUM(tts->TtsSockList);i++)
\r
1370 TTS_SOCK *ts = LIST_DATA(tts->TtsSockList, i);
\r
1372 UniFormat(tmp, sizeof(tmp), _UU("TTS_DISCONNECT"), ts->Id, ts->Sock->RemoteHostname);
\r
1373 TtPrint(tts->Param, tts->Print, tmp);
\r
1375 Disconnect(ts->Sock);
\r
1376 ReleaseSock(ts->Sock);
\r
1381 UnlockList(tts->TtsSockList);
\r
1385 ReleaseList(tts->TtsSockList);
\r
1386 ReleaseSockEvent(tts->SockEvent);
\r
1387 Free(send_buf_data);
\r
1388 Free(recv_buf_data);
\r
1391 // IPv6 用 Accept スレッド
\r
1392 void TtsIPv6AcceptThread(THREAD *thread, void *param)
\r
1394 TTS *tts = (TTS *)param;
\r
1396 if (tts == NULL || param == NULL)
\r
1401 TtsAcceptProc(tts, tts->ListenSocketV6);
\r
1405 void TtsAcceptProc(TTS *tts, SOCK *listen_socket)
\r
1407 wchar_t tmp[MAX_SIZE];
\r
1409 if (tts == NULL || listen_socket == NULL)
\r
1414 while (tts->Halt == false)
\r
1418 s = Accept(listen_socket);
\r
1422 if (tts->Halt == false)
\r
1432 tts->NewSocketArrived = true;
\r
1433 LockList(tts->TtsSockList);
\r
1435 TTS_SOCK *ts = ZeroMalloc(sizeof(TTS_SOCK));
\r
1437 ts->Id = (++tts->IdSeed);
\r
1440 UniFormat(tmp, sizeof(tmp), _UU("TTS_ACCEPTED"), ts->Id,
\r
1441 s->RemoteHostname, s->RemotePort);
\r
1442 TtPrint(tts->Param, tts->Print, tmp);
\r
1444 Insert(tts->TtsSockList, ts);
\r
1445 tts->NewSocketArrived = true;
\r
1447 UnlockList(tts->TtsSockList);
\r
1452 // 通信スループット測定サーバー待機スレッド
\r
1453 void TtsListenThread(THREAD *thread, void *param)
\r
1456 wchar_t tmp[MAX_SIZE];
\r
1458 if (thread == NULL || param == NULL)
\r
1463 tts = (TTS *)param;
\r
1465 tts->ListenSocket = NULL;
\r
1466 tts->ListenSocket = Listen(tts->Port);
\r
1467 tts->ListenSocketV6 = Listen6(tts->Port);
\r
1469 if (tts->ListenSocket == NULL && tts->ListenSocketV6 == NULL)
\r
1472 UniFormat(tmp, sizeof(tmp), _UU("TT_LISTEN_FAILED"), tts->Port);
\r
1473 TtPrint(tts->Param, tts->Print, tmp);
\r
1476 NoticeThreadInit(thread);
\r
1478 tts->ErrorCode = ERR_INTERNAL_ERROR;
\r
1482 UniFormat(tmp, sizeof(tmp), _UU("TTS_LISTEN_STARTED"), tts->Port);
\r
1483 TtPrint(tts->Param, tts->Print, tmp);
\r
1485 if (tts->ListenSocketV6 != NULL)
\r
1487 UniFormat(tmp, sizeof(tmp), _UU("TTS_LISTEN_STARTED_V6"), tts->Port);
\r
1488 TtPrint(tts->Param, tts->Print, tmp);
\r
1492 UniFormat(tmp, sizeof(tmp), _UU("TTS_LISTEN_FAILED_V6"), tts->Port);
\r
1493 TtPrint(tts->Param, tts->Print, tmp);
\r
1496 if (tts->ListenSocket != NULL)
\r
1498 AddRef(tts->ListenSocket->ref);
\r
1500 if (tts->ListenSocketV6 != NULL)
\r
1502 AddRef(tts->ListenSocketV6->ref);
\r
1506 tts->WorkThread = NewThread(TtsWorkerThread, tts);
\r
1507 WaitThreadInit(tts->WorkThread);
\r
1510 NoticeThreadInit(thread);
\r
1512 // IPv6 用 Accept スレッドを準備
\r
1513 tts->IPv6AcceptThread = NULL;
\r
1514 if (tts->ListenSocketV6 != NULL)
\r
1516 tts->IPv6AcceptThread = NewThread(TtsIPv6AcceptThread, tts);
\r
1519 TtsAcceptProc(tts, tts->ListenSocket);
\r
1521 if (tts->IPv6AcceptThread != NULL)
\r
1523 WaitThread(tts->IPv6AcceptThread, INFINITE);
\r
1524 ReleaseThread(tts->IPv6AcceptThread);
\r
1527 TtPrint(tts->Param, tts->Print, _UU("TTS_LISTEN_STOP"));
\r
1529 ReleaseSock(tts->ListenSocket);
\r
1530 ReleaseSock(tts->ListenSocketV6);
\r
1531 SetSockEvent(tts->SockEvent);
\r
1533 // ワーカースレッドの停止を待機する
\r
1534 WaitThread(tts->WorkThread, INFINITE);
\r
1535 ReleaseThread(tts->WorkThread);
\r
1536 ReleaseSockEvent(tts->SockEvent);
\r
1541 wchar_t *GetTtcTypeStr(UINT type)
\r
1545 case TRAFFIC_TYPE_DOWNLOAD:
\r
1546 return _UU("TTC_TYPE_DOWNLOAD");
\r
1548 case TRAFFIC_TYPE_UPLOAD:
\r
1549 return _UU("TTC_TYPE_UPLOAD");
\r
1552 return _UU("TTC_TYPE_FULL");
\r
1557 void TtcPrintSummary(TTC *ttc)
\r
1559 wchar_t tmp[MAX_SIZE];
\r
1560 wchar_t tmp2[MAX_SIZE];
\r
1561 wchar_t *tag = L"%-35s %s";
\r
1568 TtPrint(ttc->Param, ttc->Print, L"");
\r
1569 TtPrint(ttc->Param, ttc->Print, _UU("TTC_SUMMARY_BAR"));
\r
1570 TtPrint(ttc->Param, ttc->Print, _UU("TTC_SUMMARY_TITLE"));
\r
1571 TtPrint(ttc->Param, ttc->Print, L"");
\r
1574 StrToUni(tmp2, sizeof(tmp2), ttc->Host);
\r
1575 UniFormat(tmp, sizeof(tmp), tag, _UU("TTC_SUMMARY_HOST"), tmp2);
\r
1576 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1579 UniToStru(tmp2, ttc->Port);
\r
1580 UniFormat(tmp, sizeof(tmp), tag, _UU("TTC_SUMMARY_PORT"), tmp2);
\r
1581 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1583 // 確立する TCP コネクション数
\r
1584 UniToStru(tmp2, ttc->NumTcp);
\r
1585 UniFormat(tmp, sizeof(tmp), tag, _UU("TTC_SUMMARY_NUMTCP"), tmp2);
\r
1586 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1589 UniFormat(tmp, sizeof(tmp), tag, _UU("TTC_SUMMARY_TYPE"), GetTtcTypeStr(ttc->Type));
\r
1590 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1593 UniFormat(tmp2, sizeof(tmp2), _UU("TTC_SPAN_STR"), (double)(ttc->Span) / 1000.0);
\r
1594 UniFormat(tmp, sizeof(tmp), tag, _UU("TTC_SUMMARY_SPAN"), tmp2);
\r
1595 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1597 // Ethernet フレーム用にデータ補正
\r
1598 UniFormat(tmp, sizeof(tmp), tag, _UU("TTC_SUMMARY_ETHER"), ttc->Raw ? _UU("SEC_NO") : _UU("SEC_YES"));
\r
1599 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1601 // 中継機器の入出力合計スループット計測
\r
1602 UniFormat(tmp, sizeof(tmp), tag, _UU("TTC_SUMMARY_DOUBLE"), ttc->Double ? _UU("SEC_YES") : _UU("SEC_NO"));
\r
1603 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1605 TtPrint(ttc->Param, ttc->Print, _UU("TTC_SUMMARY_BAR"));
\r
1606 TtPrint(ttc->Param, ttc->Print, L"");
\r
1609 // 通信スループット測定クライアントの停止
\r
1610 void StopTtc(TTC *ttc)
\r
1618 TtPrint(ttc->Param, ttc->Print, _UU("TTC_STOPPING"));
\r
1621 SetSockEvent(ttc->SockEvent);
\r
1625 void TtcGenerateResult(TTC *ttc)
\r
1635 res = &ttc->Result;
\r
1637 Zero(res, sizeof(TT_RESULT));
\r
1639 res->Raw = ttc->Raw;
\r
1640 res->Double = ttc->Double;
\r
1641 res->Span = ttc->RealSpan;
\r
1643 for (i = 0;i < LIST_NUM(ttc->ItcSockList);i++)
\r
1645 TTC_SOCK *ts = LIST_DATA(ttc->ItcSockList, i);
\r
1647 if (ts->Download == false)
\r
1650 res->NumBytesUpload += ts->NumBytes;
\r
1655 res->NumBytesDownload += ts->NumBytes;
\r
1659 if (res->Raw == false)
\r
1661 // Ethernet に合わせて補正する
\r
1662 // (1 個の Ethernet フレーム中の最大の TCP ペイロードサイズは 1460 である。)
\r
1663 res->NumBytesDownload = (UINT64)((double)res->NumBytesDownload * 1514.0 / 1460.0);
\r
1664 res->NumBytesUpload = (UINT64)((double)res->NumBytesUpload * 1514.0 / 1460.0);
\r
1667 res->NumBytesTotal = res->NumBytesDownload + res->NumBytesUpload;
\r
1670 if (res->Span != 0)
\r
1672 res->BpsUpload = (UINT64)((double)res->NumBytesUpload * 8.0 / ((double)res->Span / 1000.0));
\r
1673 res->BpsDownload = (UINT64)((double)res->NumBytesDownload * 8.0 / ((double)res->Span / 1000.0));
\r
1678 res->BpsUpload *= 2ULL;
\r
1679 res->BpsDownload *= 2ULL;
\r
1682 res->BpsTotal = res->BpsUpload + res->BpsDownload;
\r
1686 void TtcThread(THREAD *thread, void *param)
\r
1690 wchar_t tmp[MAX_SIZE];
\r
1693 UCHAR *send_buf_data, *recv_buf_data;
\r
1695 if (thread == NULL || param == NULL)
\r
1701 TtGenerateRandomData(&send_buf_data, &buf_size);
\r
1702 TtGenerateRandomData(&recv_buf_data, &buf_size);
\r
1704 ttc = (TTC *)param;
\r
1706 ttc->SockEvent = NewSockEvent();
\r
1707 AddRef(ttc->SockEvent->ref);
\r
1710 NoticeThreadInit(thread);
\r
1712 TtcPrintSummary(ttc);
\r
1714 UniFormat(tmp, sizeof(tmp), _UU("TTC_CONNECT_START"),
\r
1715 ttc->Host, ttc->Port, ttc->NumTcp);
\r
1716 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1718 // クライアントへのすべてのコネクションを確立する
\r
1719 ttc->ItcSockList = NewList(NULL);
\r
1723 for (i = 0;i < ttc->NumTcp;i++)
\r
1726 TTC_SOCK *ts = ZeroMalloc(sizeof(TTC_SOCK));
\r
1730 if (ttc->Type == TRAFFIC_TYPE_DOWNLOAD)
\r
1732 ts->Download = true;
\r
1734 else if (ttc->Type == TRAFFIC_TYPE_UPLOAD)
\r
1736 ts->Download = false;
\r
1740 ts->Download = ((i % 2) == 0) ? true : false;
\r
1743 s = Connect(ttc->Host, ttc->Port);
\r
1747 UniFormat(tmp, sizeof(tmp), _UU("TTC_CONNECT_FAILED"), i + 1);
\r
1748 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1755 char buffer[TRAFFIC_VER_STR_SIZE];
\r
1757 SetTimeout(s, 5000);
\r
1759 Zero(buffer, sizeof(buffer));
\r
1760 if (Recv(s, buffer, sizeof(buffer), false) != sizeof(buffer) || Cmp(buffer, TRAFFIC_VER_STR, TRAFFIC_VER_STR_SIZE) != 0)
\r
1762 TtPrint(ttc->Param, ttc->Print, _UU("TTC_CONNECT_NOT_SERVER"));
\r
1769 UniFormat(tmp, sizeof(tmp), _UU("TTC_CONNECT_OK"), i + 1);
\r
1770 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1772 UniFormat(tmp, sizeof(tmp), _UU("TTC_CONNECT_OK_2"), GetTtcTypeStr(ts->Download ? TRAFFIC_TYPE_DOWNLOAD : TRAFFIC_TYPE_UPLOAD));
\r
1773 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1777 SetTimeout(s, TIMEOUT_INFINITE);
\r
1779 JoinSockToSockEvent(s, ttc->SockEvent);
\r
1782 Insert(ttc->ItcSockList, ts);
\r
1785 Set(ttc->InitedEvent);
\r
1787 if (ttc->StartEvent != NULL)
\r
1789 Wait(ttc->StartEvent, INFINITE);
\r
1795 bool all_sockets_blocked;
\r
1796 bool dont_block_next_time = false;
\r
1797 bool halt_flag = false;
\r
1798 UINT64 start_tick, end_tick;
\r
1799 UINT64 halt_timeout = 0;
\r
1800 wchar_t tmp1[MAX_SIZE], tmp2[MAX_SIZE];
\r
1801 UINT check_clock_seed = 0;
\r
1802 bool halting = false;
\r
1806 start_tick = Tick64();
\r
1807 end_tick = start_tick + ttc->Span;
\r
1810 GetDateTimeStrEx64(tmp1, sizeof(tmp1), SystemToLocal64(TickToTime(start_tick)), NULL);
\r
1811 GetDateTimeStrEx64(tmp2, sizeof(tmp2), SystemToLocal64(TickToTime(end_tick)), NULL);
\r
1812 UniFormat(tmp, sizeof(tmp), _UU("TTC_COMM_START"), tmp1, tmp2);
\r
1813 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1820 if (dont_block_next_time == false)
\r
1822 WaitSockEvent(ttc->SockEvent, 50);
\r
1825 dont_block_next_time = false;
\r
1827 if (ttc->AbnormalTerminated)
\r
1833 if (ttc->Halt || end_tick <= Tick64())
\r
1836 if (halting == false)
\r
1841 TtPrint(ttc->Param, ttc->Print, _UU("TTC_COMM_USER_CANCEL"));
\r
1846 UniFormat(tmp, sizeof(tmp), _UU("TTC_COMM_END"),
\r
1847 (double)ttc->Span / 1000.0);
\r
1848 TtPrint(ttc->Param, ttc->Print, tmp);
\r
1851 ttc->RealSpan = Tick64() - start_tick;
\r
1855 // サーバーからの報告データを待つ
\r
1856 halt_timeout = Tick64() + 60000ULL;
\r
1860 if (halt_timeout != 0)
\r
1864 // すべての TCP コネクションが処理を完了するまで待機する
\r
1865 for (i = 0;i < LIST_NUM(ttc->ItcSockList);i++)
\r
1867 TTC_SOCK *ts = LIST_DATA(ttc->ItcSockList, i);
\r
1869 if (ts->Download == false)
\r
1871 if (ts->ServerUploadReportReceived == false)
\r
1882 TtcGenerateResult(ttc);
\r
1887 if (halt_timeout <= Tick64())
\r
1890 ttc->AbnormalTerminated = true;
\r
1891 ttc->ErrorCode = ERR_PROTOCOL_ERROR;
\r
1897 all_sockets_blocked = false;
\r
1899 // すべてのソケットがブロック状態にならない限り
\r
1901 while (all_sockets_blocked == false)
\r
1903 all_sockets_blocked = true;
\r
1905 for (i = 0;i < LIST_NUM(ttc->ItcSockList);i++)
\r
1907 UINT ret = SOCK_LATER;
\r
1908 TTC_SOCK *ts = LIST_DATA(ttc->ItcSockList, i);
\r
1909 bool blocked_for_this_socket = false;
\r
1912 if (halt_timeout != 0)
\r
1914 if (ts->State != 3 && ts->State != 4)
\r
1916 if (ts->Download == false)
\r
1918 if (ts->State != 0)
\r
1924 ts->ServerUploadReportReceived = true;
\r
1935 switch (ts->State)
\r
1938 // 初期状態: クライアント/サーバー間のデータの流れの
\r
1949 ret = Send(ts->Sock, &c, 1, false);
\r
1951 if (ret != 0 && ret != SOCK_LATER)
\r
1965 // サーバー -> クライアント (ダウンロード)
\r
1966 ret = Recv(ts->Sock, recv_buf_data, buf_size, false);
\r
1970 // クライアント -> サーバー (アップロード)
\r
1971 ret = Send(ts->Sock, send_buf_data, buf_size, false);
\r
1975 // クライアント -> サーバー (アップロード) の送信完了
\r
1977 if (ts->NextSendRequestReportTick == 0 ||
\r
1978 (Tick64() >= ts->NextSendRequestReportTick))
\r
1980 UCHAR suprise[MAX_SIZE];
\r
1983 ts->NextSendRequestReportTick = Tick64() + 200ULL;
\r
1985 for (i = 0;i < sizeof(suprise);i++)
\r
1990 ret = Send(ts->Sock, suprise, sizeof(suprise), false);
\r
1993 ret = Recv(ts->Sock, &tmp64, sizeof(tmp64), false);
\r
1994 if (ret != 0 && ret != SOCK_LATER && ret == sizeof(tmp64))
\r
1996 ts->NumBytes = Endian64(tmp64);
\r
1998 ts->ServerUploadReportReceived = true;
\r
2006 if (Recv(ts->Sock, recv_buf_data, buf_size, false) == SOCK_LATER)
\r
2016 ttc->AbnormalTerminated = true;
\r
2017 ttc->ErrorCode = ERR_PROTOCOL_ERROR;
\r
2018 blocked_for_this_socket = true;
\r
2019 dont_block_next_time = false;
\r
2021 UniFormat(tmp, sizeof(tmp), _UU("TTC_COMM_DISCONNECTED"), ts->Id);
\r
2022 TtPrint(ttc->Param, ttc->Print, tmp);
\r
2024 else if (ret == SOCK_LATER)
\r
2027 blocked_for_this_socket = true;
\r
2028 dont_block_next_time = false;
\r
2034 ts->NumBytes += (UINT64)ret;
\r
2038 if (blocked_for_this_socket == false)
\r
2040 all_sockets_blocked = false;
\r
2046 all_sockets_blocked = true;
\r
2047 dont_block_next_time = true;
\r
2050 if (end_tick <= Tick64())
\r
2052 all_sockets_blocked = true;
\r
2053 dont_block_next_time = true;
\r
2061 TtPrint(ttc->Param, ttc->Print, _UU("TTC_ERROR_ABORTED"));
\r
2062 ttc->ErrorCode = ERR_CONNECT_FAILED;
\r
2066 for (i = 0;i < LIST_NUM(ttc->ItcSockList);i++)
\r
2068 TTC_SOCK *ts = LIST_DATA(ttc->ItcSockList, i);
\r
2070 Disconnect(ts->Sock);
\r
2071 ReleaseSock(ts->Sock);
\r
2075 ReleaseSockEvent(ttc->SockEvent);
\r
2076 ReleaseList(ttc->ItcSockList);
\r
2077 Free(send_buf_data);
\r
2078 Free(recv_buf_data);
\r
2081 // 通信スループット測定クライアントの開始
\r
2082 TTC *NewTtc(char *host, UINT port, UINT numtcp, UINT type, UINT64 span, bool dbl, bool raw, TT_PRINT_PROC *print_proc, void *param)
\r
2084 return NewTtcEx(host, port, numtcp, type, span, dbl, raw, print_proc, param, NULL);
\r
2086 TTC *NewTtcEx(char *host, UINT port, UINT numtcp, UINT type, UINT64 span, bool dbl, bool raw, TT_PRINT_PROC *print_proc, void *param, EVENT *start_event)
\r
2090 ttc = ZeroMalloc(sizeof(TTC));
\r
2091 ttc->InitedEvent = NewEvent();
\r
2093 StrCpy(ttc->Host, sizeof(ttc->Host), host);
\r
2094 ttc->NumTcp = numtcp;
\r
2097 ttc->Double = dbl;
\r
2099 ttc->StartEvent = start_event;
\r
2101 if (ttc->Type == TRAFFIC_TYPE_FULL && ttc->NumTcp < 2)
\r
2106 ttc->Print = print_proc;
\r
2107 ttc->Param = param;
\r
2108 ttc->ErrorCode = ERR_NO_ERROR;
\r
2110 TtPrint(ttc->Param, ttc->Print, _UU("TTC_INIT"));
\r
2112 ttc->Thread = NewThread(TtcThread, ttc);
\r
2113 WaitThreadInit(ttc->Thread);
\r
2118 // 通信スループット測定クライアントの終了を待機
\r
2119 UINT FreeTtc(TTC *ttc, TT_RESULT *result)
\r
2125 return ERR_INVALID_PARAMETER;
\r
2128 WaitThread(ttc->Thread, INFINITE);
\r
2129 ReleaseThread(ttc->Thread);
\r
2131 TtPrint(ttc->Param, ttc->Print, _UU("TTC_FREE"));
\r
2133 ret = ttc->ErrorCode;
\r
2135 if (ret == ERR_NO_ERROR)
\r
2137 if (result != NULL)
\r
2139 Copy(result, &ttc->Result, sizeof(TT_RESULT));
\r
2143 ReleaseSockEvent(ttc->SockEvent);
\r
2144 ReleaseEvent(ttc->InitedEvent);
\r
2151 // 通信スループット測定サーバーの開始
\r
2152 TTS *NewTts(UINT port, void *param, TT_PRINT_PROC *print_proc)
\r
2157 tts = ZeroMalloc(sizeof(TTS));
\r
2159 tts->Param = param;
\r
2160 tts->Print = print_proc;
\r
2162 TtPrint(param, print_proc, _UU("TTS_INIT"));
\r
2165 t = NewThread(TtsListenThread, tts);
\r
2166 WaitThreadInit(t);
\r
2173 // 通信スループット測定サーバーの終了を待機
\r
2174 UINT FreeTts(TTS *tts)
\r
2180 return ERR_INVALID_PARAMETER;
\r
2183 TtPrint(tts->Param, tts->Print, _UU("TTS_STOP_INIT"));
\r
2186 Disconnect(tts->ListenSocket);
\r
2187 ReleaseSock(tts->ListenSocket);
\r
2188 Disconnect(tts->ListenSocketV6);
\r
2189 ReleaseSock(tts->ListenSocketV6);
\r
2192 WaitThread(tts->Thread, INFINITE);
\r
2194 ReleaseThread(tts->Thread);
\r
2196 TtPrint(tts->Param, tts->Print, _UU("TTS_STOP_FINISHED"));
\r
2198 ret = tts->ErrorCode;
\r
2206 void PtTrafficPrintProc(void *param, wchar_t *str)
\r
2210 if (param == NULL || str == NULL)
\r
2215 c = (CONSOLE *)param;
\r
2217 if (c->ConsoleType == CONSOLE_LOCAL)
\r
2219 wchar_t tmp[MAX_SIZE];
\r
2221 // ローカルコンソールの場合のみ表示する (それ以外の場合はマルチスレッドの同期
\r
2222 // がとれないので表示できない?)
\r
2223 UniStrCpy(tmp, sizeof(tmp), str);
\r
2224 if (UniEndWith(str, L"\n") == false)
\r
2226 UniStrCat(tmp, sizeof(tmp), L"\n");
\r
2228 UniPrint(L"%s", tmp);
\r
2233 void TtcPrintResult(CONSOLE *c, TT_RESULT *res)
\r
2236 wchar_t tmp[MAX_SIZE];
\r
2237 wchar_t tmp1[MAX_SIZE];
\r
2238 wchar_t tmp2[MAX_SIZE];
\r
2239 char str[MAX_SIZE];
\r
2241 if (c == NULL || res == NULL)
\r
2246 c->Write(c, _UU("TTC_RES_TITLE"));
\r
2249 CtInsertColumn(ct, _UU("TTC_RES_COLUMN_1"), false);
\r
2250 CtInsertColumn(ct, _UU("TTC_RES_COLUMN_2"), true);
\r
2251 CtInsertColumn(ct, _UU("TTC_RES_COLUMN_3"), true);
\r
2254 GetSpanStrMilli(str, sizeof(str), res->Span);
\r
2255 StrToUni(tmp, sizeof(tmp), str);
\r
2256 CtInsert(ct, _UU("TTC_RES_SPAN"), tmp, L"");
\r
2258 // Ethernet フレーム用にデータ補正
\r
2259 CtInsert(ct, _UU("TTC_RES_ETHER"), res->Raw ? _UU("SEC_NO") : _UU("SEC_YES"), L"");
\r
2261 // ダウンロード方向の通信データ量
\r
2262 ToStr3(str, sizeof(str), res->NumBytesDownload);
\r
2263 UniFormat(tmp1, sizeof(tmp1), L"%S Bytes", str);
\r
2264 ToStrByte1000(str, sizeof(str), res->NumBytesDownload);
\r
2265 StrToUni(tmp2, sizeof(tmp2), str);
\r
2266 CtInsert(ct, _UU("TTC_RES_BYTES_DOWNLOAD"), tmp1, tmp2);
\r
2268 // アップロード方向の通信データ量
\r
2269 ToStr3(str, sizeof(str), res->NumBytesUpload);
\r
2270 UniFormat(tmp1, sizeof(tmp1), L"%S Bytes", str);
\r
2271 ToStrByte1000(str, sizeof(str), res->NumBytesUpload);
\r
2272 StrToUni(tmp2, sizeof(tmp2), str);
\r
2273 CtInsert(ct, _UU("TTC_RES_BYTES_UPLOAD"), tmp1, tmp2);
\r
2276 ToStr3(str, sizeof(str), res->NumBytesTotal);
\r
2277 UniFormat(tmp1, sizeof(tmp1), L"%S Bytes", str);
\r
2278 ToStrByte1000(str, sizeof(str), res->NumBytesTotal);
\r
2279 StrToUni(tmp2, sizeof(tmp2), str);
\r
2280 CtInsert(ct, _UU("TTC_RES_BYTES_TOTAL"), tmp1, tmp2);
\r
2282 // 中継機器入出力合計スループット算出
\r
2283 CtInsert(ct, _UU("TTC_RES_DOUBLE"), (res->Double == false) ? _UU("SEC_NO") : _UU("SEC_YES"), L"");
\r
2285 // ダウンロード方向の平均スループット
\r
2286 ToStr3(str, sizeof(str), res->BpsDownload);
\r
2287 UniFormat(tmp1, sizeof(tmp1), L"%S bps", str);
\r
2288 ToStrByte1000(str, sizeof(str), res->BpsDownload);
\r
2289 ReplaceStr(str, sizeof(str), str, "Bytes", "bps");
\r
2290 StrToUni(tmp2, sizeof(tmp2), str);
\r
2291 CtInsert(ct, _UU("TTC_RES_BPS_DOWNLOAD"), tmp1, tmp2);
\r
2293 // アップロード方向の平均スループット
\r
2294 ToStr3(str, sizeof(str), res->BpsUpload);
\r
2295 UniFormat(tmp1, sizeof(tmp1), L"%S bps", str);
\r
2296 ToStrByte1000(str, sizeof(str), res->BpsUpload);
\r
2297 ReplaceStr(str, sizeof(str), str, "Bytes", "bps");
\r
2298 StrToUni(tmp2, sizeof(tmp2), str);
\r
2299 CtInsert(ct, _UU("TTC_RES_BPS_UPLOAD"), tmp1, tmp2);
\r
2302 ToStr3(str, sizeof(str), res->BpsTotal);
\r
2303 UniFormat(tmp1, sizeof(tmp1), L"%S bps", str);
\r
2304 ToStrByte1000(str, sizeof(str), res->BpsTotal);
\r
2305 ReplaceStr(str, sizeof(str), str, "Bytes", "bps");
\r
2306 StrToUni(tmp2, sizeof(tmp2), str);
\r
2307 CtInsert(ct, _UU("TTC_RES_BPS_TOTAL"), tmp1, tmp2);
\r
2312 // 通信スループット測定ツールサーバーの実行
\r
2313 UINT PtTrafficServer(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2316 UINT ret = ERR_NO_ERROR;
\r
2321 {"[port]", NULL, NULL, NULL, NULL},
\r
2325 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
2328 return ERR_INVALID_PARAMETER;
\r
2331 port = GetParamInt(o, "[port]");
\r
2334 port = TRAFFIC_DEFAULT_PORT;
\r
2337 tts = NewTts(port, c, PtTrafficPrintProc);
\r
2339 c->Write(c, _UU("TTS_ENTER_TO_EXIT"));
\r
2341 Free(c->ReadLine(c, L"", true));
\r
2343 ret = tts->ErrorCode;
\r
2347 if (ret != ERR_NO_ERROR)
\r
2349 CmdPrintError(c, ret);
\r
2353 FreeParamValueList(o);
\r
2358 // 通信スループット測定ツールクライアントの実行
\r
2359 UINT PtTrafficClient(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2363 UINT ret = ERR_NO_ERROR;
\r
2364 char *host = NULL;
\r
2367 bool dbl = false, raw = false;
\r
2370 CMD_EVAL_MIN_MAX minmax =
\r
2372 "CMD_TrafficClient_EVAL_NUMTCP",
\r
2373 0, TRAFFIC_NUMTCP_MAX,
\r
2377 {"[host:port]", CmdPrompt, _UU("CMD_TrafficClient_PROMPT_HOST"), CmdEvalNotEmpty, NULL},
\r
2378 {"NUMTCP", NULL, NULL, CmdEvalMinMax, &minmax},
\r
2379 {"TYPE", NULL, NULL, NULL, NULL},
\r
2380 {"SPAN", NULL, NULL, NULL, NULL},
\r
2381 {"DOUBLE", NULL, NULL, NULL, NULL},
\r
2382 {"RAW", NULL, NULL, NULL, NULL},
\r
2386 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
2389 return ERR_INVALID_PARAMETER;
\r
2392 if (ParseHostPort(GetParamStr(o, "[host:port]"), &host, &port, TRAFFIC_DEFAULT_PORT) == false)
\r
2394 c->Write(c, _UU("CMD_TrafficClient_ERROR_HOSTPORT"));
\r
2395 ret = ERR_INVALID_PARAMETER;
\r
2404 num = GetParamInt(o, "NUMTCP");
\r
2407 num = TRAFFIC_NUMTCP_DEFAULT;
\r
2409 s = GetParamStr(o, "TYPE");
\r
2411 if (StartWith("download", s))
\r
2413 type = TRAFFIC_TYPE_DOWNLOAD;
\r
2415 else if (StartWith("upload", s))
\r
2417 type = TRAFFIC_TYPE_UPLOAD;
\r
2421 type = TRAFFIC_TYPE_FULL;
\r
2424 i = GetParamInt(o, "SPAN");
\r
2428 i = TRAFFIC_SPAN_DEFAULT;
\r
2431 span = (UINT64)i * 1000ULL;
\r
2433 dbl = GetParamYes(o, "DOUBLE");
\r
2434 raw = GetParamYes(o, "RAW");
\r
2436 if (type == TRAFFIC_TYPE_FULL)
\r
2438 if ((num % 2) != 0)
\r
2440 ret = ERR_INVALID_PARAMETER;
\r
2441 c->Write(c, _UU("CMD_TrafficClient_ERROR_NUMTCP"));
\r
2445 if (ret == ERR_NO_ERROR)
\r
2448 ttc = NewTtc(host, port, num, type, span, dbl, raw, PtTrafficPrintProc, c);
\r
2450 if (c->ConsoleType == CONSOLE_LOCAL)
\r
2452 if (c->Param != NULL && (((LOCAL_CONSOLE_PARAM *)c->Param)->InBuf == NULL))
\r
2454 // c->Write(c, _UU("TTC_ENTER_TO_EXIT"));
\r
2455 // GetLine(NULL, 0);
\r
2461 Zero(&result, sizeof(result));
\r
2462 ret = FreeTtc(ttc, &result);
\r
2464 if (ret == ERR_NO_ERROR)
\r
2466 TtcPrintResult(c, &result);
\r
2471 if (ret != ERR_NO_ERROR)
\r
2473 CmdPrintError(c, ret);
\r
2477 FreeParamValueList(o);
\r
2485 UINT PtMakeCert(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2488 UINT ret = ERR_NO_ERROR;
\r
2493 X_SERIAL *x_serial = NULL;
\r
2499 CMD_EVAL_MIN_MAX minmax =
\r
2501 "CMD_MakeCert_EVAL_EXPIRES",
\r
2507 {"CN", CmdPrompt, _UU("CMD_MakeCert_PROMPT_CN"), NULL, NULL},
\r
2508 {"O", CmdPrompt, _UU("CMD_MakeCert_PROMPT_O"), NULL, NULL},
\r
2509 {"OU", CmdPrompt, _UU("CMD_MakeCert_PROMPT_OU"), NULL, NULL},
\r
2510 {"C", CmdPrompt, _UU("CMD_MakeCert_PROMPT_C"), NULL, NULL},
\r
2511 {"ST", CmdPrompt, _UU("CMD_MakeCert_PROMPT_ST"), NULL, NULL},
\r
2512 {"L", CmdPrompt, _UU("CMD_MakeCert_PROMPT_L"), NULL, NULL},
\r
2513 {"SERIAL", CmdPrompt, _UU("CMD_MakeCert_PROMPT_SERIAL"), NULL, NULL},
\r
2514 {"EXPIRES", CmdPrompt, _UU("CMD_MakeCert_PROMPT_EXPIRES"), CmdEvalMinMax, &minmax},
\r
2515 {"SIGNCERT", NULL, NULL, CmdEvalIsFile, NULL},
\r
2516 {"SIGNKEY", NULL, NULL, CmdEvalIsFile, NULL},
\r
2517 {"SAVECERT", CmdPrompt, _UU("CMD_MakeCert_PROMPT_SAVECERT"), CmdEvalNotEmpty, NULL},
\r
2518 {"SAVEKEY", CmdPrompt, _UU("CMD_MakeCert_PROMPT_SAVEKEY"), CmdEvalNotEmpty, NULL},
\r
2522 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
2525 return ERR_INVALID_PARAMETER;
\r
2528 if (IsEmptyStr(GetParamStr(o, "SIGNCERT")) == false && IsEmptyStr(GetParamStr(o, "SIGNKEY")) == false)
\r
2530 root_x = FileToX(GetParamStr(o, "SIGNCERT"));
\r
2531 root_k = FileToK(GetParamStr(o, "SIGNKEY"), true, NULL);
\r
2533 if (root_x == NULL || root_k == NULL || CheckXandK(root_x, root_k) == false)
\r
2535 ret = ERR_INTERNAL_ERROR;
\r
2537 c->Write(c, _UU("CMD_MakeCert_ERROR_SIGNKEY"));
\r
2541 if (ret == ERR_NO_ERROR)
\r
2543 buf = StrToBin(GetParamStr(o, "SERIAL"));
\r
2544 if (buf != NULL && buf->Size >= 1)
\r
2546 x_serial = NewXSerial(buf->Buf, buf->Size);
\r
2550 n = NewName(GetParamUniStr(o, "CN"), GetParamUniStr(o, "O"), GetParamUniStr(o, "OU"),
\r
2551 GetParamUniStr(o, "C"), GetParamUniStr(o, "ST"), GetParamUniStr(o, "L"));
\r
2553 days = GetParamInt(o, "EXPIRES");
\r
2559 RsaGen(&pri, &pub, 1024);
\r
2561 if (root_x == NULL)
\r
2563 x = NewRootX(pub, pri, n, days, x_serial);
\r
2567 x = NewX(pub, root_k, root_x, n, days, x_serial);
\r
2570 FreeXSerial(x_serial);
\r
2575 ret = ERR_INTERNAL_ERROR;
\r
2576 c->Write(c, _UU("CMD_MakeCert_ERROR_GEN_FAILED"));
\r
2580 if (XToFile(x, GetParamStr(o, "SAVECERT"), true) == false)
\r
2582 c->Write(c, _UU("CMD_SAVECERT_FAILED"));
\r
2584 else if (KToFile(pri, GetParamStr(o, "SAVEKEY"), true, NULL) == false)
\r
2586 c->Write(c, _UU("CMD_SAVEKEY_FAILED"));
\r
2591 if (ret != ERR_NO_ERROR)
\r
2594 CmdPrintError(c, ret);
\r
2598 FreeParamValueList(o);
\r
2612 void PcMain(PC *pc)
\r
2614 char prompt[MAX_SIZE];
\r
2615 wchar_t tmp[MAX_SIZE];
\r
2622 // 接続が完了したメッセージを表示する
\r
2623 UniFormat(tmp, sizeof(tmp), _UU("CMD_UTVPNCMD_CLIENT_CONNECTED"),
\r
2625 pc->Console->Write(pc->Console, tmp);
\r
2626 pc->Console->Write(pc->Console, L"");
\r
2633 {"About", PsAbout},
\r
2634 {"Check", PtCheck},
\r
2635 {"VersionGet", PcVersionGet},
\r
2636 {"PasswordSet", PcPasswordSet},
\r
2637 {"PasswordGet", PcPasswordGet},
\r
2638 {"CertList", PcCertList},
\r
2639 {"CertAdd", PcCertAdd},
\r
2640 {"CertDelete", PcCertDelete},
\r
2641 {"CertGet", PcCertGet},
\r
2642 {"SecureList", PcSecureList},
\r
2643 {"SecureSelect", PcSecureSelect},
\r
2644 {"SecureGet", PcSecureGet},
\r
2645 {"NicCreate", PcNicCreate},
\r
2646 {"NicDelete", PcNicDelete},
\r
2647 {"NicUpgrade", PcNicUpgrade},
\r
2648 {"NicGetSetting", PcNicGetSetting},
\r
2649 {"NicSetSetting", PcNicSetSetting},
\r
2650 {"NicEnable", PcNicEnable},
\r
2651 {"NicDisable", PcNicDisable},
\r
2652 {"NicList", PcNicList},
\r
2653 {"AccountList", PcAccountList},
\r
2654 {"AccountCreate", PcAccountCreate},
\r
2655 {"AccountSet", PcAccountSet},
\r
2656 {"AccountGet", PcAccountGet},
\r
2657 {"AccountDelete", PcAccountDelete},
\r
2658 {"AccountUsernameSet", PcAccountUsernameSet},
\r
2659 {"AccountAnonymousSet", PcAccountAnonymousSet},
\r
2660 {"AccountPasswordSet", PcAccountPasswordSet},
\r
2661 {"AccountCertSet", PcAccountCertSet},
\r
2662 {"AccountCertGet", PcAccountCertGet},
\r
2663 {"AccountEncryptDisable", PcAccountEncryptDisable},
\r
2664 {"AccountEncryptEnable", PcAccountEncryptEnable},
\r
2665 {"AccountCompressEnable", PcAccountCompressEnable},
\r
2666 {"AccountCompressDisable", PcAccountCompressDisable},
\r
2667 {"AccountProxyNone", PcAccountProxyNone},
\r
2668 {"AccountProxyHttp", PcAccountProxyHttp},
\r
2669 {"AccountProxySocks", PcAccountProxySocks},
\r
2670 {"AccountServerCertEnable", PcAccountServerCertEnable},
\r
2671 {"AccountServerCertDisable", PcAccountServerCertDisable},
\r
2672 {"AccountServerCertSet", PcAccountServerCertSet},
\r
2673 {"AccountServerCertDelete", PcAccountServerCertDelete},
\r
2674 {"AccountServerCertGet", PcAccountServerCertGet},
\r
2675 {"AccountDetailSet", PcAccountDetailSet},
\r
2676 {"AccountRename", PcAccountRename},
\r
2677 {"AccountConnect", PcAccountConnect},
\r
2678 {"AccountDisconnect", PcAccountDisconnect},
\r
2679 {"AccountStatusGet", PcAccountStatusGet},
\r
2680 {"AccountNicSet", PcAccountNicSet},
\r
2681 {"AccountStatusShow", PcAccountStatusShow},
\r
2682 {"AccountStatusHide", PcAccountStatusHide},
\r
2683 {"AccountSecureCertSet", PcAccountSecureCertSet},
\r
2684 {"AccountRetrySet", PcAccountRetrySet},
\r
2685 {"AccountStartupSet", PcAccountStartupSet},
\r
2686 {"AccountStartupRemove", PcAccountStartupRemove},
\r
2687 {"AccountExport", PcAccountExport},
\r
2688 {"AccountImport", PcAccountImport},
\r
2689 {"RemoteEnable", PcRemoteEnable},
\r
2690 {"RemoteDisable", PcRemoteDisable},
\r
2691 {"KeepEnable", PcKeepEnable},
\r
2692 {"KeepDisable", PcKeepDisable},
\r
2693 {"KeepSet", PcKeepSet},
\r
2694 {"KeepGet", PcKeepGet},
\r
2695 {"MakeCert", PtMakeCert},
\r
2696 {"TrafficClient", PtTrafficClient},
\r
2697 {"TrafficServer", PtTrafficServer},
\r
2701 StrCpy(prompt, sizeof(prompt), "VPN Client>");
\r
2703 if (DispatchNextCmdEx(pc->Console, pc->CmdLine, prompt, cmd, sizeof(cmd) / sizeof(cmd[0]), pc) == false)
\r
2707 pc->LastError = pc->Console->RetCode;
\r
2709 if (pc->LastError == ERR_NO_ERROR && pc->Console->ConsoleType != CONSOLE_CSV)
\r
2711 pc->Console->Write(pc->Console, _UU("CMD_MSG_OK"));
\r
2712 pc->Console->Write(pc->Console, L"");
\r
2715 if (pc->CmdLine != NULL)
\r
2722 // VPN Client サービスのバージョン情報の取得
\r
2723 UINT PcVersionGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2726 PC *pc = (PC *)param;
\r
2727 UINT ret = ERR_NO_ERROR;
\r
2728 RPC_CLIENT_VERSION t;
\r
2731 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
2734 return ERR_INVALID_PARAMETER;
\r
2738 Zero(&t, sizeof(t));
\r
2740 ret = CcGetClientVersion(pc->RemoteClient, &t);
\r
2742 if (ret == ERR_NO_ERROR)
\r
2744 wchar_t tmp[MAX_SIZE];
\r
2748 ct = CtNewStandard();
\r
2750 StrToUni(tmp, sizeof(tmp), t.ClientProductName);
\r
2751 CtInsert(ct, _UU("CMD_VersionGet_1"), tmp);
\r
2753 StrToUni(tmp, sizeof(tmp), t.ClientVersionString);
\r
2754 CtInsert(ct, _UU("CMD_VersionGet_2"), tmp);
\r
2756 StrToUni(tmp, sizeof(tmp), t.ClientBuildInfoString);
\r
2757 CtInsert(ct, _UU("CMD_VersionGet_3"), tmp);
\r
2759 UniToStru(tmp, t.ProcessId);
\r
2760 CtInsert(ct, _UU("CMD_VersionGet_4"), tmp);
\r
2762 StrToUni(tmp, sizeof(tmp), OsTypeToStr(t.OsType));
\r
2763 CtInsert(ct, _UU("CMD_VersionGet_5"), tmp);
\r
2768 if (ret != ERR_NO_ERROR)
\r
2771 CmdPrintError(c, ret);
\r
2775 FreeParamValueList(o);
\r
2780 // VPN Client サービスに接続するためのパスワードの設定
\r
2781 UINT PcPasswordSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2784 PC *pc = (PC *)param;
\r
2785 UINT ret = ERR_NO_ERROR;
\r
2786 RPC_CLIENT_PASSWORD t;
\r
2790 {"[password]", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
2791 {"REMOTEONLY", NULL, NULL, NULL, NULL},
\r
2795 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
2798 return ERR_INVALID_PARAMETER;
\r
2802 Zero(&t, sizeof(t));
\r
2803 StrCpy(t.Password, sizeof(t.Password), GetParamStr(o, "[password]"));
\r
2804 t.PasswordRemoteOnly = GetParamYes(o, "REMOTEONLY");
\r
2806 ret = CcSetPassword(pc->RemoteClient, &t);
\r
2808 if (ret == ERR_NO_ERROR)
\r
2813 if (ret != ERR_NO_ERROR)
\r
2816 CmdPrintError(c, ret);
\r
2820 FreeParamValueList(o);
\r
2825 // VPN Client サービスに接続するためのパスワードの設定の取得
\r
2826 UINT PcPasswordGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2829 PC *pc = (PC *)param;
\r
2830 UINT ret = ERR_NO_ERROR;
\r
2831 RPC_CLIENT_PASSWORD_SETTING t;
\r
2834 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
2837 return ERR_INVALID_PARAMETER;
\r
2841 Zero(&t, sizeof(t));
\r
2843 ret = CcGetPasswordSetting(pc->RemoteClient, &t);
\r
2845 if (ret == ERR_NO_ERROR)
\r
2848 CT *ct = CtNewStandard();
\r
2850 CtInsert(ct, _UU("CMD_PasswordGet_1"),
\r
2851 t.IsPasswordPresented ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
2853 CtInsert(ct, _UU("CMD_PasswordGet_2"),
\r
2854 t.PasswordRemoteOnly ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
2859 if (ret != ERR_NO_ERROR)
\r
2862 CmdPrintError(c, ret);
\r
2866 FreeParamValueList(o);
\r
2871 // 信頼する証明機関の証明書一覧の取得
\r
2872 UINT PcCertList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2875 PC *pc = (PC *)param;
\r
2876 UINT ret = ERR_NO_ERROR;
\r
2877 RPC_CLIENT_ENUM_CA t;
\r
2880 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
2883 return ERR_INVALID_PARAMETER;
\r
2887 Zero(&t, sizeof(t));
\r
2889 ret = CcEnumCa(pc->RemoteClient, &t);
\r
2891 if (ret == ERR_NO_ERROR)
\r
2895 CT *ct = CtNewStandard();
\r
2897 for (i = 0;i < t.NumItem;i++)
\r
2899 wchar_t tmp[MAX_SIZE];
\r
2901 RPC_CLIENT_ENUM_CA_ITEM *e = t.Items[i];
\r
2903 GetDateStrEx64(tmp, sizeof(tmp), SystemToLocal64(e->Expires), NULL);
\r
2905 UniToStru(tmp2, e->Key);
\r
2907 CtInsert(ct, _UU("CMD_CAList_COLUMN_ID"), tmp2);
\r
2908 CtInsert(ct, _UU("CM_CERT_COLUMN_1"), e->SubjectName);
\r
2909 CtInsert(ct, _UU("CM_CERT_COLUMN_2"), e->IssuerName);
\r
2910 CtInsert(ct, _UU("CM_CERT_COLUMN_3"), tmp);
\r
2912 if (i != (t.NumItem - 1))
\r
2914 CtInsert(ct, L"---", L"---");
\r
2920 CiFreeClientEnumCa(&t);
\r
2923 if (ret != ERR_NO_ERROR)
\r
2926 CmdPrintError(c, ret);
\r
2931 FreeParamValueList(o);
\r
2936 // 信頼する証明機関の証明書の追加
\r
2937 UINT PcCertAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2940 PC *pc = (PC *)param;
\r
2941 UINT ret = ERR_NO_ERROR;
\r
2947 {"[path]", CmdPrompt, _UU("CMD_CAAdd_PROMPT_PATH"), CmdEvalIsFile, NULL},
\r
2951 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
2954 return ERR_INVALID_PARAMETER;
\r
2958 x = FileToX(GetParamStr(o, "[path]"));
\r
2962 FreeParamValueList(o);
\r
2963 c->Write(c, _UU("CMD_MSG_LOAD_CERT_FAILED"));
\r
2964 return ERR_INVALID_PARAMETER;
\r
2968 Zero(&t, sizeof(t));
\r
2971 ret = CcAddCa(pc->RemoteClient, &t);
\r
2973 if (ret == ERR_NO_ERROR)
\r
2978 if (ret != ERR_NO_ERROR)
\r
2981 CmdPrintError(c, ret);
\r
2987 FreeParamValueList(o);
\r
2992 // 信頼する証明機関の証明書の削除
\r
2993 UINT PcCertDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
2996 PC *pc = (PC *)param;
\r
2997 UINT ret = ERR_NO_ERROR;
\r
2998 RPC_CLIENT_DELETE_CA t;
\r
3002 {"[id]", CmdPrompt, _UU("CMD_CADelete_PROMPT_ID"), CmdEvalNotEmpty, NULL},
\r
3006 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3009 return ERR_INVALID_PARAMETER;
\r
3013 Zero(&t, sizeof(t));
\r
3014 t.Key = GetParamInt(o, "[id]");
\r
3016 ret = CcDeleteCa(pc->RemoteClient, &t);
\r
3018 if (ret == ERR_NO_ERROR)
\r
3023 if (ret != ERR_NO_ERROR)
\r
3026 CmdPrintError(c, ret);
\r
3030 FreeParamValueList(o);
\r
3035 // 信頼する証明機関の証明書の取得
\r
3036 UINT PcCertGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3039 PC *pc = (PC *)param;
\r
3040 UINT ret = ERR_NO_ERROR;
\r
3045 {"[id]", CmdPrompt, _UU("CMD_CAGet_PROMPT_ID"), CmdEvalNotEmpty, NULL},
\r
3046 {"SAVECERT", CmdPrompt, _UU("CMD_CAGet_PROMPT_SAVECERT"), CmdEvalNotEmpty, NULL},
\r
3050 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3053 return ERR_INVALID_PARAMETER;
\r
3057 Zero(&t, sizeof(t));
\r
3058 t.Key = GetParamInt(o, "[id]");
\r
3060 ret = CcGetCa(pc->RemoteClient, &t);
\r
3062 if (ret == ERR_NO_ERROR)
\r
3065 if (XToFile(t.x, GetParamStr(o, "SAVECERT"), true))
\r
3072 ret = ERR_INTERNAL_ERROR;
\r
3073 c->Write(c, _UU("CMD_MSG_SAVE_CERT_FAILED"));
\r
3079 if (ret != ERR_NO_ERROR)
\r
3082 CmdPrintError(c, ret);
\r
3086 FreeParamValueList(o);
\r
3091 // 使用できるスマートカードの種類の一覧の取得
\r
3092 UINT PcSecureList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3095 PC *pc = (PC *)param;
\r
3096 UINT ret = ERR_NO_ERROR;
\r
3097 RPC_CLIENT_ENUM_SECURE t;
\r
3100 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
3103 return ERR_INVALID_PARAMETER;
\r
3107 Zero(&t, sizeof(t));
\r
3109 ret = CcEnumSecure(pc->RemoteClient, &t);
\r
3111 if (ret == ERR_NO_ERROR)
\r
3115 wchar_t tmp1[MAX_SIZE];
\r
3116 wchar_t tmp2[MAX_SIZE];
\r
3117 wchar_t tmp4[MAX_SIZE];
\r
3122 CtInsertColumn(ct, _UU("SEC_COLUMN1"), false);
\r
3123 CtInsertColumn(ct, _UU("SEC_COLUMN2"), false);
\r
3124 CtInsertColumn(ct, _UU("SEC_COLUMN3"), false);
\r
3125 CtInsertColumn(ct, _UU("SEC_COLUMN4"), false);
\r
3127 for (i = 0;i < t.NumItem;i++)
\r
3129 RPC_CLIENT_ENUM_SECURE_ITEM *e = t.Items[i];
\r
3132 UniToStru(tmp1, e->DeviceId);
\r
3135 StrToUni(tmp2, sizeof(tmp2), e->DeviceName);
\r
3138 tmp3 = (e->Type == SECURE_IC_CARD) ? _UU("SEC_SMART_CARD") : _UU("SEC_USB_TOKEN");
\r
3141 StrToUni(tmp4, sizeof(tmp4), e->Manufacturer);
\r
3143 CtInsert(ct, tmp1, tmp2, tmp3, tmp4);
\r
3146 CtFreeEx(ct, c, true);
\r
3148 CiFreeClientEnumSecure(&t);
\r
3151 if (ret != ERR_NO_ERROR)
\r
3154 CmdPrintError(c, ret);
\r
3158 FreeParamValueList(o);
\r
3163 // 使用するスマートカードの種類の選択
\r
3164 UINT PcSecureSelect(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3167 PC *pc = (PC *)param;
\r
3168 UINT ret = ERR_NO_ERROR;
\r
3173 {"[id]", CmdPrompt, _UU("CMD_SecureSelect_PROMPT_ID"), NULL, NULL},
\r
3177 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3180 return ERR_INVALID_PARAMETER;
\r
3184 Zero(&t, sizeof(t));
\r
3185 t.DeviceId = GetParamInt(o, "[id]");
\r
3187 ret = CcUseSecure(pc->RemoteClient, &t);
\r
3189 if (ret == ERR_NO_ERROR)
\r
3194 if (ret != ERR_NO_ERROR)
\r
3197 CmdPrintError(c, ret);
\r
3201 FreeParamValueList(o);
\r
3206 // 使用するスマートカードの種類の ID の取得
\r
3207 UINT PcSecureGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3210 PC *pc = (PC *)param;
\r
3211 UINT ret = ERR_NO_ERROR;
\r
3215 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
3218 return ERR_INVALID_PARAMETER;
\r
3222 Zero(&t, sizeof(t));
\r
3224 ret = CcGetUseSecure(pc->RemoteClient, &t);
\r
3226 if (ret == ERR_NO_ERROR)
\r
3229 wchar_t tmp[MAX_SIZE];
\r
3231 if (t.DeviceId != 0)
\r
3233 UniFormat(tmp, sizeof(tmp), _UU("CMD_SecureGet_Print"), t.DeviceId);
\r
3237 UniStrCpy(tmp, sizeof(tmp), _UU("CMD_SecureGet_NoPrint"));
\r
3242 if (ret != ERR_NO_ERROR)
\r
3245 CmdPrintError(c, ret);
\r
3249 FreeParamValueList(o);
\r
3254 // 新規仮想 LAN カードの作成
\r
3255 UINT PcNicCreate(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3258 PC *pc = (PC *)param;
\r
3259 UINT ret = ERR_NO_ERROR;
\r
3260 RPC_CLIENT_CREATE_VLAN t;
\r
3264 {"[name]", CmdPrompt, _UU("CMD_NicCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
3268 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3271 return ERR_INVALID_PARAMETER;
\r
3275 Zero(&t, sizeof(t));
\r
3276 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "[name]"));
\r
3278 ret = CcCreateVLan(pc->RemoteClient, &t);
\r
3280 if (ret == ERR_NO_ERROR)
\r
3285 if (ret != ERR_NO_ERROR)
\r
3288 CmdPrintError(c, ret);
\r
3292 FreeParamValueList(o);
\r
3298 UINT PcNicDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3301 PC *pc = (PC *)param;
\r
3302 UINT ret = ERR_NO_ERROR;
\r
3303 RPC_CLIENT_CREATE_VLAN t;
\r
3307 {"[name]", CmdPrompt, _UU("CMD_NicCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
3311 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3314 return ERR_INVALID_PARAMETER;
\r
3318 Zero(&t, sizeof(t));
\r
3319 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "[name]"));
\r
3321 ret = CcDeleteVLan(pc->RemoteClient, &t);
\r
3323 if (ret == ERR_NO_ERROR)
\r
3328 if (ret != ERR_NO_ERROR)
\r
3331 CmdPrintError(c, ret);
\r
3335 FreeParamValueList(o);
\r
3340 // 仮想 LAN カードのデバイスドライバのアップグレード
\r
3341 UINT PcNicUpgrade(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3344 PC *pc = (PC *)param;
\r
3345 UINT ret = ERR_NO_ERROR;
\r
3346 RPC_CLIENT_CREATE_VLAN t;
\r
3350 {"[name]", CmdPrompt, _UU("CMD_NicCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
3354 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3357 return ERR_INVALID_PARAMETER;
\r
3361 Zero(&t, sizeof(t));
\r
3362 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "[name]"));
\r
3364 ret = CcUpgradeVLan(pc->RemoteClient, &t);
\r
3366 if (ret == ERR_NO_ERROR)
\r
3371 if (ret != ERR_NO_ERROR)
\r
3374 CmdPrintError(c, ret);
\r
3378 FreeParamValueList(o);
\r
3383 // 仮想 LAN カードの設定の取得
\r
3384 UINT PcNicGetSetting(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3387 PC *pc = (PC *)param;
\r
3388 UINT ret = ERR_NO_ERROR;
\r
3389 RPC_CLIENT_GET_VLAN t;
\r
3393 {"[name]", CmdPrompt, _UU("CMD_NicCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
3397 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3400 return ERR_INVALID_PARAMETER;
\r
3404 Zero(&t, sizeof(t));
\r
3405 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "[name]"));
\r
3407 ret = CcGetVLan(pc->RemoteClient, &t);
\r
3409 if (ret == ERR_NO_ERROR)
\r
3412 CT *ct = CtNewStandard();
\r
3413 wchar_t tmp[MAX_SIZE];
\r
3415 StrToUni(tmp, sizeof(tmp), t.DeviceName);
\r
3416 CtInsert(ct, _UU("CMD_NicGetSetting_1"), tmp);
\r
3418 CtInsert(ct, _UU("CMD_NicGetSetting_2"), t.Enabled ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
3420 StrToUni(tmp, sizeof(tmp), t.MacAddress);
\r
3421 CtInsert(ct, _UU("CMD_NicGetSetting_3"), tmp);
\r
3423 StrToUni(tmp, sizeof(tmp), t.Version);
\r
3424 CtInsert(ct, _UU("CMD_NicGetSetting_4"), tmp);
\r
3426 StrToUni(tmp, sizeof(tmp), t.FileName);
\r
3427 CtInsert(ct, _UU("CMD_NicGetSetting_5"), tmp);
\r
3429 StrToUni(tmp, sizeof(tmp), t.Guid);
\r
3430 CtInsert(ct, _UU("CMD_NicGetSetting_6"), tmp);
\r
3435 if (ret != ERR_NO_ERROR)
\r
3438 CmdPrintError(c, ret);
\r
3442 FreeParamValueList(o);
\r
3447 // 仮想 LAN カードの設定の変更
\r
3448 UINT PcNicSetSetting(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3451 PC *pc = (PC *)param;
\r
3452 UINT ret = ERR_NO_ERROR;
\r
3453 RPC_CLIENT_SET_VLAN t;
\r
3454 UCHAR mac_address[6];
\r
3459 {"[name]", CmdPrompt, _UU("CMD_NicCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
3460 {"MAC", CmdPrompt, _UU("CMD_NicSetSetting_PROMPT_MAC"), CmdEvalNotEmpty, NULL},
\r
3464 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3467 return ERR_INVALID_PARAMETER;
\r
3471 Zero(mac_address, sizeof(mac_address));
\r
3472 b = StrToBin(GetParamStr(o, "MAC"));
\r
3473 if (b != NULL && b->Size == 6)
\r
3475 Copy(mac_address, b->Buf, 6);
\r
3479 if (IsZero(mac_address, 6))
\r
3482 FreeParamValueList(o);
\r
3484 CmdPrintError(c, ERR_INVALID_PARAMETER);
\r
3485 return ERR_INVALID_PARAMETER;
\r
3489 Zero(&t, sizeof(t));
\r
3490 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "[name]"));
\r
3491 NormalizeMacAddress(t.MacAddress, sizeof(t.MacAddress), GetParamStr(o, "MAC"));
\r
3493 ret = CcSetVLan(pc->RemoteClient, &t);
\r
3495 if (ret == ERR_NO_ERROR)
\r
3500 if (ret != ERR_NO_ERROR)
\r
3503 CmdPrintError(c, ret);
\r
3507 FreeParamValueList(o);
\r
3513 UINT PcNicEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3516 PC *pc = (PC *)param;
\r
3517 UINT ret = ERR_NO_ERROR;
\r
3518 RPC_CLIENT_CREATE_VLAN t;
\r
3522 {"[name]", CmdPrompt, _UU("CMD_NicCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
3526 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3529 return ERR_INVALID_PARAMETER;
\r
3533 Zero(&t, sizeof(t));
\r
3534 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "[name]"));
\r
3536 ret = CcEnableVLan(pc->RemoteClient, &t);
\r
3538 if (ret == ERR_NO_ERROR)
\r
3543 if (ret != ERR_NO_ERROR)
\r
3546 CmdPrintError(c, ret);
\r
3550 FreeParamValueList(o);
\r
3556 UINT PcNicDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3559 PC *pc = (PC *)param;
\r
3560 UINT ret = ERR_NO_ERROR;
\r
3561 RPC_CLIENT_CREATE_VLAN t;
\r
3565 {"[name]", CmdPrompt, _UU("CMD_NicCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
3569 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3572 return ERR_INVALID_PARAMETER;
\r
3576 Zero(&t, sizeof(t));
\r
3577 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "[name]"));
\r
3579 ret = CcDisableVLan(pc->RemoteClient, &t);
\r
3581 if (ret == ERR_NO_ERROR)
\r
3586 if (ret != ERR_NO_ERROR)
\r
3589 CmdPrintError(c, ret);
\r
3593 FreeParamValueList(o);
\r
3598 // 仮想 LAN カード一覧の取得
\r
3599 UINT PcNicList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3602 PC *pc = (PC *)param;
\r
3603 UINT ret = ERR_NO_ERROR;
\r
3604 RPC_CLIENT_ENUM_VLAN t;
\r
3607 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
3610 return ERR_INVALID_PARAMETER;
\r
3614 Zero(&t, sizeof(t));
\r
3616 ret = CcEnumVLan(pc->RemoteClient, &t);
\r
3618 if (ret == ERR_NO_ERROR)
\r
3625 CtInsertColumn(ct, _UU("CM_VLAN_COLUMN_1"), false);
\r
3626 CtInsertColumn(ct, _UU("CM_VLAN_COLUMN_2"), false);
\r
3627 CtInsertColumn(ct, _UU("CM_VLAN_COLUMN_3"), false);
\r
3628 CtInsertColumn(ct, _UU("CM_VLAN_COLUMN_4"), false);
\r
3630 for (i = 0;i < t.NumItem;i++)
\r
3632 wchar_t name[MAX_SIZE];
\r
3633 wchar_t mac[MAX_SIZE];
\r
3634 wchar_t ver[MAX_SIZE];
\r
3636 RPC_CLIENT_ENUM_VLAN_ITEM *v = t.Items[i];
\r
3639 StrToUni(name, sizeof(name), v->DeviceName);
\r
3642 status = v->Enabled ? _UU("CM_VLAN_ENABLED") : _UU("CM_VLAN_DISABLED");
\r
3645 StrToUni(mac, sizeof(mac), v->MacAddress);
\r
3648 StrToUni(ver, sizeof(ver), v->Version);
\r
3651 name, status, mac, ver);
\r
3654 CtFreeEx(ct, c, true);
\r
3657 if (ret != ERR_NO_ERROR)
\r
3660 CmdPrintError(c, ret);
\r
3663 CiFreeClientEnumVLan(&t);
\r
3666 FreeParamValueList(o);
\r
3672 wchar_t *GetProtocolName(UINT n)
\r
3676 case PROXY_DIRECT:
\r
3677 return _UU("PROTO_DIRECT_TCP");
\r
3679 return _UU("PROTO_HTTP_PROXY");
\r
3681 return _UU("PROTO_SOCKS_PROXY");
\r
3684 return _UU("PROTO_UNKNOWN");
\r
3688 UINT PcAccountList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3691 PC *pc = (PC *)param;
\r
3692 UINT ret = ERR_NO_ERROR;
\r
3693 RPC_CLIENT_ENUM_ACCOUNT t;
\r
3696 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
3699 return ERR_INVALID_PARAMETER;
\r
3703 Zero(&t, sizeof(t));
\r
3705 ret = CcEnumAccount(pc->RemoteClient, &t);
\r
3707 if (ret == ERR_NO_ERROR)
\r
3714 CtInsertColumn(ct, _UU("CM_ACCOUNT_COLUMN_1"), false);
\r
3715 CtInsertColumn(ct, _UU("CM_ACCOUNT_COLUMN_2"), false);
\r
3716 CtInsertColumn(ct, _UU("CM_ACCOUNT_COLUMN_3"), false);
\r
3717 CtInsertColumn(ct, _UU("CM_ACCOUNT_COLUMN_3_2"), false);
\r
3718 CtInsertColumn(ct, _UU("CM_ACCOUNT_COLUMN_4"), false);
\r
3720 for (i = 0;i < t.NumItem;i++)
\r
3722 RPC_CLIENT_ENUM_ACCOUNT_ITEM *e = t.Items[i];
\r
3723 wchar_t tmp[MAX_SIZE];
\r
3724 wchar_t tmp2[MAX_SIZE];
\r
3725 wchar_t tmp4[MAX_SIZE];
\r
3727 char ip_str[MAX_SIZE];
\r
3729 // IPv6 アドレスの場合の特別処理
\r
3730 if (StrToIP6(&ip, e->ServerName) && StartWith(e->ServerName, "[") == false)
\r
3732 Format(ip_str, sizeof(ip_str),
\r
3733 "[%s]", e->ServerName);
\r
3737 StrCpy(ip_str, sizeof(ip_str), e->ServerName);
\r
3743 UniFormat(tmp2, sizeof(tmp2), L"%S (%s)", ip_str, GetProtocolName(e->ProxyType));
\r
3748 UniFormat(tmp2, sizeof(tmp2), L"%S:%u (%s)", ip_str, e->Port, GetProtocolName(e->ProxyType));
\r
3752 StrToUni(tmp4, sizeof(tmp4), e->HubName);
\r
3755 StrToUni(tmp, sizeof(tmp), e->DeviceName);
\r
3759 e->Active == false ? _UU("CM_ACCOUNT_OFFLINE") :
\r
3760 (e->Connected ? _UU("CM_ACCOUNT_ONLINE") : _UU("CM_ACCOUNT_CONNECTING")),
\r
3765 CtFreeEx(ct, c, true);
\r
3768 CiFreeClientEnumAccount(&t);
\r
3770 if (ret != ERR_NO_ERROR)
\r
3773 CmdPrintError(c, ret);
\r
3777 FreeParamValueList(o);
\r
3783 UINT PcAccountCreate(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3786 PC *pc = (PC *)param;
\r
3787 UINT ret = ERR_NO_ERROR;
\r
3788 RPC_CLIENT_CREATE_ACCOUNT t;
\r
3790 char *host = NULL;
\r
3794 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
3795 {"SERVER", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Server"), CmdEvalHostAndPort, NULL},
\r
3796 {"HUB", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Hub"), CmdEvalSafe, NULL},
\r
3797 {"USERNAME", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Username"), CmdEvalNotEmpty, NULL},
\r
3798 {"NICNAME", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Nicname"), CmdEvalNotEmpty, NULL},
\r
3802 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3805 return ERR_INVALID_PARAMETER;
\r
3808 ParseHostPort(GetParamStr(o, "SERVER"), &host, &port, 443);
\r
3811 Zero(&t, sizeof(t));
\r
3813 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
3814 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
3815 t.ClientOption->Port = port;
\r
3816 StrCpy(t.ClientOption->Hostname, sizeof(t.ClientOption->Hostname), host);
\r
3817 StrCpy(t.ClientOption->HubName, sizeof(t.ClientOption->HubName), GetParamStr(o, "HUB"));
\r
3818 t.ClientOption->NumRetry = INFINITE;
\r
3819 t.ClientOption->RetryInterval = 15;
\r
3820 t.ClientOption->MaxConnection = 1;
\r
3821 t.ClientOption->UseEncrypt = true;
\r
3822 t.ClientOption->AdditionalConnectionInterval = 1;
\r
3823 StrCpy(t.ClientOption->DeviceName, sizeof(t.ClientOption->DeviceName), GetParamStr(o, "NICNAME"));
\r
3825 t.ClientAuth = ZeroMalloc(sizeof(CLIENT_AUTH));
\r
3826 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_ANONYMOUS;
\r
3827 StrCpy(t.ClientAuth->Username, sizeof(t.ClientAuth->Username), GetParamStr(o, "USERNAME"));
\r
3831 ret = CcCreateAccount(pc->RemoteClient, &t);
\r
3833 if (ret == ERR_NO_ERROR)
\r
3838 CiFreeClientCreateAccount(&t);
\r
3840 if (ret != ERR_NO_ERROR)
\r
3843 CmdPrintError(c, ret);
\r
3847 FreeParamValueList(o);
\r
3853 UINT PcAccountSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3856 PC *pc = (PC *)param;
\r
3857 UINT ret = ERR_NO_ERROR;
\r
3858 RPC_CLIENT_GET_ACCOUNT t;
\r
3859 char *host = NULL;
\r
3864 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
3865 {"SERVER", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Server"), CmdEvalHostAndPort, NULL},
\r
3866 {"HUB", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Hub"), CmdEvalSafe, NULL},
\r
3870 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3873 return ERR_INVALID_PARAMETER;
\r
3877 Zero(&t, sizeof(t));
\r
3879 ParseHostPort(GetParamStr(o, "SERVER"), &host, &port, 443);
\r
3881 Zero(&t, sizeof(t));
\r
3882 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
3884 ret = CcGetAccount(pc->RemoteClient, &t);
\r
3886 if (ret == ERR_NO_ERROR)
\r
3888 RPC_CLIENT_CREATE_ACCOUNT c;
\r
3890 t.ClientOption->Port = port;
\r
3891 StrCpy(t.ClientOption->Hostname, sizeof(t.ClientOption->Hostname), host);
\r
3892 StrCpy(t.ClientOption->HubName, sizeof(t.ClientOption->HubName), GetParamStr(o, "HUB"));
\r
3894 Zero(&c, sizeof(c));
\r
3896 c.ClientAuth = t.ClientAuth;
\r
3897 c.ClientOption = t.ClientOption;
\r
3898 c.CheckServerCert = t.CheckServerCert;
\r
3899 c.ServerCert = t.ServerCert;
\r
3900 c.StartupAccount = t.StartupAccount;
\r
3902 ret = CcSetAccount(pc->RemoteClient, &c);
\r
3905 if (ret != ERR_NO_ERROR)
\r
3908 CmdPrintError(c, ret);
\r
3911 CiFreeClientGetAccount(&t);
\r
3914 FreeParamValueList(o);
\r
3922 UINT PcAccountGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
3925 PC *pc = (PC *)param;
\r
3926 UINT ret = ERR_NO_ERROR;
\r
3927 RPC_CLIENT_GET_ACCOUNT t;
\r
3931 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
3935 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
3938 return ERR_INVALID_PARAMETER;
\r
3942 Zero(&t, sizeof(t));
\r
3943 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
3945 ret = CcGetAccount(pc->RemoteClient, &t);
\r
3947 if (ret == ERR_NO_ERROR)
\r
3950 wchar_t tmp[MAX_SIZE];
\r
3952 CT *ct = CtNewStandard();
\r
3955 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_NAME"), t.ClientOption->AccountName);
\r
3957 // 接続先 VPN Server のホスト名
\r
3958 StrToUni(tmp, sizeof(tmp), t.ClientOption->Hostname);
\r
3959 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_HOSTNAME"), tmp);
\r
3961 // 接続先 VPN Server のポート番号
\r
3962 UniToStru(tmp, t.ClientOption->Port);
\r
3963 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PORT"), tmp);
\r
3965 // 接続先 VPN Server の仮想 HUB 名
\r
3966 StrToUni(tmp, sizeof(tmp), t.ClientOption->HubName);
\r
3967 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_HUBNAME"), tmp);
\r
3969 // 経由するプロキシ サーバーの種類
\r
3970 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PROXY_TYPE"), GetProxyTypeStr(t.ClientOption->ProxyType));
\r
3972 if (t.ClientOption->ProxyType != PROXY_DIRECT)
\r
3975 StrToUni(tmp, sizeof(tmp), t.ClientOption->ProxyName);
\r
3976 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PROXY_HOSTNAME"), tmp);
\r
3978 // プロキシ サーバーのポート番号
\r
3979 UniToStru(tmp, t.ClientOption->ProxyPort);
\r
3980 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PROXY_PORT"), tmp);
\r
3982 // プロキシ サーバーのユーザー名
\r
3983 StrToUni(tmp, sizeof(tmp), t.ClientOption->ProxyUsername);
\r
3984 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PROXY_USERNAME"), tmp);
\r
3988 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_SERVER_CERT_USE"),
\r
3989 t.CheckServerCert ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
3992 if (t.ServerCert != NULL)
\r
3994 GetAllNameFromX(tmp, sizeof(tmp), t.ServerCert);
\r
3995 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_SERVER_CERT_NAME"), tmp);
\r
3999 StrToUni(tmp, sizeof(tmp), t.ClientOption->DeviceName);
\r
4000 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_DEVICE_NAME"), tmp);
\r
4003 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_AUTH_TYPE"), GetClientAuthTypeStr(t.ClientAuth->AuthType));
\r
4006 StrToUni(tmp, sizeof(tmp), t.ClientAuth->Username);
\r
4007 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_AUTH_USERNAME"), tmp);
\r
4009 if (t.ClientAuth->AuthType == CLIENT_AUTHTYPE_CERT)
\r
4011 if (t.ClientAuth->ClientX != NULL)
\r
4014 GetAllNameFromX(tmp, sizeof(tmp), t.ClientAuth->ClientX);
\r
4015 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_AUTH_CERT_NAME"), tmp);
\r
4019 // VPN 通信に使用する TCP コネクション数
\r
4020 UniToStru(tmp, t.ClientOption->MaxConnection);
\r
4021 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_NUMTCP"), tmp);
\r
4023 // 各 TCP コネクションの確立間隔
\r
4024 UniToStru(tmp, t.ClientOption->AdditionalConnectionInterval);
\r
4025 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_TCP_INTERVAL"), tmp);
\r
4027 // 各 TCP コネクションの寿命
\r
4028 if (t.ClientOption->ConnectionDisconnectSpan != 0)
\r
4030 UniToStru(tmp, t.ClientOption->ConnectionDisconnectSpan);
\r
4034 UniStrCpy(tmp, sizeof(tmp), _UU("CMD_MSG_INFINITE"));
\r
4036 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_TCP_TTL"), tmp);
\r
4039 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_TCP_HALF"),
\r
4040 t.ClientOption->HalfConnection ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
4043 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_ENCRYPT"),
\r
4044 t.ClientOption->UseEncrypt ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
4047 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_COMPRESS"),
\r
4048 t.ClientOption->UseCompress ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
4050 // ブリッジ / ルータモードで接続
\r
4051 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_BRIDGE_ROUTER"),
\r
4052 t.ClientOption->RequireBridgeRoutingMode ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
4055 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_MONITOR"),
\r
4056 t.ClientOption->RequireMonitorMode ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
4058 // ルーティング テーブルを書き換えない
\r
4059 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_NO_TRACKING"),
\r
4060 t.ClientOption->NoRoutingTracking ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
4063 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_QOS_DISABLE"),
\r
4064 t.ClientOption->DisableQoS ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
4069 if (ret != ERR_NO_ERROR)
\r
4072 CmdPrintError(c, ret);
\r
4075 CiFreeClientGetAccount(&t);
\r
4078 FreeParamValueList(o);
\r
4084 UINT PcAccountDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4087 PC *pc = (PC *)param;
\r
4088 UINT ret = ERR_NO_ERROR;
\r
4089 RPC_CLIENT_DELETE_ACCOUNT t;
\r
4093 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4097 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4100 return ERR_INVALID_PARAMETER;
\r
4104 Zero(&t, sizeof(t));
\r
4106 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4108 ret = CcDeleteAccount(pc->RemoteClient, &t);
\r
4110 if (ret == ERR_NO_ERROR)
\r
4115 if (ret != ERR_NO_ERROR)
\r
4118 CmdPrintError(c, ret);
\r
4122 FreeParamValueList(o);
\r
4127 // 接続設定の接続に使用するユーザー名の設定
\r
4128 UINT PcAccountUsernameSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4131 PC *pc = (PC *)param;
\r
4132 UINT ret = ERR_NO_ERROR;
\r
4133 RPC_CLIENT_GET_ACCOUNT t;
\r
4137 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4138 {"USERNAME", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Username"), CmdEvalNotEmpty, NULL},
\r
4142 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4145 return ERR_INVALID_PARAMETER;
\r
4149 Zero(&t, sizeof(t));
\r
4151 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4153 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4155 if (ret == ERR_NO_ERROR)
\r
4157 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4159 StrCpy(t.ClientAuth->Username, sizeof(t.ClientAuth->Username), GetParamStr(o, "USERNAME"));
\r
4161 if (t.ClientAuth->AuthType == CLIENT_AUTHTYPE_PASSWORD)
\r
4163 c->Write(c, _UU("CMD_AccountUsername_Notice"));
\r
4166 Zero(&z, sizeof(z));
\r
4167 z.CheckServerCert = t.CheckServerCert;
\r
4168 z.ClientAuth = t.ClientAuth;
\r
4169 z.ClientOption = t.ClientOption;
\r
4170 z.ServerCert = t.ServerCert;
\r
4171 z.StartupAccount = t.StartupAccount;
\r
4173 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4176 if (ret != ERR_NO_ERROR)
\r
4179 CmdPrintError(c, ret);
\r
4182 CiFreeClientGetAccount(&t);
\r
4185 FreeParamValueList(o);
\r
4190 // 接続設定のユーザー認証の種類を匿名認証に設定
\r
4191 UINT PcAccountAnonymousSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4194 PC *pc = (PC *)param;
\r
4195 UINT ret = ERR_NO_ERROR;
\r
4196 RPC_CLIENT_GET_ACCOUNT t;
\r
4200 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4204 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4207 return ERR_INVALID_PARAMETER;
\r
4211 Zero(&t, sizeof(t));
\r
4213 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4215 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4217 if (ret == ERR_NO_ERROR)
\r
4219 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4221 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_ANONYMOUS;
\r
4223 Zero(&z, sizeof(z));
\r
4224 z.CheckServerCert = t.CheckServerCert;
\r
4225 z.ClientAuth = t.ClientAuth;
\r
4226 z.ClientOption = t.ClientOption;
\r
4227 z.ServerCert = t.ServerCert;
\r
4228 z.StartupAccount = t.StartupAccount;
\r
4230 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4233 if (ret != ERR_NO_ERROR)
\r
4236 CmdPrintError(c, ret);
\r
4239 CiFreeClientGetAccount(&t);
\r
4242 FreeParamValueList(o);
\r
4247 // 接続設定のユーザー認証の種類をパスワード認証に設定
\r
4248 UINT PcAccountPasswordSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4251 PC *pc = (PC *)param;
\r
4252 UINT ret = ERR_NO_ERROR;
\r
4253 RPC_CLIENT_GET_ACCOUNT t;
\r
4257 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4258 {"PASSWORD", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
4259 {"TYPE", CmdPrompt, _UU("CMD_CascadePasswordSet_Prompt_Type"), CmdEvalNotEmpty, NULL},
\r
4263 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4266 return ERR_INVALID_PARAMETER;
\r
4270 Zero(&t, sizeof(t));
\r
4272 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4274 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4276 if (ret == ERR_NO_ERROR)
\r
4278 char *typestr = GetParamStr(o, "TYPE");
\r
4279 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4282 if (StartWith("standard", typestr))
\r
4284 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_PASSWORD;
\r
4285 HashPassword(t.ClientAuth->HashedPassword, t.ClientAuth->Username,
\r
4286 GetParamStr(o, "PASSWORD"));
\r
4288 else if (StartWith("radius", typestr) || StartWith("ntdomain", typestr))
\r
4290 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_PLAIN_PASSWORD;
\r
4292 StrCpy(t.ClientAuth->PlainPassword, sizeof(t.ClientAuth->PlainPassword),
\r
4293 GetParamStr(o, "PASSWORD"));
\r
4298 c->Write(c, _UU("CMD_CascadePasswordSet_Type_Invalid"));
\r
4299 ret = ERR_INVALID_PARAMETER;
\r
4302 if (ret == ERR_NO_ERROR)
\r
4304 Zero(&z, sizeof(z));
\r
4305 z.CheckServerCert = t.CheckServerCert;
\r
4306 z.ClientAuth = t.ClientAuth;
\r
4307 z.ClientOption = t.ClientOption;
\r
4308 z.ServerCert = t.ServerCert;
\r
4309 z.StartupAccount = t.StartupAccount;
\r
4311 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4315 if (ret != ERR_NO_ERROR)
\r
4318 CmdPrintError(c, ret);
\r
4321 CiFreeClientGetAccount(&t);
\r
4324 FreeParamValueList(o);
\r
4329 // 接続設定のユーザー認証の種類をクライアント証明書認証に設定
\r
4330 UINT PcAccountCertSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4333 PC *pc = (PC *)param;
\r
4334 UINT ret = ERR_NO_ERROR;
\r
4335 RPC_CLIENT_GET_ACCOUNT t;
\r
4341 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4342 {"LOADCERT", CmdPrompt, _UU("CMD_LOADCERTPATH"), CmdEvalIsFile, NULL},
\r
4343 {"LOADKEY", CmdPrompt, _UU("CMD_LOADKEYPATH"), CmdEvalIsFile, NULL},
\r
4347 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4350 return ERR_INVALID_PARAMETER;
\r
4353 if (CmdLoadCertAndKey(c, &x, &k, GetParamStr(o, "LOADCERT"), GetParamStr(o, "LOADKEY")) == false)
\r
4355 return ERR_INTERNAL_ERROR;
\r
4359 Zero(&t, sizeof(t));
\r
4361 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4363 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4365 if (ret == ERR_NO_ERROR)
\r
4367 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4369 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_CERT;
\r
4370 if (t.ClientAuth->ClientX != NULL)
\r
4372 FreeX(t.ClientAuth->ClientX);
\r
4374 if (t.ClientAuth->ClientK != NULL)
\r
4376 FreeK(t.ClientAuth->ClientK);
\r
4379 t.ClientAuth->ClientX = CloneX(x);
\r
4380 t.ClientAuth->ClientK = CloneK(k);
\r
4382 Zero(&z, sizeof(z));
\r
4383 z.CheckServerCert = t.CheckServerCert;
\r
4384 z.ClientAuth = t.ClientAuth;
\r
4385 z.ClientOption = t.ClientOption;
\r
4386 z.ServerCert = t.ServerCert;
\r
4387 z.StartupAccount = t.StartupAccount;
\r
4389 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4392 if (ret != ERR_NO_ERROR)
\r
4395 CmdPrintError(c, ret);
\r
4401 CiFreeClientGetAccount(&t);
\r
4404 FreeParamValueList(o);
\r
4409 // 接続設定に用いるクライアント証明書の取得
\r
4410 UINT PcAccountCertGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4413 PC *pc = (PC *)param;
\r
4414 UINT ret = ERR_NO_ERROR;
\r
4415 RPC_CLIENT_GET_ACCOUNT t;
\r
4419 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4420 {"SAVECERT", CmdPrompt, _UU("CMD_SAVECERTPATH"), CmdEvalNotEmpty, NULL},
\r
4424 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4427 return ERR_INVALID_PARAMETER;
\r
4431 Zero(&t, sizeof(t));
\r
4433 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4435 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4437 if (ret == ERR_NO_ERROR)
\r
4439 if (t.ClientAuth->AuthType != CLIENT_AUTHTYPE_CERT)
\r
4441 c->Write(c, _UU("CMD_CascadeCertSet_Not_Auth_Cert"));
\r
4442 ret = ERR_INTERNAL_ERROR;
\r
4444 else if (t.ClientAuth->ClientX == NULL)
\r
4446 c->Write(c, _UU("CMD_CascadeCertSet_Cert_Not_Exists"));
\r
4447 ret = ERR_INTERNAL_ERROR;
\r
4451 XToFile(t.ClientAuth->ClientX, GetParamStr(o, "SAVECERT"), true);
\r
4455 CiFreeClientGetAccount(&t);
\r
4457 if (ret != ERR_NO_ERROR)
\r
4460 CmdPrintError(c, ret);
\r
4464 FreeParamValueList(o);
\r
4469 // 接続設定の通信時の暗号化の無効化
\r
4470 UINT PcAccountEncryptDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4473 PC *pc = (PC *)param;
\r
4474 UINT ret = ERR_NO_ERROR;
\r
4475 RPC_CLIENT_GET_ACCOUNT t;
\r
4479 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4483 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4486 return ERR_INVALID_PARAMETER;
\r
4490 Zero(&t, sizeof(t));
\r
4492 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4494 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4496 if (ret == ERR_NO_ERROR)
\r
4498 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4500 t.ClientOption->UseEncrypt = false;
\r
4502 Zero(&z, sizeof(z));
\r
4503 z.CheckServerCert = t.CheckServerCert;
\r
4504 z.ClientAuth = t.ClientAuth;
\r
4505 z.ClientOption = t.ClientOption;
\r
4506 z.ServerCert = t.ServerCert;
\r
4507 z.StartupAccount = t.StartupAccount;
\r
4509 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4512 if (ret != ERR_NO_ERROR)
\r
4515 CmdPrintError(c, ret);
\r
4518 CiFreeClientGetAccount(&t);
\r
4521 FreeParamValueList(o);
\r
4526 // 接続設定の通信時の暗号化の有効化
\r
4527 UINT PcAccountEncryptEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4530 PC *pc = (PC *)param;
\r
4531 UINT ret = ERR_NO_ERROR;
\r
4532 RPC_CLIENT_GET_ACCOUNT t;
\r
4536 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4540 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4543 return ERR_INVALID_PARAMETER;
\r
4547 Zero(&t, sizeof(t));
\r
4549 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4551 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4553 if (ret == ERR_NO_ERROR)
\r
4555 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4557 t.ClientOption->UseEncrypt = true;
\r
4559 Zero(&z, sizeof(z));
\r
4560 z.CheckServerCert = t.CheckServerCert;
\r
4561 z.ClientAuth = t.ClientAuth;
\r
4562 z.ClientOption = t.ClientOption;
\r
4563 z.ServerCert = t.ServerCert;
\r
4564 z.StartupAccount = t.StartupAccount;
\r
4566 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4569 if (ret != ERR_NO_ERROR)
\r
4572 CmdPrintError(c, ret);
\r
4575 CiFreeClientGetAccount(&t);
\r
4578 FreeParamValueList(o);
\r
4583 // 接続設定の通信時のデータ圧縮の有効化
\r
4584 UINT PcAccountCompressEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4587 PC *pc = (PC *)param;
\r
4588 UINT ret = ERR_NO_ERROR;
\r
4589 RPC_CLIENT_GET_ACCOUNT t;
\r
4593 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4597 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4600 return ERR_INVALID_PARAMETER;
\r
4604 Zero(&t, sizeof(t));
\r
4606 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4608 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4610 if (ret == ERR_NO_ERROR)
\r
4612 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4614 t.ClientOption->UseCompress = true;
\r
4616 Zero(&z, sizeof(z));
\r
4617 z.CheckServerCert = t.CheckServerCert;
\r
4618 z.ClientAuth = t.ClientAuth;
\r
4619 z.ClientOption = t.ClientOption;
\r
4620 z.ServerCert = t.ServerCert;
\r
4621 z.StartupAccount = t.StartupAccount;
\r
4623 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4626 if (ret != ERR_NO_ERROR)
\r
4629 CmdPrintError(c, ret);
\r
4632 CiFreeClientGetAccount(&t);
\r
4635 FreeParamValueList(o);
\r
4640 // 接続設定の通信時のデータ圧縮の無効化
\r
4641 UINT PcAccountCompressDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4644 PC *pc = (PC *)param;
\r
4645 UINT ret = ERR_NO_ERROR;
\r
4646 RPC_CLIENT_GET_ACCOUNT t;
\r
4650 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4654 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4657 return ERR_INVALID_PARAMETER;
\r
4661 Zero(&t, sizeof(t));
\r
4663 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4665 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4667 if (ret == ERR_NO_ERROR)
\r
4669 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4671 t.ClientOption->UseCompress = false;
\r
4673 Zero(&z, sizeof(z));
\r
4674 z.CheckServerCert = t.CheckServerCert;
\r
4675 z.ClientAuth = t.ClientAuth;
\r
4676 z.ClientOption = t.ClientOption;
\r
4677 z.ServerCert = t.ServerCert;
\r
4678 z.StartupAccount = t.StartupAccount;
\r
4680 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4683 if (ret != ERR_NO_ERROR)
\r
4686 CmdPrintError(c, ret);
\r
4689 CiFreeClientGetAccount(&t);
\r
4692 FreeParamValueList(o);
\r
4697 // 接続設定の接続方法を直接 TCP/IP 接続に設定
\r
4698 UINT PcAccountProxyNone(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4701 PC *pc = (PC *)param;
\r
4702 UINT ret = ERR_NO_ERROR;
\r
4703 RPC_CLIENT_GET_ACCOUNT t;
\r
4707 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4711 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4714 return ERR_INVALID_PARAMETER;
\r
4718 Zero(&t, sizeof(t));
\r
4720 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4722 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4724 if (ret == ERR_NO_ERROR)
\r
4726 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4728 t.ClientOption->ProxyType = PROXY_DIRECT;
\r
4730 Zero(&z, sizeof(z));
\r
4731 z.CheckServerCert = t.CheckServerCert;
\r
4732 z.ClientAuth = t.ClientAuth;
\r
4733 z.ClientOption = t.ClientOption;
\r
4734 z.ServerCert = t.ServerCert;
\r
4735 z.StartupAccount = t.StartupAccount;
\r
4737 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4740 if (ret != ERR_NO_ERROR)
\r
4743 CmdPrintError(c, ret);
\r
4746 CiFreeClientGetAccount(&t);
\r
4749 FreeParamValueList(o);
\r
4754 // 接続設定の接続方法を HTTP プロキシサーバー経由接続に設定
\r
4755 UINT PcAccountProxyHttp(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4758 PC *pc = (PC *)param;
\r
4759 UINT ret = ERR_NO_ERROR;
\r
4760 RPC_CLIENT_GET_ACCOUNT t;
\r
4764 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4765 {"SERVER", CmdPrompt, _UU("CMD_AccountProxyHttp_Prompt_Server"), CmdEvalHostAndPort, NULL},
\r
4766 {"USERNAME", NULL, NULL, NULL, NULL},
\r
4767 {"PASSWORD", NULL, NULL, NULL, NULL},
\r
4771 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4774 return ERR_INVALID_PARAMETER;
\r
4778 Zero(&t, sizeof(t));
\r
4780 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4782 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4784 if (ret == ERR_NO_ERROR)
\r
4786 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4791 if (ParseHostPort(GetParamStr(o, "SERVER"), &host, &port, 8080))
\r
4793 t.ClientOption->ProxyType = PROXY_HTTP;
\r
4794 StrCpy(t.ClientOption->ProxyName, sizeof(t.ClientOption->ProxyName), host);
\r
4795 t.ClientOption->ProxyPort = port;
\r
4796 StrCpy(t.ClientOption->ProxyUsername, sizeof(t.ClientOption->ProxyName), GetParamStr(o, "USERNAME"));
\r
4797 StrCpy(t.ClientOption->ProxyPassword, sizeof(t.ClientOption->ProxyName), GetParamStr(o, "PASSWORD"));
\r
4801 Zero(&z, sizeof(z));
\r
4802 z.CheckServerCert = t.CheckServerCert;
\r
4803 z.ClientAuth = t.ClientAuth;
\r
4804 z.ClientOption = t.ClientOption;
\r
4805 z.ServerCert = t.ServerCert;
\r
4806 z.StartupAccount = t.StartupAccount;
\r
4808 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4811 if (ret != ERR_NO_ERROR)
\r
4814 CmdPrintError(c, ret);
\r
4817 CiFreeClientGetAccount(&t);
\r
4820 FreeParamValueList(o);
\r
4825 // 接続設定の接続方法を SOCKS プロキシサーバー経由接続に設定
\r
4826 UINT PcAccountProxySocks(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4829 PC *pc = (PC *)param;
\r
4830 UINT ret = ERR_NO_ERROR;
\r
4831 RPC_CLIENT_GET_ACCOUNT t;
\r
4835 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4836 {"SERVER", CmdPrompt, _UU("CMD_AccountProxyHttp_Prompt_Server"), CmdEvalHostAndPort, NULL},
\r
4837 {"USERNAME", NULL, NULL, NULL, NULL},
\r
4838 {"PASSWORD", NULL, NULL, NULL, NULL},
\r
4842 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4845 return ERR_INVALID_PARAMETER;
\r
4849 Zero(&t, sizeof(t));
\r
4851 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4853 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4855 if (ret == ERR_NO_ERROR)
\r
4857 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4862 if (ParseHostPort(GetParamStr(o, "SERVER"), &host, &port, 8080))
\r
4864 t.ClientOption->ProxyType = PROXY_SOCKS;
\r
4865 StrCpy(t.ClientOption->ProxyName, sizeof(t.ClientOption->ProxyName), host);
\r
4866 t.ClientOption->ProxyPort = port;
\r
4867 StrCpy(t.ClientOption->ProxyUsername, sizeof(t.ClientOption->ProxyName), GetParamStr(o, "USERNAME"));
\r
4868 StrCpy(t.ClientOption->ProxyPassword, sizeof(t.ClientOption->ProxyName), GetParamStr(o, "PASSWORD"));
\r
4872 Zero(&z, sizeof(z));
\r
4873 z.CheckServerCert = t.CheckServerCert;
\r
4874 z.ClientAuth = t.ClientAuth;
\r
4875 z.ClientOption = t.ClientOption;
\r
4876 z.ServerCert = t.ServerCert;
\r
4877 z.StartupAccount = t.StartupAccount;
\r
4879 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4882 if (ret != ERR_NO_ERROR)
\r
4885 CmdPrintError(c, ret);
\r
4888 CiFreeClientGetAccount(&t);
\r
4891 FreeParamValueList(o);
\r
4896 // 接続設定のサーバー証明書の検証オプションの有効化
\r
4897 UINT PcAccountServerCertEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4900 PC *pc = (PC *)param;
\r
4901 UINT ret = ERR_NO_ERROR;
\r
4902 RPC_CLIENT_GET_ACCOUNT t;
\r
4906 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4910 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4913 return ERR_INVALID_PARAMETER;
\r
4917 Zero(&t, sizeof(t));
\r
4919 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4921 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4923 if (ret == ERR_NO_ERROR)
\r
4925 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4927 t.CheckServerCert = true;
\r
4929 Zero(&z, sizeof(z));
\r
4930 z.CheckServerCert = t.CheckServerCert;
\r
4931 z.ClientAuth = t.ClientAuth;
\r
4932 z.ClientOption = t.ClientOption;
\r
4933 z.ServerCert = t.ServerCert;
\r
4934 z.StartupAccount = t.StartupAccount;
\r
4936 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4939 if (ret != ERR_NO_ERROR)
\r
4942 CmdPrintError(c, ret);
\r
4945 CiFreeClientGetAccount(&t);
\r
4948 FreeParamValueList(o);
\r
4953 // 接続設定のサーバー証明書の検証オプションの無効化
\r
4954 UINT PcAccountServerCertDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
4957 PC *pc = (PC *)param;
\r
4958 UINT ret = ERR_NO_ERROR;
\r
4959 RPC_CLIENT_GET_ACCOUNT t;
\r
4963 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
4967 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
4970 return ERR_INVALID_PARAMETER;
\r
4974 Zero(&t, sizeof(t));
\r
4976 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
4978 ret = CcGetAccount(pc->RemoteClient, &t);
\r
4980 if (ret == ERR_NO_ERROR)
\r
4982 RPC_CLIENT_CREATE_ACCOUNT z;
\r
4984 t.CheckServerCert = false;
\r
4986 Zero(&z, sizeof(z));
\r
4987 z.CheckServerCert = t.CheckServerCert;
\r
4988 z.ClientAuth = t.ClientAuth;
\r
4989 z.ClientOption = t.ClientOption;
\r
4990 z.ServerCert = t.ServerCert;
\r
4991 z.StartupAccount = t.StartupAccount;
\r
4993 ret = CcSetAccount(pc->RemoteClient, &z);
\r
4996 if (ret != ERR_NO_ERROR)
\r
4999 CmdPrintError(c, ret);
\r
5002 CiFreeClientGetAccount(&t);
\r
5005 FreeParamValueList(o);
\r
5010 // 接続設定のサーバー固有証明書の設定
\r
5011 UINT PcAccountServerCertSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5014 PC *pc = (PC *)param;
\r
5015 UINT ret = ERR_NO_ERROR;
\r
5016 RPC_CLIENT_GET_ACCOUNT t;
\r
5021 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5022 {"LOADCERT", CmdPrompt, _UU("CMD_LOADCERTPATH"), CmdEvalIsFile, NULL},
\r
5026 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5029 return ERR_INVALID_PARAMETER;
\r
5032 x = FileToX(GetParamStr(o, "LOADCERT"));
\r
5035 FreeParamValueList(o);
\r
5036 c->Write(c, _UU("CMD_LOADCERT_FAILED"));
\r
5037 return ERR_INTERNAL_ERROR;
\r
5041 Zero(&t, sizeof(t));
\r
5043 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5045 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5047 if (ret == ERR_NO_ERROR)
\r
5049 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5051 if (t.ServerCert != NULL)
\r
5053 FreeX(t.ServerCert);
\r
5055 t.ServerCert = CloneX(x);
\r
5057 Zero(&z, sizeof(z));
\r
5058 z.CheckServerCert = t.CheckServerCert;
\r
5059 z.ClientAuth = t.ClientAuth;
\r
5060 z.ClientOption = t.ClientOption;
\r
5061 z.ServerCert = t.ServerCert;
\r
5062 z.StartupAccount = t.StartupAccount;
\r
5064 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5067 if (ret != ERR_NO_ERROR)
\r
5070 CmdPrintError(c, ret);
\r
5073 CiFreeClientGetAccount(&t);
\r
5076 FreeParamValueList(o);
\r
5083 // 接続設定のサーバー固有証明書の削除
\r
5084 UINT PcAccountServerCertDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5087 PC *pc = (PC *)param;
\r
5088 UINT ret = ERR_NO_ERROR;
\r
5089 RPC_CLIENT_GET_ACCOUNT t;
\r
5093 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5097 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5100 return ERR_INVALID_PARAMETER;
\r
5104 Zero(&t, sizeof(t));
\r
5106 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5108 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5110 if (ret == ERR_NO_ERROR)
\r
5112 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5114 if (t.ServerCert != NULL)
\r
5116 FreeX(t.ServerCert);
\r
5118 t.ServerCert = NULL;
\r
5120 Zero(&z, sizeof(z));
\r
5121 z.CheckServerCert = t.CheckServerCert;
\r
5122 z.ClientAuth = t.ClientAuth;
\r
5123 z.ClientOption = t.ClientOption;
\r
5124 z.ServerCert = t.ServerCert;
\r
5125 z.StartupAccount = t.StartupAccount;
\r
5127 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5130 if (ret != ERR_NO_ERROR)
\r
5133 CmdPrintError(c, ret);
\r
5136 CiFreeClientGetAccount(&t);
\r
5139 FreeParamValueList(o);
\r
5144 // 接続設定のサーバー固有証明書の取得
\r
5145 UINT PcAccountServerCertGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5148 PC *pc = (PC *)param;
\r
5149 UINT ret = ERR_NO_ERROR;
\r
5150 RPC_CLIENT_GET_ACCOUNT t;
\r
5154 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5155 {"SAVECERT", CmdPrompt, _UU("CMD_SAVECERTPATH"), CmdEvalNotEmpty, NULL},
\r
5159 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5162 return ERR_INVALID_PARAMETER;
\r
5166 Zero(&t, sizeof(t));
\r
5168 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5170 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5172 if (ret == ERR_NO_ERROR)
\r
5174 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5176 if (t.ServerCert != NULL)
\r
5178 FreeX(t.ServerCert);
\r
5180 t.ServerCert = NULL;
\r
5182 Zero(&z, sizeof(z));
\r
5183 z.CheckServerCert = t.CheckServerCert;
\r
5184 z.ClientAuth = t.ClientAuth;
\r
5185 z.ClientOption = t.ClientOption;
\r
5186 z.ServerCert = t.ServerCert;
\r
5187 z.StartupAccount = t.StartupAccount;
\r
5189 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5192 if (ret != ERR_NO_ERROR)
\r
5195 CmdPrintError(c, ret);
\r
5198 CiFreeClientGetAccount(&t);
\r
5201 FreeParamValueList(o);
\r
5206 // 接続設定の高度な通信設定の設定
\r
5207 UINT PcAccountDetailSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5210 PC *pc = (PC *)param;
\r
5211 UINT ret = ERR_NO_ERROR;
\r
5212 RPC_CLIENT_GET_ACCOUNT t;
\r
5213 CMD_EVAL_MIN_MAX mm_maxtcp =
\r
5215 "CMD_CascadeDetailSet_Eval_MaxTcp", 1, 32
\r
5217 CMD_EVAL_MIN_MAX mm_interval =
\r
5219 "CMD_CascadeDetailSet_Eval_Interval", 1, 4294967295UL
\r
5224 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5225 {"MAXTCP", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_MaxTcp"), CmdEvalMinMax, &mm_maxtcp},
\r
5226 {"INTERVAL", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_Interval"), CmdEvalMinMax, &mm_interval},
\r
5227 {"TTL", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_TTL"), NULL, NULL},
\r
5228 {"HALF", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_HALF"), NULL, NULL},
\r
5229 {"BRIDGE", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_BRIDGE"), NULL, NULL},
\r
5230 {"MONITOR", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_MONITOR"), NULL, NULL},
\r
5231 {"NOTRACK", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_NOTRACK"), NULL, NULL},
\r
5232 {"NOQOS", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_NOQOS"), NULL, NULL},
\r
5236 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5239 return ERR_INVALID_PARAMETER;
\r
5243 Zero(&t, sizeof(t));
\r
5245 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5247 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5249 if (ret == ERR_NO_ERROR)
\r
5251 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5253 t.ClientOption->MaxConnection = GetParamInt(o, "MAXTCP");
\r
5254 t.ClientOption->AdditionalConnectionInterval = GetParamInt(o, "INTERVAL");
\r
5255 t.ClientOption->ConnectionDisconnectSpan = GetParamInt(o, "TTL");
\r
5256 t.ClientOption->HalfConnection = GetParamYes(o, "HALF");
\r
5257 t.ClientOption->RequireBridgeRoutingMode = GetParamYes(o, "BRIDGE");
\r
5258 t.ClientOption->RequireMonitorMode = GetParamYes(o, "MONITOR");
\r
5259 t.ClientOption->NoRoutingTracking = GetParamYes(o, "NOTRACK");
\r
5260 t.ClientOption->DisableQoS = GetParamYes(o, "NOQOS");
\r
5262 Zero(&z, sizeof(z));
\r
5263 z.CheckServerCert = t.CheckServerCert;
\r
5264 z.ClientAuth = t.ClientAuth;
\r
5265 z.ClientOption = t.ClientOption;
\r
5266 z.ServerCert = t.ServerCert;
\r
5267 z.StartupAccount = t.StartupAccount;
\r
5269 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5272 if (ret != ERR_NO_ERROR)
\r
5275 CmdPrintError(c, ret);
\r
5278 CiFreeClientGetAccount(&t);
\r
5281 FreeParamValueList(o);
\r
5287 UINT PcAccountRename(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5290 PC *pc = (PC *)param;
\r
5291 UINT ret = ERR_NO_ERROR;
\r
5292 RPC_RENAME_ACCOUNT t;
\r
5296 {"[name]", CmdPrompt, _UU("CMD_AccountRename_PROMPT_OLD"), CmdEvalNotEmpty, NULL},
\r
5297 {"NEW", CmdPrompt, _UU("CMD_AccountRename_PROMPT_NEW"), CmdEvalNotEmpty, NULL},
\r
5301 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5304 return ERR_INVALID_PARAMETER;
\r
5308 Zero(&t, sizeof(t));
\r
5309 UniStrCpy(t.NewName, sizeof(t.NewName), GetParamUniStr(o, "NEW"));
\r
5310 UniStrCpy(t.OldName, sizeof(t.OldName), GetParamUniStr(o, "[name]"));
\r
5312 ret = CcRenameAccount(pc->RemoteClient, &t);
\r
5314 if (ret == ERR_NO_ERROR)
\r
5319 if (ret != ERR_NO_ERROR)
\r
5322 CmdPrintError(c, ret);
\r
5326 FreeParamValueList(o);
\r
5331 // 接続設定を使用して VPN Server へ接続を開始
\r
5332 UINT PcAccountConnect(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5335 PC *pc = (PC *)param;
\r
5336 UINT ret = ERR_NO_ERROR;
\r
5337 RPC_CLIENT_CONNECT t;
\r
5341 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5345 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5348 return ERR_INVALID_PARAMETER;
\r
5352 Zero(&t, sizeof(t));
\r
5353 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5355 ret = CcConnect(pc->RemoteClient, &t);
\r
5357 if (ret == ERR_NO_ERROR)
\r
5362 if (ret != ERR_NO_ERROR)
\r
5365 CmdPrintError(c, ret);
\r
5369 FreeParamValueList(o);
\r
5375 UINT PcAccountDisconnect(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5378 PC *pc = (PC *)param;
\r
5379 UINT ret = ERR_NO_ERROR;
\r
5380 RPC_CLIENT_CONNECT t;
\r
5384 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5388 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5391 return ERR_INVALID_PARAMETER;
\r
5395 Zero(&t, sizeof(t));
\r
5396 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5398 ret = CcDisconnect(pc->RemoteClient, &t);
\r
5400 if (ret == ERR_NO_ERROR)
\r
5405 if (ret != ERR_NO_ERROR)
\r
5408 CmdPrintError(c, ret);
\r
5412 FreeParamValueList(o);
\r
5418 UINT PcAccountStatusGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5421 PC *pc = (PC *)param;
\r
5422 UINT ret = ERR_NO_ERROR;
\r
5423 RPC_CLIENT_GET_CONNECTION_STATUS t;
\r
5427 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5431 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5434 return ERR_INVALID_PARAMETER;
\r
5438 Zero(&t, sizeof(t));
\r
5439 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5441 ret = CcGetAccountStatus(pc->RemoteClient, &t);
\r
5443 if (ret == ERR_NO_ERROR)
\r
5445 if (t.Active == false)
\r
5448 ret = ERR_ACCOUNT_INACTIVE;
\r
5452 CT *ct = CtNewStandard();
\r
5454 CmdPrintStatusToListView(ct, &t);
\r
5460 if (ret != ERR_NO_ERROR)
\r
5463 CmdPrintError(c, ret);
\r
5466 CiFreeClientGetConnectionStatus(&t);
\r
5469 FreeParamValueList(o);
\r
5474 // 接続設定で使用する仮想 LAN カードの設定
\r
5475 UINT PcAccountNicSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5478 PC *pc = (PC *)param;
\r
5479 UINT ret = ERR_NO_ERROR;
\r
5480 RPC_CLIENT_GET_ACCOUNT t;
\r
5484 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5485 {"NICNAME", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Nicname"), CmdEvalNotEmpty, NULL},
\r
5489 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5492 return ERR_INVALID_PARAMETER;
\r
5496 Zero(&t, sizeof(t));
\r
5498 Zero(&t, sizeof(t));
\r
5499 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5501 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5503 if (ret == ERR_NO_ERROR)
\r
5505 RPC_CLIENT_CREATE_ACCOUNT c;
\r
5507 StrCpy(t.ClientOption->DeviceName, sizeof(t.ClientOption->DeviceName),
\r
5508 GetParamStr(o, "NICNAME"));
\r
5510 Zero(&c, sizeof(c));
\r
5512 c.ClientAuth = t.ClientAuth;
\r
5513 c.ClientOption = t.ClientOption;
\r
5514 c.CheckServerCert = t.CheckServerCert;
\r
5515 c.ServerCert = t.ServerCert;
\r
5516 c.StartupAccount = t.StartupAccount;
\r
5518 ret = CcSetAccount(pc->RemoteClient, &c);
\r
5521 if (ret != ERR_NO_ERROR)
\r
5524 CmdPrintError(c, ret);
\r
5527 CiFreeClientGetAccount(&t);
\r
5530 FreeParamValueList(o);
\r
5535 // VPN Server への接続中に接続状況やエラー画面を表示するように設定
\r
5536 UINT PcAccountStatusShow(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5539 PC *pc = (PC *)param;
\r
5540 UINT ret = ERR_NO_ERROR;
\r
5541 RPC_CLIENT_GET_ACCOUNT t;
\r
5545 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5549 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5552 return ERR_INVALID_PARAMETER;
\r
5556 Zero(&t, sizeof(t));
\r
5558 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5560 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5562 if (ret == ERR_NO_ERROR)
\r
5564 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5566 t.ClientOption->HideStatusWindow = false;
\r
5568 Zero(&z, sizeof(z));
\r
5569 z.CheckServerCert = t.CheckServerCert;
\r
5570 z.ClientAuth = t.ClientAuth;
\r
5571 z.ClientOption = t.ClientOption;
\r
5572 z.ServerCert = t.ServerCert;
\r
5573 z.StartupAccount = t.StartupAccount;
\r
5575 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5578 if (ret != ERR_NO_ERROR)
\r
5581 CmdPrintError(c, ret);
\r
5584 CiFreeClientGetAccount(&t);
\r
5587 FreeParamValueList(o);
\r
5592 // VPN Server への接続中に接続状況やエラー画面を表示しないように設定
\r
5593 UINT PcAccountStatusHide(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5596 PC *pc = (PC *)param;
\r
5597 UINT ret = ERR_NO_ERROR;
\r
5598 RPC_CLIENT_GET_ACCOUNT t;
\r
5602 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5606 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5609 return ERR_INVALID_PARAMETER;
\r
5613 Zero(&t, sizeof(t));
\r
5615 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5617 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5619 if (ret == ERR_NO_ERROR)
\r
5621 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5623 t.ClientOption->HideStatusWindow = true;
\r
5625 Zero(&z, sizeof(z));
\r
5626 z.CheckServerCert = t.CheckServerCert;
\r
5627 z.ClientAuth = t.ClientAuth;
\r
5628 z.ClientOption = t.ClientOption;
\r
5629 z.ServerCert = t.ServerCert;
\r
5630 z.StartupAccount = t.StartupAccount;
\r
5632 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5635 if (ret != ERR_NO_ERROR)
\r
5638 CmdPrintError(c, ret);
\r
5641 CiFreeClientGetAccount(&t);
\r
5644 FreeParamValueList(o);
\r
5649 // 接続設定のユーザー認証の種類をスマートカード認証に設定
\r
5650 UINT PcAccountSecureCertSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5653 PC *pc = (PC *)param;
\r
5654 UINT ret = ERR_NO_ERROR;
\r
5655 RPC_CLIENT_GET_ACCOUNT t;
\r
5659 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5660 {"CERTNAME", CmdPrompt, _UU("CMD_AccountSecureCertSet_PROMPT_CERTNAME"), CmdEvalNotEmpty, NULL},
\r
5661 {"KEYNAME", CmdPrompt, _UU("CMD_AccountSecureCertSet_PROMPT_KEYNAME"), CmdEvalNotEmpty, NULL},
\r
5665 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5668 return ERR_INVALID_PARAMETER;
\r
5672 Zero(&t, sizeof(t));
\r
5674 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5676 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5678 if (ret == ERR_NO_ERROR)
\r
5680 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5682 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_SECURE;
\r
5683 StrCpy(t.ClientAuth->SecurePublicCertName, sizeof(t.ClientAuth->SecurePublicCertName),
\r
5684 GetParamStr(o, "CERTNAME"));
\r
5685 StrCpy(t.ClientAuth->SecurePrivateKeyName, sizeof(t.ClientAuth->SecurePrivateKeyName),
\r
5686 GetParamStr(o, "KEYNAME"));
\r
5688 Zero(&z, sizeof(z));
\r
5689 z.CheckServerCert = t.CheckServerCert;
\r
5690 z.ClientAuth = t.ClientAuth;
\r
5691 z.ClientOption = t.ClientOption;
\r
5692 z.ServerCert = t.ServerCert;
\r
5693 z.StartupAccount = t.StartupAccount;
\r
5695 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5698 if (ret != ERR_NO_ERROR)
\r
5701 CmdPrintError(c, ret);
\r
5704 CiFreeClientGetAccount(&t);
\r
5707 FreeParamValueList(o);
\r
5712 // 接続設定の接続失敗または切断時の再試行回数と間隔の設定
\r
5713 UINT PcAccountRetrySet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5716 PC *pc = (PC *)param;
\r
5717 UINT ret = ERR_NO_ERROR;
\r
5718 RPC_CLIENT_GET_ACCOUNT t;
\r
5720 CMD_EVAL_MIN_MAX minmax =
\r
5722 "CMD_AccountRetrySet_EVAL_INTERVAL",
\r
5728 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5729 {"NUM", CmdPrompt, _UU("CMD_AccountRetrySet_PROMPT_NUM"), CmdEvalNotEmpty, NULL},
\r
5730 {"INTERVAL", CmdPrompt, _UU("CMD_AccountRetrySet_PROMPY_INTERVAL"), CmdEvalMinMax, &minmax},
\r
5734 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5737 return ERR_INVALID_PARAMETER;
\r
5741 Zero(&t, sizeof(t));
\r
5743 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5745 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5747 if (ret == ERR_NO_ERROR)
\r
5749 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5751 UINT num = GetParamInt(o, "NUM");
\r
5752 UINT interval = GetParamInt(o, "INTERVAL");
\r
5754 t.ClientOption->NumRetry = (num == 999) ? INFINITE : num;
\r
5755 t.ClientOption->RetryInterval = interval;
\r
5757 Zero(&z, sizeof(z));
\r
5758 z.CheckServerCert = t.CheckServerCert;
\r
5759 z.ClientAuth = t.ClientAuth;
\r
5760 z.ClientOption = t.ClientOption;
\r
5761 z.ServerCert = t.ServerCert;
\r
5762 z.StartupAccount = t.StartupAccount;
\r
5764 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5767 if (ret != ERR_NO_ERROR)
\r
5770 CmdPrintError(c, ret);
\r
5773 CiFreeClientGetAccount(&t);
\r
5776 FreeParamValueList(o);
\r
5782 // 接続設定をスタートアップ接続に設定
\r
5783 UINT PcAccountStartupSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5786 PC *pc = (PC *)param;
\r
5787 UINT ret = ERR_NO_ERROR;
\r
5788 RPC_CLIENT_GET_ACCOUNT t;
\r
5792 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5796 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5799 return ERR_INVALID_PARAMETER;
\r
5803 Zero(&t, sizeof(t));
\r
5805 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5807 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5809 if (ret == ERR_NO_ERROR)
\r
5811 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5813 t.StartupAccount = true;
\r
5815 Zero(&z, sizeof(z));
\r
5816 z.CheckServerCert = t.CheckServerCert;
\r
5817 z.ClientAuth = t.ClientAuth;
\r
5818 z.ClientOption = t.ClientOption;
\r
5819 z.ServerCert = t.ServerCert;
\r
5820 z.StartupAccount = t.StartupAccount;
\r
5822 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5825 if (ret != ERR_NO_ERROR)
\r
5828 CmdPrintError(c, ret);
\r
5831 CiFreeClientGetAccount(&t);
\r
5834 FreeParamValueList(o);
\r
5839 // 接続設定のスタートアップ接続を解除
\r
5840 UINT PcAccountStartupRemove(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5843 PC *pc = (PC *)param;
\r
5844 UINT ret = ERR_NO_ERROR;
\r
5845 RPC_CLIENT_GET_ACCOUNT t;
\r
5849 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5853 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5856 return ERR_INVALID_PARAMETER;
\r
5860 Zero(&t, sizeof(t));
\r
5862 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5864 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5866 if (ret == ERR_NO_ERROR)
\r
5868 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5870 t.StartupAccount = false;
\r
5872 Zero(&z, sizeof(z));
\r
5873 z.CheckServerCert = t.CheckServerCert;
\r
5874 z.ClientAuth = t.ClientAuth;
\r
5875 z.ClientOption = t.ClientOption;
\r
5876 z.ServerCert = t.ServerCert;
\r
5877 z.StartupAccount = t.StartupAccount;
\r
5879 ret = CcSetAccount(pc->RemoteClient, &z);
\r
5882 if (ret != ERR_NO_ERROR)
\r
5885 CmdPrintError(c, ret);
\r
5888 CiFreeClientGetAccount(&t);
\r
5891 FreeParamValueList(o);
\r
5897 UINT PcAccountExport(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
5900 PC *pc = (PC *)param;
\r
5901 UINT ret = ERR_NO_ERROR;
\r
5902 RPC_CLIENT_GET_ACCOUNT t;
\r
5906 {"[name]", CmdPrompt, _UU("CMD_AccountCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
5907 {"SAVEPATH", CmdPrompt, _UU("CMD_AccountExport_PROMPT_SAVEPATH"), CmdEvalNotEmpty, NULL},
\r
5911 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
5914 return ERR_INVALID_PARAMETER;
\r
5918 Zero(&t, sizeof(t));
\r
5920 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
5922 ret = CcGetAccount(pc->RemoteClient, &t);
\r
5924 if (ret == ERR_NO_ERROR)
\r
5926 RPC_CLIENT_CREATE_ACCOUNT z;
\r
5929 char tmp[MAX_SIZE];
\r
5932 UCHAR bom[] = {0xef, 0xbb, 0xbf, };
\r
5934 Zero(&z, sizeof(z));
\r
5935 z.CheckServerCert = t.CheckServerCert;
\r
5936 z.ClientAuth = t.ClientAuth;
\r
5937 z.ClientOption = t.ClientOption;
\r
5938 z.ServerCert = t.ServerCert;
\r
5939 z.StartupAccount = t.StartupAccount;
\r
5941 b = CiAccountToCfg(&z);
\r
5943 StrCpy(tmp, sizeof(tmp), GetParamStr(o, "SAVEPATH"));
\r
5946 WriteBuf(b2, bom, sizeof(bom));
\r
5949 buf_size = CalcUniToUtf8(_UU("CM_ACCOUNT_FILE_BANNER"));
\r
5950 buf = ZeroMalloc(buf_size + 32);
\r
5951 UniToUtf8(buf, buf_size, _UU("CM_ACCOUNT_FILE_BANNER"));
\r
5953 WriteBuf(b2, buf, StrLen((char *)buf));
\r
5954 WriteBuf(b2, b->Buf, b->Size);
\r
5955 SeekBuf(b2, 0, 0);
\r
5959 if (DumpBuf(b2, tmp) == false)
\r
5961 c->Write(c, _UU("CMD_SAVEFILE_FAILED"));
\r
5962 ret = ERR_INTERNAL_ERROR;
\r
5969 if (ret != ERR_NO_ERROR)
\r
5972 CmdPrintError(c, ret);
\r
5975 CiFreeClientGetAccount(&t);
\r
5978 FreeParamValueList(o);
\r
5983 // 指定されたアカウント名が存在するかチェックする
\r
5984 bool CmdIsAccountName(REMOTE_CLIENT *r, wchar_t *name)
\r
5987 RPC_CLIENT_ENUM_ACCOUNT t;
\r
5988 wchar_t tmp[MAX_SIZE];
\r
5991 if (r == NULL || name == NULL)
\r
5996 if (CcEnumAccount(r, &t) != ERR_NO_ERROR)
\r
6001 UniStrCpy(tmp, sizeof(tmp), name);
\r
6004 for (i = 0;i < t.NumItem;i++)
\r
6006 if (UniStrCmpi(t.Items[i]->AccountName, tmp) == 0)
\r
6013 CiFreeClientEnumAccount(&t);
\r
6019 void CmdGenerateImportName(REMOTE_CLIENT *r, wchar_t *name, UINT size, wchar_t *old_name)
\r
6023 if (r == NULL || name == NULL || old_name == NULL)
\r
6030 wchar_t tmp[MAX_SIZE];
\r
6033 UniFormat(tmp, sizeof(tmp), _UU("CM_IMPORT_NAME_1"), old_name);
\r
6037 UniFormat(tmp, sizeof(tmp), _UU("CM_IMPORT_NAME_2"), old_name, i);
\r
6040 if (CmdIsAccountName(r, tmp) == false)
\r
6042 UniStrCpy(name, size, tmp);
\r
6049 UINT PcAccountImport(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6052 PC *pc = (PC *)param;
\r
6053 UINT ret = ERR_NO_ERROR;
\r
6055 wchar_t name[MAX_SIZE];
\r
6059 {"[path]", CmdPrompt, _UU("CMD_AccountImport_PROMPT_PATH"), CmdEvalIsFile, NULL},
\r
6063 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
6066 return ERR_INVALID_PARAMETER;
\r
6070 b = ReadDump(GetParamStr(o, "[path]"));
\r
6075 c->Write(c, _UU("CMD_LOADFILE_FAILED"));
\r
6076 ret = ERR_INTERNAL_ERROR;
\r
6080 RPC_CLIENT_CREATE_ACCOUNT *t;
\r
6082 t = CiCfgToAccount(b);
\r
6087 c->Write(c, _UU("CMD_AccountImport_FAILED_PARSE"));
\r
6088 ret = ERR_INTERNAL_ERROR;
\r
6092 CmdGenerateImportName(pc->RemoteClient, name, sizeof(name), t->ClientOption->AccountName);
\r
6093 UniStrCpy(t->ClientOption->AccountName, sizeof(t->ClientOption->AccountName), name);
\r
6095 ret = CcCreateAccount(pc->RemoteClient, t);
\r
6097 if (ret == ERR_NO_ERROR)
\r
6099 wchar_t tmp[MAX_SIZE];
\r
6101 UniFormat(tmp, sizeof(tmp), _UU("CMD_AccountImport_OK"), name);
\r
6105 CiFreeClientCreateAccount(t);
\r
6112 if (ret != ERR_NO_ERROR)
\r
6115 CmdPrintError(c, ret);
\r
6119 FreeParamValueList(o);
\r
6124 // VPN Client サービスのリモート管理の許可
\r
6125 UINT PcRemoteEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6128 PC *pc = (PC *)param;
\r
6129 UINT ret = ERR_NO_ERROR;
\r
6133 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
6136 return ERR_INVALID_PARAMETER;
\r
6140 Zero(&t, sizeof(t));
\r
6142 ret = CcGetClientConfig(pc->RemoteClient, &t);
\r
6144 if (ret == ERR_NO_ERROR)
\r
6146 t.AllowRemoteConfig = true;
\r
6147 ret = CcSetClientConfig(pc->RemoteClient, &t);
\r
6150 if (ret == ERR_NO_ERROR)
\r
6155 if (ret != ERR_NO_ERROR)
\r
6158 CmdPrintError(c, ret);
\r
6162 FreeParamValueList(o);
\r
6167 // VPN Client サービスのリモート管理の禁止
\r
6168 UINT PcRemoteDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6171 PC *pc = (PC *)param;
\r
6172 UINT ret = ERR_NO_ERROR;
\r
6176 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
6179 return ERR_INVALID_PARAMETER;
\r
6183 Zero(&t, sizeof(t));
\r
6185 ret = CcGetClientConfig(pc->RemoteClient, &t);
\r
6187 if (ret == ERR_NO_ERROR)
\r
6189 t.AllowRemoteConfig = false;
\r
6190 ret = CcSetClientConfig(pc->RemoteClient, &t);
\r
6193 if (ret == ERR_NO_ERROR)
\r
6198 if (ret != ERR_NO_ERROR)
\r
6201 CmdPrintError(c, ret);
\r
6205 FreeParamValueList(o);
\r
6210 // インターネット接続の維持機能の有効化
\r
6211 UINT PcKeepEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6214 PC *pc = (PC *)param;
\r
6215 UINT ret = ERR_NO_ERROR;
\r
6219 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
6222 return ERR_INVALID_PARAMETER;
\r
6226 Zero(&t, sizeof(t));
\r
6228 ret = CcGetClientConfig(pc->RemoteClient, &t);
\r
6230 if (ret == ERR_NO_ERROR)
\r
6233 t.UseKeepConnect = true;
\r
6234 ret = CcSetClientConfig(pc->RemoteClient, &t);
\r
6237 if (ret == ERR_NO_ERROR)
\r
6242 if (ret != ERR_NO_ERROR)
\r
6245 CmdPrintError(c, ret);
\r
6249 FreeParamValueList(o);
\r
6254 // インターネット接続の維持機能の無効化
\r
6255 UINT PcKeepDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6258 PC *pc = (PC *)param;
\r
6259 UINT ret = ERR_NO_ERROR;
\r
6263 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
6266 return ERR_INVALID_PARAMETER;
\r
6270 Zero(&t, sizeof(t));
\r
6272 ret = CcGetClientConfig(pc->RemoteClient, &t);
\r
6274 if (ret == ERR_NO_ERROR)
\r
6277 t.UseKeepConnect = false;
\r
6278 ret = CcSetClientConfig(pc->RemoteClient, &t);
\r
6281 if (ret == ERR_NO_ERROR)
\r
6286 if (ret != ERR_NO_ERROR)
\r
6289 CmdPrintError(c, ret);
\r
6293 FreeParamValueList(o);
\r
6298 // インターネット接続の維持機能の設定
\r
6299 UINT PcKeepSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6302 PC *pc = (PC *)param;
\r
6303 UINT ret = ERR_NO_ERROR;
\r
6310 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
6311 {"HOST", CmdPrompt, _UU("CMD_KeepSet_PROMPT_HOST"), CmdEvalHostAndPort, NULL},
\r
6312 {"PROTOCOL", CmdPrompt, _UU("CMD_KeepSet_PROMPT_PROTOCOL"), CmdEvalTcpOrUdp, NULL},
\r
6313 {"INTERVAL", CmdPrompt, _UU("CMD_KeepSet_PROMPT_INTERVAL"), NULL, NULL},
\r
6316 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
6319 return ERR_INVALID_PARAMETER;
\r
6323 Zero(&t, sizeof(t));
\r
6325 ret = CcGetClientConfig(pc->RemoteClient, &t);
\r
6327 if (ret == ERR_NO_ERROR)
\r
6329 if (ParseHostPort(GetParamStr(o, "HOST"), &host, &port, 0))
\r
6331 StrCpy(t.KeepConnectHost, sizeof(t.KeepConnectHost), host);
\r
6332 t.KeepConnectPort = port;
\r
6333 t.KeepConnectInterval = GetParamInt(o, "INTERVAL");
\r
6334 t.KeepConnectProtocol = (StrCmpi(GetParamStr(o, "PROTOCOL"), "tcp") == 0) ? 0 : 1;
\r
6337 ret = CcSetClientConfig(pc->RemoteClient, &t);
\r
6341 if (ret != ERR_NO_ERROR)
\r
6344 CmdPrintError(c, ret);
\r
6348 FreeParamValueList(o);
\r
6353 // インターネット接続の維持機能の取得
\r
6354 UINT PcKeepGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6357 PC *pc = (PC *)param;
\r
6358 UINT ret = ERR_NO_ERROR;
\r
6361 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
6364 return ERR_INVALID_PARAMETER;
\r
6368 Zero(&t, sizeof(t));
\r
6370 ret = CcGetClientConfig(pc->RemoteClient, &t);
\r
6372 if (ret == ERR_NO_ERROR)
\r
6374 wchar_t tmp[MAX_SIZE];
\r
6375 CT *ct = CtNewStandard();
\r
6377 StrToUni(tmp, sizeof(tmp), t.KeepConnectHost);
\r
6378 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_1"), tmp);
\r
6380 UniToStru(tmp, t.KeepConnectPort);
\r
6381 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_2"), tmp);
\r
6383 UniToStru(tmp, t.KeepConnectInterval);
\r
6384 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_3"), tmp);
\r
6386 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_4"),
\r
6387 t.KeepConnectProtocol == 0 ? L"TCP/IP" : L"UDP/IP");
\r
6389 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_5"),
\r
6390 t.UseKeepConnect ? _UU("SM_ACCESS_ENABLE") : _UU("SM_ACCESS_DISABLE"));
\r
6395 if (ret != ERR_NO_ERROR)
\r
6398 CmdPrintError(c, ret);
\r
6402 FreeParamValueList(o);
\r
6408 // 新しいクライアント管理ツールコンテキストの作成
\r
6409 PC *NewPc(CONSOLE *c, REMOTE_CLIENT *remote_client, char *servername, wchar_t *cmdline)
\r
6413 if (c == NULL || remote_client == NULL || servername == NULL)
\r
6417 if (UniIsEmptyStr(cmdline))
\r
6422 pc = ZeroMalloc(sizeof(PC));
\r
6423 pc->ConsoleForServer = false;
\r
6424 pc->ServerName = CopyStr(servername);
\r
6426 pc->LastError = 0;
\r
6427 pc->RemoteClient = remote_client;
\r
6428 pc->CmdLine = CopyUniStr(cmdline);
\r
6433 // クライアント管理ツールコンテキストの解放
\r
6434 void FreePc(PC *pc)
\r
6442 Free(pc->ServerName);
\r
6443 Free(pc->CmdLine);
\r
6448 UINT PcConnect(CONSOLE *c, char *target, wchar_t *cmdline, char *password)
\r
6451 REMOTE_CLIENT *client;
\r
6454 char pass[MAX_SIZE];
\r
6457 if (c == NULL || target == NULL)
\r
6459 return ERR_INTERNAL_ERROR;
\r
6462 StrCpy(pass, sizeof(pass), password);
\r
6464 cedar = NewCedar(NULL, NULL);
\r
6467 client = CcConnectRpc(target, pass, &bad_pass, &no_remote, 0);
\r
6469 if (client == NULL)
\r
6474 c->Write(c, _UU("CMD_UTVPNCMD_CLIENT_NO_REMODE"));
\r
6475 ReleaseCedar(cedar);
\r
6476 return ERR_INTERNAL_ERROR;
\r
6478 else if (bad_pass)
\r
6482 c->Write(c, _UU("CMD_UTVPNCMD_PASSWORD_1"));
\r
6483 tmp = c->ReadPassword(c, _UU("CMD_UTVPNCMD_PASSWORD_2"));
\r
6489 ReleaseCedar(cedar);
\r
6490 return ERR_ACCESS_DENIED;
\r
6494 StrCpy(pass, sizeof(pass), tmp);
\r
6503 CmdPrintError(c, ERR_CONNECT_FAILED);
\r
6504 ReleaseCedar(cedar);
\r
6505 return ERR_CONNECT_FAILED;
\r
6511 PC *pc = NewPc(c, client, target, cmdline);
\r
6513 ret = pc->LastError;
\r
6517 CcDisconnectRpc(client);
\r
6519 ReleaseCedar(cedar);
\r
6525 // サーバー管理ツールプロセッサメイン
\r
6526 void PsMain(PS *ps)
\r
6528 char prompt[MAX_SIZE];
\r
6529 wchar_t tmp[MAX_SIZE];
\r
6536 // CSV モードでなければ、接続が完了したメッセージを表示する
\r
6537 if(ps->Console->ConsoleType != CONSOLE_CSV)
\r
6539 UniFormat(tmp, sizeof(tmp), _UU("CMD_UTVPNCMD_SERVER_CONNECTED"),
\r
6540 ps->ServerName, ps->ServerPort);
\r
6541 ps->Console->Write(ps->Console, tmp);
\r
6542 ps->Console->Write(ps->Console, L"");
\r
6544 if (ps->HubName == NULL)
\r
6547 ps->Console->Write(ps->Console, _UU("CMD_UTVPNCMD_SERVER_CONNECTED_1"));
\r
6552 UniFormat(tmp, sizeof(tmp), _UU("CMD_UTVPNCMD_SERVER_CONNECTED_2"),
\r
6554 ps->Console->Write(ps->Console, tmp);
\r
6556 ps->Console->Write(ps->Console, L"");
\r
6560 ps->CapsList = ScGetCapsEx(ps->Rpc);
\r
6562 if (ps->AdminHub != NULL)
\r
6566 wchar_t tmp[MAX_SIZE];
\r
6568 // ADMINHUB で指定された仮想 HUB を選択する
\r
6569 Zero(&t, sizeof(t));
\r
6571 StrCpy(t.HubName, sizeof(t.HubName), ps->AdminHub);
\r
6573 ret = ScGetHubStatus(ps->Rpc, &t);
\r
6574 if (ret == ERR_NO_ERROR)
\r
6577 UniFormat(tmp, sizeof(tmp), _UU("CMD_Hub_Selected"), t.HubName);
\r
6579 if (ps->HubName != NULL)
\r
6581 Free(ps->HubName);
\r
6583 ps->HubName = CopyStr(t.HubName);
\r
6585 if( ps->Console->ConsoleType != CONSOLE_CSV)
\r
6587 ps->Console->Write(ps->Console, tmp);
\r
6593 UniFormat(tmp, sizeof(tmp), _UU("CMD_Hub_Select_Failed"), ps->AdminHub);
\r
6595 ps->Console->Write(ps->Console, tmp);
\r
6596 CmdPrintError(ps->Console, ret);
\r
6605 {"About", PsAbout},
\r
6606 {"Check", PtCheck},
\r
6607 {"Crash", PsCrash},
\r
6608 {"Flush", PsFlush},
\r
6609 {"Debug", PsDebug},
\r
6610 {"ServerInfoGet", PsServerInfoGet},
\r
6611 {"ServerStatusGet", PsServerStatusGet},
\r
6612 {"ListenerCreate", PsListenerCreate},
\r
6613 {"ListenerDelete", PsListenerDelete},
\r
6614 {"ListenerList", PsListenerList},
\r
6615 {"ListenerEnable", PsListenerEnable},
\r
6616 {"ListenerDisable", PsListenerDisable},
\r
6617 {"ServerPasswordSet", PsServerPasswordSet},
\r
6618 {"ClusterSettingGet", PsClusterSettingGet},
\r
6619 {"ClusterSettingStandalone", PsClusterSettingStandalone},
\r
6620 {"ClusterSettingController", PsClusterSettingController},
\r
6621 {"ClusterSettingMember", PsClusterSettingMember},
\r
6622 {"ClusterMemberList", PsClusterMemberList},
\r
6623 {"ClusterMemberInfoGet", PsClusterMemberInfoGet},
\r
6624 {"ClusterMemberCertGet", PsClusterMemberCertGet},
\r
6625 {"ClusterConnectionStatusGet", PsClusterConnectionStatusGet},
\r
6626 {"ServerCertGet", PsServerCertGet},
\r
6627 {"ServerKeyGet", PsServerKeyGet},
\r
6628 {"ServerCertSet", PsServerCertSet},
\r
6629 {"ServerCipherGet", PsServerCipherGet},
\r
6630 {"ServerCipherSet", PsServerCipherSet},
\r
6631 {"KeepEnable", PsKeepEnable},
\r
6632 {"KeepDisable", PsKeepDisable},
\r
6633 {"KeepSet", PsKeepSet},
\r
6634 {"KeepGet", PsKeepGet},
\r
6635 {"SyslogGet", PsSyslogGet},
\r
6636 {"SyslogDisable", PsSyslogDisable},
\r
6637 {"SyslogEnable", PsSyslogEnable},
\r
6638 {"ConnectionList", PsConnectionList},
\r
6639 {"ConnectionGet", PsConnectionGet},
\r
6640 {"ConnectionDisconnect", PsConnectionDisconnect},
\r
6641 {"BridgeDeviceList", PsBridgeDeviceList},
\r
6642 {"BridgeList", PsBridgeList},
\r
6643 {"BridgeCreate", PsBridgeCreate},
\r
6644 {"BridgeDelete", PsBridgeDelete},
\r
6646 {"Reboot", PsReboot},
\r
6647 {"ConfigGet", PsConfigGet},
\r
6648 {"ConfigSet", PsConfigSet},
\r
6649 {"RouterList", PsRouterList},
\r
6650 {"RouterAdd", PsRouterAdd},
\r
6651 {"RouterDelete", PsRouterDelete},
\r
6652 {"RouterStart", PsRouterStart},
\r
6653 {"RouterStop", PsRouterStop},
\r
6654 {"RouterIfList", PsRouterIfList},
\r
6655 {"RouterIfAdd", PsRouterIfAdd},
\r
6656 {"RouterIfDel", PsRouterIfDel},
\r
6657 {"RouterTableList", PsRouterTableList},
\r
6658 {"RouterTableAdd", PsRouterTableAdd},
\r
6659 {"RouterTableDel", PsRouterTableDel},
\r
6660 {"LogFileList", PsLogFileList},
\r
6661 {"LogFileGet", PsLogFileGet},
\r
6662 {"HubCreate", PsHubCreate},
\r
6663 {"HubCreateDynamic", PsHubCreateDynamic},
\r
6664 {"HubCreateStatic", PsHubCreateStatic},
\r
6665 {"HubDelete", PsHubDelete},
\r
6666 {"HubSetStatic", PsHubSetStatic},
\r
6667 {"HubSetDynamic", PsHubSetDynamic},
\r
6668 {"HubList", PsHubList},
\r
6670 {"Online", PsOnline},
\r
6671 {"Offline", PsOffline},
\r
6672 {"SetMaxSession", PsSetMaxSession},
\r
6673 {"SetHubPassword", PsSetHubPassword},
\r
6674 {"SetEnumAllow", PsSetEnumAllow},
\r
6675 {"SetEnumDeny", PsSetEnumDeny},
\r
6676 {"OptionsGet", PsOptionsGet},
\r
6677 {"RadiusServerSet", PsRadiusServerSet},
\r
6678 {"RadiusServerDelete", PsRadiusServerDelete},
\r
6679 {"RadiusServerGet", PsRadiusServerGet},
\r
6680 {"StatusGet", PsStatusGet},
\r
6681 {"LogGet", PsLogGet},
\r
6682 {"LogEnable", PsLogEnable},
\r
6683 {"LogDisable", PsLogDisable},
\r
6684 {"LogSwitchSet", PsLogSwitchSet},
\r
6685 {"LogPacketSaveType", PsLogPacketSaveType},
\r
6686 {"CAList", PsCAList},
\r
6687 {"CAAdd", PsCAAdd},
\r
6688 {"CADelete", PsCADelete},
\r
6689 {"CAGet", PsCAGet},
\r
6690 {"CascadeList", PsCascadeList},
\r
6691 {"CascadeCreate", PsCascadeCreate},
\r
6692 {"CascadeSet", PsCascadeSet},
\r
6693 {"CascadeGet", PsCascadeGet},
\r
6694 {"CascadeDelete", PsCascadeDelete},
\r
6695 {"CascadeUsernameSet", PsCascadeUsernameSet},
\r
6696 {"CascadeAnonymousSet", PsCascadeAnonymousSet},
\r
6697 {"CascadePasswordSet", PsCascadePasswordSet},
\r
6698 {"CascadeCertSet", PsCascadeCertSet},
\r
6699 {"CascadeCertGet", PsCascadeCertGet},
\r
6700 {"CascadeEncryptEnable", PsCascadeEncryptEnable},
\r
6701 {"CascadeEncryptDisable", PsCascadeEncryptDisable},
\r
6702 {"CascadeCompressEnable", PsCascadeCompressEnable},
\r
6703 {"CascadeCompressDisable", PsCascadeCompressDisable},
\r
6704 {"CascadeProxyNone", PsCascadeProxyNone},
\r
6705 {"CascadeProxyHttp", PsCascadeProxyHttp},
\r
6706 {"CascadeProxySocks", PsCascadeProxySocks},
\r
6707 {"CascadeServerCertEnable", PsCascadeServerCertEnable},
\r
6708 {"CascadeServerCertDisable", PsCascadeServerCertDisable},
\r
6709 {"CascadeServerCertSet", PsCascadeServerCertSet},
\r
6710 {"CascadeServerCertDelete", PsCascadeServerCertDelete},
\r
6711 {"CascadeServerCertGet", PsCascadeServerCertGet},
\r
6712 {"CascadeDetailSet", PsCascadeDetailSet},
\r
6713 {"CascadePolicySet", PsCascadePolicySet},
\r
6714 {"PolicyList", PsPolicyList},
\r
6715 {"CascadeStatusGet", PsCascadeStatusGet},
\r
6716 {"CascadeRename", PsCascadeRename},
\r
6717 {"CascadeOnline", PsCascadeOnline},
\r
6718 {"CascadeOffline", PsCascadeOffline},
\r
6719 {"AccessAdd", PsAccessAdd},
\r
6720 {"AccessAddEx", PsAccessAddEx},
\r
6721 {"AccessAdd6", PsAccessAdd6},
\r
6722 {"AccessAddEx6", PsAccessAddEx6},
\r
6723 {"AccessList", PsAccessList},
\r
6724 {"AccessDelete", PsAccessDelete},
\r
6725 {"AccessEnable", PsAccessEnable},
\r
6726 {"AccessDisable", PsAccessDisable},
\r
6727 {"UserList", PsUserList},
\r
6728 {"UserCreate", PsUserCreate},
\r
6729 {"UserSet", PsUserSet},
\r
6730 {"UserDelete", PsUserDelete},
\r
6731 {"UserGet", PsUserGet},
\r
6732 {"UserAnonymousSet", PsUserAnonymousSet},
\r
6733 {"UserPasswordSet", PsUserPasswordSet},
\r
6734 {"UserCertSet", PsUserCertSet},
\r
6735 {"UserCertGet", PsUserCertGet},
\r
6736 {"UserSignedSet", PsUserSignedSet},
\r
6737 {"UserRadiusSet", PsUserRadiusSet},
\r
6738 {"UserNTLMSet", PsUserNTLMSet},
\r
6739 {"UserPolicyRemove", PsUserPolicyRemove},
\r
6740 {"UserPolicySet", PsUserPolicySet},
\r
6741 {"UserExpiresSet", PsUserExpiresSet},
\r
6742 {"GroupList", PsGroupList},
\r
6743 {"GroupCreate", PsGroupCreate},
\r
6744 {"GroupSet", PsGroupSet},
\r
6745 {"GroupDelete", PsGroupDelete},
\r
6746 {"GroupGet", PsGroupGet},
\r
6747 {"GroupJoin", PsGroupJoin},
\r
6748 {"GroupUnjoin", PsGroupUnjoin},
\r
6749 {"GroupPolicyRemove", PsGroupPolicyRemove},
\r
6750 {"GroupPolicySet", PsGroupPolicySet},
\r
6751 {"SessionList", PsSessionList},
\r
6752 {"SessionGet", PsSessionGet},
\r
6753 {"SessionDisconnect", PsSessionDisconnect},
\r
6754 {"MacTable", PsMacTable},
\r
6755 {"MacDelete", PsMacDelete},
\r
6756 {"IpTable", PsIpTable},
\r
6757 {"IpDelete", PsIpDelete},
\r
6758 {"SecureNatEnable", PsSecureNatEnable},
\r
6759 {"SecureNatDisable", PsSecureNatDisable},
\r
6760 {"SecureNatStatusGet", PsSecureNatStatusGet},
\r
6761 {"SecureNatHostGet", PsSecureNatHostGet},
\r
6762 {"SecureNatHostSet", PsSecureNatHostSet},
\r
6763 {"NatGet", PsNatGet},
\r
6764 {"NatEnable", PsNatEnable},
\r
6765 {"NatDisable", PsNatDisable},
\r
6766 {"NatSet", PsNatSet},
\r
6767 {"NatTable", PsNatTable},
\r
6768 {"DhcpGet", PsDhcpGet},
\r
6769 {"DhcpEnable", PsDhcpEnable},
\r
6770 {"DhcpDisable", PsDhcpDisable},
\r
6771 {"DhcpSet", PsDhcpSet},
\r
6772 {"DhcpTable", PsDhcpTable},
\r
6773 {"AdminOptionList", PsAdminOptionList},
\r
6774 {"AdminOptionSet", PsAdminOptionSet},
\r
6775 {"ExtOptionList", PsExtOptionList},
\r
6776 {"ExtOptionSet", PsExtOptionSet},
\r
6777 {"CrlList", PsCrlList},
\r
6778 {"CrlAdd", PsCrlAdd},
\r
6779 {"CrlDel", PsCrlDel},
\r
6780 {"CrlGet", PsCrlGet},
\r
6781 {"AcList", PsAcList},
\r
6782 {"AcAdd", PsAcAdd},
\r
6783 {"AcAdd6", PsAcAdd6},
\r
6784 {"AcDel", PsAcDel},
\r
6785 {"MakeCert", PtMakeCert},
\r
6786 {"TrafficClient", PtTrafficClient},
\r
6787 {"TrafficServer", PtTrafficServer},
\r
6788 {"LicenseAdd", PsLicenseAdd},
\r
6789 {"LicenseDel", PsLicenseDel},
\r
6790 {"LicenseList", PsLicenseList},
\r
6791 {"LicenseStatus", PsLicenseStatus},
\r
6795 if (ps->HubName == NULL)
\r
6797 Format(prompt, sizeof(prompt), "VPN Server>");
\r
6801 Format(prompt, sizeof(prompt), "VPN Server/%s>", ps->HubName);
\r
6804 if (DispatchNextCmdEx(ps->Console, ps->CmdLine, prompt, cmd, sizeof(cmd) / sizeof(cmd[0]), ps) == false)
\r
6808 ps->LastError = ps->Console->RetCode;
\r
6810 if (ps->LastError == ERR_NO_ERROR && ps->Console->ConsoleType != CONSOLE_CSV)
\r
6812 ps->Console->Write(ps->Console, _UU("CMD_MSG_OK"));
\r
6813 ps->Console->Write(ps->Console, L"");
\r
6816 if (ps->CmdLine != NULL)
\r
6823 FreeCapsList(ps->CapsList);
\r
6824 ps->CapsList = NULL;
\r
6827 // 新しいコマンド関数のテンプレート
\r
6828 UINT PsXxx(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6831 PS *ps = (PS *)param;
\r
6836 {"[port]", CmdPromptPort, _UU("CMD_ListenerCreate_PortPrompt"), CmdEvalPort, NULL},
\r
6839 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
6842 return ERR_INVALID_PARAMETER;
\r
6845 Zero(&t, sizeof(t));
\r
6847 t.Port = ToInt(GetParamStr(o, "[port]"));
\r
6849 ret = ScCreateListener(ps->Rpc, &t);
\r
6851 if (ret != ERR_NO_ERROR)
\r
6853 CmdPrintError(c, ret);
\r
6854 FreeParamValueList(o);
\r
6858 FreeParamValueList(o);
\r
6864 UINT PsClusterSettingStandalone(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6867 PS *ps = (PS *)param;
\r
6871 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
6874 return ERR_INVALID_PARAMETER;
\r
6877 Zero(&t, sizeof(t));
\r
6878 t.ServerType = SERVER_TYPE_STANDALONE;
\r
6881 ret = ScSetFarmSetting(ps->Rpc, &t);
\r
6883 if (ret != ERR_NO_ERROR)
\r
6886 CmdPrintError(c, ret);
\r
6887 FreeParamValueList(o);
\r
6891 FreeParamValueList(o);
\r
6896 // クラスタコントローラモードに設定
\r
6897 UINT PsClusterSettingController(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
6900 PS *ps = (PS *)param;
\r
6906 {"WEIGHT", NULL, NULL, NULL, NULL},
\r
6907 {"ONLY", NULL, NULL, NULL, NULL},
\r
6910 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
6913 return ERR_INVALID_PARAMETER;
\r
6916 weight = GetParamInt(o, "WEIGHT");
\r
6919 weight = FARM_DEFAULT_WEIGHT;
\r
6922 Zero(&t, sizeof(t));
\r
6923 t.ServerType = SERVER_TYPE_FARM_CONTROLLER;
\r
6924 t.Weight = weight;
\r
6925 t.ControllerOnly = GetParamYes(o, "ONLY");
\r
6928 ret = ScSetFarmSetting(ps->Rpc, &t);
\r
6930 if (ret != ERR_NO_ERROR)
\r
6933 CmdPrintError(c, ret);
\r
6934 FreeParamValueList(o);
\r
6938 FreeParamValueList(o);
\r
6944 bool CmdEvalIp(CONSOLE *c, wchar_t *str, void *param)
\r
6947 if (c == NULL || str == NULL)
\r
6952 if (UniIsEmptyStr(str))
\r
6957 if (UniStrToIP32(str) == 0 && UniStrCmpi(str, L"0.0.0.0") != 0)
\r
6959 wchar_t *msg = (param == NULL) ? _UU("CMD_IP_EVAL_FAILED") : (wchar_t *)param;
\r
6968 LIST *StrToPortList(char *str)
\r
6979 t = ParseToken(str, ", ");
\r
6984 if (t->NumTokens == 0)
\r
6990 o = NewListFast(NULL);
\r
6992 for (i = 0;i < t->NumTokens;i++)
\r
6994 char *s = t->Token[i];
\r
6996 if (IsNum(s) == false)
\r
7003 if (n == 0 || n >= 65536)
\r
7009 if (IsInList(o, (void *)n))
\r
7015 Add(o, (void *)n);
\r
7020 if (LIST_NUM(o) > MAX_PUBLIC_PORT_NUM)
\r
7030 UINT PsClusterSettingMember(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7033 PS *ps = (PS *)param;
\r
7036 char *host_and_port;
\r
7043 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
7044 {"[server:port]", CmdPrompt, _UU("CMD_ClusterSettingMember_Prompt_HOST_1"), CmdEvalHostAndPort, NULL},
\r
7045 {"IP", PsClusterSettingMemberPromptIp, NULL, CmdEvalIp, NULL},
\r
7046 {"PORTS", PsClusterSettingMemberPromptPorts, NULL, CmdEvalPortList, NULL},
\r
7047 {"PASSWORD", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
7048 {"WEIGHT", NULL, NULL, NULL, NULL},
\r
7051 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
7054 return ERR_INVALID_PARAMETER;
\r
7057 weight = GetParamInt(o, "WEIGHT");
\r
7061 weight = FARM_DEFAULT_WEIGHT;
\r
7064 Zero(&t, sizeof(t));
\r
7065 host_and_port = GetParamStr(o, "[server:port]");
\r
7066 if (ParseHostPort(host_and_port, &host, &port, 0))
\r
7073 StrCpy(t.ControllerName, sizeof(t.ControllerName), host);
\r
7074 t.ControllerPort = port;
\r
7077 pw = GetParamStr(o, "PASSWORD");
\r
7079 Hash(t.MemberPassword, pw, StrLen(pw), true);
\r
7080 t.PublicIp = StrToIP32(GetParamStr(o, "IP"));
\r
7081 t.ServerType = SERVER_TYPE_FARM_MEMBER;
\r
7083 ports_str = GetParamStr(o, "PORTS");
\r
7085 ports = StrToPortList(ports_str);
\r
7087 t.NumPort = LIST_NUM(ports);
\r
7088 t.Ports = ZeroMalloc(sizeof(UINT) * t.NumPort);
\r
7090 for (i = 0;i < t.NumPort;i++)
\r
7092 t.Ports[i] = (UINT)LIST_DATA(ports, i);
\r
7095 t.Weight = weight;
\r
7097 ReleaseList(ports);
\r
7100 ret = ScSetFarmSetting(ps->Rpc, &t);
\r
7102 if (ret != ERR_NO_ERROR)
\r
7105 CmdPrintError(c, ret);
\r
7106 FreeParamValueList(o);
\r
7113 FreeParamValueList(o);
\r
7119 bool CmdEvalPortList(CONSOLE *c, wchar_t *str, void *param)
\r
7125 if (c == NULL || str == NULL)
\r
7130 s = CopyUniToStr(str);
\r
7132 o = StrToPortList(s);
\r
7145 c->Write(c, _UU("CMD_PORTLIST_EVAL_FAILED"));
\r
7151 // ホスト名とポート番号の形式の文字列のチェック
\r
7152 bool CmdEvalHostAndPort(CONSOLE *c, wchar_t *str, void *param)
\r
7157 if (c == NULL || str == NULL)
\r
7162 tmp = CopyUniToStr(str);
\r
7164 ret = ParseHostPort(tmp, NULL, NULL, (UINT)param);
\r
7168 c->Write(c, param == NULL ? _UU("CMD_HOSTPORT_EVAL_FAILED") : (wchar_t *)param);
\r
7177 wchar_t *PsClusterSettingMemberPromptPorts(CONSOLE *c, void *param)
\r
7186 c->Write(c, _UU("CMD_ClusterSettingMember_Prompt_PORT_1"));
\r
7189 ret = c->ReadLine(c, _UU("CMD_ClusterSettingMember_Prompt_PORT_2"), true);
\r
7195 wchar_t *PsClusterSettingMemberPromptIp(CONSOLE *c, void *param)
\r
7204 c->Write(c, _UU("CMD_ClusterSettingMember_Prompt_IP_1"));
\r
7207 ret = c->ReadLine(c, _UU("CMD_ClusterSettingMember_Prompt_IP_2"), true);
\r
7213 UINT PsClusterMemberList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7216 PS *ps = (PS *)param;
\r
7222 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
7225 return ERR_INVALID_PARAMETER;
\r
7228 Zero(&t, sizeof(t));
\r
7231 ret = ScEnumFarmMember(ps->Rpc, &t);
\r
7233 if (ret != ERR_NO_ERROR)
\r
7236 CmdPrintError(c, ret);
\r
7237 FreeParamValueList(o);
\r
7243 CtInsertColumn(ct, _UU("CMD_ID"), true);
\r
7244 CtInsertColumn(ct, _UU("SM_FM_COLUMN_1"), false);
\r
7245 CtInsertColumn(ct, _UU("SM_FM_COLUMN_2"), false);
\r
7246 CtInsertColumn(ct, _UU("SM_FM_COLUMN_3"), false);
\r
7247 CtInsertColumn(ct, _UU("SM_FM_COLUMN_4"), true);
\r
7248 CtInsertColumn(ct, _UU("SM_FM_COLUMN_5"), true);
\r
7249 CtInsertColumn(ct, _UU("SM_FM_COLUMN_6"), true);
\r
7250 CtInsertColumn(ct, _UU("SM_FM_COLUMN_7"), true);
\r
7251 CtInsertColumn(ct, _UU("SM_FM_COLUMN_8"), true);
\r
7252 CtInsertColumn(ct, _UU("SM_FM_COLUMN_9"), true);
\r
7254 for (i = 0;i < t.NumFarm;i++)
\r
7256 RPC_ENUM_FARM_ITEM *e = &t.Farms[i];
\r
7258 wchar_t tmp1[MAX_SIZE];
\r
7259 wchar_t tmp2[MAX_SIZE];
\r
7267 GetDateTimeStrEx64(tmp1, sizeof(tmp1), SystemToLocal64(e->ConnectedTime), NULL);
\r
7268 StrToUni(tmp2, sizeof(tmp2), e->Hostname);
\r
7269 UniToStru(tmp3, e->Point);
\r
7270 UniToStru(tmp4, e->NumSessions);
\r
7271 UniToStru(tmp5, e->NumTcpConnections);
\r
7272 UniToStru(tmp6, e->NumHubs);
\r
7273 UniToStru(tmp7, e->AssignedClientLicense);
\r
7274 UniToStru(tmp8, e->AssignedBridgeLicense);
\r
7276 UniToStru(tmp0, e->Id);
\r
7278 CtInsert(ct, tmp0,
\r
7279 e->Controller ? _UU("SM_FM_CONTROLLER") : _UU("SM_FM_MEMBER"),
\r
7280 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8);
\r
7285 FreeRpcEnumFarm(&t);
\r
7287 FreeParamValueList(o);
\r
7293 UINT PsClusterMemberInfoGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7296 PS *ps = (PS *)param;
\r
7303 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
7304 {"[id]", CmdPrompt, _UU("CMD_ClusterMemberInfoGet_PROMPT_ID"), NULL, NULL},
\r
7307 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
7310 return ERR_INVALID_PARAMETER;
\r
7313 Zero(&t, sizeof(t));
\r
7314 t.Id = UniToInt(GetParamUniStr(o, "[id]"));
\r
7317 ret = ScGetFarmInfo(ps->Rpc, &t);
\r
7319 if (ret != ERR_NO_ERROR)
\r
7322 CmdPrintError(c, ret);
\r
7323 FreeParamValueList(o);
\r
7327 ct = CtNewStandard();
\r
7330 wchar_t tmp[MAX_SIZE];
\r
7331 char str[MAX_SIZE];
\r
7334 CtInsert(ct, _UU("SM_FMINFO_TYPE"),
\r
7335 t.Controller ? _UU("SM_FARM_CONTROLLER") : _UU("SM_FARM_MEMBER"));
\r
7337 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.ConnectedTime), NULL);
\r
7338 CtInsert(ct, _UU("SM_FMINFO_CONNECT_TIME"), tmp);
\r
7340 IPToStr32(str, sizeof(str), t.Ip);
\r
7341 StrToUni(tmp, sizeof(tmp), str);
\r
7342 CtInsert(ct, _UU("SM_FMINFO_IP"), tmp);
\r
7344 StrToUni(tmp, sizeof(tmp), t.Hostname);
\r
7345 CtInsert(ct, _UU("SM_FMINFO_HOSTNAME"), tmp);
\r
7347 UniToStru(tmp, t.Point);
\r
7348 CtInsert(ct, _UU("SM_FMINFO_POINT"), tmp);
\r
7350 UniToStru(tmp, t.Weight);
\r
7351 CtInsert(ct, _UU("SM_FMINFO_WEIGHT"), tmp);
\r
7353 UniToStru(tmp, t.NumPort);
\r
7354 CtInsert(ct, _UU("SM_FMINFO_NUM_PORT"), tmp);
\r
7356 for (i = 0;i < t.NumPort;i++)
\r
7358 wchar_t tmp2[MAX_SIZE];
\r
7359 UniFormat(tmp, sizeof(tmp), _UU("SM_FMINFO_PORT"), i + 1);
\r
7360 UniToStru(tmp2, t.Ports[i]);
\r
7361 CtInsert(ct, tmp, tmp2);
\r
7364 UniToStru(tmp, t.NumFarmHub);
\r
7365 CtInsert(ct, _UU("SM_FMINFO_NUM_HUB"), tmp);
\r
7367 for (i = 0;i < t.NumFarmHub;i++)
\r
7369 wchar_t tmp2[MAX_SIZE];
\r
7370 UniFormat(tmp, sizeof(tmp), _UU("SM_FMINFO_HUB"), i + 1);
\r
7371 UniFormat(tmp2, sizeof(tmp2),
\r
7372 t.FarmHubs[i].DynamicHub ? _UU("SM_FMINFO_HUB_TAG_2") : _UU("SM_FMINFO_HUB_TAG_1"),
\r
7373 t.FarmHubs[i].HubName);
\r
7374 CtInsert(ct, tmp, tmp2);
\r
7377 UniToStru(tmp, t.NumSessions);
\r
7378 CtInsert(ct, _UU("SM_FMINFO_NUM_SESSION"), tmp);
\r
7380 UniToStru(tmp, t.NumTcpConnections);
\r
7381 CtInsert(ct, _UU("SM_FMINFO_NUN_CONNECTION"), tmp);
\r
7386 FreeRpcFarmInfo(&t);
\r
7388 FreeParamValueList(o);
\r
7393 // クラスタ メンバの証明書の取得
\r
7394 UINT PsClusterMemberCertGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7397 PS *ps = (PS *)param;
\r
7403 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
7404 {"[id]", CmdPrompt, _UU("CMD_ClusterMemberCertGet_PROMPT_ID"), NULL, NULL},
\r
7405 {"SAVECERT", CmdPrompt, _UU("CMD_SAVECERTPATH"), CmdEvalNotEmpty, NULL},
\r
7408 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
7411 return ERR_INVALID_PARAMETER;
\r
7414 Zero(&t, sizeof(t));
\r
7416 t.Id = UniToInt(GetParamUniStr(o, "[id]"));
\r
7419 ret = ScGetFarmInfo(ps->Rpc, &t);
\r
7421 if (ret != ERR_NO_ERROR)
\r
7424 CmdPrintError(c, ret);
\r
7425 FreeParamValueList(o);
\r
7430 X *x = t.ServerCert;
\r
7431 char *filename = GetParamStr(o, "SAVECERT");
\r
7433 if (XToFile(x, filename, true) == false)
\r
7435 c->Write(c, _UU("CMD_SAVECERT_FAILED"));
\r
7437 ret = ERR_INTERNAL_ERROR;
\r
7441 FreeRpcFarmInfo(&t);
\r
7443 FreeParamValueList(o);
\r
7448 // クラスタ コントローラへの接続状態の取得
\r
7449 UINT PsClusterConnectionStatusGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7452 PS *ps = (PS *)param;
\r
7454 RPC_FARM_CONNECTION_STATUS t;
\r
7455 wchar_t tmp[MAX_SIZE];
\r
7457 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
7460 return ERR_INVALID_PARAMETER;
\r
7463 Zero(&t, sizeof(t));
\r
7466 ret = ScGetFarmConnectionStatus(ps->Rpc, &t);
\r
7468 if (ret != ERR_NO_ERROR)
\r
7471 CmdPrintError(c, ret);
\r
7472 FreeParamValueList(o);
\r
7477 CT *ct = CtNewStandard();
\r
7478 char str[MAX_SIZE];
\r
7480 if (t.Online == false)
\r
7482 CtInsert(ct, _UU("SM_FC_IP"), _UU("SM_FC_NOT_CONNECTED"));
\r
7484 CtInsert(ct, _UU("SM_FC_PORT"), _UU("SM_FC_NOT_CONNECTED"));
\r
7488 IPToStr32(str, sizeof(str), t.Ip);
\r
7489 StrToUni(tmp, sizeof(tmp), str);
\r
7490 CtInsert(ct, _UU("SM_FC_IP"), tmp);
\r
7492 UniToStru(tmp, t.Port);
\r
7493 CtInsert(ct, _UU("SM_FC_PORT"), tmp);
\r
7497 _UU("SM_FC_STATUS"),
\r
7498 t.Online ? _UU("SM_FC_ONLINE") : _UU("SM_FC_OFFLINE"));
\r
7500 if (t.Online == false)
\r
7502 UniFormat(tmp, sizeof(tmp), _UU("SM_FC_ERROR_TAG"), _E(t.LastError), t.LastError);
\r
7504 _UU("SM_FC_LAST_ERROR"), tmp);
\r
7507 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.StartedTime), NULL);
\r
7508 CtInsert(ct, _UU("SM_FC_START_TIME"), tmp);
\r
7510 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.FirstConnectedTime), NULL);
\r
7511 CtInsert(ct, _UU("SM_FC_FIRST_TIME"), tmp);
\r
7513 //if (t.Online == false)
\r
7515 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.CurrentConnectedTime), NULL);
\r
7516 CtInsert(ct, _UU("SM_FC_CURRENT_TIME"), tmp);
\r
7519 UniToStru(tmp, t.NumTry);
\r
7520 CtInsert(ct, _UU("SM_FC_NUM_TRY"), tmp);
\r
7522 UniToStru(tmp, t.NumConnected);
\r
7523 CtInsert(ct, _UU("SM_FC_NUM_CONNECTED"), tmp);
\r
7525 UniToStru(tmp, t.NumFailed);
\r
7526 CtInsert(ct, _UU("SM_FC_NUM_FAILED"), tmp);
\r
7531 FreeParamValueList(o);
\r
7536 // VPN Server の SSL 証明書の取得
\r
7537 UINT PsServerCertGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7540 PS *ps = (PS *)param;
\r
7546 {"[cert]", CmdPrompt, _UU("CMD_SAVECERTPATH"), CmdEvalNotEmpty, NULL},
\r
7549 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
7552 return ERR_INVALID_PARAMETER;
\r
7555 Zero(&t, sizeof(t));
\r
7558 ret = ScGetServerCert(ps->Rpc, &t);
\r
7560 if (ret != ERR_NO_ERROR)
\r
7563 CmdPrintError(c, ret);
\r
7564 FreeParamValueList(o);
\r
7568 if (XToFile(t.Cert, GetParamStr(o, "[cert]"), true) == false)
\r
7570 c->Write(c, _UU("CMD_SAVECERT_FAILED"));
\r
7573 FreeRpcKeyPair(&t);
\r
7575 FreeParamValueList(o);
\r
7580 // VPN Server の SSL 証明書の秘密鍵の取得
\r
7581 UINT PsServerKeyGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7584 PS *ps = (PS *)param;
\r
7590 {"[key]", CmdPrompt, _UU("CMD_SAVEKEYPATH"), CmdEvalNotEmpty, NULL},
\r
7593 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
7596 return ERR_INVALID_PARAMETER;
\r
7599 Zero(&t, sizeof(t));
\r
7602 ret = ScGetServerCert(ps->Rpc, &t);
\r
7604 if (ret != ERR_NO_ERROR)
\r
7607 CmdPrintError(c, ret);
\r
7608 FreeParamValueList(o);
\r
7612 if (t.Key != NULL)
\r
7614 if (KToFile(t.Key, GetParamStr(o, "[key]"), true, NULL) == false)
\r
7616 c->Write(c, _UU("CMD_SAVEKEY_FAILED"));
\r
7621 ret = ERR_NOT_ENOUGH_RIGHT;
\r
7622 CmdPrintError(c, ret);
\r
7625 FreeRpcKeyPair(&t);
\r
7627 FreeParamValueList(o);
\r
7633 bool CmdLoadCertAndKey(CONSOLE *c, X **xx, K **kk, char *cert_filename, char *key_filename)
\r
7638 if (c == NULL || cert_filename == NULL || key_filename == NULL || xx == NULL || kk == NULL)
\r
7643 x = FileToX(cert_filename);
\r
7646 c->Write(c, _UU("CMD_LOADCERT_FAILED"));
\r
7650 k = CmdLoadKey(c, key_filename);
\r
7653 c->Write(c, _UU("CMD_LOADKEY_FAILED"));
\r
7658 if (CheckXandK(x, k) == false)
\r
7660 c->Write(c, _UU("CMD_KEYPAIR_FAILED"));
\r
7674 K *CmdLoadKey(CONSOLE *c, char *filename)
\r
7678 if (c == NULL || filename == NULL)
\r
7683 b = ReadDump(filename);
\r
7686 c->Write(c, _UU("CMD_LOADCERT_FAILED"));
\r
7692 if (IsEncryptedK(b, true) == false)
\r
7694 key = BufToK(b, true, IsBase64(b), NULL);
\r
7698 c->Write(c, _UU("CMD_LOADKEY_ENCRYPTED_1"));
\r
7702 char *pass = c->ReadPassword(c, _UU("CMD_LOADKEY_ENCRYPTED_2"));
\r
7710 key = BufToK(b, true, IsBase64(b), pass);
\r
7718 c->Write(c, _UU("CMD_LOADKEY_ENCRYPTED_3"));
\r
7728 // VPN Server の SSL 証明書と秘密鍵の設定
\r
7729 UINT PsServerCertSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7732 PS *ps = (PS *)param;
\r
7738 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
7739 {"LOADCERT", CmdPrompt, _UU("CMD_LOADCERTPATH"), CmdEvalIsFile, NULL},
\r
7740 {"LOADKEY", CmdPrompt, _UU("CMD_LOADKEYPATH"), CmdEvalIsFile, NULL},
\r
7743 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
7746 return ERR_INVALID_PARAMETER;
\r
7749 Zero(&t, sizeof(t));
\r
7751 if (CmdLoadCertAndKey(c, &t.Cert, &t.Key,
\r
7752 GetParamStr(o, "LOADCERT"),
\r
7753 GetParamStr(o, "LOADKEY")))
\r
7756 ret = ScSetServerCert(ps->Rpc, &t);
\r
7758 if (ret != ERR_NO_ERROR)
\r
7761 CmdPrintError(c, ret);
\r
7762 FreeParamValueList(o);
\r
7766 FreeRpcKeyPair(&t);
\r
7770 ret = ERR_INTERNAL_ERROR;
\r
7773 FreeParamValueList(o);
\r
7778 // VPN 通信で使用される暗号化アルゴリズムの取得
\r
7779 UINT PsServerCipherGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7782 PS *ps = (PS *)param;
\r
7785 TOKEN_LIST *ciphers;
\r
7787 wchar_t tmp[MAX_SIZE];
\r
7789 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
7792 return ERR_INVALID_PARAMETER;
\r
7795 Zero(&t, sizeof(t));
\r
7798 ret = ScGetServerCipher(ps->Rpc, &t);
\r
7800 if (ret != ERR_NO_ERROR)
\r
7803 CmdPrintError(c, ret);
\r
7804 FreeParamValueList(o);
\r
7808 ciphers = GetCipherList();
\r
7810 c->Write(c, _UU("CMD_ServerCipherGet_SERVER"));
\r
7812 UniFormat(tmp, sizeof(tmp), L" %S", t.String);
\r
7816 c->Write(c, _UU("CMD_ServerCipherGet_CIPHERS"));
\r
7818 for (i = 0;i < ciphers->NumTokens;i++)
\r
7820 UniFormat(tmp, sizeof(tmp), L" %S", ciphers->Token[i]);
\r
7826 FreeParamValueList(o);
\r
7831 // VPN 通信で使用される暗号化アルゴリズムの設定
\r
7832 UINT PsServerCipherSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7835 PS *ps = (PS *)param;
\r
7841 {"[name]", CmdPrompt, _UU("CMD_ServerCipherSet_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
7844 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
7847 return ERR_INVALID_PARAMETER;
\r
7850 Zero(&t, sizeof(t));
\r
7851 t.String = CopyStr(GetParamStr(o, "[name]"));
\r
7854 ret = ScSetServerCipher(ps->Rpc, &t);
\r
7856 if (ret != ERR_NO_ERROR)
\r
7859 CmdPrintError(c, ret);
\r
7860 FreeParamValueList(o);
\r
7866 FreeParamValueList(o);
\r
7871 // インターネット接続の維持機能の有効化
\r
7872 UINT PsKeepEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7875 PS *ps = (PS *)param;
\r
7879 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
7882 return ERR_INVALID_PARAMETER;
\r
7885 Zero(&t, sizeof(t));
\r
7888 ret = ScGetKeep(ps->Rpc, &t);
\r
7890 if (ret != ERR_NO_ERROR)
\r
7893 CmdPrintError(c, ret);
\r
7894 FreeParamValueList(o);
\r
7898 t.UseKeepConnect = true;
\r
7900 ret = ScSetKeep(ps->Rpc, &t);
\r
7902 if (ret != ERR_NO_ERROR)
\r
7905 CmdPrintError(c, ret);
\r
7906 FreeParamValueList(o);
\r
7910 FreeParamValueList(o);
\r
7915 // インターネット接続の維持機能の無効化
\r
7916 UINT PsKeepDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7919 PS *ps = (PS *)param;
\r
7923 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
7926 return ERR_INVALID_PARAMETER;
\r
7929 Zero(&t, sizeof(t));
\r
7932 ret = ScGetKeep(ps->Rpc, &t);
\r
7934 if (ret != ERR_NO_ERROR)
\r
7937 CmdPrintError(c, ret);
\r
7938 FreeParamValueList(o);
\r
7942 t.UseKeepConnect = false;
\r
7944 ret = ScSetKeep(ps->Rpc, &t);
\r
7946 if (ret != ERR_NO_ERROR)
\r
7949 CmdPrintError(c, ret);
\r
7950 FreeParamValueList(o);
\r
7954 FreeParamValueList(o);
\r
7959 // tcp または udp の評価
\r
7960 bool CmdEvalTcpOrUdp(CONSOLE *c, wchar_t *str, void *param)
\r
7963 if (c == NULL || str == NULL)
\r
7968 if (UniStrCmpi(str, L"tcp") == 0 || UniStrCmpi(str, L"udp") == 0)
\r
7973 c->Write(c, _UU("CMD_KeepSet_EVAL_TCP_UDP"));
\r
7979 UINT PsSyslogEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
7982 PS *ps = (PS *)param;
\r
7985 CMD_EVAL_MIN_MAX minmax = {"CMD_SyslogEnable_MINMAX", 1, 3};
\r
7992 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
7993 {"[1|2|3]", CmdPrompt, _UU("CMD_SyslogEnable_Prompt_123"), CmdEvalMinMax, &minmax},
\r
7994 {"HOST", CmdPrompt, _UU("CMD_SyslogEnable_Prompt_HOST"), CmdEvalHostAndPort, (void *)SYSLOG_PORT},
\r
7997 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8000 return ERR_INVALID_PARAMETER;
\r
8003 Zero(&t, sizeof(t));
\r
8005 if (ParseHostPort(GetParamStr(o, "HOST"), &host, &port, SYSLOG_PORT))
\r
8007 StrCpy(t.Hostname, sizeof(t.Hostname), host);
\r
8009 t.SaveType = GetParamInt(o, "[1|2|3]");
\r
8014 ret = ScSetSysLog(ps->Rpc, &t);
\r
8016 if (ret != ERR_NO_ERROR)
\r
8019 CmdPrintError(c, ret);
\r
8020 FreeParamValueList(o);
\r
8025 FreeParamValueList(o);
\r
8031 UINT PsSyslogDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8034 PS *ps = (PS *)param;
\r
8038 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
8041 return ERR_INVALID_PARAMETER;
\r
8044 Zero(&t, sizeof(t));
\r
8047 ret = ScGetSysLog(ps->Rpc, &t);
\r
8049 if (ret != ERR_NO_ERROR)
\r
8052 CmdPrintError(c, ret);
\r
8053 FreeParamValueList(o);
\r
8057 t.SaveType = SYSLOG_NONE;
\r
8060 ret = ScSetSysLog(ps->Rpc, &t);
\r
8062 if (ret != ERR_NO_ERROR)
\r
8065 CmdPrintError(c, ret);
\r
8066 FreeParamValueList(o);
\r
8070 FreeParamValueList(o);
\r
8076 UINT PsSyslogGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8079 PS *ps = (PS *)param;
\r
8083 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
8086 return ERR_INVALID_PARAMETER;
\r
8089 Zero(&t, sizeof(t));
\r
8092 ret = ScGetSysLog(ps->Rpc, &t);
\r
8094 if (ret != ERR_NO_ERROR)
\r
8097 CmdPrintError(c, ret);
\r
8098 FreeParamValueList(o);
\r
8103 wchar_t tmp[MAX_SIZE];
\r
8104 CT *ct = CtNewStandard();
\r
8106 CtInsert(ct, _UU("CMD_SyslogGet_COLUMN_1"), GetSyslogSettingName(t.SaveType));
\r
8108 if (t.SaveType != SYSLOG_NONE)
\r
8110 StrToUni(tmp, sizeof(tmp), t.Hostname);
\r
8111 CtInsert(ct, _UU("CMD_SyslogGet_COLUMN_2"), tmp);
\r
8113 UniToStru(tmp, t.Port);
\r
8114 CtInsert(ct, _UU("CMD_SyslogGet_COLUMN_3"), tmp);
\r
8120 FreeParamValueList(o);
\r
8126 wchar_t *GetSyslogSettingName(UINT n)
\r
8128 char tmp[MAX_PATH];
\r
8130 Format(tmp, sizeof(tmp), "SM_SYSLOG_%u", n);
\r
8135 // インターネット接続の維持機能の設定
\r
8136 UINT PsKeepSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8139 PS *ps = (PS *)param;
\r
8147 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
8148 {"HOST", CmdPrompt, _UU("CMD_KeepSet_PROMPT_HOST"), CmdEvalHostAndPort, NULL},
\r
8149 {"PROTOCOL", CmdPrompt, _UU("CMD_KeepSet_PROMPT_PROTOCOL"), CmdEvalTcpOrUdp, NULL},
\r
8150 {"INTERVAL", CmdPrompt, _UU("CMD_KeepSet_PROMPT_INTERVAL"), NULL, NULL},
\r
8153 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8156 return ERR_INVALID_PARAMETER;
\r
8159 Zero(&t, sizeof(t));
\r
8162 ret = ScGetKeep(ps->Rpc, &t);
\r
8164 if (ret != ERR_NO_ERROR)
\r
8167 CmdPrintError(c, ret);
\r
8168 FreeParamValueList(o);
\r
8172 if (ParseHostPort(GetParamStr(o, "HOST"), &host, &port, 0))
\r
8174 StrCpy(t.KeepConnectHost, sizeof(t.KeepConnectHost), host);
\r
8175 t.KeepConnectPort = port;
\r
8176 t.KeepConnectInterval = GetParamInt(o, "INTERVAL");
\r
8177 t.KeepConnectProtocol = (StrCmpi(GetParamStr(o, "PROTOCOL"), "tcp") == 0) ? 0 : 1;
\r
8181 ret = ScSetKeep(ps->Rpc, &t);
\r
8183 if (ret != ERR_NO_ERROR)
\r
8186 CmdPrintError(c, ret);
\r
8187 FreeParamValueList(o);
\r
8192 FreeParamValueList(o);
\r
8197 // インターネット接続の維持機能の取得
\r
8198 UINT PsKeepGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8201 PS *ps = (PS *)param;
\r
8205 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
8208 return ERR_INVALID_PARAMETER;
\r
8211 Zero(&t, sizeof(t));
\r
8214 ret = ScGetKeep(ps->Rpc, &t);
\r
8216 if (ret != ERR_NO_ERROR)
\r
8219 CmdPrintError(c, ret);
\r
8220 FreeParamValueList(o);
\r
8225 wchar_t tmp[MAX_SIZE];
\r
8226 CT *ct = CtNewStandard();
\r
8228 StrToUni(tmp, sizeof(tmp), t.KeepConnectHost);
\r
8229 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_1"), tmp);
\r
8231 UniToStru(tmp, t.KeepConnectPort);
\r
8232 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_2"), tmp);
\r
8234 UniToStru(tmp, t.KeepConnectInterval);
\r
8235 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_3"), tmp);
\r
8237 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_4"),
\r
8238 t.KeepConnectProtocol == 0 ? L"TCP/IP" : L"UDP/IP");
\r
8240 CtInsert(ct, _UU("CMD_KeepGet_COLUMN_5"),
\r
8241 t.UseKeepConnect ? _UU("SM_ACCESS_ENABLE") : _UU("SM_ACCESS_DISABLE"));
\r
8246 FreeParamValueList(o);
\r
8252 wchar_t *GetConnectionTypeStr(UINT type)
\r
8254 char tmp[MAX_SIZE];
\r
8255 Format(tmp, sizeof(tmp), "SM_CONNECTION_TYPE_%u", type);
\r
8260 // VPN Server に接続中の TCP コネクション一覧の取得
\r
8261 UINT PsConnectionList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8264 PS *ps = (PS *)param;
\r
8266 RPC_ENUM_CONNECTION t;
\r
8270 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
8273 return ERR_INVALID_PARAMETER;
\r
8276 Zero(&t, sizeof(t));
\r
8279 ret = ScEnumConnection(ps->Rpc, &t);
\r
8281 if (ret != ERR_NO_ERROR)
\r
8284 CmdPrintError(c, ret);
\r
8285 FreeParamValueList(o);
\r
8290 CtInsertColumn(ct, _UU("SM_CONN_COLUMN_1"), false);
\r
8291 CtInsertColumn(ct, _UU("SM_CONN_COLUMN_2"), false);
\r
8292 CtInsertColumn(ct, _UU("SM_CONN_COLUMN_3"), false);
\r
8293 CtInsertColumn(ct, _UU("SM_CONN_COLUMN_4"), false);
\r
8295 for (i = 0;i < t.NumConnection;i++)
\r
8297 wchar_t tmp[MAX_SIZE];
\r
8298 wchar_t name[MAX_SIZE];
\r
8299 wchar_t datetime[MAX_SIZE];
\r
8300 RPC_ENUM_CONNECTION_ITEM *e = &t.Connections[i];
\r
8302 StrToUni(name, sizeof(name), e->Name);
\r
8303 UniFormat(tmp, sizeof(tmp), _UU("SM_HOSTNAME_AND_PORT"), e->Hostname, e->Port);
\r
8304 GetDateTimeStrEx64(datetime, sizeof(datetime), SystemToLocal64(e->ConnectedTime), NULL);
\r
8306 CtInsert(ct, name, tmp, datetime,
\r
8307 GetConnectionTypeStr(e->Type));
\r
8312 FreeRpcEnumConnetion(&t);
\r
8314 FreeParamValueList(o);
\r
8319 // VPN Server に接続中の TCP コネクションの情報の取得
\r
8320 UINT PsConnectionGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8323 PS *ps = (PS *)param;
\r
8325 RPC_CONNECTION_INFO t;
\r
8327 wchar_t tmp[MAX_SIZE];
\r
8331 {"[name]", CmdPrompt, _UU("CMD_ConnectionGet_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
8334 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8337 return ERR_INVALID_PARAMETER;
\r
8340 Zero(&t, sizeof(t));
\r
8342 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
8345 ret = ScGetConnectionInfo(ps->Rpc, &t);
\r
8347 if (ret != ERR_NO_ERROR)
\r
8350 CmdPrintError(c, ret);
\r
8351 FreeParamValueList(o);
\r
8356 ct = CtNewStandard();
\r
8358 StrToUni(tmp, sizeof(tmp), t.Name);
\r
8359 CtInsert(ct, _UU("SM_CONNINFO_NAME"), tmp);
\r
8361 CtInsert(ct, _UU("SM_CONNINFO_TYPE"), GetConnectionTypeStr(t.Type));
\r
8363 StrToUni(tmp, sizeof(tmp), t.Hostname);
\r
8364 CtInsert(ct, _UU("SM_CONNINFO_HOSTNAME"), tmp);
\r
8366 UniToStru(tmp, t.Port);
\r
8367 CtInsert(ct, _UU("SM_CONNINFO_PORT"), tmp);
\r
8369 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.ConnectedTime), NULL);
\r
8370 CtInsert(ct, _UU("SM_CONNINFO_TIME"), tmp);
\r
8372 StrToUni(tmp, sizeof(tmp), t.ServerStr);
\r
8373 CtInsert(ct, _UU("SM_CONNINFO_SERVER_STR"), tmp);
\r
8375 UniFormat(tmp, sizeof(tmp), L"%u.%02u", t.ServerVer / 100, t.ServerVer % 100);
\r
8376 CtInsert(ct, _UU("SM_CONNINFO_SERVER_VER"), tmp);
\r
8378 UniToStru(tmp, t.ServerBuild);
\r
8379 CtInsert(ct, _UU("SM_CONNINFO_SERVER_BUILD"), tmp);
\r
8381 if (StrLen(t.ClientStr) != 0)
\r
8383 StrToUni(tmp, sizeof(tmp), t.ClientStr);
\r
8384 CtInsert(ct, _UU("SM_CONNINFO_CLIENT_STR"), tmp);
\r
8386 UniFormat(tmp, sizeof(tmp), L"%u.%02u", t.ClientVer / 100, t.ClientVer % 100);
\r
8387 CtInsert(ct, _UU("SM_CONNINFO_CLIENT_VER"), tmp);
\r
8389 UniToStru(tmp, t.ClientBuild);
\r
8390 CtInsert(ct, _UU("SM_CONNINFO_CLIENT_BUILD"), tmp);
\r
8396 FreeParamValueList(o);
\r
8401 // VPN Server に接続中の TCP コネクションの切断
\r
8402 UINT PsConnectionDisconnect(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8405 PS *ps = (PS *)param;
\r
8407 RPC_DISCONNECT_CONNECTION t;
\r
8411 {"[name]", CmdPrompt, _UU("CMD_ConnectionDisconnect_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
8414 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8417 return ERR_INVALID_PARAMETER;
\r
8420 Zero(&t, sizeof(t));
\r
8422 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
8425 ret = ScDisconnectConnection(ps->Rpc, &t);
\r
8427 if (ret != ERR_NO_ERROR)
\r
8430 CmdPrintError(c, ret);
\r
8431 FreeParamValueList(o);
\r
8435 FreeParamValueList(o);
\r
8440 // ローカル ブリッジに使用できる LAN カード一覧の取得
\r
8441 UINT PsBridgeDeviceList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8444 PS *ps = (PS *)param;
\r
8449 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
8452 return ERR_INVALID_PARAMETER;
\r
8455 Zero(&t, sizeof(t));
\r
8458 ret = ScEnumEthernet(ps->Rpc, &t);
\r
8460 if (ret != ERR_NO_ERROR)
\r
8463 CmdPrintError(c, ret);
\r
8464 FreeParamValueList(o);
\r
8468 for (i = 0;i < t.NumItem;i++)
\r
8470 RPC_ENUM_ETH_ITEM *item = &t.Items[i];
\r
8471 wchar_t tmp[MAX_SIZE * 2];
\r
8473 if(UniIsEmptyStr(item->NetworkConnectionName) == false)
\r
8475 UniFormat(tmp, sizeof(tmp), BRIDGE_NETWORK_CONNECTION_STR, item->NetworkConnectionName, item->DeviceName);
\r
8479 StrToUni(tmp, sizeof(tmp), item->DeviceName);
\r
8484 FreeRpcEnumEth(&t);
\r
8486 FreeParamValueList(o);
\r
8491 // ローカル ブリッジ接続の一覧の取得
\r
8492 UINT PsBridgeList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8495 PS *ps = (PS *)param;
\r
8497 RPC_ENUM_LOCALBRIDGE t;
\r
8501 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
8504 return ERR_INVALID_PARAMETER;
\r
8507 Zero(&t, sizeof(t));
\r
8510 ret = ScEnumLocalBridge(ps->Rpc, &t);
\r
8512 if (ret != ERR_NO_ERROR)
\r
8515 CmdPrintError(c, ret);
\r
8516 FreeParamValueList(o);
\r
8522 CtInsertColumn(ct, _UU("SM_BRIDGE_COLUMN_1"), false);
\r
8523 CtInsertColumn(ct, _UU("SM_BRIDGE_COLUMN_2"), false);
\r
8524 CtInsertColumn(ct, _UU("SM_BRIDGE_COLUMN_3"), false);
\r
8525 CtInsertColumn(ct, _UU("SM_BRIDGE_COLUMN_4"), false);
\r
8527 for (i = 0;i < t.NumItem;i++)
\r
8529 RPC_LOCALBRIDGE *e = &t.Items[i];
\r
8530 wchar_t name[MAX_SIZE];
\r
8531 wchar_t nic[MAX_SIZE];
\r
8532 wchar_t hub[MAX_SIZE];
\r
8533 wchar_t *status = _UU("SM_BRIDGE_OFFLINE");
\r
8535 UniToStru(name, i + 1);
\r
8536 StrToUni(nic, sizeof(nic), e->DeviceName);
\r
8537 StrToUni(hub, sizeof(hub), e->HubName);
\r
8541 status = e->Active ? _UU("SM_BRIDGE_ONLINE") : _UU("SM_BRIDGE_ERROR");
\r
8544 CtInsert(ct, name, hub, nic, status);
\r
8549 FreeRpcEnumLocalBridge(&t);
\r
8551 FreeParamValueList(o);
\r
8557 UINT PsBridgeCreate(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8560 PS *ps = (PS *)param;
\r
8562 RPC_LOCALBRIDGE t;
\r
8566 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
8567 {"[hubname]", CmdPrompt, _UU("CMD_BridgeCreate_PROMPT_HUBNAME"), CmdEvalNotEmpty, NULL},
\r
8568 {"DEVICE", CmdPrompt, _UU("CMD_BridgeCreate_PROMPT_DEVICE"), CmdEvalNotEmpty, NULL},
\r
8569 {"TAP", NULL, NULL, NULL, NULL},
\r
8572 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8575 return ERR_INVALID_PARAMETER;
\r
8578 Zero(&t, sizeof(t));
\r
8581 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "DEVICE"));
\r
8582 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[hubname]"));
\r
8584 t.TapMode = GetParamYes(o, "TAP");
\r
8587 ret = ScAddLocalBridge(ps->Rpc, &t);
\r
8589 if (ret != ERR_NO_ERROR)
\r
8592 CmdPrintError(c, ret);
\r
8593 FreeParamValueList(o);
\r
8598 c->Write(c, _UU("SM_BRIDGE_INTEL"));
\r
8602 FreeParamValueList(o);
\r
8608 UINT PsBridgeDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8611 PS *ps = (PS *)param;
\r
8613 RPC_LOCALBRIDGE t;
\r
8617 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
8618 {"[hubname]", CmdPrompt, _UU("CMD_BridgeDelete_PROMPT_HUBNAME"), CmdEvalNotEmpty, NULL},
\r
8619 {"DEVICE", CmdPrompt, _UU("CMD_BridgeDelete_PROMPT_DEVICE"), CmdEvalNotEmpty, NULL},
\r
8622 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8625 return ERR_INVALID_PARAMETER;
\r
8628 Zero(&t, sizeof(t));
\r
8630 StrCpy(t.DeviceName, sizeof(t.DeviceName), GetParamStr(o, "DEVICE"));
\r
8631 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[hubname]"));
\r
8634 ret = ScDeleteLocalBridge(ps->Rpc, &t);
\r
8636 if (ret != ERR_NO_ERROR)
\r
8639 CmdPrintError(c, ret);
\r
8640 FreeParamValueList(o);
\r
8644 FreeParamValueList(o);
\r
8649 // サーバーの機能・能力一覧の取得
\r
8650 UINT PsCaps(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8653 PS *ps = (PS *)param;
\r
8657 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
8660 return ERR_INVALID_PARAMETER;
\r
8664 t = ScGetCapsEx(ps->Rpc);
\r
8666 if (ret != ERR_NO_ERROR)
\r
8669 CmdPrintError(c, ret);
\r
8670 FreeParamValueList(o);
\r
8678 ct = CtNewStandard();
\r
8680 for (i = 0;i < LIST_NUM(t->CapsList);i++)
\r
8682 CAPS *c = LIST_DATA(t->CapsList, i);
\r
8683 wchar_t title[MAX_SIZE];
\r
8686 Format(name, sizeof(name), "CT_%s", c->Name);
\r
8688 UniStrCpy(title, sizeof(title), _UU(name));
\r
8690 if (UniIsEmptyStr(title))
\r
8692 UniFormat(title, sizeof(title), L"%S", (StrLen(c->Name) >= 2) ? c->Name + 2 : c->Name);
\r
8695 if (StartWith(c->Name, "b_"))
\r
8697 bool icon_pass = c->Value == 0 ? false : true;
\r
8698 if (StrCmpi(c->Name, "b_must_install_pcap") == 0)
\r
8700 // WinPcap の項目のみ反転する
\r
8701 icon_pass = !icon_pass;
\r
8703 CtInsert(ct, title, c->Value == 0 ? _UU("CAPS_NO") : _UU("CAPS_YES"));
\r
8708 UniToStru(str, c->Value);
\r
8709 CtInsert(ct, title, str);
\r
8718 FreeParamValueList(o);
\r
8723 // VPN Server サービスの再起動
\r
8724 UINT PsReboot(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8727 PS *ps = (PS *)param;
\r
8733 {"RESETCONFIG", NULL, NULL, NULL, NULL},
\r
8736 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8739 return ERR_INVALID_PARAMETER;
\r
8742 Zero(&t, sizeof(t));
\r
8744 t.IntValue = GetParamYes(o, "RESETCONFIG") ? 1 : 0;
\r
8747 ret = ScRebootServer(ps->Rpc, &t);
\r
8749 if (ret != ERR_NO_ERROR)
\r
8752 CmdPrintError(c, ret);
\r
8753 FreeParamValueList(o);
\r
8759 FreeParamValueList(o);
\r
8764 // VPN Server の現在のコンフィグレーションの取得
\r
8765 UINT PsConfigGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8768 PS *ps = (PS *)param;
\r
8774 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
8775 {"[path]", NULL, NULL, NULL, NULL},
\r
8778 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8781 return ERR_INVALID_PARAMETER;
\r
8784 Zero(&t, sizeof(t));
\r
8787 ret = ScGetConfig(ps->Rpc, &t);
\r
8789 if (ret != ERR_NO_ERROR)
\r
8792 CmdPrintError(c, ret);
\r
8793 FreeParamValueList(o);
\r
8798 char *filename = GetParamStr(o, "[path]");
\r
8800 if (IsEmptyStr(filename))
\r
8803 wchar_t tmp[MAX_SIZE];
\r
8807 UniFormat(tmp, sizeof(tmp), _UU("CMD_ConfigGet_FILENAME"), t.FileName,
\r
8808 StrLen(t.FileData));
\r
8812 buf_size = CalcUtf8ToUni((BYTE *)t.FileData, StrLen(t.FileData));
\r
8813 buf = ZeroMalloc(buf_size + 32);
\r
8815 Utf8ToUni(buf, buf_size, (BYTE *)t.FileData, StrLen(t.FileData));
\r
8825 IO *io = FileCreate(filename);
\r
8829 c->Write(c, _UU("CMD_ConfigGet_FILE_SAVE_FAILED"));
\r
8831 ret = ERR_INTERNAL_ERROR;
\r
8835 FileWrite(io, t.FileData, StrLen(t.FileData));
\r
8841 FreeRpcConfig(&t);
\r
8843 FreeParamValueList(o);
\r
8848 // VPN Server へのコンフィグレーションの書き込み
\r
8849 UINT PsConfigSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8852 PS *ps = (PS *)param;
\r
8860 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
8861 {"[path]", CmdPrompt, _UU("CMD_ConfigSet_PROMPT_PATH"), CmdEvalIsFile, NULL},
\r
8864 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8867 return ERR_INVALID_PARAMETER;
\r
8870 filename = GetParamStr(o, "[path]");
\r
8872 buf = ReadDump(filename);
\r
8875 c->Write(c, _UU("CMD_ConfigSet_FILE_LOAD_FAILED"));
\r
8879 Zero(&t, sizeof(t));
\r
8881 t.FileData = ZeroMalloc(buf->Size + 1);
\r
8882 Copy(t.FileData, buf->Buf, buf->Size);
\r
8886 ret = ScSetConfig(ps->Rpc, &t);
\r
8888 if (ret != ERR_NO_ERROR)
\r
8891 CmdPrintError(c, ret);
\r
8892 FreeParamValueList(o);
\r
8896 FreeRpcConfig(&t);
\r
8899 FreeParamValueList(o);
\r
8904 // 仮想レイヤ 3 スイッチ一覧の取得
\r
8905 UINT PsRouterList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8908 PS *ps = (PS *)param;
\r
8912 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
8915 return ERR_INVALID_PARAMETER;
\r
8918 Zero(&t, sizeof(t));
\r
8921 ret = ScEnumL3Switch(ps->Rpc, &t);
\r
8923 if (ret != ERR_NO_ERROR)
\r
8926 CmdPrintError(c, ret);
\r
8927 FreeParamValueList(o);
\r
8935 CtInsertColumn(ct, _UU("SM_L3_SW_COLUMN1"), false);
\r
8936 CtInsertColumn(ct, _UU("SM_L3_SW_COLUMN2"), false);
\r
8937 CtInsertColumn(ct, _UU("SM_L3_SW_COLUMN3"), true);
\r
8938 CtInsertColumn(ct, _UU("SM_L3_SW_COLUMN4"), true);
\r
8940 for (i = 0;i < t.NumItem;i++)
\r
8942 RPC_ENUM_L3SW_ITEM *e = &t.Items[i];
\r
8943 wchar_t tmp1[MAX_SIZE], *tmp2, tmp3[64], tmp4[64];
\r
8945 StrToUni(tmp1, sizeof(tmp1), e->Name);
\r
8946 if (e->Active == false)
\r
8948 tmp2 = _UU("SM_L3_SW_ST_F_F");
\r
8950 else if (e->Online == false)
\r
8952 tmp2 = _UU("SM_L3_SW_ST_T_F");
\r
8956 tmp2 = _UU("SM_L3_SW_ST_T_T");
\r
8958 UniToStru(tmp3, e->NumInterfaces);
\r
8959 UniToStru(tmp4, e->NumTables);
\r
8962 tmp1, tmp2, tmp3, tmp4);
\r
8968 FreeRpcEnumL3Sw(&t);
\r
8970 FreeParamValueList(o);
\r
8975 // 新しい仮想レイヤ 3 スイッチの定義
\r
8976 UINT PsRouterAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
8979 PS *ps = (PS *)param;
\r
8985 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
8986 {"[name]", CmdPrompt, _UU("CMD_RouterAdd_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
8989 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
8992 return ERR_INVALID_PARAMETER;
\r
8995 Zero(&t, sizeof(t));
\r
8997 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9000 ret = ScAddL3Switch(ps->Rpc, &t);
\r
9002 if (ret != ERR_NO_ERROR)
\r
9005 CmdPrintError(c, ret);
\r
9006 FreeParamValueList(o);
\r
9010 FreeParamValueList(o);
\r
9015 // 仮想レイヤ 3 スイッチの削除
\r
9016 UINT PsRouterDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9019 PS *ps = (PS *)param;
\r
9025 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9026 {"[name]", CmdPrompt, _UU("CMD_RouterDelete_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9029 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9032 return ERR_INVALID_PARAMETER;
\r
9035 Zero(&t, sizeof(t));
\r
9037 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9040 ret = ScDelL3Switch(ps->Rpc, &t);
\r
9042 if (ret != ERR_NO_ERROR)
\r
9045 CmdPrintError(c, ret);
\r
9046 FreeParamValueList(o);
\r
9050 FreeParamValueList(o);
\r
9055 // 仮想レイヤ 3 スイッチの動作の開始
\r
9056 UINT PsRouterStart(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9059 PS *ps = (PS *)param;
\r
9065 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9066 {"[name]", CmdPrompt, _UU("CMD_RouterStart_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9069 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9072 return ERR_INVALID_PARAMETER;
\r
9075 Zero(&t, sizeof(t));
\r
9077 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9080 ret = ScStartL3Switch(ps->Rpc, &t);
\r
9082 if (ret != ERR_NO_ERROR)
\r
9085 CmdPrintError(c, ret);
\r
9086 FreeParamValueList(o);
\r
9090 FreeParamValueList(o);
\r
9095 // 仮想レイヤ 3 スイッチの動作の停止
\r
9096 UINT PsRouterStop(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9099 PS *ps = (PS *)param;
\r
9105 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9106 {"[name]", CmdPrompt, _UU("CMD_RouterStop_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9109 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9112 return ERR_INVALID_PARAMETER;
\r
9115 Zero(&t, sizeof(t));
\r
9117 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9120 ret = ScStopL3Switch(ps->Rpc, &t);
\r
9122 if (ret != ERR_NO_ERROR)
\r
9125 CmdPrintError(c, ret);
\r
9126 FreeParamValueList(o);
\r
9130 FreeParamValueList(o);
\r
9135 // 仮想レイヤ 3 スイッチに登録されているインターフェイス一覧の取得
\r
9136 UINT PsRouterIfList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9139 PS *ps = (PS *)param;
\r
9145 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9146 {"[name]", CmdPrompt, _UU("CMD_RouterIfList_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9149 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9152 return ERR_INVALID_PARAMETER;
\r
9155 Zero(&t, sizeof(t));
\r
9157 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9160 ret = ScEnumL3If(ps->Rpc, &t);
\r
9162 if (ret != ERR_NO_ERROR)
\r
9165 CmdPrintError(c, ret);
\r
9166 FreeParamValueList(o);
\r
9172 wchar_t tmp1[MAX_SIZE];
\r
9173 wchar_t tmp2[MAX_SIZE];
\r
9174 wchar_t tmp3[MAX_SIZE];
\r
9177 CtInsertColumn(ct, _UU("SM_L3_SW_IF_COLUMN1"), false);
\r
9178 CtInsertColumn(ct, _UU("SM_L3_SW_IF_COLUMN2"), false);
\r
9179 CtInsertColumn(ct, _UU("SM_L3_SW_IF_COLUMN3"), false);
\r
9181 for (i = 0;i < t.NumItem;i++)
\r
9183 RPC_L3IF *e = &t.Items[i];
\r
9185 IPToUniStr32(tmp1, sizeof(tmp1), e->IpAddress);
\r
9186 IPToUniStr32(tmp2, sizeof(tmp2), e->SubnetMask);
\r
9187 StrToUni(tmp3, sizeof(tmp3), e->HubName);
\r
9189 CtInsert(ct, tmp1, tmp2, tmp3);
\r
9196 FreeRpcEnumL3If(&t);
\r
9198 FreeParamValueList(o);
\r
9204 bool CmdEvalIpAndMask4(CONSOLE *c, wchar_t *str, void *param)
\r
9206 char tmp[MAX_SIZE];
\r
9209 if (c == NULL || str == NULL)
\r
9214 UniToStr(tmp, sizeof(tmp), str);
\r
9216 if (ParseIpAndMask4(tmp, &ip, &mask) == false)
\r
9218 c->Write(c, _UU("CMD_PARSE_IP_MASK_ERROR_1"));
\r
9224 bool CmdEvalIpAndMask6(CONSOLE *c, wchar_t *str, void *param)
\r
9226 char tmp[MAX_SIZE];
\r
9229 if (c == NULL || str == NULL)
\r
9234 UniToStr(tmp, sizeof(tmp), str);
\r
9236 if (ParseIpAndMask6(tmp, &ip, &mask) == false)
\r
9238 c->Write(c, _UU("CMD_PARSE_IP_MASK_ERROR_1_6"));
\r
9244 bool CmdEvalIpAndMask46(CONSOLE *c, wchar_t *str, void *param)
\r
9246 char tmp[MAX_SIZE];
\r
9250 Zero(tmp, sizeof(tmp));
\r
9251 UniToStr(tmp, sizeof(tmp), str);
\r
9253 t = ParseToken(tmp, "/");
\r
9259 if (t->NumTokens >= 1)
\r
9261 Trim(t->Token[0]);
\r
9263 if (IsIpStr4(t->Token[0]))
\r
9265 ret = CmdEvalIpAndMask4(c, str, param);
\r
9269 ret = CmdEvalIpAndMask6(c, str, param);
\r
9278 // ネットワークアドレスとサブネットマスクの評価
\r
9279 bool CmdEvalNetworkAndSubnetMask4(CONSOLE *c, wchar_t *str, void *param)
\r
9281 char tmp[MAX_SIZE];
\r
9284 if (c == NULL || str == NULL)
\r
9289 UniToStr(tmp, sizeof(tmp), str);
\r
9291 if (ParseIpAndSubnetMask4(tmp, &ip, &mask) == false)
\r
9293 c->Write(c, _UU("CMD_PARSE_IP_SUBNET_ERROR_1"));
\r
9297 if (IsNetworkAddress32(ip, mask) == false)
\r
9299 c->Write(c, _UU("CMD_PARSE_IP_SUBNET_ERROR_2"));
\r
9305 bool CmdEvalNetworkAndSubnetMask6(CONSOLE *c, wchar_t *str, void *param)
\r
9307 char tmp[MAX_SIZE];
\r
9310 if (c == NULL || str == NULL)
\r
9315 UniToStr(tmp, sizeof(tmp), str);
\r
9317 if (ParseIpAndSubnetMask6(tmp, &ip, &mask) == false)
\r
9319 c->Write(c, _UU("CMD_PARSE_IP_SUBNET_ERROR_1_6"));
\r
9323 if (IsNetworkPrefixAddress6(&ip, &mask) == false)
\r
9325 c->Write(c, _UU("CMD_PARSE_IP_SUBNET_ERROR_3"));
\r
9331 bool CmdEvalNetworkAndSubnetMask46(CONSOLE *c, wchar_t *str, void *param)
\r
9333 char tmp[MAX_SIZE];
\r
9337 Zero(tmp, sizeof(tmp));
\r
9338 UniToStr(tmp, sizeof(tmp), str);
\r
9340 t = ParseToken(tmp, "/");
\r
9346 if (t->NumTokens >= 1)
\r
9348 Trim(t->Token[0]);
\r
9350 if (IsIpStr4(t->Token[0]))
\r
9352 ret = CmdEvalNetworkAndSubnetMask4(c, str, param);
\r
9356 ret = CmdEvalNetworkAndSubnetMask6(c, str, param);
\r
9365 // IP アドレスとサブネットマスクの評価
\r
9366 bool CmdEvalHostAndSubnetMask4(CONSOLE *c, wchar_t *str, void *param)
\r
9368 char tmp[MAX_SIZE];
\r
9370 if (c == NULL || str == NULL)
\r
9375 UniToStr(tmp, sizeof(tmp), str);
\r
9377 if (ParseIpAndSubnetMask4(tmp, NULL, NULL) == false)
\r
9379 c->Write(c, _UU("CMD_PARSE_IP_SUBNET_ERROR_1"));
\r
9386 // 仮想レイヤ 3 スイッチへの仮想インターフェイスの追加
\r
9387 UINT PsRouterIfAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9390 PS *ps = (PS *)param;
\r
9396 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9397 {"[name]", CmdPrompt, _UU("CMD_RouterIfAdd_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9398 {"HUB", CmdPrompt, _UU("CMD_RouterIfAdd_PROMPT_HUB"), CmdEvalNotEmpty, NULL},
\r
9399 {"IP", CmdPrompt, _UU("CMD_RouterIfAdd_PROMPT_IP"), CmdEvalHostAndSubnetMask4, NULL},
\r
9402 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9405 return ERR_INVALID_PARAMETER;
\r
9408 Zero(&t, sizeof(t));
\r
9410 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9411 ParseIpAndSubnetMask4(GetParamStr(o, "IP"), &t.IpAddress, &t.SubnetMask);
\r
9412 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "HUB"));
\r
9415 ret = ScAddL3If(ps->Rpc, &t);
\r
9417 if (ret != ERR_NO_ERROR)
\r
9420 CmdPrintError(c, ret);
\r
9421 FreeParamValueList(o);
\r
9425 FreeParamValueList(o);
\r
9430 // 仮想レイヤ 3 スイッチの仮想インターフェイスの削除
\r
9431 UINT PsRouterIfDel(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9434 PS *ps = (PS *)param;
\r
9440 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9441 {"[name]", CmdPrompt, _UU("CMD_RouterIfAdd_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9442 {"HUB", CmdPrompt, _UU("CMD_RouterIfAdd_PROMPT_HUB"), CmdEvalNotEmpty, NULL},
\r
9445 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9448 return ERR_INVALID_PARAMETER;
\r
9451 Zero(&t, sizeof(t));
\r
9453 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9454 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "HUB"));
\r
9457 ret = ScDelL3If(ps->Rpc, &t);
\r
9459 if (ret != ERR_NO_ERROR)
\r
9462 CmdPrintError(c, ret);
\r
9463 FreeParamValueList(o);
\r
9467 FreeParamValueList(o);
\r
9472 // 仮想レイヤ 3 スイッチのルーティング テーブル一覧の取得
\r
9473 UINT PsRouterTableList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9476 PS *ps = (PS *)param;
\r
9478 RPC_ENUM_L3TABLE t;
\r
9480 wchar_t tmp1[MAX_SIZE];
\r
9481 wchar_t tmp2[MAX_SIZE];
\r
9482 wchar_t tmp3[MAX_SIZE];
\r
9483 wchar_t tmp4[MAX_SIZE];
\r
9487 {"[name]", CmdPrompt, _UU("CMD_RouterTableList_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9490 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9493 return ERR_INVALID_PARAMETER;
\r
9496 Zero(&t, sizeof(t));
\r
9498 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9501 ret = ScEnumL3Table(ps->Rpc, &t);
\r
9503 if (ret != ERR_NO_ERROR)
\r
9506 CmdPrintError(c, ret);
\r
9507 FreeParamValueList(o);
\r
9516 CtInsertColumn(ct, _UU("SM_L3_SW_TABLE_COLUMN1"), false);
\r
9517 CtInsertColumn(ct, _UU("SM_L3_SW_TABLE_COLUMN2"), false);
\r
9518 CtInsertColumn(ct, _UU("SM_L3_SW_TABLE_COLUMN3"), false);
\r
9519 CtInsertColumn(ct, _UU("SM_L3_SW_TABLE_COLUMN4"), true);
\r
9521 for (i = 0;i < t.NumItem;i++)
\r
9523 RPC_L3TABLE *e = &t.Items[i];
\r
9525 IPToUniStr32(tmp1, sizeof(tmp1), e->NetworkAddress);
\r
9526 IPToUniStr32(tmp2, sizeof(tmp2), e->SubnetMask);
\r
9527 IPToUniStr32(tmp3, sizeof(tmp3), e->GatewayAddress);
\r
9528 UniToStru(tmp4, e->Metric);
\r
9530 CtInsert(ct, tmp1, tmp2, tmp3, tmp4);
\r
9536 FreeRpcEnumL3Table(&t);
\r
9538 FreeParamValueList(o);
\r
9543 // 仮想レイヤ 3 スイッチへのルーティング テーブル エントリの追加
\r
9544 UINT PsRouterTableAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9547 PS *ps = (PS *)param;
\r
9553 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9554 {"[name]", CmdPrompt, _UU("CMD_RouterTableAdd_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9555 {"NETWORK", CmdPrompt, _UU("CMD_RouterTableAdd_PROMPT_NETWORK"), CmdEvalNetworkAndSubnetMask4, NULL},
\r
9556 {"GATEWAY", CmdPrompt, _UU("CMD_RouterTableAdd_PROMPT_GATEWAY"), CmdEvalIp, NULL},
\r
9557 {"METRIC", CmdPrompt, _UU("CMD_RouterTableAdd_PROMPT_METRIC"), CmdEvalInt1, NULL},
\r
9560 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9563 return ERR_INVALID_PARAMETER;
\r
9566 Zero(&t, sizeof(t));
\r
9568 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9569 ParseIpAndSubnetMask4(GetParamStr(o, "NETWORK"), &t.NetworkAddress, &t.SubnetMask);
\r
9570 t.Metric = GetParamInt(o, "METRIC");
\r
9571 t.GatewayAddress = StrToIP32(GetParamStr(o, "GATEWAY"));
\r
9574 ret = ScAddL3Table(ps->Rpc, &t);
\r
9576 if (ret != ERR_NO_ERROR)
\r
9579 CmdPrintError(c, ret);
\r
9580 FreeParamValueList(o);
\r
9584 FreeParamValueList(o);
\r
9589 // 仮想レイヤ 3 スイッチのルーティング テーブル エントリの削除
\r
9590 UINT PsRouterTableDel(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9593 PS *ps = (PS *)param;
\r
9599 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9600 {"[name]", CmdPrompt, _UU("CMD_RouterTableAdd_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9601 {"NETWORK", CmdPrompt, _UU("CMD_RouterTableAdd_PROMPT_NETWORK"), CmdEvalNetworkAndSubnetMask4, NULL},
\r
9602 {"GATEWAY", CmdPrompt, _UU("CMD_RouterTableAdd_PROMPT_GATEWAY"), CmdEvalIp, NULL},
\r
9603 {"METRIC", CmdPrompt, _UU("CMD_RouterTableAdd_PROMPT_METRIC"), CmdEvalInt1, NULL},
\r
9606 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9609 return ERR_INVALID_PARAMETER;
\r
9612 Zero(&t, sizeof(t));
\r
9614 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
9615 ParseIpAndSubnetMask4(GetParamStr(o, "NETWORK"), &t.NetworkAddress, &t.SubnetMask);
\r
9616 t.Metric = GetParamInt(o, "METRIC");
\r
9617 t.GatewayAddress = StrToIP32(GetParamStr(o, "GATEWAY"));
\r
9620 ret = ScDelL3Table(ps->Rpc, &t);
\r
9622 if (ret != ERR_NO_ERROR)
\r
9625 CmdPrintError(c, ret);
\r
9626 FreeParamValueList(o);
\r
9630 FreeParamValueList(o);
\r
9636 UINT PsLogFileList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9639 PS *ps = (PS *)param;
\r
9641 RPC_ENUM_LOG_FILE t;
\r
9643 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
9646 return ERR_INVALID_PARAMETER;
\r
9649 Zero(&t, sizeof(t));
\r
9651 c->Write(c, _UU("CMD_LogFileList_START"));
\r
9655 ret = ScEnumLogFile(ps->Rpc, &t);
\r
9657 if (ret != ERR_NO_ERROR)
\r
9660 CmdPrintError(c, ret);
\r
9661 FreeParamValueList(o);
\r
9667 wchar_t tmp[MAX_SIZE];
\r
9670 UniFormat(tmp, sizeof(tmp), _UU("CMD_LogFileList_NUM_LOGS"), t.NumItem);
\r
9675 CtInsertColumn(ct, _UU("SM_LOG_FILE_COLUMN_1"), false);
\r
9676 CtInsertColumn(ct, _UU("SM_LOG_FILE_COLUMN_2"), true);
\r
9677 CtInsertColumn(ct, _UU("SM_LOG_FILE_COLUMN_3"), false);
\r
9678 CtInsertColumn(ct, _UU("SM_LOG_FILE_COLUMN_4"), false);
\r
9680 for (i = 0;i < t.NumItem;i++)
\r
9682 RPC_ENUM_LOG_FILE_ITEM *e = &t.Items[i];
\r
9683 wchar_t tmp1[MAX_PATH], tmp2[128], tmp3[128], tmp4[MAX_HOST_NAME_LEN + 1];
\r
9684 char tmp[MAX_SIZE];
\r
9686 StrToUni(tmp1, sizeof(tmp1), e->FilePath);
\r
9688 ToStrByte(tmp, sizeof(tmp), e->FileSize);
\r
9689 StrToUni(tmp2, sizeof(tmp2), tmp);
\r
9691 GetDateTimeStr64Uni(tmp3, sizeof(tmp3), SystemToLocal64(e->UpdatedTime));
\r
9693 StrToUni(tmp4, sizeof(tmp4), e->ServerName);
\r
9695 CtInsert(ct, tmp1, tmp2, tmp3, tmp4);
\r
9698 CtFreeEx(ct, c, true);
\r
9701 FreeRpcEnumLogFile(&t);
\r
9703 FreeParamValueList(o);
\r
9709 UINT PsLogFileGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9712 PS *ps = (PS *)param;
\r
9715 char *filename = NULL;
\r
9716 char *server_name;
\r
9720 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9721 {"[name]", CmdPrompt, _UU("CMD_LogFileGet_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9722 {"SERVER", NULL, NULL, NULL, NULL},
\r
9723 {"SAVEPATH", NULL, NULL, NULL, NULL},
\r
9726 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9729 return ERR_INVALID_PARAMETER;
\r
9732 filename = GetParamStr(o, "SAVE");
\r
9734 c->Write(c, _UU("CMD_LogFileGet_START"));
\r
9736 server_name = GetParamStr(o, "SERVER");
\r
9738 buf = DownloadFileFromServer(ps->Rpc, server_name,
\r
9739 GetParamStr(o, "[name]"), 0, NULL, NULL);
\r
9743 c->Write(c, _UU("CMD_LogFileGet_FAILED"));
\r
9745 ret = ERR_INTERNAL_ERROR;
\r
9749 if (IsEmptyStr(filename) == false)
\r
9752 if (DumpBuf(buf, filename) == false)
\r
9754 ret = ERR_INTERNAL_ERROR;
\r
9755 c->Write(c, _UU("CMD_LogFileGet_SAVE_FAILED"));
\r
9761 wchar_t tmp[MAX_SIZE];
\r
9765 UniFormat(tmp, sizeof(tmp), _UU("CMD_LogFileGet_FILESIZE"),
\r
9770 buf_size = CalcUtf8ToUni((BYTE *)buf->Buf, buf->Size);
\r
9771 uni_buf = ZeroMalloc(buf_size + 32);
\r
9773 Utf8ToUni(uni_buf, buf_size, (BYTE *)buf->Buf, buf->Size);
\r
9775 c->Write(c, uni_buf);
\r
9784 FreeParamValueList(o);
\r
9790 UINT PsHubCreate(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9793 PS *ps = (PS *)param;
\r
9797 UINT hub_type = HUB_TYPE_STANDALONE;
\r
9801 {"[name]", CmdPrompt, _UU("CMD_HubCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9802 {"PASSWORD", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
9805 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9808 return ERR_INVALID_PARAMETER;
\r
9812 RPC_SERVER_INFO t;
\r
9813 Zero(&t, sizeof(t));
\r
9814 if (ScGetServerInfo(ps->Rpc, &t) == ERR_NO_ERROR)
\r
9816 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
\r
9818 hub_type = HUB_TYPE_FARM_DYNAMIC;
\r
9820 FreeRpcServerInfo(&t);
\r
9824 Zero(&t, sizeof(t));
\r
9826 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
9827 t.HubType = hub_type;
\r
9829 if (IsEmptyStr(GetParamStr(o, "PASSWORD")) == false)
\r
9831 pass = GetParamStr(o, "PASSWORD");
\r
9834 Hash(t.HashedPassword, pass, StrLen(pass), true);
\r
9835 HashPassword(t.SecurePassword, ADMINISTRATOR_USERNAME, pass);
\r
9839 ret = ScCreateHub(ps->Rpc, &t);
\r
9841 if (ret != ERR_NO_ERROR)
\r
9844 CmdPrintError(c, ret);
\r
9845 FreeParamValueList(o);
\r
9849 FreeParamValueList(o);
\r
9854 // 新しい仮想 HUB の作成 (ダイナミックモード)
\r
9855 UINT PsHubCreateDynamic(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9858 PS *ps = (PS *)param;
\r
9862 UINT hub_type = HUB_TYPE_FARM_DYNAMIC;
\r
9866 {"[name]", CmdPrompt, _UU("CMD_HubCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9867 {"PASSWORD", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
9870 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9873 return ERR_INVALID_PARAMETER;
\r
9876 Zero(&t, sizeof(t));
\r
9878 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
9879 t.HubType = hub_type;
\r
9881 if (IsEmptyStr(GetParamStr(o, "PASSWORD")) == false)
\r
9883 pass = GetParamStr(o, "PASSWORD");
\r
9886 Hash(t.HashedPassword, pass, StrLen(pass), true);
\r
9887 HashPassword(t.SecurePassword, ADMINISTRATOR_USERNAME, pass);
\r
9891 ret = ScCreateHub(ps->Rpc, &t);
\r
9893 if (ret != ERR_NO_ERROR)
\r
9896 CmdPrintError(c, ret);
\r
9897 FreeParamValueList(o);
\r
9901 FreeParamValueList(o);
\r
9906 // 新しい仮想 HUB の作成 (スタティックモード)
\r
9907 UINT PsHubCreateStatic(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9910 PS *ps = (PS *)param;
\r
9914 UINT hub_type = HUB_TYPE_FARM_STATIC;
\r
9918 {"[name]", CmdPrompt, _UU("CMD_HubCreate_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9919 {"PASSWORD", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
9922 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9925 return ERR_INVALID_PARAMETER;
\r
9928 Zero(&t, sizeof(t));
\r
9930 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
9931 t.HubType = hub_type;
\r
9933 if (IsEmptyStr(GetParamStr(o, "PASSWORD")) == false)
\r
9935 pass = GetParamStr(o, "PASSWORD");
\r
9938 Hash(t.HashedPassword, pass, StrLen(pass), true);
\r
9939 HashPassword(t.SecurePassword, ADMINISTRATOR_USERNAME, pass);
\r
9943 ret = ScCreateHub(ps->Rpc, &t);
\r
9945 if (ret != ERR_NO_ERROR)
\r
9948 CmdPrintError(c, ret);
\r
9949 FreeParamValueList(o);
\r
9953 FreeParamValueList(o);
\r
9959 UINT PsHubDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
9962 PS *ps = (PS *)param;
\r
9968 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
9969 {"[name]", CmdPrompt, _UU("CMD_HubDelete_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
9972 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
9975 return ERR_INVALID_PARAMETER;
\r
9978 Zero(&t, sizeof(t));
\r
9980 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
9983 ret = ScDeleteHub(ps->Rpc, &t);
\r
9985 if (ret != ERR_NO_ERROR)
\r
9988 CmdPrintError(c, ret);
\r
9989 FreeParamValueList(o);
\r
9993 FreeParamValueList(o);
\r
9998 // 仮想 HUB をスタティックにする
\r
9999 UINT PsHubSetStatic(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10002 PS *ps = (PS *)param;
\r
10004 RPC_CREATE_HUB t;
\r
10005 // 指定できるパラメータ リスト
\r
10008 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
10009 {"[name]", CmdPrompt, _UU("CMD_HubChange_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
10012 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
10015 return ERR_INVALID_PARAMETER;
\r
10018 Zero(&t, sizeof(t));
\r
10020 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
10023 ret = ScGetHub(ps->Rpc, &t);
\r
10025 if (ret != ERR_NO_ERROR)
\r
10028 CmdPrintError(c, ret);
\r
10029 FreeParamValueList(o);
\r
10034 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
10035 t.HubType = HUB_TYPE_FARM_STATIC;
\r
10038 ret = ScSetHub(ps->Rpc, &t);
\r
10040 if (ret != ERR_NO_ERROR)
\r
10043 CmdPrintError(c, ret);
\r
10044 FreeParamValueList(o);
\r
10048 FreeParamValueList(o);
\r
10053 // 仮想 HUB の種類をダイナミック仮想 HUB に変更
\r
10054 UINT PsHubSetDynamic(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10057 PS *ps = (PS *)param;
\r
10059 RPC_CREATE_HUB t;
\r
10060 // 指定できるパラメータ リスト
\r
10063 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
10064 {"[name]", CmdPrompt, _UU("CMD_HubChange_PROMPT_NAME"), CmdEvalNotEmpty, NULL},
\r
10067 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
10070 return ERR_INVALID_PARAMETER;
\r
10073 Zero(&t, sizeof(t));
\r
10075 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
10078 ret = ScGetHub(ps->Rpc, &t);
\r
10080 if (ret != ERR_NO_ERROR)
\r
10083 CmdPrintError(c, ret);
\r
10084 FreeParamValueList(o);
\r
10089 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
10090 t.HubType = HUB_TYPE_FARM_DYNAMIC;
\r
10093 ret = ScSetHub(ps->Rpc, &t);
\r
10095 if (ret != ERR_NO_ERROR)
\r
10098 CmdPrintError(c, ret);
\r
10099 FreeParamValueList(o);
\r
10103 FreeParamValueList(o);
\r
10109 UINT PsHubList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10112 PS *ps = (PS *)param;
\r
10117 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10120 return ERR_INVALID_PARAMETER;
\r
10123 Zero(&t, sizeof(t));
\r
10126 ret = ScEnumHub(ps->Rpc, &t);
\r
10128 if (ret != ERR_NO_ERROR)
\r
10131 CmdPrintError(c, ret);
\r
10132 FreeParamValueList(o);
\r
10137 CT *ct = CtNew();
\r
10139 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_1"), false);
\r
10140 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_2"), false);
\r
10141 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_3"), false);
\r
10142 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_4"), false);
\r
10143 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_5"), false);
\r
10144 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_6"), false);
\r
10145 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_7"), false);
\r
10146 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_8"), false);
\r
10147 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_9"), false);
\r
10148 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_10"), false);
\r
10149 CtInsertColumn(ct, _UU("SM_HUB_COLUMN_11"), false);
\r
10151 for (i = 0;i < t.NumHub;i++)
\r
10153 RPC_ENUM_HUB_ITEM *e = &t.Hubs[i];
\r
10154 wchar_t name[MAX_HUBNAME_LEN + 1];
\r
10155 wchar_t s1[64], s2[64], s3[64], s4[64], s5[64];
\r
10156 wchar_t s6[64], s7[128], s8[128];
\r
10157 UniToStru(s1, e->NumUsers);
\r
10158 UniToStru(s2, e->NumGroups);
\r
10159 UniToStru(s3, e->NumSessions);
\r
10160 UniToStru(s4, e->NumMacTables);
\r
10161 UniToStru(s5, e->NumIpTables);
\r
10163 UniToStru(s6, e->NumLogin);
\r
10165 if (e->LastLoginTime != 0)
\r
10167 GetDateTimeStr64Uni(s7, sizeof(s7), SystemToLocal64(e->LastLoginTime));
\r
10171 UniStrCpy(s7, sizeof(s7), _UU("COMMON_UNKNOWN"));
\r
10174 if (e->LastCommTime != 0)
\r
10176 GetDateTimeStr64Uni(s8, sizeof(s8), SystemToLocal64(e->LastCommTime));
\r
10180 UniStrCpy(s8, sizeof(s8), _UU("COMMON_UNKNOWN"));
\r
10183 StrToUni(name, sizeof(name), e->HubName);
\r
10187 e->Online ? _UU("SM_HUB_ONLINE") : _UU("SM_HUB_OFFLINE"),
\r
10188 GetHubTypeStr(e->HubType),
\r
10189 s1, s2, s3, s4, s5, s6, s7, s8);
\r
10192 CtFreeEx(ct, c, true);
\r
10195 FreeRpcEnumHub(&t);
\r
10197 FreeParamValueList(o);
\r
10202 // 管理する仮想 HUB の選択
\r
10203 UINT PsHub(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10206 PS *ps = (PS *)param;
\r
10208 RPC_HUB_STATUS t;
\r
10209 // 指定できるパラメータ リスト
\r
10212 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
10213 {"[name]", NULL, NULL, NULL, NULL},
\r
10216 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
10219 return ERR_INVALID_PARAMETER;
\r
10222 if (IsEmptyStr(GetParamStr(o, "[name]")) == false)
\r
10224 wchar_t tmp[MAX_SIZE];
\r
10225 Zero(&t, sizeof(t));
\r
10227 // 指定した仮想 HUB にアクセスできるかどうか調べる
\r
10228 StrCpy(t.HubName, sizeof(t.HubName), GetParamStr(o, "[name]"));
\r
10231 ret = ScGetHubStatus(ps->Rpc, &t);
\r
10233 if (ret != ERR_NO_ERROR)
\r
10236 CmdPrintError(c, ret);
\r
10237 FreeParamValueList(o);
\r
10242 if (ps->HubName != NULL)
\r
10244 Free(ps->HubName);
\r
10246 ps->HubName = CopyStr(t.HubName);
\r
10248 UniFormat(tmp, sizeof(tmp), _UU("CMD_Hub_Selected"), t.HubName);
\r
10249 c->Write(c, tmp);
\r
10254 if (ps->HubName != NULL)
\r
10256 c->Write(c, _UU("CMD_Hub_Unselected"));
\r
10257 Free(ps->HubName);
\r
10259 ps->HubName = NULL;
\r
10262 FreeParamValueList(o);
\r
10267 // 仮想 HUB をオンラインにする
\r
10268 UINT PsOnline(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10271 PS *ps = (PS *)param;
\r
10273 RPC_SET_HUB_ONLINE t;
\r
10275 // 仮想 HUB が選択されていない場合はエラー
\r
10276 if (ps->HubName == NULL)
\r
10278 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10279 return ERR_INVALID_PARAMETER;
\r
10282 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10285 return ERR_INVALID_PARAMETER;
\r
10288 Zero(&t, sizeof(t));
\r
10290 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10294 ret = ScSetHubOnline(ps->Rpc, &t);
\r
10296 if (ret != ERR_NO_ERROR)
\r
10299 CmdPrintError(c, ret);
\r
10300 FreeParamValueList(o);
\r
10304 FreeParamValueList(o);
\r
10309 // 仮想 HUB をオフラインにする
\r
10310 UINT PsOffline(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10313 PS *ps = (PS *)param;
\r
10315 RPC_SET_HUB_ONLINE t;
\r
10317 // 仮想 HUB が選択されていない場合はエラー
\r
10318 if (ps->HubName == NULL)
\r
10320 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10321 return ERR_INVALID_PARAMETER;
\r
10324 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10327 return ERR_INVALID_PARAMETER;
\r
10330 Zero(&t, sizeof(t));
\r
10332 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10333 t.Online = false;
\r
10336 ret = ScSetHubOnline(ps->Rpc, &t);
\r
10338 if (ret != ERR_NO_ERROR)
\r
10341 CmdPrintError(c, ret);
\r
10342 FreeParamValueList(o);
\r
10346 FreeParamValueList(o);
\r
10351 // 仮想 HUB の最大同時接続セッション数を設定する
\r
10352 UINT PsSetMaxSession(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10355 PS *ps = (PS *)param;
\r
10357 RPC_CREATE_HUB t;
\r
10358 // 指定できるパラメータ リスト
\r
10361 {"[max_session]", CmdPrompt, _UU("CMD_SetMaxSession_Prompt"), CmdEvalNotEmpty, NULL},
\r
10364 // 仮想 HUB が選択されていない場合はエラー
\r
10365 if (ps->HubName == NULL)
\r
10367 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10368 return ERR_INVALID_PARAMETER;
\r
10371 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
10374 return ERR_INVALID_PARAMETER;
\r
10377 // 現在の仮想 HUB の設定を取得
\r
10378 Zero(&t, sizeof(t));
\r
10379 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10380 ret = ScGetHub(ps->Rpc, &t);
\r
10381 if (ret != ERR_NO_ERROR)
\r
10384 CmdPrintError(c, ret);
\r
10385 FreeParamValueList(o);
\r
10389 t.HubOption.MaxSession = GetParamInt(o, "[max_session]");
\r
10391 // 仮想 HUB の設定を書き込み
\r
10392 ret = ScSetHub(ps->Rpc, &t);
\r
10393 if (ret != ERR_NO_ERROR)
\r
10396 CmdPrintError(c, ret);
\r
10397 FreeParamValueList(o);
\r
10401 FreeParamValueList(o);
\r
10406 // 仮想 HUB の管理パスワードを設定する
\r
10407 UINT PsSetHubPassword(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10410 PS *ps = (PS *)param;
\r
10412 RPC_CREATE_HUB t;
\r
10414 // 指定できるパラメータ リスト
\r
10417 {"[password]", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
10420 // 仮想 HUB が選択されていない場合はエラー
\r
10421 if (ps->HubName == NULL)
\r
10423 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10424 return ERR_INVALID_PARAMETER;
\r
10427 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
10430 return ERR_INVALID_PARAMETER;
\r
10433 // 現在の仮想 HUB の設定を取得
\r
10434 Zero(&t, sizeof(t));
\r
10435 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10436 ret = ScGetHub(ps->Rpc, &t);
\r
10437 if (ret != ERR_NO_ERROR)
\r
10440 CmdPrintError(c, ret);
\r
10441 FreeParamValueList(o);
\r
10446 pw = GetParamStr(o, "[password]");
\r
10447 HashPassword(t.SecurePassword, ADMINISTRATOR_USERNAME, pw);
\r
10448 Hash(t.HashedPassword, pw, StrLen(pw), true);
\r
10450 // 仮想 HUB の設定を書き込み
\r
10451 ret = ScSetHub(ps->Rpc, &t);
\r
10452 if (ret != ERR_NO_ERROR)
\r
10455 CmdPrintError(c, ret);
\r
10456 FreeParamValueList(o);
\r
10460 FreeParamValueList(o);
\r
10465 // 仮想 HUB の匿名ユーザーへの列挙の許可設定
\r
10466 UINT PsSetEnumAllow(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10469 PS *ps = (PS *)param;
\r
10471 RPC_CREATE_HUB t;
\r
10473 // 仮想 HUB が選択されていない場合はエラー
\r
10474 if (ps->HubName == NULL)
\r
10476 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10477 return ERR_INVALID_PARAMETER;
\r
10480 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10483 return ERR_INVALID_PARAMETER;
\r
10486 // 現在の仮想 HUB の設定を取得
\r
10487 Zero(&t, sizeof(t));
\r
10488 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10489 ret = ScGetHub(ps->Rpc, &t);
\r
10490 if (ret != ERR_NO_ERROR)
\r
10493 CmdPrintError(c, ret);
\r
10494 FreeParamValueList(o);
\r
10498 t.HubOption.NoEnum = false;
\r
10500 // 仮想 HUB の設定を書き込み
\r
10501 ret = ScSetHub(ps->Rpc, &t);
\r
10502 if (ret != ERR_NO_ERROR)
\r
10505 CmdPrintError(c, ret);
\r
10506 FreeParamValueList(o);
\r
10510 FreeParamValueList(o);
\r
10515 // 仮想 HUB の匿名ユーザーへの列挙の禁止設定
\r
10516 UINT PsSetEnumDeny(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10519 PS *ps = (PS *)param;
\r
10521 RPC_CREATE_HUB t;
\r
10523 // 仮想 HUB が選択されていない場合はエラー
\r
10524 if (ps->HubName == NULL)
\r
10526 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10527 return ERR_INVALID_PARAMETER;
\r
10530 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10533 return ERR_INVALID_PARAMETER;
\r
10536 // 現在の仮想 HUB の設定を取得
\r
10537 Zero(&t, sizeof(t));
\r
10538 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10539 ret = ScGetHub(ps->Rpc, &t);
\r
10540 if (ret != ERR_NO_ERROR)
\r
10543 CmdPrintError(c, ret);
\r
10544 FreeParamValueList(o);
\r
10548 t.HubOption.NoEnum = true;
\r
10550 // 仮想 HUB の設定を書き込み
\r
10551 ret = ScSetHub(ps->Rpc, &t);
\r
10552 if (ret != ERR_NO_ERROR)
\r
10555 CmdPrintError(c, ret);
\r
10556 FreeParamValueList(o);
\r
10560 FreeParamValueList(o);
\r
10565 // 仮想 HUB のオプション設定の取得
\r
10566 UINT PsOptionsGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10569 PS *ps = (PS *)param;
\r
10571 RPC_CREATE_HUB t;
\r
10573 // 仮想 HUB が選択されていない場合はエラー
\r
10574 if (ps->HubName == NULL)
\r
10576 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10577 return ERR_INVALID_PARAMETER;
\r
10580 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10583 return ERR_INVALID_PARAMETER;
\r
10586 Zero(&t, sizeof(t));
\r
10588 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10591 ret = ScGetHub(ps->Rpc, &t);
\r
10593 if (ret != ERR_NO_ERROR)
\r
10596 CmdPrintError(c, ret);
\r
10597 FreeParamValueList(o);
\r
10603 wchar_t tmp[MAX_SIZE];
\r
10605 UniFormat(tmp, sizeof(tmp), _UU("CMD_OptionsGet_TITLE"), ps->HubName);
\r
10606 c->Write(c, tmp);
\r
10609 ct = CtNewStandard();
\r
10611 CtInsert(ct, _UU("CMD_OptionsGet_ENUM"),
\r
10612 t.HubOption.NoEnum ? _UU("CMD_MSG_DENY") : _UU("CMD_MSG_ALLOW"));
\r
10614 if (t.HubOption.MaxSession == 0)
\r
10616 UniStrCpy(tmp, sizeof(tmp), _UU("CMD_MSG_INFINITE"));
\r
10620 UniToStru(tmp, t.HubOption.MaxSession);
\r
10622 CtInsert(ct, _UU("CMD_OptionsGet_MAXSESSIONS"), tmp);
\r
10624 CtInsert(ct, _UU("CMD_OptionsGet_STATUS"), t.Online ? _UU("SM_HUB_ONLINE") : _UU("SM_HUB_OFFLINE"));
\r
10626 CtInsert(ct, _UU("CMD_OptionsGet_TYPE"), GetHubTypeStr(t.HubType));
\r
10631 FreeParamValueList(o);
\r
10636 // ユーザー認証に使用する Radius サーバーの設定
\r
10637 UINT PsRadiusServerSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10640 PS *ps = (PS *)param;
\r
10645 // 指定できるパラメータ リスト
\r
10646 CMD_EVAL_MIN_MAX minmax =
\r
10648 "CMD_RadiusServerSet_EVAL_NUMINTERVAL", RADIUS_RETRY_INTERVAL, RADIUS_RETRY_TIMEOUT,
\r
10652 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
10653 {"[server_name:port]", CmdPrompt, _UU("CMD_RadiusServerSet_Prompt_Host"), CmdEvalNotEmpty, NULL},
\r
10654 {"SECRET", CmdPromptChoosePassword, _UU("CMD_RadiusServerSet_Prompt_Secret"), NULL, NULL},
\r
10655 {"RETRY_INTERVAL", CmdPrompt, _UU("CMD_RadiusServerSet_Prompt_RetryInterval"), CmdEvalMinMax, &minmax},
\r
10658 // 仮想 HUB が選択されていない場合はエラー
\r
10659 if (ps->HubName == NULL)
\r
10661 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10662 return ERR_INVALID_PARAMETER;
\r
10665 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
10668 return ERR_INVALID_PARAMETER;
\r
10671 if (ParseHostPort(GetParamStr(o, "[server_name:port]"), &host, &port, 1812))
\r
10673 Zero(&t, sizeof(t));
\r
10675 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10676 t.RadiusPort = port;
\r
10677 StrCpy(t.RadiusServerName, sizeof(t.RadiusServerName), host);
\r
10678 StrCpy(t.RadiusSecret, sizeof(t.RadiusSecret), GetParamStr(o, "SECRET"));
\r
10679 t.RadiusRetryInterval = GetParamInt(o, "RETRY_INTERVAL");
\r
10684 ret = ScSetHubRadius(ps->Rpc, &t);
\r
10686 if (ret != ERR_NO_ERROR)
\r
10689 CmdPrintError(c, ret);
\r
10690 FreeParamValueList(o);
\r
10695 FreeParamValueList(o);
\r
10700 // ユーザー認証に使用する Radius サーバー設定の削除
\r
10701 UINT PsRadiusServerDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10704 PS *ps = (PS *)param;
\r
10708 // 仮想 HUB が選択されていない場合はエラー
\r
10709 if (ps->HubName == NULL)
\r
10711 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10712 return ERR_INVALID_PARAMETER;
\r
10715 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10718 return ERR_INVALID_PARAMETER;
\r
10721 Zero(&t, sizeof(t));
\r
10723 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10724 t.RadiusPort = 1812;
\r
10727 ret = ScSetHubRadius(ps->Rpc, &t);
\r
10729 if (ret != ERR_NO_ERROR)
\r
10732 CmdPrintError(c, ret);
\r
10733 FreeParamValueList(o);
\r
10737 FreeParamValueList(o);
\r
10742 // ユーザー認証に使用する Radius サーバー設定の取得
\r
10743 UINT PsRadiusServerGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10746 PS *ps = (PS *)param;
\r
10750 // 仮想 HUB が選択されていない場合はエラー
\r
10751 if (ps->HubName == NULL)
\r
10753 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10754 return ERR_INVALID_PARAMETER;
\r
10757 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10760 return ERR_INVALID_PARAMETER;
\r
10763 Zero(&t, sizeof(t));
\r
10765 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10768 ret = ScGetHubRadius(ps->Rpc, &t);
\r
10770 if (ret != ERR_NO_ERROR)
\r
10773 CmdPrintError(c, ret);
\r
10774 FreeParamValueList(o);
\r
10780 wchar_t tmp[MAX_SIZE];
\r
10782 ct = CtNewStandard();
\r
10784 if (IsEmptyStr(t.RadiusServerName))
\r
10786 CtInsert(ct, _UU("CMD_RadiusServerGet_STATUS"), _UU("CMD_MSG_DISABLE"));
\r
10790 CtInsert(ct, _UU("CMD_RadiusServerGet_STATUS"), _UU("CMD_MSG_ENABLE"));
\r
10792 StrToUni(tmp, sizeof(tmp), t.RadiusServerName);
\r
10793 CtInsert(ct, _UU("CMD_RadiusServerGet_HOST"), tmp);
\r
10795 UniToStri(tmp, t.RadiusPort);
\r
10796 CtInsert(ct, _UU("CMD_RadiusServerGet_PORT"), tmp);
\r
10798 StrToUni(tmp, sizeof(tmp), t.RadiusSecret);
\r
10799 CtInsert(ct, _UU("CMD_RadiusServerGet_SECRET"), tmp);
\r
10801 UniToStri(tmp, t.RadiusRetryInterval);
\r
10802 CtInsert(ct, _UU("CMD_RadiusServerGet_RetryInterval"), tmp);
\r
10808 FreeParamValueList(o);
\r
10813 // 仮想 HUB の現在の状況の取得
\r
10814 UINT PsStatusGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10817 PS *ps = (PS *)param;
\r
10819 RPC_HUB_STATUS t;
\r
10821 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10824 return ERR_INVALID_PARAMETER;
\r
10827 // 仮想 HUB が選択されていない場合はエラー
\r
10828 if (ps->HubName == NULL)
\r
10830 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10831 return ERR_INVALID_PARAMETER;
\r
10834 Zero(&t, sizeof(t));
\r
10836 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10839 ret = ScGetHubStatus(ps->Rpc, &t);
\r
10841 if (ret != ERR_NO_ERROR)
\r
10844 CmdPrintError(c, ret);
\r
10845 FreeParamValueList(o);
\r
10850 CT *ct = CtNewStandard();
\r
10852 wchar_t tmp[MAX_SIZE];
\r
10855 s = CopyStrToUni(t.HubName);
\r
10856 CtInsert(ct, _UU("SM_HUB_STATUS_HUBNAME"), s);
\r
10860 CtInsert(ct, _UU("SM_HUB_STATUS_ONLINE"),
\r
10861 t.Online ? _UU("SM_HUB_ONLINE") : _UU("SM_HUB_OFFLINE"));
\r
10864 CtInsert(ct, _UU("SM_HUB_TYPE"),
\r
10865 GetHubTypeStr(t.HubType));
\r
10867 if (t.HubType == HUB_TYPE_STANDALONE)
\r
10869 // SecureNAT の有効/無効
\r
10870 CtInsert(ct, _UU("SM_HUB_SECURE_NAT"),
\r
10871 t.SecureNATEnabled ? _UU("SM_HUB_SECURE_NAT_YES") : _UU("SM_HUB_SECURE_NAT_NO"));
\r
10875 UniToStru(tmp, t.NumSessions);
\r
10876 CtInsert(ct, _UU("SM_HUB_NUM_SESSIONS"), tmp);
\r
10878 if (t.NumSessionsClient != 0 || t.NumSessionsBridge != 0)
\r
10880 UniToStru(tmp, t.NumSessionsClient);
\r
10881 CtInsert(ct, _UU("SM_HUB_NUM_SESSIONS_CLIENT"), tmp);
\r
10882 UniToStru(tmp, t.NumSessionsBridge);
\r
10883 CtInsert(ct, _UU("SM_HUB_NUM_SESSIONS_BRIDGE"), tmp);
\r
10886 UniToStru(tmp, t.NumAccessLists);
\r
10887 CtInsert(ct, _UU("SM_HUB_NUM_ACCESSES"), tmp);
\r
10889 UniToStru(tmp, t.NumUsers);
\r
10890 CtInsert(ct, _UU("SM_HUB_NUM_USERS"), tmp);
\r
10891 UniToStru(tmp, t.NumGroups);
\r
10892 CtInsert(ct, _UU("SM_HUB_NUM_GROUPS"), tmp);
\r
10894 UniToStru(tmp, t.NumMacTables);
\r
10895 CtInsert(ct, _UU("SM_HUB_NUM_MAC_TABLES"), tmp);
\r
10896 UniToStru(tmp, t.NumIpTables);
\r
10897 CtInsert(ct, _UU("SM_HUB_NUM_IP_TABLES"), tmp);
\r
10900 UniToStru(tmp, t.NumLogin);
\r
10901 CtInsert(ct, _UU("SM_HUB_NUM_LOGIN"), tmp);
\r
10903 if (t.LastLoginTime != 0)
\r
10905 GetDateTimeStr64Uni(tmp, sizeof(tmp), SystemToLocal64(t.LastLoginTime));
\r
10909 UniStrCpy(tmp, sizeof(tmp), _UU("COMMON_UNKNOWN"));
\r
10911 CtInsert(ct, _UU("SM_HUB_LAST_LOGIN_TIME"), tmp);
\r
10913 if (t.LastCommTime != 0)
\r
10915 GetDateTimeStr64Uni(tmp, sizeof(tmp), SystemToLocal64(t.LastCommTime));
\r
10919 UniStrCpy(tmp, sizeof(tmp), _UU("COMMON_UNKNOWN"));
\r
10921 CtInsert(ct, _UU("SM_HUB_LAST_COMM_TIME"), tmp);
\r
10923 if (t.CreatedTime != 0)
\r
10925 GetDateTimeStr64Uni(tmp, sizeof(tmp), SystemToLocal64(t.CreatedTime));
\r
10929 UniStrCpy(tmp, sizeof(tmp), _UU("COMMON_UNKNOWN"));
\r
10931 CtInsert(ct, _UU("SM_HUB_CREATED_TIME"), tmp);
\r
10934 CmdInsertTrafficInfo(ct, &t.Traffic);
\r
10939 FreeParamValueList(o);
\r
10945 wchar_t *GetLogSwitchStr(UINT i)
\r
10949 Format(tmp, sizeof(tmp), "SM_LOG_SWITCH_%u", i);
\r
10955 wchar_t *GetPacketLogNameStr(UINT i)
\r
10959 Format(tmp, sizeof(tmp), "CMD_Log_%u", i);
\r
10964 // 仮想 HUB のログ保存設定の取得
\r
10965 UINT PsLogGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
10968 PS *ps = (PS *)param;
\r
10972 // 仮想 HUB が選択されていない場合はエラー
\r
10973 if (ps->HubName == NULL)
\r
10975 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
10976 return ERR_INVALID_PARAMETER;
\r
10979 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
10982 return ERR_INVALID_PARAMETER;
\r
10985 Zero(&t, sizeof(t));
\r
10987 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
10990 ret = ScGetHubLog(ps->Rpc, &t);
\r
10992 if (ret != ERR_NO_ERROR)
\r
10995 CmdPrintError(c, ret);
\r
10996 FreeParamValueList(o);
\r
11001 CT *ct = CtNewStandard();
\r
11003 CtInsert(ct, _UU("CMD_Log_SecurityLog"),
\r
11004 t.LogSetting.SaveSecurityLog ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
11005 if (t.LogSetting.SaveSecurityLog)
\r
11007 CtInsert(ct, _UU("CMD_Log_SwitchType"), GetLogSwitchStr(t.LogSetting.SecurityLogSwitchType));
\r
11010 CtInsert(ct, L"", L"");
\r
11012 CtInsert(ct, _UU("CMD_Log_PacketLog"),
\r
11013 t.LogSetting.SavePacketLog ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
11014 if (t.LogSetting.SavePacketLog)
\r
11018 CtInsert(ct, _UU("CMD_Log_SwitchType"), GetLogSwitchStr(t.LogSetting.PacketLogSwitchType));
\r
11020 for (i = 0;i <= 7;i++)
\r
11022 wchar_t *tmp = NULL;
\r
11024 switch (t.LogSetting.PacketLogConfig[i])
\r
11026 case PACKET_LOG_NONE:
\r
11027 tmp = _UU("D_SM_LOG@B_PACKET_0_0");
\r
11030 case PACKET_LOG_HEADER:
\r
11031 tmp = _UU("D_SM_LOG@B_PACKET_0_1");
\r
11034 case PACKET_LOG_ALL:
\r
11035 tmp = _UU("D_SM_LOG@B_PACKET_0_2");
\r
11039 CtInsert(ct, GetPacketLogNameStr(i),
\r
11047 FreeParamValueList(o);
\r
11052 // LogEnable コマンド
\r
11053 UINT PsLogEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11056 PS *ps = (PS *)param;
\r
11059 bool packet_log = false;
\r
11061 // 指定できるパラメータ リスト
\r
11064 {"[security|packet]", CmdPrompt, _UU("CMD_LogEnable_Prompt"), CmdEvalNotEmpty, NULL},
\r
11067 // 仮想 HUB が選択されていない場合はエラー
\r
11068 if (ps->HubName == NULL)
\r
11070 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11071 return ERR_INVALID_PARAMETER;
\r
11074 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11077 return ERR_INVALID_PARAMETER;
\r
11080 tmp = GetParamStr(o, "[security|packet]");
\r
11082 if (StartWith(tmp, "p"))
\r
11084 packet_log = true;
\r
11086 else if (StartWith(tmp, "s") == false)
\r
11088 c->Write(c, _UU("CMD_LogEnable_Prompt_Error"));
\r
11089 FreeParamValueList(o);
\r
11093 Zero(&t, sizeof(t));
\r
11095 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11098 ret = ScGetHubLog(ps->Rpc, &t);
\r
11099 if (ret != ERR_NO_ERROR)
\r
11102 CmdPrintError(c, ret);
\r
11103 FreeParamValueList(o);
\r
11107 if (packet_log == false)
\r
11109 t.LogSetting.SaveSecurityLog = true;
\r
11113 t.LogSetting.SavePacketLog = true;
\r
11117 ret = ScSetHubLog(ps->Rpc, &t);
\r
11118 if (ret != ERR_NO_ERROR)
\r
11121 CmdPrintError(c, ret);
\r
11122 FreeParamValueList(o);
\r
11126 FreeParamValueList(o);
\r
11131 // セキュリティ ログまたはパケット ログの無効化
\r
11132 UINT PsLogDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11135 PS *ps = (PS *)param;
\r
11138 bool packet_log = false;
\r
11140 // 指定できるパラメータ リスト
\r
11143 {"[security|packet]", CmdPrompt, _UU("CMD_LogEnable_Prompt"), CmdEvalNotEmpty, NULL},
\r
11146 // 仮想 HUB が選択されていない場合はエラー
\r
11147 if (ps->HubName == NULL)
\r
11149 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11150 return ERR_INVALID_PARAMETER;
\r
11153 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11156 return ERR_INVALID_PARAMETER;
\r
11159 tmp = GetParamStr(o, "[security|packet]");
\r
11161 if (StartWith(tmp, "p"))
\r
11163 packet_log = true;
\r
11165 else if (StartWith(tmp, "s") == false)
\r
11167 c->Write(c, _UU("CMD_LogEnable_Prompt_Error"));
\r
11168 FreeParamValueList(o);
\r
11169 return ERR_INVALID_PARAMETER;
\r
11172 Zero(&t, sizeof(t));
\r
11174 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11177 ret = ScGetHubLog(ps->Rpc, &t);
\r
11178 if (ret != ERR_NO_ERROR)
\r
11181 CmdPrintError(c, ret);
\r
11182 FreeParamValueList(o);
\r
11186 if (packet_log == false)
\r
11188 t.LogSetting.SaveSecurityLog = false;
\r
11192 t.LogSetting.SavePacketLog = false;
\r
11196 ret = ScSetHubLog(ps->Rpc, &t);
\r
11197 if (ret != ERR_NO_ERROR)
\r
11200 CmdPrintError(c, ret);
\r
11201 FreeParamValueList(o);
\r
11205 FreeParamValueList(o);
\r
11210 // 文字列をログ切り替え種類に変換
\r
11211 UINT StrToLogSwitchType(char *str)
\r
11213 UINT ret = INFINITE;
\r
11220 if (IsEmptyStr(str) || StartWith("none", str))
\r
11222 ret = LOG_SWITCH_NO;
\r
11224 else if (StartWith("second", str))
\r
11226 ret = LOG_SWITCH_SECOND;
\r
11228 else if (StartWith("minute", str))
\r
11230 ret = LOG_SWITCH_MINUTE;
\r
11232 else if (StartWith("hour", str))
\r
11234 ret = LOG_SWITCH_HOUR;
\r
11236 else if (StartWith("day", str))
\r
11238 ret = LOG_SWITCH_DAY;
\r
11240 else if (StartWith("month", str))
\r
11242 ret = LOG_SWITCH_MONTH;
\r
11248 // ログ ファイルの切り替え周期の設定
\r
11249 UINT PsLogSwitchSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11252 PS *ps = (PS *)param;
\r
11255 bool packet_log = false;
\r
11257 UINT new_switch_type = 0;
\r
11258 // 指定できるパラメータ リスト
\r
11261 {"[security|packet]", CmdPrompt, _UU("CMD_LogEnable_Prompt"), CmdEvalNotEmpty, NULL},
\r
11262 {"SWITCH", CmdPrompt, _UU("CMD_LogSwitchSet_Prompt"), NULL, NULL},
\r
11265 // 仮想 HUB が選択されていない場合はエラー
\r
11266 if (ps->HubName == NULL)
\r
11268 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11269 return ERR_INVALID_PARAMETER;
\r
11272 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11275 return ERR_INVALID_PARAMETER;
\r
11278 tmp = GetParamStr(o, "[security|packet]");
\r
11280 if (StartWith(tmp, "p"))
\r
11282 packet_log = true;
\r
11284 else if (StartWith(tmp, "s") == false)
\r
11286 c->Write(c, _UU("CMD_LogEnable_Prompt_Error"));
\r
11287 FreeParamValueList(o);
\r
11288 return ERR_INVALID_PARAMETER;
\r
11291 new_switch_type = StrToLogSwitchType(GetParamStr(o, "SWITCH"));
\r
11293 if (new_switch_type == INFINITE)
\r
11295 c->Write(c, _UU("CMD_LogEnable_Prompt_Error"));
\r
11296 FreeParamValueList(o);
\r
11297 return ERR_INVALID_PARAMETER;
\r
11300 Zero(&t, sizeof(t));
\r
11302 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11305 ret = ScGetHubLog(ps->Rpc, &t);
\r
11306 if (ret != ERR_NO_ERROR)
\r
11309 CmdPrintError(c, ret);
\r
11310 FreeParamValueList(o);
\r
11314 if (packet_log == false)
\r
11316 t.LogSetting.SecurityLogSwitchType = new_switch_type;
\r
11320 t.LogSetting.PacketLogSwitchType = new_switch_type;
\r
11324 ret = ScSetHubLog(ps->Rpc, &t);
\r
11325 if (ret != ERR_NO_ERROR)
\r
11328 CmdPrintError(c, ret);
\r
11329 FreeParamValueList(o);
\r
11333 FreeParamValueList(o);
\r
11338 // パケットログのパケットの保存内容の文字列を整数に変換
\r
11339 UINT StrToPacketLogSaveInfoType(char *str)
\r
11341 UINT ret = INFINITE;
\r
11347 if (StartWith("none", str) || IsEmptyStr(str))
\r
11349 ret = PACKET_LOG_NONE;
\r
11351 else if (StartWith("header", str))
\r
11353 ret = PACKET_LOG_HEADER;
\r
11355 else if (StartWith("full", str) || StartWith("all", str))
\r
11357 ret = PACKET_LOG_ALL;
\r
11363 // パケットログのパケットの種類の文字列を整数に変換
\r
11364 UINT StrToPacketLogType(char *str)
\r
11366 UINT ret = INFINITE;
\r
11367 if (str == NULL || IsEmptyStr(str))
\r
11372 if (StartWith("tcpconn", str))
\r
11374 ret = PACKET_LOG_TCP_CONN;
\r
11376 else if (StartWith("tcpdata", str))
\r
11378 ret = PACKET_LOG_TCP;
\r
11380 else if (StartWith("dhcp", str))
\r
11382 ret = PACKET_LOG_DHCP;
\r
11384 else if (StartWith("udp", str))
\r
11386 ret = PACKET_LOG_UDP;
\r
11388 else if (StartWith("icmp", str))
\r
11390 ret = PACKET_LOG_ICMP;
\r
11392 else if (StartWith("ip", str))
\r
11394 ret = PACKET_LOG_IP;
\r
11396 else if (StartWith("arp", str))
\r
11398 ret = PACKET_LOG_ARP;
\r
11400 else if (StartWith("ethernet", str))
\r
11402 ret = PACKET_LOG_ETHERNET;
\r
11408 // パケット ログに保存するパケットの種類と保存内容の設定
\r
11409 UINT PsLogPacketSaveType(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11412 PS *ps = (PS *)param;
\r
11415 bool packet_log = false;
\r
11416 UINT packet_type = INFINITE;
\r
11417 UINT packet_save_info_type = INFINITE;
\r
11418 // 指定できるパラメータ リスト
\r
11421 {"TYPE", CmdPrompt, _UU("CMD_LogPacketSaveType_Prompt_TYPE"), NULL, NULL},
\r
11422 {"SAVE", CmdPrompt, _UU("CMD_LogPacketSaveType_Prompt_SAVE"), NULL, NULL},
\r
11425 // 仮想 HUB が選択されていない場合はエラー
\r
11426 if (ps->HubName == NULL)
\r
11428 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11429 return ERR_INVALID_PARAMETER;
\r
11432 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11435 return ERR_INVALID_PARAMETER;
\r
11438 packet_type = StrToPacketLogType(GetParamStr(o, "TYPE"));
\r
11439 packet_save_info_type = StrToPacketLogSaveInfoType(GetParamStr(o, "SAVE"));
\r
11441 if (packet_type == INFINITE || packet_save_info_type == INFINITE)
\r
11443 c->Write(c, _UU("CMD_LogEnable_Prompt_Error"));
\r
11444 FreeParamValueList(o);
\r
11445 return ERR_INVALID_PARAMETER;
\r
11448 Zero(&t, sizeof(t));
\r
11450 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11453 ret = ScGetHubLog(ps->Rpc, &t);
\r
11454 if (ret != ERR_NO_ERROR)
\r
11457 CmdPrintError(c, ret);
\r
11458 FreeParamValueList(o);
\r
11462 t.LogSetting.PacketLogConfig[packet_type] = packet_save_info_type;
\r
11465 ret = ScSetHubLog(ps->Rpc, &t);
\r
11466 if (ret != ERR_NO_ERROR)
\r
11469 CmdPrintError(c, ret);
\r
11470 FreeParamValueList(o);
\r
11474 FreeParamValueList(o);
\r
11479 // 信頼する証明機関の証明書一覧の取得
\r
11480 UINT PsCAList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11483 PS *ps = (PS *)param;
\r
11485 RPC_HUB_ENUM_CA t;
\r
11487 // 仮想 HUB が選択されていない場合はエラー
\r
11488 if (ps->HubName == NULL)
\r
11490 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11491 return ERR_INVALID_PARAMETER;
\r
11494 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
11497 return ERR_INVALID_PARAMETER;
\r
11500 Zero(&t, sizeof(t));
\r
11502 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11505 ret = ScEnumCa(ps->Rpc, &t);
\r
11507 if (ret != ERR_NO_ERROR)
\r
11510 CmdPrintError(c, ret);
\r
11511 FreeParamValueList(o);
\r
11517 CT *ct = CtNewStandard();
\r
11519 for (i = 0;i < t.NumCa;i++)
\r
11521 wchar_t tmp[MAX_SIZE];
\r
11522 wchar_t tmp2[64];
\r
11523 RPC_HUB_ENUM_CA_ITEM *e = &t.Ca[i];
\r
11525 GetDateStrEx64(tmp, sizeof(tmp), SystemToLocal64(e->Expires), NULL);
\r
11527 UniToStru(tmp2, e->Key);
\r
11529 CtInsert(ct, _UU("CMD_CAList_COLUMN_ID"), tmp2);
\r
11530 CtInsert(ct, _UU("CM_CERT_COLUMN_1"), e->SubjectName);
\r
11531 CtInsert(ct, _UU("CM_CERT_COLUMN_2"), e->IssuerName);
\r
11532 CtInsert(ct, _UU("CM_CERT_COLUMN_3"), tmp);
\r
11534 if (i != (t.NumCa - 1))
\r
11536 CtInsert(ct, L"---", L"---");
\r
11543 FreeRpcHubEnumCa(&t);
\r
11545 FreeParamValueList(o);
\r
11550 // 信頼する証明機関の証明書の追加
\r
11551 UINT PsCAAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11554 PS *ps = (PS *)param;
\r
11556 RPC_HUB_ADD_CA t;
\r
11558 // 指定できるパラメータ リスト
\r
11561 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
11562 {"[path]", CmdPrompt, _UU("CMD_CAAdd_PROMPT_PATH"), CmdEvalIsFile, NULL},
\r
11565 // 仮想 HUB が選択されていない場合はエラー
\r
11566 if (ps->HubName == NULL)
\r
11568 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11569 return ERR_INVALID_PARAMETER;
\r
11572 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11575 return ERR_INVALID_PARAMETER;
\r
11578 x = FileToX(GetParamStr(o, "[path]"));
\r
11582 FreeParamValueList(o);
\r
11583 c->Write(c, _UU("CMD_MSG_LOAD_CERT_FAILED"));
\r
11584 return ERR_INVALID_PARAMETER;
\r
11587 Zero(&t, sizeof(t));
\r
11588 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11592 ret = ScAddCa(ps->Rpc, &t);
\r
11594 if (ret != ERR_NO_ERROR)
\r
11597 CmdPrintError(c, ret);
\r
11598 FreeParamValueList(o);
\r
11602 FreeRpcHubAddCa(&t);
\r
11604 FreeParamValueList(o);
\r
11609 // 信頼する証明機関の証明書の削除
\r
11610 UINT PsCADelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11613 PS *ps = (PS *)param;
\r
11615 RPC_HUB_DELETE_CA t;
\r
11616 // 指定できるパラメータ リスト
\r
11619 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
11620 {"[id]", CmdPrompt, _UU("CMD_CADelete_PROMPT_ID"), CmdEvalNotEmpty, NULL},
\r
11623 // 仮想 HUB が選択されていない場合はエラー
\r
11624 if (ps->HubName == NULL)
\r
11626 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11627 return ERR_INVALID_PARAMETER;
\r
11630 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11633 return ERR_INVALID_PARAMETER;
\r
11636 Zero(&t, sizeof(t));
\r
11637 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11638 t.Key = GetParamInt(o, "[id]");
\r
11641 ret = ScDeleteCa(ps->Rpc, &t);
\r
11643 if (ret != ERR_NO_ERROR)
\r
11646 CmdPrintError(c, ret);
\r
11647 FreeParamValueList(o);
\r
11651 FreeParamValueList(o);
\r
11656 // 信頼する証明機関の証明書の取得
\r
11657 UINT PsCAGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11660 PS *ps = (PS *)param;
\r
11662 RPC_HUB_GET_CA t;
\r
11663 // 指定できるパラメータ リスト
\r
11666 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
11667 {"[id]", CmdPrompt, _UU("CMD_CAGet_PROMPT_ID"), CmdEvalNotEmpty, NULL},
\r
11668 {"SAVECERT", CmdPrompt, _UU("CMD_CAGet_PROMPT_SAVECERT"), CmdEvalNotEmpty, NULL},
\r
11671 // 仮想 HUB が選択されていない場合はエラー
\r
11672 if (ps->HubName == NULL)
\r
11674 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11675 return ERR_INVALID_PARAMETER;
\r
11678 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11681 return ERR_INVALID_PARAMETER;
\r
11684 Zero(&t, sizeof(t));
\r
11685 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11686 t.Key = GetParamInt(o, "[id]");
\r
11689 ret = ScGetCa(ps->Rpc, &t);
\r
11691 if (ret != ERR_NO_ERROR)
\r
11694 CmdPrintError(c, ret);
\r
11695 FreeParamValueList(o);
\r
11700 if (XToFile(t.Cert, GetParamStr(o, "SAVECERT"), true))
\r
11706 ret = ERR_INTERNAL_ERROR;
\r
11707 c->Write(c, _UU("CMD_MSG_SAVE_CERT_FAILED"));
\r
11711 FreeRpcHubGetCa(&t);
\r
11713 FreeParamValueList(o);
\r
11719 UINT PsCascadeList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11722 PS *ps = (PS *)param;
\r
11726 // 仮想 HUB が選択されていない場合はエラー
\r
11727 if (ps->HubName == NULL)
\r
11729 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11730 return ERR_INVALID_PARAMETER;
\r
11733 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
11736 return ERR_INVALID_PARAMETER;
\r
11739 Zero(&t, sizeof(t));
\r
11740 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11743 ret = ScEnumLink(ps->Rpc, &t);
\r
11745 if (ret != ERR_NO_ERROR)
\r
11748 CmdPrintError(c, ret);
\r
11749 FreeParamValueList(o);
\r
11754 CT *ct = CtNew();
\r
11757 CtInsertColumn(ct, _UU("SM_LINK_COLUMN_1"), false);
\r
11758 CtInsertColumn(ct, _UU("SM_LINK_COLUMN_2"), false);
\r
11759 CtInsertColumn(ct, _UU("SM_LINK_COLUMN_3"), false);
\r
11760 CtInsertColumn(ct, _UU("SM_LINK_COLUMN_4"), false);
\r
11761 CtInsertColumn(ct, _UU("SM_LINK_COLUMN_5"), false);
\r
11763 for (i = 0;i < t.NumLink;i++)
\r
11765 RPC_ENUM_LINK_ITEM *e = &t.Links[i];
\r
11766 wchar_t tmp1[MAX_SIZE];
\r
11767 wchar_t tmp2[MAX_SIZE];
\r
11768 wchar_t tmp3[MAX_SIZE];
\r
11769 wchar_t tmp4[MAX_SIZE];
\r
11771 GetDateTimeStrEx64(tmp1, sizeof(tmp1), SystemToLocal64(e->ConnectedTime), NULL);
\r
11772 StrToUni(tmp2, sizeof(tmp2), e->Hostname);
\r
11773 StrToUni(tmp3, sizeof(tmp3), e->HubName);
\r
11775 if (e->Online == false)
\r
11777 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_LINK_STATUS_OFFLINE"));
\r
11781 if (e->Connected)
\r
11783 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_LINK_STATUS_ONLINE"));
\r
11787 if (e->LastError != 0)
\r
11789 UniFormat(tmp4, sizeof(tmp4), _UU("SM_LINK_STATUS_ERROR"), e->LastError, _E(e->LastError));
\r
11793 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_LINK_CONNECTING"));
\r
11798 CtInsert(ct, e->AccountName, tmp4, tmp1, tmp2, tmp3);
\r
11801 CtFreeEx(ct, c, true);
\r
11804 FreeRpcEnumLink(&t);
\r
11806 FreeParamValueList(o);
\r
11812 UINT PsCascadeCreate(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11815 PS *ps = (PS *)param;
\r
11817 RPC_CREATE_LINK t;
\r
11818 char *host = NULL;
\r
11820 // 指定できるパラメータ リスト
\r
11823 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
11824 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
11825 {"SERVER", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Server"), CmdEvalHostAndPort, NULL},
\r
11826 {"HUB", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Hub"), CmdEvalSafe, NULL},
\r
11827 {"USERNAME", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Username"), CmdEvalNotEmpty, NULL},
\r
11830 // 仮想 HUB が選択されていない場合はエラー
\r
11831 if (ps->HubName == NULL)
\r
11833 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11834 return ERR_INVALID_PARAMETER;
\r
11837 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11840 return ERR_INVALID_PARAMETER;
\r
11843 ParseHostPort(GetParamStr(o, "SERVER"), &host, &port, 443);
\r
11845 Zero(&t, sizeof(t));
\r
11846 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11848 t.Online = false;
\r
11850 Copy(&t.Policy, GetDefaultPolicy(), sizeof(POLICY));
\r
11852 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
11853 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
11854 t.ClientOption->Port = port;
\r
11855 StrCpy(t.ClientOption->Hostname, sizeof(t.ClientOption->Hostname), host);
\r
11856 StrCpy(t.ClientOption->HubName, sizeof(t.ClientOption->HubName), GetParamStr(o, "HUB"));
\r
11857 t.ClientOption->NumRetry = INFINITE;
\r
11858 t.ClientOption->RetryInterval = 15;
\r
11859 t.ClientOption->MaxConnection = 8;
\r
11860 t.ClientOption->UseEncrypt = true;
\r
11861 t.ClientOption->AdditionalConnectionInterval = 1;
\r
11862 t.ClientOption->RequireBridgeRoutingMode = true;
\r
11864 t.ClientAuth = ZeroMalloc(sizeof(CLIENT_AUTH));
\r
11865 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_ANONYMOUS;
\r
11866 StrCpy(t.ClientAuth->Username, sizeof(t.ClientAuth->Username), GetParamStr(o, "USERNAME"));
\r
11871 ret = ScCreateLink(ps->Rpc, &t);
\r
11873 if (ret != ERR_NO_ERROR)
\r
11876 CmdPrintError(c, ret);
\r
11877 FreeParamValueList(o);
\r
11881 FreeRpcCreateLink(&t);
\r
11883 FreeParamValueList(o);
\r
11888 // カスケード接続の接続先とユーザー名の設定
\r
11889 UINT PsCascadeSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11892 PS *ps = (PS *)param;
\r
11894 RPC_CREATE_LINK t;
\r
11895 char *host = NULL;
\r
11897 // 指定できるパラメータ リスト
\r
11900 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
11901 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
11902 {"SERVER", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Server"), CmdEvalHostAndPort, NULL},
\r
11903 {"HUB", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Hub"), CmdEvalSafe, NULL},
\r
11906 // 仮想 HUB が選択されていない場合はエラー
\r
11907 if (ps->HubName == NULL)
\r
11909 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
11910 return ERR_INVALID_PARAMETER;
\r
11913 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
11916 return ERR_INVALID_PARAMETER;
\r
11919 ParseHostPort(GetParamStr(o, "SERVER"), &host, &port, 443);
\r
11921 Zero(&t, sizeof(t));
\r
11922 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
11924 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
11925 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
11927 ret = ScGetLink(ps->Rpc, &t);
\r
11928 if (ret != ERR_NO_ERROR)
\r
11931 CmdPrintError(c, ret);
\r
11932 FreeParamValueList(o);
\r
11937 t.ClientOption->Port = port;
\r
11938 StrCpy(t.ClientOption->Hostname, sizeof(t.ClientOption->Hostname), host);
\r
11939 StrCpy(t.ClientOption->HubName, sizeof(t.ClientOption->HubName), GetParamStr(o, "HUB"));
\r
11944 ret = ScSetLink(ps->Rpc, &t);
\r
11946 if (ret != ERR_NO_ERROR)
\r
11949 CmdPrintError(c, ret);
\r
11950 FreeParamValueList(o);
\r
11954 FreeRpcCreateLink(&t);
\r
11956 FreeParamValueList(o);
\r
11962 wchar_t *GetProxyTypeStr(UINT i)
\r
11966 case PROXY_DIRECT:
\r
11968 return _UU("PROTO_DIRECT_TCP");
\r
11971 return _UU("PROTO_HTTP_PROXY");
\r
11973 case PROXY_SOCKS:
\r
11974 return _UU("PROTO_SOCKS_PROXY");
\r
11977 return _UU("PROTO_UNKNOWN");
\r
11981 // クライアントのユーザー認証の種類文字列の取得
\r
11982 wchar_t *GetClientAuthTypeStr(UINT i)
\r
11984 char tmp[MAX_SIZE];
\r
11986 Format(tmp, sizeof(tmp), "PW_TYPE_%u", i);
\r
11992 UINT PsCascadeGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
11995 PS *ps = (PS *)param;
\r
11997 RPC_CREATE_LINK t;
\r
11998 // 指定できるパラメータ リスト
\r
12001 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12002 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12005 // 仮想 HUB が選択されていない場合はエラー
\r
12006 if (ps->HubName == NULL)
\r
12008 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12009 return ERR_INVALID_PARAMETER;
\r
12012 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12015 return ERR_INVALID_PARAMETER;
\r
12018 Zero(&t, sizeof(t));
\r
12019 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12020 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12021 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName),
\r
12022 GetParamUniStr(o, "[name]"));
\r
12025 ret = ScGetLink(ps->Rpc, &t);
\r
12027 if (ret != ERR_NO_ERROR)
\r
12030 CmdPrintError(c, ret);
\r
12031 FreeParamValueList(o);
\r
12037 wchar_t tmp[MAX_SIZE];
\r
12039 CT *ct = CtNewStandard();
\r
12042 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_NAME"), t.ClientOption->AccountName);
\r
12044 // 接続先 VPN Server のホスト名
\r
12045 StrToUni(tmp, sizeof(tmp), t.ClientOption->Hostname);
\r
12046 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_HOSTNAME"), tmp);
\r
12048 // 接続先 VPN Server のポート番号
\r
12049 UniToStru(tmp, t.ClientOption->Port);
\r
12050 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PORT"), tmp);
\r
12052 // 接続先 VPN Server の仮想 HUB 名
\r
12053 StrToUni(tmp, sizeof(tmp), t.ClientOption->HubName);
\r
12054 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_HUBNAME"), tmp);
\r
12056 // 経由するプロキシ サーバーの種類
\r
12057 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PROXY_TYPE"), GetProxyTypeStr(t.ClientOption->ProxyType));
\r
12059 if (t.ClientOption->ProxyType != PROXY_DIRECT)
\r
12061 // プロキシ サーバーのホスト名
\r
12062 StrToUni(tmp, sizeof(tmp), t.ClientOption->ProxyName);
\r
12063 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PROXY_HOSTNAME"), tmp);
\r
12065 // プロキシ サーバーのポート番号
\r
12066 UniToStru(tmp, t.ClientOption->ProxyPort);
\r
12067 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PROXY_PORT"), tmp);
\r
12069 // プロキシ サーバーのユーザー名
\r
12070 StrToUni(tmp, sizeof(tmp), t.ClientOption->ProxyUsername);
\r
12071 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_PROXY_USERNAME"), tmp);
\r
12075 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_SERVER_CERT_USE"),
\r
12076 t.CheckServerCert ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
12079 if (t.ServerCert != NULL)
\r
12081 GetAllNameFromX(tmp, sizeof(tmp), t.ServerCert);
\r
12082 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_SERVER_CERT_NAME"), tmp);
\r
12086 StrToUni(tmp, sizeof(tmp), t.ClientOption->DeviceName);
\r
12087 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_DEVICE_NAME"), tmp);
\r
12090 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_AUTH_TYPE"), GetClientAuthTypeStr(t.ClientAuth->AuthType));
\r
12093 StrToUni(tmp, sizeof(tmp), t.ClientAuth->Username);
\r
12094 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_AUTH_USERNAME"), tmp);
\r
12096 if (t.ClientAuth->AuthType == CLIENT_AUTHTYPE_CERT)
\r
12098 if (t.ClientAuth->ClientX != NULL)
\r
12101 GetAllNameFromX(tmp, sizeof(tmp), t.ClientAuth->ClientX);
\r
12102 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_AUTH_CERT_NAME"), tmp);
\r
12106 // VPN 通信に使用する TCP コネクション数
\r
12107 UniToStru(tmp, t.ClientOption->MaxConnection);
\r
12108 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_NUMTCP"), tmp);
\r
12110 // 各 TCP コネクションの確立間隔
\r
12111 UniToStru(tmp, t.ClientOption->AdditionalConnectionInterval);
\r
12112 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_TCP_INTERVAL"), tmp);
\r
12114 // 各 TCP コネクションの寿命
\r
12115 if (t.ClientOption->ConnectionDisconnectSpan != 0)
\r
12117 UniToStru(tmp, t.ClientOption->ConnectionDisconnectSpan);
\r
12121 UniStrCpy(tmp, sizeof(tmp), _UU("CMD_MSG_INFINITE"));
\r
12123 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_TCP_TTL"), tmp);
\r
12126 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_TCP_HALF"),
\r
12127 t.ClientOption->HalfConnection ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
12130 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_ENCRYPT"),
\r
12131 t.ClientOption->UseEncrypt ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
12134 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_COMPRESS"),
\r
12135 t.ClientOption->UseCompress ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
12137 // ブリッジ / ルータモードで接続
\r
12138 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_BRIDGE_ROUTER"),
\r
12139 t.ClientOption->RequireBridgeRoutingMode ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
12142 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_MONITOR"),
\r
12143 t.ClientOption->RequireMonitorMode ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
12145 // ルーティング テーブルを書き換えない
\r
12146 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_NO_TRACKING"),
\r
12147 t.ClientOption->NoRoutingTracking ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
12150 CtInsert(ct, _UU("CMD_ACCOUNT_COLUMN_QOS_DISABLE"),
\r
12151 t.ClientOption->DisableQoS ? _UU("CMD_MSG_ENABLE") : _UU("CMD_MSG_DISABLE"));
\r
12156 c->Write(c, L"");
\r
12157 c->Write(c, _UU("CMD_CascadeGet_Policy"));
\r
12158 PrintPolicy(c, &t.Policy, true);
\r
12161 FreeRpcCreateLink(&t);
\r
12163 FreeParamValueList(o);
\r
12169 UINT PsCascadeDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12172 PS *ps = (PS *)param;
\r
12175 // 指定できるパラメータ リスト
\r
12178 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12181 // 仮想 HUB が選択されていない場合はエラー
\r
12182 if (ps->HubName == NULL)
\r
12184 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12185 return ERR_INVALID_PARAMETER;
\r
12188 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12191 return ERR_INVALID_PARAMETER;
\r
12194 Zero(&t, sizeof(t));
\r
12195 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
12196 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12199 ret = ScDeleteLink(ps->Rpc, &t);
\r
12201 if (ret != ERR_NO_ERROR)
\r
12204 CmdPrintError(c, ret);
\r
12205 FreeParamValueList(o);
\r
12209 FreeParamValueList(o);
\r
12214 // カスケード接続の接続に使用するユーザー名の設定
\r
12215 UINT PsCascadeUsernameSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12218 PS *ps = (PS *)param;
\r
12220 RPC_CREATE_LINK t;
\r
12221 // 指定できるパラメータ リスト
\r
12224 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12225 {"USERNAME", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Username"), CmdEvalNotEmpty, NULL},
\r
12228 // 仮想 HUB が選択されていない場合はエラー
\r
12229 if (ps->HubName == NULL)
\r
12231 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12232 return ERR_INVALID_PARAMETER;
\r
12235 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12238 return ERR_INVALID_PARAMETER;
\r
12241 Zero(&t, sizeof(t));
\r
12242 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12243 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12244 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12247 ret = ScGetLink(ps->Rpc, &t);
\r
12249 if (ret != ERR_NO_ERROR)
\r
12252 CmdPrintError(c, ret);
\r
12253 FreeParamValueList(o);
\r
12259 StrCpy(t.ClientAuth->Username, sizeof(t.ClientAuth->Username),
\r
12260 GetParamStr(o, "USERNAME"));
\r
12262 if (t.ClientAuth->AuthType == CLIENT_AUTHTYPE_PASSWORD)
\r
12264 c->Write(c, _UU("CMD_CascadeUsername_Notice"));
\r
12267 ret = ScSetLink(ps->Rpc, &t);
\r
12268 if (ret != ERR_NO_ERROR)
\r
12271 CmdPrintError(c, ret);
\r
12272 FreeParamValueList(o);
\r
12276 FreeRpcCreateLink(&t);
\r
12279 FreeParamValueList(o);
\r
12284 //カスケード接続のユーザー認証の種類を匿名認証に設定
\r
12285 UINT PsCascadeAnonymousSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12288 PS *ps = (PS *)param;
\r
12290 RPC_CREATE_LINK t;
\r
12291 // 指定できるパラメータ リスト
\r
12294 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12297 // 仮想 HUB が選択されていない場合はエラー
\r
12298 if (ps->HubName == NULL)
\r
12300 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12301 return ERR_INVALID_PARAMETER;
\r
12304 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12307 return ERR_INVALID_PARAMETER;
\r
12310 Zero(&t, sizeof(t));
\r
12311 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12312 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12313 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12316 ret = ScGetLink(ps->Rpc, &t);
\r
12318 if (ret != ERR_NO_ERROR)
\r
12321 CmdPrintError(c, ret);
\r
12322 FreeParamValueList(o);
\r
12328 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_ANONYMOUS;
\r
12330 ret = ScSetLink(ps->Rpc, &t);
\r
12331 if (ret != ERR_NO_ERROR)
\r
12334 CmdPrintError(c, ret);
\r
12335 FreeParamValueList(o);
\r
12339 FreeRpcCreateLink(&t);
\r
12342 FreeParamValueList(o);
\r
12347 // カスケード接続のユーザー認証の種類をパスワード認証に設定
\r
12348 UINT PsCascadePasswordSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12351 PS *ps = (PS *)param;
\r
12353 RPC_CREATE_LINK t;
\r
12354 // 指定できるパラメータ リスト
\r
12357 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12358 {"PASSWORD", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
12359 {"TYPE", CmdPrompt, _UU("CMD_CascadePasswordSet_Prompt_Type"), CmdEvalNotEmpty, NULL},
\r
12362 // 仮想 HUB が選択されていない場合はエラー
\r
12363 if (ps->HubName == NULL)
\r
12365 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12366 return ERR_INVALID_PARAMETER;
\r
12369 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12372 return ERR_INVALID_PARAMETER;
\r
12375 Zero(&t, sizeof(t));
\r
12376 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12377 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12378 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12381 ret = ScGetLink(ps->Rpc, &t);
\r
12383 if (ret != ERR_NO_ERROR)
\r
12386 CmdPrintError(c, ret);
\r
12387 FreeParamValueList(o);
\r
12393 char *typestr = GetParamStr(o, "TYPE");
\r
12395 if (StartWith("standard", typestr))
\r
12397 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_PASSWORD;
\r
12398 HashPassword(t.ClientAuth->HashedPassword, t.ClientAuth->Username,
\r
12399 GetParamStr(o, "PASSWORD"));
\r
12401 else if (StartWith("radius", typestr) || StartWith("ntdomain", typestr))
\r
12403 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_PLAIN_PASSWORD;
\r
12405 StrCpy(t.ClientAuth->PlainPassword, sizeof(t.ClientAuth->PlainPassword),
\r
12406 GetParamStr(o, "PASSWORD"));
\r
12411 c->Write(c, _UU("CMD_CascadePasswordSet_Type_Invalid"));
\r
12412 FreeRpcCreateLink(&t);
\r
12413 ret = ERR_INVALID_PARAMETER;
\r
12414 CmdPrintError(c, ret);
\r
12415 FreeParamValueList(o);
\r
12416 return ERR_INTERNAL_ERROR;
\r
12419 ret = ScSetLink(ps->Rpc, &t);
\r
12420 if (ret != ERR_NO_ERROR)
\r
12423 CmdPrintError(c, ret);
\r
12424 FreeParamValueList(o);
\r
12428 FreeRpcCreateLink(&t);
\r
12431 FreeParamValueList(o);
\r
12436 // カスケード接続のユーザー認証の種類をクライアント証明書認証に設定
\r
12437 UINT PsCascadeCertSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12440 PS *ps = (PS *)param;
\r
12442 RPC_CREATE_LINK t;
\r
12445 // 指定できるパラメータ リスト
\r
12448 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12449 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12450 {"LOADCERT", CmdPrompt, _UU("CMD_LOADCERTPATH"), CmdEvalIsFile, NULL},
\r
12451 {"LOADKEY", CmdPrompt, _UU("CMD_LOADKEYPATH"), CmdEvalIsFile, NULL},
\r
12454 // 仮想 HUB が選択されていない場合はエラー
\r
12455 if (ps->HubName == NULL)
\r
12457 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12458 return ERR_INVALID_PARAMETER;
\r
12461 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12464 return ERR_INVALID_PARAMETER;
\r
12467 if (CmdLoadCertAndKey(c, &x, &k, GetParamStr(o, "LOADCERT"), GetParamStr(o, "LOADKEY")) == false)
\r
12469 return ERR_INTERNAL_ERROR;
\r
12472 Zero(&t, sizeof(t));
\r
12473 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12474 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12475 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12478 ret = ScGetLink(ps->Rpc, &t);
\r
12480 if (ret != ERR_NO_ERROR)
\r
12485 CmdPrintError(c, ret);
\r
12486 FreeParamValueList(o);
\r
12492 t.ClientAuth->AuthType = CLIENT_AUTHTYPE_CERT;
\r
12493 if (t.ClientAuth->ClientX != NULL)
\r
12495 FreeX(t.ClientAuth->ClientX);
\r
12497 if (t.ClientAuth->ClientK != NULL)
\r
12499 FreeK(t.ClientAuth->ClientK);
\r
12502 t.ClientAuth->ClientX = x;
\r
12503 t.ClientAuth->ClientK = k;
\r
12505 ret = ScSetLink(ps->Rpc, &t);
\r
12506 if (ret != ERR_NO_ERROR)
\r
12509 CmdPrintError(c, ret);
\r
12510 FreeParamValueList(o);
\r
12514 FreeRpcCreateLink(&t);
\r
12517 FreeParamValueList(o);
\r
12522 // カスケード接続に用いるクライアント証明書の取得
\r
12523 UINT PsCascadeCertGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12526 PS *ps = (PS *)param;
\r
12528 RPC_CREATE_LINK t;
\r
12529 // 指定できるパラメータ リスト
\r
12532 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12533 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12534 {"SAVECERT", CmdPrompt, _UU("CMD_SAVECERTPATH"), CmdEvalNotEmpty, NULL},
\r
12537 // 仮想 HUB が選択されていない場合はエラー
\r
12538 if (ps->HubName == NULL)
\r
12540 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12541 return ERR_INVALID_PARAMETER;
\r
12544 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12547 return ERR_INVALID_PARAMETER;
\r
12550 Zero(&t, sizeof(t));
\r
12551 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12552 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12553 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12556 ret = ScGetLink(ps->Rpc, &t);
\r
12558 if (ret != ERR_NO_ERROR)
\r
12561 CmdPrintError(c, ret);
\r
12562 FreeParamValueList(o);
\r
12567 if (t.ClientAuth->AuthType != CLIENT_AUTHTYPE_CERT)
\r
12569 c->Write(c, _UU("CMD_CascadeCertSet_Not_Auth_Cert"));
\r
12570 ret = ERR_INTERNAL_ERROR;
\r
12572 else if (t.ClientAuth->ClientX == NULL)
\r
12574 c->Write(c, _UU("CMD_CascadeCertSet_Cert_Not_Exists"));
\r
12575 ret = ERR_INTERNAL_ERROR;
\r
12579 XToFile(t.ClientAuth->ClientX, GetParamStr(o, "SAVECERT"), true);
\r
12581 FreeRpcCreateLink(&t);
\r
12584 FreeParamValueList(o);
\r
12589 // カスケード接続の通信時の暗号化の有効化
\r
12590 UINT PsCascadeEncryptEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12593 PS *ps = (PS *)param;
\r
12595 RPC_CREATE_LINK t;
\r
12596 // 指定できるパラメータ リスト
\r
12599 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12600 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12603 // 仮想 HUB が選択されていない場合はエラー
\r
12604 if (ps->HubName == NULL)
\r
12606 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12607 return ERR_INVALID_PARAMETER;
\r
12610 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12613 return ERR_INVALID_PARAMETER;
\r
12616 Zero(&t, sizeof(t));
\r
12617 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12618 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12619 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12622 ret = ScGetLink(ps->Rpc, &t);
\r
12624 if (ret != ERR_NO_ERROR)
\r
12627 CmdPrintError(c, ret);
\r
12628 FreeParamValueList(o);
\r
12634 t.ClientOption->UseEncrypt = true;
\r
12636 ret = ScSetLink(ps->Rpc, &t);
\r
12637 if (ret != ERR_NO_ERROR)
\r
12640 CmdPrintError(c, ret);
\r
12641 FreeParamValueList(o);
\r
12645 FreeRpcCreateLink(&t);
\r
12648 FreeParamValueList(o);
\r
12653 // カスケード接続の通信時の暗号化の無効化
\r
12654 UINT PsCascadeEncryptDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12657 PS *ps = (PS *)param;
\r
12659 RPC_CREATE_LINK t;
\r
12660 // 指定できるパラメータ リスト
\r
12663 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12664 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12667 // 仮想 HUB が選択されていない場合はエラー
\r
12668 if (ps->HubName == NULL)
\r
12670 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12671 return ERR_INVALID_PARAMETER;
\r
12674 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12677 return ERR_INVALID_PARAMETER;
\r
12680 Zero(&t, sizeof(t));
\r
12681 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12682 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12683 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12686 ret = ScGetLink(ps->Rpc, &t);
\r
12688 if (ret != ERR_NO_ERROR)
\r
12691 CmdPrintError(c, ret);
\r
12692 FreeParamValueList(o);
\r
12698 t.ClientOption->UseEncrypt = false;
\r
12700 ret = ScSetLink(ps->Rpc, &t);
\r
12701 if (ret != ERR_NO_ERROR)
\r
12704 CmdPrintError(c, ret);
\r
12705 FreeParamValueList(o);
\r
12709 FreeRpcCreateLink(&t);
\r
12712 FreeParamValueList(o);
\r
12717 // カスケード接続の通信時のデータ圧縮の有効化
\r
12718 UINT PsCascadeCompressEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12721 PS *ps = (PS *)param;
\r
12723 RPC_CREATE_LINK t;
\r
12724 // 指定できるパラメータ リスト
\r
12727 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12728 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12731 // 仮想 HUB が選択されていない場合はエラー
\r
12732 if (ps->HubName == NULL)
\r
12734 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12735 return ERR_INVALID_PARAMETER;
\r
12738 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12741 return ERR_INVALID_PARAMETER;
\r
12744 Zero(&t, sizeof(t));
\r
12745 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12746 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12747 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12750 ret = ScGetLink(ps->Rpc, &t);
\r
12752 if (ret != ERR_NO_ERROR)
\r
12755 CmdPrintError(c, ret);
\r
12756 FreeParamValueList(o);
\r
12762 t.ClientOption->UseCompress = true;
\r
12764 ret = ScSetLink(ps->Rpc, &t);
\r
12765 if (ret != ERR_NO_ERROR)
\r
12768 CmdPrintError(c, ret);
\r
12769 FreeParamValueList(o);
\r
12773 FreeRpcCreateLink(&t);
\r
12776 FreeParamValueList(o);
\r
12781 // カスケード接続の通信時のデータ圧縮の無効化
\r
12782 UINT PsCascadeCompressDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12785 PS *ps = (PS *)param;
\r
12787 RPC_CREATE_LINK t;
\r
12788 // 指定できるパラメータ リスト
\r
12791 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12792 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12795 // 仮想 HUB が選択されていない場合はエラー
\r
12796 if (ps->HubName == NULL)
\r
12798 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12799 return ERR_INVALID_PARAMETER;
\r
12802 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12805 return ERR_INVALID_PARAMETER;
\r
12808 Zero(&t, sizeof(t));
\r
12809 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12810 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12811 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12814 ret = ScGetLink(ps->Rpc, &t);
\r
12816 if (ret != ERR_NO_ERROR)
\r
12819 CmdPrintError(c, ret);
\r
12820 FreeParamValueList(o);
\r
12826 t.ClientOption->UseCompress = false;
\r
12828 ret = ScSetLink(ps->Rpc, &t);
\r
12829 if (ret != ERR_NO_ERROR)
\r
12832 CmdPrintError(c, ret);
\r
12833 FreeParamValueList(o);
\r
12837 FreeRpcCreateLink(&t);
\r
12840 FreeParamValueList(o);
\r
12845 // カスケード接続の接続方法を直接 TCP/IP 接続に設定
\r
12846 UINT PsCascadeProxyNone(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12849 PS *ps = (PS *)param;
\r
12851 RPC_CREATE_LINK t;
\r
12852 // 指定できるパラメータ リスト
\r
12855 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12856 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12859 // 仮想 HUB が選択されていない場合はエラー
\r
12860 if (ps->HubName == NULL)
\r
12862 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12863 return ERR_INVALID_PARAMETER;
\r
12866 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12869 return ERR_INVALID_PARAMETER;
\r
12872 Zero(&t, sizeof(t));
\r
12873 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12874 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12875 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12878 ret = ScGetLink(ps->Rpc, &t);
\r
12880 if (ret != ERR_NO_ERROR)
\r
12883 CmdPrintError(c, ret);
\r
12884 FreeParamValueList(o);
\r
12890 t.ClientOption->ProxyType = PROXY_DIRECT;
\r
12892 ret = ScSetLink(ps->Rpc, &t);
\r
12893 if (ret != ERR_NO_ERROR)
\r
12896 CmdPrintError(c, ret);
\r
12897 FreeParamValueList(o);
\r
12901 FreeRpcCreateLink(&t);
\r
12904 FreeParamValueList(o);
\r
12909 // カスケード接続の接続方法を HTTP プロキシサーバー経由接続に設定
\r
12910 UINT PsCascadeProxyHttp(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12913 PS *ps = (PS *)param;
\r
12915 RPC_CREATE_LINK t;
\r
12916 // 指定できるパラメータ リスト
\r
12919 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12920 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12921 {"SERVER", CmdPrompt, _UU("CMD_CascadeProxyHttp_Prompt_Server"), CmdEvalHostAndPort, NULL},
\r
12922 {"USERNAME", NULL, NULL, NULL, NULL},
\r
12923 {"PASSWORD", NULL, NULL, NULL, NULL},
\r
12926 // 仮想 HUB が選択されていない場合はエラー
\r
12927 if (ps->HubName == NULL)
\r
12929 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
12930 return ERR_INVALID_PARAMETER;
\r
12933 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
12936 return ERR_INVALID_PARAMETER;
\r
12939 Zero(&t, sizeof(t));
\r
12940 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
12941 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
12942 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
12945 ret = ScGetLink(ps->Rpc, &t);
\r
12947 if (ret != ERR_NO_ERROR)
\r
12950 CmdPrintError(c, ret);
\r
12951 FreeParamValueList(o);
\r
12960 if (ParseHostPort(GetParamStr(o, "SERVER"), &host, &port, 8080))
\r
12962 t.ClientOption->ProxyType = PROXY_HTTP;
\r
12963 StrCpy(t.ClientOption->ProxyName, sizeof(t.ClientOption->ProxyName), host);
\r
12964 t.ClientOption->ProxyPort = port;
\r
12965 StrCpy(t.ClientOption->ProxyUsername, sizeof(t.ClientOption->ProxyName), GetParamStr(o, "USERNAME"));
\r
12966 StrCpy(t.ClientOption->ProxyPassword, sizeof(t.ClientOption->ProxyName), GetParamStr(o, "PASSWORD"));
\r
12970 ret = ScSetLink(ps->Rpc, &t);
\r
12971 if (ret != ERR_NO_ERROR)
\r
12974 CmdPrintError(c, ret);
\r
12975 FreeParamValueList(o);
\r
12979 FreeRpcCreateLink(&t);
\r
12982 FreeParamValueList(o);
\r
12987 // カスケード接続の接続方法を SOCKS プロキシサーバー経由接続に設定
\r
12988 UINT PsCascadeProxySocks(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
12991 PS *ps = (PS *)param;
\r
12993 RPC_CREATE_LINK t;
\r
12994 // 指定できるパラメータ リスト
\r
12997 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
12998 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
12999 {"SERVER", CmdPrompt, _UU("CMD_CascadeProxyHttp_Prompt_Server"), CmdEvalHostAndPort, NULL},
\r
13000 {"USERNAME", NULL, NULL, NULL, NULL},
\r
13001 {"PASSWORD", NULL, NULL, NULL, NULL},
\r
13004 // 仮想 HUB が選択されていない場合はエラー
\r
13005 if (ps->HubName == NULL)
\r
13007 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
13008 return ERR_INVALID_PARAMETER;
\r
13011 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13014 return ERR_INVALID_PARAMETER;
\r
13017 Zero(&t, sizeof(t));
\r
13018 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
13019 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
13020 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
13023 ret = ScGetLink(ps->Rpc, &t);
\r
13025 if (ret != ERR_NO_ERROR)
\r
13028 CmdPrintError(c, ret);
\r
13029 FreeParamValueList(o);
\r
13038 if (ParseHostPort(GetParamStr(o, "SERVER"), &host, &port, 8080))
\r
13040 t.ClientOption->ProxyType = PROXY_SOCKS;
\r
13041 StrCpy(t.ClientOption->ProxyName, sizeof(t.ClientOption->ProxyName), host);
\r
13042 t.ClientOption->ProxyPort = port;
\r
13043 StrCpy(t.ClientOption->ProxyUsername, sizeof(t.ClientOption->ProxyName), GetParamStr(o, "USERNAME"));
\r
13044 StrCpy(t.ClientOption->ProxyPassword, sizeof(t.ClientOption->ProxyName), GetParamStr(o, "PASSWORD"));
\r
13048 ret = ScSetLink(ps->Rpc, &t);
\r
13049 if (ret != ERR_NO_ERROR)
\r
13052 CmdPrintError(c, ret);
\r
13053 FreeParamValueList(o);
\r
13057 FreeRpcCreateLink(&t);
\r
13060 FreeParamValueList(o);
\r
13065 // カスケード接続のサーバー証明書の検証オプションの有効化
\r
13066 UINT PsCascadeServerCertEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
13069 PS *ps = (PS *)param;
\r
13071 RPC_CREATE_LINK t;
\r
13072 // 指定できるパラメータ リスト
\r
13075 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
13076 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
13079 // 仮想 HUB が選択されていない場合はエラー
\r
13080 if (ps->HubName == NULL)
\r
13082 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
13083 return ERR_INVALID_PARAMETER;
\r
13086 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13089 return ERR_INVALID_PARAMETER;
\r
13092 Zero(&t, sizeof(t));
\r
13093 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
13094 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
13095 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
13098 ret = ScGetLink(ps->Rpc, &t);
\r
13100 if (ret != ERR_NO_ERROR)
\r
13103 CmdPrintError(c, ret);
\r
13104 FreeParamValueList(o);
\r
13110 t.CheckServerCert = true;
\r
13112 ret = ScSetLink(ps->Rpc, &t);
\r
13113 if (ret != ERR_NO_ERROR)
\r
13116 CmdPrintError(c, ret);
\r
13117 FreeParamValueList(o);
\r
13121 FreeRpcCreateLink(&t);
\r
13124 FreeParamValueList(o);
\r
13129 // カスケード接続のサーバー証明書の検証オプションの無効化
\r
13130 UINT PsCascadeServerCertDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
13133 PS *ps = (PS *)param;
\r
13135 RPC_CREATE_LINK t;
\r
13136 // 指定できるパラメータ リスト
\r
13139 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
13140 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
13143 // 仮想 HUB が選択されていない場合はエラー
\r
13144 if (ps->HubName == NULL)
\r
13146 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
13147 return ERR_INVALID_PARAMETER;
\r
13150 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13153 return ERR_INVALID_PARAMETER;
\r
13156 Zero(&t, sizeof(t));
\r
13157 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
13158 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
13159 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
13162 ret = ScGetLink(ps->Rpc, &t);
\r
13164 if (ret != ERR_NO_ERROR)
\r
13167 CmdPrintError(c, ret);
\r
13168 FreeParamValueList(o);
\r
13174 t.CheckServerCert = false;
\r
13176 ret = ScSetLink(ps->Rpc, &t);
\r
13177 if (ret != ERR_NO_ERROR)
\r
13180 CmdPrintError(c, ret);
\r
13181 FreeParamValueList(o);
\r
13185 FreeRpcCreateLink(&t);
\r
13188 FreeParamValueList(o);
\r
13193 // カスケード接続のサーバー固有証明書の設定
\r
13194 UINT PsCascadeServerCertSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
13197 PS *ps = (PS *)param;
\r
13199 RPC_CREATE_LINK t;
\r
13201 // 指定できるパラメータ リスト
\r
13204 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
13205 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
13206 {"LOADCERT", CmdPrompt, _UU("CMD_LOADCERTPATH"), CmdEvalIsFile, NULL},
\r
13209 // 仮想 HUB が選択されていない場合はエラー
\r
13210 if (ps->HubName == NULL)
\r
13212 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
13213 return ERR_INVALID_PARAMETER;
\r
13216 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13219 return ERR_INVALID_PARAMETER;
\r
13222 x = FileToX(GetParamStr(o, "LOADCERT"));
\r
13225 FreeParamValueList(o);
\r
13226 c->Write(c, _UU("CMD_LOADCERT_FAILED"));
\r
13227 return ERR_INTERNAL_ERROR;
\r
13230 Zero(&t, sizeof(t));
\r
13231 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
13232 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
13233 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
13236 ret = ScGetLink(ps->Rpc, &t);
\r
13238 if (ret != ERR_NO_ERROR)
\r
13241 CmdPrintError(c, ret);
\r
13242 FreeParamValueList(o);
\r
13249 if (t.ServerCert != NULL)
\r
13251 FreeX(t.ServerCert);
\r
13253 t.ServerCert = x;
\r
13255 ret = ScSetLink(ps->Rpc, &t);
\r
13256 if (ret != ERR_NO_ERROR)
\r
13259 CmdPrintError(c, ret);
\r
13260 FreeParamValueList(o);
\r
13264 FreeRpcCreateLink(&t);
\r
13267 FreeParamValueList(o);
\r
13272 // カスケード接続のサーバー固有証明書の削除
\r
13273 UINT PsCascadeServerCertDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
13276 PS *ps = (PS *)param;
\r
13278 RPC_CREATE_LINK t;
\r
13279 // 指定できるパラメータ リスト
\r
13282 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
13283 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
13286 // 仮想 HUB が選択されていない場合はエラー
\r
13287 if (ps->HubName == NULL)
\r
13289 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
13290 return ERR_INVALID_PARAMETER;
\r
13293 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13296 return ERR_INVALID_PARAMETER;
\r
13299 Zero(&t, sizeof(t));
\r
13300 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
13301 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
13302 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
13305 ret = ScGetLink(ps->Rpc, &t);
\r
13307 if (ret != ERR_NO_ERROR)
\r
13310 CmdPrintError(c, ret);
\r
13311 FreeParamValueList(o);
\r
13317 if (t.ServerCert != NULL)
\r
13319 FreeX(t.ServerCert);
\r
13321 t.ServerCert = NULL;
\r
13323 ret = ScSetLink(ps->Rpc, &t);
\r
13324 if (ret != ERR_NO_ERROR)
\r
13327 CmdPrintError(c, ret);
\r
13328 FreeParamValueList(o);
\r
13332 FreeRpcCreateLink(&t);
\r
13335 FreeParamValueList(o);
\r
13340 // カスケード接続のサーバー固有証明書の取得
\r
13341 UINT PsCascadeServerCertGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
13344 PS *ps = (PS *)param;
\r
13346 RPC_CREATE_LINK t;
\r
13347 // 指定できるパラメータ リスト
\r
13350 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
13351 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
13352 {"SAVECERT", CmdPrompt, _UU("CMD_SAVECERTPATH"), CmdEvalNotEmpty, NULL},
\r
13355 // 仮想 HUB が選択されていない場合はエラー
\r
13356 if (ps->HubName == NULL)
\r
13358 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
13359 return ERR_INVALID_PARAMETER;
\r
13362 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13365 return ERR_INVALID_PARAMETER;
\r
13368 Zero(&t, sizeof(t));
\r
13369 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
13370 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
13371 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
13374 ret = ScGetLink(ps->Rpc, &t);
\r
13376 if (ret != ERR_NO_ERROR)
\r
13379 CmdPrintError(c, ret);
\r
13380 FreeParamValueList(o);
\r
13386 if (t.ServerCert == NULL)
\r
13388 c->Write(c, _UU("CMD_CERT_NOT_EXISTS"));
\r
13389 ret = ERR_INTERNAL_ERROR;
\r
13393 if (XToFile(t.ServerCert, GetParamStr(o, "SAVECERT"), true) == false)
\r
13395 c->Write(c, _UU("CMD_SAVECERT_FAILED"));
\r
13396 ret = ERR_INTERNAL_ERROR;
\r
13400 FreeRpcCreateLink(&t);
\r
13403 FreeParamValueList(o);
\r
13408 // カスケード接続の高度な通信設定の設定
\r
13409 UINT PsCascadeDetailSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
13412 PS *ps = (PS *)param;
\r
13414 RPC_CREATE_LINK t;
\r
13415 CMD_EVAL_MIN_MAX mm_maxtcp =
\r
13417 "CMD_CascadeDetailSet_Eval_MaxTcp", 1, 32
\r
13419 CMD_EVAL_MIN_MAX mm_interval =
\r
13421 "CMD_CascadeDetailSet_Eval_Interval", 1, 4294967295UL
\r
13423 // 指定できるパラメータ リスト
\r
13426 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
13427 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
13428 {"MAXTCP", CmdPrompt, _UU("CMD_CascadeDetailSet_Prompt_MaxTcp"), CmdEvalMinMax, &mm_maxtcp},
\r
13429 {"INTERVAL", CmdPrompt, _UU("CMD_CascadeDetailSet_Prompt_Interval"), CmdEvalMinMax, &mm_interval},
\r
13430 {"TTL", CmdPrompt, _UU("CMD_CascadeDetailSet_Prompt_TTL"), NULL, NULL},
\r
13431 {"HALF", CmdPrompt, _UU("CMD_CascadeDetailSet_Prompt_HALF"), NULL, NULL},
\r
13432 {"NOQOS", CmdPrompt, _UU("CMD_AccountDetailSet_Prompt_NOQOS"), NULL, NULL},
\r
13435 // 仮想 HUB が選択されていない場合はエラー
\r
13436 if (ps->HubName == NULL)
\r
13438 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
13439 return ERR_INVALID_PARAMETER;
\r
13442 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13445 return ERR_INVALID_PARAMETER;
\r
13448 Zero(&t, sizeof(t));
\r
13449 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
13450 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
13451 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
13454 ret = ScGetLink(ps->Rpc, &t);
\r
13456 if (ret != ERR_NO_ERROR)
\r
13459 CmdPrintError(c, ret);
\r
13460 FreeParamValueList(o);
\r
13466 t.ClientOption->MaxConnection = GetParamInt(o, "MAXTCP");
\r
13467 t.ClientOption->AdditionalConnectionInterval = GetParamInt(o, "INTERVAL");
\r
13468 t.ClientOption->ConnectionDisconnectSpan = GetParamInt(o, "TTL");
\r
13469 t.ClientOption->HalfConnection = GetParamYes(o, "HALF");
\r
13470 t.ClientOption->DisableQoS = GetParamYes(o, "NOQOS");
\r
13472 ret = ScSetLink(ps->Rpc, &t);
\r
13473 if (ret != ERR_NO_ERROR)
\r
13476 CmdPrintError(c, ret);
\r
13477 FreeParamValueList(o);
\r
13481 FreeRpcCreateLink(&t);
\r
13484 FreeParamValueList(o);
\r
13489 // セキュリティ ポリシーを表示
\r
13490 void PrintPolicy(CONSOLE *c, POLICY *pol, bool cascade_mode)
\r
13496 if (c == NULL || pol == NULL)
\r
13502 CtInsertColumn(ct, _UU("CMD_PolicyList_Column_1"), false);
\r
13503 CtInsertColumn(ct, _UU("CMD_PolicyList_Column_2"), false);
\r
13504 CtInsertColumn(ct, _UU("CMD_PolicyList_Column_3"), false);
\r
13507 OutRpcPolicy(p, pol);
\r
13509 // すべてのポリシー一覧を表示する
\r
13510 for (i = 0; i < PolicyNum();i++)
\r
13515 if (cascade_mode == false || PolicyIsSupportedForCascade(i))
\r
13517 wchar_t value_str[256];
\r
13521 Format(tmp2, sizeof(tmp2), "policy:%s", PolicyIdToStr(i));
\r
13522 value = PackGetInt(p, tmp2);
\r
13524 tmp = CopyStrToUni(PolicyIdToStr(i));
\r
13526 FormatPolicyValue(value_str, sizeof(value_str),
\r
13529 Format(name, sizeof(name), "POL_%u", i);
\r
13530 CtInsert(ct, tmp, _UU(name), value_str);
\r
13541 // セキュリティ ポリシー リストを表示
\r
13542 void PrintPolicyList(CONSOLE *c, char *name)
\r
13550 if (IsEmptyStr(name))
\r
13555 if (name != NULL)
\r
13557 id = PolicyStrToId(name);
\r
13558 if (id == INFINITE)
\r
13561 c->Write(c, _UU("CMD_PolicyList_Invalid_Name"));
\r
13565 wchar_t tmp[MAX_SIZE];
\r
13566 wchar_t tmp2[MAX_SIZE];
\r
13567 char name1[64], name2[64];
\r
13568 wchar_t *title, *descript;
\r
13569 wchar_t policy_name[MAX_SIZE];
\r
13571 Format(name1, sizeof(name1), "POL_%u", id);
\r
13572 Format(name2, sizeof(name2), "POL_EX_%u", id);
\r
13574 title = _UU(name1);
\r
13575 descript = _UU(name2);
\r
13577 StrToUni(policy_name, sizeof(policy_name), PolicyIdToStr(id));
\r
13580 c->Write(c, _UU("CMD_PolicyList_Help_1"));
\r
13581 UniFormat(tmp2, sizeof(tmp2), L" %s", policy_name);
\r
13582 c->Write(c, tmp2);
\r
13583 c->Write(c, L"");
\r
13586 c->Write(c, _UU("CMD_PolicyList_Help_2"));
\r
13587 UniFormat(tmp2, sizeof(tmp2), L" %s", title);
\r
13588 c->Write(c, tmp2);
\r
13589 c->Write(c, L"");
\r
13592 GetPolicyValueRangeStr(tmp, sizeof(tmp), id);
\r
13593 c->Write(c, _UU("CMD_PolicyList_Help_3"));
\r
13594 UniFormat(tmp2, sizeof(tmp2), L" %s", tmp);
\r
13595 c->Write(c, tmp2);
\r
13596 c->Write(c, L"");
\r
13599 FormatPolicyValue(tmp, sizeof(tmp), id, GetPolicyItem(id)->DefaultValue);
\r
13600 c->Write(c, _UU("CMD_PolicyList_Help_4"));
\r
13601 UniFormat(tmp2, sizeof(tmp2), L" %s", tmp);
\r
13602 c->Write(c, tmp2);
\r
13603 c->Write(c, L"");
\r
13606 c->Write(c, _UU("CMD_PolicyList_Help_5"));
\r
13607 c->Write(c, descript);
\r
13608 c->Write(c, L"");
\r
13614 CT *ct = CtNew();
\r
13615 CtInsertColumn(ct, _UU("CMD_PolicyList_Column_1"), false);
\r
13616 CtInsertColumn(ct, _UU("CMD_PolicyList_Column_2"), false);
\r
13618 // すべてのポリシー一覧を表示する
\r
13619 for (i = 0; i < PolicyNum();i++)
\r
13624 tmp = CopyStrToUni(PolicyIdToStr(i));
\r
13626 Format(name, sizeof(name), "POL_%u", i);
\r
13627 CtInsert(ct, tmp, _UU(name));
\r
13637 bool EditPolicy(CONSOLE *c, POLICY *pol, char *name, char *value, bool cascade_mode)
\r
13641 POLICY_ITEM *item;
\r
13643 wchar_t tmp[MAX_SIZE];
\r
13644 wchar_t tmp2[MAX_SIZE];
\r
13645 char pack_name[128];
\r
13647 if (c == NULL || pol == NULL || name == NULL || value == NULL)
\r
13654 OutRpcPolicy(p, pol);
\r
13656 Format(pack_name, sizeof(pack_name), "policy:%s", PolicyIdToStr(PolicyStrToId(name)));
\r
13658 if ((e = GetElement(p, pack_name, VALUE_INT)) == NULL || (id = PolicyStrToId(name)) == INFINITE)
\r
13660 UniFormat(tmp, sizeof(tmp), _UU("CMD_CascadePolicySet_Invalid_Name"), name);
\r
13661 c->Write(c, tmp);
\r
13666 if (cascade_mode && (PolicyIsSupportedForCascade(id) == false))
\r
13668 UniFormat(tmp, sizeof(tmp), _UU("CMD_CascadePolicySet_Invalid_Name_For_Cadcade"), name);
\r
13669 c->Write(c, tmp);
\r
13674 item = GetPolicyItem(id);
\r
13676 if (item->TypeInt == false)
\r
13679 e->values[0]->IntValue = (
\r
13680 StartWith(value, "y") || StartWith(value, "t") ||
\r
13681 ToInt(value) != 0) ? 1 : 0;
\r
13685 UINT n = ToInt(value);
\r
13689 GetPolicyValueRangeStr(tmp, sizeof(tmp), id);
\r
13691 if (item->AllowZero == false)
\r
13699 if (n != 0 && (n < item->MinValue || n > item->MaxValue))
\r
13706 UniFormat(tmp2, sizeof(tmp2), _UU("CMD_CascadePolicySet_Invalid_Range"), PolicyIdToStr(id), tmp);
\r
13707 c->Write(c, tmp2);
\r
13712 e->values[0]->IntValue = n;
\r
13715 Zero(pol, sizeof(POLICY));
\r
13717 InRpcPolicy(pol, p);
\r
13724 // セキュリティ ポリシーの種類と設定可能値の一覧を表示
\r
13725 UINT PsPolicyList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
13730 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
13731 {"[name]", NULL, NULL, NULL, NULL}
\r
13734 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13737 return ERR_INVALID_PARAMETER;
\r
13740 PrintPolicyList(c, GetParamStr(o, "[name]"));
\r
13742 FreeParamValueList(o);
\r
13744 return ERR_NO_ERROR;
\r
13747 // カスケード接続セッションのセキュリティ ポリシーの設定
\r
13748 UINT PsCascadePolicySet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
13751 PS *ps = (PS *)param;
\r
13753 RPC_CREATE_LINK t;
\r
13754 // 指定できるパラメータ リスト
\r
13757 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
13758 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
13759 {"NAME", CmdPrompt, _UU("CMD_CascadePolicySet_PROMPT_POLNAME"), CmdEvalNotEmpty, NULL},
\r
13760 {"VALUE", CmdPrompt, _UU("CMD_CascadePolicySet_PROMPT_POLVALUE"), CmdEvalNotEmpty, NULL},
\r
13763 // 仮想 HUB が選択されていない場合はエラー
\r
13764 if (ps->HubName == NULL)
\r
13766 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
13767 return ERR_INVALID_PARAMETER;
\r
13770 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
13773 return ERR_INVALID_PARAMETER;
\r
13776 Zero(&t, sizeof(t));
\r
13777 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
13778 t.ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));
\r
13779 UniStrCpy(t.ClientOption->AccountName, sizeof(t.ClientOption->AccountName), GetParamUniStr(o, "[name]"));
\r
13782 ret = ScGetLink(ps->Rpc, &t);
\r
13784 if (ret != ERR_NO_ERROR)
\r
13787 CmdPrintError(c, ret);
\r
13788 FreeParamValueList(o);
\r
13793 if (EditPolicy(c, &t.Policy, GetParamStr(o, "NAME"), GetParamStr(o, "VALUE"), true) == false)
\r
13796 FreeRpcCreateLink(&t);
\r
13797 FreeParamValueList(o);
\r
13798 return ERR_INTERNAL_ERROR;
\r
13801 ret = ScSetLink(ps->Rpc, &t);
\r
13802 if (ret != ERR_NO_ERROR)
\r
13805 CmdPrintError(c, ret);
\r
13806 FreeParamValueList(o);
\r
13810 FreeRpcCreateLink(&t);
\r
13813 FreeParamValueList(o);
\r
13818 // セッションのステータス情報の表示
\r
13819 void CmdPrintStatusToListView(CT *ct, RPC_CLIENT_GET_CONNECTION_STATUS *s)
\r
13821 CmdPrintStatusToListViewEx(ct, s, false);
\r
13823 void CmdPrintStatusToListViewEx(CT *ct, RPC_CLIENT_GET_CONNECTION_STATUS *s, bool server_mode)
\r
13825 wchar_t tmp[MAX_SIZE];
\r
13826 char str[MAX_SIZE];
\r
13834 if (server_mode == false)
\r
13836 CtInsert(ct, _UU("CM_ST_ACCOUNT_NAME"), s->AccountName);
\r
13838 if (s->Connected == false)
\r
13840 wchar_t *st = _UU("CM_ST_CONNECTED_FALSE");
\r
13841 switch (s->SessionStatus)
\r
13843 case CLIENT_STATUS_CONNECTING:
\r
13844 st = _UU("CM_ST_CONNECTING");
\r
13846 case CLIENT_STATUS_NEGOTIATION:
\r
13847 st = _UU("CM_ST_NEGOTIATION");
\r
13849 case CLIENT_STATUS_AUTH:
\r
13850 st = _UU("CM_ST_AUTH");
\r
13852 case CLIENT_STATUS_ESTABLISHED:
\r
13853 st = _UU("CM_ST_ESTABLISHED");
\r
13855 case CLIENT_STATUS_RETRY:
\r
13856 st = _UU("CM_ST_RETRY");
\r
13858 case CLIENT_STATUS_IDLE:
\r
13859 st = _UU("CM_ST_IDLE");
\r
13862 CtInsert(ct, _UU("CM_ST_CONNECTED"), st);
\r
13866 CtInsert(ct, _UU("CM_ST_CONNECTED"), _UU("CM_ST_CONNECTED_TRUE"));
\r
13870 if (s->Connected)
\r
13872 if (s->VLanId == 0)
\r
13874 UniStrCpy(tmp, sizeof(tmp), _UU("CM_ST_NO_VLAN"));
\r
13878 UniToStru(tmp, s->VLanId);
\r
13881 CtInsert(ct, _UU("CM_ST_VLAN_ID"), tmp);
\r
13883 if (server_mode == false)
\r
13885 StrToUni(tmp, sizeof(tmp), s->ServerName);
\r
13886 CtInsert(ct, _UU("CM_ST_SERVER_NAME"), tmp);
\r
13888 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_PORT_TCP"), s->ServerPort);
\r
13889 CtInsert(ct, _UU("CM_ST_SERVER_PORT"), tmp);
\r
13892 StrToUni(tmp, sizeof(tmp), s->ServerProductName);
\r
13893 CtInsert(ct, _UU("CM_ST_SERVER_P_NAME"), tmp);
\r
13895 UniFormat(tmp, sizeof(tmp), L"%u.%02u", s->ServerProductVer / 100, s->ServerProductVer % 100);
\r
13896 CtInsert(ct, _UU("CM_ST_SERVER_P_VER"), tmp);
\r
13897 UniFormat(tmp, sizeof(tmp), L"Build %u", s->ServerProductBuild);
\r
13898 CtInsert(ct, _UU("CM_ST_SERVER_P_BUILD"), tmp);
\r
13901 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(s->StartTime), NULL);
\r
13902 CtInsert(ct, _UU("CM_ST_START_TIME"), tmp);
\r
13903 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(s->FirstConnectionEstablisiedTime), NULL);
\r
13904 CtInsert(ct, _UU("CM_ST_FIRST_ESTAB_TIME"), s->FirstConnectionEstablisiedTime == 0 ? _UU("CM_ST_NONE") : tmp);
\r
13906 if (s->Connected)
\r
13908 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(s->CurrentConnectionEstablishTime), NULL);
\r
13909 CtInsert(ct, _UU("CM_ST_CURR_ESTAB_TIME"), tmp);
\r
13912 if (server_mode == false)
\r
13914 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_STR"), s->NumConnectionsEatablished);
\r
13915 CtInsert(ct, _UU("CM_ST_NUM_ESTABLISHED"), tmp);
\r
13918 if (s->Connected)
\r
13920 CtInsert(ct, _UU("CM_ST_HALF_CONNECTION"), s->HalfConnection ? _UU("CM_ST_HALF_TRUE") : _UU("CM_ST_HALF_FALSE"));
\r
13922 CtInsert(ct, _UU("CM_ST_QOS"), s->QoS ? _UU("CM_ST_QOS_TRUE") : _UU("CM_ST_QOS_FALSE"));
\r
13924 UniFormat(tmp, sizeof(tmp), L"%u", s->NumTcpConnections);
\r
13925 CtInsert(ct, _UU("CM_ST_NUM_TCP"), tmp);
\r
13927 if (s->HalfConnection)
\r
13929 UniFormat(tmp, sizeof(tmp), L"%u", s->NumTcpConnectionsUpload);
\r
13930 CtInsert(ct, _UU("CM_ST_NUM_TCP_UPLOAD"), tmp);
\r
13931 UniFormat(tmp, sizeof(tmp), L"%u", s->NumTcpConnectionsDownload);
\r
13932 CtInsert(ct, _UU("CM_ST_NUM_TCP_DOWNLOAD"), tmp);
\r
13935 UniFormat(tmp, sizeof(tmp), L"%u", s->MaxTcpConnections);
\r
13936 CtInsert(ct, _UU("CM_ST_MAX_TCP"), tmp);
\r
13938 if (s->UseEncrypt == false)
\r
13940 UniStrCpy(tmp, sizeof(tmp), _UU("CM_ST_USE_ENCRYPT_FALSE"));
\r
13944 if (StrLen(s->CipherName) != 0)
\r
13946 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_USE_ENCRYPT_TRUE"), s->CipherName);
\r
13950 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_USE_ENCRYPT_TRUE2"));
\r
13953 CtInsert(ct, _UU("CM_ST_USE_ENCRYPT"), tmp);
\r
13955 if (s->UseCompress)
\r
13957 UINT percent = 0;
\r
13958 if ((s->TotalRecvSize + s->TotalSendSize) > 0)
\r
13960 percent = (UINT)((UINT64)100 - (UINT64)(s->TotalRecvSizeReal + s->TotalSendSizeReal) * (UINT64)100 /
\r
13961 (s->TotalRecvSize + s->TotalSendSize));
\r
13962 percent = MAKESURE(percent, 0, 100);
\r
13965 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_COMPRESS_TRUE"), percent);
\r
13969 UniStrCpy(tmp, sizeof(tmp), _UU("CM_ST_COMPRESS_FALSE"));
\r
13971 CtInsert(ct, _UU("CM_ST_USE_COMPRESS"), tmp);
\r
13973 StrToUni(tmp, sizeof(tmp), s->SessionName);
\r
13974 CtInsert(ct, _UU("CM_ST_SESSION_NAME"), tmp);
\r
13976 StrToUni(tmp, sizeof(tmp), s->ConnectionName);
\r
13977 if (UniStrCmpi(tmp, L"INITING") != 0)
\r
13979 CtInsert(ct, _UU("CM_ST_CONNECTION_NAME"), tmp);
\r
13982 BinToStr(str, sizeof(str), s->SessionKey, sizeof(s->SessionKey));
\r
13983 StrToUni(tmp, sizeof(tmp), str);
\r
13984 CtInsert(ct, _UU("CM_ST_SESSION_KEY"), tmp);
\r
13986 CtInsert(ct, _UU("CM_ST_BRIDGE_MODE"), s->IsBridgeMode ? _UU("CM_ST_YES") : _UU("CM_ST_NO"));
\r
13988 CtInsert(ct, _UU("CM_ST_MONITOR_MODE"), s->IsMonitorMode ? _UU("CM_ST_YES") : _UU("CM_ST_NO"));
\r
13990 ToStr3(vv, sizeof(vv), s->TotalSendSize);
\r
13991 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
\r
13992 CtInsert(ct, _UU("CM_ST_SEND_SIZE"), tmp);
\r
13994 ToStr3(vv, sizeof(vv), s->TotalRecvSize);
\r
13995 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
\r
13996 CtInsert(ct, _UU("CM_ST_RECV_SIZE"), tmp);
\r
13998 ToStr3(vv, sizeof(vv), s->Traffic.Send.UnicastCount);
\r
13999 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_PACKET_STR"), vv);
\r
14000 CtInsert(ct, _UU("CM_ST_SEND_UCAST_NUM"), tmp);
\r
14002 ToStr3(vv, sizeof(vv), s->Traffic.Send.UnicastBytes);
\r
14003 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
\r
14004 CtInsert(ct, _UU("CM_ST_SEND_UCAST_SIZE"), tmp);
\r
14006 ToStr3(vv, sizeof(vv), s->Traffic.Send.BroadcastCount);
\r
14007 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_PACKET_STR"), vv);
\r
14008 CtInsert(ct, _UU("CM_ST_SEND_BCAST_NUM"), tmp);
\r
14010 ToStr3(vv, sizeof(vv), s->Traffic.Send.BroadcastBytes);
\r
14011 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
\r
14012 CtInsert(ct, _UU("CM_ST_SEND_BCAST_SIZE"), tmp);
\r
14014 ToStr3(vv, sizeof(vv), s->Traffic.Recv.UnicastCount);
\r
14015 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_PACKET_STR"), vv);
\r
14016 CtInsert(ct, _UU("CM_ST_RECV_UCAST_NUM"), tmp);
\r
14018 ToStr3(vv, sizeof(vv), s->Traffic.Recv.UnicastBytes);
\r
14019 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
\r
14020 CtInsert(ct, _UU("CM_ST_RECV_UCAST_SIZE"), tmp);
\r
14022 ToStr3(vv, sizeof(vv), s->Traffic.Recv.BroadcastCount);
\r
14023 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_NUM_PACKET_STR"), vv);
\r
14024 CtInsert(ct, _UU("CM_ST_RECV_BCAST_NUM"), tmp);
\r
14026 ToStr3(vv, sizeof(vv), s->Traffic.Recv.BroadcastBytes);
\r
14027 UniFormat(tmp, sizeof(tmp), _UU("CM_ST_SIZE_BYTE_STR"), vv);
\r
14028 CtInsert(ct, _UU("CM_ST_RECV_BCAST_SIZE"), tmp);
\r
14032 // カスケード接続の現在の状態の取得
\r
14033 UINT PsCascadeStatusGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14036 PS *ps = (PS *)param;
\r
14038 RPC_LINK_STATUS t;
\r
14039 // 指定できるパラメータ リスト
\r
14042 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
14043 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
14046 // 仮想 HUB が選択されていない場合はエラー
\r
14047 if (ps->HubName == NULL)
\r
14049 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14050 return ERR_INVALID_PARAMETER;
\r
14053 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
14056 return ERR_INVALID_PARAMETER;
\r
14059 Zero(&t, sizeof(t));
\r
14060 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14061 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
14064 ret = ScGetLinkStatus(ps->Rpc, &t);
\r
14066 if (ret != ERR_NO_ERROR)
\r
14069 CmdPrintError(c, ret);
\r
14070 FreeParamValueList(o);
\r
14076 CT *ct = CtNewStandard();
\r
14078 CmdPrintStatusToListView(ct, &t.Status);
\r
14082 FreeRpcLinkStatus(&t);
\r
14085 FreeParamValueList(o);
\r
14091 UINT PsCascadeRename(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14094 PS *ps = (PS *)param;
\r
14096 RPC_RENAME_LINK t;
\r
14097 // 指定できるパラメータ リスト
\r
14100 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
14101 {"[name]", CmdPrompt, _UU("CMD_CascadeRename_PROMPT_OLD"), CmdEvalNotEmpty, NULL},
\r
14102 {"NEW", CmdPrompt, _UU("CMD_CascadeRename_PROMPT_NEW"), CmdEvalNotEmpty, NULL},
\r
14105 // 仮想 HUB が選択されていない場合はエラー
\r
14106 if (ps->HubName == NULL)
\r
14108 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14109 return ERR_INVALID_PARAMETER;
\r
14112 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
14115 return ERR_INVALID_PARAMETER;
\r
14118 Zero(&t, sizeof(t));
\r
14119 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14121 UniStrCpy(t.NewAccountName, sizeof(t.NewAccountName), GetParamUniStr(o, "NEW"));
\r
14122 UniStrCpy(t.OldAccountName, sizeof(t.OldAccountName), GetParamUniStr(o, "[name]"));
\r
14125 ret = ScRenameLink(ps->Rpc, &t);
\r
14127 if (ret != ERR_NO_ERROR)
\r
14130 CmdPrintError(c, ret);
\r
14131 FreeParamValueList(o);
\r
14135 FreeParamValueList(o);
\r
14140 // カスケード接続のオンライン状態への設定
\r
14141 UINT PsCascadeOnline(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14144 PS *ps = (PS *)param;
\r
14147 // 指定できるパラメータ リスト
\r
14150 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
14151 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
14154 // 仮想 HUB が選択されていない場合はエラー
\r
14155 if (ps->HubName == NULL)
\r
14157 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14158 return ERR_INVALID_PARAMETER;
\r
14161 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
14164 return ERR_INVALID_PARAMETER;
\r
14167 Zero(&t, sizeof(t));
\r
14168 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14169 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
14172 ret = ScSetLinkOnline(ps->Rpc, &t);
\r
14174 if (ret != ERR_NO_ERROR)
\r
14177 CmdPrintError(c, ret);
\r
14178 FreeParamValueList(o);
\r
14182 FreeParamValueList(o);
\r
14187 // カスケード接続のオフライン状態への設定
\r
14188 UINT PsCascadeOffline(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14191 PS *ps = (PS *)param;
\r
14194 // 指定できるパラメータ リスト
\r
14197 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
14198 {"[name]", CmdPrompt, _UU("CMD_CascadeCreate_Prompt_Name"), CmdEvalNotEmpty, NULL},
\r
14201 // 仮想 HUB が選択されていない場合はエラー
\r
14202 if (ps->HubName == NULL)
\r
14204 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14205 return ERR_INVALID_PARAMETER;
\r
14208 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
14211 return ERR_INVALID_PARAMETER;
\r
14214 Zero(&t, sizeof(t));
\r
14215 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14216 UniStrCpy(t.AccountName, sizeof(t.AccountName), GetParamUniStr(o, "[name]"));
\r
14219 ret = ScSetLinkOffline(ps->Rpc, &t);
\r
14221 if (ret != ERR_NO_ERROR)
\r
14224 CmdPrintError(c, ret);
\r
14225 FreeParamValueList(o);
\r
14229 FreeParamValueList(o);
\r
14234 // 文字列を pass/discard に変換
\r
14235 bool StrToPassOrDiscard(char *str)
\r
14243 if (ToInt(str) != 0)
\r
14248 if (StartWith(str, "p") || StartWith(str, "y") || StartWith(str, "t"))
\r
14257 UINT StrToProtocol(char *str)
\r
14259 if (IsEmptyStr(str))
\r
14264 if (StartWith("ip", str))
\r
14268 else if (StartWith("tcp", str))
\r
14270 return IP_PROTO_TCP;
\r
14272 else if (StartWith("udp", str))
\r
14274 return IP_PROTO_UDP;
\r
14276 else if (StartWith("icmpv4", str))
\r
14278 return IP_PROTO_ICMPV4;
\r
14280 else if (StartWith("icmpv6", str))
\r
14282 return IP_PROTO_ICMPV6;
\r
14285 if (ToInt(str) == 0)
\r
14287 if (StrCmpi(str, "0") == 0)
\r
14297 if (ToInt(str) >= 256)
\r
14302 return ToInt(str);
\r
14306 bool CmdEvalProtocol(CONSOLE *c, wchar_t *str, void *param)
\r
14310 if (c == NULL || str == NULL)
\r
14315 UniToStr(tmp, sizeof(tmp), str);
\r
14317 if (StrToProtocol(tmp) == INFINITE)
\r
14319 c->Write(c, _UU("CMD_PROTOCOL_EVAL_FAILED"));
\r
14327 bool ParsePortRange(char *str, UINT *start, UINT *end)
\r
14329 UINT a = 0, b = 0;
\r
14337 if (IsEmptyStr(str) == false)
\r
14340 t = ParseToken(str, "\t -");
\r
14342 if (t->NumTokens == 1)
\r
14344 a = b = ToInt(t->Token[0]);
\r
14346 else if (t->NumTokens == 2)
\r
14348 a = ToInt(t->Token[0]);
\r
14349 b = ToInt(t->Token[1]);
\r
14359 if (a >= 65536 || b >= 65536)
\r
14364 if (a == 0 && b != 0)
\r
14370 if (start != NULL)
\r
14383 bool CmdEvalPortRange(CONSOLE *c, wchar_t *str, void *param)
\r
14387 if (c == NULL || str == NULL)
\r
14392 UniToStr(tmp, sizeof(tmp), str);
\r
14394 if (ParsePortRange(tmp, NULL, NULL) == false)
\r
14396 c->Write(c, _UU("CMD_PORT_RANGE_EVAL_FAILED"));
\r
14403 // MAC アドレスとマスクのパース
\r
14404 bool ParseMacAddressAndMask(char *src, bool *check_mac, UCHAR *mac_bin, UCHAR *mask_bin)
\r
14407 char *macstr, *maskstr;
\r
14408 UCHAR mac[6], mask[6];
\r
14417 //Zero(mac, sizeof(mac));
\r
14418 //Zero(mask, sizeof(mask));
\r
14420 if(check_mac != NULL && mac_bin != NULL && mask_bin != NULL)
\r
14424 if(IsEmptyStr(src) != false)
\r
14428 *check_mac = false;
\r
14429 Zero(mac_bin, 6);
\r
14430 Zero(mask_bin, 6);
\r
14435 t = ParseToken(src, "/");
\r
14436 if(t->NumTokens != 2)
\r
14442 macstr = t->Token[0];
\r
14443 maskstr = t->Token[1];
\r
14448 if(StrToMac(mac, macstr) == false || StrToMac(mask, maskstr) == false)
\r
14457 Copy(mac_bin, mac, 6);
\r
14458 Copy(mask_bin, mask, 6);
\r
14459 *check_mac = true;
\r
14467 // MAC アドレスとマスクのチェック
\r
14468 bool CmdEvalMacAddressAndMask(CONSOLE *c, wchar_t *str, void *param)
\r
14472 if(c == NULL || str == NULL)
\r
14477 UniToStr(tmp, sizeof(tmp), str);
\r
14480 if(ParseMacAddressAndMask(tmp, NULL, NULL, NULL) == false)
\r
14482 c->Write(c, _UU("CMD_MAC_ADDRESS_AND_MASK_EVAL_FAILED"));
\r
14488 // TCP コネクションの状態パース
\r
14489 bool ParseTcpState(char *src, bool *check_tcp_state, bool *established)
\r
14498 if(check_tcp_state != NULL && established != NULL)
\r
14503 if (IsEmptyStr(src) == false)
\r
14505 if (StartWith("Established", src) == 0)
\r
14509 *check_tcp_state = true;
\r
14510 *established = true;
\r
14513 else if (StartWith("Unestablished", src) == 0)
\r
14517 *check_tcp_state = true;
\r
14518 *established = false;
\r
14531 *check_tcp_state = false;
\r
14532 *established = false;
\r
14538 // TCP コネクションの状態チェック
\r
14539 bool CmdEvalTcpState(CONSOLE *c, wchar_t *str, void *param)
\r
14543 if(c == NULL || str == NULL)
\r
14548 UniToStr(tmp, sizeof(tmp), str);
\r
14550 if(ParseTcpState(tmp, NULL, NULL) == false)
\r
14552 c->Write(c, _UU("CMD_TCP_CONNECTION_STATE_EVAL_FAILED"));
\r
14559 // アクセス リストへのルールの追加 (標準、IPv4)
\r
14560 UINT PsAccessAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14563 PS *ps = (PS *)param;
\r
14565 RPC_ADD_ACCESS t;
\r
14567 // 指定できるパラメータ リスト
\r
14568 CMD_EVAL_MIN_MAX minmax =
\r
14570 "CMD_AccessAdd_Eval_PRIORITY", 1, 4294967295UL,
\r
14574 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
14575 {"[pass|discard]", CmdPrompt, _UU("CMD_AccessAdd_Prompt_TYPE"), CmdEvalNotEmpty, NULL},
\r
14576 {"MEMO", CmdPrompt, _UU("CMD_AccessAdd_Prompt_MEMO"), NULL, NULL},
\r
14577 {"PRIORITY", CmdPrompt, _UU("CMD_AccessAdd_Prompt_PRIORITY"), CmdEvalMinMax, &minmax},
\r
14578 {"SRCUSERNAME", CmdPrompt, _UU("CMD_AccessAdd_Prompt_SRCUSERNAME"), NULL, NULL},
\r
14579 {"DESTUSERNAME", CmdPrompt, _UU("CMD_AccessAdd_Prompt_DESTUSERNAME"), NULL, NULL},
\r
14580 {"SRCMAC", CmdPrompt, _UU("CMD_AccessAdd_Prompt_SRCMAC"), CmdEvalMacAddressAndMask, NULL},
\r
14581 {"DESTMAC", CmdPrompt, _UU("CMD_AccessAdd_Prompt_DESTMAC"), CmdEvalMacAddressAndMask, NULL},
\r
14582 {"SRCIP", CmdPrompt, _UU("CMD_AccessAdd_Prompt_SRCIP"), CmdEvalIpAndMask4, NULL},
\r
14583 {"DESTIP", CmdPrompt, _UU("CMD_AccessAdd_Prompt_DESTIP"), CmdEvalIpAndMask4, NULL},
\r
14584 {"PROTOCOL", CmdPrompt, _UU("CMD_AccessAdd_Prompt_PROTOCOL"), CmdEvalProtocol, NULL},
\r
14585 {"SRCPORT", CmdPrompt, _UU("CMD_AccessAdd_Prompt_SRCPORT"), CmdEvalPortRange, NULL},
\r
14586 {"DESTPORT", CmdPrompt, _UU("CMD_AccessAdd_Prompt_DESTPORT"), CmdEvalPortRange, NULL},
\r
14587 {"TCPSTATE", CmdPrompt, _UU("CMD_AccessAdd_Prompt_TCPSTATE"), CmdEvalTcpState, NULL},
\r
14590 // 仮想 HUB が選択されていない場合はエラー
\r
14591 if (ps->HubName == NULL)
\r
14593 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14594 return ERR_INVALID_PARAMETER;
\r
14597 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
14600 return ERR_INVALID_PARAMETER;
\r
14603 Zero(&t, sizeof(t));
\r
14606 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14607 UniStrCpy(a->Note, sizeof(a->Note), GetParamUniStr(o, "MEMO"));
\r
14608 a->Active = true;
\r
14609 a->Priority = GetParamInt(o, "PRIORITY");
\r
14610 a->Discard = StrToPassOrDiscard(GetParamStr(o, "[pass|discard]")) ? false : true;
\r
14611 StrCpy(a->SrcUsername, sizeof(a->SrcUsername), GetParamStr(o, "SRCUSERNAME"));
\r
14612 StrCpy(a->DestUsername, sizeof(a->DestUsername), GetParamStr(o, "DESTUSERNAME"));
\r
14613 ParseMacAddressAndMask(GetParamStr(o, "SRCMAC"), &a->CheckSrcMac, a->SrcMacAddress, a->SrcMacMask);
\r
14614 ParseMacAddressAndMask(GetParamStr(o, "DESTMAC"), &a->CheckDstMac, a->DstMacAddress, a->DstMacMask);
\r
14615 ParseIpAndMask4(GetParamStr(o, "SRCIP"), &a->SrcIpAddress, &a->SrcSubnetMask);
\r
14616 ParseIpAndMask4(GetParamStr(o, "DESTIP"), &a->DestIpAddress, &a->DestSubnetMask);
\r
14617 a->Protocol = StrToProtocol(GetParamStr(o, "PROTOCOL"));
\r
14618 ParsePortRange(GetParamStr(o, "SRCPORT"), &a->SrcPortStart, &a->SrcPortEnd);
\r
14619 ParsePortRange(GetParamStr(o, "DESTPORT"), &a->DestPortStart, &a->DestPortEnd);
\r
14620 ParseTcpState(GetParamStr(o, "TCPSTATE"), &a->CheckTcpState, &a->Established);
\r
14623 ret = ScAddAccess(ps->Rpc, &t);
\r
14625 if (ret != ERR_NO_ERROR)
\r
14628 CmdPrintError(c, ret);
\r
14629 FreeParamValueList(o);
\r
14633 FreeParamValueList(o);
\r
14638 // アクセス リストへのルールの追加 (拡張、IPv4)
\r
14639 UINT PsAccessAddEx(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14642 PS *ps = (PS *)param;
\r
14644 RPC_ADD_ACCESS t;
\r
14646 // 指定できるパラメータ リスト
\r
14647 CMD_EVAL_MIN_MAX minmax =
\r
14649 "CMD_AccessAdd_Eval_PRIORITY", 1, 4294967295UL,
\r
14651 CMD_EVAL_MIN_MAX minmax_delay =
\r
14653 "CMD_AccessAddEx_Eval_DELAY", 0, HUB_ACCESSLIST_DELAY_MAX,
\r
14655 CMD_EVAL_MIN_MAX minmax_jitter =
\r
14657 "CMD_AccessAddEx_Eval_JITTER", 0, HUB_ACCESSLIST_JITTER_MAX,
\r
14659 CMD_EVAL_MIN_MAX minmax_loss =
\r
14661 "CMD_AccessAddEx_Eval_LOSS", 0, HUB_ACCESSLIST_LOSS_MAX,
\r
14665 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
14666 {"[pass|discard]", CmdPrompt, _UU("CMD_AccessAdd_Prompt_TYPE"), CmdEvalNotEmpty, NULL},
\r
14667 {"MEMO", CmdPrompt, _UU("CMD_AccessAdd_Prompt_MEMO"), NULL, NULL},
\r
14668 {"PRIORITY", CmdPrompt, _UU("CMD_AccessAdd_Prompt_PRIORITY"), CmdEvalMinMax, &minmax},
\r
14669 {"SRCUSERNAME", CmdPrompt, _UU("CMD_AccessAdd_Prompt_SRCUSERNAME"), NULL, NULL},
\r
14670 {"DESTUSERNAME", CmdPrompt, _UU("CMD_AccessAdd_Prompt_DESTUSERNAME"), NULL, NULL},
\r
14671 {"SRCMAC", CmdPrompt, _UU("CMD_AccessAdd_Prompt_SRCMAC"), CmdEvalMacAddressAndMask, NULL},
\r
14672 {"DESTMAC", CmdPrompt, _UU("CMD_AccessAdd_Prompt_DESTMAC"), CmdEvalMacAddressAndMask, NULL},
\r
14673 {"SRCIP", CmdPrompt, _UU("CMD_AccessAdd_Prompt_SRCIP"), CmdEvalIpAndMask4, NULL},
\r
14674 {"DESTIP", CmdPrompt, _UU("CMD_AccessAdd_Prompt_DESTIP"), CmdEvalIpAndMask4, NULL},
\r
14675 {"PROTOCOL", CmdPrompt, _UU("CMD_AccessAdd_Prompt_PROTOCOL"), CmdEvalProtocol, NULL},
\r
14676 {"SRCPORT", CmdPrompt, _UU("CMD_AccessAdd_Prompt_SRCPORT"), CmdEvalPortRange, NULL},
\r
14677 {"DESTPORT", CmdPrompt, _UU("CMD_AccessAdd_Prompt_DESTPORT"), CmdEvalPortRange, NULL},
\r
14678 {"TCPSTATE", CmdPrompt, _UU("CMD_AccessAdd_Prompt_TCPSTATE"), CmdEvalTcpState, NULL},
\r
14679 {"DELAY", CmdPrompt, _UU("CMD_AccessAddEx_Prompt_DELAY"), CmdEvalMinMax, &minmax_delay},
\r
14680 {"JITTER", CmdPrompt, _UU("CMD_AccessAddEx_Prompt_JITTER"), CmdEvalMinMax, &minmax_jitter},
\r
14681 {"LOSS", CmdPrompt, _UU("CMD_AccessAddEx_Prompt_LOSS"), CmdEvalMinMax, &minmax_loss},
\r
14684 // 仮想 HUB が選択されていない場合はエラー
\r
14685 if (ps->HubName == NULL)
\r
14687 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14688 return ERR_INVALID_PARAMETER;
\r
14691 // サポートしているかどうかチェック
\r
14692 if (GetCapsBool(ps->CapsList, "b_support_ex_acl") == false)
\r
14694 c->Write(c, _E(ERR_NOT_SUPPORTED));
\r
14695 return ERR_NOT_SUPPORTED;
\r
14698 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
14701 return ERR_INVALID_PARAMETER;
\r
14704 Zero(&t, sizeof(t));
\r
14707 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14708 UniStrCpy(a->Note, sizeof(a->Note), GetParamUniStr(o, "MEMO"));
\r
14709 a->Active = true;
\r
14710 a->Priority = GetParamInt(o, "PRIORITY");
\r
14711 a->Discard = StrToPassOrDiscard(GetParamStr(o, "[pass|discard]")) ? false : true;
\r
14712 StrCpy(a->SrcUsername, sizeof(a->SrcUsername), GetParamStr(o, "SRCUSERNAME"));
\r
14713 StrCpy(a->DestUsername, sizeof(a->DestUsername), GetParamStr(o, "DESTUSERNAME"));
\r
14714 ParseMacAddressAndMask(GetParamStr(o, "SRCMAC"), &a->CheckSrcMac, a->SrcMacAddress, a->SrcMacMask);
\r
14715 ParseMacAddressAndMask(GetParamStr(o, "DESTMAC"), &a->CheckDstMac, a->DstMacAddress, a->DstMacMask);
\r
14716 ParseIpAndMask4(GetParamStr(o, "SRCIP"), &a->SrcIpAddress, &a->SrcSubnetMask);
\r
14717 ParseIpAndMask4(GetParamStr(o, "DESTIP"), &a->DestIpAddress, &a->DestSubnetMask);
\r
14718 a->Protocol = StrToProtocol(GetParamStr(o, "PROTOCOL"));
\r
14719 ParsePortRange(GetParamStr(o, "SRCPORT"), &a->SrcPortStart, &a->SrcPortEnd);
\r
14720 ParsePortRange(GetParamStr(o, "DESTPORT"), &a->DestPortStart, &a->DestPortEnd);
\r
14721 ParseTcpState(GetParamStr(o, "TCPSTATE"), &a->CheckTcpState, &a->Established);
\r
14722 a->Delay = GetParamInt(o, "DELAY");
\r
14723 a->Jitter = GetParamInt(o, "JITTER");
\r
14724 a->Loss = GetParamInt(o, "LOSS");
\r
14727 ret = ScAddAccess(ps->Rpc, &t);
\r
14729 if (ret != ERR_NO_ERROR)
\r
14732 CmdPrintError(c, ret);
\r
14733 FreeParamValueList(o);
\r
14737 FreeParamValueList(o);
\r
14742 // アクセス リストへのルールの追加 (標準、IPv6)
\r
14743 UINT PsAccessAdd6(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14746 PS *ps = (PS *)param;
\r
14748 RPC_ADD_ACCESS t;
\r
14751 // 指定できるパラメータ リスト
\r
14752 CMD_EVAL_MIN_MAX minmax =
\r
14754 "CMD_AccessAdd6_Eval_PRIORITY", 1, 4294967295UL,
\r
14758 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
14759 {"[pass|discard]", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_TYPE"), CmdEvalNotEmpty, NULL},
\r
14760 {"MEMO", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_MEMO"), NULL, NULL},
\r
14761 {"PRIORITY", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_PRIORITY"), CmdEvalMinMax, &minmax},
\r
14762 {"SRCUSERNAME", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_SRCUSERNAME"), NULL, NULL},
\r
14763 {"DESTUSERNAME", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_DESTUSERNAME"), NULL, NULL},
\r
14764 {"SRCMAC", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_SRCMAC"), CmdEvalMacAddressAndMask, NULL},
\r
14765 {"DESTMAC", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_DESTMAC"), CmdEvalMacAddressAndMask, NULL},
\r
14766 {"SRCIP", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_SRCIP"), CmdEvalIpAndMask6, NULL},
\r
14767 {"DESTIP", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_DESTIP"), CmdEvalIpAndMask6, NULL},
\r
14768 {"PROTOCOL", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_PROTOCOL"), CmdEvalProtocol, NULL},
\r
14769 {"SRCPORT", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_SRCPORT"), CmdEvalPortRange, NULL},
\r
14770 {"DESTPORT", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_DESTPORT"), CmdEvalPortRange, NULL},
\r
14771 {"TCPSTATE", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_TCPSTATE"), CmdEvalTcpState, NULL},
\r
14774 // 仮想 HUB が選択されていない場合はエラー
\r
14775 if (ps->HubName == NULL)
\r
14777 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14778 return ERR_INVALID_PARAMETER;
\r
14781 // サポートしているかどうかチェック
\r
14782 if (GetCapsBool(ps->CapsList, "b_support_ex_acl") == false)
\r
14784 c->Write(c, _E(ERR_NOT_SUPPORTED));
\r
14785 return ERR_NOT_SUPPORTED;
\r
14788 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
14791 return ERR_INVALID_PARAMETER;
\r
14794 Zero(&t, sizeof(t));
\r
14797 a->IsIPv6 = true;
\r
14799 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14800 UniStrCpy(a->Note, sizeof(a->Note), GetParamUniStr(o, "MEMO"));
\r
14801 a->Active = true;
\r
14802 a->Priority = GetParamInt(o, "PRIORITY");
\r
14803 a->Discard = StrToPassOrDiscard(GetParamStr(o, "[pass|discard]")) ? false : true;
\r
14804 StrCpy(a->SrcUsername, sizeof(a->SrcUsername), GetParamStr(o, "SRCUSERNAME"));
\r
14805 StrCpy(a->DestUsername, sizeof(a->DestUsername), GetParamStr(o, "DESTUSERNAME"));
\r
14806 ParseMacAddressAndMask(GetParamStr(o, "SRCMAC"), &a->CheckSrcMac, a->SrcMacAddress, a->SrcMacMask);
\r
14807 ParseMacAddressAndMask(GetParamStr(o, "DESTMAC"), &a->CheckDstMac, a->DstMacAddress, a->DstMacMask);
\r
14809 Zero(&ip, sizeof(ip));
\r
14810 Zero(&mask, sizeof(mask));
\r
14812 ParseIpAndMask6(GetParamStr(o, "SRCIP"), &ip, &mask);
\r
14813 IPToIPv6Addr(&a->SrcIpAddress6, &ip);
\r
14814 IPToIPv6Addr(&a->SrcSubnetMask6, &mask);
\r
14816 ParseIpAndMask6(GetParamStr(o, "DESTIP"), &ip, &mask);
\r
14817 IPToIPv6Addr(&a->DestIpAddress6, &ip);
\r
14818 IPToIPv6Addr(&a->DestSubnetMask6, &mask);
\r
14820 a->Protocol = StrToProtocol(GetParamStr(o, "PROTOCOL"));
\r
14821 ParsePortRange(GetParamStr(o, "SRCPORT"), &a->SrcPortStart, &a->SrcPortEnd);
\r
14822 ParsePortRange(GetParamStr(o, "DESTPORT"), &a->DestPortStart, &a->DestPortEnd);
\r
14823 ParseTcpState(GetParamStr(o, "TCPSTATE"), &a->CheckTcpState, &a->Established);
\r
14826 ret = ScAddAccess(ps->Rpc, &t);
\r
14828 if (ret != ERR_NO_ERROR)
\r
14831 CmdPrintError(c, ret);
\r
14832 FreeParamValueList(o);
\r
14836 FreeParamValueList(o);
\r
14841 // アクセス リストへのルールの追加 (拡張、IPv6)
\r
14842 UINT PsAccessAddEx6(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14845 PS *ps = (PS *)param;
\r
14847 RPC_ADD_ACCESS t;
\r
14850 // 指定できるパラメータ リスト
\r
14851 CMD_EVAL_MIN_MAX minmax =
\r
14853 "CMD_AccessAdd6_Eval_PRIORITY", 1, 4294967295UL,
\r
14855 CMD_EVAL_MIN_MAX minmax_delay =
\r
14857 "CMD_AccessAddEx6_Eval_DELAY", 0, HUB_ACCESSLIST_DELAY_MAX,
\r
14859 CMD_EVAL_MIN_MAX minmax_jitter =
\r
14861 "CMD_AccessAddEx6_Eval_JITTER", 0, HUB_ACCESSLIST_JITTER_MAX,
\r
14863 CMD_EVAL_MIN_MAX minmax_loss =
\r
14865 "CMD_AccessAddEx6_Eval_LOSS", 0, HUB_ACCESSLIST_LOSS_MAX,
\r
14869 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
14870 {"[pass|discard]", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_TYPE"), CmdEvalNotEmpty, NULL},
\r
14871 {"MEMO", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_MEMO"), NULL, NULL},
\r
14872 {"PRIORITY", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_PRIORITY"), CmdEvalMinMax, &minmax},
\r
14873 {"SRCUSERNAME", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_SRCUSERNAME"), NULL, NULL},
\r
14874 {"DESTUSERNAME", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_DESTUSERNAME"), NULL, NULL},
\r
14875 {"SRCMAC", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_SRCMAC"), CmdEvalMacAddressAndMask, NULL},
\r
14876 {"DESTMAC", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_DESTMAC"), CmdEvalMacAddressAndMask, NULL},
\r
14877 {"SRCIP", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_SRCIP"), CmdEvalIpAndMask6, NULL},
\r
14878 {"DESTIP", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_DESTIP"), CmdEvalIpAndMask6, NULL},
\r
14879 {"PROTOCOL", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_PROTOCOL"), CmdEvalProtocol, NULL},
\r
14880 {"SRCPORT", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_SRCPORT"), CmdEvalPortRange, NULL},
\r
14881 {"DESTPORT", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_DESTPORT"), CmdEvalPortRange, NULL},
\r
14882 {"TCPSTATE", CmdPrompt, _UU("CMD_AccessAdd6_Prompt_TCPSTATE"), CmdEvalTcpState, NULL},
\r
14883 {"DELAY", CmdPrompt, _UU("CMD_AccessAddEx6_Prompt_DELAY"), CmdEvalMinMax, &minmax_delay},
\r
14884 {"JITTER", CmdPrompt, _UU("CMD_AccessAddEx6_Prompt_JITTER"), CmdEvalMinMax, &minmax_jitter},
\r
14885 {"LOSS", CmdPrompt, _UU("CMD_AccessAddEx6_Prompt_LOSS"), CmdEvalMinMax, &minmax_loss},
\r
14888 // 仮想 HUB が選択されていない場合はエラー
\r
14889 if (ps->HubName == NULL)
\r
14891 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14892 return ERR_INVALID_PARAMETER;
\r
14895 // サポートしているかどうかチェック
\r
14896 if (GetCapsBool(ps->CapsList, "b_support_ex_acl") == false)
\r
14898 c->Write(c, _E(ERR_NOT_SUPPORTED));
\r
14899 return ERR_NOT_SUPPORTED;
\r
14902 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
14905 return ERR_INVALID_PARAMETER;
\r
14908 Zero(&t, sizeof(t));
\r
14911 a->IsIPv6 = true;
\r
14913 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14914 UniStrCpy(a->Note, sizeof(a->Note), GetParamUniStr(o, "MEMO"));
\r
14915 a->Active = true;
\r
14916 a->Priority = GetParamInt(o, "PRIORITY");
\r
14917 a->Discard = StrToPassOrDiscard(GetParamStr(o, "[pass|discard]")) ? false : true;
\r
14918 StrCpy(a->SrcUsername, sizeof(a->SrcUsername), GetParamStr(o, "SRCUSERNAME"));
\r
14919 StrCpy(a->DestUsername, sizeof(a->DestUsername), GetParamStr(o, "DESTUSERNAME"));
\r
14920 ParseMacAddressAndMask(GetParamStr(o, "SRCMAC"), &a->CheckSrcMac, a->SrcMacAddress, a->SrcMacMask);
\r
14921 ParseMacAddressAndMask(GetParamStr(o, "DESTMAC"), &a->CheckDstMac, a->DstMacAddress, a->DstMacMask);
\r
14923 Zero(&ip, sizeof(ip));
\r
14924 Zero(&mask, sizeof(mask));
\r
14926 ParseIpAndMask6(GetParamStr(o, "SRCIP"), &ip, &mask);
\r
14927 IPToIPv6Addr(&a->SrcIpAddress6, &ip);
\r
14928 IPToIPv6Addr(&a->SrcSubnetMask6, &mask);
\r
14930 ParseIpAndMask6(GetParamStr(o, "DESTIP"), &ip, &mask);
\r
14931 IPToIPv6Addr(&a->DestIpAddress6, &ip);
\r
14932 IPToIPv6Addr(&a->DestSubnetMask6, &mask);
\r
14934 a->Protocol = StrToProtocol(GetParamStr(o, "PROTOCOL"));
\r
14935 ParsePortRange(GetParamStr(o, "SRCPORT"), &a->SrcPortStart, &a->SrcPortEnd);
\r
14936 ParsePortRange(GetParamStr(o, "DESTPORT"), &a->DestPortStart, &a->DestPortEnd);
\r
14937 ParseTcpState(GetParamStr(o, "TCPSTATE"), &a->CheckTcpState, &a->Established);
\r
14938 a->Delay = GetParamInt(o, "DELAY");
\r
14939 a->Jitter = GetParamInt(o, "JITTER");
\r
14940 a->Loss = GetParamInt(o, "LOSS");
\r
14943 ret = ScAddAccess(ps->Rpc, &t);
\r
14945 if (ret != ERR_NO_ERROR)
\r
14948 CmdPrintError(c, ret);
\r
14949 FreeParamValueList(o);
\r
14953 FreeParamValueList(o);
\r
14959 // アクセス リストのルール一覧の取得
\r
14960 UINT PsAccessList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
14963 PS *ps = (PS *)param;
\r
14965 RPC_ENUM_ACCESS_LIST t;
\r
14969 // 仮想 HUB が選択されていない場合はエラー
\r
14970 if (ps->HubName == NULL)
\r
14972 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
14973 return ERR_INVALID_PARAMETER;
\r
14976 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
14979 return ERR_INVALID_PARAMETER;
\r
14982 Zero(&t, sizeof(t));
\r
14983 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
14986 ret = ScEnumAccess(ps->Rpc, &t);
\r
14988 if (ret != ERR_NO_ERROR)
\r
14991 CmdPrintError(c, ret);
\r
14992 FreeParamValueList(o);
\r
14997 CtInsertColumn(ct, _UU("SM_ACCESS_COLUMN_0"), true);
\r
14998 CtInsertColumn(ct, _UU("SM_ACCESS_COLUMN_1"), true);
\r
14999 CtInsertColumn(ct, _UU("SM_ACCESS_COLUMN_2"), true);
\r
15000 CtInsertColumn(ct, _UU("SM_ACCESS_COLUMN_3"), true);
\r
15001 CtInsertColumn(ct, _UU("SM_ACCESS_COLUMN_5"), false);
\r
15002 CtInsertColumn(ct, _UU("SM_ACCESS_COLUMN_4"), false);
\r
15004 for (i = 0;i < t.NumAccess;i++)
\r
15006 ACCESS *a = &t.Accesses[i];
\r
15007 char tmp[MAX_SIZE];
\r
15008 wchar_t tmp3[MAX_SIZE];
\r
15009 wchar_t tmp1[MAX_SIZE];
\r
15010 wchar_t tmp2[MAX_SIZE];
\r
15012 GetAccessListStr(tmp, sizeof(tmp), a);
\r
15013 UniToStru(tmp1, a->Priority);
\r
15014 StrToUni(tmp2, sizeof(tmp2), tmp);
\r
15016 UniToStru(tmp3, a->Id);
\r
15020 a->Discard ? _UU("SM_ACCESS_DISCARD") : _UU("SM_ACCESS_PASS"),
\r
15021 a->Active ? _UU("SM_ACCESS_ENABLE") : _UU("SM_ACCESS_DISABLE"),
\r
15027 CtFreeEx(ct, c, true);
\r
15029 FreeRpcEnumAccessList(&t);
\r
15031 FreeParamValueList(o);
\r
15036 // アクセス リストからルールを削除
\r
15037 UINT PsAccessDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15040 PS *ps = (PS *)param;
\r
15042 RPC_DELETE_ACCESS t;
\r
15043 // 指定できるパラメータ リスト
\r
15046 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15047 {"[id]", CmdPrompt, _UU("CMD_Access_Prompt_ID"), CmdEvalNotEmpty, NULL},
\r
15050 // 仮想 HUB が選択されていない場合はエラー
\r
15051 if (ps->HubName == NULL)
\r
15053 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15054 return ERR_INVALID_PARAMETER;
\r
15057 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15060 return ERR_INVALID_PARAMETER;
\r
15063 Zero(&t, sizeof(t));
\r
15064 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15065 t.Id = GetParamInt(o, "[id]");
\r
15068 ret = ScDeleteAccess(ps->Rpc, &t);
\r
15070 if (ret != ERR_NO_ERROR)
\r
15073 CmdPrintError(c, ret);
\r
15074 FreeParamValueList(o);
\r
15078 FreeParamValueList(o);
\r
15083 // アクセス リストのルールの有効化
\r
15084 UINT PsAccessEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15087 PS *ps = (PS *)param;
\r
15089 RPC_ENUM_ACCESS_LIST t;
\r
15090 // 指定できるパラメータ リスト
\r
15093 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15094 {"[id]", CmdPrompt, _UU("CMD_Access_Prompt_ID"), CmdEvalNotEmpty, NULL},
\r
15097 // 仮想 HUB が選択されていない場合はエラー
\r
15098 if (ps->HubName == NULL)
\r
15100 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15101 return ERR_INVALID_PARAMETER;
\r
15104 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15107 return ERR_INVALID_PARAMETER;
\r
15110 Zero(&t, sizeof(t));
\r
15111 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15114 ret = ScEnumAccess(ps->Rpc, &t);
\r
15116 if (ret != ERR_NO_ERROR)
\r
15119 CmdPrintError(c, ret);
\r
15120 FreeParamValueList(o);
\r
15127 for (i = 0;i < t.NumAccess;i++)
\r
15129 ACCESS *a = &t.Accesses[i];
\r
15131 if (a->Id == GetParamInt(o, "[id]"))
\r
15135 a->Active = true;
\r
15141 // 指定した ID が見つからない
\r
15142 ret = ERR_OBJECT_NOT_FOUND;
\r
15143 CmdPrintError(c, ret);
\r
15144 FreeParamValueList(o);
\r
15145 FreeRpcEnumAccessList(&t);
\r
15149 ret = ScSetAccessList(ps->Rpc, &t);
\r
15150 if (ret != ERR_NO_ERROR)
\r
15153 CmdPrintError(c, ret);
\r
15154 FreeParamValueList(o);
\r
15158 FreeRpcEnumAccessList(&t);
\r
15161 FreeParamValueList(o);
\r
15166 // アクセス リストのルールの無効化
\r
15167 UINT PsAccessDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15170 PS *ps = (PS *)param;
\r
15172 RPC_ENUM_ACCESS_LIST t;
\r
15173 // 指定できるパラメータ リスト
\r
15176 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15177 {"[id]", CmdPrompt, _UU("CMD_Access_Prompt_ID"), CmdEvalNotEmpty, NULL},
\r
15180 // 仮想 HUB が選択されていない場合はエラー
\r
15181 if (ps->HubName == NULL)
\r
15183 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15184 return ERR_INVALID_PARAMETER;
\r
15187 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15190 return ERR_INVALID_PARAMETER;
\r
15193 Zero(&t, sizeof(t));
\r
15194 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15197 ret = ScEnumAccess(ps->Rpc, &t);
\r
15199 if (ret != ERR_NO_ERROR)
\r
15202 CmdPrintError(c, ret);
\r
15203 FreeParamValueList(o);
\r
15210 for (i = 0;i < t.NumAccess;i++)
\r
15212 ACCESS *a = &t.Accesses[i];
\r
15214 if (a->Id == GetParamInt(o, "[id]"))
\r
15218 a->Active = false;
\r
15224 // 指定した ID が見つからない
\r
15225 ret = ERR_OBJECT_NOT_FOUND;
\r
15226 CmdPrintError(c, ret);
\r
15227 FreeParamValueList(o);
\r
15228 FreeRpcEnumAccessList(&t);
\r
15232 ret = ScSetAccessList(ps->Rpc, &t);
\r
15233 if (ret != ERR_NO_ERROR)
\r
15236 CmdPrintError(c, ret);
\r
15237 FreeParamValueList(o);
\r
15241 FreeRpcEnumAccessList(&t);
\r
15244 FreeParamValueList(o);
\r
15250 UINT PsUserList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15253 PS *ps = (PS *)param;
\r
15257 // 仮想 HUB が選択されていない場合はエラー
\r
15258 if (ps->HubName == NULL)
\r
15260 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15261 return ERR_INVALID_PARAMETER;
\r
15264 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
15267 return ERR_INVALID_PARAMETER;
\r
15270 Zero(&t, sizeof(t));
\r
15271 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15274 ret = ScEnumUser(ps->Rpc, &t);
\r
15276 if (ret != ERR_NO_ERROR)
\r
15279 CmdPrintError(c, ret);
\r
15280 FreeParamValueList(o);
\r
15286 CT *ct = CtNew();
\r
15288 CtInsertColumn(ct, _UU("SM_USER_COLUMN_1"), false);
\r
15289 CtInsertColumn(ct, _UU("SM_USER_COLUMN_2"), false);
\r
15290 CtInsertColumn(ct, _UU("SM_USER_COLUMN_3"), false);
\r
15291 CtInsertColumn(ct, _UU("SM_USER_COLUMN_4"), false);
\r
15292 CtInsertColumn(ct, _UU("SM_USER_COLUMN_5"), false);
\r
15293 CtInsertColumn(ct, _UU("SM_USER_COLUMN_6"), false);
\r
15294 CtInsertColumn(ct, _UU("SM_USER_COLUMN_7"), false);
\r
15296 for (i = 0;i < t.NumUser;i++)
\r
15298 RPC_ENUM_USER_ITEM *e = &t.Users[i];
\r
15299 wchar_t name[MAX_SIZE];
\r
15300 wchar_t group[MAX_SIZE];
\r
15301 wchar_t num[MAX_SIZE];
\r
15302 wchar_t time[MAX_SIZE];
\r
15304 StrToUni(name, sizeof(name), e->Name);
\r
15306 if (StrLen(e->GroupName) != 0)
\r
15308 StrToUni(group, sizeof(group), e->GroupName);
\r
15312 UniStrCpy(group, sizeof(group), _UU("SM_NO_GROUP"));
\r
15315 UniToStru(num, e->NumLogin);
\r
15317 GetDateTimeStrEx64(time, sizeof(time), SystemToLocal64(e->LastLoginTime), NULL);
\r
15320 name, e->Realname, group, e->Note, GetAuthTypeStr(e->AuthType),
\r
15324 CtFreeEx(ct, c, true);
\r
15327 FreeRpcEnumUser(&t);
\r
15329 FreeParamValueList(o);
\r
15334 // ユーザー認証方法の文字列の取得
\r
15335 wchar_t *GetAuthTypeStr(UINT id)
\r
15337 char tmp[MAX_SIZE];
\r
15338 Format(tmp, sizeof(tmp), "SM_AUTHTYPE_%u", id);
\r
15344 UINT PsUserCreate(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15347 PS *ps = (PS *)param;
\r
15350 // 指定できるパラメータ リスト
\r
15353 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15354 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15355 {"GROUP", CmdPrompt, _UU("CMD_UserCreate_Prompt_GROUP"), NULL, NULL},
\r
15356 {"REALNAME", CmdPrompt, _UU("CMD_UserCreate_Prompt_REALNAME"), NULL, NULL},
\r
15357 {"NOTE", CmdPrompt, _UU("CMD_UserCreate_Prompt_NOTE"), NULL, NULL},
\r
15360 // 仮想 HUB が選択されていない場合はエラー
\r
15361 if (ps->HubName == NULL)
\r
15363 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15364 return ERR_INVALID_PARAMETER;
\r
15367 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15370 return ERR_INVALID_PARAMETER;
\r
15373 Zero(&t, sizeof(t));
\r
15374 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15375 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
15376 StrCpy(t.GroupName, sizeof(t.GroupName), GetParamStr(o, "GROUP"));
\r
15377 UniStrCpy(t.Realname, sizeof(t.Realname), GetParamUniStr(o, "REALNAME"));
\r
15378 UniStrCpy(t.Note, sizeof(t.Note), GetParamUniStr(o, "NOTE"));
\r
15381 if (StrCmpi(t.Name, "*") == 0)
\r
15383 t.AuthType = AUTHTYPE_RADIUS;
\r
15384 t.AuthData = NewRadiusAuthData(NULL);
\r
15388 UCHAR random_pass[SHA1_SIZE];
\r
15390 Rand(random_pass, sizeof(random_pass));
\r
15391 t.AuthType = AUTHTYPE_PASSWORD;
\r
15392 t.AuthData = NewPasswordAuthDataRaw(random_pass);
\r
15396 ret = ScCreateUser(ps->Rpc, &t);
\r
15398 if (ret != ERR_NO_ERROR)
\r
15401 CmdPrintError(c, ret);
\r
15402 FreeParamValueList(o);
\r
15406 FreeRpcSetUser(&t);
\r
15408 FreeParamValueList(o);
\r
15414 UINT PsUserSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15417 PS *ps = (PS *)param;
\r
15420 // 指定できるパラメータ リスト
\r
15423 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15424 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15425 {"GROUP", CmdPrompt, _UU("CMD_UserCreate_Prompt_GROUP"), NULL, NULL},
\r
15426 {"REALNAME", CmdPrompt, _UU("CMD_UserCreate_Prompt_REALNAME"), NULL, NULL},
\r
15427 {"NOTE", CmdPrompt, _UU("CMD_UserCreate_Prompt_NOTE"), NULL, NULL},
\r
15430 // 仮想 HUB が選択されていない場合はエラー
\r
15431 if (ps->HubName == NULL)
\r
15433 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15434 return ERR_INVALID_PARAMETER;
\r
15437 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15440 return ERR_INVALID_PARAMETER;
\r
15443 Zero(&t, sizeof(t));
\r
15445 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15446 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
15448 ret = ScGetUser(ps->Rpc, &t);
\r
15449 if (ret != ERR_NO_ERROR)
\r
15452 CmdPrintError(c, ret);
\r
15453 FreeParamValueList(o);
\r
15458 StrCpy(t.GroupName, sizeof(t.GroupName), GetParamStr(o, "GROUP"));
\r
15459 UniStrCpy(t.Realname, sizeof(t.Realname), GetParamUniStr(o, "REALNAME"));
\r
15460 UniStrCpy(t.Note, sizeof(t.Note), GetParamUniStr(o, "NOTE"));
\r
15462 // ユーザーオブジェクトを書き込み
\r
15463 ret = ScSetUser(ps->Rpc, &t);
\r
15465 if (ret != ERR_NO_ERROR)
\r
15468 CmdPrintError(c, ret);
\r
15469 FreeParamValueList(o);
\r
15473 FreeRpcSetUser(&t);
\r
15475 FreeParamValueList(o);
\r
15481 UINT PsUserDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15484 PS *ps = (PS *)param;
\r
15486 RPC_DELETE_USER t;
\r
15487 // 指定できるパラメータ リスト
\r
15490 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15493 // 仮想 HUB が選択されていない場合はエラー
\r
15494 if (ps->HubName == NULL)
\r
15496 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15497 return ERR_INVALID_PARAMETER;
\r
15500 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15503 return ERR_INVALID_PARAMETER;
\r
15506 Zero(&t, sizeof(t));
\r
15507 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15508 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
15511 ret = ScDeleteUser(ps->Rpc, &t);
\r
15513 if (ret != ERR_NO_ERROR)
\r
15516 CmdPrintError(c, ret);
\r
15517 FreeParamValueList(o);
\r
15521 FreeParamValueList(o);
\r
15527 UINT PsUserGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15530 PS *ps = (PS *)param;
\r
15533 // 指定できるパラメータ リスト
\r
15536 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15537 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15540 // 仮想 HUB が選択されていない場合はエラー
\r
15541 if (ps->HubName == NULL)
\r
15543 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15544 return ERR_INVALID_PARAMETER;
\r
15547 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15550 return ERR_INVALID_PARAMETER;
\r
15553 Zero(&t, sizeof(t));
\r
15555 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15556 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
15558 ret = ScGetUser(ps->Rpc, &t);
\r
15559 if (ret != ERR_NO_ERROR)
\r
15562 CmdPrintError(c, ret);
\r
15563 FreeParamValueList(o);
\r
15568 wchar_t tmp[MAX_SIZE];
\r
15572 ct = CtNewStandard();
\r
15575 StrToUni(tmp, sizeof(tmp), t.Name);
\r
15576 CtInsert(ct, _UU("CMD_UserGet_Column_Name"), tmp);
\r
15579 CtInsert(ct, _UU("CMD_UserGet_Column_RealName"), t.Realname);
\r
15582 CtInsert(ct, _UU("CMD_UserGet_Column_Note"), t.Note);
\r
15585 if (IsEmptyStr(t.GroupName) == false)
\r
15587 StrToUni(tmp, sizeof(tmp), t.GroupName);
\r
15588 CtInsert(ct, _UU("CMD_UserGet_Column_Group"), tmp);
\r
15592 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.ExpireTime), NULL);
\r
15593 CtInsert(ct, _UU("CMD_UserGet_Column_Expires"), tmp);
\r
15596 CtInsert(ct, _UU("CMD_UserGet_Column_AuthType"), GetAuthTypeStr(t.AuthType));
\r
15598 switch (t.AuthType)
\r
15600 case AUTHTYPE_USERCERT:
\r
15601 if (t.AuthData != NULL)
\r
15603 AUTHUSERCERT *auc = (AUTHUSERCERT *)t.AuthData;
\r
15605 if (auc != NULL && auc->UserX != NULL)
\r
15608 GetAllNameFromX(tmp, sizeof(tmp), auc->UserX);
\r
15609 CtInsert(ct, _UU("CMD_UserGet_Column_UserCert"), tmp);
\r
15614 case AUTHTYPE_ROOTCERT:
\r
15615 if (t.AuthData != NULL)
\r
15617 AUTHROOTCERT *arc = (AUTHROOTCERT *)t.AuthData;
\r
15619 if (IsEmptyUniStr(arc->CommonName) == false)
\r
15622 CtInsert(ct, _UU("CMD_UserGet_Column_RootCert_CN"), arc->CommonName);
\r
15625 if (arc->Serial != NULL && arc->Serial->size >= 1)
\r
15627 char tmp2[MAX_SIZE];
\r
15630 BinToStrEx(tmp2, sizeof(tmp2), arc->Serial->data, arc->Serial->size);
\r
15631 StrToUni(tmp, sizeof(tmp), tmp2);
\r
15632 CtInsert(ct, _UU("CMD_UserGet_Column_RootCert_SERIAL"), tmp);
\r
15637 case AUTHTYPE_RADIUS:
\r
15638 case AUTHTYPE_NT:
\r
15639 if (t.AuthData != NULL)
\r
15641 AUTHRADIUS *ar = (AUTHRADIUS *)t.AuthData;
\r
15643 // 外部認証サーバーの認証ユーザー名
\r
15644 if (IsEmptyUniStr(ar->RadiusUsername) == false)
\r
15646 CtInsert(ct, _UU("CMD_UserGet_Column_RadiusAlias"), ar->RadiusUsername);
\r
15652 CtInsert(ct, L"---", L"---");
\r
15654 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.CreatedTime), NULL);
\r
15655 CtInsert(ct, _UU("SM_USERINFO_CREATE"), tmp);
\r
15657 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.UpdatedTime), NULL);
\r
15658 CtInsert(ct, _UU("SM_USERINFO_UPDATE"), tmp);
\r
15660 CmdInsertTrafficInfo(ct, &t.Traffic);
\r
15662 UniToStru(tmp, t.NumLogin);
\r
15663 CtInsert(ct, _UU("SM_USERINFO_NUMLOGIN"), tmp);
\r
15668 if (t.Policy != NULL)
\r
15670 c->Write(c, L"");
\r
15671 c->Write(c, _UU("CMD_UserGet_Policy"));
\r
15672 PrintPolicy(c, t.Policy, false);
\r
15676 FreeRpcSetUser(&t);
\r
15678 FreeParamValueList(o);
\r
15683 // ユーザーの認証方法を匿名認証に設定
\r
15684 UINT PsUserAnonymousSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15687 PS *ps = (PS *)param;
\r
15690 // 指定できるパラメータ リスト
\r
15693 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15694 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15697 // 仮想 HUB が選択されていない場合はエラー
\r
15698 if (ps->HubName == NULL)
\r
15700 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15701 return ERR_INVALID_PARAMETER;
\r
15704 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15707 return ERR_INVALID_PARAMETER;
\r
15710 Zero(&t, sizeof(t));
\r
15712 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15713 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
15715 ret = ScGetUser(ps->Rpc, &t);
\r
15716 if (ret != ERR_NO_ERROR)
\r
15719 CmdPrintError(c, ret);
\r
15720 FreeParamValueList(o);
\r
15725 FreeAuthData(t.AuthType, t.AuthData);
\r
15728 t.AuthType = AUTHTYPE_ANONYMOUS;
\r
15729 t.AuthData = NULL;
\r
15731 // ユーザーオブジェクトを書き込み
\r
15732 ret = ScSetUser(ps->Rpc, &t);
\r
15734 if (ret != ERR_NO_ERROR)
\r
15737 CmdPrintError(c, ret);
\r
15738 FreeParamValueList(o);
\r
15742 FreeRpcSetUser(&t);
\r
15744 FreeParamValueList(o);
\r
15749 // ユーザーの認証方法をパスワード認証に設定しパスワードを設定
\r
15750 UINT PsUserPasswordSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15753 PS *ps = (PS *)param;
\r
15756 // 指定できるパラメータ リスト
\r
15759 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15760 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15761 {"PASSWORD", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
15764 // 仮想 HUB が選択されていない場合はエラー
\r
15765 if (ps->HubName == NULL)
\r
15767 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15768 return ERR_INVALID_PARAMETER;
\r
15771 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15774 return ERR_INVALID_PARAMETER;
\r
15777 Zero(&t, sizeof(t));
\r
15779 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15780 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
15782 ret = ScGetUser(ps->Rpc, &t);
\r
15783 if (ret != ERR_NO_ERROR)
\r
15786 CmdPrintError(c, ret);
\r
15787 FreeParamValueList(o);
\r
15792 FreeAuthData(t.AuthType, t.AuthData);
\r
15795 AUTHPASSWORD *pw;
\r
15797 pw = NewPasswordAuthData(t.Name, GetParamStr(o, "PASSWORD"));
\r
15800 t.AuthType = AUTHTYPE_PASSWORD;
\r
15804 // ユーザーオブジェクトを書き込み
\r
15805 ret = ScSetUser(ps->Rpc, &t);
\r
15807 if (ret != ERR_NO_ERROR)
\r
15810 CmdPrintError(c, ret);
\r
15811 FreeParamValueList(o);
\r
15815 FreeRpcSetUser(&t);
\r
15817 FreeParamValueList(o);
\r
15822 // ユーザーの認証方法を固有証明書認証に設定し証明書を設定
\r
15823 UINT PsUserCertSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15826 PS *ps = (PS *)param;
\r
15830 // 指定できるパラメータ リスト
\r
15833 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15834 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15835 {"LOADCERT", CmdPrompt, _UU("CMD_LOADCERTPATH"), CmdEvalIsFile, NULL},
\r
15838 // 仮想 HUB が選択されていない場合はエラー
\r
15839 if (ps->HubName == NULL)
\r
15841 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15842 return ERR_INVALID_PARAMETER;
\r
15845 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15848 return ERR_INVALID_PARAMETER;
\r
15852 x = FileToX(GetParamStr(o, "LOADCERT"));
\r
15855 c->Write(c, _UU("CMD_LOADCERT_FAILED"));
\r
15857 FreeParamValueList(o);
\r
15859 return ERR_INTERNAL_ERROR;
\r
15862 Zero(&t, sizeof(t));
\r
15864 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15865 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
15867 ret = ScGetUser(ps->Rpc, &t);
\r
15868 if (ret != ERR_NO_ERROR)
\r
15871 CmdPrintError(c, ret);
\r
15872 FreeParamValueList(o);
\r
15878 FreeAuthData(t.AuthType, t.AuthData);
\r
15883 c = NewUserCertAuthData(x);
\r
15888 t.AuthType = AUTHTYPE_USERCERT;
\r
15892 // ユーザーオブジェクトを書き込み
\r
15893 ret = ScSetUser(ps->Rpc, &t);
\r
15895 if (ret != ERR_NO_ERROR)
\r
15898 CmdPrintError(c, ret);
\r
15899 FreeParamValueList(o);
\r
15903 FreeRpcSetUser(&t);
\r
15905 FreeParamValueList(o);
\r
15910 // 固有証明書認証のユーザーの登録されている証明書の取得
\r
15911 UINT PsUserCertGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15914 PS *ps = (PS *)param;
\r
15918 // 指定できるパラメータ リスト
\r
15921 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15922 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15923 {"SAVECERT", CmdPrompt, _UU("CMD_SAVECERTPATH"), NULL, NULL},
\r
15926 // 仮想 HUB が選択されていない場合はエラー
\r
15927 if (ps->HubName == NULL)
\r
15929 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15930 return ERR_INVALID_PARAMETER;
\r
15933 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
15936 return ERR_INVALID_PARAMETER;
\r
15939 Zero(&t, sizeof(t));
\r
15941 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
15942 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
15944 ret = ScGetUser(ps->Rpc, &t);
\r
15945 if (ret != ERR_NO_ERROR)
\r
15948 CmdPrintError(c, ret);
\r
15949 FreeParamValueList(o);
\r
15953 a = (AUTHUSERCERT *)t.AuthData;
\r
15955 if (t.AuthType != AUTHTYPE_USERCERT || a == NULL || a->UserX == NULL)
\r
15957 // ユーザーは固有証明書認証ではない
\r
15958 ret = ERR_INVALID_PARAMETER;
\r
15960 c->Write(c, _UU("CMD_UserCertGet_Not_Cert"));
\r
15964 if (XToFile(a->UserX, GetParamStr(o, "SAVECERT"), true) == false)
\r
15966 c->Write(c, _UU("CMD_SAVECERT_FAILED"));
\r
15970 FreeRpcSetUser(&t);
\r
15972 FreeParamValueList(o);
\r
15977 // ユーザーの認証方法を署名済み証明書認証に設定
\r
15978 UINT PsUserSignedSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
15981 PS *ps = (PS *)param;
\r
15984 // 指定できるパラメータ リスト
\r
15987 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
15988 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
15989 {"CN", CmdPrompt, _UU("CMD_UserSignedSet_Prompt_CN"), NULL, NULL},
\r
15990 {"SERIAL", CmdPrompt, _UU("CMD_UserSignedSet_Prompt_SERIAL"), NULL, NULL},
\r
15993 // 仮想 HUB が選択されていない場合はエラー
\r
15994 if (ps->HubName == NULL)
\r
15996 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
15997 return ERR_INVALID_PARAMETER;
\r
16000 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16003 return ERR_INVALID_PARAMETER;
\r
16006 Zero(&t, sizeof(t));
\r
16008 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16009 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16011 ret = ScGetUser(ps->Rpc, &t);
\r
16012 if (ret != ERR_NO_ERROR)
\r
16015 CmdPrintError(c, ret);
\r
16016 FreeParamValueList(o);
\r
16021 FreeAuthData(t.AuthType, t.AuthData);
\r
16026 X_SERIAL *serial = NULL;
\r
16028 b = StrToBin(GetParamStr(o, "SERIAL"));
\r
16030 if (b != NULL && b->Size >= 1)
\r
16032 serial = NewXSerial(b->Buf, b->Size);
\r
16037 c = NewRootCertAuthData(serial, GetParamUniStr(o, "CN"));
\r
16039 FreeXSerial(serial);
\r
16042 t.AuthType = AUTHTYPE_ROOTCERT;
\r
16046 // ユーザーオブジェクトを書き込み
\r
16047 ret = ScSetUser(ps->Rpc, &t);
\r
16049 if (ret != ERR_NO_ERROR)
\r
16052 CmdPrintError(c, ret);
\r
16053 FreeParamValueList(o);
\r
16057 FreeRpcSetUser(&t);
\r
16059 FreeParamValueList(o);
\r
16064 // ユーザーの認証方法を Radius 認証に設定
\r
16065 UINT PsUserRadiusSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16068 PS *ps = (PS *)param;
\r
16071 // 指定できるパラメータ リスト
\r
16074 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16075 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16076 {"ALIAS", CmdPrompt, _UU("CMD_UserRadiusSet_Prompt_ALIAS"), NULL, NULL},
\r
16079 // 仮想 HUB が選択されていない場合はエラー
\r
16080 if (ps->HubName == NULL)
\r
16082 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16083 return ERR_INVALID_PARAMETER;
\r
16086 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16089 return ERR_INVALID_PARAMETER;
\r
16092 Zero(&t, sizeof(t));
\r
16094 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16095 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16097 ret = ScGetUser(ps->Rpc, &t);
\r
16098 if (ret != ERR_NO_ERROR)
\r
16101 CmdPrintError(c, ret);
\r
16102 FreeParamValueList(o);
\r
16107 FreeAuthData(t.AuthType, t.AuthData);
\r
16112 a = NewRadiusAuthData(GetParamUniStr(o, "ALIAS"));
\r
16114 // Radius 認証に設定する
\r
16115 t.AuthType = AUTHTYPE_RADIUS;
\r
16119 // ユーザーオブジェクトを書き込み
\r
16120 ret = ScSetUser(ps->Rpc, &t);
\r
16122 if (ret != ERR_NO_ERROR)
\r
16125 CmdPrintError(c, ret);
\r
16126 FreeParamValueList(o);
\r
16130 FreeRpcSetUser(&t);
\r
16132 FreeParamValueList(o);
\r
16137 // ユーザーの認証方法を NT ドメイン認証に設定
\r
16138 UINT PsUserNTLMSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16141 PS *ps = (PS *)param;
\r
16144 // 指定できるパラメータ リスト
\r
16147 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16148 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16149 {"ALIAS", CmdPrompt, _UU("CMD_UserRadiusSet_Prompt_ALIAS"), NULL, NULL},
\r
16152 // 仮想 HUB が選択されていない場合はエラー
\r
16153 if (ps->HubName == NULL)
\r
16155 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16156 return ERR_INVALID_PARAMETER;
\r
16159 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16162 return ERR_INVALID_PARAMETER;
\r
16165 Zero(&t, sizeof(t));
\r
16167 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16168 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16170 ret = ScGetUser(ps->Rpc, &t);
\r
16171 if (ret != ERR_NO_ERROR)
\r
16174 CmdPrintError(c, ret);
\r
16175 FreeParamValueList(o);
\r
16180 FreeAuthData(t.AuthType, t.AuthData);
\r
16185 a = NewRadiusAuthData(GetParamUniStr(o, "ALIAS"));
\r
16187 // NT ドメイン認証に設定する
\r
16188 t.AuthType = AUTHTYPE_NT;
\r
16192 // ユーザーオブジェクトを書き込み
\r
16193 ret = ScSetUser(ps->Rpc, &t);
\r
16195 if (ret != ERR_NO_ERROR)
\r
16198 CmdPrintError(c, ret);
\r
16199 FreeParamValueList(o);
\r
16203 FreeRpcSetUser(&t);
\r
16205 FreeParamValueList(o);
\r
16210 // ユーザーのセキュリティ ポリシーの削除
\r
16211 UINT PsUserPolicyRemove(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16214 PS *ps = (PS *)param;
\r
16217 // 指定できるパラメータ リスト
\r
16220 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16221 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16224 // 仮想 HUB が選択されていない場合はエラー
\r
16225 if (ps->HubName == NULL)
\r
16227 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16228 return ERR_INVALID_PARAMETER;
\r
16231 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16234 return ERR_INVALID_PARAMETER;
\r
16237 Zero(&t, sizeof(t));
\r
16239 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16240 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16242 ret = ScGetUser(ps->Rpc, &t);
\r
16243 if (ret != ERR_NO_ERROR)
\r
16246 CmdPrintError(c, ret);
\r
16247 FreeParamValueList(o);
\r
16252 if (t.Policy != NULL)
\r
16258 // ユーザーオブジェクトを書き込み
\r
16259 ret = ScSetUser(ps->Rpc, &t);
\r
16261 if (ret != ERR_NO_ERROR)
\r
16264 CmdPrintError(c, ret);
\r
16265 FreeParamValueList(o);
\r
16269 FreeRpcSetUser(&t);
\r
16271 FreeParamValueList(o);
\r
16276 // ユーザーのセキュリティ ポリシーの設定
\r
16277 UINT PsUserPolicySet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16280 PS *ps = (PS *)param;
\r
16283 // 指定できるパラメータ リスト
\r
16286 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16287 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16288 {"NAME", CmdPrompt, _UU("CMD_CascadePolicySet_PROMPT_POLNAME"), CmdEvalNotEmpty, NULL},
\r
16289 {"VALUE", CmdPrompt, _UU("CMD_CascadePolicySet_PROMPT_POLVALUE"), CmdEvalNotEmpty, NULL},
\r
16292 // 仮想 HUB が選択されていない場合はエラー
\r
16293 if (ps->HubName == NULL)
\r
16295 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16296 return ERR_INVALID_PARAMETER;
\r
16299 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16302 return ERR_INVALID_PARAMETER;
\r
16305 Zero(&t, sizeof(t));
\r
16307 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16308 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16310 ret = ScGetUser(ps->Rpc, &t);
\r
16311 if (ret != ERR_NO_ERROR)
\r
16314 CmdPrintError(c, ret);
\r
16315 FreeParamValueList(o);
\r
16320 if (t.Policy == NULL)
\r
16322 t.Policy = ClonePolicy(GetDefaultPolicy());
\r
16326 if (EditPolicy(c, t.Policy, GetParamStr(o, "NAME"), GetParamStr(o, "VALUE"), false) == false)
\r
16328 ret = ERR_INVALID_PARAMETER;
\r
16332 // ユーザーオブジェクトを書き込み
\r
16333 ret = ScSetUser(ps->Rpc, &t);
\r
16335 if (ret != ERR_NO_ERROR)
\r
16338 CmdPrintError(c, ret);
\r
16339 FreeParamValueList(o);
\r
16344 FreeRpcSetUser(&t);
\r
16346 FreeParamValueList(o);
\r
16352 UINT64 StrToDateTime64(char *str)
\r
16356 UINT a, b, c, d, e, f;
\r
16363 if (IsEmptyStr(str) || StrCmpi(str, "none") == 0)
\r
16368 t = ParseToken(str, ":/,. \"");
\r
16369 if (t->NumTokens != 6)
\r
16375 a = ToInt(t->Token[0]);
\r
16376 b = ToInt(t->Token[1]);
\r
16377 c = ToInt(t->Token[2]);
\r
16378 d = ToInt(t->Token[3]);
\r
16379 e = ToInt(t->Token[4]);
\r
16380 f = ToInt(t->Token[5]);
\r
16384 if (a >= 1000 && a <= 9999 && b >= 1 && b <= 12 && c >= 1 && c <= 31 &&
\r
16385 d >= 0 && d <= 23 && e >= 0 && e <= 59 && f >= 0 && f <= 59)
\r
16389 Zero(&t, sizeof(t));
\r
16397 ret = SystemToUINT64(&t);
\r
16406 bool CmdEvalDateTime(CONSOLE *c, wchar_t *str, void *param)
\r
16409 char tmp[MAX_SIZE];
\r
16411 if (c == NULL || str == NULL)
\r
16416 UniToStr(tmp, sizeof(tmp), str);
\r
16418 ret = StrToDateTime64(tmp);
\r
16420 if (ret == INFINITE)
\r
16422 c->Write(c, _UU("CMD_EVAL_DATE_TIME_FAILED"));
\r
16430 UINT PsUserExpiresSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16433 PS *ps = (PS *)param;
\r
16437 // 指定できるパラメータ リスト
\r
16440 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16441 {"[name]", CmdPrompt, _UU("CMD_UserCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16442 {"EXPIRES", CmdPrompt, _UU("CMD_UserExpiresSet_Prompt_EXPIRES"), CmdEvalDateTime, NULL},
\r
16445 // 仮想 HUB が選択されていない場合はエラー
\r
16446 if (ps->HubName == NULL)
\r
16448 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16449 return ERR_INVALID_PARAMETER;
\r
16452 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16455 return ERR_INVALID_PARAMETER;
\r
16458 Zero(&t, sizeof(t));
\r
16460 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16461 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16463 ret = ScGetUser(ps->Rpc, &t);
\r
16464 if (ret != ERR_NO_ERROR)
\r
16467 CmdPrintError(c, ret);
\r
16468 FreeParamValueList(o);
\r
16473 expires = StrToDateTime64(GetParamStr(o, "EXPIRES"));
\r
16475 if (expires != 0)
\r
16477 expires = LocalToSystem64(expires);
\r
16480 t.ExpireTime = expires;
\r
16482 // ユーザーオブジェクトを書き込み
\r
16483 ret = ScSetUser(ps->Rpc, &t);
\r
16485 if (ret != ERR_NO_ERROR)
\r
16488 CmdPrintError(c, ret);
\r
16489 FreeParamValueList(o);
\r
16493 FreeRpcSetUser(&t);
\r
16495 FreeParamValueList(o);
\r
16501 UINT PsGroupList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16504 PS *ps = (PS *)param;
\r
16506 RPC_ENUM_GROUP t;
\r
16508 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
16511 return ERR_INVALID_PARAMETER;
\r
16514 // 仮想 HUB が選択されていない場合はエラー
\r
16515 if (ps->HubName == NULL)
\r
16517 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16518 return ERR_INVALID_PARAMETER;
\r
16521 Zero(&t, sizeof(t));
\r
16522 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16525 ret = ScEnumGroup(ps->Rpc, &t);
\r
16527 if (ret != ERR_NO_ERROR)
\r
16530 CmdPrintError(c, ret);
\r
16531 FreeParamValueList(o);
\r
16536 CT *ct = CtNew();
\r
16539 CtInsertColumn(ct, _UU("SM_GROUPLIST_NAME"), false);
\r
16540 CtInsertColumn(ct, _UU("SM_GROUPLIST_REALNAME"), false);
\r
16541 CtInsertColumn(ct, _UU("SM_GROUPLIST_NOTE"), false);
\r
16542 CtInsertColumn(ct, _UU("SM_GROUPLIST_NUMUSERS"), false);
\r
16544 for (i = 0;i < t.NumGroup;i++)
\r
16546 wchar_t tmp1[MAX_SIZE];
\r
16547 wchar_t tmp2[MAX_SIZE];
\r
16548 RPC_ENUM_GROUP_ITEM *e = &t.Groups[i];
\r
16550 StrToUni(tmp1, sizeof(tmp1), e->Name);
\r
16551 UniToStru(tmp2, e->NumUsers);
\r
16553 CtInsert(ct, tmp1, e->Realname, e->Note, tmp2);
\r
16556 CtFreeEx(ct, c, true);
\r
16559 FreeRpcEnumGroup(&t);
\r
16561 FreeParamValueList(o);
\r
16567 UINT PsGroupCreate(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16570 PS *ps = (PS *)param;
\r
16573 // 指定できるパラメータ リスト
\r
16576 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16577 {"[name]", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16578 {"REALNAME", CmdPrompt, _UU("CMD_GroupCreate_Prompt_REALNAME"), NULL, NULL},
\r
16579 {"NOTE", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NOTE"), NULL, NULL},
\r
16582 // 仮想 HUB が選択されていない場合はエラー
\r
16583 if (ps->HubName == NULL)
\r
16585 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16586 return ERR_INVALID_PARAMETER;
\r
16589 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16592 return ERR_INVALID_PARAMETER;
\r
16595 Zero(&t, sizeof(t));
\r
16596 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16597 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16598 UniStrCpy(t.Realname, sizeof(t.Realname), GetParamUniStr(o, "REALNAME"));
\r
16599 UniStrCpy(t.Note, sizeof(t.Note), GetParamUniStr(o, "NOTE"));
\r
16602 ret = ScCreateGroup(ps->Rpc, &t);
\r
16604 if (ret != ERR_NO_ERROR)
\r
16607 CmdPrintError(c, ret);
\r
16608 FreeParamValueList(o);
\r
16612 FreeRpcSetGroup(&t);
\r
16614 FreeParamValueList(o);
\r
16620 UINT PsGroupSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16623 PS *ps = (PS *)param;
\r
16626 // 指定できるパラメータ リスト
\r
16629 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16630 {"[name]", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16631 {"REALNAME", CmdPrompt, _UU("CMD_GroupCreate_Prompt_REALNAME"), NULL, NULL},
\r
16632 {"NOTE", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NOTE"), NULL, NULL},
\r
16635 // 仮想 HUB が選択されていない場合はエラー
\r
16636 if (ps->HubName == NULL)
\r
16638 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16639 return ERR_INVALID_PARAMETER;
\r
16642 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16645 return ERR_INVALID_PARAMETER;
\r
16648 Zero(&t, sizeof(t));
\r
16649 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16650 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16653 ret = ScGetGroup(ps->Rpc, &t);
\r
16655 if (ret != ERR_NO_ERROR)
\r
16658 CmdPrintError(c, ret);
\r
16659 FreeParamValueList(o);
\r
16664 UniStrCpy(t.Realname, sizeof(t.Realname), GetParamUniStr(o, "REALNAME"));
\r
16665 UniStrCpy(t.Note, sizeof(t.Note), GetParamUniStr(o, "NOTE"));
\r
16668 ret = ScSetGroup(ps->Rpc, &t);
\r
16670 if (ret != ERR_NO_ERROR)
\r
16673 CmdPrintError(c, ret);
\r
16674 FreeParamValueList(o);
\r
16678 FreeRpcSetGroup(&t);
\r
16680 FreeParamValueList(o);
\r
16686 UINT PsGroupDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16689 PS *ps = (PS *)param;
\r
16691 RPC_DELETE_USER t;
\r
16692 // 指定できるパラメータ リスト
\r
16695 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16696 {"[name]", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16699 // 仮想 HUB が選択されていない場合はエラー
\r
16700 if (ps->HubName == NULL)
\r
16702 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16703 return ERR_INVALID_PARAMETER;
\r
16706 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16709 return ERR_INVALID_PARAMETER;
\r
16712 Zero(&t, sizeof(t));
\r
16713 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16714 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16717 ret = ScDeleteGroup(ps->Rpc, &t);
\r
16719 if (ret != ERR_NO_ERROR)
\r
16722 CmdPrintError(c, ret);
\r
16723 FreeParamValueList(o);
\r
16727 FreeParamValueList(o);
\r
16732 // グループ情報と所属しているユーザー一覧の取得
\r
16733 UINT PsGroupGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16736 PS *ps = (PS *)param;
\r
16739 // 指定できるパラメータ リスト
\r
16742 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16743 {"[name]", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16746 // 仮想 HUB が選択されていない場合はエラー
\r
16747 if (ps->HubName == NULL)
\r
16749 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16750 return ERR_INVALID_PARAMETER;
\r
16753 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16756 return ERR_INVALID_PARAMETER;
\r
16759 Zero(&t, sizeof(t));
\r
16760 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16761 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16764 ret = ScGetGroup(ps->Rpc, &t);
\r
16766 if (ret != ERR_NO_ERROR)
\r
16769 CmdPrintError(c, ret);
\r
16770 FreeParamValueList(o);
\r
16775 wchar_t tmp[MAX_SIZE];
\r
16776 char groupname[MAX_USERNAME_LEN + 1];
\r
16777 CT *ct = CtNewStandard();
\r
16779 StrCpy(groupname, sizeof(groupname), t.Name);
\r
16781 StrToUni(tmp, sizeof(tmp), t.Name);
\r
16782 CtInsert(ct, _UU("CMD_GroupGet_Column_NAME"), tmp);
\r
16783 CtInsert(ct, _UU("CMD_GroupGet_Column_REALNAME"), t.Realname);
\r
16784 CtInsert(ct, _UU("CMD_GroupGet_Column_NOTE"), t.Note);
\r
16788 if (t.Policy != NULL)
\r
16790 c->Write(c, L"");
\r
16791 c->Write(c, _UU("CMD_GroupGet_Column_POLICY"));
\r
16793 PrintPolicy(c, t.Policy, false);
\r
16800 Zero(&t, sizeof(t));
\r
16802 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16804 if (ScEnumUser(ps->Rpc, &t) == ERR_NO_ERROR)
\r
16808 for (i = 0;i < t.NumUser;i++)
\r
16810 RPC_ENUM_USER_ITEM *u = &t.Users[i];
\r
16812 if (StrCmpi(u->GroupName, groupname) == 0)
\r
16817 c->Write(c, L"");
\r
16818 c->Write(c, _UU("CMD_GroupGet_Column_MEMBERS"));
\r
16821 UniFormat(tmp, sizeof(tmp), L" %S", u->Name);
\r
16822 c->Write(c, tmp);
\r
16825 FreeRpcEnumUser(&t);
\r
16829 c->Write(c, L"");
\r
16836 FreeRpcSetGroup(&t);
\r
16838 FreeParamValueList(o);
\r
16844 UINT PsGroupJoin(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16847 PS *ps = (PS *)param;
\r
16850 // 指定できるパラメータ リスト
\r
16853 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16854 {"[name]", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16855 {"USERNAME", CmdPrompt, _UU("CMD_GroupJoin_Prompt_USERNAME"), CmdEvalNotEmpty, NULL},
\r
16858 // 仮想 HUB が選択されていない場合はエラー
\r
16859 if (ps->HubName == NULL)
\r
16861 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16862 return ERR_INVALID_PARAMETER;
\r
16865 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16868 return ERR_INVALID_PARAMETER;
\r
16871 Zero(&t, sizeof(t));
\r
16872 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16873 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "USERNAME"));
\r
16876 ret = ScGetUser(ps->Rpc, &t);
\r
16878 if (ret != ERR_NO_ERROR)
\r
16881 CmdPrintError(c, ret);
\r
16882 FreeParamValueList(o);
\r
16888 StrCpy(t.GroupName, sizeof(t.GroupName), GetParamStr(o, "[name]"));
\r
16890 ret = ScSetUser(ps->Rpc, &t);
\r
16892 if (ret != ERR_NO_ERROR)
\r
16895 CmdPrintError(c, ret);
\r
16896 FreeParamValueList(o);
\r
16901 FreeRpcSetUser(&t);
\r
16903 FreeParamValueList(o);
\r
16909 UINT PsGroupUnjoin(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16912 PS *ps = (PS *)param;
\r
16915 // 指定できるパラメータ リスト
\r
16918 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16919 {"[name]", CmdPrompt, _UU("CMD_GroupUnjoin_Prompt_name"), CmdEvalNotEmpty, NULL},
\r
16922 // 仮想 HUB が選択されていない場合はエラー
\r
16923 if (ps->HubName == NULL)
\r
16925 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16926 return ERR_INVALID_PARAMETER;
\r
16929 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16932 return ERR_INVALID_PARAMETER;
\r
16935 Zero(&t, sizeof(t));
\r
16936 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
16937 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
16940 ret = ScGetUser(ps->Rpc, &t);
\r
16942 if (ret != ERR_NO_ERROR)
\r
16945 CmdPrintError(c, ret);
\r
16946 FreeParamValueList(o);
\r
16952 StrCpy(t.GroupName, sizeof(t.GroupName), "");
\r
16954 ret = ScSetUser(ps->Rpc, &t);
\r
16956 if (ret != ERR_NO_ERROR)
\r
16959 CmdPrintError(c, ret);
\r
16960 FreeParamValueList(o);
\r
16965 FreeRpcSetUser(&t);
\r
16967 FreeParamValueList(o);
\r
16972 // グループのセキュリティ ポリシーの削除
\r
16973 UINT PsGroupPolicyRemove(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
16976 PS *ps = (PS *)param;
\r
16979 // 指定できるパラメータ リスト
\r
16982 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
16983 {"[name]", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
16986 // 仮想 HUB が選択されていない場合はエラー
\r
16987 if (ps->HubName == NULL)
\r
16989 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
16990 return ERR_INVALID_PARAMETER;
\r
16993 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
16996 return ERR_INVALID_PARAMETER;
\r
16999 Zero(&t, sizeof(t));
\r
17000 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17001 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
17004 ret = ScGetGroup(ps->Rpc, &t);
\r
17006 if (ret != ERR_NO_ERROR)
\r
17009 CmdPrintError(c, ret);
\r
17010 FreeParamValueList(o);
\r
17016 if (t.Policy != NULL)
\r
17022 ret = ScSetGroup(ps->Rpc, &t);
\r
17024 if (ret != ERR_NO_ERROR)
\r
17027 CmdPrintError(c, ret);
\r
17028 FreeParamValueList(o);
\r
17033 FreeRpcSetGroup(&t);
\r
17035 FreeParamValueList(o);
\r
17040 // グループのセキュリティ ポリシーの設定
\r
17041 UINT PsGroupPolicySet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17044 PS *ps = (PS *)param;
\r
17047 // 指定できるパラメータ リスト
\r
17050 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
17051 {"[name]", CmdPrompt, _UU("CMD_GroupCreate_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
17052 {"NAME", CmdPrompt, _UU("CMD_CascadePolicySet_PROMPT_POLNAME"), CmdEvalNotEmpty, NULL},
\r
17053 {"VALUE", CmdPrompt, _UU("CMD_CascadePolicySet_PROMPT_POLVALUE"), CmdEvalNotEmpty, NULL},
\r
17056 // 仮想 HUB が選択されていない場合はエラー
\r
17057 if (ps->HubName == NULL)
\r
17059 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17060 return ERR_INVALID_PARAMETER;
\r
17063 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
17066 return ERR_INVALID_PARAMETER;
\r
17069 Zero(&t, sizeof(t));
\r
17070 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17071 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
17074 ret = ScGetGroup(ps->Rpc, &t);
\r
17076 if (ret != ERR_NO_ERROR)
\r
17079 CmdPrintError(c, ret);
\r
17080 FreeParamValueList(o);
\r
17086 if (t.Policy == NULL)
\r
17088 t.Policy = ClonePolicy(GetDefaultPolicy());
\r
17091 if (EditPolicy(c, t.Policy, GetParamStr(o, "NAME"), GetParamStr(o, "VALUE"), false) == false)
\r
17094 FreeRpcSetGroup(&t);
\r
17095 CmdPrintError(c, ret);
\r
17096 FreeParamValueList(o);
\r
17097 return ERR_INTERNAL_ERROR;
\r
17100 ret = ScSetGroup(ps->Rpc, &t);
\r
17102 if (ret != ERR_NO_ERROR)
\r
17105 CmdPrintError(c, ret);
\r
17106 FreeParamValueList(o);
\r
17111 FreeRpcSetGroup(&t);
\r
17113 FreeParamValueList(o);
\r
17118 // 接続中のセッション一覧の取得
\r
17119 UINT PsSessionList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17122 PS *ps = (PS *)param;
\r
17124 RPC_ENUM_SESSION t;
\r
17125 UINT server_type = 0;
\r
17127 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
17130 return ERR_INVALID_PARAMETER;
\r
17133 // 仮想 HUB が選択されていない場合はエラー
\r
17134 if (ps->HubName == NULL)
\r
17136 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17137 return ERR_INVALID_PARAMETER;
\r
17142 RPC_SERVER_INFO t;
\r
17144 Zero(&t, sizeof(t));
\r
17146 if (ScGetServerInfo(ps->Rpc, &t) == ERR_NO_ERROR)
\r
17148 server_type = t.ServerType;
\r
17150 FreeRpcServerInfo(&t);
\r
17154 Zero(&t, sizeof(t));
\r
17155 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17158 ret = ScEnumSession(ps->Rpc, &t);
\r
17160 if (ret != ERR_NO_ERROR)
\r
17163 CmdPrintError(c, ret);
\r
17164 FreeParamValueList(o);
\r
17169 CT *ct = CtNew();
\r
17172 CtInsertColumn(ct, _UU("SM_SESS_COLUMN_1"), false);
\r
17173 CtInsertColumn(ct, _UU("SM_SESS_COLUMN_8"), false);
\r
17174 CtInsertColumn(ct, _UU("SM_SESS_COLUMN_2"), false);
\r
17175 CtInsertColumn(ct, _UU("SM_SESS_COLUMN_3"), false);
\r
17176 CtInsertColumn(ct, _UU("SM_SESS_COLUMN_4"), false);
\r
17177 CtInsertColumn(ct, _UU("SM_SESS_COLUMN_5"), true);
\r
17178 CtInsertColumn(ct, _UU("SM_SESS_COLUMN_6"), true);
\r
17179 CtInsertColumn(ct, _UU("SM_SESS_COLUMN_7"), true);
\r
17181 for (i = 0;i < t.NumSession;i++)
\r
17183 RPC_ENUM_SESSION_ITEM *e = &t.Sessions[i];
\r
17184 wchar_t tmp1[MAX_SIZE];
\r
17186 wchar_t tmp3[MAX_SIZE];
\r
17187 wchar_t tmp4[MAX_SIZE];
\r
17188 wchar_t tmp5[MAX_SIZE];
\r
17189 wchar_t tmp6[MAX_SIZE];
\r
17190 wchar_t tmp7[MAX_SIZE];
\r
17191 wchar_t tmp8[MAX_SIZE];
\r
17192 bool free_tmp2 = false;
\r
17194 StrToUni(tmp1, sizeof(tmp1), e->Name);
\r
17196 tmp2 = _UU("SM_SESS_NORMAL");
\r
17197 if (server_type != SERVER_TYPE_STANDALONE)
\r
17199 if (e->RemoteSession)
\r
17201 tmp2 = ZeroMalloc(MAX_SIZE);
\r
17202 UniFormat(tmp2, MAX_SIZE, _UU("SM_SESS_REMOTE"), e->RemoteHostname);
\r
17203 free_tmp2 = true;
\r
17207 if (StrLen(e->RemoteHostname) == 0)
\r
17209 tmp2 = _UU("SM_SESS_LOCAL");
\r
17213 tmp2 = ZeroMalloc(MAX_SIZE);
\r
17214 UniFormat(tmp2, MAX_SIZE, _UU("SM_SESS_LOCAL_2"), e->RemoteHostname);
\r
17215 free_tmp2 = true;
\r
17224 free_tmp2 = false;
\r
17226 tmp2 = _UU("SM_SESS_LINK");
\r
17228 else if (e->SecureNATMode)
\r
17233 free_tmp2 = false;
\r
17235 tmp2 = _UU("SM_SESS_SNAT");
\r
17238 StrToUni(tmp3, sizeof(tmp3), e->Username);
\r
17240 StrToUni(tmp4, sizeof(tmp4), e->Hostname);
\r
17243 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_SESS_LINK_HOSTNAME"));
\r
17245 else if (e->SecureNATMode)
\r
17247 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_SESS_SNAT_HOSTNAME"));
\r
17249 else if (e->BridgeMode)
\r
17251 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_SESS_BRIDGE_HOSTNAME"));
\r
17253 else if (StartWith(e->Username, L3_USERNAME))
\r
17255 UniStrCpy(tmp4, sizeof(tmp4), _UU("SM_SESS_LAYER3_HOSTNAME"));
\r
17258 UniFormat(tmp5, sizeof(tmp5), L"%u / %u", e->CurrentNumTcp, e->MaxNumTcp);
\r
17261 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_SESS_LINK_TCP"));
\r
17263 else if (e->SecureNATMode)
\r
17265 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_SESS_SNAT_TCP"));
\r
17267 else if (e->BridgeMode)
\r
17269 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_SESS_BRIDGE_TCP"));
\r
17272 UniToStr3(tmp6, sizeof(tmp6), e->PacketSize);
\r
17273 UniToStr3(tmp7, sizeof(tmp7), e->PacketNum);
\r
17275 if (e->VLanId == 0)
\r
17277 UniStrCpy(tmp8, sizeof(tmp8), _UU("CM_ST_NO_VLAN"));
\r
17281 UniToStru(tmp8, e->VLanId);
\r
17284 CtInsert(ct, tmp1, tmp8, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7);
\r
17293 CtFreeEx(ct, c, true);
\r
17296 FreeRpcEnumSession(&t);
\r
17298 FreeParamValueList(o);
\r
17304 void CmdPrintNodeInfo(CT *ct, NODE_INFO *info)
\r
17306 wchar_t tmp[MAX_SIZE];
\r
17307 char str[MAX_SIZE];
\r
17309 if (ct == NULL || info == NULL)
\r
17314 StrToUni(tmp, sizeof(tmp), info->ClientProductName);
\r
17315 CtInsert(ct, _UU("SM_NODE_CLIENT_NAME"), tmp);
\r
17317 UniFormat(tmp, sizeof(tmp), L"%u.%02u", Endian32(info->ClientProductVer) / 100, Endian32(info->ClientProductVer) % 100);
\r
17318 CtInsert(ct, _UU("SM_NODE_CLIENT_VER"), tmp);
\r
17320 UniFormat(tmp, sizeof(tmp), L"Build %u", Endian32(info->ClientProductBuild));
\r
17321 CtInsert(ct, _UU("SM_NODE_CLIENT_BUILD"), tmp);
\r
17323 StrToUni(tmp, sizeof(tmp), info->ClientOsName);
\r
17324 CtInsert(ct, _UU("SM_NODE_CLIENT_OS_NAME"), tmp);
\r
17326 StrToUni(tmp, sizeof(tmp), info->ClientOsVer);
\r
17327 CtInsert(ct, _UU("SM_NODE_CLIENT_OS_VER"), tmp);
\r
17329 StrToUni(tmp, sizeof(tmp), info->ClientOsProductId);
\r
17330 CtInsert(ct, _UU("SM_NODE_CLIENT_OS_PID"), tmp);
\r
17332 StrToUni(tmp, sizeof(tmp), info->ClientHostname);
\r
17333 CtInsert(ct, _UU("SM_NODE_CLIENT_HOST"), tmp);
\r
17335 IPToStr4or6(str, sizeof(str), info->ClientIpAddress, info->ClientIpAddress6);
\r
17336 StrToUni(tmp, sizeof(tmp), str);
\r
17337 CtInsert(ct, _UU("SM_NODE_CLIENT_IP"), tmp);
\r
17339 UniToStru(tmp, Endian32(info->ClientPort));
\r
17340 CtInsert(ct, _UU("SM_NODE_CLIENT_PORT"), tmp);
\r
17342 StrToUni(tmp, sizeof(tmp), info->ServerHostname);
\r
17343 CtInsert(ct, _UU("SM_NODE_SERVER_HOST"), tmp);
\r
17345 IPToStr4or6(str, sizeof(str), info->ServerIpAddress, info->ServerIpAddress6);
\r
17346 StrToUni(tmp, sizeof(tmp), str);
\r
17347 CtInsert(ct, _UU("SM_NODE_SERVER_IP"), tmp);
\r
17349 UniToStru(tmp, Endian32(info->ServerPort));
\r
17350 CtInsert(ct, _UU("SM_NODE_SERVER_PORT"), tmp);
\r
17352 if (StrLen(info->ProxyHostname) != 0)
\r
17354 StrToUni(tmp, sizeof(tmp), info->ProxyHostname);
\r
17355 CtInsert(ct, _UU("SM_NODE_PROXY_HOSTNAME"), tmp);
\r
17357 IPToStr4or6(str, sizeof(str), info->ProxyIpAddress, info->ProxyIpAddress6);
\r
17358 StrToUni(tmp, sizeof(tmp), str);
\r
17359 CtInsert(ct, _UU("SM_NODE_PROXY_IP"), tmp);
\r
17361 UniToStru(tmp, Endian32(info->ProxyPort));
\r
17362 CtInsert(ct, _UU("SM_NODE_PROXY_PORT"), tmp);
\r
17367 UINT PsSessionGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17370 PS *ps = (PS *)param;
\r
17372 RPC_SESSION_STATUS t;
\r
17373 // 指定できるパラメータ リスト
\r
17376 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
17377 {"[name]", CmdPrompt, _UU("CMD_SessionGet_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
17380 // 仮想 HUB が選択されていない場合はエラー
\r
17381 if (ps->HubName == NULL)
\r
17383 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17384 return ERR_INVALID_PARAMETER;
\r
17387 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
17390 return ERR_INVALID_PARAMETER;
\r
17393 Zero(&t, sizeof(t));
\r
17394 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17395 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
17398 ret = ScGetSessionStatus(ps->Rpc, &t);
\r
17400 if (ret != ERR_NO_ERROR)
\r
17403 CmdPrintError(c, ret);
\r
17404 FreeParamValueList(o);
\r
17409 wchar_t tmp[MAX_SIZE];
\r
17410 char str[MAX_SIZE];
\r
17411 CT *ct = CtNewStandard();
\r
17413 if (t.ClientIp != 0)
\r
17415 IPToStr4or6(str, sizeof(str), t.ClientIp, t.ClientIp6);
\r
17416 StrToUni(tmp, sizeof(tmp), str);
\r
17417 CtInsert(ct, _UU("SM_CLIENT_IP"), tmp);
\r
17420 if (StrLen(t.ClientHostName) != 0)
\r
17422 StrToUni(tmp, sizeof(tmp), t.ClientHostName);
\r
17423 CtInsert(ct, _UU("SM_CLIENT_HOSTNAME"), tmp);
\r
17426 StrToUni(tmp, sizeof(tmp), t.Username);
\r
17427 CtInsert(ct, _UU("SM_SESS_STATUS_USERNAME"), tmp);
\r
17429 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)
\r
17431 StrToUni(tmp, sizeof(tmp), t.RealUsername);
\r
17432 CtInsert(ct, _UU("SM_SESS_STATUS_REALUSER"), tmp);
\r
17435 if (IsEmptyStr(t.GroupName) == false)
\r
17437 StrToUni(tmp, sizeof(tmp), t.GroupName);
\r
17438 CtInsert(ct, _UU("SM_SESS_STATUS_GROUPNAME"), tmp);
\r
17442 CmdPrintStatusToListViewEx(ct, &t.Status, true);
\r
17444 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 &&
\r
17445 StartWith(t.Username, L3_USERNAME) == false)
\r
17447 CmdPrintNodeInfo(ct, &t.NodeInfo);
\r
17453 FreeRpcSessionStatus(&t);
\r
17455 FreeParamValueList(o);
\r
17461 UINT PsSessionDisconnect(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17464 PS *ps = (PS *)param;
\r
17466 RPC_DELETE_SESSION t;
\r
17467 // 指定できるパラメータ リスト
\r
17470 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
17471 {"[name]", CmdPrompt, _UU("CMD_SessionGet_Prompt_NAME"), CmdEvalNotEmpty, NULL},
\r
17474 // 仮想 HUB が選択されていない場合はエラー
\r
17475 if (ps->HubName == NULL)
\r
17477 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17478 return ERR_INVALID_PARAMETER;
\r
17481 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
17484 return ERR_INVALID_PARAMETER;
\r
17487 Zero(&t, sizeof(t));
\r
17488 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17489 StrCpy(t.Name, sizeof(t.Name), GetParamStr(o, "[name]"));
\r
17492 ret = ScDeleteSession(ps->Rpc, &t);
\r
17494 if (ret != ERR_NO_ERROR)
\r
17497 CmdPrintError(c, ret);
\r
17498 FreeParamValueList(o);
\r
17502 FreeParamValueList(o);
\r
17507 // MAC アドレス テーブル データベースの取得
\r
17508 UINT PsMacTable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17511 PS *ps = (PS *)param;
\r
17513 RPC_ENUM_MAC_TABLE t;
\r
17516 // 指定できるパラメータ リスト
\r
17519 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
17520 {"[session_name]", NULL, NULL, NULL, NULL,}
\r
17523 // 仮想 HUB が選択されていない場合はエラー
\r
17524 if (ps->HubName == NULL)
\r
17526 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17527 return ERR_INVALID_PARAMETER;
\r
17530 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
17533 return ERR_INVALID_PARAMETER;
\r
17536 Zero(&t, sizeof(t));
\r
17537 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17540 ret = ScEnumMacTable(ps->Rpc, &t);
\r
17542 if (ret != ERR_NO_ERROR)
\r
17545 CmdPrintError(c, ret);
\r
17546 FreeParamValueList(o);
\r
17551 CT *ct = CtNew();
\r
17552 char *session_name = GetParamStr(o, "[session_name]");
\r
17554 if (IsEmptyStr(session_name))
\r
17556 session_name = NULL;
\r
17559 CtInsertColumn(ct, _UU("CMD_ID"), false);
\r
17560 CtInsertColumn(ct, _UU("SM_MAC_COLUMN_1"), false);
\r
17561 CtInsertColumn(ct, _UU("SM_MAC_COLUMN_1A"), false);
\r
17562 CtInsertColumn(ct, _UU("SM_MAC_COLUMN_2"), false);
\r
17563 CtInsertColumn(ct, _UU("SM_MAC_COLUMN_3"), false);
\r
17564 CtInsertColumn(ct, _UU("SM_MAC_COLUMN_4"), false);
\r
17565 CtInsertColumn(ct, _UU("SM_MAC_COLUMN_5"), false);
\r
17567 for (i = 0;i < t.NumMacTable;i++)
\r
17569 char str[MAX_SIZE];
\r
17570 wchar_t tmp0[128];
\r
17571 wchar_t tmp1[MAX_SIZE];
\r
17572 wchar_t tmp2[MAX_SIZE];
\r
17573 wchar_t tmp3[MAX_SIZE];
\r
17574 wchar_t tmp4[MAX_SIZE];
\r
17575 wchar_t tmp5[MAX_SIZE];
\r
17576 wchar_t tmp6[MAX_SIZE];
\r
17578 RPC_ENUM_MAC_TABLE_ITEM *e = &t.MacTables[i];
\r
17580 if (session_name == NULL || StrCmpi(e->SessionName, session_name) == 0)
\r
17582 UniToStru(tmp0, e->Key);
\r
17584 StrToUni(tmp1, sizeof(tmp1), e->SessionName);
\r
17586 MacToStr(str, sizeof(str), e->MacAddress);
\r
17587 StrToUni(tmp2, sizeof(tmp2), str);
\r
17589 GetDateTimeStr64Uni(tmp3, sizeof(tmp3), SystemToLocal64(e->CreatedTime));
\r
17591 GetDateTimeStr64Uni(tmp4, sizeof(tmp4), SystemToLocal64(e->UpdatedTime));
\r
17593 if (StrLen(e->RemoteHostname) == 0)
\r
17595 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_MACIP_LOCAL"));
\r
17599 UniFormat(tmp5, sizeof(tmp5), _UU("SM_MACIP_SERVER"), e->RemoteHostname);
\r
17602 UniToStru(tmp6, e->VlanId);
\r
17603 if (e->VlanId == 0)
\r
17605 UniStrCpy(tmp6, sizeof(tmp6), _UU("CM_ST_NONE"));
\r
17609 tmp0, tmp1, tmp6, tmp2, tmp3, tmp4, tmp5);
\r
17613 CtFreeEx(ct, c, true);
\r
17616 FreeRpcEnumMacTable(&t);
\r
17618 FreeParamValueList(o);
\r
17623 // MAC アドレス テーブル エントリの削除
\r
17624 UINT PsMacDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17627 PS *ps = (PS *)param;
\r
17629 RPC_DELETE_TABLE t;
\r
17630 // 指定できるパラメータ リスト
\r
17633 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
17634 {"[id]", CmdPrompt, _UU("CMD_MacDelete_Prompt"), CmdEvalNotEmpty, NULL},
\r
17637 // 仮想 HUB が選択されていない場合はエラー
\r
17638 if (ps->HubName == NULL)
\r
17640 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17641 return ERR_INVALID_PARAMETER;
\r
17644 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
17647 return ERR_INVALID_PARAMETER;
\r
17650 Zero(&t, sizeof(t));
\r
17651 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17652 t.Key = GetParamInt(o, "[id]");
\r
17655 ret = ScDeleteMacTable(ps->Rpc, &t);
\r
17657 if (ret != ERR_NO_ERROR)
\r
17660 CmdPrintError(c, ret);
\r
17661 FreeParamValueList(o);
\r
17665 FreeParamValueList(o);
\r
17670 // IP アドレス テーブル データベースの取得
\r
17671 UINT PsIpTable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17674 PS *ps = (PS *)param;
\r
17676 RPC_ENUM_IP_TABLE t;
\r
17679 // 指定できるパラメータ リスト
\r
17682 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
17683 {"[session_name]", NULL, NULL, NULL, NULL,}
\r
17686 // 仮想 HUB が選択されていない場合はエラー
\r
17687 if (ps->HubName == NULL)
\r
17689 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17690 return ERR_INVALID_PARAMETER;
\r
17693 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
17696 return ERR_INVALID_PARAMETER;
\r
17699 Zero(&t, sizeof(t));
\r
17700 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17703 ret = ScEnumIpTable(ps->Rpc, &t);
\r
17705 if (ret != ERR_NO_ERROR)
\r
17708 CmdPrintError(c, ret);
\r
17709 FreeParamValueList(o);
\r
17714 CT *ct = CtNew();
\r
17715 char *session_name = GetParamStr(o, "[session_name]");
\r
17717 if (IsEmptyStr(session_name))
\r
17719 session_name = NULL;
\r
17722 CtInsertColumn(ct, _UU("CMD_ID"), false);
\r
17723 CtInsertColumn(ct, _UU("SM_IP_COLUMN_1"), false);
\r
17724 CtInsertColumn(ct, _UU("SM_IP_COLUMN_2"), false);
\r
17725 CtInsertColumn(ct, _UU("SM_IP_COLUMN_3"), false);
\r
17726 CtInsertColumn(ct, _UU("SM_IP_COLUMN_4"), false);
\r
17727 CtInsertColumn(ct, _UU("SM_IP_COLUMN_5"), false);
\r
17729 for (i = 0;i < t.NumIpTable;i++)
\r
17731 char str[MAX_SIZE];
\r
17732 wchar_t tmp0[128];
\r
17733 wchar_t tmp1[MAX_SIZE];
\r
17734 wchar_t tmp2[MAX_SIZE];
\r
17735 wchar_t tmp3[MAX_SIZE];
\r
17736 wchar_t tmp4[MAX_SIZE];
\r
17737 wchar_t tmp5[MAX_SIZE];
\r
17738 RPC_ENUM_IP_TABLE_ITEM *e = &t.IpTables[i];
\r
17740 if (session_name == NULL || StrCmpi(e->SessionName, session_name) == 0)
\r
17742 UniToStru(tmp0, e->Key);
\r
17744 StrToUni(tmp1, sizeof(tmp1), e->SessionName);
\r
17746 if (e->DhcpAllocated == false)
\r
17748 IPToStr(str, sizeof(str), &e->IpV6);
\r
17749 StrToUni(tmp2, sizeof(tmp2), str);
\r
17753 IPToStr(str, sizeof(str), &e->IpV6);
\r
17754 UniFormat(tmp2, sizeof(tmp2), _UU("SM_MAC_IP_DHCP"), str);
\r
17757 GetDateTimeStr64Uni(tmp3, sizeof(tmp3), SystemToLocal64(e->CreatedTime));
\r
17759 GetDateTimeStr64Uni(tmp4, sizeof(tmp4), SystemToLocal64(e->UpdatedTime));
\r
17761 if (StrLen(e->RemoteHostname) == 0)
\r
17763 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_MACIP_LOCAL"));
\r
17767 UniFormat(tmp5, sizeof(tmp5), _UU("SM_MACIP_SERVER"), e->RemoteHostname);
\r
17771 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5);
\r
17775 CtFreeEx(ct, c, true);
\r
17778 FreeRpcEnumIpTable(&t);
\r
17780 FreeParamValueList(o);
\r
17785 // IP アドレス テーブル エントリの削除
\r
17786 UINT PsIpDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17789 PS *ps = (PS *)param;
\r
17791 RPC_DELETE_TABLE t;
\r
17792 // 指定できるパラメータ リスト
\r
17795 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
17796 {"[id]", CmdPrompt, _UU("CMD_MacDelete_Prompt"), CmdEvalNotEmpty, NULL},
\r
17799 // 仮想 HUB が選択されていない場合はエラー
\r
17800 if (ps->HubName == NULL)
\r
17802 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17803 return ERR_INVALID_PARAMETER;
\r
17806 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
17809 return ERR_INVALID_PARAMETER;
\r
17812 Zero(&t, sizeof(t));
\r
17813 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17814 t.Key = GetParamInt(o, "[id]");
\r
17817 ret = ScDeleteIpTable(ps->Rpc, &t);
\r
17819 if (ret != ERR_NO_ERROR)
\r
17822 CmdPrintError(c, ret);
\r
17823 FreeParamValueList(o);
\r
17827 FreeParamValueList(o);
\r
17832 // 仮想 NAT および DHCP サーバー機能 (SecureNAT 機能) の有効化
\r
17833 UINT PsSecureNatEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17836 PS *ps = (PS *)param;
\r
17840 // 仮想 HUB が選択されていない場合はエラー
\r
17841 if (ps->HubName == NULL)
\r
17843 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17844 return ERR_INVALID_PARAMETER;
\r
17847 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
17850 return ERR_INVALID_PARAMETER;
\r
17853 Zero(&t, sizeof(t));
\r
17854 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17857 ret = ScEnableSecureNAT(ps->Rpc, &t);
\r
17859 if (ret != ERR_NO_ERROR)
\r
17862 CmdPrintError(c, ret);
\r
17863 FreeParamValueList(o);
\r
17867 FreeParamValueList(o);
\r
17872 // 仮想 NAT および DHCP サーバー機能 (SecureNAT 機能) の無効化
\r
17873 UINT PsSecureNatDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17876 PS *ps = (PS *)param;
\r
17880 // 仮想 HUB が選択されていない場合はエラー
\r
17881 if (ps->HubName == NULL)
\r
17883 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17884 return ERR_INVALID_PARAMETER;
\r
17887 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
17890 return ERR_INVALID_PARAMETER;
\r
17893 Zero(&t, sizeof(t));
\r
17894 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17897 ret = ScDisableSecureNAT(ps->Rpc, &t);
\r
17899 if (ret != ERR_NO_ERROR)
\r
17902 CmdPrintError(c, ret);
\r
17903 FreeParamValueList(o);
\r
17907 FreeParamValueList(o);
\r
17912 // 仮想 NAT および DHCP サーバー機能 (SecureNAT 機能) の動作状況の取得
\r
17913 UINT PsSecureNatStatusGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17916 PS *ps = (PS *)param;
\r
17918 RPC_NAT_STATUS t;
\r
17920 // 仮想 HUB が選択されていない場合はエラー
\r
17921 if (ps->HubName == NULL)
\r
17923 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17924 return ERR_INVALID_PARAMETER;
\r
17927 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
17930 return ERR_INVALID_PARAMETER;
\r
17933 Zero(&t, sizeof(t));
\r
17934 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17937 ret = ScGetSecureNATStatus(ps->Rpc, &t);
\r
17939 if (ret != ERR_NO_ERROR)
\r
17942 CmdPrintError(c, ret);
\r
17943 FreeParamValueList(o);
\r
17948 wchar_t tmp[MAX_SIZE];
\r
17949 CT *ct = CtNewStandard();
\r
17951 StrToUni(tmp, sizeof(tmp), ps->HubName);
\r
17952 CtInsert(ct, _UU("SM_HUB_COLUMN_1"), tmp);
\r
17954 UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumTcpSessions);
\r
17955 CtInsert(ct, _UU("NM_STATUS_TCP"), tmp);
\r
17957 UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_SESSION"), t.NumUdpSessions);
\r
17958 CtInsert(ct, _UU("NM_STATUS_UDP"), tmp);
\r
17960 UniFormat(tmp, sizeof(tmp), _UU("SM_SNAT_NUM_CLIENT"), t.NumDhcpClients);
\r
17961 CtInsert(ct, _UU("NM_STATUS_DHCP"), tmp);
\r
17966 FreeRpcNatStatus(&t);
\r
17968 FreeParamValueList(o);
\r
17973 // SecureNAT 機能の仮想ホストのネットワーク インターフェイス設定の取得
\r
17974 UINT PsSecureNatHostGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
17977 PS *ps = (PS *)param;
\r
17981 // 仮想 HUB が選択されていない場合はエラー
\r
17982 if (ps->HubName == NULL)
\r
17984 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
17985 return ERR_INVALID_PARAMETER;
\r
17988 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
17991 return ERR_INVALID_PARAMETER;
\r
17994 Zero(&t, sizeof(t));
\r
17995 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
17998 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18000 if (ret != ERR_NO_ERROR)
\r
18003 CmdPrintError(c, ret);
\r
18004 FreeParamValueList(o);
\r
18009 wchar_t tmp[MAX_SIZE];
\r
18010 char str[MAX_SIZE];
\r
18011 CT *ct = CtNewStandard();
\r
18015 MacToStr(str, sizeof(str), t.MacAddress);
\r
18016 StrToUni(tmp, sizeof(tmp), str);
\r
18017 CtInsert(ct, _UU("CMD_SecureNatHostGet_Column_MAC"), tmp);
\r
18020 IPToUniStr(tmp, sizeof(tmp), &t.Ip);
\r
18021 CtInsert(ct, _UU("CMD_SecureNatHostGet_Column_IP"), tmp);
\r
18024 IPToUniStr(tmp, sizeof(tmp), &t.Mask);
\r
18025 CtInsert(ct, _UU("CMD_SecureNatHostGet_Column_MASK"), tmp);
\r
18030 FreeParamValueList(o);
\r
18035 // SecureNAT 機能の仮想ホストのネットワーク インターフェイス設定の変更
\r
18036 UINT PsSecureNatHostSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18039 PS *ps = (PS *)param;
\r
18042 // 指定できるパラメータ リスト
\r
18045 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
18046 {"MAC", CmdPrompt, _UU("CMD_SecureNatHostSet_Prompt_MAC"), NULL, NULL},
\r
18047 {"IP", CmdPrompt, _UU("CMD_SecureNatHostSet_Prompt_IP"), CmdEvalIp, NULL},
\r
18048 {"MASK", CmdPrompt, _UU("CMD_SecureNatHostSet_Prompt_MASK"), CmdEvalIp, NULL},
\r
18051 // 仮想 HUB が選択されていない場合はエラー
\r
18052 if (ps->HubName == NULL)
\r
18054 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18055 return ERR_INVALID_PARAMETER;
\r
18058 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
18061 return ERR_INVALID_PARAMETER;
\r
18064 Zero(&t, sizeof(t));
\r
18065 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18068 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18070 if (ret != ERR_NO_ERROR)
\r
18073 CmdPrintError(c, ret);
\r
18074 FreeParamValueList(o);
\r
18079 char *mac, *ip, *mask;
\r
18082 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18084 mac = GetParamStr(o, "MAC");
\r
18085 ip = GetParamStr(o, "IP");
\r
18086 mask = GetParamStr(o, "MASK");
\r
18088 if (IsEmptyStr(mac) == false)
\r
18090 BUF *b = StrToBin(mac);
\r
18092 if (b == NULL || b->Size != 6)
\r
18098 Copy(t.MacAddress, b->Buf, 6);
\r
18104 if (IsEmptyStr(ip) == false)
\r
18106 if (IsIpStr4(ip) == false)
\r
18112 UINT u = StrToIP32(ip);
\r
18114 if (u == 0 || u == 0xffffffff)
\r
18120 UINTToIP(&t.Ip, u);
\r
18125 if (IsEmptyStr(mask) == false)
\r
18127 if (IsIpStr4(mask) == false)
\r
18133 StrToIP(&t.Mask, mask);
\r
18140 ret = ERR_INVALID_PARAMETER;
\r
18141 CmdPrintError(c, ret);
\r
18142 FreeParamValueList(o);
\r
18147 ret = ScSetSecureNATOption(ps->Rpc, &t);
\r
18149 if (ret != ERR_NO_ERROR)
\r
18152 CmdPrintError(c, ret);
\r
18153 FreeParamValueList(o);
\r
18159 FreeParamValueList(o);
\r
18164 // SecureNAT 機能の仮想 NAT 機能の設定の取得
\r
18165 UINT PsNatGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18168 PS *ps = (PS *)param;
\r
18172 // 仮想 HUB が選択されていない場合はエラー
\r
18173 if (ps->HubName == NULL)
\r
18175 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18176 return ERR_INVALID_PARAMETER;
\r
18179 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
18182 return ERR_INVALID_PARAMETER;
\r
18185 Zero(&t, sizeof(t));
\r
18186 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18189 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18191 if (ret != ERR_NO_ERROR)
\r
18194 CmdPrintError(c, ret);
\r
18195 FreeParamValueList(o);
\r
18200 wchar_t tmp[MAX_SIZE];
\r
18201 CT *ct = CtNewStandard();
\r
18203 // 仮想 NAT 機能を使用する
\r
18204 CtInsert(ct, _UU("CMD_NatGet_Column_USE"), t.UseNat ? _UU("SEC_YES") : _UU("SEC_NO"));
\r
18207 UniToStru(tmp, t.Mtu);
\r
18208 CtInsert(ct, _UU("CMD_NetGet_Column_MTU"), tmp);
\r
18210 // TCP セッションのタイムアウト (秒)
\r
18211 UniToStru(tmp, t.NatTcpTimeout);
\r
18212 CtInsert(ct, _UU("CMD_NatGet_Column_TCP"), tmp);
\r
18214 // UDP セッションのタイムアウト (秒)
\r
18215 UniToStru(tmp, t.NatUdpTimeout);
\r
18216 CtInsert(ct, _UU("CMD_NatGet_Column_UDP"), tmp);
\r
18219 CtInsert(ct, _UU("CMD_SecureNatHostGet_Column_LOG"), t.SaveLog ? _UU("SEC_YES") : _UU("SEC_NO"));
\r
18224 FreeParamValueList(o);
\r
18229 // SecureNAT 機能の仮想 NAT 機能の有効化
\r
18230 UINT PsNatEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18233 PS *ps = (PS *)param;
\r
18237 // 仮想 HUB が選択されていない場合はエラー
\r
18238 if (ps->HubName == NULL)
\r
18240 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18241 return ERR_INVALID_PARAMETER;
\r
18244 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
18247 return ERR_INVALID_PARAMETER;
\r
18250 Zero(&t, sizeof(t));
\r
18251 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18254 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18256 if (ret != ERR_NO_ERROR)
\r
18259 CmdPrintError(c, ret);
\r
18260 FreeParamValueList(o);
\r
18272 ret = ERR_INVALID_PARAMETER;
\r
18273 CmdPrintError(c, ret);
\r
18274 FreeParamValueList(o);
\r
18279 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18280 ret = ScSetSecureNATOption(ps->Rpc, &t);
\r
18282 if (ret != ERR_NO_ERROR)
\r
18285 CmdPrintError(c, ret);
\r
18286 FreeParamValueList(o);
\r
18292 FreeParamValueList(o);
\r
18297 // SecureNAT 機能の仮想 NAT 機能の無効化
\r
18298 UINT PsNatDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18301 PS *ps = (PS *)param;
\r
18305 // 仮想 HUB が選択されていない場合はエラー
\r
18306 if (ps->HubName == NULL)
\r
18308 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18309 return ERR_INVALID_PARAMETER;
\r
18312 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
18315 return ERR_INVALID_PARAMETER;
\r
18318 Zero(&t, sizeof(t));
\r
18319 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18322 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18324 if (ret != ERR_NO_ERROR)
\r
18327 CmdPrintError(c, ret);
\r
18328 FreeParamValueList(o);
\r
18335 t.UseNat = false;
\r
18340 ret = ERR_INVALID_PARAMETER;
\r
18341 CmdPrintError(c, ret);
\r
18342 FreeParamValueList(o);
\r
18347 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18348 ret = ScSetSecureNATOption(ps->Rpc, &t);
\r
18350 if (ret != ERR_NO_ERROR)
\r
18353 CmdPrintError(c, ret);
\r
18354 FreeParamValueList(o);
\r
18360 FreeParamValueList(o);
\r
18365 // SecureNAT 機能の仮想 NAT 機能の設定の変更
\r
18366 UINT PsNatSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18369 PS *ps = (PS *)param;
\r
18372 // 指定できるパラメータ リスト
\r
18373 CMD_EVAL_MIN_MAX mtu_mm =
\r
18375 "CMD_NatSet_Eval_MTU", TCP_HEADER_SIZE + IP_HEADER_SIZE + MAC_HEADER_SIZE + 8, MAX_L3_DATA_SIZE,
\r
18377 CMD_EVAL_MIN_MAX tcp_mm =
\r
18379 "CMD_NatSet_Eval_TCP", NAT_TCP_MIN_TIMEOUT / 1000, NAT_TCP_MAX_TIMEOUT / 1000,
\r
18381 CMD_EVAL_MIN_MAX udp_mm =
\r
18383 "CMD_NatSet_Eval_UDP", NAT_UDP_MIN_TIMEOUT / 1000, NAT_UDP_MAX_TIMEOUT / 1000,
\r
18387 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
18388 {"MTU", CmdPrompt, _UU("CMD_NatSet_Prompt_MTU"), CmdEvalMinMax, &mtu_mm},
\r
18389 {"TCPTIMEOUT", CmdPrompt, _UU("CMD_NatSet_Prompt_TCPTIMEOUT"), CmdEvalMinMax, &tcp_mm},
\r
18390 {"UDPTIMEOUT", CmdPrompt, _UU("CMD_NatSet_Prompt_UDPTIMEOUT"), CmdEvalMinMax, &udp_mm},
\r
18391 {"LOG", CmdPrompt, _UU("CMD_NatSet_Prompt_LOG"), CmdEvalNotEmpty, NULL},
\r
18394 // 仮想 HUB が選択されていない場合はエラー
\r
18395 if (ps->HubName == NULL)
\r
18397 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18398 return ERR_INVALID_PARAMETER;
\r
18401 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
18404 return ERR_INVALID_PARAMETER;
\r
18407 Zero(&t, sizeof(t));
\r
18408 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18411 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18413 if (ret != ERR_NO_ERROR)
\r
18416 CmdPrintError(c, ret);
\r
18417 FreeParamValueList(o);
\r
18424 t.Mtu = GetParamInt(o, "MTU");
\r
18425 t.NatTcpTimeout = GetParamInt(o, "TCPTIMEOUT");
\r
18426 t.NatUdpTimeout = GetParamInt(o, "UDPTIMEOUT");
\r
18427 t.SaveLog = GetParamYes(o, "LOG");
\r
18432 ret = ERR_INVALID_PARAMETER;
\r
18433 CmdPrintError(c, ret);
\r
18434 FreeParamValueList(o);
\r
18439 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18440 ret = ScSetSecureNATOption(ps->Rpc, &t);
\r
18442 if (ret != ERR_NO_ERROR)
\r
18445 CmdPrintError(c, ret);
\r
18446 FreeParamValueList(o);
\r
18452 FreeParamValueList(o);
\r
18457 // SecureNAT 機能の仮想 NAT 機能のセッション テーブルの取得
\r
18458 UINT PsNatTable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18461 PS *ps = (PS *)param;
\r
18465 // 仮想 HUB が選択されていない場合はエラー
\r
18466 if (ps->HubName == NULL)
\r
18468 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18469 return ERR_INVALID_PARAMETER;
\r
18472 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
18475 return ERR_INVALID_PARAMETER;
\r
18478 Zero(&t, sizeof(t));
\r
18479 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18482 ret = ScEnumNAT(ps->Rpc, &t);
\r
18484 if (ret != ERR_NO_ERROR)
\r
18487 CmdPrintError(c, ret);
\r
18488 FreeParamValueList(o);
\r
18493 CT *ct = CtNew();
\r
18496 CtInsertColumn(ct, _UU("NM_NAT_ID"), false);
\r
18497 CtInsertColumn(ct, _UU("NM_NAT_PROTOCOL"), false);
\r
18498 CtInsertColumn(ct, _UU("NM_NAT_SRC_HOST"), false);
\r
18499 CtInsertColumn(ct, _UU("NM_NAT_SRC_PORT"), false);
\r
18500 CtInsertColumn(ct, _UU("NM_NAT_DST_HOST"), false);
\r
18501 CtInsertColumn(ct, _UU("NM_NAT_DST_PORT"), false);
\r
18502 CtInsertColumn(ct, _UU("NM_NAT_CREATED"), false);
\r
18503 CtInsertColumn(ct, _UU("NM_NAT_LAST_COMM"), false);
\r
18504 CtInsertColumn(ct, _UU("NM_NAT_SIZE"), false);
\r
18505 CtInsertColumn(ct, _UU("NM_NAT_TCP_STATUS"), false);
\r
18507 for (i = 0;i < t.NumItem;i++)
\r
18509 RPC_ENUM_NAT_ITEM *e = &t.Items[i];
\r
18510 wchar_t tmp0[MAX_SIZE];
\r
18511 wchar_t *tmp1 = L"";
\r
18512 wchar_t tmp2[MAX_SIZE];
\r
18513 wchar_t tmp3[MAX_SIZE];
\r
18514 wchar_t tmp4[MAX_SIZE];
\r
18515 wchar_t tmp5[MAX_SIZE];
\r
18516 wchar_t tmp6[MAX_SIZE];
\r
18517 wchar_t tmp7[MAX_SIZE];
\r
18518 wchar_t tmp8[MAX_SIZE];
\r
18519 wchar_t *tmp9 = L"";
\r
18520 char v1[128], v2[128];
\r
18523 UniToStru(tmp0, e->Id);
\r
18526 switch (e->Protocol)
\r
18529 tmp1 = _UU("NM_NAT_PROTO_TCP");
\r
18532 tmp1 = _UU("NM_NAT_PROTO_UDP");
\r
18535 tmp1 = _UU("NM_NAT_PROTO_DNS");
\r
18540 StrToUni(tmp2, sizeof(tmp2), e->SrcHost);
\r
18543 UniToStru(tmp3, e->SrcPort);
\r
18546 StrToUni(tmp4, sizeof(tmp4), e->DestHost);
\r
18549 UniToStru(tmp5, e->DestPort);
\r
18552 GetDateTimeStrEx64(tmp6, sizeof(tmp6), SystemToLocal64(e->CreatedTime), NULL);
\r
18555 GetDateTimeStrEx64(tmp7, sizeof(tmp7), SystemToLocal64(e->LastCommTime), NULL);
\r
18558 ToStr3(v1, sizeof(v1), e->RecvSize);
\r
18559 ToStr3(v2, sizeof(v2), e->SendSize);
\r
18560 UniFormat(tmp8, sizeof(tmp8), L"%S / %S", v1, v2);
\r
18563 if (e->Protocol == NAT_TCP)
\r
18565 switch (e->TcpStatus)
\r
18567 case NAT_TCP_CONNECTING:
\r
18568 tmp9 = _UU("NAT_TCP_CONNECTING");
\r
18570 case NAT_TCP_SEND_RESET:
\r
18571 tmp9 = _UU("NAT_TCP_SEND_RESET");
\r
18573 case NAT_TCP_CONNECTED:
\r
18574 tmp9 = _UU("NAT_TCP_CONNECTED");
\r
18576 case NAT_TCP_ESTABLISHED:
\r
18577 tmp9 = _UU("NAT_TCP_ESTABLISHED");
\r
18579 case NAT_TCP_WAIT_DISCONNECT:
\r
18580 tmp9 = _UU("NAT_TCP_WAIT_DISCONNECT");
\r
18586 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9);
\r
18589 CtFreeEx(ct, c, true);
\r
18592 FreeRpcEnumNat(&t);
\r
18594 FreeParamValueList(o);
\r
18599 // SecureNAT 機能の仮想 DHCP サーバー機能の設定の取得
\r
18600 UINT PsDhcpGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18603 PS *ps = (PS *)param;
\r
18607 // 仮想 HUB が選択されていない場合はエラー
\r
18608 if (ps->HubName == NULL)
\r
18610 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18611 return ERR_INVALID_PARAMETER;
\r
18614 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
18617 return ERR_INVALID_PARAMETER;
\r
18620 Zero(&t, sizeof(t));
\r
18621 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18624 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18626 if (ret != ERR_NO_ERROR)
\r
18629 CmdPrintError(c, ret);
\r
18630 FreeParamValueList(o);
\r
18635 wchar_t tmp[MAX_SIZE];
\r
18636 CT *ct = CtNewStandard();
\r
18638 // 仮想 DHCP 機能を使用する
\r
18639 CtInsert(ct, _UU("CMD_DhcpGet_Column_USE"), t.UseDhcp ? _UU("SEC_YES") : _UU("SEC_NO"));
\r
18642 IPToUniStr(tmp, sizeof(tmp), &t.DhcpLeaseIPStart);
\r
18643 CtInsert(ct, _UU("CMD_DhcpGet_Column_IP1"), tmp);
\r
18646 IPToUniStr(tmp, sizeof(tmp), &t.DhcpLeaseIPEnd);
\r
18647 CtInsert(ct, _UU("CMD_DhcpGet_Column_IP2"), tmp);
\r
18650 IPToUniStr(tmp, sizeof(tmp), &t.DhcpSubnetMask);
\r
18651 CtInsert(ct, _UU("CMD_DhcpGet_Column_MASK"), tmp);
\r
18654 UniToStru(tmp, t.DhcpExpireTimeSpan);
\r
18655 CtInsert(ct, _UU("CMD_DhcpGet_Column_LEASE"), tmp);
\r
18657 // デフォルトゲートウェイアドレス
\r
18658 UniStrCpy(tmp, sizeof(tmp), _UU("SEC_NONE"));
\r
18659 if (IPToUINT(&t.DhcpGatewayAddress) != 0)
\r
18661 IPToUniStr(tmp, sizeof(tmp), &t.DhcpGatewayAddress);
\r
18663 CtInsert(ct, _UU("CMD_DhcpGet_Column_GW"), tmp);
\r
18666 UniStrCpy(tmp, sizeof(tmp), _UU("SEC_NONE"));
\r
18667 if (IPToUINT(&t.DhcpDnsServerAddress) != 0)
\r
18669 IPToUniStr(tmp, sizeof(tmp), &t.DhcpDnsServerAddress);
\r
18671 CtInsert(ct, _UU("CMD_DhcpGet_Column_DNS"), tmp);
\r
18674 StrToUni(tmp, sizeof(tmp), t.DhcpDomainName);
\r
18675 CtInsert(ct, _UU("CMD_DhcpGet_Column_DOMAIN"), tmp);
\r
18678 CtInsert(ct, _UU("CMD_SecureNatHostGet_Column_LOG"), t.SaveLog ? _UU("SEC_YES") : _UU("SEC_NO"));
\r
18683 FreeParamValueList(o);
\r
18688 // SecureNAT 機能の仮想 DHCP サーバー機能の有効化
\r
18689 UINT PsDhcpEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18692 PS *ps = (PS *)param;
\r
18696 // 仮想 HUB が選択されていない場合はエラー
\r
18697 if (ps->HubName == NULL)
\r
18699 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18700 return ERR_INVALID_PARAMETER;
\r
18703 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
18706 return ERR_INVALID_PARAMETER;
\r
18709 Zero(&t, sizeof(t));
\r
18710 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18713 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18715 if (ret != ERR_NO_ERROR)
\r
18718 CmdPrintError(c, ret);
\r
18719 FreeParamValueList(o);
\r
18726 t.UseDhcp = true;
\r
18731 ret = ERR_INVALID_PARAMETER;
\r
18732 CmdPrintError(c, ret);
\r
18733 FreeParamValueList(o);
\r
18738 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18739 ret = ScSetSecureNATOption(ps->Rpc, &t);
\r
18741 if (ret != ERR_NO_ERROR)
\r
18744 CmdPrintError(c, ret);
\r
18745 FreeParamValueList(o);
\r
18751 FreeParamValueList(o);
\r
18756 // SecureNAT 機能の仮想 DHCP サーバー機能の無効化
\r
18757 UINT PsDhcpDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18760 PS *ps = (PS *)param;
\r
18764 // 仮想 HUB が選択されていない場合はエラー
\r
18765 if (ps->HubName == NULL)
\r
18767 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18768 return ERR_INVALID_PARAMETER;
\r
18771 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
18774 return ERR_INVALID_PARAMETER;
\r
18777 Zero(&t, sizeof(t));
\r
18778 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18781 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18783 if (ret != ERR_NO_ERROR)
\r
18786 CmdPrintError(c, ret);
\r
18787 FreeParamValueList(o);
\r
18794 t.UseDhcp = false;
\r
18799 ret = ERR_INVALID_PARAMETER;
\r
18800 CmdPrintError(c, ret);
\r
18801 FreeParamValueList(o);
\r
18806 ret = ScSetSecureNATOption(ps->Rpc, &t);
\r
18808 if (ret != ERR_NO_ERROR)
\r
18811 CmdPrintError(c, ret);
\r
18812 FreeParamValueList(o);
\r
18818 FreeParamValueList(o);
\r
18823 // SecureNAT 機能の仮想 DHCP サーバー機能の設定の変更
\r
18824 UINT PsDhcpSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18827 PS *ps = (PS *)param;
\r
18830 // 指定できるパラメータ リスト
\r
18831 CMD_EVAL_MIN_MAX mm =
\r
18833 "CMD_NatSet_Eval_UDP", NAT_UDP_MIN_TIMEOUT / 1000, NAT_UDP_MAX_TIMEOUT / 1000,
\r
18837 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
18838 {"START", CmdPrompt, _UU("CMD_DhcpSet_Prompt_START"), CmdEvalIp, NULL},
\r
18839 {"END", CmdPrompt, _UU("CMD_DhcpSet_Prompt_END"), CmdEvalIp, NULL},
\r
18840 {"MASK", CmdPrompt, _UU("CMD_DhcpSet_Prompt_MASK"), CmdEvalIp, NULL},
\r
18841 {"EXPIRE", CmdPrompt, _UU("CMD_DhcpSet_Prompt_EXPIRE"), CmdEvalMinMax, &mm},
\r
18842 {"GW", CmdPrompt, _UU("CMD_DhcpSet_Prompt_GW"), CmdEvalIp, NULL},
\r
18843 {"DNS", CmdPrompt, _UU("CMD_DhcpSet_Prompt_DNS"), CmdEvalIp, NULL},
\r
18844 {"DOMAIN", CmdPrompt, _UU("CMD_DhcpSet_Prompt_DOMAIN"), NULL, NULL},
\r
18845 {"LOG", CmdPrompt, _UU("CMD_NatSet_Prompt_LOG"), CmdEvalNotEmpty, NULL},
\r
18848 // 仮想 HUB が選択されていない場合はエラー
\r
18849 if (ps->HubName == NULL)
\r
18851 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18852 return ERR_INVALID_PARAMETER;
\r
18855 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
18858 return ERR_INVALID_PARAMETER;
\r
18861 Zero(&t, sizeof(t));
\r
18862 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18865 ret = ScGetSecureNATOption(ps->Rpc, &t);
\r
18867 if (ret != ERR_NO_ERROR)
\r
18870 CmdPrintError(c, ret);
\r
18871 FreeParamValueList(o);
\r
18878 StrToIP(&t.DhcpLeaseIPStart, GetParamStr(o, "START"));
\r
18879 StrToIP(&t.DhcpLeaseIPEnd, GetParamStr(o, "END"));
\r
18880 StrToIP(&t.DhcpSubnetMask, GetParamStr(o, "MASK"));
\r
18881 t.DhcpExpireTimeSpan = GetParamInt(o, "EXPIRE");
\r
18882 StrToIP(&t.DhcpGatewayAddress, GetParamStr(o, "GW"));
\r
18883 StrToIP(&t.DhcpDnsServerAddress, GetParamStr(o, "DNS"));
\r
18884 StrCpy(t.DhcpDomainName, sizeof(t.DhcpDomainName), GetParamStr(o, "DOMAIN"));
\r
18885 t.SaveLog = GetParamYes(o, "LOG");
\r
18890 ret = ERR_INVALID_PARAMETER;
\r
18891 CmdPrintError(c, ret);
\r
18892 FreeParamValueList(o);
\r
18897 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18898 ret = ScSetSecureNATOption(ps->Rpc, &t);
\r
18900 if (ret != ERR_NO_ERROR)
\r
18903 CmdPrintError(c, ret);
\r
18904 FreeParamValueList(o);
\r
18910 FreeParamValueList(o);
\r
18915 // SecureNAT 機能の仮想 DHCP サーバー機能のリース テーブルの取得
\r
18916 UINT PsDhcpTable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
18919 PS *ps = (PS *)param;
\r
18923 // 仮想 HUB が選択されていない場合はエラー
\r
18924 if (ps->HubName == NULL)
\r
18926 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
18927 return ERR_INVALID_PARAMETER;
\r
18930 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
18933 return ERR_INVALID_PARAMETER;
\r
18936 Zero(&t, sizeof(t));
\r
18937 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
18940 ret = ScEnumDHCP(ps->Rpc, &t);
\r
18942 if (ret != ERR_NO_ERROR)
\r
18945 CmdPrintError(c, ret);
\r
18946 FreeParamValueList(o);
\r
18951 CT *ct = CtNew();
\r
18954 CtInsertColumn(ct, _UU("DHCP_DHCP_ID"), false);
\r
18955 CtInsertColumn(ct, _UU("DHCP_LEASED_TIME"), false);
\r
18956 CtInsertColumn(ct, _UU("DHCP_EXPIRE_TIME"), false);
\r
18957 CtInsertColumn(ct, _UU("DHCP_MAC_ADDRESS"), false);
\r
18958 CtInsertColumn(ct, _UU("DHCP_IP_ADDRESS"), false);
\r
18959 CtInsertColumn(ct, _UU("DHCP_HOSTNAME"), false);
\r
18961 for (i = 0;i < t.NumItem;i++)
\r
18963 RPC_ENUM_DHCP_ITEM *e = &t.Items[i];
\r
18964 wchar_t tmp0[MAX_SIZE];
\r
18965 wchar_t tmp1[MAX_SIZE];
\r
18966 wchar_t tmp2[MAX_SIZE];
\r
18967 wchar_t tmp3[MAX_SIZE];
\r
18968 wchar_t tmp4[MAX_SIZE];
\r
18969 wchar_t tmp5[MAX_SIZE];
\r
18970 char str[MAX_SIZE];
\r
18973 UniToStru(tmp0, e->Id);
\r
18976 GetDateTimeStrEx64(tmp1, sizeof(tmp1), SystemToLocal64(e->LeasedTime), NULL);
\r
18977 GetDateTimeStrEx64(tmp2, sizeof(tmp2), SystemToLocal64(e->ExpireTime), NULL);
\r
18979 MacToStr(str, sizeof(str), e->MacAddress);
\r
18980 StrToUni(tmp3, sizeof(tmp3), str);
\r
18982 IPToStr32(str, sizeof(str), e->IpAddress);
\r
18983 StrToUni(tmp4, sizeof(tmp4), str);
\r
18985 StrToUni(tmp5, sizeof(tmp5), e->Hostname);
\r
18988 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5);
\r
18991 CtFreeEx(ct, c, true);
\r
18994 FreeRpcEnumDhcp(&t);
\r
18996 FreeParamValueList(o);
\r
19001 // 仮想 HUB 管理オプションの一覧の取得
\r
19002 UINT PsAdminOptionList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19005 PS *ps = (PS *)param;
\r
19007 RPC_ADMIN_OPTION t;
\r
19009 // 仮想 HUB が選択されていない場合はエラー
\r
19010 if (ps->HubName == NULL)
\r
19012 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19013 return ERR_INVALID_PARAMETER;
\r
19016 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
19019 return ERR_INVALID_PARAMETER;
\r
19022 Zero(&t, sizeof(t));
\r
19023 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19026 ret = ScGetHubAdminOptions(ps->Rpc, &t);
\r
19028 if (ret != ERR_NO_ERROR)
\r
19031 CmdPrintError(c, ret);
\r
19032 FreeParamValueList(o);
\r
19037 CT *ct = CtNewStandardEx();
\r
19040 for (i = 0;i < t.NumItem;i++)
\r
19042 ADMIN_OPTION *e = &t.Items[i];
\r
19043 wchar_t tmp1[MAX_SIZE];
\r
19044 wchar_t tmp2[MAX_SIZE];
\r
19046 StrToUni(tmp1, sizeof(tmp1), e->Name);
\r
19047 UniToStru(tmp2, e->Value);
\r
19049 CtInsert(ct, tmp1, tmp2, GetHubAdminOptionHelpString(e->Name));
\r
19053 CtFreeEx(ct, c, true);
\r
19056 FreeRpcAdminOption(&t);
\r
19058 FreeParamValueList(o);
\r
19063 // 仮想 HUB 管理オプションの値の設定
\r
19064 UINT PsAdminOptionSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19067 PS *ps = (PS *)param;
\r
19069 RPC_ADMIN_OPTION t;
\r
19070 // 指定できるパラメータ リスト
\r
19073 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
19074 {"[name]", CmdPrompt, _UU("CMD_AdminOptionSet_Prompt_name"), CmdEvalNotEmpty, NULL},
\r
19075 {"VALUE", CmdPrompt, _UU("CMD_AdminOptionSet_Prompt_VALUE"), CmdEvalNotEmpty, NULL},
\r
19078 // 仮想 HUB が選択されていない場合はエラー
\r
19079 if (ps->HubName == NULL)
\r
19081 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19082 return ERR_INVALID_PARAMETER;
\r
19085 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
19088 return ERR_INVALID_PARAMETER;
\r
19091 Zero(&t, sizeof(t));
\r
19092 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19095 ret = ScGetHubAdminOptions(ps->Rpc, &t);
\r
19097 if (ret != ERR_NO_ERROR)
\r
19100 CmdPrintError(c, ret);
\r
19101 FreeParamValueList(o);
\r
19109 for (i = 0;i < t.NumItem;i++)
\r
19111 if (StrCmpi(t.Items[i].Name, GetParamStr(o, "[name]")) == 0)
\r
19113 t.Items[i].Value = GetParamInt(o, "VALUE");
\r
19121 ret = ERR_OBJECT_NOT_FOUND;
\r
19122 CmdPrintError(c, ret);
\r
19123 FreeParamValueList(o);
\r
19124 FreeRpcAdminOption(&t);
\r
19129 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19130 ret = ScSetHubAdminOptions(ps->Rpc, &t);
\r
19132 if (ret != ERR_NO_ERROR)
\r
19135 CmdPrintError(c, ret);
\r
19136 FreeParamValueList(o);
\r
19142 FreeRpcAdminOption(&t);
\r
19144 FreeParamValueList(o);
\r
19149 // 仮想 HUB 拡張オプションの一覧の取得
\r
19150 UINT PsExtOptionList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19153 PS *ps = (PS *)param;
\r
19155 RPC_ADMIN_OPTION t;
\r
19157 // 仮想 HUB が選択されていない場合はエラー
\r
19158 if (ps->HubName == NULL)
\r
19160 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19161 return ERR_INVALID_PARAMETER;
\r
19164 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
19167 return ERR_INVALID_PARAMETER;
\r
19170 Zero(&t, sizeof(t));
\r
19171 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19174 ret = ScGetHubExtOptions(ps->Rpc, &t);
\r
19176 if (ret != ERR_NO_ERROR)
\r
19179 CmdPrintError(c, ret);
\r
19180 FreeParamValueList(o);
\r
19185 CT *ct = CtNewStandardEx();
\r
19188 for (i = 0;i < t.NumItem;i++)
\r
19190 ADMIN_OPTION *e = &t.Items[i];
\r
19191 wchar_t tmp1[MAX_SIZE];
\r
19192 wchar_t tmp2[MAX_SIZE];
\r
19194 StrToUni(tmp1, sizeof(tmp1), e->Name);
\r
19195 UniToStru(tmp2, e->Value);
\r
19197 CtInsert(ct, tmp1, tmp2, GetHubAdminOptionHelpString(e->Name));
\r
19201 CtFreeEx(ct, c, true);
\r
19204 FreeRpcAdminOption(&t);
\r
19206 FreeParamValueList(o);
\r
19211 // 仮想 HUB 拡張オプションの値の設定
\r
19212 UINT PsExtOptionSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19215 PS *ps = (PS *)param;
\r
19217 RPC_ADMIN_OPTION t;
\r
19218 // 指定できるパラメータ リスト
\r
19221 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
19222 {"[name]", CmdPrompt, _UU("CMD_AdminOptionSet_Prompt_name"), CmdEvalNotEmpty, NULL},
\r
19223 {"VALUE", CmdPrompt, _UU("CMD_AdminOptionSet_Prompt_VALUE"), CmdEvalNotEmpty, NULL},
\r
19226 // 仮想 HUB が選択されていない場合はエラー
\r
19227 if (ps->HubName == NULL)
\r
19229 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19230 return ERR_INVALID_PARAMETER;
\r
19233 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
19236 return ERR_INVALID_PARAMETER;
\r
19239 Zero(&t, sizeof(t));
\r
19240 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19243 ret = ScGetHubExtOptions(ps->Rpc, &t);
\r
19245 if (ret != ERR_NO_ERROR)
\r
19248 CmdPrintError(c, ret);
\r
19249 FreeParamValueList(o);
\r
19257 for (i = 0;i < t.NumItem;i++)
\r
19259 if (StrCmpi(t.Items[i].Name, GetParamStr(o, "[name]")) == 0)
\r
19261 t.Items[i].Value = GetParamInt(o, "VALUE");
\r
19269 ret = ERR_OBJECT_NOT_FOUND;
\r
19270 CmdPrintError(c, ret);
\r
19271 FreeParamValueList(o);
\r
19272 FreeRpcAdminOption(&t);
\r
19277 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19278 ret = ScSetHubExtOptions(ps->Rpc, &t);
\r
19280 if (ret != ERR_NO_ERROR)
\r
19283 CmdPrintError(c, ret);
\r
19284 FreeParamValueList(o);
\r
19290 FreeRpcAdminOption(&t);
\r
19292 FreeParamValueList(o);
\r
19297 // 無効な証明書リストの一覧の取得
\r
19298 UINT PsCrlList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19301 PS *ps = (PS *)param;
\r
19305 // 仮想 HUB が選択されていない場合はエラー
\r
19306 if (ps->HubName == NULL)
\r
19308 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19309 return ERR_INVALID_PARAMETER;
\r
19312 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
19315 return ERR_INVALID_PARAMETER;
\r
19318 Zero(&t, sizeof(t));
\r
19319 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19322 ret = ScEnumCrl(ps->Rpc, &t);
\r
19324 if (ret != ERR_NO_ERROR)
\r
19327 CmdPrintError(c, ret);
\r
19328 FreeParamValueList(o);
\r
19334 CT *ct = CtNew();
\r
19336 CtInsertColumn(ct, _UU("CMD_ID"), false);
\r
19337 CtInsertColumn(ct, _UU("SM_CRL_COLUMN_1"), false);
\r
19339 for (i = 0;i < t.NumItem;i++)
\r
19342 RPC_ENUM_CRL_ITEM *e = &t.Items[i];
\r
19344 UniToStru(tmp, e->Key);
\r
19345 CtInsert(ct, tmp, e->CrlInfo);
\r
19348 CtFreeEx(ct, c, true);
\r
19351 FreeRpcEnumCrl(&t);
\r
19353 FreeParamValueList(o);
\r
19359 UINT PsCrlAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19362 PS *ps = (PS *)param;
\r
19365 // 指定できるパラメータ リスト
\r
19368 {"SERIAL", NULL, NULL, NULL, NULL},
\r
19369 {"MD5", NULL, NULL, NULL, NULL},
\r
19370 {"SHA1", NULL, NULL, NULL, NULL},
\r
19371 {"CN", NULL, NULL, NULL, NULL},
\r
19372 {"O", NULL, NULL, NULL, NULL},
\r
19373 {"OU", NULL, NULL, NULL, NULL},
\r
19374 {"C", NULL, NULL, NULL, NULL},
\r
19375 {"ST", NULL, NULL, NULL, NULL},
\r
19376 {"L", NULL, NULL, NULL, NULL},
\r
19379 // 仮想 HUB が選択されていない場合はエラー
\r
19380 if (ps->HubName == NULL)
\r
19382 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19383 return ERR_INVALID_PARAMETER;
\r
19386 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
19389 return ERR_INVALID_PARAMETER;
\r
19392 Zero(&t, sizeof(t));
\r
19393 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19396 bool param_exists = false;
\r
19397 CRL *crl = ZeroMalloc(sizeof(CRL));
\r
19399 n = crl->Name = ZeroMalloc(sizeof(NAME));
\r
19401 if (IsEmptyStr(GetParamStr(o, "CN")) == false)
\r
19403 n->CommonName = CopyUniStr(GetParamUniStr(o, "CN"));
\r
19404 param_exists = true;
\r
19407 if (IsEmptyStr(GetParamStr(o, "O")) == false)
\r
19409 n->CommonName = CopyUniStr(GetParamUniStr(o, "O"));
\r
19410 param_exists = true;
\r
19413 if (IsEmptyStr(GetParamStr(o, "OU")) == false)
\r
19415 n->CommonName = CopyUniStr(GetParamUniStr(o, "OU"));
\r
19416 param_exists = true;
\r
19419 if (IsEmptyStr(GetParamStr(o, "C")) == false)
\r
19421 n->CommonName = CopyUniStr(GetParamUniStr(o, "C"));
\r
19422 param_exists = true;
\r
19425 if (IsEmptyStr(GetParamStr(o, "ST")) == false)
\r
19427 n->CommonName = CopyUniStr(GetParamUniStr(o, "ST"));
\r
19428 param_exists = true;
\r
19431 if (IsEmptyStr(GetParamStr(o, "L")) == false)
\r
19433 n->CommonName = CopyUniStr(GetParamUniStr(o, "L"));
\r
19434 param_exists = true;
\r
19437 if (IsEmptyStr(GetParamStr(o, "SERIAL")) == false)
\r
19441 b = StrToBin(GetParamStr(o, "SERIAL"));
\r
19443 if (b != NULL && b->Size >= 1)
\r
19445 crl->Serial = NewXSerial(b->Buf, b->Size);
\r
19446 param_exists = true;
\r
19452 if (IsEmptyStr(GetParamStr(o, "MD5")) == false)
\r
19456 b = StrToBin(GetParamStr(o, "MD5"));
\r
19458 if (b != NULL && b->Size == MD5_SIZE)
\r
19460 Copy(crl->DigestMD5, b->Buf, MD5_SIZE);
\r
19461 param_exists = true;
\r
19467 if (IsEmptyStr(GetParamStr(o, "SHA1")) == false)
\r
19471 b = StrToBin(GetParamStr(o, "SHA1"));
\r
19473 if (b != NULL && b->Size == SHA1_SIZE)
\r
19475 Copy(crl->DigestSHA1, b->Buf, SHA1_SIZE);
\r
19476 param_exists = true;
\r
19484 if (param_exists == false)
\r
19487 ret = ERR_INVALID_PARAMETER;
\r
19488 CmdPrintError(c, ret);
\r
19489 FreeParamValueList(o);
\r
19495 ret = ScAddCrl(ps->Rpc, &t);
\r
19497 if (ret != ERR_NO_ERROR)
\r
19500 CmdPrintError(c, ret);
\r
19501 FreeParamValueList(o);
\r
19507 FreeParamValueList(o);
\r
19513 UINT PsCrlDel(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19516 PS *ps = (PS *)param;
\r
19519 // 指定できるパラメータ リスト
\r
19522 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
19523 {"[id]", CmdPrompt, _UU("CMD_CrlDel_Prompt_ID"), CmdEvalNotEmpty, NULL},
\r
19526 // 仮想 HUB が選択されていない場合はエラー
\r
19527 if (ps->HubName == NULL)
\r
19529 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19530 return ERR_INVALID_PARAMETER;
\r
19533 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
19536 return ERR_INVALID_PARAMETER;
\r
19539 Zero(&t, sizeof(t));
\r
19540 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19541 t.Key = GetParamInt(o, "[id]");
\r
19544 ret = ScDelCrl(ps->Rpc, &t);
\r
19546 if (ret != ERR_NO_ERROR)
\r
19549 CmdPrintError(c, ret);
\r
19550 FreeParamValueList(o);
\r
19556 FreeParamValueList(o);
\r
19562 UINT PsCrlGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19565 PS *ps = (PS *)param;
\r
19568 // 指定できるパラメータ リスト
\r
19571 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
19572 {"[id]", CmdPrompt, _UU("CMD_CrlGet_Prompt_ID"), CmdEvalNotEmpty, NULL},
\r
19575 // 仮想 HUB が選択されていない場合はエラー
\r
19576 if (ps->HubName == NULL)
\r
19578 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19579 return ERR_INVALID_PARAMETER;
\r
19582 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
19585 return ERR_INVALID_PARAMETER;
\r
19588 Zero(&t, sizeof(t));
\r
19589 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19590 t.Key = GetParamInt(o, "[id]");
\r
19593 ret = ScGetCrl(ps->Rpc, &t);
\r
19595 if (ret != ERR_NO_ERROR)
\r
19598 CmdPrintError(c, ret);
\r
19599 FreeParamValueList(o);
\r
19605 CT *ct = CtNewStandard();
\r
19606 CRL *crl = t.Crl;
\r
19615 if (UniIsEmptyStr(n->CommonName) == false)
\r
19617 CtInsert(ct, _UU("CMD_CrlGet_CN"), n->CommonName);
\r
19619 if (UniIsEmptyStr(n->Organization) == false)
\r
19621 CtInsert(ct, _UU("CMD_CrlGet_O"), n->Organization);
\r
19623 if (UniIsEmptyStr(n->Unit) == false)
\r
19625 CtInsert(ct, _UU("CMD_CrlGet_OU"), n->Unit);
\r
19627 if (UniIsEmptyStr(n->Country) == false)
\r
19629 CtInsert(ct, _UU("CMD_CrlGet_C"), n->Country);
\r
19631 if (UniIsEmptyStr(n->State) == false)
\r
19633 CtInsert(ct, _UU("CMD_CrlGet_ST"), n->State);
\r
19635 if (UniIsEmptyStr(n->Local) == false)
\r
19637 CtInsert(ct, _UU("CMD_CrlGet_L"), n->Local);
\r
19641 if (crl->Serial != NULL && crl->Serial->size >= 1)
\r
19643 wchar_t tmp[MAX_SIZE];
\r
19644 char str[MAX_SIZE];
\r
19646 BinToStrEx(str, sizeof(str), crl->Serial->data, crl->Serial->size);
\r
19647 StrToUni(tmp, sizeof(tmp), str);
\r
19649 CtInsert(ct, _UU("CMD_CrlGet_SERI"), tmp);
\r
19652 if (IsZero(crl->DigestMD5, MD5_SIZE) == false)
\r
19654 wchar_t tmp[MAX_SIZE];
\r
19655 char str[MAX_SIZE];
\r
19657 BinToStrEx(str, sizeof(str), crl->DigestMD5, MD5_SIZE);
\r
19658 StrToUni(tmp, sizeof(tmp), str);
\r
19660 CtInsert(ct, _UU("CMD_CrlGet_MD5_HASH"), tmp);
\r
19663 if (IsZero(crl->DigestSHA1, SHA1_SIZE) == false)
\r
19665 wchar_t tmp[MAX_SIZE];
\r
19666 char str[MAX_SIZE];
\r
19668 BinToStrEx(str, sizeof(str), crl->DigestSHA1, SHA1_SIZE);
\r
19669 StrToUni(tmp, sizeof(tmp), str);
\r
19671 CtInsert(ct, _UU("CMD_CrlGet_SHA1_HASH"), tmp);
\r
19679 FreeParamValueList(o);
\r
19684 // IP アクセス制御リストのルール一覧の取得
\r
19685 UINT PsAcList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19688 PS *ps = (PS *)param;
\r
19692 // 仮想 HUB が選択されていない場合はエラー
\r
19693 if (ps->HubName == NULL)
\r
19695 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19696 return ERR_INVALID_PARAMETER;
\r
19699 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
19702 return ERR_INVALID_PARAMETER;
\r
19705 Zero(&t, sizeof(t));
\r
19706 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19709 ret = ScGetAcList(ps->Rpc, &t);
\r
19711 if (ret != ERR_NO_ERROR)
\r
19714 CmdPrintError(c, ret);
\r
19715 FreeParamValueList(o);
\r
19724 CtInsertColumn(ct, _UU("SM_AC_COLUMN_1"), true);
\r
19725 CtInsertColumn(ct, _UU("SM_AC_COLUMN_2"), true);
\r
19726 CtInsertColumn(ct, _UU("SM_AC_COLUMN_3"), false);
\r
19727 CtInsertColumn(ct, _UU("SM_AC_COLUMN_4"), false);
\r
19729 for (i = 0;i < LIST_NUM(t.o);i++)
\r
19731 wchar_t tmp1[32], *tmp2, tmp3[MAX_SIZE], tmp4[32];
\r
19733 AC *ac = LIST_DATA(t.o, i);
\r
19735 UniToStru(tmp1, ac->Id);
\r
19736 tmp2 = ac->Deny ? _UU("SM_AC_DENY") : _UU("SM_AC_PASS");
\r
19737 tmp_str = GenerateAcStr(ac);
\r
19738 StrToUni(tmp3, sizeof(tmp3), tmp_str);
\r
19742 UniToStru(tmp4, ac->Priority);
\r
19744 CtInsert(ct, tmp1, tmp4, tmp2, tmp3);
\r
19750 FreeRpcAcList(&t);
\r
19752 FreeParamValueList(o);
\r
19757 // IP アクセス制御リストにルールを追加 (IPv4)
\r
19758 UINT PsAcAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19761 PS *ps = (PS *)param;
\r
19764 // 指定できるパラメータ リスト
\r
19765 CMD_EVAL_MIN_MAX mm =
\r
19767 "CMD_AcAdd_Eval_PRIORITY", 1, 4294967295UL,
\r
19771 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
19772 {"[allow|deny]", CmdPrompt, _UU("CMD_AcAdd_Prompt_AD"), CmdEvalNotEmpty, NULL},
\r
19773 {"PRIORITY", CmdPrompt, _UU("CMD_AcAdd_Prompt_PRIORITY"), CmdEvalMinMax, &mm},
\r
19774 {"IP", CmdPrompt, _UU("CMD_AcAdd_Prompt_IP"), CmdEvalIpAndMask4, NULL},
\r
19777 // 仮想 HUB が選択されていない場合はエラー
\r
19778 if (ps->HubName == NULL)
\r
19780 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19781 return ERR_INVALID_PARAMETER;
\r
19784 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
19787 return ERR_INVALID_PARAMETER;
\r
19790 Zero(&t, sizeof(t));
\r
19791 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19794 ret = ScGetAcList(ps->Rpc, &t);
\r
19796 if (ret != ERR_NO_ERROR)
\r
19799 CmdPrintError(c, ret);
\r
19800 FreeParamValueList(o);
\r
19805 // リストに新しい項目を追加する
\r
19806 AC *ac = ZeroMalloc(sizeof(AC));
\r
19807 char *test = GetParamStr(o, "[allow|deny]");
\r
19808 UINT u_ip, u_mask;
\r
19810 if (StartWith("deny", test))
\r
19815 ParseIpAndMask4(GetParamStr(o, "IP"), &u_ip, &u_mask);
\r
19816 UINTToIP(&ac->IpAddress, u_ip);
\r
19818 if (u_mask == 0xffffffff)
\r
19820 ac->Masked = false;
\r
19824 ac->Masked = true;
\r
19825 UINTToIP(&ac->SubnetMask, u_mask);
\r
19828 ac->Priority = GetParamInt(o, "PRIORITY");
\r
19832 ret = ScSetAcList(ps->Rpc, &t);
\r
19833 if (ret != ERR_NO_ERROR)
\r
19836 CmdPrintError(c, ret);
\r
19837 FreeParamValueList(o);
\r
19842 FreeRpcAcList(&t);
\r
19844 FreeParamValueList(o);
\r
19849 // IP アクセス制御リストにルールを追加 (IPv6)
\r
19850 UINT PsAcAdd6(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19853 PS *ps = (PS *)param;
\r
19856 // 指定できるパラメータ リスト
\r
19857 CMD_EVAL_MIN_MAX mm =
\r
19859 "CMD_AcAdd6_Eval_PRIORITY", 1, 4294967295UL,
\r
19863 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
19864 {"[allow|deny]", CmdPrompt, _UU("CMD_AcAdd6_Prompt_AD"), CmdEvalNotEmpty, NULL},
\r
19865 {"PRIORITY", CmdPrompt, _UU("CMD_AcAdd6_Prompt_PRIORITY"), CmdEvalMinMax, &mm},
\r
19866 {"IP", CmdPrompt, _UU("CMD_AcAdd6_Prompt_IP"), CmdEvalIpAndMask6, NULL},
\r
19869 // 仮想 HUB が選択されていない場合はエラー
\r
19870 if (ps->HubName == NULL)
\r
19872 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
19873 return ERR_INVALID_PARAMETER;
\r
19876 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
19879 return ERR_INVALID_PARAMETER;
\r
19882 Zero(&t, sizeof(t));
\r
19883 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
19886 ret = ScGetAcList(ps->Rpc, &t);
\r
19888 if (ret != ERR_NO_ERROR)
\r
19891 CmdPrintError(c, ret);
\r
19892 FreeParamValueList(o);
\r
19897 // リストに新しい項目を追加する
\r
19898 AC *ac = ZeroMalloc(sizeof(AC));
\r
19899 char *test = GetParamStr(o, "[allow|deny]");
\r
19902 if (StartWith("deny", test))
\r
19907 ParseIpAndMask6(GetParamStr(o, "IP"), &u_ip, &u_mask);
\r
19908 Copy(&ac->IpAddress, &u_ip, sizeof(IP));
\r
19910 if (SubnetMaskToInt6(&u_mask) == 128)
\r
19912 ac->Masked = false;
\r
19916 ac->Masked = true;
\r
19917 Copy(&ac->SubnetMask, &u_mask, sizeof(IP));
\r
19920 ac->Priority = GetParamInt(o, "PRIORITY");
\r
19924 ret = ScSetAcList(ps->Rpc, &t);
\r
19925 if (ret != ERR_NO_ERROR)
\r
19928 CmdPrintError(c, ret);
\r
19929 FreeParamValueList(o);
\r
19934 FreeRpcAcList(&t);
\r
19936 FreeParamValueList(o);
\r
19942 UINT PsDebug(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
19945 PS *ps = (PS *)param;
\r
19948 // 指定できるパラメータ リスト
\r
19951 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
19952 {"[id]", NULL, NULL, NULL, NULL},
\r
19953 {"ARG", NULL, NULL, NULL, NULL},
\r
19956 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
19959 return ERR_INVALID_PARAMETER;
\r
19962 id = GetParamInt(o, "[id]");
\r
19969 c->Write(c, _UU("CMD_Debug_Msg1"));
\r
19971 Zero(&t, sizeof(t));
\r
19974 StrCpy(t.StrValue, sizeof(t.StrValue), GetParamStr(o, "ARG"));
\r
19976 ret = ScDebug(ps->Rpc, &t);
\r
19978 if (ret != ERR_NO_ERROR)
\r
19981 CmdPrintError(c, ret);
\r
19982 FreeParamValueList(o);
\r
19987 wchar_t tmp[sizeof(t.StrValue)];
\r
19989 UniFormat(tmp, sizeof(tmp), _UU("CMD_Debug_Msg2"), t.StrValue);
\r
19990 c->Write(c, tmp);
\r
19994 FreeParamValueList(o);
\r
19999 // サーバーの設定ファイルをフラッシュする
\r
20000 UINT PsFlush(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20003 PS *ps = (PS *)param;
\r
20006 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
20009 return ERR_INVALID_PARAMETER;
\r
20016 wchar_t tmp[MAX_SIZE];
\r
20017 char sizestr[MAX_SIZE];
\r
20019 c->Write(c, _UU("CMD_Flush_Msg1"));
\r
20021 Zero(&t, sizeof(t));
\r
20023 ret = ScFlush(ps->Rpc, &t);
\r
20025 if (ret != ERR_NO_ERROR)
\r
20028 CmdPrintError(c, ret);
\r
20029 FreeParamValueList(o);
\r
20033 ToStr3(sizestr, sizeof(sizestr), (UINT64)t.IntValue);
\r
20034 UniFormat(tmp, sizeof(tmp), _UU("CMD_Flush_Msg2"), sizestr);
\r
20035 c->Write(c, tmp);
\r
20038 FreeParamValueList(o);
\r
20044 UINT PsCrash(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20047 PS *ps = (PS *)param;
\r
20050 // 指定できるパラメータ リスト
\r
20053 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
20054 {"[yes]", CmdPrompt, _UU("CMD_Crash_Confirm"), NULL, NULL},
\r
20057 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
20060 return ERR_INVALID_PARAMETER;
\r
20063 yes = GetParamStr(o, "[yes]");
\r
20065 if (StrCmpi(yes, "yes") != 0)
\r
20067 c->Write(c, _UU("CMD_Crash_Aborted"));
\r
20074 c->Write(c, _UU("CMD_Crash_Msg"));
\r
20076 Zero(&t, sizeof(t));
\r
20078 ret = ScCrash(ps->Rpc, &t);
\r
20080 if (ret != ERR_NO_ERROR)
\r
20083 CmdPrintError(c, ret);
\r
20084 FreeParamValueList(o);
\r
20089 FreeParamValueList(o);
\r
20094 // IP アクセス制御リスト内のルールの削除
\r
20095 UINT PsAcDel(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20098 PS *ps = (PS *)param;
\r
20101 // 指定できるパラメータ リスト
\r
20104 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
20105 {"[id]", CmdPrompt, _UU("CMD_AcDel_Prompt_ID"), CmdEvalNotEmpty, NULL},
\r
20108 // 仮想 HUB が選択されていない場合はエラー
\r
20109 if (ps->HubName == NULL)
\r
20111 c->Write(c, _UU("CMD_Hub_Not_Selected"));
\r
20112 return ERR_INVALID_PARAMETER;
\r
20115 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
20118 return ERR_INVALID_PARAMETER;
\r
20121 Zero(&t, sizeof(t));
\r
20122 StrCpy(t.HubName, sizeof(t.HubName), ps->HubName);
\r
20125 ret = ScGetAcList(ps->Rpc, &t);
\r
20127 if (ret != ERR_NO_ERROR)
\r
20130 CmdPrintError(c, ret);
\r
20131 FreeParamValueList(o);
\r
20140 for (i = 0;i < LIST_NUM(t.o);i++)
\r
20142 AC *ac = LIST_DATA(t.o, i);
\r
20144 if (ac->Id == GetParamInt(o, "[id]"))
\r
20155 ret = ERR_OBJECT_NOT_FOUND;
\r
20156 FreeRpcAcList(&t);
\r
20160 ret = ScSetAcList(ps->Rpc, &t);
\r
20162 if (ret != ERR_NO_ERROR)
\r
20165 CmdPrintError(c, ret);
\r
20166 FreeParamValueList(o);
\r
20171 FreeRpcAcList(&t);
\r
20172 FreeParamValueList(o);
\r
20178 UINT PsLicenseAdd(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20181 PS *ps = (PS *)param;
\r
20184 // 指定できるパラメータ リスト
\r
20187 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
20188 {"[key]", CmdPrompt, _UU("CMD_LicenseAdd_Prompt_Key"), CmdEvalNotEmpty, NULL},
\r
20191 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
20194 return ERR_INVALID_PARAMETER;
\r
20197 Zero(&t, sizeof(t));
\r
20198 StrCpy(t.StrValue, sizeof(t.StrValue), GetParamStr(o, "[key]"));
\r
20201 ret = ScAddLicenseKey(ps->Rpc, &t);
\r
20203 if (ret != ERR_NO_ERROR)
\r
20206 CmdPrintError(c, ret);
\r
20207 FreeParamValueList(o);
\r
20211 FreeParamValueList(o);
\r
20216 // 登録されているライセンスの削除
\r
20217 UINT PsLicenseDel(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20220 PS *ps = (PS *)param;
\r
20223 // 指定できるパラメータ リスト
\r
20226 // "name", prompt_proc, prompt_param, eval_proc, eval_param
\r
20227 {"[id]", CmdPrompt, _UU("CMD_LicenseDel_Prompt_ID"), CmdEvalNotEmpty, NULL},
\r
20230 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
20233 return ERR_INVALID_PARAMETER;
\r
20236 Zero(&t, sizeof(t));
\r
20237 t.IntValue = GetParamInt(o, "[id]");
\r
20240 ret = ScDelLicenseKey(ps->Rpc, &t);
\r
20242 if (ret != ERR_NO_ERROR)
\r
20245 CmdPrintError(c, ret);
\r
20246 FreeParamValueList(o);
\r
20250 FreeParamValueList(o);
\r
20255 // 登録されているライセンス一覧の取得
\r
20256 UINT PsLicenseList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20259 PS *ps = (PS *)param;
\r
20261 RPC_ENUM_LICENSE_KEY t;
\r
20265 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
20268 return ERR_INVALID_PARAMETER;
\r
20271 Zero(&t, sizeof(t));
\r
20274 ret = ScEnumLicenseKey(ps->Rpc, &t);
\r
20276 if (ret != ERR_NO_ERROR)
\r
20279 CmdPrintError(c, ret);
\r
20280 FreeParamValueList(o);
\r
20285 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_1"), false);
\r
20286 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_2"), false);
\r
20287 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_3"), false);
\r
20288 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_4"), false);
\r
20289 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_5"), false);
\r
20290 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_6"), false);
\r
20291 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_7"), false);
\r
20292 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_8"), false);
\r
20293 CtInsertColumn(ct, _UU("SM_LICENSE_COLUMN_9"), false);
\r
20295 for (i = 0;i < t.NumItem;i++)
\r
20297 wchar_t tmp1[32], tmp2[LICENSE_KEYSTR_LEN + 1], tmp3[LICENSE_MAX_PRODUCT_NAME_LEN + 1],
\r
20298 *tmp4, tmp5[128], tmp6[LICENSE_LICENSEID_STR_LEN + 1], tmp7[64],
\r
20299 tmp8[64], tmp9[64];
\r
20300 RPC_ENUM_LICENSE_KEY_ITEM *e = &t.Items[i];
\r
20302 UniToStru(tmp1, e->Id);
\r
20303 StrToUni(tmp2, sizeof(tmp2), e->LicenseKey);
\r
20304 StrToUni(tmp3, sizeof(tmp3), e->LicenseName);
\r
20305 tmp4 = LiGetLicenseStatusStr(e->Status);
\r
20306 if (e->Expires == 0)
\r
20308 UniStrCpy(tmp5, sizeof(tmp5), _UU("SM_LICENSE_NO_EXPIRES"));
\r
20312 GetDateStrEx64(tmp5, sizeof(tmp5), e->Expires, NULL);
\r
20314 StrToUni(tmp6, sizeof(tmp6), e->LicenseId);
\r
20315 UniToStru(tmp7, e->ProductId);
\r
20316 UniFormat(tmp8, sizeof(tmp8), L"%I64u", e->SystemId);
\r
20317 UniToStru(tmp9, e->SerialId);
\r
20320 tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8, tmp9);
\r
20323 CtFreeEx(ct, c, true);
\r
20325 FreeRpcEnumLicenseKey(&t);
\r
20327 FreeParamValueList(o);
\r
20332 // 現在の VPN Server のライセンス状態の取得
\r
20333 UINT PsLicenseStatus(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20336 PS *ps = (PS *)param;
\r
20338 RPC_LICENSE_STATUS st;
\r
20340 wchar_t tmp[MAX_SIZE];
\r
20342 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
20345 return ERR_INVALID_PARAMETER;
\r
20348 Zero(&st, sizeof(st));
\r
20351 ret = ScGetLicenseStatus(ps->Rpc, &st);
\r
20353 if (ret != ERR_NO_ERROR)
\r
20356 CmdPrintError(c, ret);
\r
20357 FreeParamValueList(o);
\r
20361 ct = CtNewStandard();
\r
20363 if (st.EditionId == LICENSE_EDITION_VPN3_NO_LICENSE)
\r
20365 CtInsert(ct, _UU("SM_NO_LICENSE_COLUMN"), _UU("SM_NO_LICENSE"));
\r
20370 StrToUni(tmp, sizeof(tmp), st.EditionStr);
\r
20371 CtInsert(ct, _UU("SM_LICENSE_STATUS_EDITION"), tmp);
\r
20374 if (st.ReleaseDate != 0)
\r
20376 GetDateStrEx64(tmp, sizeof(tmp), st.ReleaseDate, NULL);
\r
20377 CtInsert(ct, _UU("SM_LICENSE_STATUS_RELEASE"), tmp);
\r
20381 UniFormat(tmp, sizeof(tmp), L"%I64u", st.SystemId);
\r
20382 CtInsert(ct, _UU("SM_LICENSE_STATUS_SYSTEM_ID"), tmp);
\r
20384 // 現在の製品ライセンスの有効期限
\r
20385 if (st.SystemExpires == 0)
\r
20387 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_NO_EXPIRES"));
\r
20391 GetDateStrEx64(tmp, sizeof(tmp), st.SystemExpires, NULL);
\r
20393 CtInsert(ct, _UU("SM_LICENSE_STATUS_EXPIRES"), tmp);
\r
20395 // サブスクリプション (サポート) 契約
\r
20396 if (st.NeedSubscription == false)
\r
20398 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_STATUS_SUBSCRIPTION_NONEED"));
\r
20402 if (st.SubscriptionExpires == 0)
\r
20404 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_STATUS_SUBSCRIPTION_NONE"));
\r
20408 wchar_t dtstr[MAX_PATH];
\r
20410 GetDateStrEx64(dtstr, sizeof(dtstr), st.SubscriptionExpires, NULL);
\r
20412 UniFormat(tmp, sizeof(tmp),
\r
20413 st.IsSubscriptionExpired ? _UU("SM_LICENSE_STATUS_SUBSCRIPTION_EXPIRED") : _UU("SM_LICENSE_STATUS_SUBSCRIPTION_VALID"),
\r
20417 CtInsert(ct, _UU("SM_LICENSE_STATUS_SUBSCRIPTION"), tmp);
\r
20419 if (st.NeedSubscription == false && st.SubscriptionExpires != 0)
\r
20421 wchar_t dtstr[MAX_PATH];
\r
20423 GetDateStrEx64(dtstr, sizeof(dtstr), st.SubscriptionExpires, NULL);
\r
20425 CtInsert(ct, _UU("SM_LICENSE_STATUS_SUBSCRIPTION_BUILD_STR"), tmp);
\r
20428 if (GetCapsBool(ps->CapsList, "b_vpn3"))
\r
20431 if (st.NumClientConnectLicense == INFINITE)
\r
20433 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_INFINITE"));
\r
20437 UniToStru(tmp, st.NumClientConnectLicense);
\r
20439 CtInsert(ct, _UU("SM_LICENSE_NUM_CLIENT"), tmp);
\r
20443 if (st.NumBridgeConnectLicense == INFINITE)
\r
20445 UniStrCpy(tmp, sizeof(tmp), _UU("SM_LICENSE_INFINITE"));
\r
20449 UniToStru(tmp, st.NumBridgeConnectLicense);
\r
20451 CtInsert(ct, _UU("SM_LICENSE_NUM_BRIDGE"), tmp);
\r
20453 // エンタープライズ機能の利用可否
\r
20454 CtInsert(ct, _UU("SM_LICENSE_STATUS_ENTERPRISE"),
\r
20455 st.AllowEnterpriseFunction ? _UU("SM_LICENSE_STATUS_ENTERPRISE_YES") : _UU("SM_LICENSE_STATUS_ENTERPRISE_NO"));
\r
20458 CtFreeEx(ct, c, false);
\r
20460 FreeParamValueList(o);
\r
20467 UINT PsClusterSettingGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20470 PS *ps = (PS *)param;
\r
20475 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
20478 return ERR_INVALID_PARAMETER;
\r
20481 Zero(&t, sizeof(t));
\r
20483 ret = ScGetFarmSetting(ps->Rpc, &t);
\r
20485 if (ret != ERR_NO_ERROR)
\r
20487 CmdPrintError(c, ret);
\r
20488 FreeParamValueList(o);
\r
20492 if (t.Weight == 0)
\r
20494 t.Weight = FARM_DEFAULT_WEIGHT;
\r
20498 ct = CtNewStandard();
\r
20500 CtInsert(ct, _UU("CMD_ClusterSettingGet_Current"),
\r
20501 GetServerTypeStr(t.ServerType));
\r
20503 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
\r
20505 CtInsert(ct, _UU("CMD_ClusterSettingGet_ControllerOnly"), t.ControllerOnly ? _UU("SEC_YES") : _UU("SEC_NO"));
\r
20508 if (t.ServerType != SERVER_TYPE_STANDALONE)
\r
20510 wchar_t tmp[MAX_SIZE];
\r
20512 UniToStru(tmp, t.Weight);
\r
20514 CtInsert(ct, _UU("CMD_ClusterSettingGet_Weight"), tmp);
\r
20517 if (t.ServerType == SERVER_TYPE_FARM_MEMBER)
\r
20519 wchar_t tmp[MAX_SIZE];
\r
20523 if (t.PublicIp != 0)
\r
20525 IPToUniStr32(tmp, sizeof(tmp), t.PublicIp);
\r
20529 UniStrCpy(tmp, sizeof(tmp), _UU("CMD_ClusterSettingGet_None"));
\r
20532 CtInsert(ct, _UU("CMD_ClusterSettingGet_PublicIp"), tmp);
\r
20536 for (i = 0;i < t.NumPort;i++)
\r
20538 wchar_t tmp2[64];
\r
20540 UniFormat(tmp2, sizeof(tmp2), L"%u, ", t.Ports[i]);
\r
20542 UniStrCat(tmp, sizeof(tmp), tmp2);
\r
20545 if (UniEndWith(tmp, L", "))
\r
20547 tmp[UniStrLen(tmp) - 2] = 0;
\r
20550 CtInsert(ct, _UU("CMD_ClusterSettingGet_PublicPorts"), tmp);
\r
20553 UniFormat(tmp, sizeof(tmp), L"%S:%u", t.ControllerName, t.ControllerPort);
\r
20554 CtInsert(ct, _UU("CMD_ClusterSettingGet_Controller"), tmp);
\r
20560 FreeParamValueList(o);
\r
20566 UINT PsServerPasswordSet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20569 PS *ps = (PS *)param;
\r
20571 RPC_SET_PASSWORD t;
\r
20575 {"[password]", CmdPromptChoosePassword, NULL, NULL, NULL},
\r
20578 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
20581 return ERR_INVALID_PARAMETER;
\r
20584 pw = GetParamStr(o, "[password]");
\r
20586 Zero(&t, sizeof(t));
\r
20587 Hash(t.HashedPassword, pw, StrLen(pw), true);
\r
20589 ret = ScSetServerPassword(ps->Rpc, &t);
\r
20591 if (ret != ERR_NO_ERROR)
\r
20593 CmdPrintError(c, ret);
\r
20594 FreeParamValueList(o);
\r
20598 FreeParamValueList(o);
\r
20603 // パスワード決定プロンプト (プロンプト関数用)
\r
20604 wchar_t *CmdPromptChoosePassword(CONSOLE *c, void *param)
\r
20613 s = CmdPasswordPrompt(c);
\r
20621 wchar_t *ret = CopyStrToUni(s);
\r
20629 // パスワード入力用プロンプト (汎用)
\r
20630 char *CmdPasswordPrompt(CONSOLE *c)
\r
20639 c->Write(c, _UU("CMD_UTVPNCMD_PWPROMPT_0"));
\r
20642 c->Write(c, L"");
\r
20645 pw1 = c->ReadPassword(c, _UU("CMD_UTVPNCMD_PWPROMPT_1"));
\r
20651 pw2 = c->ReadPassword(c, _UU("CMD_UTVPNCMD_PWPROMPT_2"));
\r
20658 c->Write(c, L"");
\r
20660 if (StrCmp(pw1, pw2) != 0)
\r
20664 c->Write(c, _UU("CMD_UTVPNCMD_PWPROMPT_3"));
\r
20674 UINT PsListenerDisable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20677 PS *ps = (PS *)param;
\r
20682 {"[port]", CmdPromptPort, _UU("CMD_ListenerDisable_PortPrompt"), CmdEvalPort, NULL},
\r
20685 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
20688 return ERR_INVALID_PARAMETER;
\r
20691 Zero(&t, sizeof(t));
\r
20692 t.Enable = false;
\r
20693 t.Port = ToInt(GetParamStr(o, "[port]"));
\r
20695 ret = ScEnableListener(ps->Rpc, &t);
\r
20697 if (ret != ERR_NO_ERROR)
\r
20699 CmdPrintError(c, ret);
\r
20700 FreeParamValueList(o);
\r
20704 FreeParamValueList(o);
\r
20710 UINT PsListenerEnable(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
20713 PS *ps = (PS *)param;
\r
20718 {"[port]", CmdPromptPort, _UU("CMD_ListenerEnable_PortPrompt"), CmdEvalPort, NULL},
\r
20721 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
20724 return ERR_INVALID_PARAMETER;
\r
20727 Zero(&t, sizeof(t));
\r
20729 t.Port = ToInt(GetParamStr(o, "[port]"));
\r
20731 ret = ScEnableListener(ps->Rpc, &t);
\r
20733 if (ret != ERR_NO_ERROR)
\r
20735 CmdPrintError(c, ret);
\r
20736 FreeParamValueList(o);
\r
20740 FreeParamValueList(o);
\r
20745 // コンソールテーブルの 1 行を描画
\r
20746 void CtPrintRow(CONSOLE *c, UINT num, UINT *widths, wchar_t **strings, bool *rights, char separate_char)
\r
20751 bool is_sep_line = true;
\r
20753 if (c == NULL || num == 0 || widths == NULL || strings == NULL || rights == NULL)
\r
20759 for (i = 0;i < num;i++)
\r
20761 buf_size += sizeof(wchar_t) * widths[i] + 6;
\r
20764 buf = ZeroMalloc(buf_size);
\r
20766 for (i = 0;i < num;i++)
\r
20769 wchar_t *space_string;
\r
20772 wchar_t *string = strings[i];
\r
20773 wchar_t *tmp_line = NULL;
\r
20775 if (UniStrCmpi(string, L"---") == 0)
\r
20777 char *s = MakeCharArray('-', widths[i]);
\r
20778 tmp_line = string = CopyStrToUni(s);
\r
20784 is_sep_line = false;
\r
20787 w = UniStrWidth(string);
\r
20789 if (widths[i] >= w)
\r
20791 space = widths[i] - w;
\r
20794 tmp = MakeCharArray(' ', space);
\r
20795 space_string = CopyStrToUni(tmp);
\r
20797 if (rights[i] != false)
\r
20799 UniStrCat(buf, buf_size, space_string);
\r
20802 UniStrCat(buf, buf_size, string);
\r
20804 if (rights[i] == false)
\r
20806 UniStrCat(buf, buf_size, space_string);
\r
20809 Free(space_string);
\r
20812 if (i < (num - 1))
\r
20817 if (UniStrCmpi(strings[i], L"---") == 0)
\r
20823 str[0] = separate_char;
\r
20827 StrToUni(tmp, sizeof(tmp), str);
\r
20829 UniStrCat(buf, buf_size, tmp);
\r
20832 if (tmp_line != NULL)
\r
20838 UniTrimRight(buf);
\r
20842 if (UniStrLen(buf) > (c->GetWidth(c) - 1))
\r
20844 buf[c->GetWidth(c) - 1] = 0;
\r
20848 c->Write(c, buf);
\r
20853 // コンソール テーブルを標準形式で描画
\r
20854 void CtPrintStandard(CT *ct, CONSOLE *c)
\r
20859 if (ct == NULL || c == NULL)
\r
20864 t = CtNewStandard();
\r
20865 for (i = 0;i < LIST_NUM(ct->Rows);i++)
\r
20867 CTR *row = LIST_DATA(ct->Rows, i);
\r
20869 for (j = 0;j < LIST_NUM(ct->Columns);j++)
\r
20871 CTC *column = LIST_DATA(ct->Columns, j);
\r
20873 CtInsert(t, column->String, row->Strings[j]);
\r
20876 if (i != (LIST_NUM(ct->Rows) - 1))
\r
20878 CtInsert(t, L"---", L"---");
\r
20886 void CtPrint(CT *ct, CONSOLE *c)
\r
20891 wchar_t **header_strings;
\r
20894 if (ct == NULL || c == NULL)
\r
20899 num = LIST_NUM(ct->Columns);
\r
20900 widths = ZeroMalloc(sizeof(UINT) * num);
\r
20903 for (i = 0;i < num;i++)
\r
20905 CTC *ctc = LIST_DATA(ct->Columns, i);
\r
20908 w = UniStrWidth(ctc->String);
\r
20909 widths[i] = MAX(widths[i], w);
\r
20911 for (j = 0;j < LIST_NUM(ct->Rows);j++)
\r
20913 CTR *ctr = LIST_DATA(ct->Rows, j);
\r
20915 for (i = 0;i < num;i++)
\r
20919 w = UniStrWidth(ctr->Strings[i]);
\r
20920 widths[i] = MAX(widths[i], w);
\r
20925 header_strings = ZeroMalloc(sizeof(wchar_t *) * num);
\r
20926 rights = ZeroMalloc(sizeof(bool) * num);
\r
20928 for (i = 0;i < num;i++)
\r
20930 CTC *ctc = LIST_DATA(ct->Columns, i);
\r
20932 header_strings[i] = ctc->String;
\r
20933 rights[i] = ctc->Right;
\r
20936 CtPrintRow(c, num, widths, header_strings, rights, '|');
\r
20938 for (i = 0;i < num;i++)
\r
20942 s = MakeCharArray('-', widths[i]);
\r
20943 header_strings[i] = CopyStrToUni(s);
\r
20947 CtPrintRow(c, num, widths, header_strings, rights, '+');
\r
20949 for (i = 0;i < num;i++)
\r
20951 Free(header_strings[i]);
\r
20955 for (j = 0;j < LIST_NUM(ct->Rows);j++)
\r
20957 CTR *ctr = LIST_DATA(ct->Rows, j);
\r
20959 CtPrintRow(c, num, widths, ctr->Strings, rights, '|');
\r
20963 Free(header_strings);
\r
20967 // CSV でのメタ文字をエスケープする
\r
20968 void CtEscapeCsv(wchar_t *dst, UINT size, wchar_t *src){
\r
20970 UINT len = UniStrLen(src);
\r
20972 BOOL need_to_escape = false;
\r
20973 wchar_t tmp[2]=L"*";
\r
20976 if (src==NULL || dst==NULL)
\r
20981 // 入力文字中にエスケープする必要のある文字が無ければそのまま出力にコピー
\r
20982 len = UniStrLen(src);
\r
20983 for (i=0; i<len; i++)
\r
20986 if (tmp[0] == L","[0] || tmp[0] == L"\n"[0] || tmp[0] == L"\""[0])
\r
20988 need_to_escape = true;
\r
20991 if (need_to_escape == false)
\r
20993 UniStrCpy(dst,size,src);
\r
20997 // メタ文字(改行、コンマ、ダブルクオート)を含んでいる場合は”で囲む
\r
20998 UniStrCpy(dst, size, L"\"");
\r
20999 idx = UniStrLen(dst);
\r
21002 for (i=0; i<len; i++)
\r
21005 // ”は””に変換する(MS-Excel方式)
\r
21006 if (tmp[0] == L"\""[0])
\r
21008 UniStrCat(dst, size, tmp);
\r
21010 UniStrCat(dst, size, tmp);
\r
21013 UniStrCat(dst, size, L"\"");
\r
21017 // コンソールテーブルの CSV 形式の表示
\r
21018 void CtPrintCsv(CT *ct, CONSOLE *c)
\r
21021 UINT num_columns = LIST_NUM(ct->Columns);
\r
21022 wchar_t buf[MAX_SIZE];
\r
21023 wchar_t fmtbuf[MAX_SIZE];
\r
21027 for(i=0; i<num_columns; i++)
\r
21029 CTC *ctc = LIST_DATA(ct->Columns, i);
\r
21030 CtEscapeCsv(fmtbuf, MAX_SIZE, ctc->String);
\r
21031 UniStrCat(buf, MAX_SIZE, fmtbuf);
\r
21032 if(i != num_columns-1)
\r
21033 UniStrCat(buf, MAX_SIZE, L",");
\r
21035 c->Write(c, buf);
\r
21038 for(j=0; j<LIST_NUM(ct->Rows); j++)
\r
21040 CTR *ctr = LIST_DATA(ct->Rows, j);
\r
21042 for(i=0; i<num_columns; i++)
\r
21044 CtEscapeCsv(fmtbuf, MAX_SIZE, ctr->Strings[i]);
\r
21045 UniStrCat(buf, MAX_SIZE, fmtbuf);
\r
21046 if(i != num_columns-1)
\r
21047 UniStrCat(buf, MAX_SIZE, L",");
\r
21049 c->Write(c, buf);
\r
21054 void CtFreeEx(CT *ct, CONSOLE *c, bool standard_view)
\r
21065 if (c->ConsoleType == CONSOLE_CSV)
\r
21067 CtPrintCsv(ct, c);
\r
21071 if (standard_view == false)
\r
21077 CtPrintStandard(ct, c);
\r
21082 num = LIST_NUM(ct->Columns);
\r
21084 for (i = 0;i < LIST_NUM(ct->Rows);i++)
\r
21087 CTR *ctr = LIST_DATA(ct->Rows, i);
\r
21089 for (j = 0;j < num;j++)
\r
21091 Free(ctr->Strings[j]);
\r
21094 Free(ctr->Strings);
\r
21098 for (i = 0;i < LIST_NUM(ct->Columns);i++)
\r
21100 CTC *ctc = LIST_DATA(ct->Columns, i);
\r
21102 Free(ctc->String);
\r
21106 ReleaseList(ct->Columns);
\r
21107 ReleaseList(ct->Rows);
\r
21111 void CtFree(CT *ct, CONSOLE *c)
\r
21113 CtFreeEx(ct, c, false);
\r
21117 void CtInsert(CT *ct, ...)
\r
21128 num = LIST_NUM(ct->Columns);
\r
21130 va_start(va, ct);
\r
21132 ctr = ZeroMalloc(sizeof(CTR));
\r
21133 ctr->Strings = ZeroMalloc(sizeof(wchar_t *) * num);
\r
21135 for (i = 0;i < num;i++)
\r
21137 wchar_t *s = va_arg(va, wchar_t *);
\r
21139 ctr->Strings[i] = CopyUniStr(s);
\r
21144 Insert(ct->Rows, ctr);
\r
21148 void CtInsertColumn(CT *ct, wchar_t *str, bool right)
\r
21161 ctc = ZeroMalloc(sizeof(CTC));
\r
21162 ctc->String = CopyUniStr(str);
\r
21163 ctc->Right = right;
\r
21165 Insert(ct->Columns, ctc);
\r
21168 // 新規コンソールテーブルの作成
\r
21173 ct = ZeroMalloc(sizeof(CT));
\r
21174 ct->Columns = NewList(NULL);
\r
21175 ct->Rows = NewList(NULL);
\r
21180 // テーブルのカラムに標準的なカラムを追加する
\r
21181 CT *CtNewStandard()
\r
21183 CT *ct = CtNew();
\r
21185 CtInsertColumn(ct, _UU("CMD_CT_STD_COLUMN_1"), false);
\r
21186 CtInsertColumn(ct, _UU("CMD_CT_STD_COLUMN_2"), false);
\r
21190 CT *CtNewStandardEx()
\r
21192 CT *ct = CtNew();
\r
21194 CtInsertColumn(ct, _UU("CMD_CT_STD_COLUMN_1"), false);
\r
21195 CtInsertColumn(ct, _UU("CMD_CT_STD_COLUMN_2"), false);
\r
21196 CtInsertColumn(ct, _UU("CMD_CT_STD_COLUMN_3"), false);
\r
21202 UINT PsListenerList(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
21205 PS *ps = (PS *)param;
\r
21207 RPC_LISTENER_LIST t;
\r
21211 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
21214 return ERR_INVALID_PARAMETER;
\r
21217 Zero(&t, sizeof(t));
\r
21219 ret = ScEnumListener(ps->Rpc, &t);
\r
21221 if (ret != ERR_NO_ERROR)
\r
21223 CmdPrintError(c, ret);
\r
21224 FreeParamValueList(o);
\r
21230 CtInsertColumn(ct, _UU("CM_LISTENER_COLUMN_1"), false);
\r
21231 CtInsertColumn(ct, _UU("CM_LISTENER_COLUMN_2"), false);
\r
21233 for (i = 0;i < t.NumPort;i++)
\r
21235 wchar_t *status = _UU("CM_LISTENER_OFFLINE");
\r
21236 wchar_t tmp[128];
\r
21240 status = _UU("CM_LISTENER_ERROR");
\r
21242 else if (t.Enables[i])
\r
21244 status = _UU("CM_LISTENER_ONLINE");
\r
21247 UniFormat(tmp, sizeof(tmp), _UU("CM_LISTENER_TCP_PORT"), t.Ports[i]);
\r
21249 CtInsert(ct, tmp, status);
\r
21254 FreeRpcListenerList(&t);
\r
21256 FreeParamValueList(o);
\r
21262 UINT PsListenerDelete(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
21265 PS *ps = (PS *)param;
\r
21270 {"[port]", CmdPromptPort, _UU("CMD_ListenerDelete_PortPrompt"), CmdEvalPort, NULL},
\r
21273 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
21276 return ERR_INVALID_PARAMETER;
\r
21279 Zero(&t, sizeof(t));
\r
21281 t.Port = ToInt(GetParamStr(o, "[port]"));
\r
21283 ret = ScDeleteListener(ps->Rpc, &t);
\r
21285 if (ret != ERR_NO_ERROR)
\r
21287 CmdPrintError(c, ret);
\r
21288 FreeParamValueList(o);
\r
21292 FreeParamValueList(o);
\r
21298 void CmdPrintRow(CONSOLE *c, wchar_t *title, wchar_t *tag, ...)
\r
21300 wchar_t buf[MAX_SIZE * 2];
\r
21301 wchar_t buf2[MAX_SIZE * 2];
\r
21304 if (title == NULL || c == NULL || tag == NULL)
\r
21309 va_start(args, tag);
\r
21310 UniFormatArgs(buf, sizeof(buf), tag, args);
\r
21312 UniFormat(buf2, sizeof(buf2), L"[%s] %s", title, buf);
\r
21316 c->Write(c, buf2);
\r
21319 // ServerInfoGet コマンド
\r
21320 UINT PsServerInfoGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
21323 PS *ps = (PS *)param;
\r
21325 RPC_SERVER_INFO t;
\r
21327 wchar_t tmp[MAX_SIZE];
\r
21329 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
21332 return ERR_INVALID_PARAMETER;
\r
21335 Zero(&t, sizeof(t));
\r
21336 ret = ScGetServerInfo(ps->Rpc, &t);
\r
21337 if (ret != ERR_NO_ERROR)
\r
21339 CmdPrintError(c, ret);
\r
21340 FreeParamValueList(o);
\r
21346 CtInsertColumn(ct, _UU("SM_STATUS_COLUMN_1"), false);
\r
21347 CtInsertColumn(ct, _UU("SM_STATUS_COLUMN_2"), false);
\r
21350 StrToUni(tmp, sizeof(tmp), t.ServerProductName);
\r
21351 CtInsert(ct, _UU("SM_INFO_PRODUCT_NAME"), tmp);
\r
21354 StrToUni(tmp, sizeof(tmp), t.ServerVersionString);
\r
21355 CtInsert(ct, _UU("SM_INFO_VERSION"), tmp);
\r
21358 StrToUni(tmp, sizeof(tmp), t.ServerBuildInfoString);
\r
21359 CtInsert(ct, _UU("SM_INFO_BUILD"), tmp);
\r
21362 StrToUni(tmp, sizeof(tmp), t.ServerHostName);
\r
21363 CtInsert(ct, _UU("SM_INFO_HOSTNAME"), tmp);
\r
21366 CtInsert(ct, _UU("SM_ST_SERVER_TYPE"), GetServerTypeStr(t.ServerType));
\r
21369 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsSystemName);
\r
21370 CtInsert(ct, _UU("SM_OS_SYSTEM_NAME"), tmp);
\r
21372 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsProductName);
\r
21373 CtInsert(ct, _UU("SM_OS_PRODUCT_NAME"), tmp);
\r
21375 if (t.OsInfo.OsServicePack != 0)
\r
21377 UniFormat(tmp, sizeof(tmp), _UU("SM_OS_SP_TAG"), t.OsInfo.OsServicePack);
\r
21378 CtInsert(ct, _UU("SM_OS_SERVICE_PACK"), tmp);
\r
21381 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsVendorName);
\r
21382 CtInsert(ct, _UU("SM_OS_VENDER_NAME"), tmp);
\r
21384 StrToUni(tmp, sizeof(tmp), t.OsInfo.OsVersion);
\r
21385 CtInsert(ct, _UU("SM_OS_VERSION"), tmp);
\r
21387 StrToUni(tmp, sizeof(tmp), t.OsInfo.KernelName);
\r
21388 CtInsert(ct, _UU("SM_OS_KERNEL_NAME"), tmp);
\r
21390 StrToUni(tmp, sizeof(tmp), t.OsInfo.KernelVersion);
\r
21391 CtInsert(ct, _UU("SM_OS_KERNEL_VERSION"), tmp);
\r
21395 FreeRpcServerInfo(&t);
\r
21397 FreeParamValueList(o);
\r
21402 // HUB の種類の文字列を取得
\r
21403 wchar_t *GetHubTypeStr(UINT type)
\r
21405 if (type == HUB_TYPE_FARM_STATIC)
\r
21407 return _UU("SM_HUB_STATIC");
\r
21409 else if (type == HUB_TYPE_FARM_DYNAMIC)
\r
21411 return _UU("SM_HUB_DYNAMIC");
\r
21413 return _UU("SM_HUB_STANDALONE");
\r
21416 // サーバーの種類の文字列を取得
\r
21417 wchar_t *GetServerTypeStr(UINT type)
\r
21419 if (type == SERVER_TYPE_FARM_CONTROLLER)
\r
21421 return _UU("SM_FARM_CONTROLLER");
\r
21423 else if (type == SERVER_TYPE_FARM_MEMBER)
\r
21425 return _UU("SM_FARM_MEMBER");
\r
21427 return _UU("SM_SERVER_STANDALONE");
\r
21430 // ServerStatusGet コマンド
\r
21431 UINT PsServerStatusGet(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
21434 PS *ps = (PS *)param;
\r
21436 RPC_SERVER_STATUS t;
\r
21437 wchar_t tmp[MAX_PATH];
\r
21438 char tmp2[MAX_PATH];
\r
21441 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
21444 return ERR_INVALID_PARAMETER;
\r
21447 Zero(&t, sizeof(t));
\r
21448 ret = ScGetServerStatus(ps->Rpc, &t);
\r
21449 if (ret != ERR_NO_ERROR)
\r
21451 CmdPrintError(c, ret);
\r
21452 FreeParamValueList(o);
\r
21458 CtInsertColumn(ct, _UU("SM_STATUS_COLUMN_1"), false);
\r
21459 CtInsertColumn(ct, _UU("SM_STATUS_COLUMN_2"), false);
\r
21462 CtInsert(ct, _UU("SM_ST_SERVER_TYPE"),
\r
21463 t.ServerType == SERVER_TYPE_STANDALONE ? _UU("SM_SERVER_STANDALONE") :
\r
21464 t.ServerType == SERVER_TYPE_FARM_MEMBER ? _UU("SM_FARM_MEMBER") : _UU("SM_FARM_CONTROLLER"));
\r
21467 UniToStru(tmp, t.NumTcpConnections);
\r
21468 CtInsert(ct, _UU("SM_ST_NUM_TCP"), tmp);
\r
21470 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
\r
21472 // ローカル TCP コネクション数
\r
21473 UniToStru(tmp, t.NumTcpConnectionsLocal);
\r
21474 CtInsert(ct, _UU("SM_ST_NUM_TCP_LOCAL"), tmp);
\r
21476 // リモート TCP コネクション数
\r
21477 UniToStru(tmp, t.NumTcpConnectionsRemote);
\r
21478 CtInsert(ct, _UU("SM_ST_NUM_TCP_REMOTE"), tmp);
\r
21482 UniToStru(tmp, t.NumHubTotal);
\r
21483 CtInsert(ct, _UU("SM_ST_NUM_HUB_TOTAL"), tmp);
\r
21485 if (t.ServerType != SERVER_TYPE_STANDALONE)
\r
21488 UniToStru(tmp, t.NumHubStatic);
\r
21489 CtInsert(ct, _UU("SM_ST_NUM_HUB_STATIC"), tmp);
\r
21492 UniToStru(tmp, t.NumHubDynamic);
\r
21493 CtInsert(ct, _UU("SM_ST_NUM_HUB_DYNAMIC"), tmp);
\r
21497 UniToStru(tmp, t.NumSessionsTotal);
\r
21498 CtInsert(ct, _UU("SM_ST_NUM_SESSION_TOTAL"), tmp);
\r
21500 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
\r
21503 UniToStru(tmp, t.NumSessionsLocal);
\r
21504 CtInsert(ct, _UU("SM_ST_NUM_SESSION_LOCAL"), tmp);
\r
21507 UniToStru(tmp, t.NumSessionsRemote);
\r
21508 CtInsert(ct, _UU("SM_ST_NUM_SESSION_REMOTE"), tmp);
\r
21512 UniToStru(tmp, t.NumMacTables);
\r
21513 CtInsert(ct, _UU("SM_ST_NUM_MAC_TABLE"), tmp);
\r
21516 UniToStru(tmp, t.NumIpTables);
\r
21517 CtInsert(ct, _UU("SM_ST_NUM_IP_TABLE"), tmp);
\r
21520 UniToStru(tmp, t.NumUsers);
\r
21521 CtInsert(ct, _UU("SM_ST_NUM_USERS"), tmp);
\r
21524 UniToStru(tmp, t.NumGroups);
\r
21525 CtInsert(ct, _UU("SM_ST_NUM_GROUPS"), tmp);
\r
21528 UniToStru(tmp, t.AssignedClientLicenses);
\r
21529 CtInsert(ct, _UU("SM_ST_CLIENT_LICENSE"), tmp);
\r
21531 UniToStru(tmp, t.AssignedBridgeLicenses);
\r
21532 CtInsert(ct, _UU("SM_ST_BRIDGE_LICENSE"), tmp);
\r
21534 if (t.ServerType == SERVER_TYPE_FARM_CONTROLLER)
\r
21536 UniToStru(tmp, t.AssignedClientLicensesTotal);
\r
21537 CtInsert(ct, _UU("SM_ST_CLIENT_LICENSE_EX"), tmp);
\r
21539 UniToStru(tmp, t.AssignedBridgeLicensesTotal);
\r
21540 CtInsert(ct, _UU("SM_ST_BRIDGE_LICENSE_EX"), tmp);
\r
21544 CmdInsertTrafficInfo(ct, &t.Traffic);
\r
21547 GetDateTimeStrEx64(tmp, sizeof(tmp), SystemToLocal64(t.StartTime), NULL);
\r
21548 CtInsert(ct, _UU("SM_ST_START_TIME"), tmp);
\r
21551 GetDateTimeStrMilli64(tmp2, sizeof(tmp2), SystemToLocal64(t.CurrentTime));
\r
21552 StrToUni(tmp, sizeof(tmp), tmp2);
\r
21553 CtInsert(ct, _UU("SM_ST_CURRENT_TIME"), tmp);
\r
21556 UniFormat(tmp, sizeof(tmp), L"%I64u", t.CurrentTick);
\r
21557 CtInsert(ct, _UU("SM_ST_CURRENT_TICK"), tmp);
\r
21560 if (t.MemInfo.TotalMemory != 0)
\r
21564 ToStr3(vv, sizeof(vv), t.MemInfo.TotalMemory);
\r
21565 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
\r
21566 CtInsert(ct, _UU("SM_ST_TOTAL_MEMORY"), tmp);
\r
21568 ToStr3(vv, sizeof(vv), t.MemInfo.UsedMemory);
\r
21569 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
\r
21570 CtInsert(ct, _UU("SM_ST_USED_MEMORY"), tmp);
\r
21572 ToStr3(vv, sizeof(vv), t.MemInfo.FreeMemory);
\r
21573 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
\r
21574 CtInsert(ct, _UU("SM_ST_FREE_MEMORY"), tmp);
\r
21576 ToStr3(vv, sizeof(vv), t.MemInfo.TotalPhys);
\r
21577 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
\r
21578 CtInsert(ct, _UU("SM_ST_TOTAL_PHYS"), tmp);
\r
21580 ToStr3(vv, sizeof(vv), t.MemInfo.UsedPhys);
\r
21581 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
\r
21582 CtInsert(ct, _UU("SM_ST_USED_PHYS"), tmp);
\r
21584 ToStr3(vv, sizeof(vv), t.MemInfo.FreePhys);
\r
21585 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_RAM_SIZE_KB"), vv);
\r
21586 CtInsert(ct, _UU("SM_ST_FREE_PHYS"), tmp);
\r
21591 FreeParamValueList(o);
\r
21596 // トラフィック情報を LVB に追加
\r
21597 void CmdInsertTrafficInfo(CT *ct, TRAFFIC *t)
\r
21599 wchar_t tmp[MAX_SIZE];
\r
21602 if (ct == NULL || t == NULL)
\r
21608 ToStr3(vv, sizeof(vv), t->Send.UnicastCount);
\r
21609 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_NUM_PACKET_STR"), vv);
\r
21610 CtInsert(ct, _UU("SM_ST_SEND_UCAST_NUM"), tmp);
\r
21612 ToStr3(vv, sizeof(vv), t->Send.UnicastBytes);
\r
21613 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_SIZE_BYTE_STR"), vv);
\r
21614 CtInsert(ct, _UU("SM_ST_SEND_UCAST_SIZE"), tmp);
\r
21616 ToStr3(vv, sizeof(vv), t->Send.BroadcastCount);
\r
21617 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_NUM_PACKET_STR"), vv);
\r
21618 CtInsert(ct, _UU("SM_ST_SEND_BCAST_NUM"), tmp);
\r
21620 ToStr3(vv, sizeof(vv), t->Send.BroadcastBytes);
\r
21621 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_SIZE_BYTE_STR"), vv);
\r
21622 CtInsert(ct, _UU("SM_ST_SEND_BCAST_SIZE"), tmp);
\r
21625 ToStr3(vv, sizeof(vv), t->Recv.UnicastCount);
\r
21626 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_NUM_PACKET_STR"), vv);
\r
21627 CtInsert(ct, _UU("SM_ST_RECV_UCAST_NUM"), tmp);
\r
21629 ToStr3(vv, sizeof(vv), t->Recv.UnicastBytes);
\r
21630 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_SIZE_BYTE_STR"), vv);
\r
21631 CtInsert(ct, _UU("SM_ST_RECV_UCAST_SIZE"), tmp);
\r
21633 ToStr3(vv, sizeof(vv), t->Recv.BroadcastCount);
\r
21634 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_NUM_PACKET_STR"), vv);
\r
21635 CtInsert(ct, _UU("SM_ST_RECV_BCAST_NUM"), tmp);
\r
21637 ToStr3(vv, sizeof(vv), t->Recv.BroadcastBytes);
\r
21638 UniFormat(tmp, sizeof(tmp), _UU("SM_ST_SIZE_BYTE_STR"), vv);
\r
21639 CtInsert(ct, _UU("SM_ST_RECV_BCAST_SIZE"), tmp);
\r
21643 wchar_t *CmdPromptPort(CONSOLE *c, void *param)
\r
21645 wchar_t *prompt_str;
\r
21647 if (param != NULL)
\r
21649 prompt_str = (wchar_t *)param;
\r
21653 prompt_str = _UU("CMD_PROPMT_PORT");
\r
21656 return c->ReadLine(c, prompt_str, true);
\r
21660 bool CmdEvalPort(CONSOLE *c, wchar_t *str, void *param)
\r
21664 if (c == NULL || str == NULL)
\r
21669 i = UniToInt(str);
\r
21671 if (i >= 1 && i <= 65535)
\r
21676 c->Write(c, _UU("CMD_EVAL_PORT"));
\r
21681 // ListenerCreate コマンド
\r
21682 UINT PsListenerCreate(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
21685 PS *ps = (PS *)param;
\r
21690 {"[port]", CmdPromptPort, _UU("CMD_ListenerCreate_PortPrompt"), CmdEvalPort, NULL},
\r
21693 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
21696 return ERR_INVALID_PARAMETER;
\r
21699 Zero(&t, sizeof(t));
\r
21701 t.Port = ToInt(GetParamStr(o, "[port]"));
\r
21703 ret = ScCreateListener(ps->Rpc, &t);
\r
21705 if (ret != ERR_NO_ERROR)
\r
21707 CmdPrintError(c, ret);
\r
21708 FreeParamValueList(o);
\r
21712 FreeParamValueList(o);
\r
21718 UINT PsAbout(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
21722 o = ParseCommandList(c, cmd_name, str, NULL, 0);
\r
21725 return ERR_INVALID_PARAMETER;
\r
21729 CmdPrintAbout(c);
\r
21731 FreeParamValueList(o);
\r
21736 // 新しいサーバー管理コンテキストの作成
\r
21737 PS *NewPs(CONSOLE *c, RPC *rpc, char *servername, UINT serverport, char *hubname, char *adminhub, wchar_t *cmdline)
\r
21741 if (c == NULL || rpc == NULL || servername == NULL)
\r
21746 if (IsEmptyStr(hubname))
\r
21750 if (IsEmptyStr(adminhub))
\r
21754 if (UniIsEmptyStr(cmdline))
\r
21759 ps = ZeroMalloc(sizeof(PS));
\r
21760 ps->ConsoleForServer = true;
\r
21761 ps->ServerPort = serverport;
\r
21762 ps->ServerName = CopyStr(servername);
\r
21765 ps->HubName = CopyStr(hubname);
\r
21766 ps->LastError = 0;
\r
21767 ps->AdminHub = CopyStr(adminhub);
\r
21768 ps->CmdLine = CopyUniStr(cmdline);
\r
21773 // サーバー管理コンテキストの解放
\r
21774 void FreePs(PS *ps)
\r
21782 Free(ps->HubName);
\r
21783 Free(ps->AdminHub);
\r
21784 Free(ps->CmdLine);
\r
21785 Free(ps->ServerName);
\r
21791 UINT PsConnect(CONSOLE *c, char *host, UINT port, char *hub, char *adminhub, wchar_t *cmdline, char *password)
\r
21793 UINT retcode = 0;
\r
21797 UCHAR hashed_password[SHA1_SIZE];
\r
21800 if (c == NULL || host == NULL)
\r
21802 return ERR_INVALID_PARAMETER;
\r
21813 cedar = NewCedar(NULL, NULL);
\r
21815 Zero(&o, sizeof(o));
\r
21816 UniStrCpy(o.AccountName, sizeof(o.AccountName), L"VPNCMD");
\r
21817 StrCpy(o.Hostname, sizeof(o.Hostname), host);
\r
21819 o.ProxyType = PROXY_DIRECT;
\r
21821 Hash(hashed_password, password, StrLen(password), true);
\r
21823 if (IsEmptyStr(password) == false)
\r
21833 rpc = AdminConnectEx(cedar, &o, hub, hashed_password, &err, CEDAR_CUI_STR);
\r
21839 if (err == ERR_ACCESS_DENIED)
\r
21846 c->Write(c, _UU("CMD_UTVPNCMD_PASSWORD_1"));
\r
21851 pass = c->ReadPassword(c, _UU("CMD_UTVPNCMD_PASSWORD_2"));
\r
21852 c->Write(c, L"");
\r
21854 if (pass != NULL)
\r
21856 Hash(hashed_password, pass, StrLen(pass), true);
\r
21867 CmdPrintError(c, err);
\r
21876 ps = NewPs(c, rpc, host, port, hub, adminhub, cmdline);
\r
21878 retcode = ps->LastError;
\r
21880 AdminDisconnect(rpc);
\r
21885 ReleaseCedar(cedar);
\r
21891 void CmdPrintError(CONSOLE *c, UINT err)
\r
21893 wchar_t tmp[MAX_SIZE];
\r
21900 UniFormat(tmp, sizeof(tmp), _UU("CMD_UTVPNCMD_ERROR"),
\r
21901 err, GetUniErrorStr(err));
\r
21902 c->Write(c, tmp);
\r
21904 if (err == ERR_DISCONNECTED)
\r
21906 c->Write(c, _UU("CMD_DISCONNECTED_MSG"));
\r
21911 void CmdPrintAbout(CONSOLE *c)
\r
21914 wchar_t tmp[MAX_SIZE];
\r
21915 char exe[MAX_PATH];
\r
21922 cedar = NewCedar(NULL, NULL);
\r
21924 GetExeName(exe, sizeof(exe));
\r
21926 UniFormat(tmp, sizeof(tmp), _UU("CMD_UTVPNCMD_ABOUT"),
\r
21927 cedar->VerString, cedar->BuildInfo);
\r
21929 c->Write(c, tmp);
\r
21931 ReleaseCedar(cedar);
\r
21934 // ホスト名とポート番号をパースする (@ で区切る)
\r
21935 bool ParseHostPortAtmark(char *src, char **host, UINT *port, UINT default_port)
\r
21938 bool ret = false;
\r
21945 t = ParseToken(src, "@");
\r
21951 if (port != NULL)
\r
21956 if (default_port == 0)
\r
21958 if (t->NumTokens < 2)
\r
21964 if (ToInt(t->Token[1]) == 0)
\r
21971 if (t->NumTokens >= 2 && ToInt(t->Token[1]) == 0)
\r
21977 if (t->NumTokens >= 1 && IsEmptyStr(t->Token[0]) == false)
\r
21981 if (host != NULL)
\r
21983 *host = CopyStr(t->Token[0]);
\r
21987 if (t->NumTokens >= 2)
\r
21989 if (port != NULL)
\r
21991 *port = ToInt(t->Token[1]);
\r
21996 if (port != NULL)
\r
22000 *port = default_port;
\r
22009 // ホスト名とポート番号をパースする
\r
22010 bool ParseHostPort(char *src, char **host, UINT *port, UINT default_port)
\r
22013 bool ret = false;
\r
22020 if (StartWith(src, "["))
\r
22022 if (InStr(src, "]"))
\r
22024 // [target]:port の形式
\r
22026 char tmp[MAX_SIZE];
\r
22028 StrCpy(tmp, sizeof(tmp), src);
\r
22030 n = SearchStrEx(tmp, "]", 0, false);
\r
22031 if (n != INFINITE)
\r
22033 UINT len = StrLen(tmp);
\r
22035 for (i = n;i < len;i++)
\r
22037 if (tmp[i] == ':')
\r
22044 return ParseHostPortAtmark(tmp, host, port, default_port);
\r
22048 if (InStr(src, "@"))
\r
22051 return ParseHostPortAtmark(src, host, port, default_port);
\r
22054 t = ParseToken(src, ":");
\r
22060 if (port != NULL)
\r
22065 if (default_port == 0)
\r
22067 if (t->NumTokens < 2)
\r
22073 if (ToInt(t->Token[1]) == 0)
\r
22080 if (t->NumTokens >= 2 && ToInt(t->Token[1]) == 0)
\r
22086 if (t->NumTokens >= 1 && IsEmptyStr(t->Token[0]) == false)
\r
22090 if (host != NULL)
\r
22092 *host = CopyStr(t->Token[0]);
\r
22096 if (t->NumTokens >= 2)
\r
22098 if (port != NULL)
\r
22100 *port = ToInt(t->Token[1]);
\r
22105 if (port != NULL)
\r
22109 *port = default_port;
\r
22118 // vpncmd コマンドプロシージャ
\r
22119 UINT VpnCmdProc(CONSOLE *c, char *cmd_name, wchar_t *str, void *param)
\r
22123 bool server = false;
\r
22124 bool client = false;
\r
22125 bool tools = false;
\r
22126 char *hostname = NULL;
\r
22128 wchar_t *cmdline;
\r
22129 bool host_inputted = false;
\r
22131 UINT retcode = 0;
\r
22134 {"[host:port]", NULL, NULL, NULL, NULL},
\r
22135 {"CLIENT", NULL, NULL, NULL, NULL},
\r
22136 {"SERVER", NULL, NULL, NULL, NULL},
\r
22137 {"TOOLS", NULL, NULL, NULL, NULL},
\r
22138 {"HUB", NULL, NULL, NULL, NULL},
\r
22139 {"ADMINHUB", NULL, NULL, NULL, NULL},
\r
22140 {"PASSWORD", NULL, NULL, NULL, NULL},
\r
22141 {"IN", NULL, NULL, NULL, NULL},
\r
22142 {"OUT", NULL, NULL, NULL, NULL},
\r
22143 {"CMD", NULL, NULL, NULL, NULL},
\r
22144 {"CSV", NULL, NULL, NULL, NULL},
\r
22147 if (c->ConsoleType == CONSOLE_LOCAL)
\r
22150 VpnCmdInitBootPath();
\r
22153 if(c->ConsoleType != CONSOLE_CSV)
\r
22155 CmdPrintAbout(c);
\r
22156 c->Write(c, L"");
\r
22159 o = ParseCommandList(c, cmd_name, str, args, sizeof(args) / sizeof(args[0]));
\r
22163 return ERR_INVALID_PARAMETER;
\r
22166 // Client か Server か Tools かの指定
\r
22167 if ((GetParamStr(o, "CLIENT") == NULL && GetParamStr(o, "SERVER") == NULL && GetParamStr(o, "TOOLS") == NULL) ||
\r
22168 (GetParamStr(o, "CLIENT") != NULL && GetParamStr(o, "SERVER") != NULL && GetParamStr(o, "TOOLS") != NULL))
\r
22172 // Client か Server か Tools かが指定されていない
\r
22173 c->Write(c, _UU("CMD_UTVPNCMD_CS_1"));
\r
22175 ret = c->ReadLine(c, _UU("CMD_UTVPNCMD_CS_2"), true);
\r
22177 code = UniToInt(ret);
\r
22199 FreeParamValueList(o);
\r
22200 return ERR_USER_CANCEL;
\r
22203 c->Write(c, L"");
\r
22207 if (GetParamStr(o, "SERVER") != NULL)
\r
22211 else if (GetParamStr(o, "CLIENT") != NULL)
\r
22222 target = CopyStr(GetParamStr(o, "[host:port]"));
\r
22224 if (target == NULL && tools == false)
\r
22230 c->Write(c, _UU("CMD_UTVPNCMD_HOST_1"));
\r
22234 c->Write(c, _UU("CMD_UTVPNCMD_HOST_2"));
\r
22237 str = c->ReadLine(c, _UU("CMD_UTVPNCMD_HOST_3"), true);
\r
22238 c->Write(c, L"");
\r
22239 target = CopyUniToStr(str);
\r
22242 if (target == NULL)
\r
22245 FreeParamValueList(o);
\r
22246 return ERR_USER_CANCEL;
\r
22249 if (IsEmptyStr(target))
\r
22252 target = CopyStr("localhost");
\r
22257 // ユーザーがホスト名を指定した
\r
22258 host_inputted = true;
\r
22261 if (tools == false)
\r
22263 if (ParseHostPort(target, &hostname, &port, 443) == false)
\r
22265 c->Write(c, _UU("CMD_MSG_INVALID_HOSTNAME"));
\r
22267 FreeParamValueList(o);
\r
22268 return ERR_INVALID_PARAMETER;
\r
22273 password = GetParamStr(o, "PASSWORD");
\r
22274 if (password == NULL)
\r
22280 cmdline = GetParamUniStr(o, "CMD");
\r
22286 char *adminhub = NULL;
\r
22288 hub = CopyStr(GetParamStr(o, "HUB"));
\r
22289 adminhub = GetParamStr(o, "ADMINHUB");
\r
22291 // 仮想 HUB 管理モードで指定する仮想 HUB を決定する
\r
22294 if (host_inputted == false)
\r
22297 // ユーザーがホスト名をコマンドラインで指定していない場合は
\r
22298 // プロンプトを表示して仮想 HUB 名も取得する
\r
22299 c->Write(c, _UU("CMD_UTVPNCMD_HUB_1"));
\r
22301 s = c->ReadLine(c, _UU("CMD_UTVPNCMD_HUB_2"), true);
\r
22303 hub = CopyUniToStr(s);
\r
22308 if (IsEmptyStr(hub))
\r
22313 if (IsEmptyStr(adminhub))
\r
22318 retcode = PsConnect(c, hostname, port, hub, adminhub, cmdline, password);
\r
22327 retcode = PcConnect(c, target, cmdline, password);
\r
22331 // VPN Tools として処理
\r
22332 retcode = PtConnect(c, cmdline);
\r
22337 FreeParamValueList(o);
\r
22342 // vpncmd のエントリポイント
\r
22343 UINT CommandMain(wchar_t *command_line)
\r
22346 wchar_t *infile, *outfile;
\r
22347 char *a_infile, *a_outfile;
\r
22348 wchar_t *csvmode;
\r
22352 if (command_line == NULL)
\r
22354 return ERR_INVALID_PARAMETER;
\r
22357 // /in と /out の項目だけ先読みする
\r
22358 infile = ParseCommand(command_line, L"in");
\r
22359 outfile = ParseCommand(command_line, L"out");
\r
22360 if (UniIsEmptyStr(infile))
\r
22365 if (UniIsEmptyStr(outfile))
\r
22371 a_infile = CopyUniToStr(infile);
\r
22372 a_outfile = CopyUniToStr(outfile);
\r
22375 c = NewLocalConsole(infile, outfile);
\r
22378 // vpncmd コマンドの定義
\r
22381 {"utvpncmd", VpnCmdProc},
\r
22384 // CSV モードを先読みしてチェック
\r
22385 csvmode = ParseCommand(command_line, L"csv");
\r
22386 if(csvmode != NULL)
\r
22389 c->ConsoleType = CONSOLE_CSV;
\r
22392 if (DispatchNextCmdEx(c, command_line, ">", cmd, sizeof(cmd) / sizeof(cmd[0]), NULL) == false)
\r
22394 ret = ERR_INVALID_PARAMETER;
\r
22398 ret = c->RetCode;
\r
22406 Print("Error: Couldn't open local console.\n");
\r