utvpn/utvpn-unix-v101-7101-public/src/Cedar/Admin.c

   1 // SoftEther UT-VPN SourceCode\r
   2 // \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
   7 // \r
   8 // http://utvpn.tsukuba.ac.jp/\r
   9 // \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
  13 // \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
  18 // \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
  22 // \r
  23 // このファイルは GPL バージョン 2 ライセンスで公開されています。\r
  24 // 誰でもこのファイルの内容を複製、改変したり、改変したバージョンを再配布\r
  25 // することができます。ただし、原著作物を改変した場合は、原著作物の著作権表示\r
  26 // を除去することはできません。改変した著作物を配布する場合は、改変実施者の\r
  27 // 著作権表示を原著作物の著作権表示に付随して記載するようにしてください。\r
  28 // \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
  32 // ホストされています。\r
  33 // 本プログラムの配布者は、本プログラムを、業としての利用以外のため、\r
  34 // および、試験または研究のために利用が行われることを想定して配布\r
  35 // しています。\r
  36 // SoftEther UT-VPN プロジェクトの Web サイトは http://utvpn.tsukuba.ac.jp/ に\r
  37 // あります。\r
  38 // 本ソフトウェアの不具合の修正、機能改良、セキュリティホールの修復などのコード\r
  39 // の改変を行った場合で、その成果物を SoftEther UT-VPN プロジェクトに提出して\r
  40 // いただける場合は、 http://utvpn.tsukuba.ac.jp/ までソースコードを送付して\r
  41 // ください。SoftEther UT-VPN プロジェクトの本体リリースまたはブランチリリース\r
  42 // に組み込みさせていただきます。\r
  43 // \r
  44 // GPL に基づいて原著作物が提供される本ソフトウェアの改良版を配布、販売する\r
  45 // 場合は、そのソースコードを GPL に基づいて誰にでも開示する義務が生じます。\r
  46 // \r
  47 // 本ソフトウェアに関連する著作権、特許権、商標権はソフトイーサ株式会社\r
  48 // (SoftEther Corporation) およびその他の著作権保持者が保有しています。\r
  49 // ソフトイーサ株式会社等はこれらの権利を放棄していません。本ソフトウェアの\r
  50 // 二次著作物を配布、販売する場合は、これらの権利を侵害しないようにご注意\r
  51 // ください。\r
  52 // \r
  53 // お願い: どのような通信ソフトウェアにも通常は必ず未発見の\r
  54 // セキュリティホールが潜んでいます。本ソースコードをご覧いただいた結果、\r
  55 // UT-VPN にセキュリティホールを発見された場合は、当該セキュリティホールの\r
  56 // 情報を不特定多数に開示される前に、必ず、ソフトイーサ株式会社\r
  57 // および脆弱性情報の届出を受け付ける公的機関まで通報いただき、\r
  58 // 公益保護にご協力いただきますようお願い申し上げます。\r
  59 // \r
  60 // ソフトイーサ株式会社は、当該セキュリティホールについて迅速に対処を\r
  61 // 行い、UT-VPN および UT-VPN に関連するソフトウェアのユーザー・顧客\r
  62 // を保護するための努力を行います。\r
  63 // \r
  64 // ソフトイーサへの届出先: http://www.softether.co.jp/jp/contact/\r
  65 // 日本国内の脆弱性情報届出受付公的機関:\r
  66 //         独立行政法人 情報処理推進機構\r
  67 //         http://www.ipa.go.jp/security/vuln/report/\r
  68 // \r
  69 // 上記各事項について不明な点は、ソフトイーサ株式会社までご連絡ください。\r
  70 // 連絡先: http://www.softether.co.jp/jp/contact/\r
  71 \r
  72 // -----------------------------------------------\r
  73 // [ChangeLog]\r
  74 // 2010.05.20\r
  75 //  新規リリース by SoftEther\r
  76 // -----------------------------------------------\r
  77 \r
  78 // Admin.c\r
  79 // 管理用 RPC モジュール\r
  80 \r
  81 #include "CedarPch.h"\r
  82 \r
  83 // RPC 関数関係マクロ\r
  84 // このあたりは急いで実装したのでコードがあまり美しくない。\r
  85 // 本当は Sun RPC のプリプロセッサのようにきれいな処理方法を採用したがったが\r
  86 // とりあえず今はマクロの羅列になっている。\r
  87 #define DECLARE_RPC_EX(rpc_name, data_type, function, in_rpc, out_rpc, free_rpc)                \\r
  88         else if (StrCmpi(name, rpc_name) == 0)                                                          \\r
  89         {                                                                                                                                       \\r
  90                 data_type *t;                                                                                                   \\r
  91                 t = ZeroMalloc(sizeof(data_type));                                                              \\r
  92                 in_rpc(t, p);                                                                                                   \\r
  93                 err = function(a, t);                                                                                   \\r
  94                 if (err == ERR_NO_ERROR)                                                                                \\r
  95                 {                                                                                                                               \\r
  96                         out_rpc(ret, t);                                                                                        \\r
  97                 }                                                                                                                               \\r
  98                 free_rpc(t);                                                                                                    \\r
  99                 Free(t);                                                                                                                \\r
 100                 ok = true;                                                                                                              \\r
 101         }\r
 102 #define DECLARE_RPC(rpc_name, data_type, function, in_rpc, out_rpc)             \\r
 103         else if (StrCmpi(name, rpc_name) == 0)                                                          \\r
 104         {                                                                                                                                       \\r
 105                 data_type *t;                                                                                                   \\r
 106                 t = ZeroMalloc(sizeof(data_type));                                                              \\r
 107                 in_rpc(t, p);                                                                                                   \\r
 108                 err = function(a, t);                                                                                   \\r
 109                 if (err == ERR_NO_ERROR)                                                                                \\r
 110                 {                                                                                                                               \\r
 111                         out_rpc(ret, t);                                                                                        \\r
 112                 }                                                                                                                               \\r
 113                 Free(t);                                                                                                                \\r
 114                 ok = true;                                                                                                              \\r
 115         }\r
 116 #define DECLARE_SC_EX(rpc_name, data_type, function, in_rpc, out_rpc, free_rpc) \\r
 117         UINT function(RPC *r, data_type *t)                                                                     \\r
 118         {                                                                                                                                       \\r
 119                 PACK *p, *ret;                                                                                                  \\r
 120                 UINT err;                                                                                                               \\r
 121                 if (r == NULL || t == NULL)                                                                             \\r
 122                 {                                                                                                                               \\r
 123                         return ERR_INTERNAL_ERROR;                                                                      \\r
 124                 }                                                                                                                               \\r
 125                 p = NewPack();                                                                                                  \\r
 126                 out_rpc(p, t);                                                                                                  \\r
 127                 free_rpc(t);                                                                                                    \\r
 128                 Zero(t, sizeof(data_type));                                                                             \\r
 129                 ret = AdminCall(r, rpc_name, p);                                                                \\r
 130                 err = GetErrorFromPack(ret);                                                                    \\r
 131                 if (err == ERR_NO_ERROR)                                                                                \\r
 132                 {                                                                                                                               \\r
 133                         in_rpc(t, ret);                                                                                         \\r
 134                 }                                                                                                                               \\r
 135                 FreePack(ret);                                                                                                  \\r
 136                 return err;                                                                                                             \\r
 137         }\r
 138 #define DECLARE_SC(rpc_name, data_type, function, in_rpc, out_rpc)              \\r
 139         UINT function(RPC *r, data_type *t)                                                                     \\r
 140         {                                                                                                                                       \\r
 141                 PACK *p, *ret;                                                                                                  \\r
 142                 UINT err;                                                                                                               \\r
 143                 if (r == NULL || t == NULL)                                                                             \\r
 144                 {                                                                                                                               \\r
 145                         return ERR_INTERNAL_ERROR;                                                                      \\r
 146                 }                                                                                                                               \\r
 147                 p = NewPack();                                                                                                  \\r
 148                 out_rpc(p, t);                                                                                                  \\r
 149                 ret = AdminCall(r, rpc_name, p);                                                                \\r
 150                 err = GetErrorFromPack(ret);                                                                    \\r
 151                 if (err == ERR_NO_ERROR)                                                                                \\r
 152                 {                                                                                                                               \\r
 153                         in_rpc(t, ret);                                                                                         \\r
 154                 }                                                                                                                               \\r
 155                 FreePack(ret);                                                                                                  \\r
 156                 return err;                                                                                                             \\r
 157         }\r
 158 #define CHECK_RIGHT                                                                                                             \\r
 159         if (a->ServerAdmin == false && (t->HubName == NULL || StrCmpi(a->HubName, t->HubName) != 0))    \\r
 160                 return ERR_NOT_ENOUGH_RIGHT;    \\r
 161         if (IsEmptyStr(t->HubName))                     \\r
 162                 return ERR_INVALID_PARAMETER;\r
 163 #define SERVER_ADMIN_ONLY                                                                                               \\r
 164         if (a->ServerAdmin == false)                                                                            \\r
 165                 return ERR_NOT_ENOUGH_RIGHT;\r
 166 #define NO_SUPPORT_FOR_BRIDGE                                                                                   \\r
 167         if (a->Server->Cedar->Bridge)                                                                           \\r
 168                 return ERR_NOT_SUPPORTED;\r
 169 \r
 170 // サーバーの Caps を取得 (取得できない場合はビルド番号から判別)\r
 171 CAPSLIST *ScGetCapsEx(RPC *rpc)\r
 172 {\r
 173         RPC_SERVER_INFO info;\r
 174         CAPSLIST *t;\r
 175         bool is_bridge = false;\r
 176         // 引数チェック\r
 177         if (rpc == NULL)\r
 178         {\r
 179                 return NULL;\r
 180         }\r
 181 \r
 182         Zero(&info, sizeof(info));\r
 183         ScGetServerInfo(rpc, &info);\r
 184 \r
 185         t = ZeroMalloc(sizeof(CAPSLIST));\r
 186 \r
 187         // RPC で Caps を取得してみる\r
 188         if (ScGetCaps(rpc, t) != ERR_NO_ERROR)\r
 189         {\r
 190                 UINT build;\r
 191 \r
 192                 Free(t);\r
 193                 t = NewCapsList();\r
 194 \r
 195                 // 取得に失敗したのでビルド番号を取得する\r
 196                 // (ものすごく古いバージョンの VPN Server のための対応コード)\r
 197                 build = info.ServerBuildInt;\r
 198 \r
 199                 is_bridge = (SearchStrEx(info.ServerProductName, "bridge", 0, false) == INFINITE) ? false : true;\r
 200 \r
 201                 AddCapsInt(t, "i_max_packet_size", 1514);\r
 202 \r
 203                 if (is_bridge == false)\r
 204                 {\r
 205                         AddCapsInt(t, "i_max_hubs", 4096);\r
 206                         AddCapsInt(t, "i_max_sessions", 4096);\r
 207 \r
 208                         if (info.ServerType != SERVER_TYPE_FARM_MEMBER)\r
 209                         {\r
 210                                 AddCapsInt(t, "i_max_users_per_hub", 10000);\r
 211                                 AddCapsInt(t, "i_max_groups_per_hub", 10000);\r
 212                                 AddCapsInt(t, "i_max_access_lists", 4096);\r
 213                         }\r
 214                         else\r
 215                         {\r
 216                                 AddCapsInt(t, "i_max_users_per_hub", 0);\r
 217                                 AddCapsInt(t, "i_max_groups_per_hub", 0);\r
 218                                 AddCapsInt(t, "i_max_access_lists", 0);\r
 219                         }\r
 220                 }\r
 221                 else\r
 222                 {\r
 223                         AddCapsInt(t, "i_max_hubs", 0);\r
 224                         AddCapsInt(t, "i_max_sessions", 0);\r
 225                         AddCapsInt(t, "i_max_users_per_hub", 0);\r
 226                         AddCapsInt(t, "i_max_groups_per_hub", 0);\r
 227                         AddCapsInt(t, "i_max_access_lists", 0);\r
 228                 }\r
 229 \r
 230                 AddCapsInt(t, "i_max_mac_tables", 10000);\r
 231                 AddCapsInt(t, "i_max_ip_tables", 10000);\r
 232 \r
 233                 if (info.ServerType == SERVER_TYPE_STANDALONE)\r
 234                 {\r
 235                         AddCapsBool(t, "b_support_securenat", (build >= 3600) ? true : false);\r
 236                         AddCapsInt(t, "i_max_secnat_tables", 4096);\r
 237                 }\r
 238                 else\r
 239                 {\r
 240                         AddCapsBool(t, "b_support_securenat", false);\r
 241                         AddCapsInt(t, "i_max_secnat_tables", 0);\r
 242                 }\r
 243 \r
 244                 if (is_bridge)\r
 245                 {\r
 246                         AddCapsBool(t, "b_bridge", true);\r
 247                 }\r
 248                 else if (info.ServerType == SERVER_TYPE_STANDALONE)\r
 249                 {\r
 250                         AddCapsBool(t, "b_standalone", true);\r
 251                 }\r
 252                 else if (info.ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
 253                 {\r
 254                         AddCapsBool(t, "b_cluster_controller", true);\r
 255                 }\r
 256                 else\r
 257                 {\r
 258                         AddCapsBool(t, "b_cluster_member", true);\r
 259                 }\r
 260 \r
 261                 AddCapsBool(t, "b_support_config_hub", info.ServerType != SERVER_TYPE_FARM_MEMBER &&\r
 262                         is_bridge == false);\r
 263 \r
 264                 AddCapsBool(t, "b_vpn_client_connect", is_bridge == false ? true : false);\r
 265 \r
 266                 AddCapsBool(t, "b_support_radius", info.ServerType != SERVER_TYPE_FARM_MEMBER &&\r
 267                         is_bridge == false);\r
 268 \r
 269                 if (build >= 3600)\r
 270                 {\r
 271                         RPC_BRIDGE_SUPPORT b;\r
 272                         Zero(&b, sizeof(b));\r
 273                         if (ScGetBridgeSupport(rpc, &b) == ERR_NO_ERROR)\r
 274                         {\r
 275                                 AddCapsBool(t, "b_local_bridge", b.IsBridgeSupportedOs);\r
 276                                 AddCapsBool(t, "b_must_install_pcap", b.IsWinPcapNeeded);\r
 277                         }\r
 278                         else\r
 279                         {\r
 280                                 AddCapsBool(t, "b_local_bridge", false);\r
 281                                 AddCapsBool(t, "b_must_install_pcap", false);\r
 282                         }\r
 283                 }\r
 284                 else\r
 285                 {\r
 286                         AddCapsBool(t, "b_local_bridge", false);\r
 287                         AddCapsBool(t, "b_must_install_pcap", false);\r
 288                 }\r
 289 \r
 290                 AddCapsBool(t, "b_tap_supported", false);\r
 291 \r
 292                 if (info.ServerType == SERVER_TYPE_STANDALONE)\r
 293                 {\r
 294                         AddCapsBool(t, "b_support_cascade", true);\r
 295                 }\r
 296                 else\r
 297                 {\r
 298                         AddCapsBool(t, "b_support_cascade", false);\r
 299                 }\r
 300 \r
 301                 AddCapsBool(t, "b_support_cascade_cert", false);\r
 302                 AddCapsBool(t, "b_support_config_log", info.ServerType != SERVER_TYPE_FARM_MEMBER);\r
 303                 AddCapsBool(t, "b_support_autodelete", false);\r
 304         }\r
 305         else\r
 306         {\r
 307                 // 成功した場合\r
 308                 if (info.ServerBuildInt <= 4350)\r
 309                 {\r
 310                         if (is_bridge == false)\r
 311                         {\r
 312                                 // Build 4300 以下では必ず b_support_cluster が true\r
 313                                 CAPS *caps = GetCaps(t, "b_support_cluster");\r
 314                                 if (caps == NULL)\r
 315                                 {\r
 316                                         AddCapsBool(t, "b_support_cluster", true);\r
 317                                 }\r
 318                                 else\r
 319                                 {\r
 320                                         caps->Value = 1;\r
 321                                 }\r
 322                         }\r
 323                 }\r
 324         }\r
 325 \r
 326         if (true)\r
 327         {\r
 328                 TOKEN_LIST *names;\r
 329 \r
 330                 // サーバー側に存在しない Caps の一覧を false として登録\r
 331                 names = GetTableNameStartWith("CT_b_");\r
 332                 if (names != NULL)\r
 333                 {\r
 334                         UINT i;\r
 335                         for (i = 0;i < names->NumTokens;i++)\r
 336                         {\r
 337                                 char *name = names->Token[i] + 3;\r
 338 \r
 339                                 if (GetCaps(t, name) == NULL)\r
 340                                 {\r
 341                                         AddCapsBool(t, name, false);\r
 342                                 }\r
 343                         }\r
 344 \r
 345                         FreeToken(names);\r
 346                 }\r
 347         }\r
 348 \r
 349         FreeRpcServerInfo(&info);\r
 350 \r
 351         return t;\r
 352 }\r
 353 \r
 354 // 管理用 RPC 関数ディスパッチルーチン\r
 355 PACK *AdminDispatch(RPC *rpc, char *name, PACK *p)\r
 356 {\r
 357         ADMIN *a;\r
 358         PACK *ret;\r
 359         UINT err;\r
 360         SERVER *server = NULL;\r
 361         CEDAR *cedar = NULL;\r
 362         bool ok = false;\r
 363         // 引数チェック\r
 364         if (rpc == NULL || name == NULL || p == NULL)\r
 365         {\r
 366                 return NULL;\r
 367         }\r
 368 \r
 369         ret = NewPack();\r
 370         err = ERR_NO_ERROR;\r
 371 \r
 372         // 管理構造体\r
 373         a = (ADMIN *)rpc->Param;\r
 374         if (a == NULL)\r
 375         {\r
 376                 FreePack(ret);\r
 377                 return NULL;\r
 378         }\r
 379 \r
 380         server = a->Server;\r
 381 \r
 382         if (server != NULL)\r
 383         {\r
 384                 cedar = server->Cedar;\r
 385         }\r
 386 \r
 387         Lock(cedar->CedarSuperLock);\r
 388 \r
 389         if (true)\r
 390         {\r
 391                 char tmp[MAX_PATH];\r
 392                 char ip[MAX_PATH];\r
 393                 UINT rpc_id = 0;\r
 394 \r
 395                 StrCpy(ip, sizeof(ip), "Unknown");\r
 396 \r
 397                 if (rpc->Sock != NULL)\r
 398                 {\r
 399                         IPToStr(ip, sizeof(ip), &rpc->Sock->RemoteIP);\r
 400                         rpc_id = rpc->Sock->socket;\r
 401                 }\r
 402 \r
 403                 Format(tmp, sizeof(tmp), "RPC: RPC-%u (%s): Entering RPC [%s]...",\r
 404                         rpc_id, ip, name);\r
 405 \r
 406                 SiDebugLog(a->Server, tmp);\r
 407         }\r
 408 \r
 409         if (0) {}\r
 410 \r
 411         // このあたりは急いで実装したのでコードがあまり美しくない。\r
 412         // 本当は Sun RPC のプリプロセッサのようにきれいな処理方法を採用したがったが\r
 413         // とりあえず今はマクロの羅列になっている。\r
 414 \r
 415         // RPC 関数定義: ここから\r
 416         DECLARE_RPC_EX("Test", RPC_TEST, StTest, InRpcTest, OutRpcTest, FreeRpcTest)\r
 417         DECLARE_RPC_EX("GetServerInfo", RPC_SERVER_INFO, StGetServerInfo, InRpcServerInfo, OutRpcServerInfo, FreeRpcServerInfo)\r
 418         DECLARE_RPC("GetServerStatus", RPC_SERVER_STATUS, StGetServerStatus, InRpcServerStatus, OutRpcServerStatus)\r
 419         DECLARE_RPC("CreateListener", RPC_LISTENER, StCreateListener, InRpcListener, OutRpcListener)\r
 420         DECLARE_RPC_EX("EnumListener", RPC_LISTENER_LIST, StEnumListener, InRpcListenerList, OutRpcListenerList, FreeRpcListenerList)\r
 421         DECLARE_RPC("DeleteListener", RPC_LISTENER, StDeleteListener, InRpcListener, OutRpcListener)\r
 422         DECLARE_RPC("EnableListener", RPC_LISTENER, StEnableListener, InRpcListener, OutRpcListener)\r
 423         DECLARE_RPC("SetServerPassword", RPC_SET_PASSWORD, StSetServerPassword, InRpcSetPassword, OutRpcSetPassword)\r
 424         DECLARE_RPC_EX("SetFarmSetting", RPC_FARM, StSetFarmSetting, InRpcFarm, OutRpcFarm, FreeRpcFarm)\r
 425         DECLARE_RPC_EX("GetFarmSetting", RPC_FARM, StGetFarmSetting, InRpcFarm, OutRpcFarm, FreeRpcFarm)\r
 426         DECLARE_RPC_EX("GetFarmInfo", RPC_FARM_INFO, StGetFarmInfo, InRpcFarmInfo, OutRpcFarmInfo, FreeRpcFarmInfo)\r
 427         DECLARE_RPC_EX("EnumFarmMember", RPC_ENUM_FARM, StEnumFarmMember, InRpcEnumFarm, OutRpcEnumFarm, FreeRpcEnumFarm)\r
 428         DECLARE_RPC("GetFarmConnectionStatus", RPC_FARM_CONNECTION_STATUS, StGetFarmConnectionStatus, InRpcFarmConnectionStatus, OutRpcFarmConnectionStatus)\r
 429         DECLARE_RPC_EX("SetServerCert", RPC_KEY_PAIR, StSetServerCert, InRpcKeyPair, OutRpcKeyPair, FreeRpcKeyPair)\r
 430         DECLARE_RPC_EX("GetServerCert", RPC_KEY_PAIR, StGetServerCert, InRpcKeyPair, OutRpcKeyPair, FreeRpcKeyPair)\r
 431         DECLARE_RPC_EX("GetServerCipher", RPC_STR, StGetServerCipher, InRpcStr, OutRpcStr, FreeRpcStr)\r
 432         DECLARE_RPC_EX("SetServerCipher", RPC_STR, StSetServerCipher, InRpcStr, OutRpcStr, FreeRpcStr)\r
 433         DECLARE_RPC("CreateHub", RPC_CREATE_HUB, StCreateHub, InRpcCreateHub, OutRpcCreateHub)\r
 434         DECLARE_RPC("SetHub", RPC_CREATE_HUB, StSetHub, InRpcCreateHub, OutRpcCreateHub)\r
 435         DECLARE_RPC("GetHub", RPC_CREATE_HUB, StGetHub, InRpcCreateHub, OutRpcCreateHub)\r
 436         DECLARE_RPC_EX("EnumHub", RPC_ENUM_HUB, StEnumHub, InRpcEnumHub, OutRpcEnumHub, FreeRpcEnumHub)\r
 437         DECLARE_RPC("DeleteHub", RPC_DELETE_HUB, StDeleteHub, InRpcDeleteHub, OutRpcDeleteHub)\r
 438         DECLARE_RPC("GetHubRadius", RPC_RADIUS, StGetHubRadius, InRpcRadius, OutRpcRadius)\r
 439         DECLARE_RPC("SetHubRadius", RPC_RADIUS, StSetHubRadius, InRpcRadius, OutRpcRadius)\r
 440         DECLARE_RPC_EX("EnumConnection", RPC_ENUM_CONNECTION, StEnumConnection, InRpcEnumConnection, OutRpcEnumConnection, FreeRpcEnumConnetion)\r
 441         DECLARE_RPC("DisconnectConnection", RPC_DISCONNECT_CONNECTION, StDisconnectConnection, InRpcDisconnectConnection, OutRpcDisconnectConnection)\r
 442         DECLARE_RPC("GetConnectionInfo", RPC_CONNECTION_INFO, StGetConnectionInfo, InRpcConnectionInfo, OutRpcConnectionInfo)\r
 443         DECLARE_RPC("SetHubOnline", RPC_SET_HUB_ONLINE, StSetHubOnline, InRpcSetHubOnline, OutRpcSetHubOnline)\r
 444         DECLARE_RPC("GetHubStatus", RPC_HUB_STATUS, StGetHubStatus, InRpcHubStatus, OutRpcHubStatus)\r
 445         DECLARE_RPC("SetHubLog", RPC_HUB_LOG, StSetHubLog, InRpcHubLog, OutRpcHubLog)\r
 446         DECLARE_RPC("GetHubLog", RPC_HUB_LOG, StGetHubLog, InRpcHubLog, OutRpcHubLog)\r
 447         DECLARE_RPC_EX("AddCa", RPC_HUB_ADD_CA, StAddCa, InRpcHubAddCa, OutRpcHubAddCa, FreeRpcHubAddCa)\r
 448         DECLARE_RPC_EX("EnumCa", RPC_HUB_ENUM_CA, StEnumCa, InRpcHubEnumCa, OutRpcHubEnumCa, FreeRpcHubEnumCa)\r
 449         DECLARE_RPC_EX("GetCa", RPC_HUB_GET_CA, StGetCa, InRpcHubGetCa, OutRpcHubGetCa, FreeRpcHubGetCa)\r
 450         DECLARE_RPC("DeleteCa", RPC_HUB_DELETE_CA, StDeleteCa, InRpcHubDeleteCa, OutRpcHubDeleteCa)\r
 451         DECLARE_RPC("SetLinkOnline", RPC_LINK, StSetLinkOnline, InRpcLink, OutRpcLink)\r
 452         DECLARE_RPC("SetLinkOffline", RPC_LINK, StSetLinkOffline, InRpcLink, OutRpcLink)\r
 453         DECLARE_RPC("DeleteLink", RPC_LINK, StDeleteLink, InRpcLink, OutRpcLink)\r
 454         DECLARE_RPC("RenameLink", RPC_RENAME_LINK, StRenameLink, InRpcRenameLink, OutRpcRenameLink)\r
 455         DECLARE_RPC_EX("CreateLink", RPC_CREATE_LINK, StCreateLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)\r
 456         DECLARE_RPC_EX("GetLink", RPC_CREATE_LINK, StGetLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)\r
 457         DECLARE_RPC_EX("SetLink", RPC_CREATE_LINK, StSetLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)\r
 458         DECLARE_RPC_EX("EnumLink", RPC_ENUM_LINK, StEnumLink, InRpcEnumLink, OutRpcEnumLink, FreeRpcEnumLink)\r
 459         DECLARE_RPC_EX("GetLinkStatus", RPC_LINK_STATUS, StGetLinkStatus, InRpcLinkStatus, OutRpcLinkStatus, FreeRpcLinkStatus)\r
 460         DECLARE_RPC("AddAccess", RPC_ADD_ACCESS, StAddAccess, InRpcAddAccess, OutRpcAddAccess)\r
 461         DECLARE_RPC("DeleteAccess", RPC_DELETE_ACCESS, StDeleteAccess, InRpcDeleteAccess, OutRpcDeleteAccess)\r
 462         DECLARE_RPC_EX("EnumAccess", RPC_ENUM_ACCESS_LIST, StEnumAccess, InRpcEnumAccessList, OutRpcEnumAccessList, FreeRpcEnumAccessList)\r
 463         DECLARE_RPC_EX("SetAccessList", RPC_ENUM_ACCESS_LIST, StSetAccessList, InRpcEnumAccessList, OutRpcEnumAccessList, FreeRpcEnumAccessList)\r
 464         DECLARE_RPC_EX("CreateUser", RPC_SET_USER, StCreateUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)\r
 465         DECLARE_RPC_EX("SetUser", RPC_SET_USER, StSetUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)\r
 466         DECLARE_RPC_EX("GetUser", RPC_SET_USER, StGetUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)\r
 467         DECLARE_RPC("DeleteUser", RPC_DELETE_USER, StDeleteUser, InRpcDeleteUser, OutRpcDeleteUser)\r
 468         DECLARE_RPC_EX("EnumUser", RPC_ENUM_USER, StEnumUser, InRpcEnumUser, OutRpcEnumUser, FreeRpcEnumUser)\r
 469         DECLARE_RPC_EX("CreateGroup", RPC_SET_GROUP, StCreateGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)\r
 470         DECLARE_RPC_EX("SetGroup", RPC_SET_GROUP, StSetGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)\r
 471         DECLARE_RPC_EX("GetGroup", RPC_SET_GROUP, StGetGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)\r
 472         DECLARE_RPC("DeleteGroup", RPC_DELETE_USER, StDeleteGroup, InRpcDeleteUser, OutRpcDeleteUser)\r
 473         DECLARE_RPC_EX("EnumGroup", RPC_ENUM_GROUP, StEnumGroup, InRpcEnumGroup, OutRpcEnumGroup, FreeRpcEnumGroup)\r
 474         DECLARE_RPC_EX("EnumSession", RPC_ENUM_SESSION, StEnumSession, InRpcEnumSession, OutRpcEnumSession, FreeRpcEnumSession)\r
 475         DECLARE_RPC_EX("GetSessionStatus", RPC_SESSION_STATUS, StGetSessionStatus, InRpcSessionStatus, OutRpcSessionStatus, FreeRpcSessionStatus)\r
 476         DECLARE_RPC("DeleteSession", RPC_DELETE_SESSION, StDeleteSession, InRpcDeleteSession, OutRpcDeleteSession)\r
 477         DECLARE_RPC_EX("EnumMacTable", RPC_ENUM_MAC_TABLE, StEnumMacTable, InRpcEnumMacTable, OutRpcEnumMacTable, FreeRpcEnumMacTable)\r
 478         DECLARE_RPC("DeleteMacTable", RPC_DELETE_TABLE, StDeleteMacTable, InRpcDeleteTable, OutRpcDeleteTable)\r
 479         DECLARE_RPC_EX("EnumIpTable", RPC_ENUM_IP_TABLE, StEnumIpTable, InRpcEnumIpTable, OutRpcEnumIpTable, FreeRpcEnumIpTable)\r
 480         DECLARE_RPC("DeleteIpTable", RPC_DELETE_TABLE, StDeleteIpTable, InRpcDeleteTable, OutRpcDeleteTable)\r
 481         DECLARE_RPC("SetKeep", RPC_KEEP, StSetKeep, InRpcKeep, OutRpcKeep)\r
 482         DECLARE_RPC("GetKeep", RPC_KEEP, StGetKeep, InRpcKeep, OutRpcKeep)\r
 483         DECLARE_RPC("EnableSecureNAT", RPC_HUB, StEnableSecureNAT, InRpcHub, OutRpcHub)\r
 484         DECLARE_RPC("DisableSecureNAT", RPC_HUB, StDisableSecureNAT, InRpcHub, OutRpcHub)\r
 485         DECLARE_RPC("SetSecureNATOption", VH_OPTION, StSetSecureNATOption, InVhOption, OutVhOption)\r
 486         DECLARE_RPC("GetSecureNATOption", VH_OPTION, StGetSecureNATOption, InVhOption, OutVhOption)\r
 487         DECLARE_RPC_EX("EnumNAT", RPC_ENUM_NAT, StEnumNAT, InRpcEnumNat, OutRpcEnumNat, FreeRpcEnumNat)\r
 488         DECLARE_RPC_EX("EnumDHCP", RPC_ENUM_DHCP, StEnumDHCP, InRpcEnumDhcp, OutRpcEnumDhcp, FreeRpcEnumDhcp)\r
 489         DECLARE_RPC("GetSecureNATStatus", RPC_NAT_STATUS, StGetSecureNATStatus, InRpcNatStatus, OutRpcNatStatus)\r
 490         DECLARE_RPC_EX("EnumEthernet", RPC_ENUM_ETH, StEnumEthernet, InRpcEnumEth, OutRpcEnumEth, FreeRpcEnumEth)\r
 491         DECLARE_RPC("AddLocalBridge", RPC_LOCALBRIDGE, StAddLocalBridge, InRpcLocalBridge, OutRpcLocalBridge)\r
 492         DECLARE_RPC("DeleteLocalBridge", RPC_LOCALBRIDGE, StDeleteLocalBridge, InRpcLocalBridge, OutRpcLocalBridge)\r
 493         DECLARE_RPC_EX("EnumLocalBridge", RPC_ENUM_LOCALBRIDGE, StEnumLocalBridge, InRpcEnumLocalBridge, OutRpcEnumLocalBridge, FreeRpcEnumLocalBridge)\r
 494         DECLARE_RPC("GetBridgeSupport", RPC_BRIDGE_SUPPORT, StGetBridgeSupport, InRpcBridgeSupport, OutRpcBridgeSupport)\r
 495         DECLARE_RPC("RebootServer", RPC_TEST, StRebootServer, InRpcTest, OutRpcTest)\r
 496         DECLARE_RPC_EX("GetCaps", CAPSLIST, StGetCaps, InRpcCapsList, OutRpcCapsList, FreeRpcCapsList)\r
 497         DECLARE_RPC_EX("GetConfig", RPC_CONFIG, StGetConfig, InRpcConfig, OutRpcConfig, FreeRpcConfig)\r
 498         DECLARE_RPC_EX("SetConfig", RPC_CONFIG, StSetConfig, InRpcConfig, OutRpcConfig, FreeRpcConfig)\r
 499         DECLARE_RPC_EX("GetDefaultHubAdminOptions", RPC_ADMIN_OPTION, StGetDefaultHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 500         DECLARE_RPC_EX("GetHubAdminOptions", RPC_ADMIN_OPTION, StGetHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 501         DECLARE_RPC_EX("SetHubAdminOptions", RPC_ADMIN_OPTION, StSetHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 502         DECLARE_RPC_EX("GetHubExtOptions", RPC_ADMIN_OPTION, StGetHubExtOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 503         DECLARE_RPC_EX("SetHubExtOptions", RPC_ADMIN_OPTION, StSetHubExtOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 504         DECLARE_RPC("AddL3Switch", RPC_L3SW, StAddL3Switch, InRpcL3Sw, OutRpcL3Sw)\r
 505         DECLARE_RPC("DelL3Switch", RPC_L3SW, StDelL3Switch, InRpcL3Sw, OutRpcL3Sw)\r
 506         DECLARE_RPC_EX("EnumL3Switch", RPC_ENUM_L3SW, StEnumL3Switch, InRpcEnumL3Sw, OutRpcEnumL3Sw, FreeRpcEnumL3Sw)\r
 507         DECLARE_RPC("StartL3Switch", RPC_L3SW, StStartL3Switch, InRpcL3Sw, OutRpcL3Sw)\r
 508         DECLARE_RPC("StopL3Switch", RPC_L3SW, StStopL3Switch, InRpcL3Sw, OutRpcL3Sw)\r
 509         DECLARE_RPC("AddL3If", RPC_L3IF, StAddL3If, InRpcL3If, OutRpcL3If)\r
 510         DECLARE_RPC("DelL3If", RPC_L3IF, StDelL3If, InRpcL3If, OutRpcL3If)\r
 511         DECLARE_RPC_EX("EnumL3If", RPC_ENUM_L3IF, StEnumL3If, InRpcEnumL3If, OutRpcEnumL3If, FreeRpcEnumL3If)\r
 512         DECLARE_RPC("AddL3Table", RPC_L3TABLE, StAddL3Table, InRpcL3Table, OutRpcL3Table)\r
 513         DECLARE_RPC("DelL3Table", RPC_L3TABLE, StDelL3Table, InRpcL3Table, OutRpcL3Table)\r
 514         DECLARE_RPC_EX("EnumL3Table", RPC_ENUM_L3TABLE, StEnumL3Table, InRpcEnumL3Table, OutRpcEnumL3Table, FreeRpcEnumL3Table)\r
 515         DECLARE_RPC_EX("EnumCrl", RPC_ENUM_CRL, StEnumCrl, InRpcEnumCrl, OutRpcEnumCrl, FreeRpcEnumCrl)\r
 516         DECLARE_RPC_EX("AddCrl", RPC_CRL, StAddCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)\r
 517         DECLARE_RPC_EX("DelCrl", RPC_CRL, StDelCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)\r
 518         DECLARE_RPC_EX("GetCrl", RPC_CRL, StGetCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)\r
 519         DECLARE_RPC_EX("SetCrl", RPC_CRL, StSetCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)\r
 520         DECLARE_RPC_EX("SetAcList", RPC_AC_LIST, StSetAcList, InRpcAcList, OutRpcAcList, FreeRpcAcList)\r
 521         DECLARE_RPC_EX("GetAcList", RPC_AC_LIST, StGetAcList, InRpcAcList, OutRpcAcList, FreeRpcAcList)\r
 522         DECLARE_RPC_EX("EnumLogFile", RPC_ENUM_LOG_FILE, StEnumLogFile, InRpcEnumLogFile, OutRpcEnumLogFile, FreeRpcEnumLogFile)\r
 523         DECLARE_RPC_EX("ReadLogFile", RPC_READ_LOG_FILE, StReadLogFile, InRpcReadLogFile, OutRpcReadLogFile, FreeRpcReadLogFile)\r
 524         DECLARE_RPC("AddLicenseKey", RPC_TEST, StAddLicenseKey, InRpcTest, OutRpcTest)\r
 525         DECLARE_RPC("DelLicenseKey", RPC_TEST, StDelLicenseKey, InRpcTest, OutRpcTest)\r
 526         DECLARE_RPC_EX("EnumLicenseKey", RPC_ENUM_LICENSE_KEY, StEnumLicenseKey, InRpcEnumLicenseKey, OutRpcEnumLicenseKey, FreeRpcEnumLicenseKey)\r
 527         DECLARE_RPC("GetLicenseStatus", RPC_LICENSE_STATUS, StGetLicenseStatus, InRpcLicenseStatus, OutRpcLicenseStatus)\r
 528         DECLARE_RPC("SetSysLog", SYSLOG_SETTING, StSetSysLog, InRpcSysLogSetting, OutRpcSysLogSetting)\r
 529         DECLARE_RPC("GetSysLog", SYSLOG_SETTING, StGetSysLog, InRpcSysLogSetting, OutRpcSysLogSetting)\r
 530         DECLARE_RPC_EX("EnumEthVLan", RPC_ENUM_ETH_VLAN, StEnumEthVLan, InRpcEnumEthVLan, OutRpcEnumEthVLan, FreeRpcEnumEthVLan)\r
 531         DECLARE_RPC("SetEnableEthVLan", RPC_TEST, StSetEnableEthVLan, InRpcTest, OutRpcTest)\r
 532         DECLARE_RPC_EX("SetHubMsg", RPC_MSG, StSetHubMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)\r
 533         DECLARE_RPC_EX("GetHubMsg", RPC_MSG, StGetHubMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)\r
 534         DECLARE_RPC("Crash", RPC_TEST, StCrash, InRpcTest, OutRpcTest)\r
 535         DECLARE_RPC_EX("GetAdminMsg", RPC_MSG, StGetAdminMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)\r
 536         DECLARE_RPC("Flush", RPC_TEST, StFlush, InRpcTest, OutRpcTest)\r
 537         DECLARE_RPC("Debug", RPC_TEST, StDebug, InRpcTest, OutRpcTest)\r
 538         // RPC 関数定義: ここまで\r
 539 \r
 540         if (ok == false)\r
 541         {\r
 542                 err = ERR_NOT_SUPPORTED;\r
 543         }\r
 544 \r
 545         if (err != ERR_NO_ERROR)\r
 546         {\r
 547                 PackAddInt(ret, "error", err);\r
 548         }\r
 549 \r
 550         if (true)\r
 551         {\r
 552                 char tmp[MAX_PATH];\r
 553                 char ip[MAX_PATH];\r
 554                 UINT rpc_id = 0;\r
 555 \r
 556                 StrCpy(ip, sizeof(ip), "Unknown");\r
 557 \r
 558                 if (rpc->Sock != NULL)\r
 559                 {\r
 560                         IPToStr(ip, sizeof(ip), &rpc->Sock->RemoteIP);\r
 561                         rpc_id = rpc->Sock->socket;\r
 562                 }\r
 563 \r
 564                 Format(tmp, sizeof(tmp), "RPC: RPC-%u (%s): Leaving RPC [%s] (Error: %u).",\r
 565                         rpc_id, ip, name, err);\r
 566 \r
 567                 SiDebugLog(a->Server, tmp);\r
 568         }\r
 569 \r
 570         Unlock(cedar->CedarSuperLock);\r
 571 \r
 572         return ret;\r
 573 }\r
 574 \r
 575 // このあたりは急いで実装したのでコードがあまり美しくない。\r
 576 // 本当は Sun RPC のプリプロセッサのようにきれいな処理方法を採用したがったが\r
 577 // とりあえず今はマクロの羅列になっている。\r
 578 \r
 579 // RPC 呼び出し関数定義: ここから\r
 580 DECLARE_SC_EX("Test", RPC_TEST, ScTest, InRpcTest, OutRpcTest, FreeRpcTest)\r
 581 DECLARE_SC_EX("GetServerInfo", RPC_SERVER_INFO, ScGetServerInfo, InRpcServerInfo, OutRpcServerInfo, FreeRpcServerInfo)\r
 582 DECLARE_SC("GetServerStatus", RPC_SERVER_STATUS, ScGetServerStatus, InRpcServerStatus, OutRpcServerStatus)\r
 583 DECLARE_SC("CreateListener", RPC_LISTENER, ScCreateListener, InRpcListener, OutRpcListener)\r
 584 DECLARE_SC_EX("EnumListener", RPC_LISTENER_LIST, ScEnumListener, InRpcListenerList, OutRpcListenerList, FreeRpcListenerList)\r
 585 DECLARE_SC("DeleteListener", RPC_LISTENER, ScDeleteListener, InRpcListener, OutRpcListener)\r
 586 DECLARE_SC("EnableListener", RPC_LISTENER, ScEnableListener, InRpcListener, OutRpcListener)\r
 587 DECLARE_SC("SetServerPassword", RPC_SET_PASSWORD, ScSetServerPassword, InRpcSetPassword, OutRpcSetPassword)\r
 588 DECLARE_SC_EX("SetFarmSetting", RPC_FARM, ScSetFarmSetting, InRpcFarm, OutRpcFarm, FreeRpcFarm)\r
 589 DECLARE_SC_EX("GetFarmSetting", RPC_FARM, ScGetFarmSetting, InRpcFarm, OutRpcFarm, FreeRpcFarm)\r
 590 DECLARE_SC_EX("GetFarmInfo", RPC_FARM_INFO, ScGetFarmInfo, InRpcFarmInfo, OutRpcFarmInfo, FreeRpcFarmInfo)\r
 591 DECLARE_SC_EX("EnumFarmMember", RPC_ENUM_FARM, ScEnumFarmMember, InRpcEnumFarm, OutRpcEnumFarm, FreeRpcEnumFarm)\r
 592 DECLARE_SC("GetFarmConnectionStatus", RPC_FARM_CONNECTION_STATUS, ScGetFarmConnectionStatus, InRpcFarmConnectionStatus, OutRpcFarmConnectionStatus)\r
 593 DECLARE_SC_EX("SetServerCert", RPC_KEY_PAIR, ScSetServerCert, InRpcKeyPair, OutRpcKeyPair, FreeRpcKeyPair)\r
 594 DECLARE_SC_EX("GetServerCert", RPC_KEY_PAIR, ScGetServerCert, InRpcKeyPair, OutRpcKeyPair, FreeRpcKeyPair)\r
 595 DECLARE_SC_EX("GetServerCipher", RPC_STR, ScGetServerCipher, InRpcStr, OutRpcStr, FreeRpcStr)\r
 596 DECLARE_SC_EX("SetServerCipher", RPC_STR, ScSetServerCipher, InRpcStr, OutRpcStr, FreeRpcStr)\r
 597 DECLARE_SC("CreateHub", RPC_CREATE_HUB, ScCreateHub, InRpcCreateHub, OutRpcCreateHub)\r
 598 DECLARE_SC("SetHub", RPC_CREATE_HUB, ScSetHub, InRpcCreateHub, OutRpcCreateHub)\r
 599 DECLARE_SC("GetHub", RPC_CREATE_HUB, ScGetHub, InRpcCreateHub, OutRpcCreateHub)\r
 600 DECLARE_SC_EX("EnumHub", RPC_ENUM_HUB, ScEnumHub, InRpcEnumHub, OutRpcEnumHub, FreeRpcEnumHub)\r
 601 DECLARE_SC("DeleteHub", RPC_DELETE_HUB, ScDeleteHub, InRpcDeleteHub, OutRpcDeleteHub)\r
 602 DECLARE_SC("GetHubRadius", RPC_RADIUS, ScGetHubRadius, InRpcRadius, OutRpcRadius)\r
 603 DECLARE_SC("SetHubRadius", RPC_RADIUS, ScSetHubRadius, InRpcRadius, OutRpcRadius)\r
 604 DECLARE_SC_EX("EnumConnection", RPC_ENUM_CONNECTION, ScEnumConnection, InRpcEnumConnection, OutRpcEnumConnection, FreeRpcEnumConnetion)\r
 605 DECLARE_SC("DisconnectConnection", RPC_DISCONNECT_CONNECTION, ScDisconnectConnection, InRpcDisconnectConnection, OutRpcDisconnectConnection)\r
 606 DECLARE_SC("GetConnectionInfo", RPC_CONNECTION_INFO, ScGetConnectionInfo, InRpcConnectionInfo, OutRpcConnectionInfo)\r
 607 DECLARE_SC("SetHubOnline", RPC_SET_HUB_ONLINE, ScSetHubOnline, InRpcSetHubOnline, OutRpcSetHubOnline)\r
 608 DECLARE_SC("GetHubStatus", RPC_HUB_STATUS, ScGetHubStatus, InRpcHubStatus, OutRpcHubStatus)\r
 609 DECLARE_SC("SetHubLog", RPC_HUB_LOG, ScSetHubLog, InRpcHubLog, OutRpcHubLog)\r
 610 DECLARE_SC("GetHubLog", RPC_HUB_LOG, ScGetHubLog, InRpcHubLog, OutRpcHubLog)\r
 611 DECLARE_SC_EX("AddCa", RPC_HUB_ADD_CA, ScAddCa, InRpcHubAddCa, OutRpcHubAddCa, FreeRpcHubAddCa)\r
 612 DECLARE_SC_EX("EnumCa", RPC_HUB_ENUM_CA, ScEnumCa, InRpcHubEnumCa, OutRpcHubEnumCa, FreeRpcHubEnumCa)\r
 613 DECLARE_SC_EX("GetCa", RPC_HUB_GET_CA, ScGetCa, InRpcHubGetCa, OutRpcHubGetCa, FreeRpcHubGetCa)\r
 614 DECLARE_SC("DeleteCa", RPC_HUB_DELETE_CA, ScDeleteCa, InRpcHubDeleteCa, OutRpcHubDeleteCa)\r
 615 DECLARE_SC_EX("CreateLink", RPC_CREATE_LINK, ScCreateLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)\r
 616 DECLARE_SC_EX("GetLink", RPC_CREATE_LINK, ScGetLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)\r
 617 DECLARE_SC_EX("SetLink", RPC_CREATE_LINK, ScSetLink, InRpcCreateLink, OutRpcCreateLink, FreeRpcCreateLink)\r
 618 DECLARE_SC_EX("EnumLink", RPC_ENUM_LINK, ScEnumLink, InRpcEnumLink, OutRpcEnumLink, FreeRpcEnumLink)\r
 619 DECLARE_SC_EX("GetLinkStatus", RPC_LINK_STATUS, ScGetLinkStatus, InRpcLinkStatus, OutRpcLinkStatus, FreeRpcLinkStatus)\r
 620 DECLARE_SC("SetLinkOnline", RPC_LINK, ScSetLinkOnline, InRpcLink, OutRpcLink)\r
 621 DECLARE_SC("SetLinkOffline", RPC_LINK, ScSetLinkOffline, InRpcLink, OutRpcLink)\r
 622 DECLARE_SC("DeleteLink", RPC_LINK, ScDeleteLink, InRpcLink, OutRpcLink)\r
 623 DECLARE_SC("RenameLink", RPC_RENAME_LINK, ScRenameLink, InRpcRenameLink, OutRpcRenameLink)\r
 624 DECLARE_SC("AddAccess", RPC_ADD_ACCESS, ScAddAccess, InRpcAddAccess, OutRpcAddAccess)\r
 625 DECLARE_SC("DeleteAccess", RPC_DELETE_ACCESS, ScDeleteAccess, InRpcDeleteAccess, OutRpcDeleteAccess)\r
 626 DECLARE_SC_EX("EnumAccess", RPC_ENUM_ACCESS_LIST, ScEnumAccess, InRpcEnumAccessList, OutRpcEnumAccessList, FreeRpcEnumAccessList)\r
 627 DECLARE_SC_EX("SetAccessList", RPC_ENUM_ACCESS_LIST, ScSetAccessList, InRpcEnumAccessList, OutRpcEnumAccessList, FreeRpcEnumAccessList)\r
 628 DECLARE_SC_EX("CreateUser", RPC_SET_USER, ScCreateUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)\r
 629 DECLARE_SC_EX("SetUser", RPC_SET_USER, ScSetUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)\r
 630 DECLARE_SC_EX("GetUser", RPC_SET_USER, ScGetUser, InRpcSetUser, OutRpcSetUser, FreeRpcSetUser)\r
 631 DECLARE_SC("DeleteUser", RPC_DELETE_USER, ScDeleteUser, InRpcDeleteUser, OutRpcDeleteUser)\r
 632 DECLARE_SC_EX("EnumUser", RPC_ENUM_USER, ScEnumUser, InRpcEnumUser, OutRpcEnumUser, FreeRpcEnumUser)\r
 633 DECLARE_SC_EX("CreateGroup", RPC_SET_GROUP, ScCreateGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)\r
 634 DECLARE_SC_EX("SetGroup", RPC_SET_GROUP, ScSetGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)\r
 635 DECLARE_SC_EX("GetGroup", RPC_SET_GROUP, ScGetGroup, InRpcSetGroup, OutRpcSetGroup, FreeRpcSetGroup)\r
 636 DECLARE_SC("DeleteGroup", RPC_DELETE_USER, ScDeleteGroup, InRpcDeleteUser, OutRpcDeleteUser)\r
 637 DECLARE_SC_EX("EnumGroup", RPC_ENUM_GROUP, ScEnumGroup, InRpcEnumGroup, OutRpcEnumGroup, FreeRpcEnumGroup)\r
 638 DECLARE_SC_EX("EnumSession", RPC_ENUM_SESSION, ScEnumSession, InRpcEnumSession, OutRpcEnumSession, FreeRpcEnumSession)\r
 639 DECLARE_SC_EX("GetSessionStatus", RPC_SESSION_STATUS, ScGetSessionStatus, InRpcSessionStatus, OutRpcSessionStatus, FreeRpcSessionStatus)\r
 640 DECLARE_SC("DeleteSession", RPC_DELETE_SESSION, ScDeleteSession, InRpcDeleteSession, OutRpcDeleteSession)\r
 641 DECLARE_SC_EX("EnumMacTable", RPC_ENUM_MAC_TABLE, ScEnumMacTable, InRpcEnumMacTable, OutRpcEnumMacTable, FreeRpcEnumMacTable)\r
 642 DECLARE_SC("DeleteMacTable", RPC_DELETE_TABLE, ScDeleteMacTable, InRpcDeleteTable, OutRpcDeleteTable)\r
 643 DECLARE_SC_EX("EnumIpTable", RPC_ENUM_IP_TABLE, ScEnumIpTable, InRpcEnumIpTable, OutRpcEnumIpTable, FreeRpcEnumIpTable)\r
 644 DECLARE_SC("DeleteIpTable", RPC_DELETE_TABLE, ScDeleteIpTable, InRpcDeleteTable, OutRpcDeleteTable)\r
 645 DECLARE_SC("SetKeep", RPC_KEEP, ScSetKeep, InRpcKeep, OutRpcKeep)\r
 646 DECLARE_SC("GetKeep", RPC_KEEP, ScGetKeep, InRpcKeep, OutRpcKeep)\r
 647 DECLARE_SC("EnableSecureNAT", RPC_HUB, ScEnableSecureNAT, InRpcHub, OutRpcHub)\r
 648 DECLARE_SC("DisableSecureNAT", RPC_HUB, ScDisableSecureNAT, InRpcHub, OutRpcHub)\r
 649 DECLARE_SC("SetSecureNATOption", VH_OPTION, ScSetSecureNATOption, InVhOption, OutVhOption)\r
 650 DECLARE_SC("GetSecureNATOption", VH_OPTION, ScGetSecureNATOption, InVhOption, OutVhOption)\r
 651 DECLARE_SC_EX("EnumNAT", RPC_ENUM_NAT, ScEnumNAT, InRpcEnumNat, OutRpcEnumNat, FreeRpcEnumNat)\r
 652 DECLARE_SC_EX("EnumDHCP", RPC_ENUM_DHCP, ScEnumDHCP, InRpcEnumDhcp, OutRpcEnumDhcp, FreeRpcEnumDhcp)\r
 653 DECLARE_SC("GetSecureNATStatus", RPC_NAT_STATUS, ScGetSecureNATStatus, InRpcNatStatus, OutRpcNatStatus)\r
 654 DECLARE_SC_EX("EnumEthernet", RPC_ENUM_ETH, ScEnumEthernet, InRpcEnumEth, OutRpcEnumEth, FreeRpcEnumEth)\r
 655 DECLARE_SC("AddLocalBridge", RPC_LOCALBRIDGE, ScAddLocalBridge, InRpcLocalBridge, OutRpcLocalBridge)\r
 656 DECLARE_SC("DeleteLocalBridge", RPC_LOCALBRIDGE, ScDeleteLocalBridge, InRpcLocalBridge, OutRpcLocalBridge)\r
 657 DECLARE_SC_EX("EnumLocalBridge", RPC_ENUM_LOCALBRIDGE, ScEnumLocalBridge, InRpcEnumLocalBridge, OutRpcEnumLocalBridge, FreeRpcEnumLocalBridge)\r
 658 DECLARE_SC("GetBridgeSupport", RPC_BRIDGE_SUPPORT, ScGetBridgeSupport, InRpcBridgeSupport, OutRpcBridgeSupport)\r
 659 DECLARE_SC("RebootServer", RPC_TEST, ScRebootServer, InRpcTest, OutRpcTest)\r
 660 DECLARE_SC_EX("GetCaps", CAPSLIST, ScGetCaps, InRpcCapsList, OutRpcCapsList, FreeRpcCapsList)\r
 661 DECLARE_SC_EX("GetConfig", RPC_CONFIG, ScGetConfig, InRpcConfig, OutRpcConfig, FreeRpcConfig)\r
 662 DECLARE_SC_EX("SetConfig", RPC_CONFIG, ScSetConfig, InRpcConfig, OutRpcConfig, FreeRpcConfig)\r
 663 DECLARE_SC_EX("GetHubAdminOptions", RPC_ADMIN_OPTION, ScGetHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 664 DECLARE_SC_EX("SetHubAdminOptions", RPC_ADMIN_OPTION, ScSetHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 665 DECLARE_SC_EX("GetHubExtOptions", RPC_ADMIN_OPTION, ScGetHubExtOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 666 DECLARE_SC_EX("SetHubExtOptions", RPC_ADMIN_OPTION, ScSetHubExtOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 667 DECLARE_SC_EX("GetDefaultHubAdminOptions", RPC_ADMIN_OPTION, ScGetDefaultHubAdminOptions, InRpcAdminOption, OutRpcAdminOption, FreeRpcAdminOption)\r
 668 DECLARE_SC("AddL3Switch", RPC_L3SW, ScAddL3Switch, InRpcL3Sw, OutRpcL3Sw)\r
 669 DECLARE_SC("DelL3Switch", RPC_L3SW, ScDelL3Switch, InRpcL3Sw, OutRpcL3Sw)\r
 670 DECLARE_SC_EX("EnumL3Switch", RPC_ENUM_L3SW, ScEnumL3Switch, InRpcEnumL3Sw, OutRpcEnumL3Sw, FreeRpcEnumL3Sw)\r
 671 DECLARE_SC("StartL3Switch", RPC_L3SW, ScStartL3Switch, InRpcL3Sw, OutRpcL3Sw)\r
 672 DECLARE_SC("StopL3Switch", RPC_L3SW, ScStopL3Switch, InRpcL3Sw, OutRpcL3Sw)\r
 673 DECLARE_SC("AddL3If", RPC_L3IF, ScAddL3If, InRpcL3If, OutRpcL3If)\r
 674 DECLARE_SC("DelL3If", RPC_L3IF, ScDelL3If, InRpcL3If, OutRpcL3If)\r
 675 DECLARE_SC_EX("EnumL3If", RPC_ENUM_L3IF, ScEnumL3If, InRpcEnumL3If, OutRpcEnumL3If, FreeRpcEnumL3If)\r
 676 DECLARE_SC("AddL3Table", RPC_L3TABLE, ScAddL3Table, InRpcL3Table, OutRpcL3Table)\r
 677 DECLARE_SC("DelL3Table", RPC_L3TABLE, ScDelL3Table, InRpcL3Table, OutRpcL3Table)\r
 678 DECLARE_SC_EX("EnumL3Table", RPC_ENUM_L3TABLE, ScEnumL3Table, InRpcEnumL3Table, OutRpcEnumL3Table, FreeRpcEnumL3Table)\r
 679 DECLARE_SC_EX("EnumCrl", RPC_ENUM_CRL, ScEnumCrl, InRpcEnumCrl, OutRpcEnumCrl, FreeRpcEnumCrl)\r
 680 DECLARE_SC_EX("AddCrl", RPC_CRL, ScAddCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)\r
 681 DECLARE_SC_EX("DelCrl", RPC_CRL, ScDelCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)\r
 682 DECLARE_SC_EX("GetCrl", RPC_CRL, ScGetCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)\r
 683 DECLARE_SC_EX("SetCrl", RPC_CRL, ScSetCrl, InRpcCrl, OutRpcCrl, FreeRpcCrl)\r
 684 DECLARE_SC_EX("SetAcList", RPC_AC_LIST, ScSetAcList, InRpcAcList, OutRpcAcList, FreeRpcAcList)\r
 685 DECLARE_SC_EX("GetAcList", RPC_AC_LIST, ScGetAcList, InRpcAcList, OutRpcAcList, FreeRpcAcList)\r
 686 DECLARE_SC_EX("EnumLogFile", RPC_ENUM_LOG_FILE, ScEnumLogFile, InRpcEnumLogFile, OutRpcEnumLogFile, FreeRpcEnumLogFile)\r
 687 DECLARE_SC_EX("ReadLogFile", RPC_READ_LOG_FILE, ScReadLogFile, InRpcReadLogFile, OutRpcReadLogFile, FreeRpcReadLogFile)\r
 688 DECLARE_SC("AddLicenseKey", RPC_TEST, ScAddLicenseKey, InRpcTest, OutRpcTest)\r
 689 DECLARE_SC("DelLicenseKey", RPC_TEST, ScDelLicenseKey, InRpcTest, OutRpcTest)\r
 690 DECLARE_SC_EX("EnumLicenseKey", RPC_ENUM_LICENSE_KEY, ScEnumLicenseKey, InRpcEnumLicenseKey, OutRpcEnumLicenseKey, FreeRpcEnumLicenseKey)\r
 691 DECLARE_SC("GetLicenseStatus", RPC_LICENSE_STATUS, ScGetLicenseStatus, InRpcLicenseStatus, OutRpcLicenseStatus)\r
 692 DECLARE_SC("SetSysLog", SYSLOG_SETTING, ScSetSysLog, InRpcSysLogSetting, OutRpcSysLogSetting)\r
 693 DECLARE_SC("GetSysLog", SYSLOG_SETTING, ScGetSysLog, InRpcSysLogSetting, OutRpcSysLogSetting)\r
 694 DECLARE_SC_EX("EnumEthVLan", RPC_ENUM_ETH_VLAN, ScEnumEthVLan, InRpcEnumEthVLan, OutRpcEnumEthVLan, FreeRpcEnumEthVLan)\r
 695 DECLARE_SC("SetEnableEthVLan", RPC_TEST, ScSetEnableEthVLan, InRpcTest, OutRpcTest)\r
 696 DECLARE_SC_EX("SetHubMsg", RPC_MSG, ScSetHubMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)\r
 697 DECLARE_SC_EX("GetHubMsg", RPC_MSG, ScGetHubMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)\r
 698 DECLARE_SC("Crash", RPC_TEST, ScCrash, InRpcTest, OutRpcTest)\r
 699 DECLARE_SC_EX("GetAdminMsg", RPC_MSG, ScGetAdminMsg, InRpcMsg, OutRpcMsg, FreeRpcMsg)\r
 700 DECLARE_SC("Flush", RPC_TEST, ScFlush, InRpcTest, OutRpcTest)\r
 701 DECLARE_SC("Debug", RPC_TEST, ScDebug, InRpcTest, OutRpcTest)\r
 702 // RPC 呼び出し関数定義: ここまで\r
 703 \r
 704 \r
 705 // メッセージを設定\r
 706 UINT StSetHubMsg(ADMIN *a, RPC_MSG *t)\r
 707 {\r
 708         SERVER *s = a->Server;\r
 709         CEDAR *c = s->Cedar;\r
 710         HUB *h;\r
 711         UINT ret = ERR_NO_ERROR;\r
 712         char hubname[MAX_HUBNAME_LEN + 1];\r
 713 \r
 714         CHECK_RIGHT;\r
 715         NO_SUPPORT_FOR_BRIDGE;\r
 716         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
 717         {\r
 718                 return ERR_NOT_SUPPORTED;\r
 719         }\r
 720         if (UniStrLen(t->Msg) > HUB_MAXMSG_LEN)\r
 721         {\r
 722                 return ERR_MEMORY_NOT_ENOUGH;\r
 723         }\r
 724 \r
 725         StrCpy(hubname, sizeof(hubname), t->HubName);\r
 726 \r
 727         h = GetHub(c, hubname);\r
 728 \r
 729         if (h == NULL)\r
 730         {\r
 731                 ret = ERR_HUB_NOT_FOUND;\r
 732         }\r
 733         else\r
 734         {\r
 735                 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_msg") != 0)\r
 736                 {\r
 737                         ret = ERR_NOT_ENOUGH_RIGHT;\r
 738                 }\r
 739                 else\r
 740                 {\r
 741                         SetHubMsg(h, t->Msg);\r
 742                 }\r
 743 \r
 744                 ReleaseHub(h);\r
 745         }\r
 746 \r
 747         IncrementServerConfigRevision(s);\r
 748 \r
 749         return ret;\r
 750 }\r
 751 \r
 752 // メッセージを取得\r
 753 UINT StGetHubMsg(ADMIN *a, RPC_MSG *t)\r
 754 {\r
 755         SERVER *s = a->Server;\r
 756         CEDAR *c = s->Cedar;\r
 757         HUB *h;\r
 758         UINT ret = ERR_NO_ERROR;\r
 759         char hubname[MAX_HUBNAME_LEN + 1];\r
 760 \r
 761         CHECK_RIGHT;\r
 762         NO_SUPPORT_FOR_BRIDGE;\r
 763         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
 764         {\r
 765                 return ERR_NOT_SUPPORTED;\r
 766         }\r
 767         if (UniStrLen(t->Msg) > HUB_MAXMSG_LEN)\r
 768         {\r
 769                 return ERR_MEMORY_NOT_ENOUGH;\r
 770         }\r
 771 \r
 772         StrCpy(hubname, sizeof(hubname), t->HubName);\r
 773 \r
 774         FreeRpcMsg(t);\r
 775         Zero(t, sizeof(t));\r
 776 \r
 777         h = GetHub(c, hubname);\r
 778 \r
 779         if (h == NULL)\r
 780         {\r
 781                 ret = ERR_HUB_NOT_FOUND;\r
 782         }\r
 783         else\r
 784         {\r
 785                 t->Msg = GetHubMsg(h);\r
 786 \r
 787                 ReleaseHub(h);\r
 788         }\r
 789 \r
 790         return ret;\r
 791 }\r
 792 \r
 793 // デバッグ機能を実行する\r
 794 UINT StDebug(ADMIN *a, RPC_TEST *t)\r
 795 {\r
 796         SERVER *s = a->Server;\r
 797         CEDAR *c = s->Cedar;\r
 798         UINT ret = ERR_NO_ERROR;\r
 799         RPC_TEST t2;\r
 800 \r
 801         SERVER_ADMIN_ONLY;\r
 802 \r
 803         Zero(&t2, sizeof(t2));\r
 804 \r
 805         ret = SiDebug(s, &t2, t->IntValue, t->StrValue);\r
 806 \r
 807         if (ret == ERR_NO_ERROR)\r
 808         {\r
 809                 Copy(t, &t2, sizeof(RPC_TEST));\r
 810         }\r
 811         else\r
 812         {\r
 813                 Zero(t, sizeof(RPC_TEST));\r
 814         }\r
 815 \r
 816         return ret;\r
 817 }\r
 818 \r
 819 // 設定ファイルをフラッシュする\r
 820 UINT StFlush(ADMIN *a, RPC_TEST *t)\r
 821 {\r
 822         SERVER *s = a->Server;\r
 823         CEDAR *c = s->Cedar;\r
 824         UINT ret = ERR_NO_ERROR;\r
 825         UINT size;\r
 826 \r
 827         SERVER_ADMIN_ONLY;\r
 828 \r
 829         size = SiWriteConfigurationFile(s);\r
 830 \r
 831         t->IntValue = size;\r
 832 \r
 833         return ERR_NO_ERROR;\r
 834 }\r
 835 \r
 836 // クラッシュさせる (システム管理者だけが実行できる緊急時用コード)\r
 837 UINT StCrash(ADMIN *a, RPC_TEST *t)\r
 838 {\r
 839         SERVER *s = a->Server;\r
 840         CEDAR *c = s->Cedar;\r
 841         UINT ret = ERR_NO_ERROR;\r
 842 \r
 843         SERVER_ADMIN_ONLY;\r
 844 \r
 845 #ifdef  OS_WIN32\r
 846         MsSetEnableMinidump(false);\r
 847 #endif  // OS_WIN32\r
 848 \r
 849         CrashNow();\r
 850 \r
 851         return ERR_NO_ERROR;\r
 852 }\r
 853 \r
 854 // 管理者向けメッセージを取得する\r
 855 UINT StGetAdminMsg(ADMIN *a, RPC_MSG *t)\r
 856 {\r
 857         SERVER *s = a->Server;\r
 858         CEDAR *c = s->Cedar;\r
 859         UINT ret = ERR_NO_ERROR;\r
 860         RPC_WINVER server_ver;\r
 861         RPC_WINVER client_ver;\r
 862         wchar_t winver_msg_client[3800];\r
 863         wchar_t winver_msg_server[3800];\r
 864         wchar_t *utvpn_msg;\r
 865         UINT tmpsize;\r
 866         wchar_t *tmp;\r
 867 \r
 868         FreeRpcMsg(t);\r
 869         Zero(t, sizeof(RPC_MSG));\r
 870 \r
 871         // Windows バージョンチェック\r
 872         GetWinVer(&server_ver);\r
 873         Copy(&client_ver, &a->ClientWinVer, sizeof(RPC_WINVER));\r
 874 \r
 875         Zero(winver_msg_client, sizeof(winver_msg_client));\r
 876         Zero(winver_msg_server, sizeof(winver_msg_server));\r
 877 \r
 878         utvpn_msg = _UU("UTVPN_MSG");\r
 879 \r
 880         if (IsSupportedWinVer(&client_ver) == false)\r
 881         {\r
 882                 SYSTEMTIME st;\r
 883 \r
 884                 LocalTime(&st);\r
 885 \r
 886                 UniFormat(winver_msg_client, sizeof(winver_msg_client), _UU("WINVER_ERROR_FORMAT"),\r
 887                         _UU("WINVER_ERROR_PC_LOCAL"),\r
 888                         client_ver.Title,\r
 889                         _UU("WINVER_ERROR_VPNSERVER"),\r
 890                         SUPPORTED_WINDOWS_LIST,\r
 891                         _UU("WINVER_ERROR_PC_LOCAL"),\r
 892                         _UU("WINVER_ERROR_VPNSERVER"),\r
 893                         _UU("WINVER_ERROR_VPNSERVER"),\r
 894                         _UU("WINVER_ERROR_VPNSERVER"),\r
 895                         st.wYear, st.wMonth);\r
 896         }\r
 897 \r
 898         if (IsSupportedWinVer(&server_ver) == false)\r
 899         {\r
 900                 SYSTEMTIME st;\r
 901 \r
 902                 LocalTime(&st);\r
 903 \r
 904                 UniFormat(winver_msg_server, sizeof(winver_msg_server), _UU("WINVER_ERROR_FORMAT"),\r
 905                         _UU("WINVER_ERROR_PC_REMOTE"),\r
 906                         server_ver.Title,\r
 907                         _UU("WINVER_ERROR_VPNSERVER"),\r
 908                         SUPPORTED_WINDOWS_LIST,\r
 909                         _UU("WINVER_ERROR_PC_REMOTE"),\r
 910                         _UU("WINVER_ERROR_VPNSERVER"),\r
 911                         _UU("WINVER_ERROR_VPNSERVER"),\r
 912                         _UU("WINVER_ERROR_VPNSERVER"),\r
 913                         st.wYear, st.wMonth);\r
 914         }\r
 915 \r
 916         tmpsize = UniStrSize(winver_msg_client) + UniStrSize(winver_msg_server) + UniStrSize(utvpn_msg) + 100;\r
 917 \r
 918         tmp = ZeroMalloc(tmpsize);\r
 919         UniStrCat(tmp, tmpsize, utvpn_msg);\r
 920         UniStrCat(tmp, tmpsize, winver_msg_client);\r
 921         UniStrCat(tmp, tmpsize, winver_msg_server);\r
 922 \r
 923         t->Msg = tmp;\r
 924 \r
 925         return ERR_NO_ERROR;\r
 926 }\r
 927 \r
 928 // VLAN 透過設定一覧の取得\r
 929 UINT StEnumEthVLan(ADMIN *a, RPC_ENUM_ETH_VLAN *t)\r
 930 {\r
 931         SERVER *s = a->Server;\r
 932         CEDAR *c = s->Cedar;\r
 933         UINT ret = ERR_NO_ERROR;\r
 934 \r
 935         SERVER_ADMIN_ONLY;\r
 936 \r
 937 #ifdef  OS_WIN32\r
 938         if (GetServerCapsBool(s, "b_support_eth_vlan") == false)\r
 939         {\r
 940                 ret = ERR_NOT_SUPPORTED;\r
 941         }\r
 942         else\r
 943         {\r
 944                 FreeRpcEnumEthVLan(t);\r
 945                 Zero(t, sizeof(RPC_ENUM_ETH_VLAN));\r
 946 \r
 947                 if (EnumEthVLanWin32(t) == false)\r
 948                 {\r
 949                         ret = ERR_INTERNAL_ERROR;\r
 950                 }\r
 951         }\r
 952 #else   // OS_WIN32\r
 953         ret = ERR_NOT_SUPPORTED;\r
 954 #endif  // OS_WIN32\r
 955 \r
 956         return ret;\r
 957 }\r
 958 \r
 959 // VLAN 透過設定の設定\r
 960 UINT StSetEnableEthVLan(ADMIN *a, RPC_TEST *t)\r
 961 {\r
 962         SERVER *s = a->Server;\r
 963         CEDAR *c = s->Cedar;\r
 964         UINT ret = ERR_NO_ERROR;\r
 965 \r
 966         SERVER_ADMIN_ONLY;\r
 967 \r
 968 #ifdef  OS_WIN32\r
 969         if (GetServerCapsBool(s, "b_support_eth_vlan") == false)\r
 970         {\r
 971                 ret = ERR_NOT_SUPPORTED;\r
 972         }\r
 973         else if (MsIsAdmin() == false)\r
 974         {\r
 975                 ret = ERR_NOT_ENOUGH_RIGHT;\r
 976         }\r
 977         else\r
 978         {\r
 979                 if (SetVLanEnableStatus(t->StrValue, MAKEBOOL(t->IntValue)) == false)\r
 980                 {\r
 981                         ret = ERR_INTERNAL_ERROR;\r
 982                 }\r
 983         }\r
 984 #else   // OS_WIN32\r
 985         ret = ERR_NOT_SUPPORTED;\r
 986 #endif  // OS_WIN32\r
 987 \r
 988         return ret;\r
 989 }\r
 990 \r
 991 // ライセンス状態の取得\r
 992 // (ソフトイーサ社の製品 PacketiX VPN の管理に使えるように互換性を残している)\r
 993 UINT StGetLicenseStatus(ADMIN *a, RPC_LICENSE_STATUS *t)\r
 994 {\r
 995         SERVER *s = a->Server;\r
 996         CEDAR *c = s->Cedar;\r
 997         UINT ret = ERR_NO_ERROR;\r
 998         LICENSE_SYSTEM *ls = s->LicenseSystem;\r
 999         LICENSE_STATUS status;\r
1000 \r
1001         if (ls == NULL)\r
1002         {\r
1003                 return ERR_NOT_SUPPORTED;\r
1004         }\r
1005 \r
1006         NO_SUPPORT_FOR_BRIDGE;\r
1007 \r
1008         SERVER_ADMIN_ONLY;\r
1009 \r
1010         Zero(t, sizeof(RPC_LICENSE_STATUS));\r
1011 \r
1012         // 現在のライセンスステータスを取得\r
1013         LiParseCurrentLicenseStatus(ls, &status);\r
1014 \r
1015         t->EditionId = status.Edition;\r
1016         StrCpy(t->EditionStr, sizeof(t->EditionStr), status.EditionStr);\r
1017         t->SystemId = status.SystemId;\r
1018         t->SystemExpires = status.Expires;\r
1019         t->NumClientConnectLicense = status.NumClientLicense;\r
1020         t->NumBridgeConnectLicense = status.NumBridgeLicense;\r
1021         t->NumUserCreationLicense = status.NumUserLicense;\r
1022         t->SubscriptionExpires = status.SubscriptionExpires;\r
1023         t->IsSubscriptionExpired = status.IsSubscriptionExpired;\r
1024         t->NeedSubscription = status.NeedSubscription;\r
1025         t->AllowEnterpriseFunction = status.AllowEnterpriseFunction;\r
1026         t->ReleaseDate = c->BuiltDate;\r
1027 \r
1028         return ret;\r
1029 }\r
1030 \r
1031 // ライセンスキーの列挙\r
1032 // (ソフトイーサ社の製品 PacketiX VPN の管理に使えるように互換性を残している)\r
1033 UINT StEnumLicenseKey(ADMIN *a, RPC_ENUM_LICENSE_KEY *t)\r
1034 {\r
1035         SERVER *s = a->Server;\r
1036         CEDAR *c = s->Cedar;\r
1037         UINT ret = ERR_NO_ERROR;\r
1038         LICENSE_SYSTEM *ls = s->LicenseSystem;\r
1039 \r
1040         if (ls == NULL)\r
1041         {\r
1042                 return ERR_NOT_SUPPORTED;\r
1043         }\r
1044 \r
1045         NO_SUPPORT_FOR_BRIDGE;\r
1046 \r
1047         SERVER_ADMIN_ONLY;\r
1048 \r
1049         FreeRpcEnumLicenseKey(t);\r
1050         Zero(t, sizeof(RPC_ENUM_LICENSE_KEY));\r
1051 \r
1052         LockList(ls->LicenseList);\r
1053         {\r
1054                 UINT i;\r
1055 \r
1056                 t->NumItem = LIST_NUM(ls->LicenseList);\r
1057                 t->Items = ZeroMalloc(sizeof(RPC_ENUM_LICENSE_KEY_ITEM) * t->NumItem);\r
1058 \r
1059                 for (i = 0;i < t->NumItem;i++)\r
1060                 {\r
1061                         RPC_ENUM_LICENSE_KEY_ITEM *k = &t->Items[i];\r
1062                         LICENSE *e = LIST_DATA(ls->LicenseList, i);\r
1063 \r
1064                         k->Id = e->Id;\r
1065                         k->Expires = e->Expires;\r
1066                         StrCpy(k->LicenseId, sizeof(k->LicenseId), e->LicenseIdStr);\r
1067                         StrCpy(k->LicenseKey, sizeof(k->LicenseKey), e->LicenseKeyStr);\r
1068                         StrCpy(k->LicenseName, sizeof(k->LicenseName), e->Name);\r
1069                         k->Status = e->Status;\r
1070                         k->ProductId = e->ProductId;\r
1071                         k->SystemId = e->SystemId;\r
1072                         k->SerialId = e->SerialId;\r
1073                 }\r
1074         }\r
1075         UnlockList(ls->LicenseList);\r
1076 \r
1077         return ret;\r
1078 }\r
1079 \r
1080 // ライセンスキーの追加\r
1081 // (ソフトイーサ社の製品 PacketiX VPN の管理に使えるように互換性を残している)\r
1082 UINT StAddLicenseKey(ADMIN *a, RPC_TEST *t)\r
1083 {\r
1084         return ERR_NOT_SUPPORTED;\r
1085 }\r
1086 \r
1087 // ライセンスキーの削除\r
1088 // (ソフトイーサ社の製品 PacketiX VPN の管理に使えるように互換性を残している)\r
1089 UINT StDelLicenseKey(ADMIN *a, RPC_TEST *t)\r
1090 {\r
1091         return ERR_NOT_SUPPORTED;\r
1092 }\r
1093 \r
1094 // ログファイルのダウンロード\r
1095 BUF *DownloadFileFromServer(RPC *r, char *server_name, char *filepath, UINT total_size, DOWNLOAD_PROC *proc, void *param)\r
1096 {\r
1097         UINT offset;\r
1098         BUF *buf;\r
1099         // 引数チェック\r
1100         if (r == NULL || filepath == NULL)\r
1101         {\r
1102                 return NULL;\r
1103         }\r
1104 \r
1105         if (server_name == NULL)\r
1106         {\r
1107                 server_name = "";\r
1108         }\r
1109 \r
1110         offset = 0;\r
1111 \r
1112         buf = NewBuf();\r
1113 \r
1114         while (true)\r
1115         {\r
1116                 DOWNLOAD_PROGRESS g;\r
1117                 RPC_READ_LOG_FILE t;\r
1118                 UINT ret;\r
1119 \r
1120                 Zero(&t, sizeof(t));\r
1121                 StrCpy(t.FilePath, sizeof(t.FilePath), filepath);\r
1122                 t.Offset = offset;\r
1123                 StrCpy(t.ServerName, sizeof(t.ServerName), server_name);\r
1124 \r
1125                 ret = ScReadLogFile(r, &t);\r
1126 \r
1127                 if (ret != ERR_NO_ERROR)\r
1128                 {\r
1129                         // 失敗\r
1130                         FreeRpcReadLogFile(&t);\r
1131                         FreeBuf(buf);\r
1132                         return NULL;\r
1133                 }\r
1134 \r
1135                 if (t.Buffer == NULL)\r
1136                 {\r
1137                         // 最後まで読み込んだ\r
1138                         break;\r
1139                 }\r
1140 \r
1141                 // 現在の状況を更新\r
1142                 offset += t.Buffer->Size;\r
1143                 Zero(&g, sizeof(g));\r
1144                 g.Param = param;\r
1145                 g.CurrentSize = offset;\r
1146                 g.TotalSize = MAX(total_size, offset);\r
1147                 g.ProgressPercent = (UINT)(MAKESURE((UINT64)g.CurrentSize * 100ULL / (UINT64)(MAX(g.TotalSize, 1)), 0, 100ULL));\r
1148 \r
1149                 WriteBuf(buf, t.Buffer->Buf, t.Buffer->Size);\r
1150 \r
1151                 FreeRpcReadLogFile(&t);\r
1152 \r
1153                 if (proc != NULL)\r
1154                 {\r
1155                         if (proc(&g) == false)\r
1156                         {\r
1157                                 // ユーザーキャンセル\r
1158                                 FreeBuf(buf);\r
1159                                 return NULL;\r
1160                         }\r
1161                 }\r
1162         }\r
1163 \r
1164         if (buf->Size == 0)\r
1165         {\r
1166                 // ダウンロード失敗\r
1167                 FreeBuf(buf);\r
1168                 return NULL;\r
1169         }\r
1170 \r
1171         return buf;\r
1172 }\r
1173 \r
1174 // ログファイルの読み込み\r
1175 UINT StReadLogFile(ADMIN *a, RPC_READ_LOG_FILE *t)\r
1176 {\r
1177         SERVER *s = a->Server;\r
1178         CEDAR *c = s->Cedar;\r
1179         char logfilename[MAX_PATH];\r
1180         char servername[MAX_HOST_NAME_LEN + 1];\r
1181         UINT offset;\r
1182         bool local = true;\r
1183 \r
1184         if (IsEmptyStr(t->FilePath))\r
1185         {\r
1186                 return ERR_INVALID_PARAMETER;\r
1187         }\r
1188 \r
1189         StrCpy(logfilename, sizeof(logfilename), t->FilePath);\r
1190         StrCpy(servername, sizeof(servername), t->ServerName);\r
1191         offset = t->Offset;\r
1192 \r
1193         if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER)\r
1194         {\r
1195                 GetMachineName(servername, sizeof(servername));\r
1196         }\r
1197 \r
1198         // ログファイルを読み込む権限があるかどうか検査する\r
1199         if (a->LogFileList == NULL)\r
1200         {\r
1201                 // キャッシュ無し\r
1202                 return ERR_OBJECT_NOT_FOUND;\r
1203         }\r
1204         if (CheckLogFileNameFromEnumList(a->LogFileList, logfilename, servername) == false)\r
1205         {\r
1206                 // そのようなファイルは列挙リストに無い\r
1207                 return ERR_OBJECT_NOT_FOUND;\r
1208         }\r
1209 \r
1210         FreeRpcReadLogFile(t);\r
1211         Zero(t, sizeof(RPC_READ_LOG_FILE));\r
1212 \r
1213         if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
1214         {\r
1215                 UINT i;\r
1216 \r
1217                 // 要求されたファイルのサーバー名がクラスタメンバのホスト名\r
1218                 // と一致した場合はリモートサーバー上にファイルが存在するのでそれを読み込む\r
1219                 LockList(s->FarmMemberList);\r
1220                 {\r
1221                         for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
1222                         {\r
1223                                 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
1224 \r
1225                                 if (f->Me == false)\r
1226                                 {\r
1227                                         if (StrCmpi(f->hostname, servername) == 0)\r
1228                                         {\r
1229                                                 RPC_READ_LOG_FILE tt;\r
1230 \r
1231                                                 Zero(&tt, sizeof(tt));\r
1232                                                 local = false;\r
1233 \r
1234                                                 StrCpy(tt.ServerName, sizeof(tt.ServerName), servername);\r
1235                                                 StrCpy(tt.FilePath, sizeof(tt.FilePath), logfilename);\r
1236                                                 tt.Offset = offset;\r
1237 \r
1238                                                 if (SiCallReadLogFile(s, f, &tt))\r
1239                                                 {\r
1240                                                         if (tt.Buffer != NULL && tt.Buffer->Size > 0)\r
1241                                                         {\r
1242                                                                 t->Buffer = NewBuf();\r
1243                                                                 WriteBuf(t->Buffer, tt.Buffer->Buf, tt.Buffer->Size);\r
1244                                                         }\r
1245                                                 }\r
1246 \r
1247                                                 FreeRpcReadLogFile(&tt);\r
1248 \r
1249                                                 break;\r
1250                                         }\r
1251                                 }\r
1252                         }\r
1253                 }\r
1254                 UnlockList(s->FarmMemberList);\r
1255         }\r
1256 \r
1257         // ローカルファイルの読み込み\r
1258         if (local)\r
1259         {\r
1260                 SiReadLocalLogFile(s, logfilename, offset, t);\r
1261         }\r
1262 \r
1263         if (offset == 0)\r
1264         {\r
1265                 ALog(a, NULL, "LA_READ_LOG_FILE", servername, logfilename);\r
1266         }\r
1267 \r
1268         return ERR_NO_ERROR;\r
1269 }\r
1270 \r
1271 // ログファイルの列挙\r
1272 UINT StEnumLogFile(ADMIN *a, RPC_ENUM_LOG_FILE *t)\r
1273 {\r
1274         SERVER *s = a->Server;\r
1275         CEDAR *c = s->Cedar;\r
1276         UINT i;\r
1277         bool no_access = false;\r
1278 \r
1279         HUB *h;\r
1280 \r
1281         if (a->ServerAdmin == false)\r
1282         {\r
1283                 h = GetHub(c, a->HubName);\r
1284 \r
1285                 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_read_log_file") != 0)\r
1286                 {\r
1287                         no_access = true;\r
1288                 }\r
1289 \r
1290                 ReleaseHub(h);\r
1291         }\r
1292         else\r
1293         {\r
1294                 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
1295                 {\r
1296                         // クラスタコントローラで管理者がログファイルの一覧を取得する\r
1297                         // と高負荷になるため制限している\r
1298                         return ERR_NOT_SUPPORTED;\r
1299                 }\r
1300         }\r
1301 \r
1302         if (no_access)\r
1303         {\r
1304                 return ERR_NOT_ENOUGH_RIGHT;\r
1305         }\r
1306 \r
1307         FreeRpcEnumLogFile(t);\r
1308         Zero(t, sizeof(RPC_ENUM_LOG_FILE));\r
1309 \r
1310         // ローカルのログファイルを列挙する\r
1311         SiEnumLocalLogFileList(s, a->ServerAdmin ? NULL : a->HubName, t);\r
1312 \r
1313         if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
1314         {\r
1315                 UINT i;\r
1316                 LIST *tt_list = NewListFast(NULL);\r
1317 \r
1318                 LockList(s->FarmMemberList);\r
1319                 {\r
1320                         for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
1321                         {\r
1322                                 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
1323 \r
1324                                 if (f->Me == false)\r
1325                                 {\r
1326                                         // 他のメンバ上のログファイルを列挙する\r
1327                                         RPC_ENUM_LOG_FILE *tt;\r
1328                                         tt = ZeroMalloc(sizeof(RPC_ENUM_LOG_FILE));\r
1329 \r
1330                                         if (SiCallEnumLogFileList(s, f, tt, a->ServerAdmin ? "" : a->HubName))\r
1331                                         {\r
1332                                                 UINT i;\r
1333                                                 for (i = 0;i < tt->NumItem;i++)\r
1334                                                 {\r
1335                                                         RPC_ENUM_LOG_FILE_ITEM *e = &tt->Items[i];\r
1336 \r
1337                                                         StrCpy(e->ServerName, sizeof(e->ServerName), f->hostname);\r
1338                                                 }\r
1339 \r
1340                                                 Add(tt_list, tt);\r
1341                                         }\r
1342                                         else\r
1343                                         {\r
1344                                                 Free(tt);\r
1345                                         }\r
1346                                 }\r
1347                         }\r
1348                 }\r
1349                 UnlockList(s->FarmMemberList);\r
1350 \r
1351                 for (i = 0;i < LIST_NUM(tt_list);i++)\r
1352                 {\r
1353                         RPC_ENUM_LOG_FILE *tt = LIST_DATA(tt_list, i);\r
1354 \r
1355                         AdjoinRpcEnumLogFile(t, tt);\r
1356                         FreeRpcEnumLogFile(tt);\r
1357 \r
1358                         Free(tt);\r
1359                 }\r
1360 \r
1361                 ReleaseList(tt_list);\r
1362         }\r
1363 \r
1364         // RPC セッションに最後に列挙したログファイル一覧をキャッシュする\r
1365         if (a->LogFileList != NULL)\r
1366         {\r
1367                 FreeEnumLogFile(a->LogFileList);\r
1368         }\r
1369 \r
1370         a->LogFileList = NewListFast(CmpLogFile);\r
1371 \r
1372         for (i = 0;i < t->NumItem;i++)\r
1373         {\r
1374                 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];\r
1375                 LOG_FILE *f = ZeroMalloc(sizeof(LOG_FILE));\r
1376 \r
1377                 f->FileSize = e->FileSize;\r
1378                 f->UpdatedTime = e->UpdatedTime;\r
1379                 StrCpy(f->Path, sizeof(f->Path), e->FilePath);\r
1380                 StrCpy(f->ServerName, sizeof(f->ServerName), e->ServerName);\r
1381 \r
1382                 Insert(a->LogFileList, f);\r
1383         }\r
1384 \r
1385         return ERR_NO_ERROR;\r
1386 }\r
1387 \r
1388 \r
1389 // AC リストの取得\r
1390 UINT StGetAcList(ADMIN *a, RPC_AC_LIST *t)\r
1391 {\r
1392         return ERR_NOT_SUPPORTED;\r
1393 }\r
1394 \r
1395 // AC リストの設定\r
1396 UINT StSetAcList(ADMIN *a, RPC_AC_LIST *t)\r
1397 {\r
1398         return ERR_NOT_SUPPORTED;\r
1399 }\r
1400 \r
1401 // CRL の設定\r
1402 UINT StSetCrl(ADMIN *a, RPC_CRL *t)\r
1403 {\r
1404         SERVER *s = a->Server;\r
1405         CEDAR *c = s->Cedar;\r
1406         HUB *h;\r
1407         UINT ret = ERR_NO_ERROR;\r
1408         UINT key;\r
1409         char hubname[MAX_HUBNAME_LEN + 1];\r
1410 \r
1411         CHECK_RIGHT;\r
1412         NO_SUPPORT_FOR_BRIDGE;\r
1413         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
1414         {\r
1415                 return ERR_NOT_SUPPORTED;\r
1416         }\r
1417 \r
1418         StrCpy(hubname, sizeof(hubname), t->HubName);\r
1419         key = t->Key;\r
1420 \r
1421         h = GetHub(c, hubname);\r
1422 \r
1423         if (h == NULL)\r
1424         {\r
1425                 ret = ERR_HUB_NOT_FOUND;\r
1426         }\r
1427         else\r
1428         {\r
1429                 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_crl_list") != 0)\r
1430                 {\r
1431                         ret = ERR_NOT_ENOUGH_RIGHT;\r
1432                 }\r
1433                 else\r
1434                 {\r
1435                         if (h->HubDb == NULL)\r
1436                         {\r
1437                                 ret = ERR_NOT_SUPPORTED;\r
1438                         }\r
1439                         else\r
1440                         {\r
1441                                 LockList(h->HubDb->CrlList);\r
1442                                 {\r
1443                                         CRL *crl = ListKeyToPointer(h->HubDb->CrlList, t->Key);\r
1444 \r
1445                                         if (crl == NULL)\r
1446                                         {\r
1447                                                 ret = ERR_INTERNAL_ERROR;\r
1448                                         }\r
1449                                         else\r
1450                                         {\r
1451                                                 CRL *new_crl = CopyCrl(t->Crl);\r
1452                                                 if (ReplaceListPointer(h->HubDb->CrlList, crl, new_crl))\r
1453                                                 {\r
1454                                                         ALog(a, h, "LA_ADD_CRL");\r
1455                                                         FreeCrl(crl);\r
1456 \r
1457                                                         IncrementServerConfigRevision(s);\r
1458                                                 }\r
1459                                         }\r
1460                                 }\r
1461                                 UnlockList(h->HubDb->CrlList);\r
1462                         }\r
1463                 }\r
1464 \r
1465                 ReleaseHub(h);\r
1466         }\r
1467 \r
1468         return ret;\r
1469 }\r
1470 \r
1471 // CRL の取得\r
1472 UINT StGetCrl(ADMIN *a, RPC_CRL *t)\r
1473 {\r
1474         SERVER *s = a->Server;\r
1475         CEDAR *c = s->Cedar;\r
1476         HUB *h;\r
1477         UINT ret = ERR_NO_ERROR;\r
1478         UINT key;\r
1479         char hubname[MAX_HUBNAME_LEN + 1];\r
1480 \r
1481         CHECK_RIGHT;\r
1482         NO_SUPPORT_FOR_BRIDGE;\r
1483         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
1484         {\r
1485                 return ERR_NOT_SUPPORTED;\r
1486         }\r
1487 \r
1488         StrCpy(hubname, sizeof(hubname), t->HubName);\r
1489         key = t->Key;\r
1490 \r
1491         FreeRpcCrl(t);\r
1492         Zero(t, sizeof(RPC_CRL));\r
1493         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
1494         t->Key = key;\r
1495 \r
1496         h = GetHub(c, hubname);\r
1497 \r
1498         if (h == NULL)\r
1499         {\r
1500                 ret = ERR_HUB_NOT_FOUND;\r
1501         }\r
1502         else\r
1503         {\r
1504                 if (h->HubDb == NULL)\r
1505                 {\r
1506                         ret = ERR_NOT_SUPPORTED;\r
1507                 }\r
1508                 else\r
1509                 {\r
1510                         LockList(h->HubDb->CrlList);\r
1511                         {\r
1512                                 CRL *crl = ListKeyToPointer(h->HubDb->CrlList, t->Key);\r
1513 \r
1514                                 if (crl == NULL)\r
1515                                 {\r
1516                                         ret = ERR_INTERNAL_ERROR;\r
1517                                 }\r
1518                                 else\r
1519                                 {\r
1520                                         t->Crl = CopyCrl(crl);\r
1521                                 }\r
1522                         }\r
1523                         UnlockList(h->HubDb->CrlList);\r
1524                 }\r
1525 \r
1526                 ReleaseHub(h);\r
1527         }\r
1528 \r
1529         return ret;\r
1530 }\r
1531 \r
1532 // CRL の削除\r
1533 UINT StDelCrl(ADMIN *a, RPC_CRL *t)\r
1534 {\r
1535         SERVER *s = a->Server;\r
1536         CEDAR *c = s->Cedar;\r
1537         HUB *h;\r
1538         UINT ret = ERR_NO_ERROR;\r
1539         char hubname[MAX_HUBNAME_LEN + 1];\r
1540 \r
1541         CHECK_RIGHT;\r
1542         NO_SUPPORT_FOR_BRIDGE;\r
1543         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
1544         {\r
1545                 return ERR_NOT_SUPPORTED;\r
1546         }\r
1547 \r
1548         StrCpy(hubname, sizeof(hubname), t->HubName);\r
1549 \r
1550         h = GetHub(c, hubname);\r
1551 \r
1552         if (h == NULL)\r
1553         {\r
1554                 ret = ERR_HUB_NOT_FOUND;\r
1555         }\r
1556         else\r
1557         {\r
1558                 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_crl_list") != 0)\r
1559                 {\r
1560                         ret = ERR_NOT_ENOUGH_RIGHT;\r
1561                 }\r
1562                 else\r
1563                 {\r
1564                         if (h->HubDb == NULL)\r
1565                         {\r
1566                                 ret = ERR_NOT_SUPPORTED;\r
1567                         }\r
1568                         else\r
1569                         {\r
1570                                 LockList(h->HubDb->CrlList);\r
1571                                 {\r
1572                                         CRL *crl = ListKeyToPointer(h->HubDb->CrlList, t->Key);\r
1573 \r
1574                                         if (crl == NULL)\r
1575                                         {\r
1576                                                 ret = ERR_INTERNAL_ERROR;\r
1577                                         }\r
1578                                         else\r
1579                                         {\r
1580                                                 ALog(a, h, "LA_DEL_CRL");\r
1581                                                 FreeCrl(crl);\r
1582                                                 Delete(h->HubDb->CrlList, crl);\r
1583                                         }\r
1584                                 }\r
1585                                 UnlockList(h->HubDb->CrlList);\r
1586                         }\r
1587                 }\r
1588 \r
1589                 ReleaseHub(h);\r
1590         }\r
1591 \r
1592         return ret;\r
1593 }\r
1594 \r
1595 // CRL の追加\r
1596 UINT StAddCrl(ADMIN *a, RPC_CRL *t)\r
1597 {\r
1598         SERVER *s = a->Server;\r
1599         CEDAR *c = s->Cedar;\r
1600         HUB *h;\r
1601         UINT ret = ERR_NO_ERROR;\r
1602         char hubname[MAX_HUBNAME_LEN + 1];\r
1603 \r
1604         if (c->Bridge)\r
1605         {\r
1606                 return ERR_NOT_SUPPORTED;\r
1607         }\r
1608 \r
1609         CHECK_RIGHT;\r
1610         NO_SUPPORT_FOR_BRIDGE;\r
1611         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
1612         {\r
1613                 return ERR_NOT_SUPPORTED;\r
1614         }\r
1615 \r
1616         StrCpy(hubname, sizeof(hubname), t->HubName);\r
1617 \r
1618         h = GetHub(c, hubname);\r
1619 \r
1620         if (h == NULL)\r
1621         {\r
1622                 ret = ERR_HUB_NOT_FOUND;\r
1623         }\r
1624         else\r
1625         {\r
1626                 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_crl_list") != 0)\r
1627                 {\r
1628                         ret = ERR_NOT_ENOUGH_RIGHT;\r
1629                 }\r
1630                 else\r
1631                 {\r
1632                         if (h->HubDb == NULL)\r
1633                         {\r
1634                                 ret = ERR_NOT_SUPPORTED;\r
1635                         }\r
1636                         else\r
1637                         {\r
1638                                 LockList(h->HubDb->CrlList);\r
1639                                 {\r
1640                                         if (LIST_NUM(h->HubDb->CrlList) < MAX_HUB_CRLS)\r
1641                                         {\r
1642                                                 CRL *crl = CopyCrl(t->Crl);\r
1643 \r
1644                                                 Insert(h->HubDb->CrlList, crl);\r
1645 \r
1646                                                 ALog(a, h, "LA_SET_CRL");\r
1647 \r
1648                                                 IncrementServerConfigRevision(s);\r
1649                                         }\r
1650                                 }\r
1651                                 UnlockList(h->HubDb->CrlList);\r
1652                         }\r
1653                 }\r
1654 \r
1655                 ReleaseHub(h);\r
1656         }\r
1657 \r
1658         return ret;\r
1659 }\r
1660 \r
1661 // CRL の列挙\r
1662 UINT StEnumCrl(ADMIN *a, RPC_ENUM_CRL *t)\r
1663 {\r
1664         SERVER *s = a->Server;\r
1665         CEDAR *c = s->Cedar;\r
1666         HUB *h;\r
1667         UINT ret = ERR_NO_ERROR;\r
1668         char hubname[MAX_HUBNAME_LEN + 1];\r
1669 \r
1670         CHECK_RIGHT;\r
1671         NO_SUPPORT_FOR_BRIDGE;\r
1672         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
1673         {\r
1674                 return ERR_NOT_SUPPORTED;\r
1675         }\r
1676 \r
1677         StrCpy(hubname, sizeof(hubname), t->HubName);\r
1678         FreeRpcEnumCrl(t);\r
1679         Zero(t, sizeof(RPC_ENUM_CRL));\r
1680 \r
1681         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
1682 \r
1683         h = GetHub(c, hubname);\r
1684 \r
1685         if (h == NULL)\r
1686         {\r
1687                 ret = ERR_HUB_NOT_FOUND;\r
1688         }\r
1689         else\r
1690         {\r
1691                 if (h->HubDb == NULL)\r
1692                 {\r
1693                         ret = ERR_NOT_SUPPORTED;\r
1694                 }\r
1695                 else\r
1696                 {\r
1697                         LockList(h->HubDb->CrlList);\r
1698                         {\r
1699                                 UINT i;\r
1700 \r
1701                                 t->NumItem = LIST_NUM(h->HubDb->CrlList);\r
1702                                 t->Items = ZeroMalloc(sizeof(RPC_ENUM_CRL_ITEM) * t->NumItem);\r
1703 \r
1704                                 for (i = 0;i < LIST_NUM(h->HubDb->CrlList);i++)\r
1705                                 {\r
1706                                         CRL *crl = LIST_DATA(h->HubDb->CrlList, i);\r
1707                                         wchar_t *info = GenerateCrlStr(crl);\r
1708 \r
1709                                         UniStrCpy(t->Items[i].CrlInfo, sizeof(t->Items[i].CrlInfo), info);\r
1710                                         Free(info);\r
1711 \r
1712                                         t->Items[i].Key = POINTER_TO_KEY(crl);\r
1713                                 }\r
1714                         }\r
1715                         UnlockList(h->HubDb->CrlList);\r
1716                 }\r
1717 \r
1718                 ReleaseHub(h);\r
1719         }\r
1720 \r
1721         return ret;\r
1722 }\r
1723 \r
1724 // ルーティングテーブルの列挙\r
1725 UINT StEnumL3Table(ADMIN *a, RPC_ENUM_L3TABLE *t)\r
1726 {\r
1727         SERVER *s = a->Server;\r
1728         CEDAR *c = s->Cedar;\r
1729         UINT ret = ERR_NO_ERROR;\r
1730         L3SW *sw;\r
1731         char name[MAX_HUBNAME_LEN + 1];\r
1732 \r
1733         if (IsEmptyStr(t->Name))\r
1734         {\r
1735                 return ERR_INVALID_PARAMETER;\r
1736         }\r
1737 \r
1738         NO_SUPPORT_FOR_BRIDGE;\r
1739 \r
1740         StrCpy(name, sizeof(name), t->Name);\r
1741         FreeRpcEnumL3Table(t);\r
1742         Zero(t, sizeof(RPC_ENUM_L3TABLE));\r
1743         StrCpy(t->Name, sizeof(t->Name), name);\r
1744 \r
1745         sw = L3GetSw(c, t->Name);\r
1746 \r
1747         if (sw == NULL)\r
1748         {\r
1749                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
1750         }\r
1751         else\r
1752         {\r
1753                 UINT i;\r
1754 \r
1755                 Lock(sw->lock);\r
1756                 {\r
1757                         t->NumItem = LIST_NUM(sw->TableList);\r
1758                         t->Items = ZeroMalloc(sizeof(RPC_L3TABLE) * t->NumItem);\r
1759 \r
1760                         for (i = 0;i < t->NumItem;i++)\r
1761                         {\r
1762                                 L3TABLE *tbl = LIST_DATA(sw->TableList, i);\r
1763                                 RPC_L3TABLE *e = &t->Items[i];\r
1764 \r
1765                                 StrCpy(e->Name, sizeof(e->Name), name);\r
1766                                 e->NetworkAddress = tbl->NetworkAddress;\r
1767                                 e->SubnetMask = tbl->SubnetMask;\r
1768                                 e->GatewayAddress = tbl->GatewayAddress;\r
1769                                 e->Metric = tbl->Metric;\r
1770                         }\r
1771                 }\r
1772                 Unlock(sw->lock);\r
1773 \r
1774                 ReleaseL3Sw(sw);\r
1775         }\r
1776 \r
1777         return ret;\r
1778 }\r
1779 \r
1780 // ルーティングテーブルの削除\r
1781 UINT StDelL3Table(ADMIN *a, RPC_L3TABLE *t)\r
1782 {\r
1783         SERVER *s = a->Server;\r
1784         CEDAR *c = s->Cedar;\r
1785         UINT ret = ERR_NO_ERROR;\r
1786         L3SW *sw;\r
1787 \r
1788         SERVER_ADMIN_ONLY;\r
1789 \r
1790         NO_SUPPORT_FOR_BRIDGE;\r
1791 \r
1792         sw = L3GetSw(c, t->Name);\r
1793 \r
1794         if (sw == NULL)\r
1795         {\r
1796                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
1797         }\r
1798         else\r
1799         {\r
1800                 L3TABLE tbl;\r
1801 \r
1802                 Zero(&tbl, sizeof(tbl));\r
1803                 tbl.NetworkAddress = t->NetworkAddress;\r
1804                 tbl.SubnetMask = t->SubnetMask;\r
1805                 tbl.GatewayAddress = t->GatewayAddress;\r
1806                 tbl.Metric = t->Metric;\r
1807 \r
1808                 if (L3DelTable(sw, &tbl) == false)\r
1809                 {\r
1810                         ret = ERR_LAYER3_TABLE_DEL_FAILED;\r
1811                 }\r
1812                 else\r
1813                 {\r
1814                         char tmp[MAX_SIZE];\r
1815                         IPToStr32(tmp, sizeof(tmp), tbl.NetworkAddress);\r
1816                         ALog(a, NULL, "LA_DEL_L3_TABLE", tmp, t->Name);\r
1817 \r
1818                         IncrementServerConfigRevision(s);\r
1819                 }\r
1820 \r
1821                 ReleaseL3Sw(sw);\r
1822         }\r
1823 \r
1824         return ret;\r
1825 }\r
1826 \r
1827 // ルーティングテーブルの追加\r
1828 UINT StAddL3Table(ADMIN *a, RPC_L3TABLE *t)\r
1829 {\r
1830         SERVER *s = a->Server;\r
1831         CEDAR *c = s->Cedar;\r
1832         UINT ret = ERR_NO_ERROR;\r
1833         L3SW *sw;\r
1834 \r
1835         if (IsNetworkAddress32(t->NetworkAddress, t->SubnetMask) == false ||\r
1836                 IsHostIPAddress32(t->GatewayAddress) == false)\r
1837         {\r
1838                 return ERR_INVALID_PARAMETER;\r
1839         }\r
1840 \r
1841         SERVER_ADMIN_ONLY;\r
1842 \r
1843         NO_SUPPORT_FOR_BRIDGE;\r
1844 \r
1845         sw = L3GetSw(c, t->Name);\r
1846 \r
1847         if (sw == NULL)\r
1848         {\r
1849                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
1850         }\r
1851         else\r
1852         {\r
1853                 L3TABLE tbl;\r
1854 \r
1855                 Zero(&tbl, sizeof(tbl));\r
1856                 tbl.NetworkAddress = t->NetworkAddress;\r
1857                 tbl.SubnetMask = t->SubnetMask;\r
1858                 tbl.GatewayAddress = t->GatewayAddress;\r
1859                 tbl.Metric = t->Metric;\r
1860 \r
1861                 if (L3AddTable(sw, &tbl) == false)\r
1862                 {\r
1863                         ret = ERR_LAYER3_TABLE_ADD_FAILED;\r
1864                 }\r
1865                 else\r
1866                 {\r
1867                         char tmp[MAX_SIZE];\r
1868                         IPToStr32(tmp, sizeof(tmp), tbl.NetworkAddress);\r
1869                         ALog(a, NULL, "LA_ADD_L3_TABLE", tmp, t->Name);\r
1870 \r
1871                         IncrementServerConfigRevision(s);\r
1872                 }\r
1873 \r
1874                 ReleaseL3Sw(sw);\r
1875         }\r
1876 \r
1877         return ret;\r
1878 }\r
1879 \r
1880 // インターフェイスの列挙\r
1881 UINT StEnumL3If(ADMIN *a, RPC_ENUM_L3IF *t)\r
1882 {\r
1883         SERVER *s = a->Server;\r
1884         CEDAR *c = s->Cedar;\r
1885         UINT ret = ERR_NO_ERROR;\r
1886         L3SW *sw;\r
1887         char name[MAX_HUBNAME_LEN + 1];\r
1888 \r
1889         NO_SUPPORT_FOR_BRIDGE;\r
1890 \r
1891         StrCpy(name, sizeof(name), t->Name);\r
1892 \r
1893         FreeRpcEnumL3If(t);\r
1894         Zero(t, sizeof(RPC_ENUM_L3IF));\r
1895 \r
1896         StrCpy(t->Name, sizeof(t->Name), name);\r
1897 \r
1898         sw = L3GetSw(c, t->Name);\r
1899 \r
1900         if (sw == NULL)\r
1901         {\r
1902                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
1903         }\r
1904         else\r
1905         {\r
1906                 Lock(sw->lock);\r
1907                 {\r
1908                         UINT i;\r
1909 \r
1910                         t->NumItem = LIST_NUM(sw->IfList);\r
1911                         t->Items = ZeroMalloc(sizeof(RPC_L3IF) * t->NumItem);\r
1912 \r
1913                         for (i = 0;i < t->NumItem;i++)\r
1914                         {\r
1915                                 L3IF *f = LIST_DATA(sw->IfList, i);\r
1916                                 RPC_L3IF *e = &t->Items[i];\r
1917 \r
1918                                 StrCpy(e->Name, sizeof(e->Name), sw->Name);\r
1919                                 StrCpy(e->HubName, sizeof(e->HubName), f->HubName);\r
1920                                 e->IpAddress = f->IpAddress;\r
1921                                 e->SubnetMask = f->SubnetMask;\r
1922                         }\r
1923                 }\r
1924                 Unlock(sw->lock);\r
1925 \r
1926                 ReleaseL3Sw(sw);\r
1927         }\r
1928 \r
1929         return ret;\r
1930 }\r
1931 \r
1932 // インターフェイスの削除\r
1933 UINT StDelL3If(ADMIN *a, RPC_L3IF *t)\r
1934 {\r
1935         SERVER *s = a->Server;\r
1936         CEDAR *c = s->Cedar;\r
1937         UINT ret = ERR_NO_ERROR;\r
1938         L3SW *sw;\r
1939 \r
1940         NO_SUPPORT_FOR_BRIDGE;\r
1941 \r
1942         SERVER_ADMIN_ONLY;\r
1943 \r
1944         sw = L3GetSw(c, t->Name);\r
1945 \r
1946         if (sw == NULL)\r
1947         {\r
1948                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
1949         }\r
1950         else\r
1951         {\r
1952                 if (L3DelIf(sw, t->HubName) == false)\r
1953                 {\r
1954                         ret = ERR_LAYER3_IF_DEL_FAILED;\r
1955                 }\r
1956                 else\r
1957                 {\r
1958                         ALog(a, NULL, "LA_DEL_L3_IF", t->HubName, t->Name);\r
1959 \r
1960                         IncrementServerConfigRevision(s);\r
1961                 }\r
1962                 ReleaseL3Sw(sw);\r
1963         }\r
1964 \r
1965         return ret;\r
1966 }\r
1967 \r
1968 // インターフェイスの追加\r
1969 UINT StAddL3If(ADMIN *a, RPC_L3IF *t)\r
1970 {\r
1971         SERVER *s = a->Server;\r
1972         CEDAR *c = s->Cedar;\r
1973         UINT ret = ERR_NO_ERROR;\r
1974         L3SW *sw;\r
1975 \r
1976         if (IsSubnetMask32(t->SubnetMask) == false || IsHostIPAddress32(t->IpAddress) == false)\r
1977         {\r
1978                 return ERR_INVALID_PARAMETER;\r
1979         }\r
1980         if ((t->IpAddress & (~t->SubnetMask)) == 0)\r
1981         {\r
1982                 return ERR_INVALID_PARAMETER;\r
1983         }\r
1984 \r
1985         NO_SUPPORT_FOR_BRIDGE;\r
1986 \r
1987         SERVER_ADMIN_ONLY;\r
1988 \r
1989         sw = L3GetSw(c, t->Name);\r
1990 \r
1991         if (sw == NULL)\r
1992         {\r
1993                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
1994         }\r
1995         else\r
1996         {\r
1997                 Lock(sw->lock);\r
1998                 {\r
1999                         if (L3SearchIf(sw, t->HubName) != NULL)\r
2000                         {\r
2001                                 // すでに存在する\r
2002                                 ret = ERR_LAYER3_IF_EXISTS;\r
2003                         }\r
2004                         else\r
2005                         {\r
2006                                 if (L3AddIf(sw, t->HubName, t->IpAddress, t->SubnetMask) == false)\r
2007                                 {\r
2008                                         ret = ERR_LAYER3_IF_ADD_FAILED;\r
2009                                 }\r
2010                                 else\r
2011                                 {\r
2012                                         ALog(a, NULL, "LA_ADD_L3_IF", t->HubName, t->Name);\r
2013 \r
2014                                         IncrementServerConfigRevision(s);\r
2015                                 }\r
2016                         }\r
2017                 }\r
2018                 Unlock(sw->lock);\r
2019                 ReleaseL3Sw(sw);\r
2020         }\r
2021 \r
2022         return ret;\r
2023 }\r
2024 \r
2025 // Layer-3 スイッチの停止\r
2026 UINT StStopL3Switch(ADMIN *a, RPC_L3SW *t)\r
2027 {\r
2028         SERVER *s = a->Server;\r
2029         CEDAR *c = s->Cedar;\r
2030         UINT ret = ERR_NO_ERROR;\r
2031         L3SW *sw;\r
2032 \r
2033         if (IsEmptyStr(t->Name))\r
2034         {\r
2035                 return ERR_INVALID_PARAMETER;\r
2036         }\r
2037 \r
2038         NO_SUPPORT_FOR_BRIDGE;\r
2039 \r
2040         SERVER_ADMIN_ONLY;\r
2041 \r
2042         sw = L3GetSw(c, t->Name);\r
2043 \r
2044         if (sw == NULL)\r
2045         {\r
2046                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
2047         }\r
2048         else\r
2049         {\r
2050                 L3SwStop(sw);\r
2051                 ALog(a, NULL, "LA_STOP_L3_SW", sw->Name);\r
2052                 ReleaseL3Sw(sw);\r
2053 \r
2054                 IncrementServerConfigRevision(s);\r
2055         }\r
2056 \r
2057         return ret;\r
2058 }\r
2059 \r
2060 // Layer-3 スイッチの開始\r
2061 UINT StStartL3Switch(ADMIN *a, RPC_L3SW *t)\r
2062 {\r
2063         SERVER *s = a->Server;\r
2064         CEDAR *c = s->Cedar;\r
2065         UINT ret = ERR_NO_ERROR;\r
2066         L3SW *sw;\r
2067 \r
2068         if (IsEmptyStr(t->Name))\r
2069         {\r
2070                 return ERR_INVALID_PARAMETER;\r
2071         }\r
2072 \r
2073         NO_SUPPORT_FOR_BRIDGE;\r
2074 \r
2075         SERVER_ADMIN_ONLY;\r
2076 \r
2077         sw = L3GetSw(c, t->Name);\r
2078 \r
2079         if (sw == NULL)\r
2080         {\r
2081                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
2082         }\r
2083         else\r
2084         {\r
2085                 Lock(sw->lock);\r
2086                 {\r
2087                         // 登録されているインターフェイス数を検査する\r
2088                         if (LIST_NUM(sw->IfList) >= 1)\r
2089                         {\r
2090                                 L3SwStart(sw);\r
2091 \r
2092                                 ALog(a, NULL, "LA_START_L3_SW", sw->Name);\r
2093 \r
2094                                 IncrementServerConfigRevision(s);\r
2095                         }\r
2096                         else\r
2097                         {\r
2098                                 ret = ERR_LAYER3_CANT_START_SWITCH;\r
2099                         }\r
2100                 }\r
2101                 Unlock(sw->lock);\r
2102 \r
2103                 ReleaseL3Sw(sw);\r
2104         }\r
2105 \r
2106         return ret;\r
2107 }\r
2108 \r
2109 // Layer-3 スイッチの列挙\r
2110 UINT StEnumL3Switch(ADMIN *a, RPC_ENUM_L3SW *t)\r
2111 {\r
2112         UINT i;\r
2113         SERVER *s = a->Server;\r
2114         CEDAR *c = s->Cedar;\r
2115         UINT ret = ERR_NO_ERROR;\r
2116 \r
2117         NO_SUPPORT_FOR_BRIDGE;\r
2118 \r
2119         FreeRpcEnumL3Sw(t);\r
2120         Zero(t, sizeof(RPC_ENUM_L3SW));\r
2121 \r
2122         LockList(c->L3SwList);\r
2123         {\r
2124                 t->NumItem = LIST_NUM(c->L3SwList);\r
2125                 t->Items = ZeroMalloc(sizeof(RPC_ENUM_L3SW_ITEM) * t->NumItem);\r
2126                 for (i = 0;i < LIST_NUM(c->L3SwList);i++)\r
2127                 {\r
2128                         L3SW *sw = LIST_DATA(c->L3SwList, i);\r
2129                         RPC_ENUM_L3SW_ITEM *e = &t->Items[i];\r
2130 \r
2131                         Lock(sw->lock);\r
2132                         {\r
2133                                 StrCpy(e->Name, sizeof(e->Name), sw->Name);\r
2134                                 e->NumInterfaces = LIST_NUM(sw->IfList);\r
2135                                 e->NumTables = LIST_NUM(sw->TableList);\r
2136                                 e->Active = sw->Active;\r
2137                                 e->Online = sw->Online;\r
2138                         }\r
2139                         Unlock(sw->lock);\r
2140                 }\r
2141         }\r
2142         UnlockList(c->L3SwList);\r
2143 \r
2144         return ret;\r
2145 }\r
2146 \r
2147 // Layer-3 スイッチの削除\r
2148 UINT StDelL3Switch(ADMIN *a, RPC_L3SW *t)\r
2149 {\r
2150         SERVER *s = a->Server;\r
2151         CEDAR *c = s->Cedar;\r
2152         UINT ret = ERR_NO_ERROR;\r
2153 \r
2154         if (IsEmptyStr(t->Name))\r
2155         {\r
2156                 return ERR_INVALID_PARAMETER;\r
2157         }\r
2158 \r
2159         NO_SUPPORT_FOR_BRIDGE;\r
2160 \r
2161         SERVER_ADMIN_ONLY;\r
2162 \r
2163         if (L3DelSw(c, t->Name) == false)\r
2164         {\r
2165                 ret = ERR_LAYER3_SW_NOT_FOUND;\r
2166         }\r
2167         else\r
2168         {\r
2169                 ALog(a, NULL, "LA_DEL_L3_SW", t->Name);\r
2170 \r
2171                 IncrementServerConfigRevision(s);\r
2172         }\r
2173 \r
2174         return ret;\r
2175 }\r
2176 \r
2177 // Layer-3 スイッチの追加\r
2178 UINT StAddL3Switch(ADMIN *a, RPC_L3SW *t)\r
2179 {\r
2180         SERVER *s = a->Server;\r
2181         CEDAR *c = s->Cedar;\r
2182         UINT ret = ERR_NO_ERROR;\r
2183         L3SW *sw;\r
2184 \r
2185         NO_SUPPORT_FOR_BRIDGE;\r
2186 \r
2187         if (IsEmptyStr(t->Name))\r
2188         {\r
2189                 return ERR_INVALID_PARAMETER;\r
2190         }\r
2191 \r
2192         if (IsSafeStr(t->Name) == false)\r
2193         {\r
2194                 return ERR_INVALID_PARAMETER;\r
2195         }\r
2196 \r
2197         SERVER_ADMIN_ONLY;\r
2198 \r
2199         // 重複チェック\r
2200         sw = L3GetSw(c, t->Name);\r
2201         if (sw != NULL)\r
2202         {\r
2203                 // すでに存在する\r
2204                 ReleaseL3Sw(sw);\r
2205                 ret = ERR_LAYER3_SW_EXISTS;\r
2206         }\r
2207         else\r
2208         {\r
2209                 LockList(c->L3SwList);\r
2210                 {\r
2211                         if (LIST_NUM(c->L3SwList) >= GetServerCapsInt(s, "i_max_l3_sw"))\r
2212                         {\r
2213                                 // これ以上作成できない\r
2214                                 sw = NULL;\r
2215                         }\r
2216                         else\r
2217                         {\r
2218                                 // 作成する\r
2219                                 sw = L3AddSw(c, t->Name);\r
2220 \r
2221                                 if (sw != NULL)\r
2222                                 {\r
2223                                         ALog(a, NULL, "LA_ADD_L3_SW", t->Name);\r
2224 \r
2225                                         IncrementServerConfigRevision(s);\r
2226                                 }\r
2227                         }\r
2228                 }\r
2229                 UnlockList(c->L3SwList);\r
2230 \r
2231                 if (sw == NULL)\r
2232                 {\r
2233                         // 失敗\r
2234                         ret = ERR_INTERNAL_ERROR;\r
2235                 }\r
2236                 else\r
2237                 {\r
2238                         // 成功\r
2239                         ReleaseL3Sw(sw);\r
2240                 }\r
2241         }\r
2242 \r
2243         return ret;\r
2244 }\r
2245 \r
2246 // 仮想 HUB の拡張オプションを設定する\r
2247 UINT StSetHubExtOptions(ADMIN *a, RPC_ADMIN_OPTION *t)\r
2248 {\r
2249         SERVER *s = a->Server;\r
2250         CEDAR *c = s->Cedar;\r
2251         HUB *h;\r
2252 \r
2253         bool not_server_admin = false;\r
2254 \r
2255         if (t->NumItem > MAX_HUB_ADMIN_OPTIONS)\r
2256         {\r
2257                 return ERR_TOO_MANT_ITEMS;\r
2258         }\r
2259 \r
2260         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
2261         {\r
2262                 return ERR_NOT_SUPPORTED;\r
2263         }\r
2264 \r
2265         CHECK_RIGHT;\r
2266 \r
2267         if (a->ServerAdmin == false)\r
2268         {\r
2269                 not_server_admin = true;\r
2270         }\r
2271 \r
2272         LockHubList(c);\r
2273         {\r
2274                 h = GetHub(c, t->HubName);\r
2275         }\r
2276         UnlockHubList(c);\r
2277 \r
2278         if (h == NULL)\r
2279         {\r
2280                 return ERR_HUB_NOT_FOUND;\r
2281         }\r
2282 \r
2283         if (GetHubAdminOption(h, "deny_hub_admin_change_ext_option") && not_server_admin)\r
2284         {\r
2285                 // 十分な管理権限が無い\r
2286                 ReleaseHub(h);\r
2287 \r
2288                 return ERR_NOT_ENOUGH_RIGHT;\r
2289         }\r
2290 \r
2291         // 設定の実行\r
2292         Lock(h->lock);\r
2293         {\r
2294                 DataToHubOptionStruct(h->Option, t);\r
2295         }\r
2296         Unlock(h->lock);\r
2297 \r
2298         ALog(a, NULL, "LA_SET_HUB_EXT_OPTION", h->Name);\r
2299 \r
2300         h->CurrentVersion++;\r
2301         SiHubUpdateProc(h);\r
2302 \r
2303         ReleaseHub(h);\r
2304 \r
2305         IncrementServerConfigRevision(s);\r
2306 \r
2307         return ERR_NO_ERROR;\r
2308 }\r
2309 \r
2310 // 仮想 HUB の拡張オプションを取得する\r
2311 UINT StGetHubExtOptions(ADMIN *a, RPC_ADMIN_OPTION *t)\r
2312 {\r
2313         SERVER *s = a->Server;\r
2314         CEDAR *c = s->Cedar;\r
2315         HUB *h;\r
2316 \r
2317         CHECK_RIGHT;\r
2318 \r
2319         LockHubList(c);\r
2320         {\r
2321                 h = GetHub(c, t->HubName);\r
2322         }\r
2323         UnlockHubList(c);\r
2324 \r
2325         if (h == NULL)\r
2326         {\r
2327                 return ERR_HUB_NOT_FOUND;\r
2328         }\r
2329 \r
2330         FreeRpcAdminOption(t);\r
2331         Zero(t, sizeof(RPC_ADMIN_OPTION));\r
2332 \r
2333         StrCpy(t->HubName, sizeof(t->HubName), h->Name);\r
2334 \r
2335         // 設定の取得\r
2336         Lock(h->lock);\r
2337         {\r
2338                 HubOptionStructToData(t, h->Option, h->Name);\r
2339         }\r
2340         Unlock(h->lock);\r
2341 \r
2342         ReleaseHub(h);\r
2343 \r
2344         return ERR_NO_ERROR;\r
2345 }\r
2346 \r
2347 // 仮想 HUB の管理オプションを設定する\r
2348 UINT StSetHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t)\r
2349 {\r
2350         UINT i;\r
2351         SERVER *s = a->Server;\r
2352         CEDAR *c = s->Cedar;\r
2353         HUB *h;\r
2354 \r
2355         bool not_server_admin = false;\r
2356 \r
2357         if (t->NumItem > MAX_HUB_ADMIN_OPTIONS)\r
2358         {\r
2359                 return ERR_TOO_MANT_ITEMS;\r
2360         }\r
2361 \r
2362         NO_SUPPORT_FOR_BRIDGE;\r
2363         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
2364         {\r
2365                 return ERR_NOT_SUPPORTED;\r
2366         }\r
2367 \r
2368         CHECK_RIGHT;\r
2369 \r
2370         if (a->ServerAdmin == false)\r
2371         {\r
2372                 not_server_admin = true;\r
2373         }\r
2374 \r
2375         LockHubList(c);\r
2376         {\r
2377                 h = GetHub(c, t->HubName);\r
2378         }\r
2379         UnlockHubList(c);\r
2380 \r
2381         if (h == NULL)\r
2382         {\r
2383                 return ERR_HUB_NOT_FOUND;\r
2384         }\r
2385 \r
2386         if (GetHubAdminOption(h, "allow_hub_admin_change_option") == false\r
2387                 && not_server_admin)\r
2388         {\r
2389                 // 十分な管理権限が無い\r
2390                 ReleaseHub(h);\r
2391 \r
2392                 return ERR_NOT_ENOUGH_RIGHT;\r
2393         }\r
2394 \r
2395         LockList(h->AdminOptionList);\r
2396         {\r
2397                 DeleteAllHubAdminOption(h, false);\r
2398 \r
2399                 for (i = 0;i < t->NumItem;i++)\r
2400                 {\r
2401                         ADMIN_OPTION *e = &t->Items[i];\r
2402                         ADMIN_OPTION *a = ZeroMalloc(sizeof(ADMIN_OPTION));\r
2403 \r
2404                         StrCpy(a->Name, sizeof(a->Name), e->Name);\r
2405                         a->Value = e->Value;\r
2406 \r
2407                         Insert(h->AdminOptionList, a);\r
2408                 }\r
2409 \r
2410                 AddHubAdminOptionsDefaults(h, false);\r
2411         }\r
2412         UnlockList(h->AdminOptionList);\r
2413 \r
2414         ALog(a, NULL, "LA_SET_HUB_ADMIN_OPTION", h->Name);\r
2415 \r
2416         h->CurrentVersion++;\r
2417         SiHubUpdateProc(h);\r
2418 \r
2419         ReleaseHub(h);\r
2420 \r
2421         IncrementServerConfigRevision(s);\r
2422 \r
2423         return ERR_NO_ERROR;\r
2424 }\r
2425 \r
2426 // 仮想 HUB の管理オプションを取得する\r
2427 UINT StGetHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t)\r
2428 {\r
2429         UINT i;\r
2430         SERVER *s = a->Server;\r
2431         CEDAR *c = s->Cedar;\r
2432         HUB *h;\r
2433 \r
2434         CHECK_RIGHT;\r
2435 \r
2436         NO_SUPPORT_FOR_BRIDGE;\r
2437         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
2438         {\r
2439                 return ERR_NOT_SUPPORTED;\r
2440         }\r
2441 \r
2442         LockHubList(c);\r
2443         {\r
2444                 h = GetHub(c, t->HubName);\r
2445         }\r
2446         UnlockHubList(c);\r
2447 \r
2448         if (h == NULL)\r
2449         {\r
2450                 return ERR_HUB_NOT_FOUND;\r
2451         }\r
2452 \r
2453         FreeRpcAdminOption(t);\r
2454         Zero(t, sizeof(RPC_ADMIN_OPTION));\r
2455 \r
2456         StrCpy(t->HubName, sizeof(t->HubName), h->Name);\r
2457 \r
2458         LockList(h->AdminOptionList);\r
2459         {\r
2460                 t->NumItem = LIST_NUM(h->AdminOptionList);\r
2461                 t->Items = ZeroMalloc(sizeof(ADMIN_OPTION) * t->NumItem);\r
2462 \r
2463                 for (i = 0;i < t->NumItem;i++)\r
2464                 {\r
2465                         ADMIN_OPTION *a = LIST_DATA(h->AdminOptionList, i);\r
2466                         ADMIN_OPTION *e = &t->Items[i];\r
2467 \r
2468                         StrCpy(e->Name, sizeof(e->Name), a->Name);\r
2469                         e->Value = a->Value;\r
2470                 }\r
2471         }\r
2472         UnlockList(h->AdminOptionList);\r
2473 \r
2474         ReleaseHub(h);\r
2475 \r
2476         return ERR_NO_ERROR;\r
2477 }\r
2478 \r
2479 // デフォルトの管理オプションの一覧を取得する\r
2480 UINT StGetDefaultHubAdminOptions(ADMIN *a, RPC_ADMIN_OPTION *t)\r
2481 {\r
2482         UINT i;\r
2483 \r
2484         NO_SUPPORT_FOR_BRIDGE;\r
2485         if (a->Server->ServerType == SERVER_TYPE_FARM_MEMBER)\r
2486         {\r
2487                 return ERR_NOT_SUPPORTED;\r
2488         }\r
2489 \r
2490         FreeRpcAdminOption(t);\r
2491         Zero(t, sizeof(RPC_ADMIN_OPTION));\r
2492 \r
2493         t->NumItem = num_admin_options;\r
2494         t->Items = ZeroMalloc(sizeof(ADMIN_OPTION) * t->NumItem);\r
2495 \r
2496         for (i = 0;i < t->NumItem;i++)\r
2497         {\r
2498                 ADMIN_OPTION *a = &t->Items[i];\r
2499 \r
2500                 StrCpy(a->Name, sizeof(a->Name), admin_options[i].Name);\r
2501                 a->Value = admin_options[i].Value;\r
2502         }\r
2503 \r
2504         return ERR_NO_ERROR;\r
2505 }\r
2506 \r
2507 // config の取得\r
2508 UINT StGetConfig(ADMIN *a, RPC_CONFIG *t)\r
2509 {\r
2510         SERVER *s;\r
2511 \r
2512         SERVER_ADMIN_ONLY;\r
2513 \r
2514         FreeRpcConfig(t);\r
2515         Zero(t, sizeof(RPC_CONFIG));\r
2516 \r
2517         s = a->Server;\r
2518 \r
2519         ALog(a, NULL, "LA_GET_CONFIG");\r
2520 \r
2521         if (s->CfgRw != NULL)\r
2522         {\r
2523                 FOLDER *f = SiWriteConfigurationToCfg(s);\r
2524                 BUF *b = CfgFolderToBuf(f, true);\r
2525 \r
2526                 StrCpy(t->FileName, sizeof(t->FileName), s->CfgRw->FileName + (s->CfgRw->FileName[0] == '@' ? 1 : 0));\r
2527 \r
2528                 t->FileData = ZeroMalloc(b->Size + 1);\r
2529                 Copy(t->FileData, b->Buf, b->Size);\r
2530 \r
2531                 CfgDeleteFolder(f);\r
2532                 FreeBuf(b);\r
2533 \r
2534                 return ERR_NO_ERROR;\r
2535         }\r
2536         else\r
2537         {\r
2538                 return ERR_INTERNAL_ERROR;\r
2539         }\r
2540 }\r
2541 \r
2542 // config の設定\r
2543 UINT StSetConfig(ADMIN *a, RPC_CONFIG *t)\r
2544 {\r
2545         SERVER *s;\r
2546         IO *o;\r
2547         char filename[MAX_PATH];\r
2548 \r
2549         SERVER_ADMIN_ONLY;\r
2550 \r
2551         s = a->Server;\r
2552         if (s->CfgRw == NULL)\r
2553         {\r
2554                 return ERR_INTERNAL_ERROR;\r
2555         }\r
2556 \r
2557         // 新しい Config ファイルに書き込む\r
2558         Format(filename, sizeof(filename), "%s.new", s->CfgRw->FileName);\r
2559 \r
2560         o = FileCreate(filename);\r
2561 \r
2562         FileWrite(o, t->FileData, StrLen(t->FileData));\r
2563 \r
2564         FileClose(o);\r
2565 \r
2566         IncrementServerConfigRevision(s);\r
2567 \r
2568         ALog(a, NULL, "LA_SET_CONFIG");\r
2569 \r
2570         // サーバーを再起動する\r
2571         SiRebootServer(s->Cedar->Bridge);\r
2572 \r
2573         return ERR_NO_ERROR;\r
2574 }\r
2575 \r
2576 // Caps の取得\r
2577 UINT StGetCaps(ADMIN *a, CAPSLIST *t)\r
2578 {\r
2579         FreeRpcCapsList(t);\r
2580         Zero(t, sizeof(CAPSLIST));\r
2581 \r
2582         GetServerCapsMain(a->Server, t);\r
2583 \r
2584         return ERR_NO_ERROR;\r
2585 }\r
2586 \r
2587 // サーバーの再起動\r
2588 UINT StRebootServer(ADMIN *a, RPC_TEST *t)\r
2589 {\r
2590         SERVER_ADMIN_ONLY;\r
2591 \r
2592         ALog(a, NULL, "LA_REBOOT_SERVER");\r
2593 \r
2594         SiRebootServerEx(a->Server->Cedar->Bridge, t->IntValue);\r
2595 \r
2596         return ERR_NO_ERROR;\r
2597 }\r
2598 \r
2599 // ローカルブリッジのサポート情報の取得\r
2600 UINT StGetBridgeSupport(ADMIN *a, RPC_BRIDGE_SUPPORT *t)\r
2601 {\r
2602         Zero(t, sizeof(RPC_BRIDGE_SUPPORT));\r
2603 \r
2604         t->IsBridgeSupportedOs = IsBridgeSupported();\r
2605         t->IsWinPcapNeeded = IsNeedWinPcap();\r
2606 \r
2607         return ERR_NO_ERROR;\r
2608 }\r
2609 \r
2610 // Ethernet デバイスの列挙\r
2611 UINT StEnumEthernet(ADMIN *a, RPC_ENUM_ETH *t)\r
2612 {\r
2613         TOKEN_LIST *o;\r
2614         UINT i;\r
2615         char tmp[MAX_SIZE];\r
2616         bool unix_support = false;\r
2617 \r
2618         SERVER_ADMIN_ONLY;\r
2619 \r
2620 #ifdef  OS_UNIX\r
2621         unix_support = EthIsInterfaceDescriptionSupportedUnix();\r
2622 #endif  // OS_UNIX\r
2623 \r
2624         o = GetEthList();\r
2625 \r
2626         FreeRpcEnumEth(t);\r
2627         Zero(t, sizeof(RPC_ENUM_ETH));\r
2628 \r
2629         t->NumItem = o->NumTokens;\r
2630         t->Items = ZeroMalloc(sizeof(RPC_ENUM_ETH_ITEM) * t->NumItem);\r
2631 \r
2632         for (i = 0;i < t->NumItem;i++)\r
2633         {\r
2634                 RPC_ENUM_ETH_ITEM *e = &t->Items[i];\r
2635 \r
2636                 StrCpy(e->DeviceName, sizeof(e->DeviceName), o->Token[i]);\r
2637 \r
2638                 StrCpy(tmp, sizeof(tmp), e->DeviceName);\r
2639 \r
2640 #ifdef OS_WIN32\r
2641                 GetEthNetworkConnectionName(e->NetworkConnectionName, sizeof(e->NetworkConnectionName), e->DeviceName);\r
2642 #else\r
2643                 if (unix_support == false)\r
2644                 {\r
2645                         StrCpy(tmp, sizeof(tmp), "");\r
2646                 }\r
2647                 else\r
2648                 {\r
2649                         if (EthGetInterfaceDescriptionUnix(e->DeviceName, tmp, sizeof(tmp)) == false)\r
2650                         {\r
2651                                 StrCpy(tmp, sizeof(tmp), e->DeviceName);\r
2652                         }\r
2653                 }\r
2654 \r
2655                 StrToUni(e->NetworkConnectionName, sizeof(e->NetworkConnectionName), tmp);\r
2656 #endif\r
2657         }\r
2658 \r
2659         FreeToken(o);\r
2660 \r
2661         return ERR_NO_ERROR;\r
2662 }\r
2663 \r
2664 // ローカルブリッジの追加\r
2665 UINT StAddLocalBridge(ADMIN *a, RPC_LOCALBRIDGE *t)\r
2666 {\r
2667         if (IsEmptyStr(t->DeviceName) || IsEmptyStr(t->HubName))\r
2668         {\r
2669                 return ERR_INVALID_PARAMETER;\r
2670         }\r
2671 \r
2672         SERVER_ADMIN_ONLY;\r
2673 \r
2674         if (IsEthSupported() == false)\r
2675         {\r
2676                 return ERR_LOCAL_BRIDGE_UNSUPPORTED;\r
2677         }\r
2678 \r
2679         ALog(a, NULL, "LA_ADD_BRIDGE", t->HubName, t->DeviceName);\r
2680 \r
2681         AddLocalBridge(a->Server->Cedar, t->HubName, t->DeviceName, false, false, t->TapMode, NULL, false);\r
2682 \r
2683         IncrementServerConfigRevision(a->Server);\r
2684 \r
2685         return ERR_NO_ERROR;\r
2686 }\r
2687 \r
2688 // ローカルブリッジの削除\r
2689 UINT StDeleteLocalBridge(ADMIN *a, RPC_LOCALBRIDGE *t)\r
2690 {\r
2691         if (IsEmptyStr(t->DeviceName) || IsEmptyStr(t->HubName))\r
2692         {\r
2693                 return ERR_INVALID_PARAMETER;\r
2694         }\r
2695 \r
2696         SERVER_ADMIN_ONLY;\r
2697 \r
2698         ALog(a, NULL, "LA_DELETE_BRIDGE", t->HubName, t->DeviceName);\r
2699 \r
2700         if (DeleteLocalBridge(a->Server->Cedar, t->HubName, t->DeviceName) == false)\r
2701         {\r
2702                 return ERR_OBJECT_NOT_FOUND;\r
2703         }\r
2704 \r
2705         IncrementServerConfigRevision(a->Server);\r
2706 \r
2707         return ERR_NO_ERROR;\r
2708 }\r
2709 \r
2710 // ローカルブリッジの列挙\r
2711 UINT StEnumLocalBridge(ADMIN *a, RPC_ENUM_LOCALBRIDGE *t)\r
2712 {\r
2713         UINT i;\r
2714         CEDAR *c;\r
2715 \r
2716         if (IsEthSupported() == false)\r
2717         {\r
2718                 return ERR_LOCAL_BRIDGE_UNSUPPORTED;\r
2719         }\r
2720 \r
2721         FreeRpcEnumLocalBridge(t);\r
2722         Zero(t, sizeof(RPC_ENUM_LOCALBRIDGE));\r
2723 \r
2724         c = a->Server->Cedar;\r
2725 \r
2726         LockList(c->LocalBridgeList);\r
2727         {\r
2728                 t->NumItem = LIST_NUM(c->LocalBridgeList);\r
2729                 t->Items = ZeroMalloc(sizeof(RPC_LOCALBRIDGE) * t->NumItem);\r
2730 \r
2731                 for (i = 0;i < t->NumItem;i++)\r
2732                 {\r
2733                         RPC_LOCALBRIDGE *e = &t->Items[i];\r
2734                         LOCALBRIDGE *br = LIST_DATA(c->LocalBridgeList, i);\r
2735 \r
2736                         if (br->Bridge == false)\r
2737                         {\r
2738                                 e->Online = e->Active = false;\r
2739                         }\r
2740                         else\r
2741                         {\r
2742                                 e->Online = true;\r
2743                                 if (br->Bridge->Active)\r
2744                                 {\r
2745                                         e->Active = true;\r
2746                                 }\r
2747                                 else\r
2748                                 {\r
2749                                         e->Active = false;\r
2750                                 }\r
2751                         }\r
2752                         StrCpy(e->DeviceName, sizeof(e->DeviceName), br->DeviceName);\r
2753                         StrCpy(e->HubName, sizeof(e->HubName), br->HubName);\r
2754 \r
2755                         e->TapMode = br->TapMode;\r
2756                 }\r
2757         }\r
2758         UnlockList(c->LocalBridgeList);\r
2759 \r
2760         return ERR_NO_ERROR;\r
2761 }\r
2762 \r
2763 // syslog 設定の書き込み\r
2764 UINT StSetSysLog(ADMIN *a, SYSLOG_SETTING *t)\r
2765 {\r
2766         return ERR_NOT_SUPPORTED;\r
2767 }\r
2768 \r
2769 // syslog 設定の読み込み\r
2770 UINT StGetSysLog(ADMIN *a, SYSLOG_SETTING *t)\r
2771 {\r
2772         return ERR_NOT_SUPPORTED;\r
2773 }\r
2774 \r
2775 // KEEP の設定\r
2776 UINT StSetKeep(ADMIN *a, RPC_KEEP *t)\r
2777 {\r
2778         SERVER *s = a->Server;\r
2779 \r
2780         if (t->UseKeepConnect)\r
2781         {\r
2782                 if (IsEmptyStr(t->KeepConnectHost) ||\r
2783                         t->KeepConnectPort == 0 ||\r
2784                         t->KeepConnectPort >= 65536)\r
2785                 {\r
2786                         return ERR_INVALID_PARAMETER;\r
2787                 }\r
2788         }\r
2789 \r
2790         SERVER_ADMIN_ONLY;\r
2791 \r
2792         Lock(s->Keep->lock);\r
2793         {\r
2794                 KEEP *keep = s->Keep;\r
2795                 keep->Enable = t->UseKeepConnect;\r
2796                 keep->Server = true;\r
2797                 StrCpy(keep->ServerName, sizeof(keep->ServerName), t->KeepConnectHost);\r
2798                 keep->ServerPort = t->KeepConnectPort;\r
2799                 keep->UdpMode = t->KeepConnectProtocol;\r
2800                 keep->Interval = t->KeepConnectInterval * 1000;\r
2801                 if (keep->Interval < 5000)\r
2802                 {\r
2803                         keep->Interval = 5000;\r
2804                 }\r
2805                 else if (keep->Interval > 600000)\r
2806                 {\r
2807                         keep->Interval = 600000;\r
2808                 }\r
2809         }\r
2810         Unlock(s->Keep->lock);\r
2811 \r
2812         ALog(a, NULL, "LA_SET_KEEP");\r
2813 \r
2814         IncrementServerConfigRevision(s);\r
2815 \r
2816         return ERR_NO_ERROR;\r
2817 }\r
2818 \r
2819 // KEEP の取得\r
2820 UINT StGetKeep(ADMIN *a, RPC_KEEP *t)\r
2821 {\r
2822         SERVER *s = a->Server;\r
2823 \r
2824         Zero(t, sizeof(RPC_KEEP));\r
2825 \r
2826         Lock(s->Keep->lock);\r
2827         {\r
2828                 KEEP *k = s->Keep;\r
2829                 t->UseKeepConnect = k->Enable;\r
2830                 StrCpy(t->KeepConnectHost, sizeof(t->KeepConnectHost), k->ServerName);\r
2831                 t->KeepConnectPort = k->ServerPort;\r
2832                 t->KeepConnectProtocol = k->UdpMode;\r
2833                 t->KeepConnectInterval = k->Interval / 1000;\r
2834         }\r
2835         Unlock(s->Keep->lock);\r
2836 \r
2837         return ERR_NO_ERROR;\r
2838 }\r
2839 \r
2840 // IP テーブルの削除\r
2841 UINT StDeleteIpTable(ADMIN *a, RPC_DELETE_TABLE *t)\r
2842 {\r
2843         SERVER *s = a->Server;\r
2844         CEDAR *c = s->Cedar;\r
2845         HUB *h = NULL;\r
2846         UINT ret = ERR_NO_ERROR;\r
2847 \r
2848         CHECK_RIGHT;\r
2849 \r
2850         LockHubList(c);\r
2851         {\r
2852                 h = GetHub(c, t->HubName);\r
2853         }\r
2854         UnlockHubList(c);\r
2855 \r
2856         if (h == NULL)\r
2857         {\r
2858                 return ERR_HUB_NOT_FOUND;\r
2859         }\r
2860 \r
2861         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_delete_iptable") != 0)\r
2862         {\r
2863                 ReleaseHub(h);\r
2864                 return ERR_NOT_ENOUGH_RIGHT;\r
2865         }\r
2866 \r
2867         LockList(h->IpTable);\r
2868         {\r
2869                 if (IsInListKey(h->IpTable, t->Key))\r
2870                 {\r
2871                         IP_TABLE_ENTRY *e = ListKeyToPointer(h->IpTable, t->Key);\r
2872                         Free(e);\r
2873                         Delete(h->IpTable, e);\r
2874                 }\r
2875                 else\r
2876                 {\r
2877                         ret = ERR_OBJECT_NOT_FOUND;\r
2878                 }\r
2879         }\r
2880         UnlockList(h->IpTable);\r
2881 \r
2882         if (ret == ERR_OBJECT_NOT_FOUND)\r
2883         {\r
2884                 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
2885                 {\r
2886                         UINT i;\r
2887                         LockList(s->FarmMemberList);\r
2888                         {\r
2889                                 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
2890                                 {\r
2891                                         FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
2892                                         if (f->Me == false)\r
2893                                         {\r
2894                                                 SiCallDeleteIpTable(s, f, t->HubName, t->Key);\r
2895                                                 ret = ERR_NO_ERROR;\r
2896                                         }\r
2897                                 }\r
2898                         }\r
2899                         UnlockList(s->FarmMemberList);\r
2900                 }\r
2901         }\r
2902 \r
2903         ReleaseHub(h);\r
2904 \r
2905         return ret;\r
2906 }\r
2907 \r
2908 // ローカル IP テーブルの列挙\r
2909 UINT SiEnumIpTable(SERVER *s, char *hubname, RPC_ENUM_IP_TABLE *t)\r
2910 {\r
2911         CEDAR *c;\r
2912         UINT i;\r
2913         HUB *h = NULL;\r
2914         // 引数チェック\r
2915         if (s == NULL || hubname == NULL || t == NULL)\r
2916         {\r
2917                 return ERR_INTERNAL_ERROR;\r
2918         }\r
2919 \r
2920         c = s->Cedar;\r
2921 \r
2922         LockHubList(c);\r
2923         {\r
2924                 h = GetHub(c, hubname);\r
2925         }\r
2926         UnlockHubList(c);\r
2927 \r
2928         if (h == NULL)\r
2929         {\r
2930                 return ERR_HUB_NOT_FOUND;\r
2931         }\r
2932 \r
2933         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
2934 \r
2935         LockList(h->IpTable);\r
2936         {\r
2937                 t->NumIpTable = LIST_NUM(h->IpTable);\r
2938                 t->IpTables = ZeroMalloc(sizeof(RPC_ENUM_IP_TABLE_ITEM) * t->NumIpTable);\r
2939 \r
2940                 for (i = 0;i < t->NumIpTable;i++)\r
2941                 {\r
2942                         RPC_ENUM_IP_TABLE_ITEM *e = &t->IpTables[i];\r
2943                         IP_TABLE_ENTRY *table = LIST_DATA(h->IpTable, i);\r
2944 \r
2945                         e->Key = POINTER_TO_KEY(table);\r
2946                         StrCpy(e->SessionName, sizeof(e->SessionName), table->Session->Name);\r
2947                         e->Ip = IPToUINT(&table->Ip);\r
2948                         Copy(&e->IpV6, &table->Ip, sizeof(IP));\r
2949                         e->DhcpAllocated = table->DhcpAllocated;\r
2950                         e->CreatedTime = TickToTime(table->CreatedTime);\r
2951                         e->UpdatedTime = TickToTime(table->UpdatedTime);\r
2952 \r
2953                         GetMachineName(e->RemoteHostname, sizeof(e->RemoteHostname));\r
2954                 }\r
2955         }\r
2956         UnlockList(h->IpTable);\r
2957 \r
2958         ReleaseHub(h);\r
2959 \r
2960         return ERR_NO_ERROR;\r
2961 }\r
2962 \r
2963 // IP テーブルの列挙\r
2964 UINT StEnumIpTable(ADMIN *a, RPC_ENUM_IP_TABLE *t)\r
2965 {\r
2966         SERVER *s = a->Server;\r
2967         CEDAR *c = s->Cedar;\r
2968         UINT ret = ERR_NO_ERROR;\r
2969         char hubname[MAX_HUBNAME_LEN + 1];\r
2970         UINT i;\r
2971 \r
2972         CHECK_RIGHT;\r
2973 \r
2974         // ローカルの列挙\r
2975         StrCpy(hubname, sizeof(hubname), t->HubName);\r
2976         FreeRpcEnumIpTable(t);\r
2977         Zero(t, sizeof(RPC_ENUM_IP_TABLE));\r
2978         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
2979 \r
2980         ret = SiEnumIpTable(s, hubname, t);\r
2981         if (ret != ERR_NO_ERROR)\r
2982         {\r
2983                 return ret;\r
2984         }\r
2985 \r
2986         if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
2987         {\r
2988                 // リモートの列挙\r
2989                 LockList(s->FarmMemberList);\r
2990                 {\r
2991                         for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
2992                         {\r
2993                                 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
2994                                 if (f->Me == false)\r
2995                                 {\r
2996                                         RPC_ENUM_IP_TABLE tmp;\r
2997 \r
2998                                         Zero(&tmp, sizeof(tmp));\r
2999 \r
3000                                         SiCallEnumIpTable(s, f, hubname, &tmp);\r
3001 \r
3002                                         AdjoinRpcEnumIpTable(t, &tmp);\r
3003                                         FreeRpcEnumIpTable(&tmp);\r
3004                                 }\r
3005                         }\r
3006                 }\r
3007                 UnlockList(s->FarmMemberList);\r
3008         }\r
3009 \r
3010         return ret;\r
3011 }\r
3012 \r
3013 // MAC テーブルの削除\r
3014 UINT StDeleteMacTable(ADMIN *a, RPC_DELETE_TABLE *t)\r
3015 {\r
3016         SERVER *s = a->Server;\r
3017         CEDAR *c = s->Cedar;\r
3018         HUB *h = NULL;\r
3019         UINT ret = ERR_NO_ERROR;\r
3020 \r
3021         CHECK_RIGHT;\r
3022 \r
3023         LockHubList(c);\r
3024         {\r
3025                 h = GetHub(c, t->HubName);\r
3026         }\r
3027         UnlockHubList(c);\r
3028 \r
3029         if (h == NULL)\r
3030         {\r
3031                 return ERR_HUB_NOT_FOUND;\r
3032         }\r
3033 \r
3034         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_delete_mactable") != 0)\r
3035         {\r
3036                 ReleaseHub(h);\r
3037                 return ERR_NOT_ENOUGH_RIGHT;\r
3038         }\r
3039 \r
3040         LockList(h->MacTable);\r
3041         {\r
3042                 if (IsInListKey(h->MacTable, t->Key))\r
3043                 {\r
3044                         MAC_TABLE_ENTRY *e = ListKeyToPointer(h->MacTable, t->Key);\r
3045                         Free(e);\r
3046                         Delete(h->MacTable, e);\r
3047                 }\r
3048                 else\r
3049                 {\r
3050                         ret = ERR_OBJECT_NOT_FOUND;\r
3051                 }\r
3052         }\r
3053         UnlockList(h->MacTable);\r
3054 \r
3055         if (ret == ERR_OBJECT_NOT_FOUND)\r
3056         {\r
3057                 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
3058                 {\r
3059                         UINT i;\r
3060                         LockList(s->FarmMemberList);\r
3061                         {\r
3062                                 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
3063                                 {\r
3064                                         FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
3065                                         if (f->Me == false)\r
3066                                         {\r
3067                                                 SiCallDeleteMacTable(s, f, t->HubName, t->Key);\r
3068                                                 ret = ERR_NO_ERROR;\r
3069                                         }\r
3070                                 }\r
3071                         }\r
3072                         UnlockList(s->FarmMemberList);\r
3073                 }\r
3074         }\r
3075 \r
3076         ReleaseHub(h);\r
3077 \r
3078         return ret;\r
3079 }\r
3080 \r
3081 // ローカル MAC テーブルの列挙\r
3082 UINT SiEnumMacTable(SERVER *s, char *hubname, RPC_ENUM_MAC_TABLE *t)\r
3083 {\r
3084         CEDAR *c;\r
3085         UINT i;\r
3086         HUB *h = NULL;\r
3087         // 引数チェック\r
3088         if (s == NULL || hubname == NULL || t == NULL)\r
3089         {\r
3090                 return ERR_INTERNAL_ERROR;\r
3091         }\r
3092 \r
3093         c = s->Cedar;\r
3094 \r
3095         LockHubList(c);\r
3096         {\r
3097                 h = GetHub(c, hubname);\r
3098         }\r
3099         UnlockHubList(c);\r
3100 \r
3101         if (h == NULL)\r
3102         {\r
3103                 return ERR_HUB_NOT_FOUND;\r
3104         }\r
3105 \r
3106         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
3107 \r
3108         LockList(h->MacTable);\r
3109         {\r
3110                 t->NumMacTable = LIST_NUM(h->MacTable);\r
3111                 t->MacTables = ZeroMalloc(sizeof(RPC_ENUM_MAC_TABLE_ITEM) * t->NumMacTable);\r
3112 \r
3113                 for (i = 0;i < t->NumMacTable;i++)\r
3114                 {\r
3115                         RPC_ENUM_MAC_TABLE_ITEM *e = &t->MacTables[i];\r
3116                         MAC_TABLE_ENTRY *mac = LIST_DATA(h->MacTable, i);\r
3117 \r
3118                         e->Key = POINTER_TO_KEY(mac);\r
3119                         StrCpy(e->SessionName, sizeof(e->SessionName), mac->Session->Name);\r
3120                         Copy(e->MacAddress, mac->MacAddress, sizeof(e->MacAddress));\r
3121                         e->CreatedTime = TickToTime(mac->CreatedTime);\r
3122                         e->UpdatedTime = TickToTime(mac->UpdatedTime);\r
3123                         e->VlanId = mac->VlanId;\r
3124 \r
3125                         GetMachineName(e->RemoteHostname, sizeof(e->RemoteHostname));\r
3126                 }\r
3127         }\r
3128         UnlockList(h->MacTable);\r
3129 \r
3130         ReleaseHub(h);\r
3131 \r
3132         return ERR_NO_ERROR;\r
3133 }\r
3134 \r
3135 // MAC テーブルの列挙\r
3136 UINT StEnumMacTable(ADMIN *a, RPC_ENUM_MAC_TABLE *t)\r
3137 {\r
3138         SERVER *s = a->Server;\r
3139         CEDAR *c = s->Cedar;\r
3140         HUB *h = NULL;\r
3141         UINT ret = ERR_NO_ERROR;\r
3142         char hubname[MAX_HUBNAME_LEN + 1];\r
3143         UINT i;\r
3144 \r
3145         CHECK_RIGHT;\r
3146 \r
3147         // ローカルの MAC テーブルを列挙する\r
3148         StrCpy(hubname, sizeof(hubname), t->HubName);\r
3149         FreeRpcEnumMacTable(t);\r
3150         Zero(t, sizeof(RPC_ENUM_MAC_TABLE));\r
3151 \r
3152         ret = SiEnumMacTable(s, hubname, t);\r
3153         if (ret != ERR_NO_ERROR)\r
3154         {\r
3155                 return ret;\r
3156         }\r
3157 \r
3158         if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
3159         {\r
3160                 // リモートの MAC テーブルを列挙する\r
3161                 LockList(s->FarmMemberList);\r
3162                 {\r
3163                         for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
3164                         {\r
3165                                 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
3166                                 if (f->Me == false)\r
3167                                 {\r
3168                                         RPC_ENUM_MAC_TABLE tmp;\r
3169 \r
3170                                         Zero(&tmp, sizeof(tmp));\r
3171 \r
3172                                         SiCallEnumMacTable(s, f, hubname, &tmp);\r
3173 \r
3174                                         AdjoinRpcEnumMacTable(t, &tmp);\r
3175                                         FreeRpcEnumMacTable(&tmp);\r
3176                                 }\r
3177                         }\r
3178                 }\r
3179                 UnlockList(s->FarmMemberList);\r
3180         }\r
3181 \r
3182         return ret;\r
3183 }\r
3184 \r
3185 // セッションの削除\r
3186 UINT StDeleteSession(ADMIN *a, RPC_DELETE_SESSION *t)\r
3187 {\r
3188         SERVER *s = a->Server;\r
3189         CEDAR *c = s->Cedar;\r
3190         HUB *h = NULL;\r
3191         UINT ret = ERR_NO_ERROR;\r
3192         char hubname[MAX_HUBNAME_LEN + 1];\r
3193         char name[MAX_SESSION_NAME_LEN + 1];\r
3194         SESSION *sess;\r
3195 \r
3196         if (IsEmptyStr(t->Name))\r
3197         {\r
3198                 return ERR_INVALID_PARAMETER;\r
3199         }\r
3200 \r
3201         StrCpy(hubname, sizeof(hubname), t->HubName);\r
3202         StrCpy(name, sizeof(name), t->Name);\r
3203 \r
3204         CHECK_RIGHT;\r
3205 \r
3206         LockHubList(c);\r
3207         {\r
3208                 h = GetHub(c, t->HubName);\r
3209         }\r
3210         UnlockHubList(c);\r
3211 \r
3212         if (h == NULL)\r
3213         {\r
3214                 return ERR_HUB_NOT_FOUND;\r
3215         }\r
3216 \r
3217         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_disconnect_session") != 0)\r
3218         {\r
3219                 ReleaseHub(h);\r
3220                 return ERR_NOT_ENOUGH_RIGHT;\r
3221         }\r
3222 \r
3223         sess = GetSessionByName(h, name);\r
3224 \r
3225         if (sess == NULL)\r
3226         {\r
3227                 if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
3228                 {\r
3229                         // ファームコントローラ\r
3230                         UINT i;\r
3231                         LockList(s->FarmMemberList);\r
3232                         {\r
3233                                 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
3234                                 {\r
3235                                         FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
3236                                         if (f->Me == false)\r
3237                                         {\r
3238                                                 // 切断を試行\r
3239                                                 SiCallDeleteSession(s, f, t->HubName, t->Name);\r
3240                                         }\r
3241                                 }\r
3242                         }\r
3243                         UnlockList(s->FarmMemberList);\r
3244                 }\r
3245                 else\r
3246                 {\r
3247                         ret = ERR_OBJECT_NOT_FOUND;\r
3248                 }\r
3249         }\r
3250         else\r
3251         {\r
3252                 if (sess->LinkModeServer)\r
3253                 {\r
3254                         ret = ERR_LINK_CANT_DISCONNECT;\r
3255                 }\r
3256                 else if (sess->SecureNATMode)\r
3257                 {\r
3258                         ret = ERR_SNAT_CANT_DISCONNECT;\r
3259                 }\r
3260                 else if (sess->BridgeMode)\r
3261                 {\r
3262                         ret = ERR_BRIDGE_CANT_DISCONNECT;\r
3263                 }\r
3264                 else if (sess->L3SwitchMode)\r
3265                 {\r
3266                         ret = ERR_LAYER3_CANT_DISCONNECT;\r
3267                 }\r
3268                 else\r
3269                 {\r
3270                         StopSession(sess);\r
3271                 }\r
3272                 ReleaseSession(sess);\r
3273         }\r
3274 \r
3275         if (ret != ERR_NO_ERROR)\r
3276         {\r
3277                 ALog(a, h, "LA_DELETE_SESSION", t->Name);\r
3278         }\r
3279 \r
3280         ReleaseHub(h);\r
3281 \r
3282         return ret;\r
3283 }\r
3284 \r
3285 // セッション状態の取得\r
3286 UINT StGetSessionStatus(ADMIN *a, RPC_SESSION_STATUS *t)\r
3287 {\r
3288         SERVER *s = a->Server;\r
3289         CEDAR *c = s->Cedar;\r
3290         HUB *h = NULL;\r
3291         UINT ret = ERR_NO_ERROR;\r
3292         char hubname[MAX_HUBNAME_LEN + 1];\r
3293         char name[MAX_SESSION_NAME_LEN + 1];\r
3294         SESSION *sess;\r
3295 \r
3296         StrCpy(hubname, sizeof(hubname), t->HubName);\r
3297         StrCpy(name, sizeof(name), t->Name);\r
3298 \r
3299         if (IsEmptyStr(t->Name))\r
3300         {\r
3301                 return ERR_INVALID_PARAMETER;\r
3302         }\r
3303 \r
3304         CHECK_RIGHT;\r
3305 \r
3306         LockHubList(c);\r
3307         {\r
3308                 h = GetHub(c, t->HubName);\r
3309         }\r
3310         UnlockHubList(c);\r
3311 \r
3312         if (h == NULL)\r
3313         {\r
3314                 return ERR_HUB_NOT_FOUND;\r
3315         }\r
3316 \r
3317         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_query_session") != 0)\r
3318         {\r
3319                 ReleaseHub(h);\r
3320                 return ERR_NOT_ENOUGH_RIGHT;\r
3321         }\r
3322 \r
3323         FreeRpcSessionStatus(t);\r
3324         Zero(t, sizeof(RPC_SESSION_STATUS));\r
3325         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
3326         StrCpy(t->Name, sizeof(t->Name), name);\r
3327 \r
3328         sess = GetSessionByName(h, t->Name);\r
3329 \r
3330         if (sess == NULL)\r
3331         {\r
3332                 if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER)\r
3333                 {\r
3334                         // セッションが見つからない\r
3335                         ret = ERR_OBJECT_NOT_FOUND;\r
3336                 }\r
3337                 else\r
3338                 {\r
3339                         UINT i;\r
3340                         // 自分以外のメンバのセッションも検索してみる\r
3341                         LockList(s->FarmMemberList);\r
3342                         {\r
3343                                 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
3344                                 {\r
3345                                         FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
3346                                         if (f->Me == false)\r
3347                                         {\r
3348                                                 RPC_SESSION_STATUS tmp;\r
3349                                                 Zero(&tmp, sizeof(tmp));\r
3350                                                 StrCpy(tmp.HubName, sizeof(tmp.HubName), t->HubName);\r
3351                                                 StrCpy(tmp.Name, sizeof(tmp.Name), t->Name);\r
3352 \r
3353                                                 if (SiCallGetSessionStatus(s, f, &tmp))\r
3354                                                 {\r
3355                                                         if (StrLen(tmp.HubName) != 0)\r
3356                                                         {\r
3357                                                                 // セッション情報の取得に成功した\r
3358                                                                 Copy(t, &tmp, sizeof(RPC_SESSION_STATUS));\r
3359                                                                 break;\r
3360                                                         }\r
3361                                                         else\r
3362                                                         {\r
3363                                                                 FreeRpcSessionStatus(&tmp);\r
3364                                                         }\r
3365                                                 }\r
3366                                         }\r
3367                                 }\r
3368 \r
3369                                 if (i == LIST_NUM(s->FarmMemberList))\r
3370                                 {\r
3371                                         // 結局見つからない\r
3372                                         ret = ERR_OBJECT_NOT_FOUND;\r
3373                                 }\r
3374                         }\r
3375                         UnlockList(s->FarmMemberList);\r
3376                 }\r
3377         }\r
3378         else\r
3379         {\r
3380                 SESSION *s = sess;\r
3381 \r
3382                 Lock(s->lock);\r
3383                 {\r
3384                         StrCpy(t->Username, sizeof(t->Username), s->Username);\r
3385                         StrCpy(t->RealUsername, sizeof(t->RealUsername), s->UserNameReal);\r
3386                         StrCpy(t->GroupName, sizeof(t->GroupName), s->GroupName);\r
3387                         Copy(&t->NodeInfo, &s->NodeInfo, sizeof(NODE_INFO));\r
3388 \r
3389                         if (s->Connection != NULL)\r
3390                         {\r
3391                                 t->ClientIp = IPToUINT(&s->Connection->ClientIp);\r
3392                                 if (IsIP6(&s->Connection->ClientIp))\r
3393                                 {\r
3394                                         Copy(&t->ClientIp6, &s->Connection->ClientIp.ipv6_addr, sizeof(t->ClientIp6));\r
3395                                 }\r
3396 \r
3397                                 StrCpy(t->ClientHostName, sizeof(t->ClientHostName), s->Connection->ClientHostname);\r
3398                         }\r
3399                 }\r
3400                 Unlock(s->lock);\r
3401 \r
3402                 CiGetSessionStatus(&t->Status, s);\r
3403 \r
3404                 ReleaseSession(s);\r
3405         }\r
3406 \r
3407         ReleaseHub(h);\r
3408 \r
3409         return ret;\r
3410 }\r
3411 \r
3412 // セッションの列挙メイン\r
3413 void SiEnumSessionMain(SERVER *s, RPC_ENUM_SESSION *t)\r
3414 {\r
3415         char hubname[MAX_HUBNAME_LEN + 1];\r
3416         UINT ret = ERR_NO_ERROR;\r
3417         UINT num;\r
3418         UINT i;\r
3419         // 引数チェック\r
3420         if (s == NULL || t == NULL)\r
3421         {\r
3422                 return;\r
3423         }\r
3424 \r
3425         StrCpy(hubname, sizeof(hubname), t->HubName);\r
3426 \r
3427         FreeRpcEnumSession(t);\r
3428         Zero(t, sizeof(RPC_ENUM_SESSION));\r
3429         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
3430 \r
3431         // ローカルセッションの列挙\r
3432         num = 0;\r
3433         SiEnumLocalSession(s, hubname, t);\r
3434 \r
3435         if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
3436         {\r
3437                 // リモートセッションの列挙\r
3438                 LockList(s->FarmMemberList);\r
3439                 {\r
3440                         for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
3441                         {\r
3442                                 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
3443                                 if (f->Me == false)\r
3444                                 {\r
3445                                         RPC_ENUM_SESSION tmp;\r
3446 \r
3447                                         Zero(&tmp, sizeof(tmp));\r
3448 \r
3449                                         SiCallEnumSession(s, f, hubname, &tmp);\r
3450 \r
3451                                         AdjoinRpcEnumSession(t, &tmp);\r
3452                                         FreeRpcEnumSession(&tmp);\r
3453                                 }\r
3454                         }\r
3455                 }\r
3456                 UnlockList(s->FarmMemberList);\r
3457         }\r
3458 }\r
3459 \r
3460 // セッションの列挙\r
3461 UINT StEnumSession(ADMIN *a, RPC_ENUM_SESSION *t)\r
3462 {\r
3463         SERVER *s = a->Server;\r
3464         CEDAR *c = s->Cedar;\r
3465         HUB *h = NULL;\r
3466         UINT ret = ERR_NO_ERROR;\r
3467 \r
3468         CHECK_RIGHT;\r
3469 \r
3470         LockHubList(c);\r
3471         {\r
3472                 h = GetHub(c, t->HubName);\r
3473         }\r
3474         UnlockHubList(c);\r
3475 \r
3476         if (h == NULL)\r
3477         {\r
3478                 return ERR_HUB_NOT_FOUND;\r
3479         }\r
3480 \r
3481         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_enum_session") != 0)\r
3482         {\r
3483                 ReleaseHub(h);\r
3484                 return ERR_NOT_ENOUGH_RIGHT;\r
3485         }\r
3486 \r
3487         SiEnumSessionMain(s, t);\r
3488 \r
3489         ReleaseHub(h);\r
3490 \r
3491         return ret;\r
3492 }\r
3493 \r
3494 // グループの列挙\r
3495 UINT StEnumGroup(ADMIN *a, RPC_ENUM_GROUP *t)\r
3496 {\r
3497         SERVER *s = a->Server;\r
3498         CEDAR *c = s->Cedar;\r
3499         HUB *h = NULL;\r
3500         UINT ret = ERR_NO_ERROR;\r
3501         char hubname[MAX_HUBNAME_LEN + 1];\r
3502 \r
3503         StrCpy(hubname, sizeof(hubname), t->HubName);\r
3504 \r
3505         CHECK_RIGHT;\r
3506 \r
3507         NO_SUPPORT_FOR_BRIDGE;\r
3508         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
3509         {\r
3510                 return ERR_NOT_SUPPORTED;\r
3511         }\r
3512 \r
3513 \r
3514         LockHubList(c);\r
3515         {\r
3516                 h = GetHub(c, t->HubName);\r
3517         }\r
3518         UnlockHubList(c);\r
3519 \r
3520         if (h == NULL)\r
3521         {\r
3522                 return ERR_HUB_NOT_FOUND;\r
3523         }\r
3524 \r
3525         AcLock(h);\r
3526         {\r
3527                 UINT i, j;\r
3528 \r
3529                 FreeRpcEnumGroup(t);\r
3530                 Zero(t, sizeof(RPC_ENUM_GROUP));\r
3531                 StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
3532 \r
3533                 t->NumGroup = LIST_NUM(h->HubDb->GroupList);\r
3534                 t->Groups = ZeroMalloc(sizeof(RPC_ENUM_GROUP_ITEM) * t->NumGroup);\r
3535 \r
3536                 for (i = 0;i < t->NumGroup;i++)\r
3537                 {\r
3538                         RPC_ENUM_GROUP_ITEM *e = &t->Groups[i];\r
3539                         USERGROUP *g = LIST_DATA(h->HubDb->GroupList, i);\r
3540 \r
3541                         Lock(g->lock);\r
3542                         {\r
3543                                 StrCpy(e->Name, sizeof(e->Name), g->Name);\r
3544                                 UniStrCpy(e->Realname, sizeof(e->Realname), g->RealName);\r
3545                                 UniStrCpy(e->Note, sizeof(e->Note), g->Note);\r
3546                                 if (g->Policy != NULL)\r
3547                                 {\r
3548                                         if (g->Policy->Access == false)\r
3549                                         {\r
3550                                                 e->DenyAccess = true;\r
3551                                         }\r
3552                                 }\r
3553                         }\r
3554                         Unlock(g->lock);\r
3555 \r
3556                         e->NumUsers = 0;\r
3557 \r
3558 \r
3559                         LockList(h->HubDb->UserList);\r
3560                         {\r
3561                                 for (j = 0;j < LIST_NUM(h->HubDb->UserList);j++)\r
3562                                 {\r
3563                                         USER *u = LIST_DATA(h->HubDb->UserList, j);\r
3564 \r
3565                                         Lock(u->lock);\r
3566                                         {\r
3567                                                 if (u->Group == g)\r
3568                                                 {\r
3569                                                         e->NumUsers++;\r
3570                                                 }\r
3571                                         }\r
3572                                         Unlock(u->lock);\r
3573                                 }\r
3574                         }\r
3575                         UnlockList(h->HubDb->UserList);\r
3576                 }\r
3577         }\r
3578         AcUnlock(h);\r
3579 \r
3580         ReleaseHub(h);\r
3581 \r
3582         return ERR_NO_ERROR;\r
3583 }\r
3584 \r
3585 // グループの削除\r
3586 UINT StDeleteGroup(ADMIN *a, RPC_DELETE_USER *t)\r
3587 {\r
3588         SERVER *s = a->Server;\r
3589         CEDAR *c = s->Cedar;\r
3590         HUB *h = NULL;\r
3591         UINT ret = ERR_NO_ERROR;\r
3592 \r
3593         if (IsEmptyStr(t->Name) || IsSafeStr(t->Name) == false)\r
3594         {\r
3595                 return ERR_INVALID_PARAMETER;\r
3596         }\r
3597 \r
3598         CHECK_RIGHT;\r
3599 \r
3600         NO_SUPPORT_FOR_BRIDGE;\r
3601         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
3602         {\r
3603                 return ERR_NOT_SUPPORTED;\r
3604         }\r
3605 \r
3606         LockHubList(c);\r
3607         {\r
3608                 h = GetHub(c, t->HubName);\r
3609         }\r
3610         UnlockHubList(c);\r
3611 \r
3612         if (h == NULL)\r
3613         {\r
3614                 return ERR_HUB_NOT_FOUND;\r
3615         }\r
3616 \r
3617         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_groups") != 0)\r
3618         {\r
3619                 ReleaseHub(h);\r
3620                 return ERR_NOT_ENOUGH_RIGHT;\r
3621         }\r
3622 \r
3623         AcLock(h);\r
3624         {\r
3625                 if (AcDeleteGroup(h, t->Name) == false)\r
3626                 {\r
3627                         ret = ERR_OBJECT_NOT_FOUND;\r
3628                 }\r
3629         }\r
3630         AcUnlock(h);\r
3631 \r
3632         if (ret == ERR_NO_ERROR)\r
3633         {\r
3634                 ALog(a, h, "LA_DELETE_GROUP", t->Name);\r
3635         }\r
3636 \r
3637         ReleaseHub(h);\r
3638 \r
3639         IncrementServerConfigRevision(s);\r
3640 \r
3641         return ret;\r
3642 }\r
3643 \r
3644 // グループの取得\r
3645 UINT StGetGroup(ADMIN *a, RPC_SET_GROUP *t)\r
3646 {\r
3647         SERVER *s = a->Server;\r
3648         CEDAR *c = s->Cedar;\r
3649         HUB *h = NULL;\r
3650         UINT ret = ERR_NO_ERROR;\r
3651         char hubname[MAX_HUBNAME_LEN + 1];\r
3652 \r
3653         if (IsEmptyStr(t->Name) || IsSafeStr(t->Name) == false)\r
3654         {\r
3655                 return ERR_INVALID_PARAMETER;\r
3656         }\r
3657 \r
3658         CHECK_RIGHT;\r
3659         NO_SUPPORT_FOR_BRIDGE;\r
3660         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
3661         {\r
3662                 return ERR_NOT_SUPPORTED;\r
3663         }\r
3664 \r
3665         StrCpy(hubname, sizeof(hubname), t->HubName);\r
3666 \r
3667         LockHubList(c);\r
3668         {\r
3669                 h = GetHub(c, t->HubName);\r
3670         }\r
3671         UnlockHubList(c);\r
3672 \r
3673         if (h == NULL)\r
3674         {\r
3675                 return ERR_HUB_NOT_FOUND;\r
3676         }\r
3677 \r
3678         AcLock(h);\r
3679         {\r
3680                 USERGROUP *g = AcGetGroup(h, t->Name);\r
3681 \r
3682                 if (g == NULL)\r
3683                 {\r
3684                         ret = ERR_OBJECT_NOT_FOUND;\r
3685                 }\r
3686                 else\r
3687                 {\r
3688                         FreeRpcSetGroup(t);\r
3689                         Zero(t, sizeof(RPC_SET_GROUP));\r
3690 \r
3691                         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
3692 \r
3693                         Lock(g->lock);\r
3694                         {\r
3695                                 StrCpy(t->Name, sizeof(t->Name), g->Name);\r
3696                                 UniStrCpy(t->Realname, sizeof(t->Realname), g->RealName);\r
3697                                 UniStrCpy(t->Note, sizeof(t->Note), g->Note);\r
3698                                 Copy(&t->Traffic, g->Traffic, sizeof(TRAFFIC));\r
3699                         }\r
3700                         Unlock(g->lock);\r
3701 \r
3702                         t->Policy = GetGroupPolicy(g);\r
3703 \r
3704                         ReleaseGroup(g);\r
3705                 }\r
3706         }\r
3707         AcUnlock(h);\r
3708 \r
3709         ReleaseHub(h);\r
3710 \r
3711         return ret;\r
3712 }\r
3713 \r
3714 // グループの設定\r
3715 UINT StSetGroup(ADMIN *a, RPC_SET_GROUP *t)\r
3716 {\r
3717         SERVER *s = a->Server;\r
3718         CEDAR *c = s->Cedar;\r
3719         HUB *h = NULL;\r
3720         UINT ret = ERR_NO_ERROR;\r
3721 \r
3722         if (IsEmptyStr(t->Name) || IsSafeStr(t->Name) == false)\r
3723         {\r
3724                 return ERR_INVALID_PARAMETER;\r
3725         }\r
3726 \r
3727         CHECK_RIGHT;\r
3728         NO_SUPPORT_FOR_BRIDGE;\r
3729         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
3730         {\r
3731                 return ERR_NOT_SUPPORTED;\r
3732         }\r
3733 \r
3734         LockHubList(c);\r
3735         {\r
3736                 h = GetHub(c, t->HubName);\r
3737         }\r
3738         UnlockHubList(c);\r
3739 \r
3740         if (h == NULL)\r
3741         {\r
3742                 return ERR_HUB_NOT_FOUND;\r
3743         }\r
3744 \r
3745         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_groups") != 0)\r
3746         {\r
3747                 ReleaseHub(h);\r
3748                 return ERR_NOT_ENOUGH_RIGHT;\r
3749         }\r
3750 \r
3751         AcLock(h);\r
3752         {\r
3753                 USERGROUP *g = AcGetGroup(h, t->Name);\r
3754                 if (g == NULL)\r
3755                 {\r
3756                         ret = ERR_OBJECT_NOT_FOUND;\r
3757                 }\r
3758                 else\r
3759                 {\r
3760                         Lock(g->lock);\r
3761                         {\r
3762                                 Free(g->RealName);\r
3763                                 Free(g->Note);\r
3764                                 g->RealName = UniCopyStr(t->Realname);\r
3765                                 g->Note = UniCopyStr(t->Note);\r
3766                         }\r
3767                         Unlock(g->lock);\r
3768 \r
3769                         SetGroupPolicy(g, t->Policy);\r
3770 \r
3771                         ReleaseGroup(g);\r
3772 \r
3773                         ALog(a, h, "LA_SET_GROUP", t->Name);\r
3774                 }\r
3775         }\r
3776         AcUnlock(h);\r
3777 \r
3778         ReleaseHub(h);\r
3779 \r
3780         IncrementServerConfigRevision(s);\r
3781 \r
3782         return ret;\r
3783 }\r
3784 \r
3785 // グループの作成\r
3786 UINT StCreateGroup(ADMIN *a, RPC_SET_GROUP *t)\r
3787 {\r
3788         SERVER *s = a->Server;\r
3789         CEDAR *c = s->Cedar;\r
3790         HUB *h = NULL;\r
3791         UINT ret = ERR_NO_ERROR;\r
3792 \r
3793         if (IsEmptyStr(t->Name) || IsSafeStr(t->Name) == false)\r
3794         {\r
3795                 return ERR_INVALID_PARAMETER;\r
3796         }\r
3797 \r
3798         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
3799         {\r
3800                 return ERR_NOT_FARM_CONTROLLER;\r
3801         }\r
3802 \r
3803         CHECK_RIGHT;\r
3804 \r
3805         NO_SUPPORT_FOR_BRIDGE;\r
3806         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
3807         {\r
3808                 return ERR_NOT_SUPPORTED;\r
3809         }\r
3810 \r
3811         LockHubList(c);\r
3812         {\r
3813                 h = GetHub(c, t->HubName);\r
3814         }\r
3815         UnlockHubList(c);\r
3816 \r
3817         if (h == NULL)\r
3818         {\r
3819                 return ERR_HUB_NOT_FOUND;\r
3820         }\r
3821 \r
3822         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_groups") != 0)\r
3823         {\r
3824                 ReleaseHub(h);\r
3825                 return ERR_NOT_ENOUGH_RIGHT;\r
3826         }\r
3827 \r
3828         AcLock(h);\r
3829         {\r
3830                 if (AcIsGroup(h, t->Name))\r
3831                 {\r
3832                         ret = ERR_GROUP_ALREADY_EXISTS;\r
3833                 }\r
3834                 else\r
3835                 {\r
3836                         USERGROUP *g = NewGroup(t->Name, t->Realname, t->Note);\r
3837                         SetGroupPolicy(g, t->Policy);\r
3838 \r
3839                         if ((LIST_NUM(h->HubDb->GroupList) >= GetServerCapsInt(a->Server, "i_max_users_per_hub")) ||\r
3840                                 ((GetHubAdminOption(h, "max_groups") != 0) && (LIST_NUM(h->HubDb->GroupList) >= GetHubAdminOption(h, "max_groups"))))\r
3841                         {\r
3842                                 ret = ERR_TOO_MANY_GROUP;\r
3843                         }\r
3844                         else\r
3845                         {\r
3846                                 AcAddGroup(h, g);\r
3847                         }\r
3848 \r
3849                         ReleaseGroup(g);\r
3850 \r
3851                         ALog(a, h, "LA_CREATE_GROUP", t->Name);\r
3852                 }\r
3853         }\r
3854         AcUnlock(h);\r
3855 \r
3856         ReleaseHub(h);\r
3857 \r
3858         IncrementServerConfigRevision(s);\r
3859 \r
3860         return ret;\r
3861 }\r
3862 \r
3863 // ユーザーの列挙\r
3864 UINT StEnumUser(ADMIN *a, RPC_ENUM_USER *t)\r
3865 {\r
3866         SERVER *s = a->Server;\r
3867         CEDAR *c = s->Cedar;\r
3868         HUB *h = NULL;\r
3869         UINT ret = ERR_NO_ERROR;\r
3870         char hubname[MAX_HUBNAME_LEN + 1];\r
3871         UINT i, num;\r
3872 \r
3873         CHECK_RIGHT;\r
3874         NO_SUPPORT_FOR_BRIDGE;\r
3875         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
3876         {\r
3877                 return ERR_NOT_SUPPORTED;\r
3878         }\r
3879 \r
3880         LockHubList(c);\r
3881         {\r
3882                 h = GetHub(c, t->HubName);\r
3883         }\r
3884         UnlockHubList(c);\r
3885 \r
3886         if (h == NULL)\r
3887         {\r
3888                 return ERR_HUB_NOT_FOUND;\r
3889         }\r
3890 \r
3891         FreeRpcEnumUser(t);\r
3892 \r
3893         StrCpy(hubname, sizeof(hubname), t->HubName);\r
3894 \r
3895         Zero(t, sizeof(RPC_ENUM_USER));\r
3896         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
3897 \r
3898         LockList(h->HubDb->UserList);\r
3899         {\r
3900                 num = LIST_NUM(h->HubDb->UserList);\r
3901 \r
3902                 t->NumUser = num;\r
3903                 t->Users = ZeroMalloc(sizeof(RPC_ENUM_USER_ITEM) * num);\r
3904 \r
3905                 for (i = 0;i < num;i++)\r
3906                 {\r
3907                         USER *u = LIST_DATA(h->HubDb->UserList, i);\r
3908 \r
3909                         Lock(u->lock);\r
3910                         {\r
3911                                 RPC_ENUM_USER_ITEM *e = &t->Users[i];\r
3912 \r
3913                                 StrCpy(e->Name, sizeof(e->Name), u->Name);\r
3914                                 StrCpy(e->GroupName, sizeof(e->GroupName), u->GroupName);\r
3915                                 UniStrCpy(e->Realname, sizeof(e->Realname), u->RealName);\r
3916                                 UniStrCpy(e->Note, sizeof(e->Note), u->Note);\r
3917                                 e->AuthType = u->AuthType;\r
3918                                 e->LastLoginTime = u->LastLoginTime;\r
3919                                 e->NumLogin = u->NumLogin;\r
3920 \r
3921                                 if (u->Policy != NULL)\r
3922                                 {\r
3923                                         e->DenyAccess = u->Policy->Access ? false : true;\r
3924                                 }\r
3925                         }\r
3926                         Unlock(u->lock);\r
3927                 }\r
3928         }\r
3929         UnlockList(h->HubDb->UserList);\r
3930 \r
3931         ReleaseHub(h);\r
3932 \r
3933         IncrementServerConfigRevision(s);\r
3934 \r
3935         return ERR_NO_ERROR;\r
3936 }\r
3937 \r
3938 // ユーザーの削除\r
3939 UINT StDeleteUser(ADMIN *a, RPC_DELETE_USER *t)\r
3940 {\r
3941         SERVER *s = a->Server;\r
3942         CEDAR *c = s->Cedar;\r
3943         HUB *h = NULL;\r
3944         UINT ret = ERR_NO_ERROR;\r
3945 \r
3946         if (IsEmptyStr(t->Name) || IsUserName(t->Name) == false)\r
3947         {\r
3948                 return ERR_INVALID_PARAMETER;\r
3949         }\r
3950 \r
3951         CHECK_RIGHT;\r
3952         NO_SUPPORT_FOR_BRIDGE;\r
3953         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
3954         {\r
3955                 return ERR_NOT_SUPPORTED;\r
3956         }\r
3957 \r
3958         LockHubList(c);\r
3959         {\r
3960                 h = GetHub(c, t->HubName);\r
3961         }\r
3962         UnlockHubList(c);\r
3963 \r
3964         if (h == NULL)\r
3965         {\r
3966                 return ERR_HUB_NOT_FOUND;\r
3967         }\r
3968 \r
3969         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_users") != 0)\r
3970         {\r
3971                 ReleaseHub(h);\r
3972                 return ERR_NOT_ENOUGH_RIGHT;\r
3973         }\r
3974 \r
3975         ALog(a, h, "LA_DELETE_USER", t->Name);\r
3976 \r
3977         AcLock(h);\r
3978         {\r
3979                 if (AcDeleteUser(h, t->Name) == false)\r
3980                 {\r
3981                         ret = ERR_OBJECT_NOT_FOUND;\r
3982                 }\r
3983         }\r
3984         AcUnlock(h);\r
3985 \r
3986         ReleaseHub(h);\r
3987 \r
3988         IncrementServerConfigRevision(s);\r
3989 \r
3990         return ret;\r
3991 }\r
3992 \r
3993 // ユーザーの取得\r
3994 UINT StGetUser(ADMIN *a, RPC_SET_USER *t)\r
3995 {\r
3996         SERVER *s = a->Server;\r
3997         CEDAR *c = s->Cedar;\r
3998         HUB *h = NULL;\r
3999         UINT ret = ERR_NO_ERROR;\r
4000         USER *u = NULL;\r
4001         USERGROUP *g = NULL;\r
4002         char name[MAX_USERNAME_LEN + 1];\r
4003         char hubname[MAX_HUBNAME_LEN + 1];\r
4004         StrCpy(name, sizeof(name), t->Name);\r
4005         StrCpy(hubname, sizeof(hubname), t->HubName);\r
4006 \r
4007         if (IsEmptyStr(t->Name) || IsUserName(t->Name) == false)\r
4008         {\r
4009                 return ERR_INVALID_PARAMETER;\r
4010         }\r
4011 \r
4012         CHECK_RIGHT;\r
4013         NO_SUPPORT_FOR_BRIDGE;\r
4014         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
4015         {\r
4016                 return ERR_NOT_SUPPORTED;\r
4017         }\r
4018 \r
4019         FreeRpcSetUser(t);\r
4020         Zero(t, sizeof(RPC_SET_USER));\r
4021         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
4022         StrCpy(t->Name, sizeof(t->Name), name);\r
4023 \r
4024         LockHubList(c);\r
4025         {\r
4026                 h = GetHub(c, hubname);\r
4027         }\r
4028         UnlockHubList(c);\r
4029 \r
4030         if (h == NULL)\r
4031         {\r
4032                 return ERR_HUB_NOT_FOUND;\r
4033         }\r
4034 \r
4035         AcLock(h);\r
4036         {\r
4037                 u = AcGetUser(h, name);\r
4038                 if (u == NULL)\r
4039                 {\r
4040                         ret = ERR_OBJECT_NOT_FOUND;\r
4041                 }\r
4042                 else\r
4043                 {\r
4044                         Lock(u->lock);\r
4045                         {\r
4046                                 StrCpy(t->GroupName, sizeof(t->GroupName), u->GroupName);\r
4047                                 UniStrCpy(t->Realname, sizeof(t->Realname), u->RealName);\r
4048                                 UniStrCpy(t->Note, sizeof(t->Note), u->Note);\r
4049                                 t->CreatedTime = u->CreatedTime;\r
4050                                 t->UpdatedTime = u->UpdatedTime;\r
4051                                 t->ExpireTime = u->ExpireTime;\r
4052 \r
4053                                 t->AuthType = u->AuthType;\r
4054                                 t->AuthData = CopyAuthData(u->AuthData, t->AuthType);\r
4055                                 t->NumLogin = u->NumLogin;\r
4056                                 Copy(&t->Traffic, u->Traffic, sizeof(TRAFFIC));\r
4057                                 if (u->Policy != NULL)\r
4058                                 {\r
4059                                         t->Policy = ClonePolicy(u->Policy);\r
4060                                 }\r
4061                         }\r
4062                         Unlock(u->lock);\r
4063 \r
4064                         ReleaseUser(u);\r
4065                 }\r
4066         }\r
4067         AcUnlock(h);\r
4068 \r
4069         ReleaseHub(h);\r
4070 \r
4071         return ret;\r
4072 }\r
4073 \r
4074 // ユーザーの設定\r
4075 UINT StSetUser(ADMIN *a, RPC_SET_USER *t)\r
4076 {\r
4077         SERVER *s = a->Server;\r
4078         CEDAR *c = s->Cedar;\r
4079         HUB *h = NULL;\r
4080         UINT ret = ERR_NO_ERROR;\r
4081         USER *u = NULL;\r
4082         USERGROUP *g = NULL;\r
4083 \r
4084         if (IsEmptyStr(t->Name) || IsUserName(t->Name) == false)\r
4085         {\r
4086                 return ERR_INVALID_PARAMETER;\r
4087         }\r
4088 \r
4089         NO_SUPPORT_FOR_BRIDGE;\r
4090         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
4091         {\r
4092                 return ERR_NOT_SUPPORTED;\r
4093         }\r
4094 \r
4095         CHECK_RIGHT;\r
4096 \r
4097         if (StrCmpi(t->Name, "*") == 0)\r
4098         {\r
4099                 if (t->AuthType != AUTHTYPE_RADIUS && t->AuthType != AUTHTYPE_NT)\r
4100                 {\r
4101                         return ERR_INVALID_PARAMETER;\r
4102                 }\r
4103         }\r
4104 \r
4105         if (t->AuthType == AUTHTYPE_RADIUS ||\r
4106                 t->AuthType == AUTHTYPE_ROOTCERT ||\r
4107                 t->AuthType == AUTHTYPE_USERCERT ||\r
4108                 t->AuthType == AUTHTYPE_NT)\r
4109         {\r
4110                 return ERR_UTVPN_NOT_SUPPORT_THIS_AUTH;\r
4111         }\r
4112 \r
4113         LockHubList(c);\r
4114         {\r
4115                 h = GetHub(c, t->HubName);\r
4116         }\r
4117         UnlockHubList(c);\r
4118 \r
4119         if (h == NULL)\r
4120         {\r
4121                 return ERR_HUB_NOT_FOUND;\r
4122         }\r
4123 \r
4124         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_users") != 0)\r
4125         {\r
4126                 ReleaseHub(h);\r
4127                 return ERR_NOT_ENOUGH_RIGHT;\r
4128         }\r
4129 \r
4130         AcLock(h);\r
4131         {\r
4132                 u = AcGetUser(h, t->Name);\r
4133                 if (u == NULL)\r
4134                 {\r
4135                         ret = ERR_OBJECT_NOT_FOUND;\r
4136                 }\r
4137                 else\r
4138                 {\r
4139                         Lock(u->lock);\r
4140                         {\r
4141                                 if (StrLen(t->GroupName) != 0)\r
4142                                 {\r
4143                                         g = AcGetGroup(h, t->GroupName);\r
4144 \r
4145                                         if (g != NULL)\r
4146                                         {\r
4147                                                 JoinUserToGroup(u, g);\r
4148                                                 ReleaseGroup(g);\r
4149                                         }\r
4150                                         else\r
4151                                         {\r
4152                                                 ret = ERR_GROUP_NOT_FOUND;\r
4153                                         }\r
4154                                 }\r
4155                                 else\r
4156                                 {\r
4157                                         JoinUserToGroup(u, NULL);\r
4158                                 }\r
4159 \r
4160                                 if (ret != ERR_GROUP_NOT_FOUND)\r
4161                                 {\r
4162                                         Free(u->RealName);\r
4163                                         Free(u->Note);\r
4164                                         u->RealName = UniCopyStr(t->Realname);\r
4165                                         u->Note = UniCopyStr(t->Note);\r
4166                                         SetUserAuthData(u, t->AuthType, CopyAuthData(t->AuthData, t->AuthType));\r
4167                                         u->ExpireTime = t->ExpireTime;\r
4168                                         u->UpdatedTime = SystemTime64();\r
4169 \r
4170                                         SetUserPolicy(u, t->Policy);\r
4171                                 }\r
4172                         }\r
4173                         Unlock(u->lock);\r
4174 \r
4175                         IncrementServerConfigRevision(s);\r
4176 \r
4177                         ReleaseUser(u);\r
4178                 }\r
4179         }\r
4180         AcUnlock(h);\r
4181 \r
4182         if (ret == ERR_NO_ERROR)\r
4183         {\r
4184                 ALog(a, h, "LA_SET_USER", t->Name);\r
4185         }\r
4186 \r
4187         ReleaseHub(h);\r
4188 \r
4189         return ret;\r
4190 }\r
4191 \r
4192 // ユーザーの作成\r
4193 UINT StCreateUser(ADMIN *a, RPC_SET_USER *t)\r
4194 {\r
4195         SERVER *s = a->Server;\r
4196         CEDAR *c = s->Cedar;\r
4197         HUB *h = NULL;\r
4198         UINT ret = ERR_NO_ERROR;\r
4199         USER *u;\r
4200         USERGROUP *g = NULL;\r
4201 \r
4202         if (IsEmptyStr(t->Name) || IsUserName(t->Name) == false)\r
4203         {\r
4204                 return ERR_INVALID_PARAMETER;\r
4205         }\r
4206 \r
4207         NO_SUPPORT_FOR_BRIDGE;\r
4208         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
4209         {\r
4210                 return ERR_NOT_SUPPORTED;\r
4211         }\r
4212 \r
4213         CHECK_RIGHT;\r
4214 \r
4215         if (t->AuthType == AUTHTYPE_RADIUS ||\r
4216                 t->AuthType == AUTHTYPE_ROOTCERT ||\r
4217                 t->AuthType == AUTHTYPE_USERCERT ||\r
4218                 t->AuthType == AUTHTYPE_NT)\r
4219         {\r
4220                 return ERR_UTVPN_NOT_SUPPORT_THIS_AUTH;\r
4221         }\r
4222 \r
4223         if (IsUserName(t->Name) == false)\r
4224         {\r
4225                 return ERR_INVALID_PARAMETER;\r
4226         }\r
4227 \r
4228         if (StrCmpi(t->Name, "*") == 0)\r
4229         {\r
4230                 if (t->AuthType != AUTHTYPE_RADIUS && t->AuthType != AUTHTYPE_NT)\r
4231                 {\r
4232                         return ERR_INVALID_PARAMETER;\r
4233                 }\r
4234         }\r
4235 \r
4236         LockHubList(c);\r
4237         {\r
4238                 h = GetHub(c, t->HubName);\r
4239         }\r
4240         UnlockHubList(c);\r
4241 \r
4242         if (h == NULL)\r
4243         {\r
4244                 return ERR_HUB_NOT_FOUND;\r
4245         }\r
4246 \r
4247         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_users") != 0)\r
4248         {\r
4249                 ReleaseHub(h);\r
4250                 return ERR_NOT_ENOUGH_RIGHT;\r
4251         }\r
4252 \r
4253         u = NewUser(t->Name, t->Realname, t->Note, t->AuthType, CopyAuthData(t->AuthData, t->AuthType));\r
4254         if (u == NULL)\r
4255         {\r
4256                 ReleaseHub(h);\r
4257                 return ERR_INTERNAL_ERROR;\r
4258         }\r
4259 \r
4260         u->ExpireTime = t->ExpireTime;\r
4261 \r
4262         SetUserPolicy(u, t->Policy);\r
4263 \r
4264         AcLock(h);\r
4265         {\r
4266                 if ((LIST_NUM(h->HubDb->UserList) >= GetServerCapsInt(a->Server, "i_max_users_per_hub")) ||\r
4267                         ((GetHubAdminOption(h, "max_users") != 0) && (LIST_NUM(h->HubDb->UserList) >= GetHubAdminOption(h, "max_users"))))\r
4268                 {\r
4269                         ret = ERR_TOO_MANY_USER;\r
4270                 }\r
4271                 else if (SiTooManyUserObjectsInServer(s, false))\r
4272                 {\r
4273                         ret = ERR_TOO_MANY_USERS_CREATED;\r
4274                         ALog(a, h, "ERR_128");\r
4275                 }\r
4276                 else if (AcIsUser(h, t->Name))\r
4277                 {\r
4278                         ret = ERR_USER_ALREADY_EXISTS;\r
4279                 }\r
4280                 else\r
4281                 {\r
4282                         if (StrLen(t->GroupName) != 0)\r
4283                         {\r
4284                                 g = AcGetGroup(h, t->GroupName);\r
4285                                 if (g == NULL)\r
4286                                 {\r
4287                                         ret = ERR_GROUP_NOT_FOUND;\r
4288                                 }\r
4289                         }\r
4290 \r
4291                         if (ret != ERR_GROUP_NOT_FOUND)\r
4292                         {\r
4293                                 if (g != NULL)\r
4294                                 {\r
4295                                         JoinUserToGroup(u, g);\r
4296                                         ReleaseGroup(g);\r
4297                                 }\r
4298 \r
4299                                 AcAddUser(h, u);\r
4300                                 ALog(a, h, "LA_CREATE_USER", t->Name);\r
4301 \r
4302                                 IncrementServerConfigRevision(s);\r
4303                         }\r
4304                 }\r
4305         }\r
4306         AcUnlock(h);\r
4307 \r
4308         ReleaseUser(u);\r
4309 \r
4310         ReleaseHub(h);\r
4311 \r
4312         return ret;\r
4313 }\r
4314 \r
4315 // アクセスリストの列挙\r
4316 UINT StEnumAccess(ADMIN *a, RPC_ENUM_ACCESS_LIST *t)\r
4317 {\r
4318         SERVER *s = a->Server;\r
4319         CEDAR *c = s->Cedar;\r
4320         HUB *h;\r
4321         UINT i;\r
4322         char hubname[MAX_HUBNAME_LEN + 1];\r
4323 \r
4324         CHECK_RIGHT;\r
4325         NO_SUPPORT_FOR_BRIDGE;\r
4326         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
4327         {\r
4328                 return ERR_NOT_SUPPORTED;\r
4329         }\r
4330 \r
4331         LockHubList(c);\r
4332         {\r
4333                 h = GetHub(c, t->HubName);\r
4334         }\r
4335         UnlockHubList(c);\r
4336 \r
4337         if (h == NULL)\r
4338         {\r
4339                 return ERR_HUB_NOT_FOUND;\r
4340         }\r
4341 \r
4342         StrCpy(hubname, sizeof(hubname), t->HubName);\r
4343         FreeRpcEnumAccessList(t);\r
4344         Zero(t, sizeof(RPC_ENUM_ACCESS_LIST));\r
4345         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
4346 \r
4347         LockList(h->AccessList);\r
4348         {\r
4349                 t->NumAccess = LIST_NUM(h->AccessList);\r
4350                 t->Accesses = ZeroMalloc(sizeof(ACCESS) * t->NumAccess);\r
4351 \r
4352                 for (i = 0;i < LIST_NUM(h->AccessList);i++)\r
4353                 {\r
4354                         ACCESS *a = &t->Accesses[i];\r
4355                         Copy(a, LIST_DATA(h->AccessList, i), sizeof(ACCESS));\r
4356                 }\r
4357         }\r
4358         UnlockList(h->AccessList);\r
4359 \r
4360         ReleaseHub(h);\r
4361 \r
4362         return ERR_NO_ERROR;\r
4363 }\r
4364 \r
4365 // アクセスリストの削除\r
4366 UINT StDeleteAccess(ADMIN *a, RPC_DELETE_ACCESS *t)\r
4367 {\r
4368         SERVER *s = a->Server;\r
4369         CEDAR *c = s->Cedar;\r
4370         HUB *h;\r
4371         UINT i;\r
4372         bool exists;\r
4373 \r
4374         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
4375         {\r
4376                 return ERR_NOT_FARM_CONTROLLER;\r
4377         }\r
4378 \r
4379         CHECK_RIGHT;\r
4380         NO_SUPPORT_FOR_BRIDGE;\r
4381 \r
4382         LockHubList(c);\r
4383         {\r
4384                 h = GetHub(c, t->HubName);\r
4385         }\r
4386         UnlockHubList(c);\r
4387 \r
4388         if (h == NULL)\r
4389         {\r
4390                 return ERR_HUB_NOT_FOUND;\r
4391         }\r
4392 \r
4393         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_access_list") != 0)\r
4394         {\r
4395                 ReleaseHub(h);\r
4396                 return ERR_NOT_ENOUGH_RIGHT;\r
4397         }\r
4398 \r
4399         exists = false;\r
4400 \r
4401         LockList(h->AccessList);\r
4402         {\r
4403                 for (i = 0;i < LIST_NUM(h->AccessList);i++)\r
4404                 {\r
4405                         ACCESS *access = LIST_DATA(h->AccessList, i);\r
4406 \r
4407                         if (access->Id == t->Id)\r
4408                         {\r
4409                                 Free(access);\r
4410                                 Delete(h->AccessList, access);\r
4411                                 exists = true;\r
4412 \r
4413                                 break;\r
4414                         }\r
4415                 }\r
4416         }\r
4417         UnlockList(h->AccessList);\r
4418 \r
4419         if (exists == false)\r
4420         {\r
4421                 ReleaseHub(h);\r
4422                 return ERR_OBJECT_NOT_FOUND;\r
4423         }\r
4424 \r
4425         ALog(a, h, "LA_DELETE_ACCESS");\r
4426 \r
4427         IncrementServerConfigRevision(s);\r
4428 \r
4429         ReleaseHub(h);\r
4430 \r
4431         return ERR_NO_ERROR;\r
4432 }\r
4433 \r
4434 // アクセスリストの設定\r
4435 UINT StSetAccessList(ADMIN *a, RPC_ENUM_ACCESS_LIST *t)\r
4436 {\r
4437         SERVER *s = a->Server;\r
4438         CEDAR *c = s->Cedar;\r
4439         HUB *h;\r
4440         UINT i;\r
4441         bool no_jitter = false;\r
4442         UINT ret = ERR_NO_ERROR;\r
4443 \r
4444         NO_SUPPORT_FOR_BRIDGE;\r
4445         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
4446         {\r
4447                 return ERR_NOT_SUPPORTED;\r
4448         }\r
4449 \r
4450         CHECK_RIGHT;\r
4451 \r
4452         if (t->NumAccess > GetServerCapsInt(a->Server, "i_max_access_lists"))\r
4453         {\r
4454                 return ERR_TOO_MANY_ACCESS_LIST;\r
4455         }\r
4456 \r
4457         LockHubList(c);\r
4458         {\r
4459                 h = GetHub(c, t->HubName);\r
4460         }\r
4461         UnlockHubList(c);\r
4462 \r
4463         if (h == NULL)\r
4464         {\r
4465                 return ERR_HUB_NOT_FOUND;\r
4466         }\r
4467 \r
4468         no_jitter = GetHubAdminOption(h, "no_delay_jitter_packet_loss");\r
4469 \r
4470         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_access_list") != 0)\r
4471         {\r
4472                 ReleaseHub(h);\r
4473                 return ERR_NOT_ENOUGH_RIGHT;\r
4474         }\r
4475 \r
4476         if (a->ServerAdmin == false && GetHubAdminOption(h, "max_accesslists") != 0 &&\r
4477                 t->NumAccess > GetHubAdminOption(h, "max_accesslists"))\r
4478         {\r
4479                 ReleaseHub(h);\r
4480                 return ERR_TOO_MANY_ACCESS_LIST;\r
4481         }\r
4482 \r
4483         LockList(h->AccessList);\r
4484         {\r
4485                 UINT i;\r
4486 \r
4487                 // 古いバージョンのクライアントで対応できない形式のアクセスリストがすでに\r
4488                 // 存在しないかどうかチェックする\r
4489                 if (a->ClientBuild < 6560)\r
4490                 {\r
4491                         for (i = 0;i < LIST_NUM(h->AccessList);i++)\r
4492                         {\r
4493                                 ACCESS *access = LIST_DATA(h->AccessList, i);\r
4494                                 if (access->IsIPv6 ||\r
4495                                         access->Jitter != 0 || access->Loss != 0 || access->Delay != 0)\r
4496                                 {\r
4497                                         ret = ERR_VERSION_INVALID;\r
4498                                         break;\r
4499                                 }\r
4500                         }\r
4501                 }\r
4502 \r
4503                 if (ret == ERR_NO_ERROR)\r
4504                 {\r
4505                         // すべて削除\r
4506                         for (i = 0;i < LIST_NUM(h->AccessList);i++)\r
4507                         {\r
4508                                 ACCESS *access = LIST_DATA(h->AccessList, i);\r
4509                                 Free(access);\r
4510                         }\r
4511 \r
4512                         DeleteAll(h->AccessList);\r
4513                 }\r
4514         }\r
4515         UnlockList(h->AccessList);\r
4516 \r
4517         if (ret == ERR_NO_ERROR)\r
4518         {\r
4519                 ALog(a, h, "LA_SET_ACCESS_LIST", t->NumAccess);\r
4520 \r
4521                 // すべてのアクセスリストを追加\r
4522                 for (i = 0;i < t->NumAccess;i++)\r
4523                 {\r
4524                         ACCESS *a = &t->Accesses[i];\r
4525 \r
4526                         if (no_jitter)\r
4527                         {\r
4528                                 a->Jitter = a->Loss = a->Delay = 0;\r
4529                         }\r
4530 \r
4531                         AddAccessList(h, a);\r
4532                 }\r
4533 \r
4534                 IncrementServerConfigRevision(s);\r
4535 \r
4536                 h->CurrentVersion++;\r
4537                 SiHubUpdateProc(h);\r
4538         }\r
4539 \r
4540         ReleaseHub(h);\r
4541 \r
4542         return ret;\r
4543 }\r
4544 \r
4545 // アクセスリストの追加\r
4546 UINT StAddAccess(ADMIN *a, RPC_ADD_ACCESS *t)\r
4547 {\r
4548         SERVER *s = a->Server;\r
4549         CEDAR *c = s->Cedar;\r
4550         HUB *h;\r
4551         bool no_jitter = false;\r
4552 \r
4553         NO_SUPPORT_FOR_BRIDGE;\r
4554         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
4555         {\r
4556                 return ERR_NOT_SUPPORTED;\r
4557         }\r
4558 \r
4559         CHECK_RIGHT;\r
4560 \r
4561         LockHubList(c);\r
4562         {\r
4563                 h = GetHub(c, t->HubName);\r
4564         }\r
4565         UnlockHubList(c);\r
4566 \r
4567         if (h == NULL)\r
4568         {\r
4569                 return ERR_HUB_NOT_FOUND;\r
4570         }\r
4571 \r
4572         no_jitter = GetHubAdminOption(h, "no_delay_jitter_packet_loss");\r
4573 \r
4574         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_access_list") != 0)\r
4575         {\r
4576                 ReleaseHub(h);\r
4577                 return ERR_NOT_ENOUGH_RIGHT;\r
4578         }\r
4579 \r
4580         if ((LIST_NUM(h->AccessList) >= GetServerCapsInt(a->Server, "i_max_access_lists") ||\r
4581                 (GetHubAdminOption(h, "max_accesslists") != 0) && (LIST_NUM(h->AccessList) >= GetHubAdminOption(h, "max_accesslists"))))\r
4582         {\r
4583                 ReleaseHub(h);\r
4584                 return ERR_TOO_MANY_ACCESS_LIST;\r
4585         }\r
4586 \r
4587         ALog(a, h, "LA_ADD_ACCESS");\r
4588 \r
4589         if (no_jitter)\r
4590         {\r
4591                 t->Access.Jitter = t->Access.Delay = t->Access.Loss = 0;\r
4592         }\r
4593 \r
4594         AddAccessList(h, &t->Access);\r
4595 \r
4596         h->CurrentVersion++;\r
4597         SiHubUpdateProc(h);\r
4598 \r
4599         ReleaseHub(h);\r
4600 \r
4601         IncrementServerConfigRevision(s);\r
4602 \r
4603         return ERR_NO_ERROR;\r
4604 }\r
4605 \r
4606 // リンクの名前を変更する\r
4607 UINT StRenameLink(ADMIN *a, RPC_RENAME_LINK *t)\r
4608 {\r
4609         UINT i;\r
4610         SERVER *s = a->Server;\r
4611         CEDAR *c = s->Cedar;\r
4612         HUB *h;\r
4613         UINT ret = ERR_NO_ERROR;\r
4614         LINK *k;\r
4615         bool exists = false;\r
4616 \r
4617         if (UniIsEmptyStr(t->OldAccountName) || UniIsEmptyStr(t->NewAccountName))\r
4618         {\r
4619                 return ERR_INVALID_PARAMETER;\r
4620         }\r
4621 \r
4622         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
4623         {\r
4624                 return ERR_NOT_SUPPORTED;\r
4625         }\r
4626 \r
4627         CHECK_RIGHT;\r
4628 \r
4629         if (UniStrCmpi(t->NewAccountName, t->OldAccountName) == 0)\r
4630         {\r
4631                 // 古い名前と新しい名前が同一\r
4632                 return ERR_NO_ERROR;\r
4633         }\r
4634 \r
4635         h = GetHub(c, t->HubName);\r
4636 \r
4637         if (h == NULL)\r
4638         {\r
4639                 return ERR_HUB_NOT_FOUND;\r
4640         }\r
4641 \r
4642         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)\r
4643         {\r
4644                 ReleaseHub(h);\r
4645                 return ERR_NOT_ENOUGH_RIGHT;\r
4646         }\r
4647 \r
4648         k = NULL;\r
4649 \r
4650         // リンクを検索する\r
4651         LockList(h->LinkList);\r
4652         {\r
4653                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
4654                 {\r
4655                         LINK *kk = LIST_DATA(h->LinkList, i);\r
4656                         Lock(kk->lock);\r
4657                         {\r
4658                                 if (UniStrCmpi(kk->Option->AccountName, t->OldAccountName) == 0)\r
4659                                 {\r
4660                                         k = kk;\r
4661                                         AddRef(kk->ref);\r
4662                                 }\r
4663                         }\r
4664                         Unlock(kk->lock);\r
4665 \r
4666                         if (k != NULL)\r
4667                         {\r
4668                                 break;\r
4669                         }\r
4670                 }\r
4671 \r
4672                 exists = false;\r
4673 \r
4674                 if (k != NULL)\r
4675                 {\r
4676                         // 新しい名前がすでに存在しているリンクの名前と重複するかどうか検査\r
4677                         for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
4678                         {\r
4679                                 LINK *kk = LIST_DATA(h->LinkList, i);\r
4680                                 Lock(kk->lock);\r
4681                                 {\r
4682                                         if (UniStrCmpi(kk->Option->AccountName, t->NewAccountName) == 0)\r
4683                                         {\r
4684                                                 // 重複した\r
4685                                                 exists = true;\r
4686                                         }\r
4687                                 }\r
4688                                 Unlock(kk->lock);\r
4689                         }\r
4690 \r
4691                         if (exists)\r
4692                         {\r
4693                                 // すでに同一の名前が存在している\r
4694                                 ret = ERR_LINK_ALREADY_EXISTS;\r
4695                         }\r
4696                         else\r
4697                         {\r
4698                                 // 変更作業を実施する\r
4699                                 UniStrCpy(k->Option->AccountName, sizeof(k->Option->AccountName), t->NewAccountName);\r
4700 \r
4701                                 ALog(a, h, "LA_RENAME_LINK", t->OldAccountName, t->NewAccountName);\r
4702 \r
4703                                 IncrementServerConfigRevision(s);\r
4704                         }\r
4705                 }\r
4706         }\r
4707         UnlockList(h->LinkList);\r
4708 \r
4709         if (k == NULL)\r
4710         {\r
4711                 // リンクが見つからない\r
4712                 ReleaseHub(h);\r
4713                 return ERR_OBJECT_NOT_FOUND;\r
4714         }\r
4715 \r
4716         ReleaseLink(k);\r
4717 \r
4718         ReleaseHub(h);\r
4719 \r
4720         return ret;\r
4721 }\r
4722 \r
4723 // リンクを削除する\r
4724 UINT StDeleteLink(ADMIN *a, RPC_LINK *t)\r
4725 {\r
4726         UINT i;\r
4727         SERVER *s = a->Server;\r
4728         CEDAR *c = s->Cedar;\r
4729         HUB *h;\r
4730         UINT ret = ERR_NO_ERROR;\r
4731         char hubname[MAX_HUBNAME_LEN + 1];\r
4732         wchar_t accountname[MAX_ACCOUNT_NAME_LEN + 1];\r
4733         LINK *k;\r
4734 \r
4735         if (UniIsEmptyStr(t->AccountName))\r
4736         {\r
4737                 return ERR_INVALID_PARAMETER;\r
4738         }\r
4739 \r
4740         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
4741         {\r
4742                 return ERR_NOT_SUPPORTED;\r
4743         }\r
4744 \r
4745         CHECK_RIGHT;\r
4746 \r
4747         LockHubList(c);\r
4748         {\r
4749                 h = GetHub(c, t->HubName);\r
4750         }\r
4751         UnlockHubList(c);\r
4752 \r
4753         if (h == NULL)\r
4754         {\r
4755                 return ERR_HUB_NOT_FOUND;\r
4756         }\r
4757 \r
4758         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)\r
4759         {\r
4760                 ReleaseHub(h);\r
4761                 return ERR_NOT_ENOUGH_RIGHT;\r
4762         }\r
4763 \r
4764         StrCpy(hubname, sizeof(hubname), t->HubName);\r
4765         UniStrCpy(accountname, sizeof(accountname), t->AccountName);\r
4766         k = NULL;\r
4767 \r
4768         // リンクを検索する\r
4769         LockList(h->LinkList);\r
4770         {\r
4771                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
4772                 {\r
4773                         LINK *kk = LIST_DATA(h->LinkList, i);\r
4774                         Lock(kk->lock);\r
4775                         {\r
4776                                 if (UniStrCmpi(kk->Option->AccountName, accountname) == 0)\r
4777                                 {\r
4778                                         k = kk;\r
4779                                         AddRef(kk->ref);\r
4780                                 }\r
4781                         }\r
4782                         Unlock(kk->lock);\r
4783 \r
4784                         if (k != NULL)\r
4785                         {\r
4786                                 break;\r
4787                         }\r
4788                 }\r
4789         }\r
4790         UnlockList(h->LinkList);\r
4791 \r
4792         if (k == NULL)\r
4793         {\r
4794                 // リンクが見つからない\r
4795                 ReleaseHub(h);\r
4796 \r
4797                 return ERR_OBJECT_NOT_FOUND;\r
4798         }\r
4799 \r
4800         ALog(a, h, "LA_DELETE_LINK", t->AccountName);\r
4801 \r
4802         SetLinkOffline(k);\r
4803 \r
4804         IncrementServerConfigRevision(s);\r
4805 \r
4806         DelLink(h, k);\r
4807 \r
4808         ReleaseLink(k);\r
4809         ReleaseHub(h);\r
4810 \r
4811         return ret;\r
4812 }\r
4813 \r
4814 // リンクをオフラインにする\r
4815 UINT StSetLinkOffline(ADMIN *a, RPC_LINK *t)\r
4816 {\r
4817         UINT i;\r
4818         SERVER *s = a->Server;\r
4819         CEDAR *c = s->Cedar;\r
4820         HUB *h;\r
4821         UINT ret = ERR_NO_ERROR;\r
4822         char hubname[MAX_HUBNAME_LEN + 1];\r
4823         wchar_t accountname[MAX_ACCOUNT_NAME_LEN + 1];\r
4824         LINK *k;\r
4825 \r
4826         if (UniIsEmptyStr(t->AccountName))\r
4827         {\r
4828                 return ERR_INVALID_PARAMETER;\r
4829         }\r
4830 \r
4831         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
4832         {\r
4833                 return ERR_NOT_SUPPORTED;\r
4834         }\r
4835 \r
4836         CHECK_RIGHT;\r
4837 \r
4838         LockHubList(c);\r
4839         {\r
4840                 h = GetHub(c, t->HubName);\r
4841         }\r
4842         UnlockHubList(c);\r
4843 \r
4844         if (h == NULL)\r
4845         {\r
4846                 return ERR_HUB_NOT_FOUND;\r
4847         }\r
4848 \r
4849         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)\r
4850         {\r
4851                 ReleaseHub(h);\r
4852                 return ERR_NOT_ENOUGH_RIGHT;\r
4853         }\r
4854 \r
4855         StrCpy(hubname, sizeof(hubname), t->HubName);\r
4856         UniStrCpy(accountname, sizeof(accountname), t->AccountName);\r
4857         k = NULL;\r
4858 \r
4859         // リンクを検索する\r
4860         LockList(h->LinkList);\r
4861         {\r
4862                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
4863                 {\r
4864                         LINK *kk = LIST_DATA(h->LinkList, i);\r
4865                         Lock(kk->lock);\r
4866                         {\r
4867                                 if (UniStrCmpi(kk->Option->AccountName, accountname) == 0)\r
4868                                 {\r
4869                                         k = kk;\r
4870                                         AddRef(kk->ref);\r
4871                                 }\r
4872                         }\r
4873                         Unlock(kk->lock);\r
4874 \r
4875                         if (k != NULL)\r
4876                         {\r
4877                                 break;\r
4878                         }\r
4879                 }\r
4880         }\r
4881         UnlockList(h->LinkList);\r
4882 \r
4883         if (k == NULL)\r
4884         {\r
4885                 // リンクが見つからない\r
4886                 ReleaseHub(h);\r
4887 \r
4888                 return ERR_OBJECT_NOT_FOUND;\r
4889         }\r
4890 \r
4891         ALog(a, h, "LA_SET_LINK_OFFLINE", t->AccountName);\r
4892 \r
4893         SetLinkOffline(k);\r
4894 \r
4895         IncrementServerConfigRevision(s);\r
4896 \r
4897         ReleaseLink(k);\r
4898         ReleaseHub(h);\r
4899 \r
4900         return ret;\r
4901 }\r
4902 \r
4903 // リンクをオンラインにする\r
4904 UINT StSetLinkOnline(ADMIN *a, RPC_LINK *t)\r
4905 {\r
4906         UINT i;\r
4907         SERVER *s = a->Server;\r
4908         CEDAR *c = s->Cedar;\r
4909         HUB *h;\r
4910         UINT ret = ERR_NO_ERROR;\r
4911         char hubname[MAX_HUBNAME_LEN + 1];\r
4912         wchar_t accountname[MAX_ACCOUNT_NAME_LEN + 1];\r
4913         LINK *k;\r
4914 \r
4915         if (UniIsEmptyStr(t->AccountName))\r
4916         {\r
4917                 return ERR_INVALID_PARAMETER;\r
4918         }\r
4919 \r
4920         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
4921         {\r
4922                 return ERR_NOT_SUPPORTED;\r
4923         }\r
4924 \r
4925         CHECK_RIGHT;\r
4926 \r
4927         LockHubList(c);\r
4928         {\r
4929                 h = GetHub(c, t->HubName);\r
4930         }\r
4931         UnlockHubList(c);\r
4932 \r
4933         if (h == NULL)\r
4934         {\r
4935                 return ERR_HUB_NOT_FOUND;\r
4936         }\r
4937 \r
4938         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)\r
4939         {\r
4940                 ReleaseHub(h);\r
4941                 return ERR_NOT_ENOUGH_RIGHT;\r
4942         }\r
4943 \r
4944         StrCpy(hubname, sizeof(hubname), t->HubName);\r
4945         UniStrCpy(accountname, sizeof(accountname), t->AccountName);\r
4946         k = NULL;\r
4947 \r
4948         // リンクを検索する\r
4949         LockList(h->LinkList);\r
4950         {\r
4951                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
4952                 {\r
4953                         LINK *kk = LIST_DATA(h->LinkList, i);\r
4954                         Lock(kk->lock);\r
4955                         {\r
4956                                 if (UniStrCmpi(kk->Option->AccountName, accountname) == 0)\r
4957                                 {\r
4958                                         k = kk;\r
4959                                         AddRef(kk->ref);\r
4960                                 }\r
4961                         }\r
4962                         Unlock(kk->lock);\r
4963 \r
4964                         if (k != NULL)\r
4965                         {\r
4966                                 break;\r
4967                         }\r
4968                 }\r
4969         }\r
4970         UnlockList(h->LinkList);\r
4971 \r
4972         if (k == NULL)\r
4973         {\r
4974                 // リンクが見つからない\r
4975                 ReleaseHub(h);\r
4976 \r
4977                 return ERR_OBJECT_NOT_FOUND;\r
4978         }\r
4979 \r
4980         ALog(a, h, "LA_SET_LINK_ONLINE", t->AccountName);\r
4981 \r
4982         SetLinkOnline(k);\r
4983 \r
4984         ReleaseLink(k);\r
4985         ReleaseHub(h);\r
4986 \r
4987         IncrementServerConfigRevision(s);\r
4988 \r
4989         return ret;\r
4990 }\r
4991 \r
4992 // リンク状態の取得\r
4993 UINT StGetLinkStatus(ADMIN *a, RPC_LINK_STATUS *t)\r
4994 {\r
4995         UINT i;\r
4996         SERVER *s = a->Server;\r
4997         CEDAR *c = s->Cedar;\r
4998         HUB *h;\r
4999         UINT ret = ERR_NO_ERROR;\r
5000         char hubname[MAX_HUBNAME_LEN + 1];\r
5001         wchar_t accountname[MAX_ACCOUNT_NAME_LEN + 1];\r
5002         LINK *k;\r
5003         SESSION *sess;\r
5004 \r
5005         if (UniIsEmptyStr(t->AccountName))\r
5006         {\r
5007                 return ERR_INVALID_PARAMETER;\r
5008         }\r
5009 \r
5010         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
5011         {\r
5012                 return ERR_NOT_SUPPORTED;\r
5013         }\r
5014 \r
5015         CHECK_RIGHT;\r
5016 \r
5017         LockHubList(c);\r
5018         {\r
5019                 h = GetHub(c, t->HubName);\r
5020         }\r
5021         UnlockHubList(c);\r
5022 \r
5023         if (h == NULL)\r
5024         {\r
5025                 return ERR_HUB_NOT_FOUND;\r
5026         }\r
5027 \r
5028         StrCpy(hubname, sizeof(hubname), t->HubName);\r
5029         UniStrCpy(accountname, sizeof(accountname), t->AccountName);\r
5030         FreeRpcLinkStatus(t);\r
5031         Zero(t, sizeof(RPC_LINK_STATUS));\r
5032         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
5033         UniStrCpy(t->AccountName, sizeof(t->AccountName), accountname);\r
5034 \r
5035         k = NULL;\r
5036 \r
5037         // リンクを検索する\r
5038         LockList(h->LinkList);\r
5039         {\r
5040                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
5041                 {\r
5042                         LINK *kk = LIST_DATA(h->LinkList, i);\r
5043                         Lock(kk->lock);\r
5044                         {\r
5045                                 if (UniStrCmpi(kk->Option->AccountName, accountname) == 0)\r
5046                                 {\r
5047                                         k = kk;\r
5048                                         AddRef(kk->ref);\r
5049                                 }\r
5050                         }\r
5051                         Unlock(kk->lock);\r
5052 \r
5053                         if (k != NULL)\r
5054                         {\r
5055                                 break;\r
5056                         }\r
5057                 }\r
5058         }\r
5059         UnlockList(h->LinkList);\r
5060 \r
5061         if (k == NULL)\r
5062         {\r
5063                 // リンクが見つからない\r
5064                 ReleaseHub(h);\r
5065 \r
5066                 return ERR_OBJECT_NOT_FOUND;\r
5067         }\r
5068 \r
5069         // セッションからステータス情報を取得する\r
5070         Lock(k->lock);\r
5071         {\r
5072                 sess = k->ClientSession;\r
5073                 if (sess != NULL)\r
5074                 {\r
5075                         AddRef(sess->ref);\r
5076                 }\r
5077         }\r
5078         Unlock(k->lock);\r
5079 \r
5080         if (sess != NULL && k->Offline == false)\r
5081         {\r
5082                 CiGetSessionStatus(&t->Status, sess);\r
5083         }\r
5084         else\r
5085         {\r
5086                 ret = ERR_LINK_IS_OFFLINE;\r
5087         }\r
5088         ReleaseSession(sess);\r
5089 \r
5090         ReleaseLink(k);\r
5091         ReleaseHub(h);\r
5092 \r
5093         return ret;\r
5094 }\r
5095 \r
5096 // リンクの列挙\r
5097 UINT StEnumLink(ADMIN *a, RPC_ENUM_LINK *t)\r
5098 {\r
5099         SERVER *s = a->Server;\r
5100         CEDAR *c = s->Cedar;\r
5101         HUB *h;\r
5102         char hubname[MAX_HUBNAME_LEN + 1];\r
5103         UINT i;\r
5104 \r
5105         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
5106         {\r
5107                 return ERR_NOT_SUPPORTED;\r
5108         }\r
5109 \r
5110         CHECK_RIGHT;\r
5111 \r
5112         LockHubList(c);\r
5113         {\r
5114                 h = GetHub(c, t->HubName);\r
5115         }\r
5116         UnlockHubList(c);\r
5117 \r
5118         if (h == NULL)\r
5119         {\r
5120                 return ERR_HUB_NOT_FOUND;\r
5121         }\r
5122 \r
5123         StrCpy(hubname, sizeof(hubname), t->HubName);\r
5124         FreeRpcEnumLink(t);\r
5125         Zero(t, sizeof(RPC_ENUM_LINK));\r
5126         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
5127 \r
5128         LockList(h->LinkList);\r
5129         {\r
5130                 t->NumLink = LIST_NUM(h->LinkList);\r
5131                 t->Links = ZeroMalloc(sizeof(RPC_ENUM_LINK_ITEM) * t->NumLink);\r
5132 \r
5133                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
5134                 {\r
5135                         LINK *k = LIST_DATA(h->LinkList, i);\r
5136                         RPC_ENUM_LINK_ITEM *e = &t->Links[i];\r
5137 \r
5138                         Lock(k->lock);\r
5139                         {\r
5140                                 UniStrCpy(e->AccountName, sizeof(e->AccountName), k->Option->AccountName);\r
5141                                 StrCpy(e->Hostname, sizeof(e->Hostname), k->Option->Hostname);\r
5142                                 StrCpy(e->HubName, sizeof(e->HubName), k->Option->HubName);\r
5143                                 e->Online = k->Offline ? false : true;\r
5144 \r
5145                                 if (e->Online)\r
5146                                 {\r
5147                                         if (k->ClientSession != NULL)\r
5148                                         {\r
5149                                                 e->ConnectedTime = TickToTime(k->ClientSession->CurrentConnectionEstablishTime);\r
5150                                                 e->Connected = (k->ClientSession->ClientStatus == CLIENT_STATUS_ESTABLISHED);\r
5151                                                 e->LastError = k->ClientSession->Err;\r
5152                                         }\r
5153                                 }\r
5154                         }\r
5155                         Unlock(k->lock);\r
5156                 }\r
5157         }\r
5158         UnlockList(h->LinkList);\r
5159 \r
5160         ReleaseHub(h);\r
5161 \r
5162         return ERR_NO_ERROR;\r
5163 }\r
5164 \r
5165 // リンクの取得\r
5166 UINT StGetLink(ADMIN *a, RPC_CREATE_LINK *t)\r
5167 {\r
5168         SERVER *s = a->Server;\r
5169         CEDAR *c = s->Cedar;\r
5170         HUB *h;\r
5171         UINT ret = ERR_NO_ERROR;\r
5172         UINT i;\r
5173         char hubname[MAX_SIZE];\r
5174         LINK *k;\r
5175 \r
5176         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
5177         {\r
5178                 return ERR_NOT_SUPPORTED;\r
5179         }\r
5180 \r
5181         CHECK_RIGHT;\r
5182 \r
5183         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
5184         {\r
5185                 return ERR_LINK_CANT_CREATE_ON_FARM;\r
5186         }\r
5187 \r
5188         LockHubList(c);\r
5189         {\r
5190                 h = GetHub(c, t->HubName);\r
5191         }\r
5192         UnlockHubList(c);\r
5193 \r
5194         if (h == NULL)\r
5195         {\r
5196                 return ERR_HUB_NOT_FOUND;\r
5197         }\r
5198 \r
5199         k = NULL;\r
5200 \r
5201         // リンクを検索する\r
5202         LockList(h->LinkList);\r
5203         {\r
5204                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
5205                 {\r
5206                         LINK *kk = LIST_DATA(h->LinkList, i);\r
5207                         Lock(kk->lock);\r
5208                         {\r
5209                                 if (UniStrCmpi(kk->Option->AccountName, t->ClientOption->AccountName) == 0)\r
5210                                 {\r
5211                                         k = kk;\r
5212                                         AddRef(kk->ref);\r
5213                                 }\r
5214                         }\r
5215                         Unlock(kk->lock);\r
5216 \r
5217                         if (k != NULL)\r
5218                         {\r
5219                                 break;\r
5220                         }\r
5221                 }\r
5222         }\r
5223         UnlockList(h->LinkList);\r
5224 \r
5225         if (k == NULL)\r
5226         {\r
5227                 // 見つからなかった\r
5228                 ReleaseHub(h);\r
5229                 return ERR_OBJECT_NOT_FOUND;\r
5230         }\r
5231 \r
5232         StrCpy(hubname, sizeof(hubname), t->HubName);\r
5233         FreeRpcCreateLink(t);\r
5234         Zero(t, sizeof(t));\r
5235         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
5236 \r
5237         Lock(k->lock);\r
5238         {\r
5239                 // 設定の取得\r
5240                 t->Online = k->Offline ? false : true;\r
5241                 t->ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));\r
5242                 Copy(t->ClientOption, k->Option, sizeof(CLIENT_OPTION));\r
5243                 t->ClientAuth = CopyClientAuth(k->Auth);\r
5244                 Copy(&t->Policy, k->Policy, sizeof(POLICY));\r
5245 \r
5246                 t->CheckServerCert = k->CheckServerCert;\r
5247                 t->ServerCert = CloneX(k->ServerCert);\r
5248         }\r
5249         Unlock(k->lock);\r
5250 \r
5251         ReleaseLink(k);\r
5252         ReleaseHub(h);\r
5253 \r
5254         return ret;\r
5255 }\r
5256 \r
5257 // リンクの設定\r
5258 UINT StSetLink(ADMIN *a, RPC_CREATE_LINK *t)\r
5259 {\r
5260         SERVER *s = a->Server;\r
5261         CEDAR *c = s->Cedar;\r
5262         HUB *h;\r
5263         UINT ret = ERR_NO_ERROR;\r
5264         UINT i;\r
5265         LINK *k;\r
5266 \r
5267         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
5268         {\r
5269                 return ERR_NOT_SUPPORTED;\r
5270         }\r
5271 \r
5272         CHECK_RIGHT;\r
5273 \r
5274         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
5275         {\r
5276                 return ERR_LINK_CANT_CREATE_ON_FARM;\r
5277         }\r
5278 \r
5279         LockHubList(c);\r
5280         {\r
5281                 h = GetHub(c, t->HubName);\r
5282         }\r
5283         UnlockHubList(c);\r
5284 \r
5285         if (h == NULL)\r
5286         {\r
5287                 return ERR_HUB_NOT_FOUND;\r
5288         }\r
5289 \r
5290         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)\r
5291         {\r
5292                 ReleaseHub(h);\r
5293                 return ERR_NOT_ENOUGH_RIGHT;\r
5294         }\r
5295 \r
5296         k = NULL;\r
5297 \r
5298         // リンクを検索する\r
5299         LockList(h->LinkList);\r
5300         {\r
5301                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
5302                 {\r
5303                         LINK *kk = LIST_DATA(h->LinkList, i);\r
5304                         Lock(kk->lock);\r
5305                         {\r
5306                                 if (UniStrCmpi(kk->Option->AccountName, t->ClientOption->AccountName) == 0)\r
5307                                 {\r
5308                                         k = kk;\r
5309                                         AddRef(kk->ref);\r
5310                                 }\r
5311                         }\r
5312                         Unlock(kk->lock);\r
5313 \r
5314                         if (k != NULL)\r
5315                         {\r
5316                                 break;\r
5317                         }\r
5318                 }\r
5319         }\r
5320         UnlockList(h->LinkList);\r
5321 \r
5322         if (k == NULL)\r
5323         {\r
5324                 // 見つからなかった\r
5325                 ReleaseHub(h);\r
5326                 return ERR_OBJECT_NOT_FOUND;\r
5327         }\r
5328 \r
5329         ALog(a, h, "LA_SET_LINK", t->ClientOption->AccountName);\r
5330 \r
5331         Lock(k->lock);\r
5332         {\r
5333                 // 設定の更新\r
5334                 if (k->ServerCert != NULL)\r
5335                 {\r
5336                         FreeX(k->ServerCert);\r
5337                         k->ServerCert = NULL;\r
5338                 }\r
5339 \r
5340                 Copy(k->Option, t->ClientOption, sizeof(CLIENT_OPTION));\r
5341                 StrCpy(k->Option->DeviceName, sizeof(k->Option->DeviceName), LINK_DEVICE_NAME);\r
5342                 k->Option->NumRetry = INFINITE;\r
5343                 k->Option->RetryInterval = 10;\r
5344                 k->Option->NoRoutingTracking = true;\r
5345                 CiFreeClientAuth(k->Auth);\r
5346                 k->Auth = CopyClientAuth(t->ClientAuth);\r
5347 \r
5348                 if (t->Policy.Ver3 == false)\r
5349                 {\r
5350                         Copy(k->Policy, &t->Policy, sizeof(UINT) * NUM_POLICY_ITEM_FOR_VER2);\r
5351                 }\r
5352                 else\r
5353                 {\r
5354                         Copy(k->Policy, &t->Policy, sizeof(POLICY));\r
5355                 }\r
5356 \r
5357                 k->Option->RequireBridgeRoutingMode = true;     // ブリッジ / ルーティングモード有効\r
5358                 k->Option->RequireMonitorMode = false;  // モニタモード無効\r
5359 \r
5360                 k->CheckServerCert = t->CheckServerCert;\r
5361                 k->ServerCert = CloneX(t->ServerCert);\r
5362         }\r
5363         Unlock(k->lock);\r
5364 \r
5365         IncrementServerConfigRevision(s);\r
5366 \r
5367         ReleaseLink(k);\r
5368         ReleaseHub(h);\r
5369 \r
5370         return ret;\r
5371 }\r
5372 \r
5373 // リンクの作成\r
5374 UINT StCreateLink(ADMIN *a, RPC_CREATE_LINK *t)\r
5375 {\r
5376         SERVER *s = a->Server;\r
5377         CEDAR *c = s->Cedar;\r
5378         HUB *h;\r
5379         UINT ret = ERR_NO_ERROR;\r
5380         UINT i;\r
5381         LINK *k;\r
5382 \r
5383         CHECK_RIGHT;\r
5384 \r
5385         if (s->ServerType != SERVER_TYPE_STANDALONE)\r
5386         {\r
5387                 return ERR_LINK_CANT_CREATE_ON_FARM;\r
5388         }\r
5389 \r
5390         LockHubList(c);\r
5391         {\r
5392                 h = GetHub(c, t->HubName);\r
5393         }\r
5394         UnlockHubList(c);\r
5395 \r
5396         if (h == NULL)\r
5397         {\r
5398                 return ERR_HUB_NOT_FOUND;\r
5399         }\r
5400 \r
5401         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_cascade") != 0)\r
5402         {\r
5403                 ReleaseHub(h);\r
5404                 return ERR_NOT_ENOUGH_RIGHT;\r
5405         }\r
5406 \r
5407         k = NULL;\r
5408 \r
5409         // 既に同じ名前のリンクが存在しないかどうか調べる\r
5410         LockList(h->LinkList);\r
5411         {\r
5412                 for (i = 0;i < LIST_NUM(h->LinkList);i++)\r
5413                 {\r
5414                         LINK *kk = LIST_DATA(h->LinkList, i);\r
5415                         Lock(kk->lock);\r
5416                         {\r
5417                                 if (UniStrCmpi(kk->Option->AccountName, t->ClientOption->AccountName) == 0)\r
5418                                 {\r
5419                                         k = kk;\r
5420                                         AddRef(kk->ref);\r
5421                                 }\r
5422                         }\r
5423                         Unlock(kk->lock);\r
5424 \r
5425                         if (k != NULL)\r
5426                         {\r
5427                                 break;\r
5428                         }\r
5429                 }\r
5430         }\r
5431         UnlockList(h->LinkList);\r
5432 \r
5433         if (k != NULL)\r
5434         {\r
5435                 // すでに同じ名前のリンクが存在する\r
5436                 ReleaseLink(k);\r
5437                 ReleaseHub(h);\r
5438                 return ERR_LINK_ALREADY_EXISTS;\r
5439         }\r
5440 \r
5441         ALog(a, h, "LA_CREATE_LINK", t->ClientOption->AccountName);\r
5442 \r
5443         // リンクの作成\r
5444         k = NewLink(c, h, t->ClientOption, t->ClientAuth, &t->Policy);\r
5445 \r
5446         if (k == NULL)\r
5447         {\r
5448                 // 作成失敗\r
5449                 ret = ERR_INTERNAL_ERROR;\r
5450         }\r
5451         else\r
5452         {\r
5453                 // サーバー証明書検証設定\r
5454                 k->CheckServerCert = t->CheckServerCert;\r
5455                 k->ServerCert = CloneX(t->ServerCert);\r
5456 \r
5457                 // オフラインにしておく\r
5458                 k->Offline = false;\r
5459                 SetLinkOffline(k);\r
5460                 ReleaseLink(k);\r
5461 \r
5462                 IncrementServerConfigRevision(s);\r
5463         }\r
5464 \r
5465         ReleaseHub(h);\r
5466 \r
5467         return ret;\r
5468 }\r
5469 \r
5470 // HUB の CA を削除\r
5471 UINT StDeleteCa(ADMIN *a, RPC_HUB_DELETE_CA *t)\r
5472 {\r
5473         SERVER *s = a->Server;\r
5474         CEDAR *c = s->Cedar;\r
5475         HUB *h;\r
5476         UINT ret = ERR_NO_ERROR;\r
5477 \r
5478         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
5479         {\r
5480                 return ERR_NOT_FARM_CONTROLLER;\r
5481         }\r
5482 \r
5483         NO_SUPPORT_FOR_BRIDGE;\r
5484         CHECK_RIGHT;\r
5485 \r
5486         LockHubList(c);\r
5487         {\r
5488                 h = GetHub(c, t->HubName);\r
5489         }\r
5490         UnlockHubList(c);\r
5491 \r
5492         if (h == NULL)\r
5493         {\r
5494                 return ERR_HUB_NOT_FOUND;\r
5495         }\r
5496 \r
5497         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_cert_list") != 0)\r
5498         {\r
5499                 ReleaseHub(h);\r
5500                 return ERR_NOT_ENOUGH_RIGHT;\r
5501         }\r
5502 \r
5503         LockList(h->HubDb->RootCertList);\r
5504         {\r
5505                 if (IsInListKey(h->HubDb->RootCertList, t->Key))\r
5506                 {\r
5507                         X *x = ListKeyToPointer(h->HubDb->RootCertList, t->Key);\r
5508                         Delete(h->HubDb->RootCertList, x);\r
5509                         FreeX(x);\r
5510 \r
5511                         ALog(a, h, "LA_DELETE_CA");\r
5512 \r
5513                         IncrementServerConfigRevision(s);\r
5514                 }\r
5515                 else\r
5516                 {\r
5517                         ret = ERR_OBJECT_NOT_FOUND;\r
5518                 }\r
5519         }\r
5520         UnlockList(h->HubDb->RootCertList);\r
5521 \r
5522         ReleaseHub(h);\r
5523 \r
5524         return ret;\r
5525 }\r
5526 \r
5527 // HUB の CA を取得\r
5528 UINT StGetCa(ADMIN *a, RPC_HUB_GET_CA *t)\r
5529 {\r
5530         SERVER *s = a->Server;\r
5531         CEDAR *c = s->Cedar;\r
5532         HUB *h;\r
5533         UINT ret = ERR_NO_ERROR;\r
5534         char hubname[MAX_HUBNAME_LEN + 1];\r
5535         UINT key;\r
5536 \r
5537         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
5538         {\r
5539                 return ERR_NOT_FARM_CONTROLLER;\r
5540         }\r
5541 \r
5542         NO_SUPPORT_FOR_BRIDGE;\r
5543 \r
5544         StrCpy(hubname, sizeof(hubname), t->HubName);\r
5545         key = t->Key;\r
5546 \r
5547         FreeRpcHubGetCa(t);\r
5548         Zero(t, sizeof(RPC_HUB_GET_CA));\r
5549         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
5550 \r
5551         CHECK_RIGHT;\r
5552 \r
5553         LockHubList(c);\r
5554         {\r
5555                 h = GetHub(c, t->HubName);\r
5556         }\r
5557         UnlockHubList(c);\r
5558 \r
5559         if (h == NULL)\r
5560         {\r
5561                 return ERR_HUB_NOT_FOUND;\r
5562         }\r
5563 \r
5564         LockList(h->HubDb->RootCertList);\r
5565         {\r
5566                 if (IsInListKey(h->HubDb->RootCertList, key))\r
5567                 {\r
5568                         X *x = ListKeyToPointer(h->HubDb->RootCertList, key);\r
5569 \r
5570                         t->Cert = CloneX(x);\r
5571                 }\r
5572                 else\r
5573                 {\r
5574                         ret = ERR_OBJECT_NOT_FOUND;\r
5575                 }\r
5576         }\r
5577         UnlockList(h->HubDb->RootCertList);\r
5578 \r
5579         ReleaseHub(h);\r
5580 \r
5581         return ret;\r
5582 }\r
5583 \r
5584 // HUB の CA を列挙\r
5585 UINT StEnumCa(ADMIN *a, RPC_HUB_ENUM_CA *t)\r
5586 {\r
5587         SERVER *s = a->Server;\r
5588         CEDAR *c = s->Cedar;\r
5589         HUB *h;\r
5590         char hubname[MAX_HUBNAME_LEN + 1];\r
5591         UINT i;\r
5592 \r
5593         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
5594         {\r
5595                 return ERR_NOT_FARM_CONTROLLER;\r
5596         }\r
5597 \r
5598         NO_SUPPORT_FOR_BRIDGE;\r
5599 \r
5600         StrCpy(hubname, sizeof(hubname), t->HubName);\r
5601 \r
5602         FreeRpcHubEnumCa(t);\r
5603         Zero(t, sizeof(RPC_HUB_ENUM_CA));\r
5604 \r
5605         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
5606         CHECK_RIGHT;\r
5607 \r
5608         LockHubList(c);\r
5609         {\r
5610                 h = GetHub(c, hubname);\r
5611         }\r
5612         UnlockHubList(c);\r
5613 \r
5614         if (h == NULL)\r
5615         {\r
5616                 return ERR_HUB_NOT_FOUND;\r
5617         }\r
5618 \r
5619         Zero(t, sizeof(RPC_HUB_ENUM_CA));\r
5620         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
5621 \r
5622         if (h->HubDb->RootCertList != NULL)\r
5623         {\r
5624                 LockList(h->HubDb->RootCertList);\r
5625                 {\r
5626                         t->NumCa = LIST_NUM(h->HubDb->RootCertList);\r
5627                         t->Ca = ZeroMalloc(sizeof(RPC_HUB_ENUM_CA_ITEM) * t->NumCa);\r
5628 \r
5629                         for (i = 0;i < t->NumCa;i++)\r
5630                         {\r
5631                                 RPC_HUB_ENUM_CA_ITEM *e = &t->Ca[i];\r
5632                                 X *x = LIST_DATA(h->HubDb->RootCertList, i);\r
5633 \r
5634                                 e->Key = POINTER_TO_KEY(x);\r
5635                                 GetAllNameFromNameEx(e->SubjectName, sizeof(e->SubjectName), x->subject_name);\r
5636                                 GetAllNameFromNameEx(e->IssuerName, sizeof(e->IssuerName), x->issuer_name);\r
5637                                 e->Expires = x->notAfter;\r
5638                         }\r
5639                 }\r
5640                 UnlockList(h->HubDb->RootCertList);\r
5641         }\r
5642 \r
5643         ReleaseHub(h);\r
5644 \r
5645         return ERR_NO_ERROR;\r
5646 }\r
5647 \r
5648 // HUB へ CA を追加\r
5649 UINT StAddCa(ADMIN *a, RPC_HUB_ADD_CA *t)\r
5650 {\r
5651         SERVER *s = a->Server;\r
5652         CEDAR *c = s->Cedar;\r
5653         HUB *h;\r
5654 \r
5655         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
5656         {\r
5657                 return ERR_NOT_FARM_CONTROLLER;\r
5658         }\r
5659 \r
5660         if (c->Bridge)\r
5661         {\r
5662                 return ERR_NOT_SUPPORTED;\r
5663         }\r
5664 \r
5665         if (t->Cert == NULL)\r
5666         {\r
5667                 ERR_INVALID_PARAMETER;\r
5668         }\r
5669 \r
5670         if (t->Cert->is_compatible_bit == false)\r
5671         {\r
5672                 return ERR_NOT_RSA_1024;\r
5673         }\r
5674 \r
5675         CHECK_RIGHT;\r
5676 \r
5677         LockHubList(c);\r
5678         {\r
5679                 h = GetHub(c, t->HubName);\r
5680         }\r
5681         UnlockHubList(c);\r
5682 \r
5683         if (h == NULL)\r
5684         {\r
5685                 return ERR_HUB_NOT_FOUND;\r
5686         }\r
5687 \r
5688         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_cert_list") != 0)\r
5689         {\r
5690                 ReleaseHub(h);\r
5691                 return ERR_NOT_ENOUGH_RIGHT;\r
5692         }\r
5693 \r
5694         IncrementServerConfigRevision(s);\r
5695 \r
5696         ALog(a, h, "LA_ADD_CA");\r
5697 \r
5698         AddRootCert(h, t->Cert);\r
5699 \r
5700         ReleaseHub(h);\r
5701 \r
5702         return ERR_NO_ERROR;\r
5703 }\r
5704 \r
5705 // HUB ログ設定の取得\r
5706 UINT StGetHubLog(ADMIN *a, RPC_HUB_LOG *t)\r
5707 {\r
5708         SERVER *s = a->Server;\r
5709         CEDAR *c = s->Cedar;\r
5710         HUB *h;\r
5711 \r
5712         CHECK_RIGHT;\r
5713 \r
5714         LockHubList(c);\r
5715         {\r
5716                 h = GetHub(c, t->HubName);\r
5717         }\r
5718         UnlockHubList(c);\r
5719 \r
5720         if (h == NULL)\r
5721         {\r
5722                 return ERR_HUB_NOT_FOUND;\r
5723         }\r
5724 \r
5725         GetHubLogSetting(h, &t->LogSetting);\r
5726 \r
5727         ReleaseHub(h);\r
5728 \r
5729         return ERR_NO_ERROR;\r
5730 }\r
5731 \r
5732 // HUB ログ設定の設定\r
5733 UINT StSetHubLog(ADMIN *a, RPC_HUB_LOG *t)\r
5734 {\r
5735         SERVER *s = a->Server;\r
5736         CEDAR *c = s->Cedar;\r
5737         HUB *h;\r
5738 \r
5739         CHECK_RIGHT;\r
5740 \r
5741         LockHubList(c);\r
5742         {\r
5743                 h = GetHub(c, t->HubName);\r
5744         }\r
5745         UnlockHubList(c);\r
5746 \r
5747         if (h == NULL)\r
5748         {\r
5749                 return ERR_HUB_NOT_FOUND;\r
5750         }\r
5751 \r
5752         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_log_config") != 0)\r
5753         {\r
5754                 ReleaseHub(h);\r
5755                 return ERR_NOT_ENOUGH_RIGHT;\r
5756         }\r
5757 \r
5758         ALog(a, h, "LA_SET_HUB_LOG");\r
5759 \r
5760         SetHubLogSettingEx(h, &t->LogSetting,\r
5761                 (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_log_switch_type") != 0));\r
5762 \r
5763         h->CurrentVersion++;\r
5764         SiHubUpdateProc(h);\r
5765 \r
5766         ReleaseHub(h);\r
5767 \r
5768         IncrementServerConfigRevision(s);\r
5769 \r
5770         return ERR_NO_ERROR;\r
5771 }\r
5772 \r
5773 // HUB 状態の取得\r
5774 UINT StGetHubStatus(ADMIN *a, RPC_HUB_STATUS *t)\r
5775 {\r
5776         SERVER *s = a->Server;\r
5777         CEDAR *c = s->Cedar;\r
5778         HUB *h;\r
5779 \r
5780         CHECK_RIGHT;\r
5781 \r
5782         LockHubList(c);\r
5783         {\r
5784                 h = GetHub(c, t->HubName);\r
5785         }\r
5786         UnlockHubList(c);\r
5787 \r
5788         if (h == NULL)\r
5789         {\r
5790                 return ERR_HUB_NOT_FOUND;\r
5791         }\r
5792 \r
5793         Zero(t, sizeof(RPC_HUB_STATUS));\r
5794 \r
5795         Lock(h->lock);\r
5796         {\r
5797                 StrCpy(t->HubName, sizeof(t->HubName), h->Name);\r
5798                 t->HubType = h->Type;\r
5799                 t->Online = h->Offline ? false : true;\r
5800                 t->NumSessions = LIST_NUM(h->SessionList);\r
5801                 t->NumSessionsClient = Count(h->NumSessionsClient);\r
5802                 t->NumSessionsBridge = Count(h->NumSessionsBridge);\r
5803                 t->NumAccessLists = LIST_NUM(h->AccessList);\r
5804 \r
5805                 if (h->HubDb != NULL)\r
5806                 {\r
5807                         t->NumUsers = LIST_NUM(h->HubDb->UserList);\r
5808                         t->NumGroups = LIST_NUM(h->HubDb->GroupList);\r
5809                 }\r
5810 \r
5811                 t->NumMacTables = LIST_NUM(h->MacTable);\r
5812                 t->NumIpTables = LIST_NUM(h->IpTable);\r
5813 \r
5814                 Lock(h->TrafficLock);\r
5815                 {\r
5816                         Copy(&t->Traffic, h->Traffic, sizeof(TRAFFIC));\r
5817                 }\r
5818                 Unlock(h->TrafficLock);\r
5819 \r
5820                 t->NumLogin = h->NumLogin;\r
5821                 t->LastCommTime = h->LastCommTime;\r
5822                 t->LastLoginTime = h->LastLoginTime;\r
5823                 t->CreatedTime = h->CreatedTime;\r
5824         }\r
5825         Unlock(h->lock);\r
5826 \r
5827         if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
5828         {\r
5829                 UINT i;\r
5830                 LockList(s->FarmMemberList);\r
5831                 {\r
5832                         for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
5833                         {\r
5834                                 UINT k;\r
5835                                 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
5836 \r
5837                                 if (f->Me == false)\r
5838                                 {\r
5839                                         LockList(f->HubList);\r
5840                                         {\r
5841                                                 for (k = 0;k < LIST_NUM(f->HubList);k++)\r
5842                                                 {\r
5843                                                         HUB_LIST *h = LIST_DATA(f->HubList, k);\r
5844 \r
5845                                                         if (StrCmpi(h->Name, t->HubName) == 0)\r
5846                                                         {\r
5847                                                                 t->NumSessions += h->NumSessions;\r
5848                                                                 t->NumSessionsClient += h->NumSessionsClient;\r
5849                                                                 t->NumSessionsBridge += h->NumSessionsBridge;\r
5850                                                                 t->NumMacTables += h->NumMacTables;\r
5851                                                                 t->NumIpTables += h->NumIpTables;\r
5852                                                         }\r
5853                                                 }\r
5854                                         }\r
5855                                         UnlockList(f->HubList);\r
5856                                 }\r
5857                         }\r
5858                 }\r
5859                 UnlockList(s->FarmMemberList);\r
5860         }\r
5861 \r
5862         if (h->Type != HUB_TYPE_FARM_STATIC)\r
5863         {\r
5864                 t->SecureNATEnabled = h->EnableSecureNAT;\r
5865         }\r
5866 \r
5867         ReleaseHub(h);\r
5868 \r
5869         return ERR_NO_ERROR;\r
5870 }\r
5871 \r
5872 // HUB の SecureNAT を有効にする\r
5873 UINT StEnableSecureNAT(ADMIN *a, RPC_HUB *t)\r
5874 {\r
5875         SERVER *s = a->Server;\r
5876         CEDAR *c = s->Cedar;\r
5877         HUB *h;\r
5878 \r
5879         CHECK_RIGHT;\r
5880 \r
5881         LockHubList(c);\r
5882         {\r
5883                 h = GetHub(c, t->HubName);\r
5884         }\r
5885         UnlockHubList(c);\r
5886 \r
5887         if (h == NULL)\r
5888         {\r
5889                 return ERR_HUB_NOT_FOUND;\r
5890         }\r
5891 \r
5892         if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)\r
5893         {\r
5894                 ReleaseHub(h);\r
5895                 return ERR_NOT_SUPPORTED;\r
5896         }\r
5897         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
5898         {\r
5899                 ReleaseHub(h);\r
5900                 return ERR_NOT_FARM_CONTROLLER;\r
5901         }\r
5902 \r
5903         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat") != 0)\r
5904         {\r
5905                 ReleaseHub(h);\r
5906                 return ERR_NOT_ENOUGH_RIGHT;\r
5907         }\r
5908 \r
5909         ALog(a, h, "LA_ENABLE_SNAT");\r
5910 \r
5911         EnableSecureNAT(h, true);\r
5912 \r
5913         h->CurrentVersion++;\r
5914         SiHubUpdateProc(h);\r
5915 \r
5916         IncrementServerConfigRevision(s);\r
5917 \r
5918         ReleaseHub(h);\r
5919 \r
5920         return ERR_NO_ERROR;\r
5921 }\r
5922 \r
5923 // HUB の SecureNAT を無効にする\r
5924 UINT StDisableSecureNAT(ADMIN *a, RPC_HUB *t)\r
5925 {\r
5926         SERVER *s = a->Server;\r
5927         CEDAR *c = s->Cedar;\r
5928         HUB *h;\r
5929 \r
5930         CHECK_RIGHT;\r
5931 \r
5932         LockHubList(c);\r
5933         {\r
5934                 h = GetHub(c, t->HubName);\r
5935         }\r
5936         UnlockHubList(c);\r
5937 \r
5938         if (h == NULL)\r
5939         {\r
5940                 return ERR_HUB_NOT_FOUND;\r
5941         }\r
5942 \r
5943         if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)\r
5944         {\r
5945                 ReleaseHub(h);\r
5946                 return ERR_NOT_SUPPORTED;\r
5947         }\r
5948         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
5949         {\r
5950                 ReleaseHub(h);\r
5951                 return ERR_NOT_FARM_CONTROLLER;\r
5952         }\r
5953 \r
5954         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat") != 0)\r
5955         {\r
5956                 ReleaseHub(h);\r
5957                 return ERR_NOT_ENOUGH_RIGHT;\r
5958         }\r
5959 \r
5960         ALog(a, h, "LA_DISABLE_SNAT");\r
5961 \r
5962         EnableSecureNAT(h, false);\r
5963 \r
5964         h->CurrentVersion++;\r
5965         SiHubUpdateProc(h);\r
5966 \r
5967         IncrementServerConfigRevision(s);\r
5968 \r
5969         ReleaseHub(h);\r
5970 \r
5971         return ERR_NO_ERROR;\r
5972 }\r
5973 \r
5974 // NAT エントリの列挙\r
5975 UINT StEnumNAT(ADMIN *a, RPC_ENUM_NAT *t)\r
5976 {\r
5977         SERVER *s = a->Server;\r
5978         CEDAR *c = s->Cedar;\r
5979         HUB *h;\r
5980         UINT ret = ERR_NO_ERROR;\r
5981         char hubname[MAX_HUBNAME_LEN + 1];\r
5982         UINT i;\r
5983 \r
5984         CHECK_RIGHT;\r
5985 \r
5986         StrCpy(hubname, sizeof(hubname), t->HubName);\r
5987 \r
5988         LockHubList(c);\r
5989         {\r
5990                 h = GetHub(c, t->HubName);\r
5991         }\r
5992         UnlockHubList(c);\r
5993 \r
5994         if (h == NULL)\r
5995         {\r
5996                 return ERR_HUB_NOT_FOUND;\r
5997         }\r
5998 \r
5999         if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)\r
6000         {\r
6001                 ReleaseHub(h);\r
6002                 return ERR_NOT_SUPPORTED;\r
6003         }\r
6004 \r
6005         Lock(h->lock_online);\r
6006         {\r
6007                 if (h->SecureNAT == NULL)\r
6008                 {\r
6009                         ret = ERR_SNAT_NOT_RUNNING;\r
6010                 }\r
6011                 else\r
6012                 {\r
6013                         NtEnumNatList(h->SecureNAT->Nat, t);\r
6014                 }\r
6015         }\r
6016         Unlock(h->lock_online);\r
6017 \r
6018         if (h->Type == HUB_TYPE_FARM_DYNAMIC)\r
6019         {\r
6020                 if (ret == ERR_SNAT_NOT_RUNNING)\r
6021                 {\r
6022                         // リモートの SecureNAT の状態取得\r
6023                         LockList(s->FarmMemberList);\r
6024                         {\r
6025                                 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
6026                                 {\r
6027                                         FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
6028                                         if (f->Me == false)\r
6029                                         {\r
6030                                                 RPC_ENUM_NAT tmp;\r
6031 \r
6032                                                 Zero(&tmp, sizeof(tmp));\r
6033 \r
6034                                                 SiCallEnumNat(s, f, hubname, &tmp);\r
6035 \r
6036                                                 if (tmp.NumItem >= 1)\r
6037                                                 {\r
6038                                                         FreeRpcEnumNat(t);\r
6039                                                         Copy(t, &tmp, sizeof(RPC_ENUM_NAT));\r
6040                                                         ret = ERR_NO_ERROR;\r
6041                                                         break;\r
6042                                                 }\r
6043                                                 else\r
6044                                                 {\r
6045                                                         FreeRpcEnumNat(&tmp);\r
6046                                                 }\r
6047                                         }\r
6048                                 }\r
6049                         }\r
6050                         UnlockList(s->FarmMemberList);\r
6051                 }\r
6052         }\r
6053 \r
6054         ReleaseHub(h);\r
6055 \r
6056         ret = ERR_NO_ERROR;\r
6057 \r
6058         return ret;\r
6059 }\r
6060 \r
6061 // SecureNAT の状態の取得\r
6062 UINT StGetSecureNATStatus(ADMIN *a, RPC_NAT_STATUS *t)\r
6063 {\r
6064         SERVER *s = a->Server;\r
6065         CEDAR *c = s->Cedar;\r
6066         HUB *h;\r
6067         UINT ret = ERR_NO_ERROR;\r
6068         char hubname[MAX_HUBNAME_LEN + 1];\r
6069         UINT i;\r
6070 \r
6071         CHECK_RIGHT;\r
6072 \r
6073         StrCpy(hubname, sizeof(hubname), t->HubName);\r
6074 \r
6075         LockHubList(c);\r
6076         {\r
6077                 h = GetHub(c, t->HubName);\r
6078         }\r
6079         UnlockHubList(c);\r
6080 \r
6081         if (h == NULL)\r
6082         {\r
6083                 return ERR_HUB_NOT_FOUND;\r
6084         }\r
6085 \r
6086         if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)\r
6087         {\r
6088                 ReleaseHub(h);\r
6089                 return ERR_NOT_SUPPORTED;\r
6090         }\r
6091 \r
6092         Lock(h->lock_online);\r
6093         {\r
6094                 if (h->SecureNAT == NULL)\r
6095                 {\r
6096                         ret = ERR_SNAT_NOT_RUNNING;\r
6097                 }\r
6098                 else\r
6099                 {\r
6100                         NtGetStatus(h->SecureNAT->Nat, t);\r
6101                 }\r
6102         }\r
6103         Unlock(h->lock_online);\r
6104 \r
6105         if (h->Type == HUB_TYPE_FARM_DYNAMIC)\r
6106         {\r
6107                 if (ret == ERR_SNAT_NOT_RUNNING)\r
6108                 {\r
6109                         // リモートの SecureNAT の状態取得\r
6110                         LockList(s->FarmMemberList);\r
6111                         {\r
6112                                 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
6113                                 {\r
6114                                         FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
6115                                         if (f->Me == false)\r
6116                                         {\r
6117                                                 RPC_NAT_STATUS tmp;\r
6118 \r
6119                                                 Zero(&tmp, sizeof(tmp));\r
6120 \r
6121                                                 SiCallGetNatStatus(s, f, hubname, &tmp);\r
6122 \r
6123                                                 if (tmp.NumDhcpClients == 0 && tmp.NumTcpSessions == 0 && tmp.NumUdpSessions == 0)\r
6124                                                 {\r
6125                                                 }\r
6126                                                 else\r
6127                                                 {\r
6128                                                         Copy(t, &tmp, sizeof(RPC_NAT_STATUS));\r
6129                                                         ret = ERR_NO_ERROR;\r
6130                                                         break;\r
6131                                                 }\r
6132                                         }\r
6133                                 }\r
6134                         }\r
6135                         UnlockList(s->FarmMemberList);\r
6136                 }\r
6137         }\r
6138 \r
6139         ReleaseHub(h);\r
6140 \r
6141         ret = ERR_NO_ERROR;\r
6142 \r
6143         return ret;\r
6144 }\r
6145 \r
6146 // DHCP エントリの列挙\r
6147 UINT StEnumDHCP(ADMIN *a, RPC_ENUM_DHCP *t)\r
6148 {\r
6149         SERVER *s = a->Server;\r
6150         CEDAR *c = s->Cedar;\r
6151         HUB *h;\r
6152         UINT ret = ERR_NO_ERROR;\r
6153         char hubname[MAX_HUBNAME_LEN + 1];\r
6154         UINT i;\r
6155         StrCpy(hubname, sizeof(hubname), t->HubName);\r
6156 \r
6157         CHECK_RIGHT;\r
6158 \r
6159         LockHubList(c);\r
6160         {\r
6161                 h = GetHub(c, t->HubName);\r
6162         }\r
6163         UnlockHubList(c);\r
6164 \r
6165         if (h == NULL)\r
6166         {\r
6167                 return ERR_HUB_NOT_FOUND;\r
6168         }\r
6169 \r
6170         if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)\r
6171         {\r
6172                 ReleaseHub(h);\r
6173                 return ERR_NOT_SUPPORTED;\r
6174         }\r
6175 \r
6176         Lock(h->lock_online);\r
6177         {\r
6178                 if (h->SecureNAT == NULL)\r
6179                 {\r
6180                         ret = ERR_SNAT_NOT_RUNNING;\r
6181                 }\r
6182                 else\r
6183                 {\r
6184                         NtEnumDhcpList(h->SecureNAT->Nat, t);\r
6185                 }\r
6186         }\r
6187         Unlock(h->lock_online);\r
6188 \r
6189         if (h->Type == HUB_TYPE_FARM_DYNAMIC)\r
6190         {\r
6191                 if (ret == ERR_SNAT_NOT_RUNNING)\r
6192                 {\r
6193                         // リモートの DHCP の状態取得\r
6194                         LockList(s->FarmMemberList);\r
6195                         {\r
6196                                 for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
6197                                 {\r
6198                                         FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
6199                                         if (f->Me == false)\r
6200                                         {\r
6201                                                 RPC_ENUM_DHCP tmp;\r
6202 \r
6203                                                 Zero(&tmp, sizeof(tmp));\r
6204 \r
6205                                                 SiCallEnumDhcp(s, f, hubname, &tmp);\r
6206 \r
6207                                                 if (tmp.NumItem >= 1)\r
6208                                                 {\r
6209                                                         FreeRpcEnumDhcp(t);\r
6210                                                         Copy(t, &tmp, sizeof(RPC_ENUM_DHCP));\r
6211                                                         ret = ERR_NO_ERROR;\r
6212                                                         break;\r
6213                                                 }\r
6214                                                 else\r
6215                                                 {\r
6216                                                         FreeRpcEnumDhcp(&tmp);\r
6217                                                 }\r
6218                                         }\r
6219                                 }\r
6220                         }\r
6221                         UnlockList(s->FarmMemberList);\r
6222                 }\r
6223         }\r
6224 \r
6225         ReleaseHub(h);\r
6226 \r
6227         ret = ERR_NO_ERROR;\r
6228 \r
6229         return ret;\r
6230 }\r
6231 \r
6232 // SecureNATOption を設定する\r
6233 UINT StSetSecureNATOption(ADMIN *a, VH_OPTION *t)\r
6234 {\r
6235         SERVER *s = a->Server;\r
6236         CEDAR *c = s->Cedar;\r
6237         HUB *h;\r
6238 \r
6239         if (IsZero(t->MacAddress, sizeof(t->MacAddress)) ||\r
6240                 IsHostIPAddress4(&t->Ip) == false ||\r
6241                 IsSubnetMask4(&t->Mask) == false)\r
6242         {\r
6243                 return ERR_INVALID_PARAMETER;\r
6244         }\r
6245         if ((IPToUINT(&t->Ip) & (~(IPToUINT(&t->Mask)))) == 0)\r
6246         {\r
6247                 return ERR_INVALID_PARAMETER;\r
6248         }\r
6249 \r
6250         CHECK_RIGHT;\r
6251 \r
6252         LockHubList(c);\r
6253         {\r
6254                 h = GetHub(c, t->HubName);\r
6255         }\r
6256         UnlockHubList(c);\r
6257 \r
6258         if (h == NULL)\r
6259         {\r
6260                 return ERR_HUB_NOT_FOUND;\r
6261         }\r
6262 \r
6263         if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)\r
6264         {\r
6265                 ReleaseHub(h);\r
6266                 return ERR_NOT_SUPPORTED;\r
6267         }\r
6268         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6269         {\r
6270                 ReleaseHub(h);\r
6271                 return ERR_NOT_FARM_CONTROLLER;\r
6272         }\r
6273 \r
6274         if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat") != 0)\r
6275         {\r
6276                 ReleaseHub(h);\r
6277                 return ERR_NOT_ENOUGH_RIGHT;\r
6278         }\r
6279 \r
6280         if (h->SecureNATOption->UseNat == false && t->UseNat)\r
6281         {\r
6282                 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat_enablenat") != 0)\r
6283                 {\r
6284                         ReleaseHub(h);\r
6285                         return ERR_NOT_ENOUGH_RIGHT;\r
6286                 }\r
6287         }\r
6288 \r
6289         if (h->SecureNATOption->UseDhcp == false && t->UseDhcp)\r
6290         {\r
6291                 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_securenat_enabledhcp") != 0)\r
6292                 {\r
6293                         ReleaseHub(h);\r
6294                         return ERR_NOT_ENOUGH_RIGHT;\r
6295                 }\r
6296         }\r
6297 \r
6298         Copy(h->SecureNATOption, t, sizeof(VH_OPTION));\r
6299 \r
6300         if (h->Type != HUB_TYPE_STANDALONE && h->Cedar != NULL && h->Cedar->Server != NULL &&\r
6301                 h->Cedar->Server->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
6302         {\r
6303                 NiClearUnsupportedVhOptionForDynamicHub(h->SecureNATOption, false);\r
6304         }\r
6305 \r
6306         Lock(h->lock_online);\r
6307         {\r
6308                 if (h->SecureNAT != NULL)\r
6309                 {\r
6310                         SetVirtualHostOption(h->SecureNAT->Nat->Virtual, t);\r
6311                 }\r
6312         }\r
6313         Unlock(h->lock_online);\r
6314 \r
6315         ALog(a, h, "LA_SET_SNAT_OPTION");\r
6316 \r
6317         h->CurrentVersion++;\r
6318         SiHubUpdateProc(h);\r
6319 \r
6320         IncrementServerConfigRevision(s);\r
6321 \r
6322         ReleaseHub(h);\r
6323 \r
6324         return ERR_NO_ERROR;\r
6325 }\r
6326 \r
6327 // SecureNATOption を取得する\r
6328 UINT StGetSecureNATOption(ADMIN *a, VH_OPTION *t)\r
6329 {\r
6330         SERVER *s = a->Server;\r
6331         CEDAR *c = s->Cedar;\r
6332         HUB *h;\r
6333         char hubname[MAX_HUBNAME_LEN + 1];\r
6334 \r
6335         StrCpy(hubname, sizeof(hubname), t->HubName);\r
6336 \r
6337         CHECK_RIGHT;\r
6338 \r
6339         LockHubList(c);\r
6340         {\r
6341                 h = GetHub(c, t->HubName);\r
6342         }\r
6343         UnlockHubList(c);\r
6344 \r
6345         if (h == NULL)\r
6346         {\r
6347                 return ERR_HUB_NOT_FOUND;\r
6348         }\r
6349 \r
6350         if (h->Type == HUB_TYPE_FARM_STATIC || GetServerCapsBool(s, "b_support_securenat") == false)\r
6351         {\r
6352                 ReleaseHub(h);\r
6353                 return ERR_NOT_SUPPORTED;\r
6354         }\r
6355         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6356         {\r
6357                 ReleaseHub(h);\r
6358                 return ERR_NOT_FARM_CONTROLLER;\r
6359         }\r
6360 \r
6361         Zero(t, sizeof(VH_OPTION));\r
6362         StrCpy(t->HubName, sizeof(t->HubName), hubname);\r
6363         Copy(t, h->SecureNATOption, sizeof(VH_OPTION));\r
6364 \r
6365         ReleaseHub(h);\r
6366 \r
6367         return ERR_NO_ERROR;\r
6368 }\r
6369 \r
6370 // HUB をオンラインまたはオフラインにする\r
6371 UINT StSetHubOnline(ADMIN *a, RPC_SET_HUB_ONLINE *t)\r
6372 {\r
6373         SERVER *s = a->Server;\r
6374         CEDAR *c = s->Cedar;\r
6375         HUB *h;\r
6376 \r
6377         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6378         {\r
6379                 return ERR_NOT_FARM_CONTROLLER;\r
6380         }\r
6381 \r
6382         NO_SUPPORT_FOR_BRIDGE;\r
6383 \r
6384         CHECK_RIGHT;\r
6385 \r
6386         LockHubList(c);\r
6387         {\r
6388                 h = GetHub(c, t->HubName);\r
6389         }\r
6390         UnlockHubList(c);\r
6391 \r
6392         if (h == NULL)\r
6393         {\r
6394                 return ERR_HUB_NOT_FOUND;\r
6395         }\r
6396 \r
6397         if (a->ServerAdmin == false && t->Online && GetHubAdminOption(h, "no_online") != 0)\r
6398         {\r
6399                 ReleaseHub(h);\r
6400                 return ERR_NOT_ENOUGH_RIGHT;\r
6401         }\r
6402 \r
6403         if (a->ServerAdmin == false && t->Online == false && GetHubAdminOption(h, "no_offline") != 0)\r
6404         {\r
6405                 ReleaseHub(h);\r
6406                 return ERR_NOT_ENOUGH_RIGHT;\r
6407         }\r
6408 \r
6409         if (t->Online)\r
6410         {\r
6411                 ALog(a, h, "LA_SET_HUB_ONLINE");\r
6412                 SetHubOnline(h);\r
6413         }\r
6414         else\r
6415         {\r
6416                 ALog(a, h, "LA_SET_HUB_OFFLINE");\r
6417                 SetHubOffline(h);\r
6418         }\r
6419 \r
6420         h->CurrentVersion++;\r
6421         SiHubUpdateProc(h);\r
6422 \r
6423         IncrementServerConfigRevision(s);\r
6424 \r
6425         ReleaseHub(h);\r
6426 \r
6427         return ERR_NO_ERROR;\r
6428 }\r
6429 \r
6430 // コネクション情報の取得\r
6431 UINT StGetConnectionInfo(ADMIN *a, RPC_CONNECTION_INFO *t)\r
6432 {\r
6433         SERVER *s = a->Server;\r
6434         CEDAR *c = s->Cedar;\r
6435         CONNECTION *connection;\r
6436         char name[MAX_CONNECTION_NAME_LEN + 1];\r
6437 \r
6438         if (IsEmptyStr(t->Name))\r
6439         {\r
6440                 return ERR_INVALID_PARAMETER;\r
6441         }\r
6442 \r
6443         SERVER_ADMIN_ONLY;\r
6444 \r
6445         LockList(c->ConnectionList);\r
6446         {\r
6447                 CONNECTION tt;\r
6448                 Zero(&tt, sizeof(tt));\r
6449                 tt.Name = t->Name;\r
6450                 StrCpy(name, sizeof(name), t->Name);\r
6451 \r
6452                 connection = Search(c->ConnectionList, &tt);\r
6453 \r
6454                 if (connection != NULL)\r
6455                 {\r
6456                         AddRef(connection->ref);\r
6457                 }\r
6458         }\r
6459         UnlockList(c->ConnectionList);\r
6460 \r
6461         if (connection == NULL)\r
6462         {\r
6463                 return ERR_OBJECT_NOT_FOUND;\r
6464         }\r
6465 \r
6466         Zero(t, sizeof(RPC_CONNECTION_INFO));\r
6467         StrCpy(t->Name, sizeof(t->Name), name);\r
6468 \r
6469         Lock(connection->lock);\r
6470         {\r
6471                 SOCK *s = connection->FirstSock;\r
6472 \r
6473                 if (s != NULL)\r
6474                 {\r
6475                         t->Ip = IPToUINT(&s->RemoteIP);\r
6476                         t->Port = s->RemotePort;\r
6477                         StrCpy(t->Hostname, sizeof(t->Hostname), s->RemoteHostname);\r
6478                 }\r
6479 \r
6480                 StrCpy(t->Name, sizeof(t->Name), connection->Name);\r
6481                 t->ConnectedTime = TickToTime(connection->ConnectedTick);\r
6482                 t->Type = connection->Type;\r
6483 \r
6484                 StrCpy(t->ServerStr, sizeof(t->ServerStr), connection->ServerStr);\r
6485                 StrCpy(t->ClientStr, sizeof(t->ClientStr), connection->ClientStr);\r
6486                 t->ServerVer = connection->ServerVer;\r
6487                 t->ServerBuild = connection->ServerBuild;\r
6488                 t->ClientVer = connection->ClientVer;\r
6489                 t->ClientBuild = connection->ClientBuild;\r
6490         }\r
6491         Unlock(connection->lock);\r
6492 \r
6493         ReleaseConnection(connection);\r
6494 \r
6495         return ERR_NO_ERROR;\r
6496 }\r
6497 \r
6498 // コネクションの切断\r
6499 UINT StDisconnectConnection(ADMIN *a, RPC_DISCONNECT_CONNECTION *t)\r
6500 {\r
6501         SERVER *s = a->Server;\r
6502         CEDAR *c = s->Cedar;\r
6503         CONNECTION *connection;\r
6504 \r
6505         if (IsEmptyStr(t->Name))\r
6506         {\r
6507                 return ERR_INVALID_PARAMETER;\r
6508         }\r
6509 \r
6510         SERVER_ADMIN_ONLY;\r
6511 \r
6512         LockList(c->ConnectionList);\r
6513         {\r
6514                 CONNECTION tt;\r
6515                 Zero(&tt, sizeof(tt));\r
6516                 tt.Name = t->Name;\r
6517 \r
6518                 connection = Search(c->ConnectionList, &tt);\r
6519                 if (connection != NULL)\r
6520                 {\r
6521                         AddRef(connection->ref);\r
6522                 }\r
6523         }\r
6524         UnlockList(c->ConnectionList);\r
6525 \r
6526         if (connection == NULL)\r
6527         {\r
6528                 return ERR_OBJECT_NOT_FOUND;\r
6529         }\r
6530 \r
6531         StopConnection(connection, true);\r
6532 \r
6533         ReleaseConnection(connection);\r
6534 \r
6535         ALog(a, NULL, "LA_DISCONNECT_CONN", t->Name);\r
6536 \r
6537         return ERR_NO_ERROR;\r
6538 }\r
6539 \r
6540 // コネクションの列挙\r
6541 UINT StEnumConnection(ADMIN *a, RPC_ENUM_CONNECTION *t)\r
6542 {\r
6543         SERVER *s = a->Server;\r
6544         CEDAR *c = s->Cedar;\r
6545 \r
6546         SERVER_ADMIN_ONLY;\r
6547 \r
6548         FreeRpcEnumConnetion(t);\r
6549         Zero(t, sizeof(RPC_ENUM_CONNECTION));\r
6550 \r
6551         LockList(c->ConnectionList);\r
6552         {\r
6553                 UINT i;\r
6554                 t->NumConnection = LIST_NUM(c->ConnectionList);\r
6555                 t->Connections = ZeroMalloc(sizeof(RPC_ENUM_CONNECTION_ITEM) * t->NumConnection);\r
6556                 \r
6557                 for (i = 0;i < t->NumConnection;i++)\r
6558                 {\r
6559                         RPC_ENUM_CONNECTION_ITEM *e = &t->Connections[i];\r
6560                         CONNECTION *connection = LIST_DATA(c->ConnectionList, i);\r
6561 \r
6562                         Lock(connection->lock);\r
6563                         {\r
6564                                 SOCK *s = connection->FirstSock;\r
6565 \r
6566                                 if (s != NULL)\r
6567                                 {\r
6568                                         e->Ip = IPToUINT(&s->RemoteIP);\r
6569                                         e->Port = s->RemotePort;\r
6570                                         StrCpy(e->Hostname, sizeof(e->Hostname), s->RemoteHostname);\r
6571                                 }\r
6572 \r
6573                                 StrCpy(e->Name, sizeof(e->Name), connection->Name);\r
6574                                 e->ConnectedTime = TickToTime(connection->ConnectedTick);\r
6575                                 e->Type = connection->Type;\r
6576                         }\r
6577                         Unlock(connection->lock);\r
6578                 }\r
6579         }\r
6580         UnlockList(c->ConnectionList);\r
6581 \r
6582         return ERR_NO_ERROR;\r
6583 }\r
6584 \r
6585 // HUB の Radius オプションの設定\r
6586 UINT StSetHubRadius(ADMIN *a, RPC_RADIUS *t)\r
6587 {\r
6588         SERVER *s = a->Server;\r
6589         CEDAR *c = s->Cedar;\r
6590         HUB *h = NULL;\r
6591 \r
6592         NO_SUPPORT_FOR_BRIDGE;\r
6593 \r
6594         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6595         {\r
6596                 return ERR_NOT_SUPPORTED;\r
6597         }\r
6598 \r
6599         CHECK_RIGHT;\r
6600 \r
6601         LockHubList(c);\r
6602         {\r
6603                 h = GetHub(c, t->HubName);\r
6604         }\r
6605         UnlockHubList(c);\r
6606 \r
6607         if (h == NULL)\r
6608         {\r
6609                 return ERR_HUB_NOT_FOUND;\r
6610         }\r
6611 \r
6612         SetRadiusServerEx(h, t->RadiusServerName, t->RadiusPort, t->RadiusSecret, t->RadiusRetryInterval);\r
6613 \r
6614         ALog(a, h, "LA_SET_HUB_RADIUS");\r
6615 \r
6616         ReleaseHub(h);\r
6617 \r
6618         IncrementServerConfigRevision(s);\r
6619 \r
6620         return ERR_NO_ERROR;\r
6621 }\r
6622 \r
6623 // HUB の Radius オプションの取得\r
6624 UINT StGetHubRadius(ADMIN *a, RPC_RADIUS *t)\r
6625 {\r
6626         SERVER *s = a->Server;\r
6627         CEDAR *c = s->Cedar;\r
6628         HUB *h = NULL;\r
6629 \r
6630         CHECK_RIGHT;\r
6631 \r
6632         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6633         {\r
6634                 return ERR_NOT_SUPPORTED;\r
6635         }\r
6636 \r
6637         LockHubList(c);\r
6638         {\r
6639                 h = GetHub(c, t->HubName);\r
6640         }\r
6641         UnlockHubList(c);\r
6642 \r
6643         if (h == NULL)\r
6644         {\r
6645                 return ERR_HUB_NOT_FOUND;\r
6646         }\r
6647 \r
6648         Zero(t, sizeof(t));\r
6649         GetRadiusServerEx(h, t->RadiusServerName, sizeof(t->RadiusServerName),\r
6650                 &t->RadiusPort, t->RadiusSecret, sizeof(t->RadiusSecret), &t->RadiusRetryInterval);\r
6651 \r
6652         ReleaseHub(h);\r
6653 \r
6654         return ERR_NO_ERROR;\r
6655 }\r
6656 \r
6657 // HUB の削除\r
6658 UINT StDeleteHub(ADMIN *a, RPC_DELETE_HUB *t)\r
6659 {\r
6660         SERVER *s = a->Server;\r
6661         CEDAR *c = s->Cedar;\r
6662         HUB *h = NULL;\r
6663 \r
6664         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6665         {\r
6666                 return ERR_NOT_FARM_CONTROLLER;\r
6667         }\r
6668 \r
6669         if (IsEmptyStr(t->HubName) || IsSafeStr(t->HubName) == false)\r
6670         {\r
6671                 return ERR_INVALID_PARAMETER;\r
6672         }\r
6673 \r
6674         NO_SUPPORT_FOR_BRIDGE;\r
6675 \r
6676         SERVER_ADMIN_ONLY;\r
6677 \r
6678         LockHubList(c);\r
6679         {\r
6680                 h = GetHub(c, t->HubName);\r
6681         }\r
6682         UnlockHubList(c);\r
6683 \r
6684         if (h == NULL)\r
6685         {\r
6686                 return ERR_HUB_NOT_FOUND;\r
6687         }\r
6688 \r
6689         StopHub(h);\r
6690 \r
6691         IncrementServerConfigRevision(s);\r
6692 \r
6693         DelHub(c, h);\r
6694         ReleaseHub(h);\r
6695 \r
6696         ALog(a, NULL, "LA_DELETE_HUB", t->HubName);\r
6697 \r
6698         return ERR_NO_ERROR;\r
6699 }\r
6700 \r
6701 // HUB の列挙\r
6702 UINT StEnumHub(ADMIN *a, RPC_ENUM_HUB *t)\r
6703 {\r
6704         SERVER *s = a->Server;\r
6705         CEDAR *c = s->Cedar;\r
6706         HUB *h = NULL;\r
6707 \r
6708         FreeRpcEnumHub(t);\r
6709 \r
6710         Zero(t, sizeof(RPC_ENUM_HUB));\r
6711 \r
6712         LockHubList(c);\r
6713         {\r
6714                 UINT i, num, j;\r
6715 \r
6716                 num = 0;\r
6717 \r
6718                 for (i = 0;i < LIST_NUM(c->HubList);i++)\r
6719                 {\r
6720                         HUB *h = LIST_DATA(c->HubList, i);\r
6721 \r
6722                         Lock(h->lock);\r
6723 \r
6724                         if (a->ServerAdmin == false &&\r
6725                                 h->Option != NULL &&\r
6726                                 StrCmpi(h->Name, a->HubName) != 0)\r
6727                         {\r
6728                                 // 列挙を許可しない\r
6729                         }\r
6730                         else\r
6731                         {\r
6732                                 // 列挙を許可する\r
6733                                 num++;\r
6734                         }\r
6735                 }\r
6736 \r
6737                 t->NumHub = num;\r
6738 \r
6739                 t->Hubs = ZeroMalloc(sizeof(RPC_ENUM_HUB_ITEM) * num);\r
6740 \r
6741                 i = 0;\r
6742                 for (j = 0;j < LIST_NUM(c->HubList);j++)\r
6743                 {\r
6744                         HUB *h = LIST_DATA(c->HubList, j);\r
6745 \r
6746                         if (a->ServerAdmin == false &&\r
6747                                 h->Option != NULL &&\r
6748                                 StrCmpi(h->Name, a->HubName) != 0)\r
6749                         {\r
6750                                 // 列挙許可しない\r
6751                         }\r
6752                         else\r
6753                         {\r
6754                                 // 列挙許可\r
6755                                 RPC_ENUM_HUB_ITEM *e = &t->Hubs[i++];\r
6756 \r
6757                                 StrCpy(e->HubName, sizeof(e->HubName), h->Name);\r
6758                                 e->Online = h->Offline ? false : true;\r
6759                                 e->HubType = h->Type;\r
6760 \r
6761                                 e->NumSessions = LIST_NUM(h->SessionList);\r
6762 \r
6763                                 LockList(h->MacTable);\r
6764                                 {\r
6765                                         e->NumMacTables = LIST_NUM(h->MacTable);\r
6766                                 }\r
6767                                 UnlockList(h->MacTable);\r
6768 \r
6769                                 LockList(h->IpTable);\r
6770                                 {\r
6771                                         e->NumIpTables = LIST_NUM(h->IpTable);\r
6772                                 }\r
6773                                 UnlockList(h->IpTable);\r
6774 \r
6775                                 if (h->HubDb != NULL)\r
6776                                 {\r
6777                                         LockList(h->HubDb->UserList);\r
6778                                         {\r
6779                                                 e->NumUsers = LIST_NUM(h->HubDb->UserList);\r
6780                                         }\r
6781                                         UnlockList(h->HubDb->UserList);\r
6782 \r
6783                                         LockList(h->HubDb->GroupList);\r
6784                                         {\r
6785                                                 e->NumGroups = LIST_NUM(h->HubDb->GroupList);\r
6786                                         }\r
6787                                         UnlockList(h->HubDb->GroupList);\r
6788                                 }\r
6789 \r
6790                                 e->LastCommTime = h->LastCommTime;\r
6791                                 e->LastLoginTime = h->LastLoginTime;\r
6792                                 e->NumLogin = h->NumLogin;\r
6793                                 e->CreatedTime = h->CreatedTime;\r
6794                         }\r
6795 \r
6796                         Unlock(h->lock);\r
6797                 }\r
6798         }\r
6799         UnlockHubList(c);\r
6800 \r
6801         if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
6802         {\r
6803                 UINT i, j, k;\r
6804                 LockList(s->FarmMemberList);\r
6805                 {\r
6806                         for (i = 0;i < LIST_NUM(s->FarmMemberList);i++)\r
6807                         {\r
6808                                 FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
6809 \r
6810                                 LockList(f->HubList);\r
6811                                 {\r
6812                                         if (f->Me == false)\r
6813                                         {\r
6814                                                 for (j = 0;j < LIST_NUM(f->HubList);j++)\r
6815                                                 {\r
6816                                                         HUB_LIST *o = LIST_DATA(f->HubList, j);\r
6817 \r
6818                                                         for (k = 0;k < t->NumHub;k++)\r
6819                                                         {\r
6820                                                                 RPC_ENUM_HUB_ITEM *e = &t->Hubs[k];\r
6821 \r
6822                                                                 if (StrCmpi(e->HubName, o->Name) == 0)\r
6823                                                                 {\r
6824                                                                         e->NumIpTables += o->NumIpTables;\r
6825                                                                         e->NumMacTables += o->NumMacTables;\r
6826                                                                         e->NumSessions += o->NumSessions;\r
6827                                                                 }\r
6828                                                         }\r
6829                                                 }\r
6830                                         }\r
6831                                 }\r
6832                                 UnlockList(f->HubList);\r
6833                         }\r
6834                 }\r
6835                 UnlockList(s->FarmMemberList);\r
6836         }\r
6837 \r
6838         return ERR_NO_ERROR;\r
6839 }\r
6840 \r
6841 // HUB 設定を取得する\r
6842 UINT StGetHub(ADMIN *a, RPC_CREATE_HUB *t)\r
6843 {\r
6844         SERVER *s = a->Server;\r
6845         CEDAR *c = s->Cedar;\r
6846         UINT ret = ERR_NO_ERROR;\r
6847         HUB *h;\r
6848 \r
6849         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6850         {\r
6851                 return ERR_NOT_FARM_CONTROLLER;\r
6852         }\r
6853 \r
6854         if (IsEmptyStr(t->HubName) || IsSafeStr(t->HubName) == false)\r
6855         {\r
6856                 return ERR_INVALID_PARAMETER;\r
6857         }\r
6858 \r
6859         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6860         {\r
6861                 return ERR_NOT_FARM_CONTROLLER;\r
6862         }\r
6863 \r
6864         NO_SUPPORT_FOR_BRIDGE;\r
6865         CHECK_RIGHT;\r
6866 \r
6867         LockHubList(c);\r
6868         {\r
6869                 h = GetHub(c, t->HubName);\r
6870         }\r
6871         UnlockHubList(c);\r
6872 \r
6873         Zero(t, sizeof(RPC_CREATE_HUB));\r
6874 \r
6875         if (h == NULL)\r
6876         {\r
6877                 return ERR_HUB_NOT_FOUND;\r
6878         }\r
6879 \r
6880         Lock(h->lock);\r
6881         {\r
6882                 StrCpy(t->HubName, sizeof(t->HubName), h->Name);\r
6883                 t->Online = h->Offline ? false : true;\r
6884                 t->HubOption.MaxSession = h->Option->MaxSession;\r
6885                 t->HubOption.NoEnum = h->Option->NoEnum;\r
6886                 t->HubType = h->Type;\r
6887         }\r
6888         Unlock(h->lock);\r
6889 \r
6890         ReleaseHub(h);\r
6891 \r
6892         return ret;\r
6893 }\r
6894 \r
6895 // HUB 設定を更新する\r
6896 UINT StSetHub(ADMIN *a, RPC_CREATE_HUB *t)\r
6897 {\r
6898         SERVER *s = a->Server;\r
6899         CEDAR *c = s->Cedar;\r
6900         HUB *h;\r
6901         UINT ret = ERR_NO_ERROR;\r
6902 \r
6903         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6904         {\r
6905                 return ERR_NOT_FARM_CONTROLLER;\r
6906         }\r
6907 \r
6908         if (IsEmptyStr(t->HubName) || IsSafeStr(t->HubName) == false)\r
6909         {\r
6910                 return ERR_INVALID_PARAMETER;\r
6911         }\r
6912 \r
6913         CHECK_RIGHT;\r
6914         NO_SUPPORT_FOR_BRIDGE;\r
6915 \r
6916         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
6917         {\r
6918                 return ERR_NOT_FARM_CONTROLLER;\r
6919         }\r
6920 \r
6921         if (s->ServerType == SERVER_TYPE_STANDALONE)\r
6922         {\r
6923                 if (t->HubType != HUB_TYPE_STANDALONE)\r
6924                 {\r
6925                         return ERR_INVALID_PARAMETER;\r
6926                 }\r
6927         }\r
6928 \r
6929         if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
6930         {\r
6931                 if (t->HubType == HUB_TYPE_STANDALONE)\r
6932                 {\r
6933                         return ERR_INVALID_PARAMETER;\r
6934                 }\r
6935         }\r
6936 \r
6937         LockHubList(c);\r
6938         {\r
6939                 h = GetHub(c, t->HubName);\r
6940         }\r
6941         UnlockHubList(c);\r
6942 \r
6943         if (h == NULL)\r
6944         {\r
6945                 return ERR_HUB_NOT_FOUND;\r
6946         }\r
6947 \r
6948         if (h->Type != t->HubType)\r
6949         {\r
6950                 ReleaseHub(h);\r
6951                 return ERR_NOT_SUPPORTED;\r
6952         }\r
6953 \r
6954         if (IsZero(t->HashedPassword, sizeof(t->HashedPassword)) == false &&\r
6955                 IsZero(t->SecurePassword, sizeof(t->SecurePassword)) == false)\r
6956         {\r
6957                 if (a->ServerAdmin == false && GetHubAdminOption(h, "no_change_admin_password") != 0)\r
6958                 {\r
6959                         ReleaseHub(h);\r
6960                         return ERR_NOT_ENOUGH_RIGHT;\r
6961                 }\r
6962         }\r
6963 \r
6964         // 設定しようとしているパスワードが空白かどうか調べる\r
6965         {\r
6966                 UCHAR hash1[SHA1_SIZE], hash2[SHA1_SIZE];\r
6967                 HashPassword(hash1, ADMINISTRATOR_USERNAME, "");\r
6968                 Hash(hash2, "", 0, true);\r
6969 \r
6970                 if (Cmp(t->HashedPassword, hash2, SHA1_SIZE) == 0 || Cmp(t->SecurePassword, hash1, SHA1_SIZE) == 0)\r
6971                 {\r
6972                         if (a->ServerAdmin == false && a->Rpc->Sock->RemoteIP.addr[0] != 127)\r
6973                         {\r
6974                                 // ローカル以外から仮想 NUB 管理者モードで接続中に\r
6975                                 // 仮想 HUB のパスワードを空白に設定しようとすると拒否する\r
6976                                 ReleaseHub(h);\r
6977                                 return ERR_INVALID_PARAMETER;\r
6978                         }\r
6979                 }\r
6980         }\r
6981 \r
6982         Lock(h->lock);\r
6983         {\r
6984                 if (a->ServerAdmin == false && h->Type != t->HubType)\r
6985                 {\r
6986                         ret = ERR_NOT_ENOUGH_RIGHT;\r
6987                 }\r
6988                 else\r
6989                 {\r
6990                         h->Type = t->HubType;\r
6991                         h->Option->MaxSession = t->HubOption.MaxSession;\r
6992                         h->Option->NoEnum = t->HubOption.NoEnum;\r
6993                         if (IsZero(t->HashedPassword, sizeof(t->HashedPassword)) == false &&\r
6994                                 IsZero(t->SecurePassword, sizeof(t->SecurePassword)) == false)\r
6995                         {\r
6996                                 Copy(h->HashedPassword, t->HashedPassword, SHA1_SIZE);\r
6997                                 Copy(h->SecurePassword, t->SecurePassword, SHA1_SIZE);\r
6998                         }\r
6999                 }\r
7000         }\r
7001         Unlock(h->lock);\r
7002 \r
7003         if (t->Online)\r
7004         {\r
7005                 if (a->ServerAdmin || GetHubAdminOption(h, "no_online") == 0)\r
7006                 {\r
7007                         SetHubOnline(h);\r
7008                 }\r
7009         }\r
7010         else\r
7011         {\r
7012                 if (a->ServerAdmin || GetHubAdminOption(h, "no_offline") == 0)\r
7013                 {\r
7014                         SetHubOffline(h);\r
7015                 }\r
7016         }\r
7017 \r
7018         if (h->Type == HUB_TYPE_FARM_STATIC)\r
7019         {\r
7020                 EnableSecureNAT(h, false);\r
7021         }\r
7022 \r
7023         h->CurrentVersion++;\r
7024         SiHubUpdateProc(h);\r
7025 \r
7026         IncrementServerConfigRevision(s);\r
7027 \r
7028         ALog(a, h, "LA_SET_HUB");\r
7029 \r
7030         ReleaseHub(h);\r
7031 \r
7032         return ret;\r
7033 }\r
7034 \r
7035 // HUB を作成する\r
7036 UINT StCreateHub(ADMIN *a, RPC_CREATE_HUB *t)\r
7037 {\r
7038         SERVER *s = a->Server;\r
7039         CEDAR *c = s->Cedar;\r
7040         HUB *h;\r
7041         HUB_OPTION o;\r
7042         UINT current_hub_num;\r
7043         bool b;\r
7044 \r
7045         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
7046         {\r
7047                 return ERR_NOT_FARM_CONTROLLER;\r
7048         }\r
7049 \r
7050         if (IsEmptyStr(t->HubName) || IsSafeStr(t->HubName) == false)\r
7051         {\r
7052                 return ERR_INVALID_PARAMETER;\r
7053         }\r
7054 \r
7055         NO_SUPPORT_FOR_BRIDGE;\r
7056 \r
7057         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
7058         {\r
7059                 return ERR_NOT_FARM_CONTROLLER;\r
7060         }\r
7061 \r
7062         SERVER_ADMIN_ONLY;\r
7063 \r
7064         Trim(t->HubName);\r
7065         if (StrLen(t->HubName) == 0)\r
7066         {\r
7067                 return ERR_INVALID_PARAMETER;\r
7068         }\r
7069         if (StartWith(t->HubName, ".") || EndWith(t->HubName, "."))\r
7070         {\r
7071                 return ERR_INVALID_PARAMETER;\r
7072         }\r
7073 \r
7074         if (s->ServerType == SERVER_TYPE_FARM_MEMBER)\r
7075         {\r
7076                 return ERR_NOT_FARM_CONTROLLER;\r
7077         }\r
7078 \r
7079         if (s->ServerType == SERVER_TYPE_STANDALONE)\r
7080         {\r
7081                 if (t->HubType != HUB_TYPE_STANDALONE)\r
7082                 {\r
7083                         return ERR_INVALID_PARAMETER;\r
7084                 }\r
7085         }\r
7086         else if (t->HubType != HUB_TYPE_FARM_DYNAMIC && t->HubType != HUB_TYPE_FARM_STATIC)\r
7087         {\r
7088                 return ERR_INVALID_PARAMETER;\r
7089         }\r
7090 \r
7091         // HUB の作成\r
7092         Zero(&o, sizeof(o));\r
7093         o.MaxSession = t->HubOption.MaxSession;\r
7094         o.NoEnum = t->HubOption.NoEnum;\r
7095         o.ManageOnlyPrivateIP = true;\r
7096         o.ManageOnlyLocalUnicastIPv6 = true;\r
7097         o.NoMacAddressLog = true;\r
7098         o.NoIPv6DefaultRouterInRAWhenIPv6 = true;\r
7099 \r
7100         LockList(c->HubList);\r
7101         {\r
7102                 current_hub_num = LIST_NUM(c->HubList);\r
7103         }\r
7104         UnlockList(c->HubList);\r
7105 \r
7106         if (current_hub_num > GetServerCapsInt(a->Server, "i_max_hubs"))\r
7107         {\r
7108                 return ERR_TOO_MANY_HUBS;\r
7109         }\r
7110 \r
7111         LockList(c->HubList);\r
7112         {\r
7113                 b = IsHub(c, t->HubName);\r
7114         }\r
7115         UnlockList(c->HubList);\r
7116 \r
7117         if (b)\r
7118         {\r
7119                 return ERR_HUB_ALREADY_EXISTS;\r
7120         }\r
7121 \r
7122         ALog(a, NULL, "LA_CREATE_HUB", t->HubName);\r
7123 \r
7124         h = NewHub(c, t->HubName, &o);\r
7125         Copy(h->HashedPassword, t->HashedPassword, SHA1_SIZE);\r
7126         Copy(h->SecurePassword, t->SecurePassword, SHA1_SIZE);\r
7127 \r
7128         h->Type = t->HubType;\r
7129 \r
7130         AddHub(c, h);\r
7131 \r
7132         if (t->Online)\r
7133         {\r
7134                 h->Offline = true;\r
7135                 SetHubOnline(h);\r
7136         }\r
7137         else\r
7138         {\r
7139                 h->Offline = false;\r
7140                 SetHubOffline(h);\r
7141         }\r
7142 \r
7143         h->CreatedTime = SystemTime64();\r
7144 \r
7145         ReleaseHub(h);\r
7146 \r
7147         IncrementServerConfigRevision(s);\r
7148 \r
7149         return ERR_NO_ERROR;\r
7150 }\r
7151 \r
7152 // 暗号化アルゴリズムを設定する\r
7153 UINT StSetServerCipher(ADMIN *a, RPC_STR *t)\r
7154 {\r
7155         SERVER *s = a->Server;\r
7156         CEDAR *c = s->Cedar;\r
7157 \r
7158         if (IsEmptyStr(t->String))\r
7159         {\r
7160                 return ERR_INVALID_PARAMETER;\r
7161         }\r
7162 \r
7163         SERVER_ADMIN_ONLY;\r
7164 \r
7165         StrUpper(t->String);\r
7166 \r
7167         if (CheckCipherListName(t->String) == false)\r
7168         {\r
7169                 return ERR_CIPHER_NOT_SUPPORTED;\r
7170         }\r
7171         else\r
7172         {\r
7173                 ALog(a, NULL, "LA_SET_SERVER_CIPHER", t->String);\r
7174         }\r
7175 \r
7176         Lock(c->lock);\r
7177         {\r
7178                 SetCedarCipherList(c, t->String);\r
7179         }\r
7180         Unlock(c->lock);\r
7181 \r
7182         IncrementServerConfigRevision(s);\r
7183 \r
7184         return ERR_NO_ERROR;\r
7185 }\r
7186 \r
7187 // 暗号化アルゴリズムを取得する\r
7188 UINT StGetServerCipher(ADMIN *a, RPC_STR *t)\r
7189 {\r
7190         SERVER *s = a->Server;\r
7191         CEDAR *c = s->Cedar;\r
7192 \r
7193         FreeRpcStr(t);\r
7194         Zero(t, sizeof(RPC_STR));\r
7195 \r
7196         Lock(c->lock);\r
7197         {\r
7198                 t->String = CopyStr(c->CipherList);\r
7199         }\r
7200         Unlock(c->lock);\r
7201 \r
7202         return ERR_NO_ERROR;\r
7203 }\r
7204 \r
7205 // サーバー証明書を取得する\r
7206 UINT StGetServerCert(ADMIN *a, RPC_KEY_PAIR *t)\r
7207 {\r
7208         bool admin;\r
7209         SERVER *s = a->Server;\r
7210         CEDAR *c = s->Cedar;\r
7211 \r
7212         admin = a->ServerAdmin;\r
7213 \r
7214         FreeRpcKeyPair(t);\r
7215         Zero(t, sizeof(RPC_KEY_PAIR));\r
7216 \r
7217         Lock(c->lock);\r
7218         {\r
7219                 t->Cert = CloneX(c->ServerX);\r
7220                 if (admin)\r
7221                 {\r
7222                         t->Key = CloneK(c->ServerK);\r
7223                 }\r
7224         }\r
7225         Unlock(c->lock);\r
7226 \r
7227         return ERR_NO_ERROR;\r
7228 }\r
7229 \r
7230 // サーバー証明書を設定する\r
7231 UINT StSetServerCert(ADMIN *a, RPC_KEY_PAIR *t)\r
7232 {\r
7233         SERVER *s = a->Server;\r
7234         CEDAR *c = s->Cedar;\r
7235 \r
7236         SERVER_ADMIN_ONLY;\r
7237 \r
7238         if (t->Cert == NULL || t->Key == NULL)\r
7239         {\r
7240                 return ERR_PROTOCOL_ERROR;\r
7241         }\r
7242 \r
7243         if (t->Cert->is_compatible_bit == false)\r
7244         {\r
7245                 return ERR_NOT_RSA_1024;\r
7246         }\r
7247 \r
7248         if (CheckXandK(t->Cert, t->Key) == false)\r
7249         {\r
7250                 return ERR_PROTOCOL_ERROR;\r
7251         }\r
7252 \r
7253         SetCedarCert(c, t->Cert, t->Key);\r
7254 \r
7255         ALog(a, NULL, "LA_SET_SERVER_CERT");\r
7256 \r
7257         IncrementServerConfigRevision(s);\r
7258 \r
7259         return ERR_NO_ERROR;\r
7260 }\r
7261 \r
7262 // サーバーファームコントローラへの接続状態を取得する\r
7263 UINT StGetFarmConnectionStatus(ADMIN *a, RPC_FARM_CONNECTION_STATUS *t)\r
7264 {\r
7265         SERVER *s = a->Server;\r
7266         CEDAR *c = s->Cedar;\r
7267         FARM_CONTROLLER *fc;\r
7268 \r
7269         if (s->ServerType != SERVER_TYPE_FARM_MEMBER)\r
7270         {\r
7271                 return ERR_NOT_FARM_MEMBER;\r
7272         }\r
7273 \r
7274         Zero(t, sizeof(RPC_FARM_CONNECTION_STATUS));\r
7275 \r
7276         fc = s->FarmController;\r
7277 \r
7278         Lock(fc->lock);\r
7279         {\r
7280                 if (fc->Sock != NULL)\r
7281                 {\r
7282                         t->Ip = IPToUINT(&fc->Sock->RemoteIP);\r
7283                         t->Port = fc->Sock->RemotePort;\r
7284                 }\r
7285 \r
7286                 t->Online = fc->Online;\r
7287                 t->LastError = ERR_NO_ERROR;\r
7288 \r
7289                 if (t->Online == false)\r
7290                 {\r
7291                         t->LastError = fc->LastError;\r
7292                 }\r
7293                 else\r
7294                 {\r
7295                         t->CurrentConnectedTime = fc->CurrentConnectedTime;\r
7296                 }\r
7297 \r
7298                 t->StartedTime = fc->StartedTime;\r
7299                 t->FirstConnectedTime = fc->FirstConnectedTime;\r
7300 \r
7301                 t->NumConnected = fc->NumConnected;\r
7302                 t->NumTry = fc->NumTry;\r
7303                 t->NumFailed = fc->NumFailed;\r
7304         }\r
7305         Unlock(fc->lock);\r
7306 \r
7307         return ERR_NO_ERROR;\r
7308 }\r
7309 \r
7310 // サーバーファームメンバ列挙\r
7311 UINT StEnumFarmMember(ADMIN *a, RPC_ENUM_FARM *t)\r
7312 {\r
7313         SERVER *s = a->Server;\r
7314         CEDAR *c = s->Cedar;\r
7315         UINT i;\r
7316 \r
7317         FreeRpcEnumFarm(t);\r
7318         Zero(t, sizeof(RPC_ENUM_FARM));\r
7319 \r
7320         if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER)\r
7321         {\r
7322                 return ERR_NOT_FARM_CONTROLLER;\r
7323         }\r
7324 \r
7325         Zero(t, sizeof(RPC_ENUM_FARM));\r
7326 \r
7327         LockList(s->FarmMemberList);\r
7328         {\r
7329                 t->NumFarm = LIST_NUM(s->FarmMemberList);\r
7330                 t->Farms = ZeroMalloc(sizeof(RPC_ENUM_FARM_ITEM) * t->NumFarm);\r
7331 \r
7332                 for (i = 0;i < t->NumFarm;i++)\r
7333                 {\r
7334                         FARM_MEMBER *f = LIST_DATA(s->FarmMemberList, i);\r
7335                         RPC_ENUM_FARM_ITEM *e = &t->Farms[i];\r
7336 \r
7337                         e->Id = POINTER_TO_KEY(f);\r
7338                         e->Controller = f->Me;\r
7339 \r
7340                         if (e->Controller)\r
7341                         {\r
7342                                 e->ConnectedTime = TickToTime(c->CreatedTick);\r
7343                                 e->Ip = 0x0100007f;\r
7344                                 GetMachineName(e->Hostname, sizeof(e->Hostname));\r
7345                                 e->Point = f->Point;\r
7346                                 e->NumSessions = Count(c->CurrentSessions);\r
7347                                 e->NumTcpConnections = Count(c->CurrentTcpConnections);\r
7348 \r
7349                                 e->AssignedBridgeLicense = Count(c->AssignedBridgeLicense);\r
7350                                 e->AssignedClientLicense = Count(c->AssignedClientLicense);\r
7351                         }\r
7352                         else\r
7353                         {\r
7354                                 e->ConnectedTime = f->ConnectedTime;\r
7355                                 e->Ip = f->Ip;\r
7356                                 StrCpy(e->Hostname, sizeof(e->Hostname), f->hostname);\r
7357                                 e->Point = f->Point;\r
7358                                 e->NumSessions = f->NumSessions;\r
7359                                 e->NumTcpConnections = f->NumTcpConnections;\r
7360 \r
7361                                 e->AssignedBridgeLicense = f->AssignedBridgeLicense;\r
7362                                 e->AssignedClientLicense = f->AssignedClientLicense;\r
7363                         }\r
7364                         e->NumHubs = LIST_NUM(f->HubList);\r
7365                 }\r
7366         }\r
7367         UnlockList(s->FarmMemberList);\r
7368 \r
7369         return ERR_NO_ERROR;\r
7370 }\r
7371 \r
7372 // サーバーファームメンバ情報の取得\r
7373 UINT StGetFarmInfo(ADMIN *a, RPC_FARM_INFO *t)\r
7374 {\r
7375         SERVER *s = a->Server;\r
7376         UINT id = t->Id;\r
7377         UINT i;\r
7378         UINT ret = ERR_NO_ERROR;\r
7379 \r
7380         FreeRpcFarmInfo(t);\r
7381         Zero(t, sizeof(RPC_FARM_INFO));\r
7382 \r
7383         if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER)\r
7384         {\r
7385                 return ERR_NOT_FARM_CONTROLLER;\r
7386         }\r
7387 \r
7388         LockList(s->FarmMemberList);\r
7389         {\r
7390                 if (IsInListKey(s->FarmMemberList, id))\r
7391                 {\r
7392                         FARM_MEMBER *f = ListKeyToPointer(s->FarmMemberList, id);\r
7393 \r
7394                         t->Id = id;\r
7395                         t->Controller = f->Me;\r
7396                         t->Weight = f->Weight;\r
7397 \r
7398                         LockList(f->HubList);\r
7399                         {\r
7400                                 t->NumFarmHub = LIST_NUM(f->HubList);\r
7401                                 t->FarmHubs = ZeroMalloc(sizeof(RPC_FARM_HUB) * t->NumFarmHub);\r
7402 \r
7403                                 for (i = 0;i < t->NumFarmHub;i++)\r
7404                                 {\r
7405                                         RPC_FARM_HUB *h = &t->FarmHubs[i];\r
7406                                         HUB_LIST *hh = LIST_DATA(f->HubList, i);\r
7407 \r
7408                                         h->DynamicHub = hh->DynamicHub;\r
7409                                         StrCpy(h->HubName, sizeof(h->HubName), hh->Name);\r
7410                                 }\r
7411                         }\r
7412                         UnlockList(f->HubList);\r
7413 \r
7414                         if (t->Controller)\r
7415                         {\r
7416                                 t->ConnectedTime = TickToTime(s->Cedar->CreatedTick);\r
7417                                 t->Ip = 0x0100007f;\r
7418                                 GetMachineName(t->Hostname, sizeof(t->Hostname));\r
7419                                 t->Point = f->Point;\r
7420 \r
7421                                 LockList(s->ServerListenerList);\r
7422                                 {\r
7423                                         UINT i, n;\r
7424                                         t->NumPort = 0;\r
7425                                         for (i = 0;i < LIST_NUM(s->ServerListenerList);i++)\r
7426                                         {\r
7427                                                 SERVER_LISTENER *o = LIST_DATA(s->ServerListenerList, i);\r
7428                                                 if (o->Enabled)\r
7429                                                 {\r
7430                                                         t->NumPort++;\r
7431                                                 }\r
7432                                         }\r
7433                                         t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
7434                                         n = 0;\r
7435                                         for (i = 0;i < LIST_NUM(s->ServerListenerList);i++)\r
7436                                         {\r
7437                                                 SERVER_LISTENER *o = LIST_DATA(s->ServerListenerList, i);\r
7438                                                 if (o->Enabled)\r
7439                                                 {\r
7440                                                         t->Ports[n++] = o->Port;\r
7441                                                 }\r
7442                                         }\r
7443                                 }\r
7444                                 UnlockList(s->ServerListenerList);\r
7445 \r
7446                                 t->ServerCert = CloneX(s->Cedar->ServerX);\r
7447                                 t->NumSessions = Count(s->Cedar->CurrentSessions);\r
7448                                 t->NumTcpConnections = Count(s->Cedar->CurrentTcpConnections);\r
7449                         }\r
7450                         else\r
7451                         {\r
7452                                 t->ConnectedTime = f->ConnectedTime;\r
7453                                 t->Ip = f->Ip;\r
7454                                 StrCpy(t->Hostname, sizeof(t->Hostname), f->hostname);\r
7455                                 t->Point = f->Point;\r
7456                                 t->NumPort = f->NumPort;\r
7457                                 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
7458                                 Copy(t->Ports, f->Ports, sizeof(UINT) * t->NumPort);\r
7459                                 t->ServerCert = CloneX(f->ServerCert);\r
7460                                 t->NumSessions = f->NumSessions;\r
7461                                 t->NumTcpConnections = f->NumTcpConnections;\r
7462                         }\r
7463                 }\r
7464                 else\r
7465                 {\r
7466                         ret = ERR_OBJECT_NOT_FOUND;\r
7467                 }\r
7468         }\r
7469         UnlockList(s->FarmMemberList);\r
7470 \r
7471         return ret;\r
7472 }\r
7473 \r
7474 // サーバーファーム設定の取得\r
7475 UINT StGetFarmSetting(ADMIN *a, RPC_FARM *t)\r
7476 {\r
7477         SERVER *s;\r
7478         FreeRpcFarm(t);\r
7479         Zero(t, sizeof(RPC_FARM));\r
7480 \r
7481         s = a->Server;\r
7482         t->ServerType = s->ServerType;\r
7483         t->ControllerOnly = s->ControllerOnly;\r
7484         t->Weight = s->Weight;\r
7485 \r
7486         if (t->ServerType == SERVER_TYPE_FARM_MEMBER)\r
7487         {\r
7488                 t->NumPort = s->NumPublicPort;\r
7489                 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
7490                 Copy(t->Ports, s->PublicPorts, sizeof(UINT) * t->NumPort);\r
7491                 t->PublicIp = s->PublicIp;\r
7492                 StrCpy(t->ControllerName, sizeof(t->ControllerName), s->ControllerName);\r
7493                 t->ControllerPort = s->ControllerPort;\r
7494         }\r
7495         else\r
7496         {\r
7497                 t->NumPort = 0;\r
7498                 t->Ports = ZeroMalloc(0);\r
7499         }\r
7500 \r
7501         return ERR_NO_ERROR;\r
7502 }\r
7503 \r
7504 // サーバーファーム設定の設定\r
7505 UINT StSetFarmSetting(ADMIN *a, RPC_FARM *t)\r
7506 {\r
7507         bool cluster_allowed = false;\r
7508 \r
7509         SERVER_ADMIN_ONLY;\r
7510         NO_SUPPORT_FOR_BRIDGE;\r
7511 \r
7512         cluster_allowed = GetServerCapsInt(a->Server, "b_support_cluster");\r
7513 \r
7514         if (t->ServerType != SERVER_TYPE_STANDALONE && cluster_allowed == false)\r
7515         {\r
7516                 // クラスタとして動作が許可されていないのにクラスタ化しようとすると\r
7517                 // エラーを発生する\r
7518                 return ERR_NOT_SUPPORTED;\r
7519         }\r
7520 \r
7521         ALog(a, NULL, "LA_SET_FARM_SETTING");\r
7522 \r
7523         IncrementServerConfigRevision(a->Server);\r
7524 \r
7525         SiSetServerType(a->Server, t->ServerType, t->PublicIp, t->NumPort, t->Ports,\r
7526                 t->ControllerName, t->ControllerPort, t->MemberPassword, t->Weight, t->ControllerOnly);\r
7527 \r
7528         return ERR_NO_ERROR;\r
7529 }\r
7530 \r
7531 // パスワードの設定\r
7532 UINT StSetServerPassword(ADMIN *a, RPC_SET_PASSWORD *t)\r
7533 {\r
7534         SERVER_ADMIN_ONLY;\r
7535 \r
7536         Copy(a->Server->HashedPassword, t->HashedPassword, SHA1_SIZE);\r
7537 \r
7538         ALog(a, NULL, "LA_SET_SERVER_PASSWORD");\r
7539 \r
7540         IncrementServerConfigRevision(a->Server);\r
7541 \r
7542         return ERR_NO_ERROR;\r
7543 }\r
7544 \r
7545 // リスナーの有効化 / 無効化\r
7546 UINT StEnableListener(ADMIN *a, RPC_LISTENER *t)\r
7547 {\r
7548         UINT ret = ERR_NO_ERROR;\r
7549 \r
7550         SERVER_ADMIN_ONLY;\r
7551 \r
7552         LockList(a->Server->ServerListenerList);\r
7553         {\r
7554                 if (t->Enable)\r
7555                 {\r
7556                         if (SiEnableListener(a->Server, t->Port) == false)\r
7557                         {\r
7558                                 ret = ERR_LISTENER_NOT_FOUND;\r
7559                         }\r
7560                         else\r
7561                         {\r
7562                                 ALog(a, NULL, "LA_ENABLE_LISTENER", t->Port);\r
7563                         }\r
7564                 }\r
7565                 else\r
7566                 {\r
7567                         if (SiDisableListener(a->Server, t->Port) == false)\r
7568                         {\r
7569                                 ret = ERR_LISTENER_NOT_FOUND;\r
7570                         }\r
7571                         else\r
7572                         {\r
7573                                 ALog(a, NULL, "LA_DISABLE_LISTENER", t->Port);\r
7574                         }\r
7575                 }\r
7576         }\r
7577         UnlockList(a->Server->ServerListenerList);\r
7578 \r
7579         IncrementServerConfigRevision(a->Server);\r
7580 \r
7581         SleepThread(250);\r
7582 \r
7583         return ret;\r
7584 }\r
7585 \r
7586 // リスナーの削除\r
7587 UINT StDeleteListener(ADMIN *a, RPC_LISTENER *t)\r
7588 {\r
7589         UINT ret = ERR_NO_ERROR;\r
7590 \r
7591         SERVER_ADMIN_ONLY;\r
7592 \r
7593         LockList(a->Server->ServerListenerList);\r
7594         {\r
7595                 if (SiDeleteListener(a->Server, t->Port) == false)\r
7596                 {\r
7597                         ret = ERR_LISTENER_NOT_FOUND;\r
7598                 }\r
7599                 else\r
7600                 {\r
7601                         ALog(a, NULL, "LA_DELETE_LISTENER", t->Port);\r
7602 \r
7603                         IncrementServerConfigRevision(a->Server);\r
7604                 }\r
7605         }\r
7606         UnlockList(a->Server->ServerListenerList);\r
7607 \r
7608         return ret;\r
7609 }\r
7610 \r
7611 // リスナーの列挙\r
7612 UINT StEnumListener(ADMIN *a, RPC_LISTENER_LIST *t)\r
7613 {\r
7614         CEDAR *c = a->Server->Cedar;\r
7615         UINT i;\r
7616 \r
7617         FreeRpcListenerList(t);\r
7618         Zero(t, sizeof(RPC_LISTENER_LIST));\r
7619 \r
7620         LockList(a->Server->ServerListenerList);\r
7621         {\r
7622                 t->NumPort = LIST_NUM(a->Server->ServerListenerList);\r
7623                 t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
7624                 t->Enables = ZeroMalloc(sizeof(bool) * t->NumPort);\r
7625                 t->Errors = ZeroMalloc(sizeof(bool) * t->NumPort);\r
7626 \r
7627                 for (i = 0;i < t->NumPort;i++)\r
7628                 {\r
7629                         SERVER_LISTENER *o = LIST_DATA(a->Server->ServerListenerList, i);\r
7630 \r
7631                         t->Ports[i] = o->Port;\r
7632                         t->Enables[i] = o->Enabled;\r
7633                         if (t->Enables[i])\r
7634                         {\r
7635                                 if (o->Listener->Status == LISTENER_STATUS_TRYING)\r
7636                                 {\r
7637                                         t->Errors[i] = true;\r
7638                                 }\r
7639                         }\r
7640                 }\r
7641         }\r
7642         UnlockList(a->Server->ServerListenerList);\r
7643 \r
7644         return ERR_NO_ERROR;\r
7645 }\r
7646 \r
7647 // リスナーの作成\r
7648 UINT StCreateListener(ADMIN *a, RPC_LISTENER *t)\r
7649 {\r
7650         UINT ret = ERR_NO_ERROR;\r
7651         CEDAR *c = a->Server->Cedar;\r
7652 \r
7653         if (t->Port == 0 || t->Port > 65535)\r
7654         {\r
7655                 return ERR_INVALID_PARAMETER;\r
7656         }\r
7657 \r
7658         SERVER_ADMIN_ONLY;\r
7659 \r
7660         LockList(a->Server->ServerListenerList);\r
7661         {\r
7662                 if (SiAddListener(a->Server, t->Port, t->Enable) == false)\r
7663                 {\r
7664                         ret = ERR_LISTENER_ALREADY_EXISTS;\r
7665                 }\r
7666                 else\r
7667                 {\r
7668                         ALog(a, NULL, "LA_CREATE_LISTENER", t->Port);\r
7669 \r
7670                         IncrementServerConfigRevision(a->Server);\r
7671                 }\r
7672         }\r
7673         UnlockList(a->Server->ServerListenerList);\r
7674 \r
7675         SleepThread(250);\r
7676 \r
7677         return ret;\r
7678 }\r
7679 \r
7680 // サーバー状態の取得\r
7681 UINT StGetServerStatus(ADMIN *a, RPC_SERVER_STATUS *t)\r
7682 {\r
7683         CEDAR *c;\r
7684         UINT i;\r
7685 \r
7686         c = a->Server->Cedar;\r
7687 \r
7688         Zero(t, sizeof(RPC_SERVER_STATUS));\r
7689 \r
7690         Lock(c->TrafficLock);\r
7691         {\r
7692                 Copy(&t->Traffic, c->Traffic, sizeof(TRAFFIC));\r
7693         }\r
7694         Unlock(c->TrafficLock);\r
7695 \r
7696         GetMemInfo(&t->MemInfo);\r
7697 \r
7698         t->ServerType = a->Server->ServerType;\r
7699         t->NumTcpConnections = t->NumTcpConnectionsLocal = t->NumTcpConnectionsRemote = 0;\r
7700         t->NumSessionsTotal = t->NumSessionsLocal = t->NumSessionsRemote = 0;\r
7701 \r
7702         t->NumTcpConnectionsLocal = Count(c->CurrentTcpConnections);\r
7703 \r
7704         if (a->Server->ServerType == SERVER_TYPE_FARM_CONTROLLER)\r
7705         {\r
7706                 LockList(a->Server->FarmMemberList);\r
7707                 {\r
7708                         for (i = 0;i < LIST_NUM(a->Server->FarmMemberList);i++)\r
7709                         {\r
7710                                 FARM_MEMBER *f = LIST_DATA(a->Server->FarmMemberList, i);\r
7711 \r
7712                                 if (f->Me == false)\r
7713                                 {\r
7714                                         t->NumTcpConnectionsRemote += f->NumTcpConnections;\r
7715                                         t->NumSessionsRemote += f->NumSessions;\r
7716                                         AddTraffic(&t->Traffic, &f->Traffic);\r
7717                                 }\r
7718                         }\r
7719                 }\r
7720                 UnlockList(a->Server->FarmMemberList);\r
7721         }\r
7722 \r
7723         t->NumMacTables = t->NumIpTables = t->NumUsers = t->NumGroups = 0;\r
7724 \r
7725         // HUB 数の情報\r
7726         LockList(c->HubList);\r
7727         {\r
7728                 t->NumHubTotal = LIST_NUM(c->HubList);\r
7729 \r
7730                 t->NumHubStandalone = t->NumHubDynamic = t->NumHubStatic = 0;\r
7731 \r
7732                 for (i = 0;i < LIST_NUM(c->HubList);i++)\r
7733                 {\r
7734                         HUB *h = LIST_DATA(c->HubList, i);\r
7735                         Lock(h->lock);\r
7736                         {\r
7737                                 switch (h->Type)\r
7738                                 {\r
7739                                 case HUB_TYPE_STANDALONE:\r
7740                                         t->NumHubStandalone++;\r
7741                                         break;\r
7742 \r
7743                                 case HUB_TYPE_FARM_STATIC:\r
7744                                         t->NumHubStatic++;\r
7745                                         break;\r
7746 \r
7747                                 case HUB_TYPE_FARM_DYNAMIC:\r
7748                                         t->NumHubDynamic++;\r
7749                                         break;\r
7750                                 }\r
7751                         }\r
7752 \r
7753                         t->NumMacTables += LIST_NUM(h->MacTable);\r
7754                         t->NumIpTables += LIST_NUM(h->IpTable);\r
7755 \r
7756                         if (h->HubDb != NULL)\r
7757                         {\r
7758                                 t->NumUsers += LIST_NUM(h->HubDb->UserList);\r
7759                                 t->NumGroups += LIST_NUM(h->HubDb->GroupList);\r
7760                         }\r
7761 \r
7762                         Unlock(h->lock);\r
7763                 }\r
7764         }\r
7765         UnlockList(c->HubList);\r
7766 \r
7767         // セッション数の情報\r
7768         t->NumSessionsLocal = Count(c->CurrentSessions);\r
7769         t->NumSessionsTotal = t->NumSessionsLocal + t->NumSessionsRemote;\r
7770         t->NumTcpConnections = t->NumTcpConnectionsLocal + t->NumTcpConnectionsRemote;\r
7771 \r
7772         t->AssignedBridgeLicenses = Count(c->AssignedBridgeLicense);\r
7773         t->AssignedClientLicenses = Count(c->AssignedClientLicense);\r
7774 \r
7775         t->AssignedBridgeLicensesTotal = a->Server->CurrentAssignedBridgeLicense;\r
7776         t->AssignedClientLicensesTotal = a->Server->CurrentAssignedClientLicense;\r
7777 \r
7778         t->CurrentTick = Tick64();\r
7779         t->CurrentTime = SystemTime64();\r
7780 \r
7781         t->StartTime = a->Server->StartTime;\r
7782 \r
7783         return ERR_NO_ERROR;\r
7784 }\r
7785 \r
7786 // サーバー情報の取得\r
7787 UINT StGetServerInfo(ADMIN *a, RPC_SERVER_INFO *t)\r
7788 {\r
7789         CEDAR *c;\r
7790         OS_INFO *info;\r
7791         // 引数チェック\r
7792         if (a == NULL || t == NULL)\r
7793         {\r
7794                 return ERR_INTERNAL_ERROR;\r
7795         }\r
7796 \r
7797         FreeRpcServerInfo(t);\r
7798         Zero(t, sizeof(RPC_SERVER_INFO));\r
7799 \r
7800         c = a->Server->Cedar;\r
7801 \r
7802         GetServerProductName(a->Server, t->ServerProductName, sizeof(t->ServerProductName));\r
7803 \r
7804         StrCpy(t->ServerVersionString, sizeof(t->ServerVersionString), c->VerString);\r
7805         StrCpy(t->ServerBuildInfoString, sizeof(t->ServerBuildInfoString), c->BuildInfo);\r
7806         t->ServerVerInt = c->Version;\r
7807         t->ServerBuildInt = c->Build;\r
7808         GetMachineName(t->ServerHostName, sizeof(t->ServerHostName));\r
7809         t->ServerType = c->Server->ServerType;\r
7810 \r
7811         info = GetOsInfo();\r
7812         if (info != NULL)\r
7813         {\r
7814                 CopyOsInfo(&t->OsInfo, info);\r
7815         }\r
7816 \r
7817         return ERR_NO_ERROR;\r
7818 }\r
7819 \r
7820 // OS_INFO のコピー\r
7821 void CopyOsInfo(OS_INFO *dst, OS_INFO *info)\r
7822 {\r
7823         // 引数チェック\r
7824         if (info == NULL || dst == NULL)\r
7825         {\r
7826                 return;\r
7827         }\r
7828 \r
7829         dst->OsType = info->OsType;\r
7830         dst->OsServicePack = info->OsServicePack;\r
7831         dst->OsSystemName = CopyStr(info->OsSystemName);\r
7832         dst->OsProductName = CopyStr(info->OsProductName);\r
7833         dst->OsVendorName = CopyStr(info->OsVendorName);\r
7834         dst->OsVersion = CopyStr(info->OsVersion);\r
7835         dst->KernelName = CopyStr(info->KernelName);\r
7836         dst->KernelVersion = CopyStr(info->KernelVersion);\r
7837 }\r
7838 \r
7839 // RPC_WINVER\r
7840 void InRpcWinVer(RPC_WINVER *t, PACK *p)\r
7841 {\r
7842         // 引数チェック\r
7843         if (t == NULL || p == NULL)\r
7844         {\r
7845                 return;\r
7846         }\r
7847 \r
7848         Zero(t, sizeof(RPC_WINVER));\r
7849 \r
7850         t->IsWindows = PackGetBool(p, "V_IsWindows");\r
7851         t->IsNT = PackGetBool(p, "V_IsNT");\r
7852         t->IsServer = PackGetBool(p, "V_IsServer");\r
7853         t->IsBeta = PackGetBool(p, "V_IsBeta");\r
7854         t->VerMajor = PackGetInt(p, "V_VerMajor");\r
7855         t->VerMinor = PackGetInt(p, "V_VerMinor");\r
7856         t->Build = PackGetInt(p, "V_Build");\r
7857         t->ServicePack = PackGetInt(p, "V_ServicePack");\r
7858         PackGetStr(p, "V_Title", t->Title, sizeof(t->Title));\r
7859 }\r
7860 void OutRpcWinVer(PACK *p, RPC_WINVER *t)\r
7861 {\r
7862         // 引数チェック\r
7863         if (t == NULL || p == NULL)\r
7864         {\r
7865                 return;\r
7866         }\r
7867 \r
7868         PackAddBool(p, "V_IsWindows", t->IsWindows);\r
7869         PackAddBool(p, "V_IsNT", t->IsNT);\r
7870         PackAddBool(p, "V_IsServer", t->IsServer);\r
7871         PackAddBool(p, "V_IsBeta", t->IsBeta);\r
7872         PackAddInt(p, "V_VerMajor", t->VerMajor);\r
7873         PackAddInt(p, "V_VerMinor", t->VerMinor);\r
7874         PackAddInt(p, "V_Build", t->Build);\r
7875         PackAddInt(p, "V_ServicePack", t->ServicePack);\r
7876         PackAddStr(p, "V_Title", t->Title);\r
7877 }\r
7878 \r
7879 // RPC_MSG\r
7880 void InRpcMsg(RPC_MSG *t, PACK *p)\r
7881 {\r
7882         UINT size;\r
7883         char *utf8;\r
7884         // 引数チェック\r
7885         if (t == NULL || p == NULL)\r
7886         {\r
7887                 return;\r
7888         }\r
7889 \r
7890         Zero(t, sizeof(RPC_MSG));\r
7891 \r
7892         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
7893         size = PackGetDataSize(p, "Msg");\r
7894         utf8 = ZeroMalloc(size + 8);\r
7895         PackGetData(p, "Msg", utf8);\r
7896         t->Msg = CopyUtfToUni(utf8);\r
7897         Free(utf8);\r
7898 }\r
7899 void OutRpcMsg(PACK *p, RPC_MSG *t)\r
7900 {\r
7901         UINT size;\r
7902         char *utf8;\r
7903         // 引数チェック\r
7904         if (t == NULL || p == NULL)\r
7905         {\r
7906                 return;\r
7907         }\r
7908 \r
7909         PackAddStr(p, "HubName", t->HubName);\r
7910         utf8 = CopyUniToUtf(t->Msg);\r
7911         size = StrLen(utf8);\r
7912         PackAddData(p, "Msg", utf8, size);\r
7913         Free(utf8);\r
7914 }\r
7915 void FreeRpcMsg(RPC_MSG *t)\r
7916 {\r
7917         // 引数チェック\r
7918         if (t == NULL)\r
7919         {\r
7920                 return;\r
7921         }\r
7922 \r
7923         Free(t->Msg);\r
7924 }\r
7925 \r
7926 // RPC_ENUM_ETH_VLAN\r
7927 void InRpcEnumEthVLan(RPC_ENUM_ETH_VLAN *t, PACK *p)\r
7928 {\r
7929         UINT i;\r
7930         // 引数チェック\r
7931         if (t == NULL || p == NULL)\r
7932         {\r
7933                 return;\r
7934         }\r
7935 \r
7936         Zero(t, sizeof(RPC_ENUM_ETH_VLAN));\r
7937 \r
7938         t->NumItem = PackGetIndexCount(p, "DeviceName");\r
7939         t->Items = ZeroMalloc(sizeof(RPC_ENUM_ETH_VLAN_ITEM) * t->NumItem);\r
7940 \r
7941         for (i = 0;i < t->NumItem;i++)\r
7942         {\r
7943                 RPC_ENUM_ETH_VLAN_ITEM *e = &t->Items[i];\r
7944 \r
7945                 PackGetStrEx(p, "DeviceName", e->DeviceName, sizeof(e->DeviceName), i);\r
7946                 PackGetStrEx(p, "Guid", e->Guid, sizeof(e->Guid), i);\r
7947                 PackGetStrEx(p, "DeviceInstanceId", e->DeviceInstanceId, sizeof(e->DeviceInstanceId), i);\r
7948                 PackGetStrEx(p, "DriverName", e->DriverName, sizeof(e->DriverName), i);\r
7949                 PackGetStrEx(p, "DriverType", e->DriverType, sizeof(e->DriverType), i);\r
7950                 e->Support = PackGetBoolEx(p, "Support", i);\r
7951                 e->Enabled = PackGetBoolEx(p, "Enabled", i);\r
7952         }\r
7953 }\r
7954 void OutRpcEnumEthVLan(PACK *p, RPC_ENUM_ETH_VLAN *t)\r
7955 {\r
7956         UINT i;\r
7957         // 引数チェック\r
7958         if (t == NULL || p == NULL)\r
7959         {\r
7960                 return;\r
7961         }\r
7962 \r
7963         for (i = 0;i < t->NumItem;i++)\r
7964         {\r
7965                 RPC_ENUM_ETH_VLAN_ITEM *e = &t->Items[i];\r
7966 \r
7967                 PackAddStrEx(p, "DeviceName", e->DeviceName, i, t->NumItem);\r
7968                 PackAddStrEx(p, "Guid", e->Guid, i, t->NumItem);\r
7969                 PackAddStrEx(p, "DeviceInstanceId", e->DeviceInstanceId, i, t->NumItem);\r
7970                 PackAddStrEx(p, "DriverName", e->DriverName, i, t->NumItem);\r
7971                 PackAddStrEx(p, "DriverType", e->DriverType, i, t->NumItem);\r
7972                 PackAddBoolEx(p, "Support", e->Support, i, t->NumItem);\r
7973                 PackAddBoolEx(p, "Enabled", e->Enabled, i, t->NumItem);\r
7974         }\r
7975 }\r
7976 void FreeRpcEnumEthVLan(RPC_ENUM_ETH_VLAN *t)\r
7977 {\r
7978         // 引数チェック\r
7979         if (t == NULL)\r
7980         {\r
7981                 return;\r
7982         }\r
7983 \r
7984         Free(t->Items);\r
7985 }\r
7986 \r
7987 // RPC_ENUM_LOG_FILE\r
7988 void InRpcEnumLogFile(RPC_ENUM_LOG_FILE *t, PACK *p)\r
7989 {\r
7990         UINT i;\r
7991         // 引数チェック\r
7992         if (t == NULL || p == NULL)\r
7993         {\r
7994                 return;\r
7995         }\r
7996 \r
7997         Zero(t, sizeof(RPC_ENUM_LOG_FILE));\r
7998         t->NumItem = PackGetInt(p, "NumItem");\r
7999         t->Items = ZeroMalloc(sizeof(RPC_ENUM_LOG_FILE_ITEM) * t->NumItem);\r
8000 \r
8001         for (i = 0;i < t->NumItem;i++)\r
8002         {\r
8003                 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];\r
8004 \r
8005                 PackGetStrEx(p, "FilePath", e->FilePath, sizeof(e->FilePath), i);\r
8006                 PackGetStrEx(p, "ServerName", e->ServerName, sizeof(e->ServerName), i);\r
8007                 e->FileSize = PackGetIntEx(p, "FileSize", i);\r
8008                 e->UpdatedTime = PackGetInt64Ex(p, "UpdatedTime", i);\r
8009         }\r
8010 }\r
8011 void OutRpcEnumLogFile(PACK *p, RPC_ENUM_LOG_FILE *t)\r
8012 {\r
8013         UINT i;\r
8014         // 引数チェック\r
8015         if (t == NULL || p == NULL)\r
8016         {\r
8017                 return;\r
8018         }\r
8019 \r
8020         PackAddInt(p, "NumItem", t->NumItem);\r
8021 \r
8022         for (i = 0;i < t->NumItem;i++)\r
8023         {\r
8024                 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];\r
8025 \r
8026                 PackAddStrEx(p, "FilePath", e->FilePath, i, t->NumItem);\r
8027                 PackAddStrEx(p, "ServerName", e->ServerName, i, t->NumItem);\r
8028                 PackAddIntEx(p, "FileSize", e->FileSize, i, t->NumItem);\r
8029                 PackAddInt64Ex(p, "UpdatedTime", e->UpdatedTime, i, t->NumItem);\r
8030         }\r
8031 }\r
8032 void FreeRpcEnumLogFile(RPC_ENUM_LOG_FILE *t)\r
8033 {\r
8034         // 引数チェック\r
8035         if (t == NULL)\r
8036         {\r
8037                 return;\r
8038         }\r
8039 \r
8040         Free(t->Items);\r
8041 }\r
8042 void AdjoinRpcEnumLogFile(RPC_ENUM_LOG_FILE *t, RPC_ENUM_LOG_FILE *src)\r
8043 {\r
8044         LIST *o;\r
8045         UINT i;\r
8046         // 引数チェック\r
8047         if (t == NULL || src == NULL)\r
8048         {\r
8049                 return;\r
8050         }\r
8051 \r
8052         o = NewListFast(CmpLogFile);\r
8053 \r
8054         for (i = 0;i < t->NumItem;i++)\r
8055         {\r
8056                 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];\r
8057                 LOG_FILE *f = ZeroMalloc(sizeof(LOG_FILE));\r
8058 \r
8059                 f->FileSize = e->FileSize;\r
8060                 StrCpy(f->Path, sizeof(f->Path), e->FilePath);\r
8061                 StrCpy(f->ServerName, sizeof(f->ServerName), e->ServerName);\r
8062                 f->UpdatedTime = e->UpdatedTime;\r
8063 \r
8064                 Add(o, f);\r
8065         }\r
8066 \r
8067         for (i = 0;i < src->NumItem;i++)\r
8068         {\r
8069                 RPC_ENUM_LOG_FILE_ITEM *e = &src->Items[i];\r
8070                 LOG_FILE *f = ZeroMalloc(sizeof(LOG_FILE));\r
8071 \r
8072                 f->FileSize = e->FileSize;\r
8073                 StrCpy(f->Path, sizeof(f->Path), e->FilePath);\r
8074                 StrCpy(f->ServerName, sizeof(f->ServerName), e->ServerName);\r
8075                 f->UpdatedTime = e->UpdatedTime;\r
8076 \r
8077                 Add(o, f);\r
8078         }\r
8079 \r
8080         FreeRpcEnumLogFile(t);\r
8081 \r
8082         Sort(o);\r
8083 \r
8084         Zero(t, sizeof(RPC_ENUM_LOG_FILE));\r
8085         t->NumItem = LIST_NUM(o);\r
8086         t->Items = ZeroMalloc(sizeof(RPC_ENUM_LOG_FILE_ITEM) * t->NumItem);\r
8087 \r
8088         for (i = 0;i < t->NumItem;i++)\r
8089         {\r
8090                 LOG_FILE *f = LIST_DATA(o, i);\r
8091                 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];\r
8092 \r
8093                 StrCpy(e->FilePath, sizeof(e->FilePath), f->Path);\r
8094                 StrCpy(e->ServerName, sizeof(e->ServerName), f->ServerName);\r
8095                 e->FileSize = f->FileSize;\r
8096                 e->UpdatedTime = f->UpdatedTime;\r
8097         }\r
8098 \r
8099         FreeEnumLogFile(o);\r
8100 }\r
8101 \r
8102 // RPC_READ_LOG_FILE\r
8103 void InRpcReadLogFile(RPC_READ_LOG_FILE *t, PACK *p)\r
8104 {\r
8105         // 引数チェック\r
8106         if (t == NULL || p == NULL)\r
8107         {\r
8108                 return;\r
8109         }\r
8110 \r
8111         Zero(t, sizeof(RPC_READ_LOG_FILE));\r
8112         PackGetStr(p, "FilePath", t->FilePath, sizeof(t->FilePath));\r
8113         PackGetStr(p, "ServerName", t->ServerName, sizeof(t->ServerName));\r
8114         t->Offset = PackGetInt(p, "Offset");\r
8115 \r
8116         t->Buffer = PackGetBuf(p, "Buffer");\r
8117 }\r
8118 void OutRpcReadLogFile(PACK *p, RPC_READ_LOG_FILE *t)\r
8119 {\r
8120         // 引数チェック\r
8121         if (p == NULL || t == NULL)\r
8122         {\r
8123                 return;\r
8124         }\r
8125 \r
8126         PackAddStr(p, "FilePath", t->FilePath);\r
8127         PackAddStr(p, "ServerName", t->ServerName);\r
8128         PackAddInt(p, "Offset", t->Offset);\r
8129 \r
8130         if (t->Buffer != NULL)\r
8131         {\r
8132                 PackAddBuf(p, "Buffer", t->Buffer);\r
8133         }\r
8134 }\r
8135 void FreeRpcReadLogFile(RPC_READ_LOG_FILE *t)\r
8136 {\r
8137         // 引数チェック\r
8138         if (t == NULL)\r
8139         {\r
8140                 return;\r
8141         }\r
8142 \r
8143         if (t->Buffer != NULL)\r
8144         {\r
8145                 FreeBuf(t->Buffer);\r
8146         }\r
8147 }\r
8148 \r
8149 // RPC_AC_LIST\r
8150 void InRpcAcList(RPC_AC_LIST *t, PACK *p)\r
8151 {\r
8152         UINT i;\r
8153         LIST *o;\r
8154         UINT num;\r
8155         // 引数チェック\r
8156         if (t == NULL || p == NULL)\r
8157         {\r
8158                 return;\r
8159         }\r
8160 \r
8161         Zero(t, sizeof(RPC_AC_LIST));\r
8162         o = NewAcList();\r
8163 \r
8164         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
8165         num = PackGetInt(p, "NumItem");\r
8166 \r
8167         for (i = 0;i < num;i++)\r
8168         {\r
8169                 AC *ac = ZeroMalloc(sizeof(AC));\r
8170 \r
8171                 ac->Deny = PackGetBoolEx(p, "Deny", i);\r
8172                 PackGetIpEx(p, "IpAddress", &ac->IpAddress, i);\r
8173                 ac->Masked = PackGetBoolEx(p, "Masked", i);\r
8174 \r
8175                 if (ac->Masked)\r
8176                 {\r
8177                         PackGetIpEx(p, "SubnetMask", &ac->SubnetMask, i);\r
8178                 }\r
8179 \r
8180                 PackGetIntEx(p, "testtest", i);\r
8181 \r
8182                 ac->Priority = PackGetIntEx(p, "Priority", i);\r
8183 \r
8184                 AddAc(o, ac);\r
8185 \r
8186                 Free(ac);\r
8187         }\r
8188 \r
8189         t->o = o;\r
8190 }\r
8191 void OutRpcAcList(PACK *p, RPC_AC_LIST *t)\r
8192 {\r
8193         UINT i, num;\r
8194         LIST *o;\r
8195         // 引数チェック\r
8196         if (t == NULL || p == NULL)\r
8197         {\r
8198                 return;\r
8199         }\r
8200 \r
8201         o = t->o;\r
8202         num = LIST_NUM(o);\r
8203 \r
8204         PackAddInt(p, "NumItem", num);\r
8205 \r
8206         PackAddStr(p, "HubName", t->HubName);\r
8207 \r
8208         for (i = 0;i < num;i++)\r
8209         {\r
8210                 AC *ac = LIST_DATA(o, i);\r
8211 \r
8212                 PackAddBoolEx(p, "Deny", ac->Deny, i, num);\r
8213                 PackAddIpEx(p, "IpAddress", &ac->IpAddress, i, num);\r
8214                 PackAddBoolEx(p, "Masked", ac->Masked, i, num);\r
8215 \r
8216                 PackAddIpEx(p, "SubnetMask", &ac->SubnetMask, i, num);\r
8217 \r
8218                 PackAddIntEx(p, "Priority", ac->Priority, i, num);\r
8219         }\r
8220 }\r
8221 void FreeRpcAcList(RPC_AC_LIST *t)\r
8222 {\r
8223         // 引数チェック\r
8224         if (t == NULL)\r
8225         {\r
8226                 return;\r
8227         }\r
8228 \r
8229         FreeAcList(t->o);\r
8230 }\r
8231 \r
8232 // RPC_INT\r
8233 void InRpcInt(RPC_INT *t, PACK *p)\r
8234 {\r
8235         // 引数チェック\r
8236         if (t == NULL || p == NULL)\r
8237         {\r
8238                 return;\r
8239         }\r
8240 \r
8241         Zero(t, sizeof(RPC_INT));\r
8242         t->IntValue = PackGetInt(p, "IntValue");\r
8243 }\r
8244 void OutRpcInt(PACK *p, RPC_INT *t)\r
8245 {\r
8246         // 引数チェック\r
8247         if (t == NULL || p == NULL)\r
8248         {\r
8249                 return;\r
8250         }\r
8251 \r
8252         PackAddInt(p, "IntValue", t->IntValue);\r
8253 }\r
8254 \r
8255 // RPC_ENUM_CRL\r
8256 void InRpcEnumCrl(RPC_ENUM_CRL *t, PACK *p)\r
8257 {\r
8258         UINT i;\r
8259         // 引数チェック\r
8260         if (t == NULL || p == NULL)\r
8261         {\r
8262                 return;\r
8263         }\r
8264 \r
8265         Zero(t, sizeof(RPC_ENUM_CRL));\r
8266         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
8267         t->NumItem = PackGetInt(p, "NumItem");\r
8268 \r
8269         t->Items = ZeroMalloc(sizeof(RPC_ENUM_CRL_ITEM) * t->NumItem);\r
8270         for (i = 0;i < t->NumItem;i++)\r
8271         {\r
8272                 RPC_ENUM_CRL_ITEM *e = &t->Items[i];\r
8273 \r
8274                 e->Key = PackGetIntEx(p, "Key", i);\r
8275                 PackGetUniStrEx(p, "CrlInfo", e->CrlInfo, sizeof(e->CrlInfo), i);\r
8276         }\r
8277 }\r
8278 void OutRpcEnumCrl(PACK *p, RPC_ENUM_CRL *t)\r
8279 {\r
8280         UINT i;\r
8281         // 引数チェック\r
8282         if (t == NULL || p == NULL)\r
8283         {\r
8284                 return;\r
8285         }\r
8286 \r
8287         PackAddStr(p, "HubName", t->HubName);\r
8288         PackAddInt(p, "NumItem", t->NumItem);\r
8289 \r
8290         for (i = 0;i < t->NumItem;i++)\r
8291         {\r
8292                 RPC_ENUM_CRL_ITEM *e = &t->Items[i];\r
8293 \r
8294                 PackAddIntEx(p, "Key", e->Key, i, t->NumItem);\r
8295                 PackAddUniStrEx(p, "CrlInfo", e->CrlInfo, i, t->NumItem);\r
8296         }\r
8297 }\r
8298 void FreeRpcEnumCrl(RPC_ENUM_CRL *t)\r
8299 {\r
8300         // 引数チェック\r
8301         if (t == NULL)\r
8302         {\r
8303                 return;\r
8304         }\r
8305 \r
8306         Free(t->Items);\r
8307 }\r
8308 \r
8309 // RPC_CRL\r
8310 void InRpcCrl(RPC_CRL *t, PACK *p)\r
8311 {\r
8312         BUF *b;\r
8313         NAME *n;\r
8314         wchar_t tmp[MAX_SIZE];\r
8315         // 引数チェック\r
8316         if (t == NULL || p == NULL)\r
8317         {\r
8318                 return;\r
8319         }\r
8320 \r
8321         Zero(t, sizeof(RPC_CRL));\r
8322         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
8323         t->Key = PackGetInt(p, "Key");\r
8324         b = PackGetBuf(p, "Serial");\r
8325         t->Crl = ZeroMalloc(sizeof(CRL));\r
8326         if (b != NULL)\r
8327         {\r
8328                 t->Crl->Serial = NewXSerial(b->Buf, b->Size);\r
8329                 FreeBuf(b);\r
8330         }\r
8331         t->Crl->Name = ZeroMalloc(sizeof(NAME));\r
8332         n = t->Crl->Name;\r
8333         if (PackGetUniStr(p, "CommonName", tmp, sizeof(tmp)))\r
8334         {\r
8335                 n->CommonName = CopyUniStr(tmp);\r
8336         }\r
8337         if (PackGetUniStr(p, "Organization", tmp, sizeof(tmp)))\r
8338         {\r
8339                 n->Organization = CopyUniStr(tmp);\r
8340         }\r
8341         if (PackGetUniStr(p, "Unit", tmp, sizeof(tmp)))\r
8342         {\r
8343                 n->Unit = CopyUniStr(tmp);\r
8344         }\r
8345         if (PackGetUniStr(p, "Country", tmp, sizeof(tmp)))\r
8346         {\r
8347                 n->Country = CopyUniStr(tmp);\r
8348         }\r
8349         if (PackGetUniStr(p, "State", tmp, sizeof(tmp)))\r
8350         {\r
8351                 n->State = CopyUniStr(tmp);\r
8352         }\r
8353         if (PackGetUniStr(p, "Local", tmp, sizeof(tmp)))\r
8354         {\r
8355                 n->Local = CopyUniStr(tmp);\r
8356         }\r
8357         if (PackGetDataSize(p, "DigestMD5") == MD5_SIZE)\r
8358         {\r
8359                 PackGetData(p, "DigestMD5", t->Crl->DigestMD5);\r
8360         }\r
8361         if (PackGetDataSize(p, "DigestSHA1") == SHA1_SIZE)\r
8362         {\r
8363                 PackGetData(p, "DigestSHA1", t->Crl->DigestSHA1);\r
8364         }\r
8365 }\r
8366 void OutRpcCrl(PACK *p, RPC_CRL *t)\r
8367 {\r
8368         NAME *n;\r
8369         // 引数チェック\r
8370         if (p == NULL || t == NULL)\r
8371         {\r
8372                 return;\r
8373         }\r
8374 \r
8375         PackAddStr(p, "HubName", t->HubName);\r
8376         PackAddInt(p, "Key", t->Key);\r
8377 \r
8378         if (t->Crl == NULL)\r
8379         {\r
8380                 return;\r
8381         }\r
8382 \r
8383         if (t->Crl->Serial != NULL)\r
8384         {\r
8385                 PackAddData(p, "Serial", t->Crl->Serial->data, t->Crl->Serial->size);\r
8386         }\r
8387         n = t->Crl->Name;\r
8388         if (n->CommonName != NULL)\r
8389         {\r
8390                 PackAddUniStr(p, "CommonName", n->CommonName);\r
8391         }\r
8392         if (n->Organization != NULL)\r
8393         {\r
8394                 PackAddUniStr(p, "Organization", n->Organization);\r
8395         }\r
8396         if (n->Unit != NULL)\r
8397         {\r
8398                 PackAddUniStr(p, "Unit", n->Unit);\r
8399         }\r
8400         if (n->Country != NULL)\r
8401         {\r
8402                 PackAddUniStr(p, "Country", n->Country);\r
8403         }\r
8404         if (n->State != NULL)\r
8405         {\r
8406                 PackAddUniStr(p, "State", n->State);\r
8407         }\r
8408         if (n->Local != NULL)\r
8409         {\r
8410                 PackAddUniStr(p, "Local", n->Local);\r
8411         }\r
8412         if (IsZero(t->Crl->DigestMD5, MD5_SIZE) == false)\r
8413         {\r
8414                 PackAddData(p, "DigestMD5", t->Crl->DigestMD5, MD5_SIZE);\r
8415         }\r
8416         if (IsZero(t->Crl->DigestSHA1, SHA1_SIZE) == false)\r
8417         {\r
8418                 PackAddData(p, "DigestSHA1", t->Crl->DigestSHA1, SHA1_SIZE);\r
8419         }\r
8420 }\r
8421 void FreeRpcCrl(RPC_CRL *t)\r
8422 {\r
8423         // 引数チェック\r
8424         if (t == NULL)\r
8425         {\r
8426                 return;\r
8427         }\r
8428 \r
8429         FreeCrl(t->Crl);\r
8430 }\r
8431 \r
8432 // RPC_ENUM_L3TABLE\r
8433 void InRpcEnumL3Table(RPC_ENUM_L3TABLE *t, PACK *p)\r
8434 {\r
8435         UINT i;\r
8436         // 引数チェック\r
8437         if (t == NULL || p == NULL)\r
8438         {\r
8439                 return;\r
8440         }\r
8441 \r
8442         Zero(t, sizeof(RPC_ENUM_L3TABLE));\r
8443         t->NumItem = PackGetInt(p, "NumItem");\r
8444         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
8445         t->Items = ZeroMalloc(sizeof(RPC_L3TABLE) * t->NumItem);\r
8446 \r
8447         for (i = 0;i < t->NumItem;i++)\r
8448         {\r
8449                 RPC_L3TABLE *e = &t->Items[i];\r
8450 \r
8451                 e->NetworkAddress = PackGetIp32Ex(p, "NetworkAddress", i);\r
8452                 e->SubnetMask = PackGetIp32Ex(p, "SubnetMask", i);\r
8453                 e->GatewayAddress = PackGetIp32Ex(p, "GatewayAddress", i);\r
8454                 e->Metric = PackGetIntEx(p, "Metric", i);\r
8455         }\r
8456 }\r
8457 void OutRpcEnumL3Table(PACK *p, RPC_ENUM_L3TABLE *t)\r
8458 {\r
8459         UINT i;\r
8460         // 引数チェック\r
8461         if (p == NULL || t == NULL)\r
8462         {\r
8463                 return;\r
8464         }\r
8465 \r
8466         PackAddInt(p, "NumItem", t->NumItem);\r
8467         PackAddStr(p, "Name", t->Name);\r
8468 \r
8469         for (i = 0;i < t->NumItem;i++)\r
8470         {\r
8471                 RPC_L3TABLE *e = &t->Items[i];\r
8472 \r
8473                 PackAddIp32Ex(p, "NetworkAddress", e->NetworkAddress, i, t->NumItem);\r
8474                 PackAddIp32Ex(p, "SubnetMask", e->SubnetMask, i, t->NumItem);\r
8475                 PackAddIp32Ex(p, "GatewayAddress", e->GatewayAddress, i, t->NumItem);\r
8476                 PackAddIntEx(p, "Metric", e->Metric, i, t->NumItem);\r
8477         }\r
8478 }\r
8479 void FreeRpcEnumL3Table(RPC_ENUM_L3TABLE *t)\r
8480 {\r
8481         Free(t->Items);\r
8482 }\r
8483 \r
8484 // RPC_L3TABLE\r
8485 void InRpcL3Table(RPC_L3TABLE *t, PACK *p)\r
8486 {\r
8487         // 引数チェック\r
8488         if (t == NULL || p == NULL)\r
8489         {\r
8490                 return;\r
8491         }\r
8492 \r
8493         Zero(t, sizeof(RPC_L3TABLE));\r
8494         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
8495         t->NetworkAddress = PackGetIp32(p, "NetworkAddress");\r
8496         t->SubnetMask = PackGetIp32(p, "SubnetMask");\r
8497         t->GatewayAddress = PackGetIp32(p, "GatewayAddress");\r
8498         t->Metric = PackGetInt(p, "Metric");\r
8499 }\r
8500 void OutRpcL3Table(PACK *p, RPC_L3TABLE *t)\r
8501 {\r
8502         // 引数チェック\r
8503         if (p == NULL || t == NULL)\r
8504         {\r
8505                 return;\r
8506         }\r
8507 \r
8508         PackAddStr(p, "Name", t->Name);\r
8509         PackAddIp32(p, "NetworkAddress", t->NetworkAddress);\r
8510         PackAddIp32(p, "SubnetMask", t->SubnetMask);\r
8511         PackAddIp32(p, "GatewayAddress", t->GatewayAddress);\r
8512         PackAddInt(p, "Metric", t->Metric);\r
8513 }\r
8514 \r
8515 // RPC_ENUM_L3IF\r
8516 void InRpcEnumL3If(RPC_ENUM_L3IF *t, PACK *p)\r
8517 {\r
8518         UINT i;\r
8519         // 引数チェック\r
8520         if (t == NULL || p == NULL)\r
8521         {\r
8522                 return;\r
8523         }\r
8524 \r
8525         Zero(t, sizeof(RPC_ENUM_L3IF));\r
8526         t->NumItem = PackGetInt(p, "NumItem");\r
8527         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
8528         t->Items = ZeroMalloc(sizeof(RPC_L3IF) * t->NumItem);\r
8529 \r
8530         for (i = 0;i < t->NumItem;i++)\r
8531         {\r
8532                 RPC_L3IF *f = &t->Items[i];\r
8533 \r
8534                 PackGetStrEx(p, "HubName", f->HubName, sizeof(f->HubName), i);\r
8535                 f->IpAddress = PackGetIp32Ex(p, "IpAddress", i);\r
8536                 f->SubnetMask = PackGetIp32Ex(p, "SubnetMask", i);\r
8537         }\r
8538 }\r
8539 void OutRpcEnumL3If(PACK *p, RPC_ENUM_L3IF *t)\r
8540 {\r
8541         UINT i;\r
8542         // 引数チェック\r
8543         if (p == NULL || t == NULL)\r
8544         {\r
8545                 return;\r
8546         }\r
8547 \r
8548         PackAddInt(p, "NumItem", t->NumItem);\r
8549         PackAddStr(p, "Name", t->Name);\r
8550 \r
8551         for (i = 0;i < t->NumItem;i++)\r
8552         {\r
8553                 RPC_L3IF *f = &t->Items[i];\r
8554 \r
8555                 PackAddStrEx(p, "HubName", f->HubName, i, t->NumItem);\r
8556                 PackAddIp32Ex(p, "IpAddress", f->IpAddress, i, t->NumItem);\r
8557                 PackAddIp32Ex(p, "SubnetMask", f->SubnetMask, i, t->NumItem);\r
8558         }\r
8559 }\r
8560 void FreeRpcEnumL3If(RPC_ENUM_L3IF *t)\r
8561 {\r
8562         // 引数チェック\r
8563         if (t == NULL)\r
8564         {\r
8565                 return;\r
8566         }\r
8567 \r
8568         Free(t->Items);\r
8569 }\r
8570 \r
8571 // RPC_L3IF\r
8572 void InRpcL3If(RPC_L3IF *t, PACK *p)\r
8573 {\r
8574         // 引数チェック\r
8575         if (t == NULL || p == NULL)\r
8576         {\r
8577                 return;\r
8578         }\r
8579 \r
8580         Zero(t, sizeof(RPC_L3IF));\r
8581         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
8582         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
8583         t->IpAddress = PackGetIp32(p, "IpAddress");\r
8584         t->SubnetMask = PackGetIp32(p, "SubnetMask");\r
8585 }\r
8586 void OutRpcL3If(PACK *p, RPC_L3IF *t)\r
8587 {\r
8588         // 引数チェック\r
8589         if (p == NULL || t == NULL)\r
8590         {\r
8591                 return;\r
8592         }\r
8593 \r
8594         PackAddStr(p, "Name", t->Name);\r
8595         PackAddStr(p, "HubName", t->HubName);\r
8596         PackAddIp32(p, "IpAddress", t->IpAddress);\r
8597         PackAddIp32(p, "SubnetMask", t->SubnetMask);\r
8598 }\r
8599 \r
8600 // RPC_L3SW\r
8601 void InRpcL3Sw(RPC_L3SW *t, PACK *p)\r
8602 {\r
8603         // 引数チェック\r
8604         if (t == NULL || p == NULL)\r
8605         {\r
8606                 return;\r
8607         }\r
8608 \r
8609         Zero(t, sizeof(RPC_L3SW));\r
8610         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
8611 }\r
8612 void OutRpcL3Sw(PACK *p, RPC_L3SW *t)\r
8613 {\r
8614         // 引数チェック\r
8615         if (p == NULL || t == NULL)\r
8616         {\r
8617                 return;\r
8618         }\r
8619 \r
8620         PackAddStr(p, "Name", t->Name);\r
8621 }\r
8622 \r
8623 // RPC_ENUM_L3SW\r
8624 void InRpcEnumL3Sw(RPC_ENUM_L3SW *t, PACK *p)\r
8625 {\r
8626         UINT i;\r
8627         // 引数チェック\r
8628         if (t == NULL || p == NULL)\r
8629         {\r
8630                 return;\r
8631         }\r
8632 \r
8633         Zero(t, sizeof(RPC_ENUM_L3SW));\r
8634         t->NumItem = PackGetInt(p, "NumItem");\r
8635         t->Items = ZeroMalloc(sizeof(RPC_ENUM_L3SW_ITEM) * t->NumItem);\r
8636 \r
8637         for (i = 0;i < t->NumItem;i++)\r
8638         {\r
8639                 RPC_ENUM_L3SW_ITEM *s = &t->Items[i];\r
8640 \r
8641                 PackGetStrEx(p, "Name", s->Name, sizeof(s->Name), i);\r
8642                 s->NumInterfaces = PackGetIntEx(p, "NumInterfaces", i);\r
8643                 s->NumTables = PackGetIntEx(p, "NumTables", i);\r
8644                 s->Active = PackGetBoolEx(p, "Active", i);\r
8645                 s->Online = PackGetBoolEx(p, "Online", i);\r
8646         }\r
8647 }\r
8648 void OutRpcEnumL3Sw(PACK *p, RPC_ENUM_L3SW *t)\r
8649 {\r
8650         UINT i;\r
8651         // 引数チェック\r
8652         if (p == NULL || t == NULL)\r
8653         {\r
8654                 return;\r
8655         }\r
8656 \r
8657         PackAddInt(p, "NumItem", t->NumItem);\r
8658 \r
8659         for (i = 0;i < t->NumItem;i++)\r
8660         {\r
8661                 RPC_ENUM_L3SW_ITEM *s = &t->Items[i];\r
8662 \r
8663                 PackAddStrEx(p, "Name", s->Name, i, t->NumItem);\r
8664                 PackAddIntEx(p, "NumInterfaces", s->NumInterfaces, i, t->NumItem);\r
8665                 PackAddIntEx(p, "NumTables", s->NumTables, i, t->NumItem);\r
8666                 PackAddBoolEx(p, "Active", s->Active, i, t->NumItem);\r
8667                 PackAddBoolEx(p, "Online", s->Online, i, t->NumItem);\r
8668         }\r
8669 }\r
8670 void FreeRpcEnumL3Sw(RPC_ENUM_L3SW *t)\r
8671 {\r
8672         // 引数チェック\r
8673         if (t == NULL)\r
8674         {\r
8675                 return;\r
8676         }\r
8677 \r
8678         Free(t->Items);\r
8679 }\r
8680 \r
8681 // RPC_ENUM_ETH\r
8682 void InRpcEnumEth(RPC_ENUM_ETH *t, PACK *p)\r
8683 {\r
8684         UINT i;\r
8685         // 引数チェック\r
8686         if (t == NULL || p == NULL)\r
8687         {\r
8688                 return;\r
8689         }\r
8690 \r
8691         Zero(t, sizeof(RPC_ENUM_ETH));\r
8692         t->NumItem = PackGetInt(p, "NumItem");\r
8693         t->Items = ZeroMalloc(sizeof(RPC_ENUM_ETH_ITEM) * t->NumItem);\r
8694 \r
8695         for (i = 0;i < t->NumItem;i++)\r
8696         {\r
8697                 RPC_ENUM_ETH_ITEM *e = &t->Items[i];\r
8698                 PackGetStrEx(p, "DeviceName", e->DeviceName, sizeof(e->DeviceName), i);\r
8699                 PackGetUniStrEx(p, "NetworkConnectionName", e->NetworkConnectionName, sizeof(e->NetworkConnectionName), i);\r
8700         }\r
8701 }\r
8702 void OutRpcEnumEth(PACK *p, RPC_ENUM_ETH *t)\r
8703 {\r
8704         UINT i;\r
8705         // 引数チェック\r
8706         if (p == NULL || t == NULL)\r
8707         {\r
8708                 return;\r
8709         }\r
8710 \r
8711         PackAddInt(p, "NumItem", t->NumItem);\r
8712 \r
8713         for (i = 0;i < t->NumItem;i++)\r
8714         {\r
8715                 RPC_ENUM_ETH_ITEM *e = &t->Items[i];\r
8716                 PackAddStrEx(p, "DeviceName", e->DeviceName, i, t->NumItem);\r
8717                 PackAddUniStrEx(p, "NetworkConnectionName", e->NetworkConnectionName, i, t->NumItem);\r
8718         }\r
8719 }\r
8720 void FreeRpcEnumEth(RPC_ENUM_ETH *t)\r
8721 {\r
8722         // 引数チェック\r
8723         if (t == NULL)\r
8724         {\r
8725                 return;\r
8726         }\r
8727 \r
8728         Free(t->Items);\r
8729 }\r
8730 \r
8731 // RPC_LOCALBRIDGE\r
8732 void InRpcLocalBridge(RPC_LOCALBRIDGE *t, PACK *p)\r
8733 {\r
8734         // 引数チェック\r
8735         if (t == NULL || p == NULL)\r
8736         {\r
8737                 return;\r
8738         }\r
8739 \r
8740         Zero(t, sizeof(RPC_LOCALBRIDGE));\r
8741         PackGetStr(p, "DeviceName", t->DeviceName, sizeof(t->DeviceName));\r
8742         PackGetStr(p, "HubNameLB", t->HubName, sizeof(t->HubName));\r
8743         t->TapMode = PackGetBool(p, "TapMode");\r
8744 }\r
8745 void OutRpcLocalBridge(PACK *p, RPC_LOCALBRIDGE *t)\r
8746 {\r
8747         // 引数チェック\r
8748         if (t == NULL || p == NULL)\r
8749         {\r
8750                 return;\r
8751         }\r
8752 \r
8753         PackAddStr(p, "DeviceName", t->DeviceName);\r
8754         PackAddStr(p, "HubNameLB", t->HubName);\r
8755         PackAddBool(p, "TapMode", t->TapMode);\r
8756 }\r
8757 \r
8758 // RPC_ENUM_LOCALBRIDGE\r
8759 void InRpcEnumLocalBridge(RPC_ENUM_LOCALBRIDGE *t, PACK *p)\r
8760 {\r
8761         UINT i;\r
8762         // 引数チェック\r
8763         if (t == NULL || p == NULL)\r
8764         {\r
8765                 return;\r
8766         }\r
8767 \r
8768         Zero(t, sizeof(RPC_ENUM_LOCALBRIDGE));\r
8769         t->NumItem = PackGetInt(p, "NumItem");\r
8770         t->Items = ZeroMalloc(sizeof(RPC_LOCALBRIDGE) * t->NumItem);\r
8771 \r
8772         for (i = 0;i < t->NumItem;i++)\r
8773         {\r
8774                 RPC_LOCALBRIDGE *e = &t->Items[i];\r
8775 \r
8776                 PackGetStrEx(p, "DeviceName", e->DeviceName, sizeof(e->DeviceName), i);\r
8777                 PackGetStrEx(p, "HubNameLB", e->HubName, sizeof(e->HubName), i);\r
8778                 e->Online = PackGetBoolEx(p, "Online", i);\r
8779                 e->Active = PackGetBoolEx(p, "Active", i);\r
8780                 e->TapMode = PackGetBoolEx(p, "TapMode", i);\r
8781         }\r
8782 }\r
8783 void OutRpcEnumLocalBridge(PACK *p, RPC_ENUM_LOCALBRIDGE *t)\r
8784 {\r
8785         UINT i;\r
8786         // 引数チェック\r
8787         if (t == NULL || p == NULL)\r
8788         {\r
8789                 return;\r
8790         }\r
8791 \r
8792         PackAddInt(p, "NumItem", t->NumItem);\r
8793 \r
8794         for (i = 0;i < t->NumItem;i++)\r
8795         {\r
8796                 RPC_LOCALBRIDGE *e = &t->Items[i];\r
8797 \r
8798                 PackAddStrEx(p, "DeviceName", e->DeviceName, i, t->NumItem);\r
8799                 PackAddStrEx(p, "HubNameLB", e->HubName, i, t->NumItem);\r
8800                 PackAddBoolEx(p, "Online", e->Online, i, t->NumItem);\r
8801                 PackAddBoolEx(p, "Active", e->Active, i, t->NumItem);\r
8802                 PackAddBoolEx(p, "TapMode", e->TapMode, i, t->NumItem);\r
8803         }\r
8804 }\r
8805 void FreeRpcEnumLocalBridge(RPC_ENUM_LOCALBRIDGE *t)\r
8806 {\r
8807         // 引数チェック\r
8808         if (t == NULL)\r
8809         {\r
8810                 return;\r
8811         }\r
8812         Free(t->Items);\r
8813 }\r
8814 \r
8815 // MEMINFO\r
8816 void InRpcMemInfo(MEMINFO *t, PACK *p)\r
8817 {\r
8818         // 引数チェック\r
8819         if (t == NULL || p == NULL)\r
8820         {\r
8821                 return;\r
8822         }\r
8823 \r
8824         Zero(t, sizeof(MEMINFO));\r
8825         t->TotalMemory = PackGetInt64(p, "TotalMemory");\r
8826         t->UsedMemory = PackGetInt64(p, "UsedMemory");\r
8827         t->FreeMemory = PackGetInt64(p, "FreeMemory");\r
8828         t->TotalPhys = PackGetInt64(p, "TotalPhys");\r
8829         t->UsedPhys = PackGetInt64(p, "UsedPhys");\r
8830         t->FreePhys = PackGetInt64(p, "FreePhys");\r
8831 }\r
8832 void OutRpcMemInfo(PACK *p, MEMINFO *t)\r
8833 {\r
8834         // 引数チェック\r
8835         if (t == NULL || p == NULL)\r
8836         {\r
8837                 return;\r
8838         }\r
8839 \r
8840         PackAddInt64(p, "TotalMemory", t->TotalMemory);\r
8841         PackAddInt64(p, "UsedMemory", t->UsedMemory);\r
8842         PackAddInt64(p, "FreeMemory", t->FreeMemory);\r
8843         PackAddInt64(p, "TotalPhys", t->TotalPhys);\r
8844         PackAddInt64(p, "UsedPhys", t->UsedPhys);\r
8845         PackAddInt64(p, "FreePhys", t->FreePhys);\r
8846 }\r
8847 \r
8848 // OS_INFO\r
8849 void InRpcOsInfo(OS_INFO *t, PACK *p)\r
8850 {\r
8851         char tmp[MAX_SIZE];\r
8852         // 引数チェック\r
8853         if (t == NULL || p == NULL)\r
8854         {\r
8855                 return;\r
8856         }\r
8857 \r
8858         Zero(t, sizeof(OS_INFO));\r
8859         t->OsType = PackGetInt(p, "OsType");\r
8860         t->OsServicePack = PackGetInt(p, "OsServicePack");\r
8861         if (PackGetStr(p, "OsSystemName", tmp, sizeof(tmp)))\r
8862         {\r
8863                 t->OsSystemName = CopyStr(tmp);\r
8864         }\r
8865         if (PackGetStr(p, "OsProductName", tmp, sizeof(tmp)))\r
8866         {\r
8867                 t->OsProductName = CopyStr(tmp);\r
8868         }\r
8869         if (PackGetStr(p, "OsVendorName", tmp, sizeof(tmp)))\r
8870         {\r
8871                 t->OsVendorName = CopyStr(tmp);\r
8872         }\r
8873         if (PackGetStr(p, "OsVersion", tmp, sizeof(tmp)))\r
8874         {\r
8875                 t->OsVersion = CopyStr(tmp);\r
8876         }\r
8877         if (PackGetStr(p, "KernelName", tmp, sizeof(tmp)))\r
8878         {\r
8879                 t->KernelName = CopyStr(tmp);\r
8880         }\r
8881         if (PackGetStr(p, "KernelVersion", tmp, sizeof(tmp)))\r
8882         {\r
8883                 t->KernelVersion = CopyStr(tmp);\r
8884         }\r
8885 }\r
8886 void OutRpcOsInfo(PACK *p, OS_INFO *t)\r
8887 {\r
8888         // 引数チェック\r
8889         if (t == NULL || p == NULL)\r
8890         {\r
8891                 return;\r
8892         }\r
8893 \r
8894         PackAddInt(p, "OsType", t->OsType);\r
8895         PackAddInt(p, "OsServicePack", t->OsServicePack);\r
8896         PackAddStr(p, "OsSystemName", t->OsSystemName);\r
8897         PackAddStr(p, "OsProductName", t->OsProductName);\r
8898         PackAddStr(p, "OsVendorName", t->OsVendorName);\r
8899         PackAddStr(p, "OsVersion", t->OsVersion);\r
8900         PackAddStr(p, "KernelName", t->KernelName);\r
8901         PackAddStr(p, "KernelVersion", t->KernelVersion);\r
8902 }\r
8903 void FreeRpcOsInfo(OS_INFO *t)\r
8904 {\r
8905         // 引数チェック\r
8906         if (t == NULL)\r
8907         {\r
8908                 return;\r
8909         }\r
8910 \r
8911         Free(t->OsSystemName);\r
8912         Free(t->OsProductName);\r
8913         Free(t->OsVendorName);\r
8914         Free(t->OsVersion);\r
8915         Free(t->KernelName);\r
8916         Free(t->KernelVersion);\r
8917 }\r
8918 \r
8919 // ローカルのログファイルを読み込む\r
8920 void SiReadLocalLogFile(SERVER *s, char *filepath, UINT offset, RPC_READ_LOG_FILE *t)\r
8921 {\r
8922         char exe_dir[MAX_PATH], full_path[MAX_PATH];\r
8923         IO *o;\r
8924         // 引数チェック\r
8925         if (s == NULL || t == NULL || filepath == NULL)\r
8926         {\r
8927                 return;\r
8928         }\r
8929 \r
8930         Zero(t, sizeof(RPC_READ_LOG_FILE));\r
8931 \r
8932         GetExeDir(exe_dir, sizeof(exe_dir));\r
8933         Format(full_path, sizeof(full_path), "%s/%s", exe_dir, filepath);\r
8934 \r
8935         // ファイルを読み込む\r
8936         o = FileOpenEx(full_path, false, false);\r
8937         if (o != NULL)\r
8938         {\r
8939                 UINT filesize = FileSize(o);\r
8940 \r
8941                 if (offset < filesize)\r
8942                 {\r
8943                         UINT readsize = MIN(filesize - offset, FTP_BLOCK_SIZE);\r
8944                         void *buf = ZeroMalloc(readsize);\r
8945 \r
8946                         FileSeek(o, FILE_BEGIN, offset);\r
8947                         FileRead(o, buf, readsize);\r
8948 \r
8949                         t->Buffer = NewBuf();\r
8950                         WriteBuf(t->Buffer, buf, readsize);\r
8951                         Free(buf);\r
8952                 }\r
8953 \r
8954                 FileClose(o);\r
8955         }\r
8956 }\r
8957 \r
8958 // ローカルのログファイルを列挙する\r
8959 void SiEnumLocalLogFileList(SERVER *s, char *hubname, RPC_ENUM_LOG_FILE *t)\r
8960 {\r
8961         LIST *o;\r
8962         UINT i;\r
8963         // 引数チェック\r
8964         if (s == NULL || t == NULL)\r
8965         {\r
8966                 return;\r
8967         }\r
8968 \r
8969         Zero(t, sizeof(RPC_ENUM_LOG_FILE));\r
8970 \r
8971         o = EnumLogFile(hubname);\r
8972 \r
8973         t->NumItem = LIST_NUM(o);\r
8974         t->Items = ZeroMalloc(sizeof(RPC_ENUM_LOG_FILE_ITEM) * t->NumItem);\r
8975 \r
8976         for (i = 0;i < LIST_NUM(o);i++)\r
8977         {\r
8978                 LOG_FILE *f = LIST_DATA(o, i);\r
8979                 RPC_ENUM_LOG_FILE_ITEM *e = &t->Items[i];\r
8980 \r
8981                 StrCpy(e->FilePath, sizeof(e->FilePath), f->Path);\r
8982                 StrCpy(e->ServerName, sizeof(e->ServerName), f->ServerName);\r
8983                 e->FileSize = f->FileSize;\r
8984                 e->UpdatedTime = f->UpdatedTime;\r
8985         }\r
8986 \r
8987         FreeEnumLogFile(o);\r
8988 }\r
8989 \r
8990 // ローカルのセッションを列挙する\r
8991 void SiEnumLocalSession(SERVER *s, char *hubname, RPC_ENUM_SESSION *t)\r
8992 {\r
8993         HUB *h;\r
8994         // 引数チェック\r
8995         if (s == NULL || hubname == NULL || t == NULL)\r
8996         {\r
8997                 return;\r
8998         }\r
8999 \r
9000         LockHubList(s->Cedar);\r
9001         h = GetHub(s->Cedar, hubname);\r
9002         UnlockHubList(s->Cedar);\r
9003 \r
9004         if (h == NULL)\r
9005         {\r
9006                 t->NumSession = 0;\r
9007                 t->Sessions = ZeroMalloc(0);\r
9008                 return;\r
9009         }\r
9010 \r
9011         LockList(h->SessionList);\r
9012         {\r
9013                 UINT i;\r
9014                 t->NumSession = LIST_NUM(h->SessionList);\r
9015                 t->Sessions = ZeroMalloc(sizeof(RPC_ENUM_SESSION_ITEM) * t->NumSession);\r
9016 \r
9017                 for (i = 0;i < t->NumSession;i++)\r
9018                 {\r
9019                         SESSION *s = LIST_DATA(h->SessionList, i);\r
9020                         RPC_ENUM_SESSION_ITEM *e = &t->Sessions[i];\r
9021                         Lock(s->lock);\r
9022                         {\r
9023                                 StrCpy(e->Name, sizeof(e->Name), s->Name);\r
9024                                 StrCpy(e->Username, sizeof(e->Username), s->Username);\r
9025                                 e->Ip = IPToUINT(&s->Connection->ClientIp);\r
9026                                 StrCpy(e->Hostname, sizeof(e->Hostname), s->Connection->ClientHostname);\r
9027                                 e->MaxNumTcp = s->MaxConnection;\r
9028                                 e->LinkMode = s->LinkModeServer;\r
9029                                 e->SecureNATMode = s->SecureNATMode;\r
9030                                 e->BridgeMode = s->BridgeMode;\r
9031                                 e->Layer3Mode = s->L3SwitchMode;\r
9032                                 e->VLanId = s->VLanId;\r
9033                                 LockList(s->Connection->Tcp->TcpSockList);\r
9034                                 {\r
9035                                         e->CurrentNumTcp = s->Connection->Tcp->TcpSockList->num_item;\r
9036                                 }\r
9037                                 UnlockList(s->Connection->Tcp->TcpSockList);\r
9038                                 Lock(s->TrafficLock);\r
9039                                 {\r
9040                                         e->PacketSize = GetTrafficPacketSize(s->Traffic);\r
9041                                         e->PacketNum = GetTrafficPacketNum(s->Traffic);\r
9042                                 }\r
9043                                 Unlock(s->TrafficLock);\r
9044                                 e->Client_BridgeMode = s->IsBridgeMode;\r
9045                                 e->Client_MonitorMode = s->IsMonitorMode;\r
9046                                 Copy(e->UniqueId, s->NodeInfo.UniqueId, 16);\r
9047                         }\r
9048                         Unlock(s->lock);\r
9049                         GetMachineName(e->RemoteHostname, sizeof(e->RemoteHostname));\r
9050                 }\r
9051         }\r
9052         UnlockList(h->SessionList);\r
9053 \r
9054         ReleaseHub(h);\r
9055 }\r
9056 \r
9057 // RPC_ENUM_LICENSE_KEY\r
9058 void InRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY *t, PACK *p)\r
9059 {\r
9060         UINT i;\r
9061         // 引数チェック\r
9062         if (t == NULL || p == NULL)\r
9063         {\r
9064                 return;\r
9065         }\r
9066 \r
9067         Zero(t, sizeof(RPC_ENUM_LICENSE_KEY));\r
9068         t->NumItem = PackGetInt(p, "NumItem");\r
9069         t->Items = ZeroMalloc(sizeof(RPC_ENUM_LICENSE_KEY_ITEM) * t->NumItem);\r
9070         for (i = 0;i < t->NumItem;i++)\r
9071         {\r
9072                 RPC_ENUM_LICENSE_KEY_ITEM *e = &t->Items[i];\r
9073 \r
9074                 e->Id = PackGetIntEx(p, "Id", i);\r
9075                 PackGetStrEx(p, "LicenseKey", e->LicenseKey, sizeof(e->LicenseKey), i);\r
9076                 PackGetStrEx(p, "LicenseId", e->LicenseId, sizeof(e->LicenseId), i);\r
9077                 PackGetStrEx(p, "LicenseName", e->LicenseName, sizeof(e->LicenseName), i);\r
9078                 e->Expires = PackGetInt64Ex(p, "Expires", i);\r
9079                 e->Status = PackGetIntEx(p, "Status", i);\r
9080                 e->ProductId = PackGetIntEx(p, "ProductId", i);\r
9081                 e->SystemId = PackGetInt64Ex(p, "SystemId", i);\r
9082                 e->SerialId = PackGetIntEx(p, "SerialId", i);\r
9083         }\r
9084 }\r
9085 void OutRpcEnumLicenseKey(PACK *p, RPC_ENUM_LICENSE_KEY *t)\r
9086 {\r
9087         UINT i;\r
9088         // 引数チェック\r
9089         if (t == NULL || p == NULL)\r
9090         {\r
9091                 return;\r
9092         }\r
9093 \r
9094         PackAddInt(p, "NumItem", t->NumItem);\r
9095         for (i = 0;i < t->NumItem;i++)\r
9096         {\r
9097                 RPC_ENUM_LICENSE_KEY_ITEM *e = &t->Items[i];\r
9098 \r
9099                 PackAddIntEx(p, "Id", e->Id, i, t->NumItem);\r
9100                 PackAddStrEx(p, "LicenseKey", e->LicenseKey, i, t->NumItem);\r
9101                 PackAddStrEx(p, "LicenseId", e->LicenseId, i, t->NumItem);\r
9102                 PackAddStrEx(p, "LicenseName", e->LicenseName, i, t->NumItem);\r
9103                 PackAddInt64Ex(p, "Expires", e->Expires, i, t->NumItem);\r
9104                 PackAddIntEx(p, "Status", e->Status, i, t->NumItem);\r
9105                 PackAddIntEx(p, "ProductId", e->ProductId, i, t->NumItem);\r
9106                 PackAddInt64Ex(p, "SystemId", e->SystemId, i, t->NumItem);\r
9107                 PackAddIntEx(p, "SerialId", e->SerialId, i, t->NumItem);\r
9108         }\r
9109 }\r
9110 void FreeRpcEnumLicenseKey(RPC_ENUM_LICENSE_KEY *t)\r
9111 {\r
9112         // 引数チェック\r
9113         if (t == NULL)\r
9114         {\r
9115                 return;\r
9116         }\r
9117 \r
9118         Free(t->Items);\r
9119 }\r
9120 \r
9121 // RPC_LICENSE_STATUS\r
9122 void InRpcLicenseStatus(RPC_LICENSE_STATUS *t, PACK *p)\r
9123 {\r
9124         // 引数チェック\r
9125         if (t == NULL || p == NULL)\r
9126         {\r
9127                 return;\r
9128         }\r
9129 \r
9130         Zero(t, sizeof(RPC_LICENSE_STATUS));\r
9131 \r
9132         t->EditionId = PackGetInt(p, "EditionId");\r
9133         PackGetStr(p, "EditionStr", t->EditionStr, sizeof(t->EditionStr) );\r
9134         t->SystemId = PackGetInt64(p, "SystemId");\r
9135         t->SystemExpires = PackGetInt64(p, "SystemExpires");\r
9136         t->NumClientConnectLicense = PackGetInt(p, "NumClientConnectLicense");\r
9137         t->NumBridgeConnectLicense = PackGetInt(p, "NumBridgeConnectLicense");\r
9138 \r
9139         // v3.0\r
9140         t->NeedSubscription = PackGetBool(p, "NeedSubscription");\r
9141         t->AllowEnterpriseFunction = PackGetBool(p, "AllowEnterpriseFunction");\r
9142         t->SubscriptionExpires = PackGetInt64(p, "SubscriptionExpires");\r
9143         t->IsSubscriptionExpired = PackGetBool(p, "IsSubscriptionExpired");\r
9144         t->NumUserCreationLicense = PackGetInt(p, "NumUserCreationLicense");\r
9145         t->ReleaseDate = PackGetInt64(p, "ReleaseDate");\r
9146 }\r
9147 void OutRpcLicenseStatus(PACK *p, RPC_LICENSE_STATUS *t)\r
9148 {\r
9149         // 引数チェック\r
9150         if (t == NULL || p == NULL)\r
9151         {\r
9152                 return;\r
9153         }\r
9154 \r
9155         PackAddInt(p, "EditionId", t->EditionId);\r
9156         PackAddStr(p, "EditionStr", t->EditionStr);\r
9157         PackAddInt64(p, "SystemId", t->SystemId);\r
9158         PackAddInt64(p, "SystemExpires", t->SystemExpires);\r
9159         PackAddInt(p, "NumClientConnectLicense", t->NumClientConnectLicense);\r
9160         PackAddInt(p, "NumBridgeConnectLicense", t->NumBridgeConnectLicense);\r
9161 \r
9162         // v3.0\r
9163         PackAddBool(p, "NeedSubscription", t->NeedSubscription);\r
9164         PackAddBool(p, "AllowEnterpriseFunction", t->AllowEnterpriseFunction);\r
9165         PackAddInt64(p, "SubscriptionExpires", t->SubscriptionExpires);\r
9166         PackAddBool(p, "IsSubscriptionExpired", t->IsSubscriptionExpired);\r
9167         PackAddInt(p, "NumUserCreationLicense", t->NumUserCreationLicense);\r
9168         PackAddInt64(p, "ReleaseDate", t->ReleaseDate);\r
9169 }\r
9170 \r
9171 // RPC_ADMIN_OPTION\r
9172 void InRpcAdminOption(RPC_ADMIN_OPTION *t, PACK *p)\r
9173 {\r
9174         UINT i;\r
9175         // 引数チェック\r
9176         if (t == NULL || p == NULL)\r
9177         {\r
9178                 return;\r
9179         }\r
9180 \r
9181         Zero(t, sizeof(RPC_ADMIN_OPTION));\r
9182         t->NumItem = PackGetInt(p, "NumItem");\r
9183         t->Items = ZeroMalloc(sizeof(ADMIN_OPTION) * t->NumItem);\r
9184 \r
9185         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
9186 \r
9187         for (i = 0;i < t->NumItem;i++)\r
9188         {\r
9189                 ADMIN_OPTION *o = &t->Items[i];\r
9190 \r
9191                 PackGetStrEx(p, "Name", o->Name, sizeof(o->Name), i);\r
9192                 o->Value = PackGetIntEx(p, "Value", i);\r
9193         }\r
9194 }\r
9195 void OutRpcAdminOption(PACK *p, RPC_ADMIN_OPTION *t)\r
9196 {\r
9197         UINT i;\r
9198         // 引数チェック\r
9199         if (t == NULL || p == NULL)\r
9200         {\r
9201                 return;\r
9202         }\r
9203 \r
9204         PackAddInt(p, "NumItem", t->NumItem);\r
9205 \r
9206         PackAddStr(p, "HubName", t->HubName);\r
9207 \r
9208         for (i = 0;i < t->NumItem;i++)\r
9209         {\r
9210                 ADMIN_OPTION *o = &t->Items[i];\r
9211 \r
9212                 PackAddStrEx(p, "Name", o->Name, i, t->NumItem);\r
9213                 PackAddIntEx(p, "Value", o->Value, i, t->NumItem);\r
9214         }\r
9215 }\r
9216 void FreeRpcAdminOption(RPC_ADMIN_OPTION *t)\r
9217 {\r
9218         // 引数チェック\r
9219         if (t == NULL)\r
9220         {\r
9221                 return;\r
9222         }\r
9223 \r
9224         Free(t->Items);\r
9225 }\r
9226 \r
9227 // RPC_CONFIG\r
9228 void InRpcConfig(RPC_CONFIG *t, PACK *p)\r
9229 {\r
9230         UINT size;\r
9231         // 引数チェック\r
9232         if (t == NULL || p == NULL)\r
9233         {\r
9234                 return;\r
9235         }\r
9236 \r
9237         Zero(t, sizeof(RPC_CONFIG));\r
9238         PackGetStr(p, "FileName", t->FileName, sizeof(t->FileName));\r
9239         size = PackGetDataSize(p, "FileData");\r
9240         t->FileData = ZeroMalloc(size + 1);\r
9241         PackGetData(p, "FileData", t->FileData);\r
9242 }\r
9243 void OutRpcConfig(PACK *p, RPC_CONFIG *t)\r
9244 {\r
9245         // 引数チェック\r
9246         if (t == NULL || p == NULL)\r
9247         {\r
9248                 return;\r
9249         }\r
9250 \r
9251         PackAddStr(p, "FileName", t->FileName);\r
9252         PackAddData(p, "FileData", t->FileData, StrLen(t->FileData));\r
9253 }\r
9254 void FreeRpcConfig(RPC_CONFIG *t)\r
9255 {\r
9256         // 引数チェック\r
9257         if (t == NULL)\r
9258         {\r
9259                 return;\r
9260         }\r
9261 \r
9262         Free(t->FileData);\r
9263 }\r
9264 \r
9265 // RPC_BRIDGE_SUPPORT\r
9266 void InRpcBridgeSupport(RPC_BRIDGE_SUPPORT *t, PACK *p)\r
9267 {\r
9268         // 引数チェック\r
9269         if (t == NULL || p == NULL)\r
9270         {\r
9271                 return;\r
9272         }\r
9273 \r
9274         Zero(t, sizeof(RPC_BRIDGE_SUPPORT));\r
9275 \r
9276         t->IsBridgeSupportedOs = PackGetBool(p, "IsBridgeSupportedOs");\r
9277         t->IsWinPcapNeeded = PackGetBool(p, "IsWinPcapNeeded");\r
9278 }\r
9279 void OutRpcBridgeSupport(PACK *p, RPC_BRIDGE_SUPPORT *t)\r
9280 {\r
9281         // 引数チェック\r
9282         if (p == NULL || t == NULL)\r
9283         {\r
9284                 return;\r
9285         }\r
9286 \r
9287         PackAddBool(p, "IsBridgeSupportedOs", t->IsBridgeSupportedOs);\r
9288         PackAddBool(p, "IsWinPcapNeeded",t->IsWinPcapNeeded);\r
9289 }\r
9290 \r
9291 // RPC_ADD_ACCESS\r
9292 void InRpcAddAccess(RPC_ADD_ACCESS *t, PACK *p)\r
9293 {\r
9294         // 引数チェック\r
9295         if (t == NULL || p == NULL)\r
9296         {\r
9297                 return;\r
9298         }\r
9299 \r
9300         Zero(t, sizeof(RPC_ADD_ACCESS));\r
9301 \r
9302         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
9303         InRpcAccess(&t->Access, p);\r
9304 }\r
9305 void OutRpcAddAccess(PACK *p, RPC_ADD_ACCESS *t)\r
9306 {\r
9307         // 引数チェック\r
9308         if (t == NULL || p == NULL)\r
9309         {\r
9310                 return;\r
9311         }\r
9312 \r
9313         PackAddStr(p, "HubName", t->HubName);\r
9314         OutRpcAccess(p, &t->Access);\r
9315 }\r
9316 \r
9317 // RPC_DELETE_ACCESS\r
9318 void InRpcDeleteAccess(RPC_DELETE_ACCESS *t, PACK *p)\r
9319 {\r
9320         // 引数チェック\r
9321         if (t == NULL || p == NULL)\r
9322         {\r
9323                 return;\r
9324         }\r
9325 \r
9326         Zero(t, sizeof(RPC_DELETE_ACCESS));\r
9327 \r
9328         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
9329         t->Id = PackGetInt(p, "Id");\r
9330 }\r
9331 void OutRpcDeleteAccess(PACK *p, RPC_DELETE_ACCESS *t)\r
9332 {\r
9333         // 引数チェック\r
9334         if (t == NULL || p == NULL)\r
9335         {\r
9336                 return;\r
9337         }\r
9338 \r
9339         PackAddStr(p, "HubName", t->HubName);\r
9340         PackAddInt(p, "Id", t->Id);\r
9341 }\r
9342 \r
9343 \r
9344 // RPC_SERVER_INFO\r
9345 void InRpcServerInfo(RPC_SERVER_INFO *t, PACK *p)\r
9346 {\r
9347         // 引数チェック\r
9348         if (t == NULL || p == NULL)\r
9349         {\r
9350                 return;\r
9351         }\r
9352 \r
9353         Zero(t, sizeof(RPC_SERVER_INFO));\r
9354 \r
9355         PackGetStr(p, "ServerProductName", t->ServerProductName, sizeof(t->ServerProductName));\r
9356         PackGetStr(p, "ServerVersionString", t->ServerVersionString, sizeof(t->ServerVersionString));\r
9357         PackGetStr(p, "ServerBuildInfoString", t->ServerBuildInfoString, sizeof(t->ServerBuildInfoString));\r
9358         t->ServerVerInt = PackGetInt(p, "ServerVerInt");\r
9359         t->ServerBuildInt = PackGetInt(p, "ServerBuildInt");\r
9360         PackGetStr(p, "ServerHostName", t->ServerHostName, sizeof(t->ServerHostName));\r
9361         t->ServerType = PackGetInt(p, "ServerType");\r
9362         InRpcOsInfo(&t->OsInfo, p);\r
9363 }\r
9364 void OutRpcServerInfo(PACK *p, RPC_SERVER_INFO *t)\r
9365 {\r
9366         // 引数チェック\r
9367         if (t == NULL || p == NULL)\r
9368         {\r
9369                 return;\r
9370         }\r
9371 \r
9372         PackAddStr(p, "ServerProductName", t->ServerProductName);\r
9373         PackAddStr(p, "ServerVersionString", t->ServerVersionString);\r
9374         PackAddStr(p, "ServerBuildInfoString", t->ServerBuildInfoString);\r
9375         PackAddInt(p, "ServerVerInt", t->ServerVerInt);\r
9376         PackAddInt(p, "ServerBuildInt", t->ServerBuildInt);\r
9377         PackAddStr(p, "ServerHostName", t->ServerHostName);\r
9378         PackAddInt(p, "ServerType", t->ServerType);\r
9379         OutRpcOsInfo(p, &t->OsInfo);\r
9380 }\r
9381 void FreeRpcServerInfo(RPC_SERVER_INFO *t)\r
9382 {\r
9383         // 引数チェック\r
9384         if (t == NULL)\r
9385         {\r
9386                 return;\r
9387         }\r
9388 \r
9389         FreeRpcOsInfo(&t->OsInfo);\r
9390 }\r
9391 \r
9392 // RPC_SERVER_STATUS\r
9393 void InRpcServerStatus(RPC_SERVER_STATUS *t, PACK *p)\r
9394 {\r
9395         // 引数チェック\r
9396         if (t == NULL || p == NULL)\r
9397         {\r
9398                 return;\r
9399         }\r
9400 \r
9401         Zero(t, sizeof(RPC_SERVER_STATUS));\r
9402         t->ServerType = PackGetInt(p, "ServerType");\r
9403         t->NumTcpConnections = PackGetInt(p, "NumTcpConnections");\r
9404         t->NumTcpConnectionsLocal = PackGetInt(p, "NumTcpConnectionsLocal");\r
9405         t->NumTcpConnectionsRemote = PackGetInt(p, "NumTcpConnectionsRemote");\r
9406         t->NumHubTotal = PackGetInt(p, "NumHubTotal");\r
9407         t->NumHubStandalone = PackGetInt(p, "NumHubStandalone");\r
9408         t->NumHubStatic = PackGetInt(p, "NumHubStatic");\r
9409         t->NumHubDynamic = PackGetInt(p, "NumHubDynamic");\r
9410         t->NumSessionsTotal = PackGetInt(p, "NumSessionsTotal");\r
9411         t->NumSessionsLocal = PackGetInt(p, "NumSessionsLocal");\r
9412         t->NumSessionsRemote = PackGetInt(p, "NumSessionsRemote");\r
9413         t->NumMacTables = PackGetInt(p, "NumMacTables");\r
9414         t->NumIpTables = PackGetInt(p, "NumIpTables");\r
9415         t->NumUsers = PackGetInt(p, "NumUsers");\r
9416         t->NumGroups = PackGetInt(p, "NumGroups");\r
9417         t->CurrentTime = PackGetInt64(p, "CurrentTime");\r
9418         t->CurrentTick = PackGetInt64(p, "CurrentTick");\r
9419         t->AssignedBridgeLicenses = PackGetInt(p, "AssignedBridgeLicenses");\r
9420         t->AssignedClientLicenses = PackGetInt(p, "AssignedClientLicenses");\r
9421         t->AssignedBridgeLicensesTotal = PackGetInt(p, "AssignedBridgeLicensesTotal");\r
9422         t->AssignedClientLicensesTotal = PackGetInt(p, "AssignedClientLicensesTotal");\r
9423         t->StartTime = PackGetInt64(p, "StartTime");\r
9424 \r
9425         InRpcTraffic(&t->Traffic, p);\r
9426 \r
9427         InRpcMemInfo(&t->MemInfo, p);\r
9428 }\r
9429 void OutRpcServerStatus(PACK *p, RPC_SERVER_STATUS *t)\r
9430 {\r
9431         // 引数チェック\r
9432         if (t == NULL || p == NULL)\r
9433         {\r
9434                 return;\r
9435         }\r
9436 \r
9437         PackAddInt(p, "ServerType", t->ServerType);\r
9438         PackAddInt(p, "NumTcpConnections", t->NumTcpConnections);\r
9439         PackAddInt(p, "NumHubTotal", t->NumHubTotal);\r
9440         PackAddInt(p, "NumHubStandalone", t->NumHubStandalone);\r
9441         PackAddInt(p, "NumHubStatic", t->NumHubStatic);\r
9442         PackAddInt(p, "NumHubDynamic", t->NumHubDynamic);\r
9443         PackAddInt(p, "NumSessionsTotal", t->NumSessionsTotal);\r
9444         PackAddInt(p, "NumSessionsLocal", t->NumSessionsLocal);\r
9445         PackAddInt(p, "NumSessionsRemote", t->NumSessionsRemote);\r
9446         PackAddInt(p, "NumTcpConnections", t->NumTcpConnections);\r
9447         PackAddInt(p, "NumTcpConnectionsLocal", t->NumTcpConnectionsLocal);\r
9448         PackAddInt(p, "NumTcpConnectionsRemote", t->NumTcpConnectionsRemote);\r
9449         PackAddInt(p, "NumMacTables", t->NumMacTables);\r
9450         PackAddInt(p, "NumIpTables", t->NumIpTables);\r
9451         PackAddInt(p, "NumUsers", t->NumUsers);\r
9452         PackAddInt(p, "NumGroups", t->NumGroups);\r
9453         PackAddInt64(p, "CurrentTime", t->CurrentTime);\r
9454         PackAddInt64(p, "CurrentTick", t->CurrentTick);\r
9455         PackAddInt(p, "AssignedBridgeLicenses", t->AssignedBridgeLicenses);\r
9456         PackAddInt(p, "AssignedClientLicenses", t->AssignedClientLicenses);\r
9457         PackAddInt(p, "AssignedBridgeLicensesTotal", t->AssignedBridgeLicensesTotal);\r
9458         PackAddInt(p, "AssignedClientLicensesTotal", t->AssignedClientLicensesTotal);\r
9459         PackAddInt64(p, "StartTime", t->StartTime);\r
9460 \r
9461         OutRpcTraffic(p, &t->Traffic);\r
9462 \r
9463         OutRpcMemInfo(p, &t->MemInfo);\r
9464 }\r
9465 \r
9466 // RPC_LISTENER\r
9467 void InRpcListener(RPC_LISTENER *t, PACK *p)\r
9468 {\r
9469         // 引数チェック\r
9470         if (t == NULL || p == NULL)\r
9471         {\r
9472                 return;\r
9473         }\r
9474 \r
9475         Zero(t, sizeof(RPC_LISTENER));\r
9476         t->Port = PackGetInt(p, "Port");\r
9477         t->Enable = PackGetBool(p, "Enable");\r
9478 }\r
9479 void OutRpcListener(PACK *p, RPC_LISTENER *t)\r
9480 {\r
9481         // 引数チェック\r
9482         if (t == NULL || p == NULL)\r
9483         {\r
9484                 return;\r
9485         }\r
9486 \r
9487         PackAddInt(p, "Port", t->Port);\r
9488         PackAddBool(p, "Enable", t->Enable);\r
9489 }\r
9490 \r
9491 // RPC_LISTENER_LIST\r
9492 void InRpcListenerList(RPC_LISTENER_LIST *t, PACK *p)\r
9493 {\r
9494         UINT i;\r
9495         // 引数チェック\r
9496         if (t == NULL || p == NULL)\r
9497         {\r
9498                 return;\r
9499         }\r
9500 \r
9501         Zero(t, sizeof(RPC_LISTENER_LIST));\r
9502         t->NumPort = PackGetIndexCount(p, "Ports");\r
9503         t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
9504         t->Enables = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
9505         t->Errors = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
9506         for (i = 0;i < t->NumPort;i++)\r
9507         {\r
9508                 t->Ports[i] = PackGetIntEx(p, "Ports", i);\r
9509                 t->Enables[i] = PackGetBoolEx(p, "Enables", i);\r
9510                 t->Errors[i] = PackGetBoolEx(p, "Errors", i);\r
9511         }\r
9512 }\r
9513 void OutRpcListenerList(PACK *p, RPC_LISTENER_LIST *t)\r
9514 {\r
9515         UINT i;\r
9516         // 引数チェック\r
9517         if (t == NULL || p == NULL)\r
9518         {\r
9519                 return;\r
9520         }\r
9521 \r
9522         for (i = 0;i < t->NumPort;i++)\r
9523         {\r
9524                 PackAddIntEx(p, "Ports", t->Ports[i], i, t->NumPort);\r
9525                 PackAddBoolEx(p, "Enables", t->Enables[i], i, t->NumPort);\r
9526                 PackAddBoolEx(p, "Errors", t->Errors[i], i, t->NumPort);\r
9527         }\r
9528 }\r
9529 void FreeRpcListenerList(RPC_LISTENER_LIST *t)\r
9530 {\r
9531         // 引数チェック\r
9532         if (t == NULL)\r
9533         {\r
9534                 return;\r
9535         }\r
9536 \r
9537         Free(t->Ports);\r
9538         Free(t->Enables);\r
9539         Free(t->Errors);\r
9540 }\r
9541 \r
9542 // RPC_STR\r
9543 void InRpcStr(RPC_STR *t, PACK *p)\r
9544 {\r
9545         UINT size = 65536;\r
9546         char *tmp = Malloc(size);\r
9547         // 引数チェック\r
9548         if (t == NULL || p == NULL)\r
9549         {\r
9550                 return;\r
9551         }\r
9552 \r
9553         Zero(t, sizeof(RPC_STR));\r
9554         if (PackGetStr(p, "String", tmp, size) == false)\r
9555         {\r
9556                 t->String = CopyStr("");\r
9557         }\r
9558         else\r
9559         {\r
9560                 t->String = CopyStr(tmp);\r
9561         }\r
9562         Free(tmp);\r
9563 }\r
9564 void OutRpcStr(PACK *p, RPC_STR *t)\r
9565 {\r
9566         // 引数チェック\r
9567         if (t == NULL || p == NULL)\r
9568         {\r
9569                 return;\r
9570         }\r
9571 \r
9572         PackAddStr(p, "String", t->String);\r
9573 }\r
9574 void FreeRpcStr(RPC_STR *t)\r
9575 {\r
9576         // 引数チェック\r
9577         if (t == NULL )\r
9578         {\r
9579                 return;\r
9580         }\r
9581 \r
9582         Free(t->String);\r
9583 }\r
9584 \r
9585 // RPC_SET_PASSWORD\r
9586 void InRpcSetPassword(RPC_SET_PASSWORD *t, PACK *p)\r
9587 {\r
9588         // 引数チェック\r
9589         if (t == NULL || p == NULL)\r
9590         {\r
9591                 return;\r
9592         }\r
9593 \r
9594         Zero(t, sizeof(RPC_SET_PASSWORD));\r
9595         PackGetData2(p, "HashedPassword", t->HashedPassword, sizeof(t->HashedPassword));\r
9596 }\r
9597 void OutRpcSetPassword(PACK *p, RPC_SET_PASSWORD *t)\r
9598 {\r
9599         // 引数チェック\r
9600         if (t == NULL || p == NULL)\r
9601         {\r
9602                 return;\r
9603         }\r
9604 \r
9605         PackAddData(p, "HashedPassword", t->HashedPassword, sizeof(t->HashedPassword));\r
9606 }\r
9607 \r
9608 // RPC_FARM\r
9609 void InRpcFarm(RPC_FARM *t, PACK *p)\r
9610 {\r
9611         UINT i;\r
9612         // 引数チェック\r
9613         if (t == NULL || p == NULL)\r
9614         {\r
9615                 return;\r
9616         }\r
9617 \r
9618         Zero(t, sizeof(RPC_FARM));\r
9619         t->ServerType = PackGetInt(p, "ServerType");\r
9620         t->NumPort = PackGetIndexCount(p, "Ports");\r
9621         t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
9622         for (i = 0;i < t->NumPort;i++)\r
9623         {\r
9624                 t->Ports[i] = PackGetIntEx(p, "Ports", i);\r
9625         }\r
9626         t->PublicIp = PackGetIp32(p, "PublicIp");\r
9627         PackGetStr(p, "ControllerName", t->ControllerName, sizeof(t->ControllerName));\r
9628         t->ControllerPort = PackGetInt(p, "ControllerPort");\r
9629         PackGetData2(p, "MemberPassword", t->MemberPassword, sizeof(t->MemberPassword));\r
9630         t->Weight = PackGetInt(p, "Weight");\r
9631         t->ControllerOnly = PackGetBool(p, "ControllerOnly");\r
9632 }\r
9633 void OutRpcFarm(PACK *p, RPC_FARM *t)\r
9634 {\r
9635         UINT i;\r
9636         // 引数チェック\r
9637         if (t == NULL || p == NULL)\r
9638         {\r
9639                 return;\r
9640         }\r
9641 \r
9642         PackAddInt(p, "ServerType", t->ServerType);\r
9643         for (i = 0;i < t->NumPort;i++)\r
9644         {\r
9645                 PackAddIntEx(p, "Ports", t->Ports[i], i, t->NumPort);\r
9646         }\r
9647         PackAddIp32(p, "PublicIp", t->PublicIp);\r
9648         PackAddStr(p, "ControllerName", t->ControllerName);\r
9649         PackAddInt(p, "ControllerPort", t->ControllerPort);\r
9650         PackAddData(p, "MemberPassword", t->MemberPassword, sizeof(t->MemberPassword));\r
9651         PackAddInt(p, "Weight", t->Weight);\r
9652         PackAddBool(p, "ControllerOnly", t->ControllerOnly);\r
9653 }\r
9654 void FreeRpcFarm(RPC_FARM *t)\r
9655 {\r
9656         // 引数チェック\r
9657         if (t == NULL)\r
9658         {\r
9659                 return;\r
9660         }\r
9661 \r
9662         Free(t->Ports);\r
9663 }\r
9664 \r
9665 // RPC_FARM_HUB\r
9666 void InRpcFarmHub(RPC_FARM_HUB *t, PACK *p)\r
9667 {\r
9668         // 引数チェック\r
9669         if (t == NULL || p == NULL)\r
9670         {\r
9671                 return;\r
9672         }\r
9673 \r
9674         Zero(t, sizeof(RPC_FARM_HUB));\r
9675         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
9676         t->DynamicHub = PackGetBool(p, "DynamicHub");\r
9677 }\r
9678 void OutRpcFarmHub(PACK *p, RPC_FARM_HUB *t)\r
9679 {\r
9680         // 引数チェック\r
9681         if (t == NULL || p == NULL)\r
9682         {\r
9683                 return;\r
9684         }\r
9685 \r
9686         PackAddStr(p, "HubName", t->HubName);\r
9687         PackAddBool(p, "DynamicHub", t->DynamicHub);\r
9688 }\r
9689 \r
9690 // RPC_FARM_INFO\r
9691 void InRpcFarmInfo(RPC_FARM_INFO *t, PACK *p)\r
9692 {\r
9693         UINT i;\r
9694         // 引数チェック\r
9695         if (t == NULL)\r
9696         {\r
9697                 return;\r
9698         }\r
9699 \r
9700         Zero(t, sizeof(RPC_FARM_INFO));\r
9701         t->Id = PackGetInt(p, "Id");\r
9702         t->Controller = PackGetBool(p, "Controller");\r
9703         t->ConnectedTime = PackGetInt64(p, "ConnectedTime");\r
9704         t->Ip = PackGetIp32(p, "Ip");\r
9705         PackGetStr(p, "Hostname", t->Hostname, sizeof(t->Hostname));\r
9706         t->Point = PackGetInt(p, "Point");\r
9707         t->NumPort = PackGetIndexCount(p, "Ports");\r
9708         t->Ports = ZeroMalloc(sizeof(UINT) * t->NumPort);\r
9709         for (i = 0;i < t->NumPort;i++)\r
9710         {\r
9711                 t->Ports[i] = PackGetIntEx(p, "Ports", i);\r
9712         }\r
9713         t->ServerCert = PackGetX(p, "ServerCert");\r
9714         t->NumFarmHub = PackGetIndexCount(p, "HubName");\r
9715         t->FarmHubs = ZeroMalloc(sizeof(RPC_FARM_HUB) * t->NumFarmHub);\r
9716         for (i = 0;i < t->NumFarmHub;i++)\r
9717         {\r
9718                 PackGetStrEx(p, "HubName", t->FarmHubs[i].HubName, sizeof(t->FarmHubs[i].HubName), i);\r
9719                 t->FarmHubs[i].DynamicHub = PackGetBoolEx(p, "DynamicHub", i);\r
9720         }\r
9721         t->NumSessions = PackGetInt(p, "NumSessions");\r
9722         t->NumTcpConnections = PackGetInt(p, "NumTcpConnections");\r
9723         t->Weight = PackGetInt(p, "Weight");\r
9724 }\r
9725 void OutRpcFarmInfo(PACK *p, RPC_FARM_INFO *t)\r
9726 {\r
9727         UINT i;\r
9728         // 引数チェック\r
9729         if (t == NULL || p == NULL)\r
9730         {\r
9731                 return;\r
9732         }\r
9733 \r
9734         PackAddInt(p, "Id", t->Id);\r
9735         PackAddBool(p, "Controller", t->Controller);\r
9736         PackAddInt64(p, "ConnectedTime", t->ConnectedTime);\r
9737         PackAddIp32(p, "Ip", t->Ip);\r
9738         PackAddStr(p, "Hostname", t->Hostname);\r
9739         PackAddInt(p, "Point", t->Point);\r
9740         for (i = 0;i < t->NumPort;i++)\r
9741         {\r
9742                 PackAddIntEx(p, "Ports", t->Ports[i], i, t->NumPort);\r
9743         }\r
9744         PackAddX(p, "ServerCert", t->ServerCert);\r
9745         for (i = 0;i < t->NumFarmHub;i++)\r
9746         {\r
9747                 PackAddStrEx(p, "HubName", t->FarmHubs[i].HubName, i, t->NumFarmHub);\r
9748                 PackAddBoolEx(p, "DynamicHub", t->FarmHubs[i].DynamicHub, i, t->NumFarmHub);\r
9749         }\r
9750         PackAddInt(p, "NumSessions", t->NumSessions);\r
9751         PackAddInt(p, "NumTcpConnections", t->NumTcpConnections);\r
9752         PackAddInt(p, "Weight", t->Weight);\r
9753 }\r
9754 void FreeRpcFarmInfo(RPC_FARM_INFO *t)\r
9755 {\r
9756         // 引数チェック\r
9757         if (t == NULL)\r
9758         {\r
9759                 return;\r
9760         }\r
9761 \r
9762         Free(t->Ports);\r
9763         Free(t->FarmHubs);\r
9764         FreeX(t->ServerCert);\r
9765 }\r
9766 \r
9767 void InRpcEnumFarm(RPC_ENUM_FARM *t, PACK *p)\r
9768 {\r
9769         UINT i;\r
9770         // 引数チェック\r
9771         if (t == NULL || p == NULL)\r
9772         {\r
9773                 return;\r
9774         }\r
9775 \r
9776         Zero(t, sizeof(RPC_ENUM_FARM));\r
9777         t->NumFarm = PackGetIndexCount(p, "Id");\r
9778         t->Farms = ZeroMalloc(sizeof(RPC_ENUM_FARM_ITEM) * t->NumFarm);\r
9779 \r
9780         for (i = 0;i < t->NumFarm;i++)\r
9781         {\r
9782                 RPC_ENUM_FARM_ITEM *e = &t->Farms[i];\r
9783 \r
9784                 e->Id = PackGetIntEx(p, "Id", i);\r
9785                 e->Controller = PackGetBoolEx(p, "Controller", i);\r
9786                 e->ConnectedTime = PackGetInt64Ex(p, "ConnectedTime", i);\r
9787                 e->Ip = PackGetIp32Ex(p, "Ip", i);\r
9788                 PackGetStrEx(p, "Hostname", e->Hostname, sizeof(e->Hostname), i);\r
9789                 e->Point = PackGetIntEx(p, "Point", i);\r
9790                 e->NumSessions = PackGetIntEx(p, "NumSessions", i);\r
9791                 e->NumTcpConnections = PackGetIntEx(p, "NumTcpConnections", i);\r
9792                 e->NumHubs = PackGetIntEx(p, "NumHubs", i);\r
9793                 e->AssignedClientLicense = PackGetIntEx(p, "AssignedClientLicense", i);\r
9794                 e->AssignedBridgeLicense = PackGetIntEx(p, "AssignedBridgeLicense", i);\r
9795         }\r
9796 }\r
9797 void OutRpcEnumFarm(PACK *p, RPC_ENUM_FARM *t)\r
9798 {\r
9799         UINT i;\r
9800         // 引数チェック\r
9801         if (t == NULL || p == NULL)\r
9802         {\r
9803                 return;\r
9804         }\r
9805 \r
9806         for (i = 0;i < t->NumFarm;i++)\r
9807         {\r
9808                 RPC_ENUM_FARM_ITEM *e = &t->Farms[i];\r
9809 \r
9810                 PackAddIntEx(p, "Id", e->Id, i, t->NumFarm);\r
9811                 PackAddBoolEx(p, "Controller", e->Controller, i, t->NumFarm);\r
9812                 PackAddInt64Ex(p, "ConnectedTime", e->ConnectedTime, i, t->NumFarm);\r
9813                 PackAddIp32Ex(p, "Ip", e->Ip, i, t->NumFarm);\r
9814                 PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumFarm);\r
9815                 PackAddIntEx(p, "Point", e->Point, i, t->NumFarm);\r
9816                 PackAddIntEx(p, "NumSessions", e->NumSessions, i, t->NumFarm);\r
9817                 PackAddIntEx(p, "NumTcpConnections", e->NumTcpConnections, i, t->NumFarm);\r
9818                 PackAddIntEx(p, "NumHubs", e->NumHubs, i, t->NumFarm);\r
9819                 PackAddIntEx(p, "AssignedClientLicense", e->AssignedClientLicense, i, t->NumFarm);\r
9820                 PackAddIntEx(p, "AssignedBridgeLicense", e->AssignedBridgeLicense, i, t->NumFarm);\r
9821         }\r
9822 }\r
9823 void FreeRpcEnumFarm(RPC_ENUM_FARM *t)\r
9824 {\r
9825         // 引数チェック\r
9826         if (t == NULL)\r
9827         {\r
9828                 return;\r
9829         }\r
9830 \r
9831         Free(t->Farms);\r
9832 }\r
9833 \r
9834 // RPC_FARM_CONNECTION_STATUS\r
9835 void InRpcFarmConnectionStatus(RPC_FARM_CONNECTION_STATUS *t, PACK *p)\r
9836 {\r
9837         Zero(t, sizeof(RPC_FARM_CONNECTION_STATUS));\r
9838         // 引数チェック\r
9839         if (t == NULL || p == NULL)\r
9840         {\r
9841                 return;\r
9842         }\r
9843 \r
9844         t->Ip = PackGetIp32(p, "Ip");\r
9845         t->Port = PackGetInt(p, "Port");\r
9846         t->Online = PackGetBool(p, "Online");\r
9847         t->LastError = PackGetInt(p, "LastError");\r
9848         t->StartedTime = PackGetInt64(p, "StartedTime");\r
9849         t->CurrentConnectedTime = PackGetInt64(p, "CurrentConnectedTime");\r
9850         t->FirstConnectedTime = PackGetInt64(p, "FirstConnectedTime");\r
9851         t->NumConnected = PackGetInt(p, "NumConnected");\r
9852         t->NumTry = PackGetInt(p, "NumTry");\r
9853         t->NumFailed = PackGetInt(p, "NumFailed");\r
9854 }\r
9855 void OutRpcFarmConnectionStatus(PACK *p, RPC_FARM_CONNECTION_STATUS *t)\r
9856 {\r
9857         // 引数チェック\r
9858         if (t == NULL || p == NULL)\r
9859         {\r
9860                 return;\r
9861         }\r
9862 \r
9863         PackAddIp32(p, "Ip", t->Ip);\r
9864         PackAddInt(p, "Port", t->Port);\r
9865         PackAddBool(p, "Online", t->Online);\r
9866         PackAddInt(p, "LastError", t->LastError);\r
9867         PackAddInt64(p, "StartedTime", t->StartedTime);\r
9868         PackAddInt64(p, "CurrentConnectedTime", t->CurrentConnectedTime);\r
9869         PackAddInt64(p, "FirstConnectedTime", t->FirstConnectedTime);\r
9870         PackAddInt(p, "NumConnected", t->NumConnected);\r
9871         PackAddInt(p, "NumTry", t->NumTry);\r
9872         PackAddInt(p, "NumFailed", t->NumFailed);\r
9873 }\r
9874 \r
9875 // RPC_HUB_OPTION\r
9876 void InRpcHubOption(RPC_HUB_OPTION *t, PACK *p)\r
9877 {\r
9878         // 引数チェック\r
9879         if (t == NULL || p == NULL)\r
9880         {\r
9881                 return;\r
9882         }\r
9883 \r
9884         Zero(t, sizeof(RPC_HUB_OPTION));\r
9885         t->MaxSession = PackGetInt(p, "MaxSession");\r
9886         t->NoEnum = PackGetBool(p, "NoEnum");\r
9887 }\r
9888 void OutRpcHubOption(PACK *p, RPC_HUB_OPTION *t)\r
9889 {\r
9890         // 引数チェック\r
9891         if (t == NULL || p == NULL)\r
9892         {\r
9893                 return;\r
9894         }\r
9895 \r
9896         PackAddInt(p, "MaxSession", t->MaxSession);\r
9897         PackAddBool(p, "NoEnum", t->NoEnum);\r
9898 }\r
9899 \r
9900 // RPC_RADIUS\r
9901 void InRpcRadius(RPC_RADIUS *t, PACK *p)\r
9902 {\r
9903         // 引数チェック\r
9904         if (t == NULL || p == NULL)\r
9905         {\r
9906                 return;\r
9907         }\r
9908 \r
9909         Zero(t, sizeof(RPC_RADIUS));\r
9910         PackGetStr(p, "RadiusServerName", t->RadiusServerName, sizeof(t->RadiusServerName));\r
9911         t->RadiusPort = PackGetInt(p, "RadiusPort");\r
9912         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
9913         PackGetStr(p, "RadiusSecret", t->RadiusSecret, sizeof(t->RadiusSecret));\r
9914         t->RadiusRetryInterval = PackGetInt(p, "RadiusRetryInterval");\r
9915 }\r
9916 void OutRpcRadius(PACK *p, RPC_RADIUS *t)\r
9917 {\r
9918         // 引数チェック\r
9919         if (t == NULL || p == NULL)\r
9920         {\r
9921                 return;\r
9922         }\r
9923 \r
9924         PackAddStr(p, "RadiusServerName", t->RadiusServerName);\r
9925         PackAddInt(p, "RadiusPort", t->RadiusPort);\r
9926         PackAddStr(p, "HubName", t->HubName);\r
9927         PackAddStr(p, "RadiusSecret", t->RadiusSecret);\r
9928         PackAddInt(p, "RadiusRetryInterval", t->RadiusRetryInterval);\r
9929 }\r
9930 \r
9931 // RPC_HUB\r
9932 void InRpcHub(RPC_HUB *t, PACK *p)\r
9933 {\r
9934         // 引数チェック\r
9935         if (t == NULL || p == NULL)\r
9936         {\r
9937                 return;\r
9938         }\r
9939 \r
9940         Zero(t, sizeof(RPC_HUB));\r
9941         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
9942 }\r
9943 void OutRpcHub(PACK *p, RPC_HUB *t)\r
9944 {\r
9945         // 引数チェック\r
9946         if (t == NULL || p == NULL)\r
9947         {\r
9948                 return;\r
9949         }\r
9950 \r
9951         PackAddStr(p, "HubName", t->HubName);\r
9952 }\r
9953 \r
9954 // RPC_CREATE_HUB\r
9955 void InRpcCreateHub(RPC_CREATE_HUB *t, PACK *p)\r
9956 {\r
9957         // 引数チェック\r
9958         if (t == NULL || p == NULL)\r
9959         {\r
9960                 return;\r
9961         }\r
9962 \r
9963         Zero(t, sizeof(RPC_CREATE_HUB));\r
9964         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
9965         PackGetData2(p, "HashedPassword", t->HashedPassword, sizeof(t->HashedPassword));\r
9966         PackGetData2(p, "SecurePassword", t->SecurePassword, sizeof(t->SecurePassword));\r
9967         t->Online = PackGetBool(p, "Online");\r
9968         InRpcHubOption(&t->HubOption, p);\r
9969         t->HubType = PackGetInt(p, "HubType");\r
9970 }\r
9971 void OutRpcCreateHub(PACK *p, RPC_CREATE_HUB *t)\r
9972 {\r
9973         // 引数チェック\r
9974         if (t == NULL || p == NULL)\r
9975         {\r
9976                 return;\r
9977         }\r
9978 \r
9979         PackAddStr(p, "HubName", t->HubName);\r
9980         PackAddData(p, "HashedPassword", t->HashedPassword, sizeof(t->HashedPassword));\r
9981         PackAddData(p, "SecurePassword", t->SecurePassword, sizeof(t->SecurePassword));\r
9982         PackAddBool(p, "Online", t->Online);\r
9983         OutRpcHubOption(p, &t->HubOption);\r
9984         PackAddInt(p, "HubType", t->HubType);\r
9985 }\r
9986 \r
9987 // RPC_ENUM_HUB\r
9988 void InRpcEnumHub(RPC_ENUM_HUB *t, PACK *p)\r
9989 {\r
9990         UINT i;\r
9991         // 引数チェック\r
9992         if (t == NULL || p == NULL)\r
9993         {\r
9994                 return;\r
9995         }\r
9996 \r
9997         Zero(t, sizeof(RPC_ENUM_HUB));\r
9998         t->NumHub = PackGetIndexCount(p, "HubName");\r
9999         t->Hubs = ZeroMalloc(sizeof(RPC_ENUM_HUB_ITEM) * t->NumHub);\r
10000 \r
10001         for (i = 0;i < t->NumHub;i++)\r
10002         {\r
10003                 RPC_ENUM_HUB_ITEM *e = &t->Hubs[i];\r
10004 \r
10005                 PackGetStrEx(p, "HubName", e->HubName, sizeof(e->HubName), i);\r
10006                 e->Online = PackGetBoolEx(p, "Online", i);\r
10007                 e->HubType = PackGetIntEx(p, "HubType", i);\r
10008                 e->NumSessions = PackGetIntEx(p, "NumSessions", i);\r
10009                 e->NumUsers = PackGetIntEx(p, "NumUsers", i);\r
10010                 e->NumGroups = PackGetIntEx(p, "NumGroups", i);\r
10011                 e->NumMacTables = PackGetIntEx(p, "NumMacTables", i);\r
10012                 e->NumIpTables = PackGetIntEx(p, "NumIpTables", i);\r
10013                 e->LastCommTime = PackGetInt64Ex(p, "LastCommTime", i);\r
10014                 e->CreatedTime = PackGetInt64Ex(p, "CreatedTime", i);\r
10015                 e->LastLoginTime = PackGetInt64Ex(p, "LastLoginTime", i);\r
10016                 e->NumLogin = PackGetIntEx(p, "NumLogin", i);\r
10017         }\r
10018 }\r
10019 void OutRpcEnumHub(PACK *p, RPC_ENUM_HUB *t)\r
10020 {\r
10021         UINT i;\r
10022         // 引数チェック\r
10023         if (t == NULL || p == NULL)\r
10024         {\r
10025                 return;\r
10026         }\r
10027 \r
10028         for (i = 0;i < t->NumHub;i++)\r
10029         {\r
10030                 RPC_ENUM_HUB_ITEM *e = &t->Hubs[i];\r
10031 \r
10032                 PackAddStrEx(p, "HubName", e->HubName, i, t->NumHub);\r
10033                 PackAddBoolEx(p, "Online", e->Online, i, t->NumHub);\r
10034                 PackAddIntEx(p, "HubType", e->HubType, i, t->NumHub);\r
10035                 PackAddIntEx(p, "NumSessions", e->NumSessions, i, t->NumHub);\r
10036                 PackAddIntEx(p, "NumUsers", e->NumUsers, i, t->NumHub);\r
10037                 PackAddIntEx(p, "NumGroups", e->NumGroups, i, t->NumHub);\r
10038                 PackAddIntEx(p, "NumMacTables", e->NumMacTables, i, t->NumHub);\r
10039                 PackAddIntEx(p, "NumIpTables", e->NumIpTables, i, t->NumHub);\r
10040                 PackAddInt64Ex(p, "LastCommTime", e->LastCommTime, i, t->NumHub);\r
10041                 PackAddInt64Ex(p, "CreatedTime", e->CreatedTime, i, t->NumHub);\r
10042                 PackAddInt64Ex(p, "LastLoginTime", e->LastLoginTime, i, t->NumHub);\r
10043                 PackAddIntEx(p, "NumLogin", e->NumLogin, i, t->NumHub);\r
10044         }\r
10045 }\r
10046 void FreeRpcEnumHub(RPC_ENUM_HUB *t)\r
10047 {\r
10048         // 引数チェック\r
10049         if (t == NULL)\r
10050         {\r
10051                 return;\r
10052         }\r
10053 \r
10054         Free(t->Hubs);\r
10055 }\r
10056 \r
10057 // RPC_DELETE_HUB\r
10058 void InRpcDeleteHub(RPC_DELETE_HUB *t, PACK *p)\r
10059 {\r
10060         // 引数チェック\r
10061         if (t == NULL || p == NULL)\r
10062         {\r
10063                 return;\r
10064         }\r
10065 \r
10066         Zero(t, sizeof(RPC_DELETE_HUB));\r
10067         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10068 }\r
10069 void OutRpcDeleteHub(PACK *p, RPC_DELETE_HUB *t)\r
10070 {\r
10071         // 引数チェック\r
10072         if (t == NULL || p == NULL)\r
10073         {\r
10074                 return;\r
10075         }\r
10076 \r
10077         PackAddStr(p, "HubName", t->HubName);\r
10078 }\r
10079 \r
10080 // RPC_ENUM_CONNECTION\r
10081 void InRpcEnumConnection(RPC_ENUM_CONNECTION *t, PACK *p)\r
10082 {\r
10083         UINT i;\r
10084         // 引数チェック\r
10085         if (t == NULL || p == NULL)\r
10086         {\r
10087                 return;\r
10088         }\r
10089 \r
10090         Zero(t, sizeof(RPC_ENUM_CONNECTION));\r
10091         t->NumConnection = PackGetIndexCount(p, "Name");\r
10092         t->Connections = ZeroMalloc(sizeof(RPC_ENUM_CONNECTION_ITEM) * t->NumConnection);\r
10093 \r
10094         for (i = 0;i < t->NumConnection;i++)\r
10095         {\r
10096                 RPC_ENUM_CONNECTION_ITEM *e = &t->Connections[i];\r
10097 \r
10098                 e->Ip = PackGetIp32Ex(p, "Ip", i);\r
10099                 e->Port = PackGetIntEx(p, "Port", i);\r
10100                 PackGetStrEx(p, "Name", e->Name, sizeof(e->Name), i);\r
10101                 PackGetStrEx(p, "Hostname", e->Hostname, sizeof(e->Hostname), i);\r
10102                 e->ConnectedTime = PackGetInt64Ex(p, "ConnectedTime", i);\r
10103                 e->Type = PackGetIntEx(p, "Type", i);\r
10104         }\r
10105 }\r
10106 void OutRpcEnumConnection(PACK *p, RPC_ENUM_CONNECTION *t)\r
10107 {\r
10108         UINT i;\r
10109         // 引数チェック\r
10110         if (t == NULL || p == NULL)\r
10111         {\r
10112                 return;\r
10113         }\r
10114 \r
10115         for (i = 0;i < t->NumConnection;i++)\r
10116         {\r
10117                 RPC_ENUM_CONNECTION_ITEM *e = &t->Connections[i];\r
10118 \r
10119                 PackAddIp32Ex(p, "Ip", e->Ip, i, t->NumConnection);\r
10120                 PackAddIntEx(p, "Port", e->Port, i, t->NumConnection);\r
10121                 PackAddStrEx(p, "Name", e->Name, i, t->NumConnection);\r
10122                 PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumConnection);\r
10123                 PackAddInt64Ex(p, "ConnectedTime", e->ConnectedTime, i, t->NumConnection);\r
10124                 PackAddIntEx(p, "Type", e->Type, i, t->NumConnection);\r
10125         }\r
10126 }\r
10127 void FreeRpcEnumConnetion(RPC_ENUM_CONNECTION *t)\r
10128 {\r
10129         // 引数チェック\r
10130         if (t == NULL)\r
10131         {\r
10132                 return;\r
10133         }\r
10134 \r
10135         Free(t->Connections);\r
10136 }\r
10137 \r
10138 // RPC_DISCONNECT_CONNECTION\r
10139 void InRpcDisconnectConnection(RPC_DISCONNECT_CONNECTION *t, PACK *p)\r
10140 {\r
10141         // 引数チェック\r
10142         if (t == NULL || p == NULL)\r
10143         {\r
10144                 return;\r
10145         }\r
10146 \r
10147         Zero(t, sizeof(RPC_DISCONNECT_CONNECTION));\r
10148         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
10149 }\r
10150 void OutRpcDisconnectConnection(PACK *p, RPC_DISCONNECT_CONNECTION *t)\r
10151 {\r
10152         // 引数チェック\r
10153         if (t == NULL || p == NULL)\r
10154         {\r
10155                 return;\r
10156         }\r
10157 \r
10158         PackAddStr(p, "Name", t->Name);\r
10159 }\r
10160 \r
10161 // RPC_CONNECTION_INFO\r
10162 void InRpcConnectionInfo(RPC_CONNECTION_INFO *t, PACK *p)\r
10163 {\r
10164         // 引数チェック\r
10165         if (t == NULL || p == NULL)\r
10166         {\r
10167                 return;\r
10168         }\r
10169 \r
10170         Zero(t, sizeof(RPC_CONNECTION_INFO));\r
10171         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
10172         t->Ip = PackGetIp32(p, "Ip");\r
10173         t->Port = PackGetInt(p, "Port");\r
10174         t->ConnectedTime = PackGetInt64(p, "ConnectedTime");\r
10175         PackGetStr(p, "Hostname", t->Hostname, sizeof(t->Hostname));\r
10176         PackGetStr(p, "ServerStr", t->ServerStr, sizeof(t->ServerStr));\r
10177         PackGetStr(p, "ClientStr", t->ClientStr, sizeof(t->ClientStr));\r
10178         t->ServerVer = PackGetInt(p, "ServerVer");\r
10179         t->ServerBuild = PackGetInt(p, "ServerBuild");\r
10180         t->ClientVer = PackGetInt(p, "ClientVer");\r
10181         t->ClientBuild = PackGetInt(p, "ClientBuild");\r
10182         t->Type = PackGetInt(p, "Type");\r
10183 }\r
10184 void OutRpcConnectionInfo(PACK *p, RPC_CONNECTION_INFO *t)\r
10185 {\r
10186         // 引数チェック\r
10187         if (t == NULL || p == NULL)\r
10188         {\r
10189                 return;\r
10190         }\r
10191 \r
10192         PackAddStr(p, "Name", t->Name);\r
10193         PackAddIp32(p, "Ip", t->Ip);\r
10194         PackAddInt(p, "Port", t->Port);\r
10195         PackAddInt64(p, "ConnectedTime", t->ConnectedTime);\r
10196         PackAddStr(p, "Hostname", t->Hostname);\r
10197         PackAddStr(p, "ServerStr", t->ServerStr);\r
10198         PackAddStr(p, "ClientStr", t->ClientStr);\r
10199         PackAddInt(p, "ServerVer", t->ServerVer);\r
10200         PackAddInt(p, "ServerBuild", t->ServerBuild);\r
10201         PackAddInt(p, "ClientVer", t->ClientVer);\r
10202         PackAddInt(p, "ClientBuild", t->ClientBuild);\r
10203         PackAddInt(p, "Type", t->Type);\r
10204 }\r
10205 \r
10206 // RPC_SET_HUB_ONLINE\r
10207 void InRpcSetHubOnline(RPC_SET_HUB_ONLINE *t, PACK *p)\r
10208 {\r
10209         // 引数チェック\r
10210         if (t == NULL || p == NULL)\r
10211         {\r
10212                 return;\r
10213         }\r
10214 \r
10215         Zero(t, sizeof(RPC_SET_HUB_ONLINE));\r
10216         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10217         t->Online = PackGetBool(p, "Online");\r
10218 }\r
10219 void OutRpcSetHubOnline(PACK *p, RPC_SET_HUB_ONLINE *t)\r
10220 {\r
10221         // 引数チェック\r
10222         if (t == NULL || p == NULL)\r
10223         {\r
10224                 return;\r
10225         }\r
10226 \r
10227         PackAddStr(p, "HubName", t->HubName);\r
10228         PackAddBool(p, "Online", t->Online);\r
10229 }\r
10230 \r
10231 // RPC_HUB_STATUS\r
10232 void InRpcHubStatus(RPC_HUB_STATUS *t, PACK *p)\r
10233 {\r
10234         Zero(t, sizeof(RPC_HUB_STATUS));\r
10235         // 引数チェック\r
10236         if (t == NULL || p == NULL)\r
10237         {\r
10238                 return;\r
10239         }\r
10240 \r
10241         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10242         t->Online = PackGetBool(p, "Online");\r
10243         t->HubType = PackGetInt(p, "HubType");\r
10244         t->NumSessions = PackGetInt(p, "NumSessions");\r
10245         t->NumSessionsClient = PackGetInt(p, "NumSessionsClient");\r
10246         t->NumSessionsBridge = PackGetInt(p, "NumSessionsBridge");\r
10247         t->NumAccessLists = PackGetInt(p, "NumAccessLists");\r
10248         t->NumUsers = PackGetInt(p, "NumUsers");\r
10249         t->NumGroups = PackGetInt(p, "NumGroups");\r
10250         t->NumMacTables = PackGetInt(p, "NumMacTables");\r
10251         t->NumIpTables = PackGetInt(p, "NumIpTables");\r
10252         t->SecureNATEnabled = PackGetBool(p, "SecureNATEnabled");\r
10253         InRpcTraffic(&t->Traffic, p);\r
10254         t->LastCommTime = PackGetInt64(p, "LastCommTime");\r
10255         t->CreatedTime = PackGetInt64(p, "CreatedTime");\r
10256         t->LastLoginTime = PackGetInt64(p, "LastLoginTime");\r
10257         t->NumLogin = PackGetInt(p, "NumLogin");\r
10258 }\r
10259 void OutRpcHubStatus(PACK *p, RPC_HUB_STATUS *t)\r
10260 {\r
10261         // 引数チェック\r
10262         if (t == NULL || p == NULL)\r
10263         {\r
10264                 return;\r
10265         }\r
10266 \r
10267         PackAddStr(p, "HubName", t->HubName);\r
10268         PackAddBool(p, "Online", t->Online);\r
10269         PackAddInt(p, "HubType", t->HubType);\r
10270         PackAddInt(p, "NumSessions", t->NumSessions);\r
10271         PackAddInt(p, "NumSessionsClient", t->NumSessionsClient);\r
10272         PackAddInt(p, "NumSessionsBridge", t->NumSessionsBridge);\r
10273         PackAddInt(p, "NumAccessLists", t->NumAccessLists);\r
10274         PackAddInt(p, "NumUsers", t->NumUsers);\r
10275         PackAddInt(p, "NumGroups", t->NumGroups);\r
10276         PackAddInt(p, "NumMacTables", t->NumMacTables);\r
10277         PackAddInt(p, "NumIpTables", t->NumIpTables);\r
10278         PackAddBool(p, "SecureNATEnabled", t->SecureNATEnabled);\r
10279         OutRpcTraffic(p, &t->Traffic);\r
10280         PackAddInt64(p, "LastCommTime", t->LastCommTime);\r
10281         PackAddInt64(p, "CreatedTime", t->CreatedTime);\r
10282         PackAddInt64(p, "LastLoginTime", t->LastLoginTime);\r
10283         PackAddInt(p, "NumLogin", t->NumLogin);\r
10284 }\r
10285 \r
10286 // RPC_HUB_LOG\r
10287 void InRpcHubLog(RPC_HUB_LOG *t, PACK *p)\r
10288 {\r
10289         UINT i;\r
10290         // 引数チェック\r
10291         if (t == NULL || p == NULL)\r
10292         {\r
10293                 return;\r
10294         }\r
10295 \r
10296         Zero(t, sizeof(RPC_HUB_LOG));\r
10297         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10298         t->LogSetting.SaveSecurityLog = PackGetBool(p, "SaveSecurityLog");\r
10299         t->LogSetting.SecurityLogSwitchType = PackGetInt(p, "SecurityLogSwitchType");\r
10300         t->LogSetting.SavePacketLog = PackGetBool(p, "SavePacketLog");\r
10301         t->LogSetting.PacketLogSwitchType = PackGetInt(p, "PacketLogSwitchType");\r
10302         for (i = 0;i < NUM_PACKET_LOG;i++)\r
10303         {\r
10304                 t->LogSetting.PacketLogConfig[i] = PackGetIntEx(p, "PacketLogConfig", i);\r
10305         }\r
10306 }\r
10307 void OutRpcHubLog(PACK *p, RPC_HUB_LOG *t)\r
10308 {\r
10309         UINT i;\r
10310         // 引数チェック\r
10311         if (t == NULL || p == NULL)\r
10312         {\r
10313                 return;\r
10314         }\r
10315 \r
10316         PackAddStr(p, "HubName", t->HubName);\r
10317         PackAddBool(p, "SaveSecurityLog", t->LogSetting.SaveSecurityLog);\r
10318         PackAddInt(p, "SecurityLogSwitchType", t->LogSetting.SecurityLogSwitchType);\r
10319         PackAddBool(p, "SavePacketLog", t->LogSetting.SavePacketLog);\r
10320         PackAddInt(p, "PacketLogSwitchType", t->LogSetting.PacketLogSwitchType);\r
10321         for (i = 0;i < NUM_PACKET_LOG;i++)\r
10322         {\r
10323                 PackAddIntEx(p, "PacketLogConfig", t->LogSetting.PacketLogConfig[i], i, NUM_PACKET_LOG);\r
10324         }\r
10325 }\r
10326 \r
10327 // RPC_HUB_ADD_CA\r
10328 void InRpcHubAddCa(RPC_HUB_ADD_CA *t, PACK *p)\r
10329 {\r
10330         // 引数チェック\r
10331         if (t == NULL || p == NULL)\r
10332         {\r
10333                 return;\r
10334         }\r
10335 \r
10336         Zero(t, sizeof(RPC_HUB_ADD_CA));\r
10337         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10338         t->Cert = PackGetX(p, "Cert");\r
10339 }\r
10340 void OutRpcHubAddCa(PACK *p, RPC_HUB_ADD_CA *t)\r
10341 {\r
10342         // 引数チェック\r
10343         if (t == NULL || p == NULL)\r
10344         {\r
10345                 return;\r
10346         }\r
10347 \r
10348         PackAddStr(p, "HubName", t->HubName);\r
10349         PackAddX(p, "Cert", t->Cert);\r
10350 }\r
10351 void FreeRpcHubAddCa(RPC_HUB_ADD_CA *t)\r
10352 {\r
10353         // 引数チェック\r
10354         if (t == NULL)\r
10355         {\r
10356                 return;\r
10357         }\r
10358 \r
10359         FreeX(t->Cert);\r
10360 }\r
10361 \r
10362 // RPC_HUB_ENUM_CA\r
10363 void InRpcHubEnumCa(RPC_HUB_ENUM_CA *t, PACK *p)\r
10364 {\r
10365         UINT i;\r
10366         // 引数チェック\r
10367         if (t == NULL || p == NULL)\r
10368         {\r
10369                 return;\r
10370         }\r
10371 \r
10372         Zero(t, sizeof(RPC_HUB_ENUM_CA));\r
10373         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10374         t->NumCa = PackGetIndexCount(p, "Key");\r
10375         t->Ca = ZeroMalloc(sizeof(RPC_HUB_ENUM_CA_ITEM) * t->NumCa);\r
10376 \r
10377         for (i = 0;i < t->NumCa;i++)\r
10378         {\r
10379                 RPC_HUB_ENUM_CA_ITEM *e = &t->Ca[i];\r
10380 \r
10381                 e->Key = PackGetIntEx(p, "Key", i);\r
10382                 PackGetUniStrEx(p, "SubjectName", e->SubjectName, sizeof(e->SubjectName), i);\r
10383                 PackGetUniStrEx(p, "IssuerName", e->IssuerName, sizeof(e->IssuerName), i);\r
10384                 e->Expires = PackGetInt64Ex(p, "Expires", i);\r
10385         }\r
10386 }\r
10387 void OutRpcHubEnumCa(PACK *p, RPC_HUB_ENUM_CA *t)\r
10388 {\r
10389         UINT i;\r
10390         PackAddStr(p, "HubName", t->HubName);\r
10391         // 引数チェック\r
10392         if (t == NULL || p == NULL)\r
10393         {\r
10394                 return;\r
10395         }\r
10396 \r
10397         for (i = 0;i < t->NumCa;i++)\r
10398         {\r
10399                 RPC_HUB_ENUM_CA_ITEM *e = &t->Ca[i];\r
10400 \r
10401                 PackAddIntEx(p, "Key", e->Key, i, t->NumCa);\r
10402                 PackAddUniStrEx(p, "SubjectName", e->SubjectName, i, t->NumCa);\r
10403                 PackAddUniStrEx(p, "IssuerName", e->IssuerName, i, t->NumCa);\r
10404                 PackAddInt64Ex(p, "Expires", e->Expires, i, t->NumCa);\r
10405         }\r
10406 }\r
10407 void FreeRpcHubEnumCa(RPC_HUB_ENUM_CA *t)\r
10408 {\r
10409         // 引数チェック\r
10410         if (t == NULL)\r
10411         {\r
10412                 return;\r
10413         }\r
10414 \r
10415         Free(t->Ca);\r
10416 }\r
10417 \r
10418 // RPC_HUB_GET_CA\r
10419 void InRpcHubGetCa(RPC_HUB_GET_CA *t, PACK *p)\r
10420 {\r
10421         // 引数チェック\r
10422         if (t == NULL || p == NULL)\r
10423         {\r
10424                 return;\r
10425         }\r
10426 \r
10427         Zero(t, sizeof(RPC_HUB_GET_CA));\r
10428         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10429         t->Key = PackGetInt(p, "Key");\r
10430         t->Cert = PackGetX(p, "Cert");\r
10431 }\r
10432 void OutRpcHubGetCa(PACK *p, RPC_HUB_GET_CA *t)\r
10433 {\r
10434         // 引数チェック\r
10435         if (t == NULL || p == NULL)\r
10436         {\r
10437                 return;\r
10438         }\r
10439 \r
10440         PackAddStr(p, "HubName", t->HubName);\r
10441         PackAddInt(p, "Key", t->Key);\r
10442         PackAddX(p, "Cert", t->Cert);\r
10443 }\r
10444 void FreeRpcHubGetCa(RPC_HUB_GET_CA *t)\r
10445 {\r
10446         // 引数チェック\r
10447         if (t == NULL)\r
10448         {\r
10449                 return;\r
10450         }\r
10451 \r
10452         FreeX(t->Cert);\r
10453 }\r
10454 \r
10455 // RPC_HUB_DELETE_CA\r
10456 void InRpcHubDeleteCa(RPC_HUB_DELETE_CA *t, PACK *p)\r
10457 {\r
10458         // 引数チェック\r
10459         if (t == NULL || p == NULL)\r
10460         {\r
10461                 return;\r
10462         }\r
10463 \r
10464         Zero(t, sizeof(RPC_HUB_DELETE_CA));\r
10465         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10466         t->Key = PackGetInt(p, "Key");\r
10467 }\r
10468 void OutRpcHubDeleteCa(PACK *p, RPC_HUB_DELETE_CA *t)\r
10469 {\r
10470         // 引数チェック\r
10471         if (t == NULL || p == NULL)\r
10472         {\r
10473                 return;\r
10474         }\r
10475 \r
10476         PackAddStr(p, "HubName", t->HubName);\r
10477         PackAddInt(p, "Key", t->Key);\r
10478 }\r
10479 \r
10480 // RPC_CREATE_LINK\r
10481 void InRpcCreateLink(RPC_CREATE_LINK *t, PACK *p)\r
10482 {\r
10483         BUF *b;\r
10484         // 引数チェック\r
10485         if (t == NULL || p == NULL)\r
10486         {\r
10487                 return;\r
10488         }\r
10489 \r
10490         Zero(t, sizeof(RPC_CREATE_LINK));\r
10491         PackGetStr(p, "HubName_Ex", t->HubName, sizeof(t->HubName));\r
10492         t->Online = PackGetBool(p, "Online");\r
10493         t->ClientOption = ZeroMalloc(sizeof(CLIENT_OPTION));\r
10494         InRpcClientOption(t->ClientOption, p);\r
10495         t->ClientAuth  = ZeroMalloc(sizeof(CLIENT_AUTH));\r
10496         InRpcClientAuth(t->ClientAuth, p);\r
10497         InRpcPolicy(&t->Policy, p);\r
10498 \r
10499         t->CheckServerCert = PackGetBool(p, "CheckServerCert");\r
10500         b = PackGetBuf(p, "ServerCert");\r
10501         if (b != NULL)\r
10502         {\r
10503                 t->ServerCert = BufToX(b, false);\r
10504                 FreeBuf(b);\r
10505         }\r
10506 }\r
10507 void OutRpcCreateLink(PACK *p, RPC_CREATE_LINK *t)\r
10508 {\r
10509         // 引数チェック\r
10510         if (t == NULL || p == NULL)\r
10511         {\r
10512                 return;\r
10513         }\r
10514 \r
10515         PackAddStr(p, "HubName_Ex",t->HubName);\r
10516         PackAddBool(p, "Online", t->Online);\r
10517         OutRpcClientOption(p, t->ClientOption);\r
10518         OutRpcClientAuth(p, t->ClientAuth);\r
10519         OutRpcPolicy(p, &t->Policy);\r
10520 \r
10521         PackAddBool(p, "CheckServerCert", t->CheckServerCert);\r
10522         if (t->ServerCert != NULL)\r
10523         {\r
10524                 BUF *b;\r
10525                 b = XToBuf(t->ServerCert, false);\r
10526                 PackAddBuf(p, "ServerCert", b);\r
10527                 FreeBuf(b);\r
10528         }\r
10529 }\r
10530 void FreeRpcCreateLink(RPC_CREATE_LINK *t)\r
10531 {\r
10532         // 引数チェック\r
10533         if (t == NULL)\r
10534         {\r
10535                 return;\r
10536         }\r
10537 \r
10538         if (t->ServerCert != NULL)\r
10539         {\r
10540                 FreeX(t->ServerCert);\r
10541         }\r
10542         Free(t->ClientOption);\r
10543         CiFreeClientAuth(t->ClientAuth);\r
10544 }\r
10545 \r
10546 // RPC_ENUM_LINK\r
10547 void InRpcEnumLink(RPC_ENUM_LINK *t, PACK *p)\r
10548 {\r
10549         UINT i;\r
10550         // 引数チェック\r
10551         if (t == NULL || p == NULL)\r
10552         {\r
10553                 return;\r
10554         }\r
10555 \r
10556         Zero(t, sizeof(RPC_ENUM_LINK));\r
10557         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10558         t->NumLink = PackGetIndexCount(p, "AccountName");\r
10559         t->Links = ZeroMalloc(sizeof(RPC_ENUM_LINK_ITEM) * t->NumLink);\r
10560 \r
10561         for (i = 0;i < t->NumLink;i++)\r
10562         {\r
10563                 RPC_ENUM_LINK_ITEM *e = &t->Links[i];\r
10564 \r
10565                 PackGetUniStrEx(p, "AccountName", e->AccountName, sizeof(e->AccountName), i);\r
10566                 PackGetStrEx(p, "Hostname", e->Hostname, sizeof(e->Hostname), i);\r
10567                 PackGetStrEx(p, "ConnectedHubName", e->HubName, sizeof(e->HubName), i);\r
10568                 e->Online = PackGetBoolEx(p, "Online", i);\r
10569                 e->ConnectedTime = PackGetInt64Ex(p, "ConnectedTime", i);\r
10570                 e->Connected = PackGetBoolEx(p, "Connected", i);\r
10571                 e->LastError = PackGetIntEx(p, "LastError", i);\r
10572         }\r
10573 }\r
10574 void OutRpcEnumLink(PACK *p, RPC_ENUM_LINK *t)\r
10575 {\r
10576         UINT i;\r
10577         // 引数チェック\r
10578         if (t == NULL || p == NULL)\r
10579         {\r
10580                 return;\r
10581         }\r
10582 \r
10583         PackAddStr(p, "HubName", t->HubName);\r
10584 \r
10585         for (i = 0;i < t->NumLink;i++)\r
10586         {\r
10587                 RPC_ENUM_LINK_ITEM *e = &t->Links[i];\r
10588 \r
10589                 PackAddUniStrEx(p, "AccountName", e->AccountName, i, t->NumLink);\r
10590                 PackAddStrEx(p, "ConnectedHubName", e->HubName, i, t->NumLink);\r
10591                 PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumLink);\r
10592                 PackAddBoolEx(p, "Online", e->Online, i, t->NumLink);\r
10593                 PackAddInt64Ex(p, "ConnectedTime", e->ConnectedTime, i, t->NumLink);\r
10594                 PackAddBoolEx(p, "Connected", e->Connected, i, t->NumLink);\r
10595                 PackAddIntEx(p, "LastError", e->LastError, i, t->NumLink);\r
10596         }\r
10597 }\r
10598 void FreeRpcEnumLink(RPC_ENUM_LINK *t)\r
10599 {\r
10600         // 引数チェック\r
10601         if (t == NULL)\r
10602         {\r
10603                 return;\r
10604         }\r
10605 \r
10606         Free(t->Links);\r
10607 }\r
10608 \r
10609 // RPC_LINK_STATUS\r
10610 void InRpcLinkStatus(RPC_LINK_STATUS *t, PACK *p)\r
10611 {\r
10612         // 引数チェック\r
10613         if (t == NULL || p == NULL)\r
10614         {\r
10615                 return;\r
10616         }\r
10617 \r
10618         Zero(t, sizeof(RPC_LINK_STATUS));\r
10619         PackGetStr(p, "HubName_Ex", t->HubName, sizeof(t->HubName));\r
10620         PackGetUniStr(p, "AccountName", t->AccountName, sizeof(t->AccountName));\r
10621         InRpcClientGetConnectionStatus(&t->Status, p);\r
10622 }\r
10623 void OutRpcLinkStatus(PACK *p, RPC_LINK_STATUS *t)\r
10624 {\r
10625         // 引数チェック\r
10626         if (t == NULL || p == NULL)\r
10627         {\r
10628                 return;\r
10629         }\r
10630 \r
10631         PackAddStr(p, "HubName_Ex", t->HubName);\r
10632         PackAddUniStr(p, "AccountName", t->AccountName);\r
10633         OutRpcClientGetConnectionStatus(p, &t->Status);\r
10634 }\r
10635 void FreeRpcLinkStatus(RPC_LINK_STATUS *t)\r
10636 {\r
10637         // 引数チェック\r
10638         if (t == NULL)\r
10639         {\r
10640                 return;\r
10641         }\r
10642 \r
10643         CiFreeClientGetConnectionStatus(&t->Status);\r
10644 }\r
10645 \r
10646 // RPC_LINK\r
10647 void InRpcLink(RPC_LINK *t, PACK *p)\r
10648 {\r
10649         // 引数チェック\r
10650         if (t == NULL || p == NULL)\r
10651         {\r
10652                 return;\r
10653         }\r
10654 \r
10655         Zero(t, sizeof(RPC_LINK));\r
10656         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10657         PackGetUniStr(p, "AccountName", t->AccountName, sizeof(t->AccountName));\r
10658 }\r
10659 void OutRpcLink(PACK *p, RPC_LINK *t)\r
10660 {\r
10661         // 引数チェック\r
10662         if (t == NULL)\r
10663         {\r
10664                 return;\r
10665         }\r
10666 \r
10667         PackAddStr(p, "HubName", t->HubName);\r
10668         PackAddUniStr(p, "AccountName", t->AccountName);\r
10669 }\r
10670 \r
10671 // RPC_RENAME_LINK\r
10672 void InRpcRenameLink(RPC_RENAME_LINK *t, PACK *p)\r
10673 {\r
10674         // 引数チェック\r
10675         if (t == NULL || p == NULL)\r
10676         {\r
10677                 return;\r
10678         }\r
10679 \r
10680         Zero(t, sizeof(RPC_RENAME_LINK));\r
10681         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
10682         PackGetUniStr(p, "OldAccountName", t->OldAccountName, sizeof(t->OldAccountName));\r
10683         PackGetUniStr(p, "NewAccountName", t->NewAccountName, sizeof(t->NewAccountName));\r
10684 }\r
10685 void OutRpcRenameLink(PACK *p, RPC_RENAME_LINK *t)\r
10686 {\r
10687         // 引数チェック\r
10688         if (p == NULL || t == NULL)\r
10689         {\r
10690                 return;\r
10691         }\r
10692 \r
10693         PackAddStr(p, "HubName", t->HubName);\r
10694         PackAddUniStr(p, "OldAccountName", t->OldAccountName);\r
10695         PackAddUniStr(p, "NewAccountName", t->NewAccountName);\r
10696 }\r
10697 \r
10698 // ACCESS\r
10699 void InRpcAccessEx(ACCESS *a, PACK *p, UINT index)\r
10700 {\r
10701         // 引数チェック\r
10702         if (a == NULL || p == NULL)\r
10703         {\r
10704                 return;\r
10705         }\r
10706 \r
10707         Zero(a, sizeof(ACCESS));\r
10708         a->Id = PackGetIntEx(p, "Id", index);\r
10709         PackGetUniStrEx(p, "Note", a->Note, sizeof(a->Note), index);\r
10710         a->Active = PackGetBoolEx(p, "Active", index);\r
10711         a->Priority = PackGetIntEx(p, "Priority", index);\r
10712         a->Discard = PackGetBoolEx(p, "Discard", index);\r
10713         a->SrcIpAddress = PackGetIp32Ex(p, "SrcIpAddress", index);\r
10714         a->SrcSubnetMask = PackGetIp32Ex(p, "SrcSubnetMask", index);\r
10715         a->DestIpAddress = PackGetIp32Ex(p, "DestIpAddress", index);\r
10716         a->DestSubnetMask = PackGetIp32Ex(p, "DestSubnetMask", index);\r
10717         a->Protocol = PackGetIntEx(p, "Protocol", index);\r
10718         a->SrcPortStart = PackGetIntEx(p, "SrcPortStart", index);\r
10719         a->SrcPortEnd = PackGetIntEx(p, "SrcPortEnd", index);\r
10720         a->DestPortStart = PackGetIntEx(p, "DestPortStart", index);\r
10721         a->DestPortEnd = PackGetIntEx(p, "DestPortEnd", index);\r
10722         a->SrcUsernameHash = PackGetIntEx(p, "SrcUsernameHash", index);\r
10723         PackGetStrEx(p, "SrcUsername", a->SrcUsername, sizeof(a->SrcUsername), index);\r
10724         a->DestUsernameHash = PackGetIntEx(p, "DestUsernameHash", index);\r
10725         PackGetStrEx(p, "DestUsername", a->DestUsername, sizeof(a->DestUsername), index);\r
10726         a->CheckSrcMac = PackGetBoolEx(p, "CheckSrcMac", index);\r
10727         PackGetDataEx2(p, "SrcMacAddress", a->SrcMacAddress, sizeof(a->SrcMacAddress), index);\r
10728         PackGetDataEx2(p, "SrcMacMask", a->SrcMacMask, sizeof(a->SrcMacMask), index);\r
10729         a->CheckDstMac = PackGetBoolEx(p, "CheckDstMac", index);\r
10730         PackGetDataEx2(p, "DstMacAddress", a->DstMacAddress, sizeof(a->DstMacAddress), index);\r
10731         PackGetDataEx2(p, "DstMacMask", a->DstMacMask, sizeof(a->DstMacMask), index);\r
10732         a->CheckTcpState = PackGetBoolEx(p, "CheckTcpState", index);\r
10733         a->Established = PackGetBoolEx(p, "Established", index);\r
10734         a->Delay = PackGetIntEx(p, "Delay", index);\r
10735         a->Jitter = PackGetIntEx(p, "Jitter", index);\r
10736         a->Loss = PackGetIntEx(p, "Loss", index);\r
10737         a->IsIPv6 = PackGetBoolEx(p, "IsIPv6", index);\r
10738         if (a->IsIPv6)\r
10739         {\r
10740                 PackGetIp6AddrEx(p, "SrcIpAddress6", &a->SrcIpAddress6, index);\r
10741                 PackGetIp6AddrEx(p, "SrcSubnetMask6", &a->SrcSubnetMask6, index);\r
10742                 PackGetIp6AddrEx(p, "DestIpAddress6", &a->DestIpAddress6, index);\r
10743                 PackGetIp6AddrEx(p, "DestSubnetMask6", &a->DestSubnetMask6, index);\r
10744         }\r
10745 }\r
10746 void InRpcAccess(ACCESS *a, PACK *p)\r
10747 {\r
10748         // 引数チェック\r
10749         if (a == NULL || p == NULL)\r
10750         {\r
10751                 return;\r
10752         }\r
10753 \r
10754         InRpcAccessEx(a, p, 0);\r
10755 }\r
10756 void OutRpcAccessEx(PACK *p, ACCESS *a, UINT index, UINT total)\r
10757 {\r
10758         // 引数チェック\r
10759         if (a == NULL || p == NULL)\r
10760         {\r
10761                 return;\r
10762         }\r
10763 \r
10764         PackAddIntEx(p, "Id", a->Id, index, total);\r
10765         PackAddUniStrEx(p, "Note", a->Note, index, total);\r
10766         PackAddBoolEx(p, "Active", a->Active, index, total);\r
10767         PackAddIntEx(p, "Priority", a->Priority, index, total);\r
10768         PackAddBoolEx(p, "Discard", a->Discard, index, total);\r
10769         if (a->IsIPv6)\r
10770         {\r
10771                 PackAddIp32Ex(p, "SrcIpAddress", 0xFDFFFFDF, index, total);\r
10772                 PackAddIp32Ex(p, "SrcSubnetMask", 0xFFFFFFFF, index, total);\r
10773                 PackAddIp32Ex(p, "DestIpAddress", 0xFDFFFFDF, index, total);\r
10774                 PackAddIp32Ex(p, "DestSubnetMask", 0xFFFFFFFF, index, total);\r
10775         }\r
10776         else\r
10777         {\r
10778                 PackAddIp32Ex(p, "SrcIpAddress", a->SrcIpAddress, index, total);\r
10779                 PackAddIp32Ex(p, "SrcSubnetMask", a->SrcSubnetMask, index, total);\r
10780                 PackAddIp32Ex(p, "DestIpAddress", a->DestIpAddress, index, total);\r
10781                 PackAddIp32Ex(p, "DestSubnetMask", a->DestSubnetMask, index, total);\r
10782         }\r
10783         PackAddIntEx(p, "Protocol", a->Protocol, index, total);\r
10784         PackAddIntEx(p, "SrcPortStart", a->SrcPortStart, index, total);\r
10785         PackAddIntEx(p, "SrcPortEnd", a->SrcPortEnd, index, total);\r
10786         PackAddIntEx(p, "DestPortStart", a->DestPortStart, index, total);\r
10787         PackAddIntEx(p, "DestPortEnd", a->DestPortEnd, index, total);\r
10788         PackAddIntEx(p, "SrcUsernameHash", a->SrcUsernameHash, index, total);\r
10789         PackAddStrEx(p, "SrcUsername", a->SrcUsername, index, total);\r
10790         PackAddIntEx(p, "DestUsernameHash", a->DestUsernameHash, index, total);\r
10791         PackAddStrEx(p, "DestUsername", a->DestUsername, index, total);\r
10792         PackAddBoolEx(p, "CheckSrcMac", a->CheckSrcMac, index, total);\r
10793         PackAddDataEx(p, "SrcMacAddress", a->SrcMacAddress, sizeof(a->SrcMacAddress), index, total);\r
10794         PackAddDataEx(p, "SrcMacMask", a->SrcMacMask, sizeof(a->SrcMacMask), index, total);\r
10795         PackAddBoolEx(p, "CheckDstMac", a->CheckDstMac, index, total);\r
10796         PackAddDataEx(p, "DstMacAddress", a->DstMacAddress, sizeof(a->DstMacAddress), index, total);\r
10797         PackAddDataEx(p, "DstMacMask", a->DstMacMask, sizeof(a->DstMacMask), index, total);\r
10798         PackAddBoolEx(p, "CheckTcpState", a->CheckTcpState, index, total);\r
10799         PackAddBoolEx(p, "Established", a->Established, index, total);\r
10800         PackAddIntEx(p, "Delay", a->Delay, index, total);\r
10801         PackAddIntEx(p, "Jitter", a->Jitter, index, total);\r
10802         PackAddIntEx(p, "Loss", a->Loss, index, total);\r
10803         PackAddBoolEx(p, "IsIPv6", a->IsIPv6, index, total);\r
10804         if (a->IsIPv6)\r
10805         {\r
10806                 PackAddIp6AddrEx(p, "SrcIpAddress6", &a->SrcIpAddress6, index, total);\r
10807                 PackAddIp6AddrEx(p, "SrcSubnetMask6", &a->SrcSubnetMask6, index, total);\r
10808                 PackAddIp6AddrEx(p, "DestIpAddress6", &a->DestIpAddress6, index, total);\r
10809                 PackAddIp6AddrEx(p, "DestSubnetMask6", &a->DestSubnetMask6, index, total);\r
10810         }\r
10811         else\r
10812         {\r
10813                 IPV6_ADDR zero;\r
10814 \r
10815                 Zero(&zero, sizeof(zero));\r
10816 \r
10817                 PackAddIp6AddrEx(p, "SrcIpAddress6", &zero, index, total);\r
10818                 PackAddIp6AddrEx(p, "SrcSubnetMask6", &zero, index, total);\r
10819                 PackAddIp6AddrEx(p, "DestIpAddress6", &zero, index, total);\r
10820                 PackAddIp6AddrEx(p, "DestSubnetMask6", &zero, index, total);\r
10821         }\r
10822 }\r
10823 void OutRpcAccess(PACK *p, ACCESS *a)\r
10824 {\r
10825         // 引数チェック\r
10826         if (a == NULL || p == NULL)\r
10827         {\r
10828                 return;\r
10829         }\r
10830 \r
10831         OutRpcAccessEx(p, a, 0, 1);\r
10832 }\r
10833 \r
10834 // RPC_ENUM_ACCESS_LIST\r
10835 void InRpcEnumAccessList(RPC_ENUM_ACCESS_LIST *a, PACK *p)\r
10836 {\r
10837         UINT i;\r
10838         // 引数チェック\r
10839         if (a == NULL || p == NULL)\r
10840         {\r
10841                 return;\r
10842         }\r
10843 \r
10844         Zero(a, sizeof(RPC_ENUM_ACCESS_LIST));\r
10845         PackGetStr(p, "HubName", a->HubName, sizeof(a->HubName));\r
10846         a->NumAccess = PackGetIndexCount(p, "Protocol");\r
10847         a->Accesses = ZeroMalloc(sizeof(ACCESS) * a->NumAccess);\r
10848 \r
10849         for (i = 0;i < a->NumAccess;i++)\r
10850         {\r
10851                 ACCESS *e = &a->Accesses[i];\r
10852 \r
10853                 InRpcAccessEx(e, p, i);\r
10854         }\r
10855 }\r
10856 void OutRpcEnumAccessList(PACK *p, RPC_ENUM_ACCESS_LIST *a)\r
10857 {\r
10858         UINT i;\r
10859         PackAddStr(p, "HubName", a->HubName);\r
10860         // 引数チェック\r
10861         if (a == NULL || p == NULL)\r
10862         {\r
10863                 return;\r
10864         }\r
10865 \r
10866         for (i = 0;i < a->NumAccess;i++)\r
10867         {\r
10868                 ACCESS *e = &a->Accesses[i];\r
10869 \r
10870                 OutRpcAccessEx(p, e, i, a->NumAccess);\r
10871         }\r
10872 }\r
10873 void FreeRpcEnumAccessList(RPC_ENUM_ACCESS_LIST *a)\r
10874 {\r
10875         // 引数チェック\r
10876         if (a == NULL)\r
10877         {\r
10878                 return;\r
10879         }\r
10880 \r
10881         Free(a->Accesses);\r
10882 }\r
10883 \r
10884 // AUTHDATA\r
10885 void *InRpcAuthData(PACK *p, UINT *authtype)\r
10886 {\r
10887         wchar_t tmp[MAX_SIZE];\r
10888         AUTHPASSWORD *pw;\r
10889         AUTHUSERCERT *usercert;\r
10890         AUTHROOTCERT *rootcert;\r
10891         AUTHRADIUS *radius;\r
10892         AUTHNT *nt;\r
10893         BUF *b;\r
10894         // 引数チェック\r
10895         if (p == NULL)\r
10896         {\r
10897                 return NULL;\r
10898         }\r
10899         if (authtype == NULL)\r
10900         {\r
10901                 return NULL;\r
10902         }\r
10903 \r
10904         *authtype = PackGetInt(p, "AuthType");\r
10905 \r
10906         switch (*authtype)\r
10907         {\r
10908         case AUTHTYPE_PASSWORD:\r
10909                 pw = ZeroMalloc(sizeof(AUTHPASSWORD));\r
10910                 PackGetData2(p, "HashedKey", pw->HashedKey, sizeof(pw->HashedKey));\r
10911                 return pw;\r
10912 \r
10913         case AUTHTYPE_USERCERT:\r
10914                 usercert = ZeroMalloc(sizeof(AUTHUSERCERT));\r
10915                 usercert->UserX = PackGetX(p, "UserX");\r
10916                 return usercert;\r
10917 \r
10918         case AUTHTYPE_ROOTCERT:\r
10919                 rootcert = ZeroMalloc(sizeof(AUTHROOTCERT));\r
10920                 b = PackGetBuf(p, "Serial");\r
10921                 if (b != NULL)\r
10922                 {\r
10923                         rootcert->Serial = NewXSerial(b->Buf, b->Size);\r
10924                         FreeBuf(b);\r
10925                 }\r
10926                 if (PackGetUniStr(p, "CommonName", tmp, sizeof(tmp)))\r
10927                 {\r
10928                         rootcert->CommonName = CopyUniStr(tmp);\r
10929                 }\r
10930                 return rootcert;\r
10931 \r
10932         case AUTHTYPE_RADIUS:\r
10933                 radius = ZeroMalloc(sizeof(AUTHRADIUS));\r
10934                 if (PackGetUniStr(p, "RadiusUsername", tmp, sizeof(tmp)))\r
10935                 {\r
10936                         radius->RadiusUsername = CopyUniStr(tmp);\r
10937                 }\r
10938                 else\r
10939                 {\r
10940                         radius->RadiusUsername = CopyUniStr(L"");\r
10941                 }\r
10942                 return radius;\r
10943 \r
10944         case AUTHTYPE_NT:\r
10945                 nt = ZeroMalloc(sizeof(AUTHNT));\r
10946                 if (PackGetUniStr(p, "NtUsername", tmp, sizeof(tmp)))\r
10947                 {\r
10948                         nt->NtUsername = CopyUniStr(tmp);\r
10949                 }\r
10950                 else\r
10951                 {\r
10952                         nt->NtUsername = CopyUniStr(L"");\r
10953                 }\r
10954                 return nt;\r
10955         }\r
10956 \r
10957         return NULL;\r
10958 }\r
10959 void OutRpcAuthData(PACK *p, void *authdata, UINT authtype)\r
10960 {\r
10961         AUTHPASSWORD *pw = authdata;\r
10962         AUTHUSERCERT *usercert = authdata;\r
10963         AUTHROOTCERT *rootcert = authdata;\r
10964         AUTHRADIUS *radius = authdata;\r
10965         AUTHNT *nt = authdata;\r
10966         // 引数チェック\r
10967         if (p == NULL)\r
10968         {\r
10969                 return;\r
10970         }\r
10971 \r
10972         PackAddInt(p, "AuthType", authtype);\r
10973 \r
10974         switch (authtype)\r
10975         {\r
10976         case AUTHTYPE_PASSWORD:\r
10977                 PackAddData(p, "HashedKey", pw->HashedKey, sizeof(pw->HashedKey));\r
10978                 break;\r
10979 \r
10980         case AUTHTYPE_USERCERT:\r
10981                 PackAddX(p, "UserX", usercert->UserX);\r
10982                 break;\r
10983 \r
10984         case AUTHTYPE_ROOTCERT:\r
10985                 if (rootcert->Serial != NULL)\r
10986                 {\r
10987                         PackAddData(p, "Serial", rootcert->Serial->data, rootcert->Serial->size);\r
10988                 }\r
10989                 if (rootcert->CommonName != NULL)\r
10990                 {\r
10991                         PackAddUniStr(p, "CommonName", rootcert->CommonName);\r
10992                 }\r
10993                 break;\r
10994 \r
10995         case AUTHTYPE_RADIUS:\r
10996                 PackAddUniStr(p, "RadiusUsername", radius->RadiusUsername);\r
10997                 break;\r
10998 \r
10999         case AUTHTYPE_NT:\r
11000                 PackAddUniStr(p, "NtUsername", nt->NtUsername);\r
11001                 break;\r
11002         }\r
11003 }\r
11004 void FreeRpcAuthData(void *authdata, UINT authtype)\r
11005 {\r
11006         FreeAuthData(authtype, authdata);\r
11007 }\r
11008 \r
11009 // RPC_SET_USER\r
11010 void InRpcSetUser(RPC_SET_USER *t, PACK *p)\r
11011 {\r
11012         // 引数チェック\r
11013         if (t == NULL || p == NULL)\r
11014         {\r
11015                 return;\r
11016         }\r
11017 \r
11018         Zero(t, sizeof(RPC_SET_USER));\r
11019         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11020         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
11021         PackGetStr(p, "GroupName", t->GroupName, sizeof(t->GroupName));\r
11022         PackGetUniStr(p, "Realname", t->Realname, sizeof(t->Realname));\r
11023         PackGetUniStr(p, "Note", t->Note, sizeof(t->Note));\r
11024         t->CreatedTime = PackGetInt64(p, "CreatedTime");\r
11025         t->UpdatedTime = PackGetInt64(p, "UpdatedTime");\r
11026         t->ExpireTime = PackGetInt64(p, "ExpireTime");\r
11027         t->AuthData = InRpcAuthData(p, &t->AuthType);\r
11028         t->NumLogin = PackGetInt(p, "NumLogin");\r
11029         InRpcTraffic(&t->Traffic, p);\r
11030 \r
11031         if (PackGetBool(p, "UsePolicy"))\r
11032         {\r
11033                 t->Policy = ZeroMalloc(sizeof(POLICY));\r
11034                 InRpcPolicy(t->Policy, p);\r
11035         }\r
11036 }\r
11037 \r
11038 void OutRpcSetUser(PACK *p, RPC_SET_USER *t)\r
11039 {\r
11040         // 引数チェック\r
11041         if (t == NULL || p == NULL)\r
11042         {\r
11043                 return;\r
11044         }\r
11045 \r
11046         PackAddStr(p, "HubName", t->HubName);\r
11047         PackAddStr(p, "Name", t->Name);\r
11048         PackAddStr(p, "GroupName", t->GroupName);\r
11049         PackAddUniStr(p, "Realname", t->Realname);\r
11050         PackAddUniStr(p, "Note", t->Note);\r
11051         PackAddInt64(p, "CreatedTime", t->CreatedTime);\r
11052         PackAddInt64(p, "UpdatedTime", t->UpdatedTime);\r
11053         PackAddInt64(p, "ExpireTime", t->ExpireTime);\r
11054         OutRpcAuthData(p, t->AuthData, t->AuthType);\r
11055         PackAddInt(p, "NumLogin", t->NumLogin);\r
11056         OutRpcTraffic(p, &t->Traffic);\r
11057 \r
11058         if (t->Policy != NULL)\r
11059         {\r
11060                 PackAddBool(p, "UsePolicy", true);\r
11061                 OutRpcPolicy(p, t->Policy);\r
11062         }\r
11063 }\r
11064 void FreeRpcSetUser(RPC_SET_USER *t)\r
11065 {\r
11066         // 引数チェック\r
11067         if (t == NULL)\r
11068         {\r
11069                 return;\r
11070         }\r
11071 \r
11072         FreeRpcAuthData(t->AuthData, t->AuthType);\r
11073         if (t->Policy)\r
11074         {\r
11075                 Free(t->Policy);\r
11076         }\r
11077 }\r
11078 \r
11079 // RPC_ENUM_USER\r
11080 void InRpcEnumUser(RPC_ENUM_USER *t, PACK *p)\r
11081 {\r
11082         UINT i;\r
11083         // 引数チェック\r
11084         if (t == NULL || p == NULL)\r
11085         {\r
11086                 return;\r
11087         }\r
11088 \r
11089         Zero(t, sizeof(RPC_ENUM_USER));\r
11090         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11091         t->NumUser = PackGetIndexCount(p, "Name");\r
11092         t->Users = ZeroMalloc(sizeof(RPC_ENUM_USER_ITEM) * t->NumUser);\r
11093 \r
11094         for (i = 0;i < t->NumUser;i++)\r
11095         {\r
11096                 RPC_ENUM_USER_ITEM *e = &t->Users[i];\r
11097 \r
11098                 PackGetStrEx(p, "Name", e->Name, sizeof(e->Name), i);\r
11099                 PackGetStrEx(p, "GroupName", e->GroupName, sizeof(e->GroupName), i);\r
11100                 PackGetUniStrEx(p, "Realname", e->Realname, sizeof(e->Realname), i);\r
11101                 PackGetUniStrEx(p, "Note", e->Note, sizeof(e->Note), i);\r
11102                 e->AuthType = PackGetIntEx(p, "AuthType", i);\r
11103                 e->LastLoginTime = PackGetInt64Ex(p, "LastLoginTime", i);\r
11104                 e->NumLogin = PackGetIntEx(p, "NumLogin", i);\r
11105                 e->DenyAccess = PackGetBoolEx(p, "DenyAccess", i);\r
11106         }\r
11107 }\r
11108 void OutRpcEnumUser(PACK *p, RPC_ENUM_USER *t)\r
11109 {\r
11110         UINT i;\r
11111         PackAddStr(p, "HubName", t->HubName);\r
11112         // 引数チェック\r
11113         if (t == NULL || p == NULL)\r
11114         {\r
11115                 return;\r
11116         }\r
11117 \r
11118         for (i = 0;i < t->NumUser;i++)\r
11119         {\r
11120                 RPC_ENUM_USER_ITEM *e = &t->Users[i];\r
11121 \r
11122                 PackAddStrEx(p, "Name", e->Name, i, t->NumUser);\r
11123                 PackAddStrEx(p, "GroupName", e->GroupName, i, t->NumUser);\r
11124                 PackAddUniStrEx(p, "Realname", e->Realname, i, t->NumUser);\r
11125                 PackAddUniStrEx(p, "Note", e->Note, i, t->NumUser);\r
11126                 PackAddIntEx(p, "AuthType", e->AuthType, i, t->NumUser);\r
11127                 PackAddInt64Ex(p, "LastLoginTime", e->LastLoginTime, i, t->NumUser);\r
11128                 PackAddIntEx(p, "NumLogin", e->NumLogin, i, t->NumUser);\r
11129                 PackAddBoolEx(p, "DenyAccess", e->DenyAccess, i, t->NumUser);\r
11130         }\r
11131 }\r
11132 void FreeRpcEnumUser(RPC_ENUM_USER *t)\r
11133 {\r
11134         // 引数チェック\r
11135         if (t == NULL)\r
11136         {\r
11137                 return;\r
11138         }\r
11139 \r
11140         Free(t->Users);\r
11141 }\r
11142 \r
11143 // RPC_SET_GROUP\r
11144 void InRpcSetGroup(RPC_SET_GROUP *t, PACK *p)\r
11145 {\r
11146         // 引数チェック\r
11147         if (t == NULL || p == NULL)\r
11148         {\r
11149                 return;\r
11150         }\r
11151 \r
11152         Zero(t, sizeof(RPC_SET_GROUP));\r
11153         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11154         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
11155         PackGetUniStr(p, "Realname", t->Realname, sizeof(t->Realname));\r
11156         PackGetUniStr(p, "Note", t->Note, sizeof(t->Note));\r
11157         InRpcTraffic(&t->Traffic, p);\r
11158 \r
11159         if (PackGetBool(p, "UsePolicy"))\r
11160         {\r
11161                 t->Policy = ZeroMalloc(sizeof(POLICY));\r
11162                 InRpcPolicy(t->Policy, p);\r
11163         }\r
11164 }\r
11165 void OutRpcSetGroup(PACK *p, RPC_SET_GROUP *t)\r
11166 {\r
11167         // 引数チェック\r
11168         if (t == NULL || p == NULL)\r
11169         {\r
11170                 return;\r
11171         }\r
11172 \r
11173         PackAddStr(p, "HubName", t->HubName);\r
11174         PackAddStr(p, "Name", t->Name);\r
11175         PackAddUniStr(p, "Realname", t->Realname);\r
11176         PackAddUniStr(p, "Note", t->Note);\r
11177         OutRpcTraffic(p, &t->Traffic);\r
11178 \r
11179         if (t->Policy != NULL)\r
11180         {\r
11181                 PackAddBool(p, "UsePolicy", true);\r
11182                 OutRpcPolicy(p, t->Policy);\r
11183         }\r
11184 }\r
11185 void FreeRpcSetGroup(RPC_SET_GROUP *t)\r
11186 {\r
11187         Free(t->Policy);\r
11188 }\r
11189 \r
11190 // RPC_ENUM_GROUP\r
11191 void InRpcEnumGroup(RPC_ENUM_GROUP *t, PACK *p)\r
11192 {\r
11193         UINT i;\r
11194         // 引数チェック\r
11195         if (t == NULL || p == NULL)\r
11196         {\r
11197                 return;\r
11198         }\r
11199 \r
11200         Zero(t, sizeof(RPC_ENUM_GROUP));\r
11201         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11202         t->NumGroup = PackGetIndexCount(p, "Name");\r
11203         t->Groups = ZeroMalloc(sizeof(RPC_ENUM_GROUP_ITEM) * t->NumGroup);\r
11204 \r
11205         for (i = 0;i < t->NumGroup;i++)\r
11206         {\r
11207                 RPC_ENUM_GROUP_ITEM *e = &t->Groups[i];\r
11208 \r
11209                 PackGetStrEx(p, "Name", e->Name, sizeof(e->Name), i);\r
11210                 PackGetUniStrEx(p, "Realname", e->Realname, sizeof(e->Realname), i);\r
11211                 PackGetUniStrEx(p, "Note", e->Note, sizeof(e->Note), i);\r
11212                 e->NumUsers = PackGetIntEx(p, "NumUsers", i);\r
11213                 e->DenyAccess = PackGetBoolEx(p, "DenyAccess", i);\r
11214         }\r
11215 }\r
11216 void OutRpcEnumGroup(PACK *p, RPC_ENUM_GROUP *t)\r
11217 {\r
11218         UINT i;\r
11219         // 引数チェック\r
11220         if (t == NULL || p == NULL)\r
11221         {\r
11222                 return;\r
11223         }\r
11224 \r
11225         PackAddStr(p, "HubName", t->HubName);\r
11226 \r
11227         for (i = 0;i < t->NumGroup;i++)\r
11228         {\r
11229                 RPC_ENUM_GROUP_ITEM *e = &t->Groups[i];\r
11230 \r
11231                 PackAddStrEx(p, "Name", e->Name, i, t->NumGroup);\r
11232                 PackAddUniStrEx(p, "Realname", e->Realname, i, t->NumGroup);\r
11233                 PackAddUniStrEx(p, "Note", e->Note, i, t->NumGroup);\r
11234                 PackAddIntEx(p, "NumUsers", e->NumUsers, i, t->NumGroup);\r
11235                 PackAddBoolEx(p, "DenyAccess", e->DenyAccess, i, t->NumGroup);\r
11236         }\r
11237 }\r
11238 void FreeRpcEnumGroup(RPC_ENUM_GROUP *t)\r
11239 {\r
11240         // 引数チェック\r
11241         if (t == NULL)\r
11242         {\r
11243                 return;\r
11244         }\r
11245 \r
11246         Free(t->Groups);\r
11247 }\r
11248 \r
11249 // RPC_DELETE_USER\r
11250 void InRpcDeleteUser(RPC_DELETE_USER *t, PACK *p)\r
11251 {\r
11252         // 引数チェック\r
11253         if (t == NULL || p == NULL)\r
11254         {\r
11255                 return;\r
11256         }\r
11257 \r
11258         Zero(t, sizeof(RPC_DELETE_USER));\r
11259         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11260         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
11261 }\r
11262 void OutRpcDeleteUser(PACK *p, RPC_DELETE_USER *t)\r
11263 {\r
11264         // 引数チェック\r
11265         if (t == NULL || p == NULL)\r
11266         {\r
11267                 return;\r
11268         }\r
11269 \r
11270         PackAddStr(p, "HubName", t->HubName);\r
11271         PackAddStr(p, "Name", t->Name);\r
11272 }\r
11273 \r
11274 // RPC_ENUM_SESSION\r
11275 void InRpcEnumSession(RPC_ENUM_SESSION *t, PACK *p)\r
11276 {\r
11277         UINT i;\r
11278         // 引数チェック\r
11279         if (t == NULL || p == NULL)\r
11280         {\r
11281                 return;\r
11282         }\r
11283 \r
11284         Zero(t, sizeof(RPC_ENUM_SESSION));\r
11285         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11286         t->NumSession = PackGetIndexCount(p, "Name");\r
11287         t->Sessions = ZeroMalloc(sizeof(RPC_ENUM_SESSION_ITEM) * t->NumSession);\r
11288 \r
11289         for (i = 0;i < t->NumSession;i++)\r
11290         {\r
11291                 RPC_ENUM_SESSION_ITEM *e = &t->Sessions[i];\r
11292 \r
11293                 PackGetStrEx(p, "Name", e->Name, sizeof(e->Name), i);\r
11294                 PackGetStrEx(p, "Username", e->Username, sizeof(e->Username), i);\r
11295                 e->Ip = PackGetIntEx(p, "Ip", i);\r
11296                 PackGetStrEx(p, "Hostname", e->Hostname, sizeof(e->Hostname), i);\r
11297                 e->MaxNumTcp = PackGetIntEx(p, "MaxNumTcp", i);\r
11298                 e->CurrentNumTcp = PackGetIntEx(p, "CurrentNumTcp", i);\r
11299                 e->PacketSize = PackGetInt64Ex(p, "PacketSize", i);\r
11300                 e->PacketNum = PackGetInt64Ex(p, "PacketNum", i);\r
11301                 e->RemoteSession = PackGetBoolEx(p, "RemoteSession", i);\r
11302                 e->LinkMode = PackGetBoolEx(p, "LinkMode", i);\r
11303                 e->SecureNATMode = PackGetBoolEx(p, "SecureNATMode", i);\r
11304                 e->BridgeMode = PackGetBoolEx(p, "BridgeMode", i);\r
11305                 e->Layer3Mode = PackGetBoolEx(p, "Layer3Mode", i);\r
11306                 e->Client_BridgeMode = PackGetBoolEx(p, "Client_BridgeMode", i);\r
11307                 e->Client_MonitorMode = PackGetBoolEx(p, "Client_MonitorMode", i);\r
11308                 PackGetStrEx(p, "RemoteHostname", e->RemoteHostname, sizeof(e->RemoteHostname), i);\r
11309                 e->VLanId = PackGetIntEx(p, "VLanId", i);\r
11310                 PackGetDataEx2(p, "UniqueId", e->UniqueId, sizeof(e->UniqueId), i);\r
11311         }\r
11312 }\r
11313 void OutRpcEnumSession(PACK *p, RPC_ENUM_SESSION *t)\r
11314 {\r
11315         UINT i;\r
11316         PackAddStr(p, "HubName", t->HubName);\r
11317         // 引数チェック\r
11318         if (t == NULL || p == NULL)\r
11319         {\r
11320                 return;\r
11321         }\r
11322 \r
11323         for (i = 0;i < t->NumSession;i++)\r
11324         {\r
11325                 RPC_ENUM_SESSION_ITEM *e = &t->Sessions[i];\r
11326 \r
11327                 PackAddStrEx(p, "Name", e->Name, i, t->NumSession);\r
11328                 PackAddStrEx(p, "Username", e->Username, i, t->NumSession);\r
11329                 PackAddIp32Ex(p, "Ip", e->Ip, i, t->NumSession);\r
11330                 PackAddStrEx(p, "Hostname", e->Hostname, i, t->NumSession);\r
11331                 PackAddIntEx(p, "MaxNumTcp", e->MaxNumTcp, i, t->NumSession);\r
11332                 PackAddIntEx(p, "CurrentNumTcp", e->CurrentNumTcp, i, t->NumSession);\r
11333                 PackAddInt64Ex(p, "PacketSize", e->PacketSize, i, t->NumSession);\r
11334                 PackAddInt64Ex(p, "PacketNum", e->PacketNum, i, t->NumSession);\r
11335                 PackAddBoolEx(p, "RemoteSession", e->RemoteSession, i, t->NumSession);\r
11336                 PackAddStrEx(p, "RemoteHostname", e->RemoteHostname, i, t->NumSession);\r
11337                 PackAddBoolEx(p, "LinkMode", e->LinkMode, i, t->NumSession);\r
11338                 PackAddBoolEx(p, "SecureNATMode", e->SecureNATMode, i, t->NumSession);\r
11339                 PackAddBoolEx(p, "BridgeMode", e->BridgeMode, i, t->NumSession);\r
11340                 PackAddBoolEx(p, "Layer3Mode", e->Layer3Mode, i, t->NumSession);\r
11341                 PackAddBoolEx(p, "Client_BridgeMode", e->Client_BridgeMode, i, t->NumSession);\r
11342                 PackAddBoolEx(p, "Client_MonitorMode", e->Client_MonitorMode, i, t->NumSession);\r
11343                 PackAddIntEx(p, "VLanId", e->VLanId, i, t->NumSession);\r
11344                 PackAddDataEx(p, "UniqueId", e->UniqueId, sizeof(e->UniqueId), i, t->NumSession);\r
11345         }\r
11346 }\r
11347 void FreeRpcEnumSession(RPC_ENUM_SESSION *t)\r
11348 {\r
11349         // 引数チェック\r
11350         if (t == NULL)\r
11351         {\r
11352                 return;\r
11353         }\r
11354 \r
11355         Free(t->Sessions);\r
11356 }\r
11357 \r
11358 // RPC_KEY_PAIR\r
11359 void InRpcKeyPair(RPC_KEY_PAIR *t, PACK *p)\r
11360 {\r
11361         // 引数チェック\r
11362         if (t == NULL || p == NULL)\r
11363         {\r
11364                 return;\r
11365         }\r
11366 \r
11367         t->Cert = PackGetX(p, "Cert");\r
11368         t->Key = PackGetK(p, "Key");\r
11369 }\r
11370 void OutRpcKeyPair(PACK *p, RPC_KEY_PAIR *t)\r
11371 {\r
11372         // 引数チェック\r
11373         if (p == NULL || t == NULL)\r
11374         {\r
11375                 return;\r
11376         }\r
11377 \r
11378         PackAddX(p, "Cert", t->Cert);\r
11379         PackAddK(p, "Key", t->Key);\r
11380 }\r
11381 void FreeRpcKeyPair(RPC_KEY_PAIR *t)\r
11382 {\r
11383         FreeX(t->Cert);\r
11384         FreeK(t->Key);\r
11385 }\r
11386 \r
11387 // NODE_INFO\r
11388 void InRpcNodeInfo(NODE_INFO *t, PACK *p)\r
11389 {\r
11390         // 引数チェック\r
11391         if (t == NULL || p == NULL)\r
11392         {\r
11393                 return;\r
11394         }\r
11395 \r
11396         Zero(t, sizeof(NODE_INFO));\r
11397         PackGetStr(p, "ClientProductName", t->ClientProductName, sizeof(t->ClientProductName));\r
11398         PackGetStr(p, "ServerProductName", t->ServerProductName, sizeof(t->ServerProductName));\r
11399         PackGetStr(p, "ClientOsName", t->ClientOsName, sizeof(t->ClientOsName));\r
11400         PackGetStr(p, "ClientOsVer", t->ClientOsVer, sizeof(t->ClientOsVer));\r
11401         PackGetStr(p, "ClientOsProductId", t->ClientOsProductId, sizeof(t->ClientOsProductId));\r
11402         PackGetStr(p, "ClientHostname", t->ClientHostname, sizeof(t->ClientHostname));\r
11403         PackGetStr(p, "ServerHostname", t->ServerHostname, sizeof(t->ServerHostname));\r
11404         PackGetStr(p, "ProxyHostname", t->ProxyHostname, sizeof(t->ProxyHostname));\r
11405         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11406         PackGetData2(p, "UniqueId", t->UniqueId, sizeof(t->UniqueId));\r
11407 \r
11408         t->ClientProductVer = PackGetInt(p, "ClientProductVer");\r
11409         t->ClientProductBuild = PackGetInt(p, "ClientProductBuild");\r
11410         t->ServerProductVer = PackGetInt(p, "ServerProductVer");\r
11411         t->ServerProductBuild = PackGetInt(p, "ServerProductBuild");\r
11412         t->ClientIpAddress = PackGetIp32(p, "ClientIpAddress");\r
11413         PackGetData2(p, "ClientIpAddress6", t->ClientIpAddress6, sizeof(t->ClientIpAddress6));\r
11414         t->ClientPort = PackGetInt(p, "ClientPort");\r
11415         t->ServerIpAddress = PackGetIp32(p, "ServerIpAddress");\r
11416         PackGetData2(p, "ServerIpAddress6", t->ServerIpAddress6, sizeof(t->ServerIpAddress6));\r
11417         t->ServerPort = PackGetInt(p, "ServerPort2");\r
11418         t->ProxyIpAddress = PackGetIp32(p, "ProxyIpAddress");\r
11419         PackGetData2(p, "ProxyIpAddress6", t->ProxyIpAddress6, sizeof(t->ProxyIpAddress6));\r
11420         t->ProxyPort = PackGetInt(p, "ProxyPort");\r
11421 }\r
11422 void OutRpcNodeInfo(PACK *p, NODE_INFO *t)\r
11423 {\r
11424         // 引数チェック\r
11425         if (t == NULL || p == NULL)\r
11426         {\r
11427                 return;\r
11428         }\r
11429 \r
11430         PackAddStr(p, "ClientProductName", t->ClientProductName);\r
11431         PackAddStr(p, "ServerProductName", t->ServerProductName);\r
11432         PackAddStr(p, "ClientOsName", t->ClientOsName);\r
11433         PackAddStr(p, "ClientOsVer", t->ClientOsVer);\r
11434         PackAddStr(p, "ClientOsProductId", t->ClientOsProductId);\r
11435         PackAddStr(p, "ClientHostname", t->ClientHostname);\r
11436         PackAddStr(p, "ServerHostname", t->ServerHostname);\r
11437         PackAddStr(p, "ProxyHostname", t->ProxyHostname);\r
11438         PackAddStr(p, "HubName", t->HubName);\r
11439         PackAddData(p, "UniqueId", t->UniqueId, sizeof(t->UniqueId));\r
11440 \r
11441         PackAddInt(p, "ClientProductVer", t->ClientProductVer);\r
11442         PackAddInt(p, "ClientProductBuild", t->ClientProductBuild);\r
11443         PackAddInt(p, "ServerProductVer", t->ServerProductVer);\r
11444         PackAddInt(p, "ServerProductBuild", t->ServerProductBuild);\r
11445         PackAddIp32(p, "ClientIpAddress", t->ClientIpAddress);\r
11446         PackAddData(p, "ClientIpAddress6", t->ClientIpAddress6, sizeof(t->ClientIpAddress6));\r
11447         PackAddInt(p, "ClientPort", t->ClientPort);\r
11448         PackAddIp32(p, "ServerIpAddress", t->ServerIpAddress);\r
11449         PackAddData(p, "ServerIpAddress6", t->ServerIpAddress6, sizeof(t->ServerIpAddress6));\r
11450         PackAddInt(p, "ServerPort2", t->ServerPort);\r
11451         PackAddIp32(p, "ProxyIpAddress", t->ProxyIpAddress);\r
11452         PackAddData(p, "ProxyIpAddress6", t->ProxyIpAddress6, sizeof(t->ProxyIpAddress6));\r
11453         PackAddInt(p, "ProxyPort", t->ProxyPort);\r
11454 }\r
11455 \r
11456 // RPC_SESSION_STATUS\r
11457 void InRpcSessionStatus(RPC_SESSION_STATUS *t, PACK *p)\r
11458 {\r
11459         // 引数チェック\r
11460         if (t == NULL || p == NULL)\r
11461         {\r
11462                 return;\r
11463         }\r
11464 \r
11465         Zero(t, sizeof(RPC_SESSION_STATUS));\r
11466         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11467         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
11468         PackGetStr(p, "Username", t->Username, sizeof(t->Username));\r
11469         PackGetStr(p, "GroupName", t->GroupName, sizeof(t->GroupName));\r
11470         PackGetStr(p, "RealUsername", t->RealUsername, sizeof(t->RealUsername));\r
11471         t->ClientIp = PackGetIp32(p, "SessionStatus_ClientIp");\r
11472         PackGetData2(p, "SessionStatus_ClientIp6", t->ClientIp6, sizeof(t->ClientIp6));\r
11473         PackGetStr(p, "SessionStatus_ClientHostName", t->ClientHostName, sizeof(t->ClientHostName));\r
11474 \r
11475         InRpcClientGetConnectionStatus(&t->Status, p);\r
11476         InRpcNodeInfo(&t->NodeInfo, p);\r
11477 }\r
11478 void OutRpcSessionStatus(PACK *p, RPC_SESSION_STATUS *t)\r
11479 {\r
11480         // 引数チェック\r
11481         if (t == NULL || p == NULL)\r
11482         {\r
11483                 return;\r
11484         }\r
11485 \r
11486         PackAddStr(p, "HubName", t->HubName);\r
11487         PackAddStr(p, "Name", t->Name);\r
11488         PackAddStr(p, "Username", t->Username);\r
11489         PackAddStr(p, "GroupName", t->GroupName);\r
11490         PackAddStr(p, "RealUsername", t->RealUsername);\r
11491         PackAddIp32(p, "SessionStatus_ClientIp", t->ClientIp);\r
11492         PackAddData(p, "SessionStatus_ClientIp6", t->ClientIp6, sizeof(t->ClientIp6));\r
11493         PackAddStr(p, "SessionStatus_ClientHostName", t->ClientHostName);\r
11494 \r
11495         OutRpcClientGetConnectionStatus(p, &t->Status);\r
11496         OutRpcNodeInfo(p, &t->NodeInfo);\r
11497 }\r
11498 void FreeRpcSessionStatus(RPC_SESSION_STATUS *t)\r
11499 {\r
11500         // 引数チェック\r
11501         if (t == NULL)\r
11502         {\r
11503                 return;\r
11504         }\r
11505 \r
11506         CiFreeClientGetConnectionStatus(&t->Status);\r
11507 }\r
11508 \r
11509 // RPC_DELETE_SESSION\r
11510 void InRpcDeleteSession(RPC_DELETE_SESSION *t, PACK *p)\r
11511 {\r
11512         // 引数チェック\r
11513         if (t == NULL || p == NULL)\r
11514         {\r
11515                 return;\r
11516         }\r
11517 \r
11518         Zero(t, sizeof(RPC_DELETE_SESSION));\r
11519         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11520         PackGetStr(p, "Name", t->Name, sizeof(t->Name));\r
11521 }\r
11522 void OutRpcDeleteSession(PACK *p, RPC_DELETE_SESSION *t)\r
11523 {\r
11524         // 引数チェック\r
11525         if (t == NULL || p == NULL)\r
11526         {\r
11527                 return;\r
11528         }\r
11529 \r
11530         PackAddStr(p, "HubName", t->HubName);\r
11531         PackAddStr(p, "Name", t->Name);\r
11532 }\r
11533 \r
11534 // RPC_ENUM_MAC_TABLE\r
11535 void InRpcEnumMacTable(RPC_ENUM_MAC_TABLE *t, PACK *p)\r
11536 {\r
11537         UINT i;\r
11538         // 引数チェック\r
11539         if (t == NULL || p == NULL)\r
11540         {\r
11541                 return;\r
11542         }\r
11543 \r
11544         Zero(t, sizeof(RPC_ENUM_MAC_TABLE));\r
11545         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11546         t->NumMacTable = PackGetIndexCount(p, "SessionName");\r
11547         t->MacTables = ZeroMalloc(sizeof(RPC_ENUM_MAC_TABLE_ITEM) * t->NumMacTable);\r
11548 \r
11549         for (i = 0;i < t->NumMacTable;i++)\r
11550         {\r
11551                 RPC_ENUM_MAC_TABLE_ITEM *e = &t->MacTables[i];\r
11552 \r
11553                 e->Key = PackGetIntEx(p, "Key", i);\r
11554                 PackGetStrEx(p, "SessionName", e->SessionName, sizeof(e->SessionName), i);\r
11555                 PackGetDataEx2(p, "MacAddress", e->MacAddress, sizeof(e->MacAddress), i);\r
11556                 e->VlanId = PackGetIntEx(p, "VlanId", i);\r
11557                 e->CreatedTime = PackGetInt64Ex(p, "CreatedTime", i);\r
11558                 e->UpdatedTime = PackGetInt64Ex(p, "UpdatedTime", i);\r
11559                 e->RemoteItem = PackGetBoolEx(p, "RemoteItem", i);\r
11560                 PackGetStrEx(p, "RemoteHostname", e->RemoteHostname, sizeof(e->RemoteHostname), i);\r
11561         }\r
11562 }\r
11563 void OutRpcEnumMacTable(PACK *p, RPC_ENUM_MAC_TABLE *t)\r
11564 {\r
11565         UINT i;\r
11566         // 引数チェック\r
11567         if (t == NULL || p == NULL)\r
11568         {\r
11569                 return;\r
11570         }\r
11571 \r
11572         PackAddStr(p, "HubName", t->HubName);\r
11573 \r
11574         for (i = 0;i < t->NumMacTable;i++)\r
11575         {\r
11576                 RPC_ENUM_MAC_TABLE_ITEM *e = &t->MacTables[i];\r
11577 \r
11578                 PackAddIntEx(p, "Key", e->Key, i, t->NumMacTable);\r
11579                 PackAddStrEx(p, "SessionName", e->SessionName, i, t->NumMacTable);\r
11580                 PackAddDataEx(p, "MacAddress", e->MacAddress, sizeof(e->MacAddress), i, t->NumMacTable);\r
11581                 PackAddIntEx(p, "VlanId", e->VlanId, i, t->NumMacTable);\r
11582                 PackAddInt64Ex(p, "CreatedTime", e->CreatedTime, i, t->NumMacTable);\r
11583                 PackAddInt64Ex(p, "UpdatedTime", e->UpdatedTime, i, t->NumMacTable);\r
11584                 PackAddBoolEx(p, "RemoteItem", e->RemoteItem, i, t->NumMacTable);\r
11585                 PackAddStrEx(p, "RemoteHostname", e->RemoteHostname, i, t->NumMacTable);\r
11586         }\r
11587 }\r
11588 void FreeRpcEnumMacTable(RPC_ENUM_MAC_TABLE *t)\r
11589 {\r
11590         // 引数チェック\r
11591         if (t == NULL)\r
11592         {\r
11593                 return;\r
11594         }\r
11595 \r
11596         Free(t->MacTables);\r
11597 }\r
11598 \r
11599 // RPC_ENUM_IP_TABLE\r
11600 void InRpcEnumIpTable(RPC_ENUM_IP_TABLE *t, PACK *p)\r
11601 {\r
11602         UINT i;\r
11603         // 引数チェック\r
11604         if (t == NULL || p == NULL)\r
11605         {\r
11606                 return;\r
11607         }\r
11608 \r
11609         Zero(t, sizeof(RPC_ENUM_IP_TABLE));\r
11610         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11611         t->NumIpTable = PackGetIndexCount(p, "SessionName");\r
11612         t->IpTables = ZeroMalloc(sizeof(RPC_ENUM_IP_TABLE_ITEM) * t->NumIpTable);\r
11613 \r
11614         for (i = 0;i < t->NumIpTable;i++)\r
11615         {\r
11616                 RPC_ENUM_IP_TABLE_ITEM *e = &t->IpTables[i];\r
11617 \r
11618                 e->Key = PackGetIntEx(p, "Key", i);\r
11619                 PackGetStrEx(p, "SessionName", e->SessionName, sizeof(e->SessionName), i);\r
11620                 e->Ip = PackGetIp32Ex(p, "Ip", i);\r
11621                 if (PackGetIpEx(p, "IpV6", &e->IpV6, i) == false)\r
11622                 {\r
11623                         UINTToIP(&e->IpV6, e->Ip);\r
11624                 }\r
11625                 e->DhcpAllocated = PackGetBoolEx(p, "DhcpAllocated", i);\r
11626                 e->CreatedTime = PackGetInt64Ex(p, "CreatedTime", i);\r
11627                 e->UpdatedTime = PackGetInt64Ex(p, "UpdatedTime", i);\r
11628                 e->RemoteItem = PackGetBoolEx(p, "RemoteItem", i);\r
11629                 PackGetStrEx(p, "RemoteHostname", e->RemoteHostname, sizeof(e->RemoteHostname), i);\r
11630         }\r
11631 }\r
11632 void OutRpcEnumIpTable(PACK *p, RPC_ENUM_IP_TABLE *t)\r
11633 {\r
11634         UINT i;\r
11635         // 引数チェック\r
11636         if (t == NULL || p == NULL)\r
11637         {\r
11638                 return;\r
11639         }\r
11640 \r
11641         PackAddStr(p, "HubName", t->HubName);\r
11642 \r
11643         for (i = 0;i < t->NumIpTable;i++)\r
11644         {\r
11645                 RPC_ENUM_IP_TABLE_ITEM *e = &t->IpTables[i];\r
11646 \r
11647                 PackAddIntEx(p, "Key", e->Key, i, t->NumIpTable);\r
11648                 PackAddStrEx(p, "SessionName", e->SessionName, i, t->NumIpTable);\r
11649                 PackAddIp32Ex(p, "Ip", e->Ip, i, t->NumIpTable);\r
11650                 PackAddIpEx(p, "IpV6", &e->IpV6, i, t->NumIpTable);\r
11651                 PackAddBoolEx(p, "DhcpAllocated", e->DhcpAllocated, i, t->NumIpTable);\r
11652                 PackAddInt64Ex(p, "CreatedTime", e->CreatedTime, i, t->NumIpTable);\r
11653                 PackAddInt64Ex(p, "UpdatedTime", e->UpdatedTime, i, t->NumIpTable);\r
11654                 PackAddBoolEx(p, "RemoteItem", e->RemoteItem, i, t->NumIpTable);\r
11655                 PackAddStrEx(p, "RemoteHostname", e->RemoteHostname, i, t->NumIpTable);\r
11656         }\r
11657 }\r
11658 void FreeRpcEnumIpTable(RPC_ENUM_IP_TABLE *t)\r
11659 {\r
11660         // 引数チェック\r
11661         if (t == NULL)\r
11662         {\r
11663                 return;\r
11664         }\r
11665 \r
11666         Free(t->IpTables);\r
11667 }\r
11668 \r
11669 // RPC_DELETE_TABLE\r
11670 void InRpcDeleteTable(RPC_DELETE_TABLE *t, PACK *p)\r
11671 {\r
11672         // 引数チェック\r
11673         if (t == NULL || p == NULL)\r
11674         {\r
11675                 return;\r
11676         }\r
11677 \r
11678         Zero(t, sizeof(RPC_DELETE_TABLE));\r
11679         PackGetStr(p, "HubName", t->HubName, sizeof(t->HubName));\r
11680         t->Key = PackGetInt(p, "Key");\r
11681 }\r
11682 void OutRpcDeleteTable(PACK *p, RPC_DELETE_TABLE *t)\r
11683 {\r
11684         // 引数チェック\r
11685         if (t == NULL || p == NULL)\r
11686         {\r
11687                 return;\r
11688         }\r
11689 \r
11690         PackAddStr(p, "HubName", t->HubName);\r
11691         PackAddInt(p, "Key", t->Key);\r
11692 }\r
11693 \r
11694 // RPC_ENUM_IP_TABLE の結合\r
11695 void AdjoinRpcEnumIpTable(RPC_ENUM_IP_TABLE *dest, RPC_ENUM_IP_TABLE *src)\r
11696 {\r
11697         UINT old_num;\r
11698         UINT i, n;\r
11699         if (dest == NULL || src == NULL)\r
11700         {\r
11701                 return;\r
11702         }\r
11703 \r
11704         if (src->NumIpTable == 0)\r
11705         {\r
11706                 return;\r
11707         }\r
11708 \r
11709         old_num = dest->NumIpTable;\r
11710         dest->NumIpTable += src->NumIpTable;\r
11711         dest->IpTables = ReAlloc(dest->IpTables, sizeof(RPC_ENUM_IP_TABLE_ITEM) * dest->NumIpTable);\r
11712 \r
11713         n = 0;\r
11714         for (i = old_num;i < dest->NumIpTable;i++)\r
11715         {\r
11716                 Copy(&dest->IpTables[i], &src->IpTables[n++], sizeof(RPC_ENUM_IP_TABLE_ITEM));\r
11717         }\r
11718 }\r
11719 \r
11720 // RPC_ENUM_MAC_TABLE の結合\r
11721 void AdjoinRpcEnumMacTable(RPC_ENUM_MAC_TABLE *dest, RPC_ENUM_MAC_TABLE *src)\r
11722 {\r
11723         UINT old_num;\r
11724         UINT i, n;\r
11725         if (dest == NULL || src == NULL)\r
11726         {\r
11727                 return;\r
11728         }\r
11729 \r
11730         if (src->NumMacTable == 0)\r
11731         {\r
11732                 return;\r
11733         }\r
11734 \r
11735         old_num = dest->NumMacTable;\r
11736         dest->NumMacTable += src->NumMacTable;\r
11737         dest->MacTables = ReAlloc(dest->MacTables, sizeof(RPC_ENUM_MAC_TABLE_ITEM) * dest->NumMacTable);\r
11738 \r
11739         n = 0;\r
11740         for (i = old_num;i < dest->NumMacTable;i++)\r
11741         {\r
11742                 Copy(&dest->MacTables[i], &src->MacTables[n++], sizeof(RPC_ENUM_MAC_TABLE_ITEM));\r
11743         }\r
11744 }\r
11745 \r
11746 // RPC_ENUM_SESSION の結合\r
11747 void AdjoinRpcEnumSession(RPC_ENUM_SESSION *dest, RPC_ENUM_SESSION *src)\r
11748 {\r
11749         UINT old_num;\r
11750         UINT i, n;\r
11751         if (dest == NULL || src == NULL)\r
11752         {\r
11753                 return;\r
11754         }\r
11755 \r
11756         if (src->NumSession == 0)\r
11757         {\r
11758                 return;\r
11759         }\r
11760 \r
11761         old_num = dest->NumSession;\r
11762         dest->NumSession += src->NumSession;\r
11763         dest->Sessions = ReAlloc(dest->Sessions, sizeof(RPC_ENUM_SESSION_ITEM) * dest->NumSession);\r
11764 \r
11765         n = 0;\r
11766         for (i = old_num;i < dest->NumSession;i++)\r
11767         {\r
11768                 Copy(&dest->Sessions[i], &src->Sessions[n++], sizeof(RPC_ENUM_SESSION_ITEM));\r
11769         }\r
11770 }\r
11771 \r
11772 // RPC_KEEP\r
11773 void InRpcKeep(RPC_KEEP *t, PACK *p)\r
11774 {\r
11775         // 引数チェック\r
11776         if (t == NULL || p == NULL)\r
11777         {\r
11778                 return;\r
11779         }\r
11780 \r
11781         Zero(t, sizeof(RPC_KEEP));\r
11782         t->UseKeepConnect = PackGetBool(p, "UseKeepConnect");\r
11783         PackGetStr(p, "KeepConnectHost", t->KeepConnectHost, sizeof(t->KeepConnectHost));\r
11784         t->KeepConnectPort = PackGetInt(p, "KeepConnectPort");\r
11785         t->KeepConnectProtocol = PackGetInt(p, "KeepConnectProtocol");\r
11786         t->KeepConnectInterval = PackGetInt(p, "KeepConnectInterval");\r
11787 }\r
11788 void OutRpcKeep(PACK *p, RPC_KEEP *t)\r
11789 {\r
11790         // 引数チェック\r
11791         if (t == NULL || p == NULL)\r
11792         {\r
11793                 return;\r
11794         }\r
11795 \r
11796         PackAddBool(p, "UseKeepConnect", t->UseKeepConnect);\r
11797         PackAddStr(p, "KeepConnectHost", t->KeepConnectHost);\r
11798         PackAddInt(p, "KeepConnectPort", t->KeepConnectPort);\r
11799         PackAddInt(p, "KeepConnectProtocol", t->KeepConnectProtocol);\r
11800         PackAddInt(p, "KeepConnectInterval", t->KeepConnectInterval);\r
11801 }\r
11802 \r
11803 // テスト RPC 関数\r
11804 UINT StTest(ADMIN *a, RPC_TEST *t)\r
11805 {\r
11806         Format(t->StrValue, sizeof(t->StrValue), "%u", t->IntValue);\r
11807 \r
11808         return ERR_NO_ERROR;\r
11809 }\r
11810 \r
11811 // RPC_TEST\r
11812 void InRpcTest(RPC_TEST *t, PACK *p)\r
11813 {\r
11814         Zero(t, sizeof(RPC_TEST));\r
11815         t->IntValue = PackGetInt(p, "IntValue");\r
11816         PackGetStr(p, "StrValue", t->StrValue, sizeof(t->StrValue));\r
11817 }\r
11818 void OutRpcTest(PACK *p, RPC_TEST *t)\r
11819 {\r
11820         PackAddInt(p, "IntValue", t->IntValue);\r
11821         PackAddStr(p, "StrValue", t->StrValue);\r
11822 }\r
11823 void FreeRpcTest(RPC_TEST *t)\r
11824 {\r
11825 }\r
11826 \r
11827 // 管理用呼び出し\r
11828 PACK *AdminCall(RPC *rpc, char *function_name, PACK *p)\r
11829 {\r
11830         // 引数チェック\r
11831         if (rpc == NULL || function_name == NULL)\r
11832         {\r
11833                 return NULL;\r
11834         }\r
11835         if (p == NULL)\r
11836         {\r
11837                 p = NewPack();\r
11838         }\r
11839 \r
11840         return RpcCall(rpc, function_name, p);\r
11841 }\r
11842 \r
11843 // 管理用コネクションのソースアドレスが許可されているかどうか調べる\r
11844 bool CheckAdminSourceAddress(SOCK *sock, char *hubname)\r
11845 {\r
11846         BUF *b;\r
11847         char *s;\r
11848         bool ok = false;\r
11849         // 引数チェック\r
11850         if (sock == NULL)\r
11851         {\r
11852                 return false;\r
11853         }\r
11854 \r
11855         b = ReadDump(ADMINIP_TXT);\r
11856         if (b == NULL)\r
11857         {\r
11858                 return true;\r
11859         }\r
11860 \r
11861         while (true)\r
11862         {\r
11863                 UINT i;\r
11864                 TOKEN_LIST *t;\r
11865                 IP ip;\r
11866                 s = CfgReadNextLine(b);\r
11867 \r
11868                 if (s == NULL)\r
11869                 {\r
11870                         break;\r
11871                 }\r
11872 \r
11873                 Trim(s);\r
11874 \r
11875                 i = SearchStrEx(s, "//", 0, false);\r
11876                 if (i != INFINITE)\r
11877                 {\r
11878                         s[i] = 0;\r
11879                 }\r
11880 \r
11881                 i = SearchStrEx(s, "#", 0, false);\r
11882                 if (i != INFINITE)\r
11883                 {\r
11884                         s[i] = 0;\r
11885                 }\r
11886 \r
11887                 Trim(s);\r
11888 \r
11889                 t = ParseToken(s, " \t");\r
11890                 if (t != NULL)\r
11891                 {\r
11892                         if (t->NumTokens >= 1)\r
11893                         {\r
11894                                 if (t->NumTokens == 1 || StrCmpi(hubname, t->Token[1]) == 0)\r
11895                                 {\r
11896                                         if (StrToIP(&ip, t->Token[0]))\r
11897                                         {\r
11898                                                 if (CmpIpAddr(&sock->RemoteIP, &ip) == 0)\r
11899                                                 {\r
11900                                                         ok = true;\r
11901                                                 }\r
11902                                         }\r
11903 \r
11904                                         if (StrCmpi(t->Token[0], "*") == 0)\r
11905                                         {\r
11906                                                 ok = true;\r
11907                                         }\r
11908                                 }\r
11909                         }\r
11910 \r
11911                         FreeToken(t);\r
11912                 }\r
11913 \r
11914                 Free(s);\r
11915         }\r
11916 \r
11917         FreeBuf(b);\r
11918 \r
11919         return ok;\r
11920 }\r
11921 \r
11922 // 管理用コネクション受け入れ\r
11923 UINT AdminAccept(CONNECTION *c, PACK *p)\r
11924 {\r
11925         ADMIN *a;\r
11926         UCHAR secure_password[SHA1_SIZE];\r
11927         UCHAR null_password[SHA1_SIZE];\r
11928         UCHAR secure_null_password[SHA1_SIZE];\r
11929         char hubname[MAX_HUBNAME_LEN + 1];\r
11930         CEDAR *cedar;\r
11931         SOCK *sock;\r
11932         RPC *rpc;\r
11933         UINT err;\r
11934         RPC_WINVER ver;\r
11935         // 引数チェック\r
11936         if (c == NULL || p == NULL)\r
11937         {\r
11938                 return ERR_INTERNAL_ERROR;\r
11939         }\r
11940 \r
11941         cedar = c->Cedar;\r
11942         sock = c->FirstSock;\r
11943 \r
11944         // クライアント OS を取得\r
11945         InRpcWinVer(&ver, p);\r
11946 \r
11947         // HUB 名を取得\r
11948         if (PackGetStr(p, "hubname", hubname, sizeof(hubname)) == false)\r
11949         {\r
11950                 // HUB 名無し\r
11951                 StrCpy(hubname, sizeof(hubname), "");\r
11952         }\r
11953 \r
11954         // IP アドレスを見て許可するかどうか決める\r
11955         if (CheckAdminSourceAddress(sock, hubname) == false)\r
11956         {\r
11957                 SLog(c->Cedar, "LA_IP_DENIED", c->Name);\r
11958                 return ERR_IP_ADDRESS_DENIED;\r
11959         }\r
11960 \r
11961         // パスワードを取得\r
11962         if (PackGetDataSize(p, "secure_password") != SHA1_SIZE)\r
11963         {\r
11964                 // プロトコルエラー\r
11965                 return ERR_PROTOCOL_ERROR;\r
11966         }\r
11967         PackGetData(p, "secure_password", secure_password);\r
11968 \r
11969         if (StrLen(hubname) == 0)\r
11970         {\r
11971                 // サーバー管理モード接続\r
11972                 SLog(c->Cedar, "LA_CONNECTED_1", c->Name);\r
11973         }\r
11974         else\r
11975         {\r
11976                 // 仮想 HUB 管理モード接続\r
11977                 if (cedar->Server != NULL && cedar->Server->ServerType == SERVER_TYPE_FARM_MEMBER)\r
11978                 {\r
11979                         // クラスタ メンバには仮想 HUB 管理モードで接続することはできない\r
11980                         return ERR_NOT_ENOUGH_RIGHT;\r
11981                 }\r
11982                 SLog(c->Cedar, "LA_CONNECTED_2", c->Name, hubname);\r
11983         }\r
11984 \r
11985         // パスワードチェック\r
11986         err = AdminCheckPassword(cedar, c->Random, secure_password,\r
11987                 StrLen(hubname) != 0 ? hubname : NULL);\r
11988 \r
11989         if (err != ERR_NO_ERROR)\r
11990         {\r
11991                 // エラー発生\r
11992                 SLog(c->Cedar, "LA_ERROR", c->Name, GetUniErrorStr(err), err);\r
11993                 return err;\r
11994         }\r
11995 \r
11996         SLog(c->Cedar, "LA_OK", c->Name);\r
11997 \r
11998         HashAdminPassword(null_password, "");\r
11999         SecurePassword(secure_null_password, null_password, c->Random);\r
12000 \r
12001         if (Cmp(secure_null_password, secure_password, SHA1_SIZE) == 0)\r
12002         {\r
12003                 if (sock->RemoteIP.addr[0] != 127)\r
12004                 {\r
12005                         // パスワードが空であるがリモート接続しようとした\r
12006                         // (仮想 HUB 管理モードのみ)\r
12007                         if (StrLen(hubname) != 0)\r
12008                         {\r
12009                                 return ERR_NULL_PASSWORD_LOCAL_ONLY;\r
12010                         }\r
12011                 }\r
12012         }\r
12013 \r
12014         // 成功結果を送信\r
12015         p = NewPack();\r
12016         HttpServerSend(sock, p);\r
12017         FreePack(p);\r
12018 \r
12019         // ADMIN 構造体を作成\r
12020         a = ZeroMalloc(sizeof(ADMIN));\r
12021         a->ServerAdmin = ((StrLen(hubname) == 0) ? true : false);\r
12022         a->HubName = (StrLen(hubname) != 0 ? hubname : NULL);\r
12023         a->Server = c->Cedar->Server;\r
12024         a->ClientBuild = c->ClientBuild;\r
12025 \r
12026         Copy(&a->ClientWinVer, &ver, sizeof(RPC_WINVER));\r
12027 \r
12028         // タイムアウト設定\r
12029         SetTimeout(sock, INFINITE);\r
12030 \r
12031         // RPC サーバー\r
12032         rpc = StartRpcServer(sock, AdminDispatch, a);\r
12033 \r
12034         a->Rpc = rpc;\r
12035 \r
12036         SLog(c->Cedar, "LA_RPC_START", c->Name, rpc->Name);\r
12037 \r
12038         RpcServer(rpc);\r
12039         RpcFree(rpc);\r
12040 \r
12041         if (a->LogFileList != NULL)\r
12042         {\r
12043                 // キャッシュされたログファイル列挙リストがあれば解放する\r
12044                 FreeEnumLogFile(a->LogFileList);\r
12045         }\r
12046 \r
12047         // ADMIN 構造体を解放\r
12048         Free(a);\r
12049 \r
12050         return ERR_NO_ERROR;\r
12051 }\r
12052 \r
12053 // 管理者パスワードのチェック\r
12054 UINT AdminCheckPassword(CEDAR *c, void *random, void *secure_password, char *hubname)\r
12055 {\r
12056         UCHAR check[SHA1_SIZE];\r
12057         // 引数チェック\r
12058         if (c == NULL || random == NULL || secure_password == NULL)\r
12059         {\r
12060                 return ERR_INTERNAL_ERROR;\r
12061         }\r
12062 \r
12063         if (hubname == NULL || StrLen(hubname) == 0)\r
12064         {\r
12065                 // サーバー全体の管理モード\r
12066                 Lock(c->lock);\r
12067                 {\r
12068                         SecurePassword(check, c->Server->HashedPassword, random);\r
12069                 }\r
12070                 Unlock(c->lock);\r
12071 \r
12072                 if (Cmp(check, secure_password, SHA1_SIZE) != 0)\r
12073                 {\r
12074                         // パスワード相違\r
12075                         return ERR_ACCESS_DENIED;\r
12076                 }\r
12077         }\r
12078         else\r
12079         {\r
12080                 HUB *h;\r
12081 \r
12082 #if     0\r
12083                 if (c->Server->ServerType == SERVER_TYPE_FARM_MEMBER)\r
12084                 {\r
12085                         // ファームメンバの場合は HUB 管理モードで接続できない\r
12086                         return ERR_FARM_MEMBER_HUB_ADMIN;\r
12087                 }\r
12088 #endif\r
12089 \r
12090                 // HUB 管理モード\r
12091                 LockHubList(c);\r
12092                 {\r
12093                         h = GetHub(c, hubname);\r
12094                 }\r
12095                 UnlockHubList(c);\r
12096 \r
12097                 if (h == NULL)\r
12098                 {\r
12099                         // HUB が見つからない\r
12100                         return ERR_HUB_NOT_FOUND;\r
12101                 }\r
12102 \r
12103                 Lock(h->lock);\r
12104                 {\r
12105                         SecurePassword(check, h->HashedPassword, random);\r
12106                 }\r
12107                 Unlock(h->lock);\r
12108 \r
12109                 ReleaseHub(h);\r
12110 \r
12111                 if (Cmp(check, secure_password, SHA1_SIZE) != 0)\r
12112                 {\r
12113                         // パスワード相違\r
12114                         return ERR_ACCESS_DENIED;\r
12115                 }\r
12116         }\r
12117 \r
12118         return ERR_NO_ERROR;\r
12119 }\r
12120 \r
12121 // 管理者パスワードのハッシュ\r
12122 void HashAdminPassword(void *hash, char *password)\r
12123 {\r
12124         // 引数チェック\r
12125         if (hash == NULL || password == NULL)\r
12126         {\r
12127                 return;\r
12128         }\r
12129 \r
12130         Hash(hash, password, StrLen(password), true);\r
12131 }\r
12132 \r
12133 // 管理用コネクション切断\r
12134 void AdminDisconnect(RPC *rpc)\r
12135 {\r
12136         SESSION *s;\r
12137         SOCK *sock;\r
12138         // 引数チェック\r
12139         if (rpc == NULL)\r
12140         {\r
12141                 return;\r
12142         }\r
12143 \r
12144         s = (SESSION *)rpc->Param;\r
12145         sock = rpc->Sock;\r
12146 \r
12147         EndRpc(rpc);\r
12148 \r
12149         Disconnect(sock);\r
12150         ReleaseSession(s);\r
12151 }\r
12152 \r
12153 // 管理接続メイン\r
12154 SESSION *AdminConnectMain(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name, void *hWnd)\r
12155 {\r
12156         UCHAR secure_password[SHA1_SIZE];\r
12157         SESSION *s;\r
12158         SOCK *sock;\r
12159         PACK *p;\r
12160         RPC_WINVER ver;\r
12161         // 接続\r
12162         s = NewRpcSessionEx2(cedar, o, err, client_name, hWnd);\r
12163         if (s == NULL)\r
12164         {\r
12165                 return NULL;\r
12166         }\r
12167 \r
12168         // ソケット取得\r
12169         sock = s->Connection->FirstSock;\r
12170 \r
12171         // 接続メソッド作成\r
12172         p = NewPack();\r
12173 \r
12174         PackAddClientVersion(p, s->Connection);\r
12175 \r
12176         PackAddStr(p, "method", "admin");\r
12177 \r
12178         // クライアント Windows バージョン\r
12179         GetWinVer(&ver);\r
12180         OutRpcWinVer(p, &ver);\r
12181 \r
12182         // セキュアパスワード\r
12183         SecurePassword(secure_password, hashed_password, s->Connection->Random);\r
12184 \r
12185         PackAddData(p, "secure_password", secure_password, sizeof(secure_password));\r
12186 \r
12187         // HUB 名\r
12188         if (hubname != NULL)\r
12189         {\r
12190                 PackAddStr(p, "hubname", hubname);\r
12191         }\r
12192 \r
12193         if (HttpClientSend(sock, p) == false)\r
12194         {\r
12195                 // 切断\r
12196                 FreePack(p);\r
12197                 ReleaseSession(s);\r
12198                 *err = ERR_DISCONNECTED;\r
12199                 return NULL;\r
12200         }\r
12201 \r
12202         FreePack(p);\r
12203 \r
12204         p = HttpClientRecv(sock);\r
12205         if (p == NULL)\r
12206         {\r
12207                 // 切断\r
12208                 ReleaseSession(s);\r
12209                 *err = ERR_DISCONNECTED;\r
12210                 return NULL;\r
12211         }\r
12212 \r
12213         if (GetErrorFromPack(p) != 0)\r
12214         {\r
12215                 // エラー\r
12216                 ReleaseSession(s);\r
12217                 *err = GetErrorFromPack(p);\r
12218                 FreePack(p);\r
12219                 return NULL;\r
12220         }\r
12221 \r
12222         FreePack(p);\r
12223 \r
12224         return s;\r
12225 }\r
12226 \r
12227 // 管理用コネクション接続\r
12228 RPC *AdminConnect(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err)\r
12229 {\r
12230         return AdminConnectEx(cedar, o, hubname, hashed_password, err, NULL);\r
12231 }\r
12232 RPC *AdminConnectEx(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name)\r
12233 {\r
12234         return AdminConnectEx2(cedar, o, hubname, hashed_password, err, client_name, NULL);\r
12235 }\r
12236 RPC *AdminConnectEx2(CEDAR *cedar, CLIENT_OPTION *o, char *hubname, void *hashed_password, UINT *err, char *client_name, void *hWnd)\r
12237 {\r
12238         SESSION *s;\r
12239         SOCK *sock;\r
12240         RPC *rpc;\r
12241         // 引数チェック\r
12242         if (cedar == NULL || o == NULL || hashed_password == NULL || err == NULL)\r
12243         {\r
12244                 return NULL;\r
12245         }\r
12246 \r
12247         if (client_name == NULL)\r
12248         {\r
12249                 client_name = CEDAR_MANAGER_STR;\r
12250         }\r
12251 \r
12252         s = AdminConnectMain(cedar, o, hubname, hashed_password, err, client_name, hWnd);\r
12253 \r
12254         if (s == NULL)\r
12255         {\r
12256                 return NULL;\r
12257         }\r
12258 \r
12259         sock = s->Connection->FirstSock;\r
12260 \r
12261         // RPC 開始\r
12262         rpc = StartRpcClient(sock, s);\r
12263 \r
12264         rpc->IsVpnServer = true;\r
12265         Copy(&rpc->VpnServerClientOption, o, sizeof(CLIENT_OPTION));\r
12266         StrCpy(rpc->VpnServerHubName, sizeof(rpc->VpnServerHubName), hubname);\r
12267         Copy(rpc->VpnServerHashedPassword, hashed_password, SHA1_SIZE);\r
12268         StrCpy(rpc->VpnServerClientName, sizeof(rpc->VpnServerClientName), client_name);\r
12269 \r
12270         // タイムアウト設定\r
12271         SetTimeout(sock, INFINITE);\r
12272 \r
12273         return rpc;\r
12274 }\r
12275 \r
12276 // 再接続\r
12277 UINT AdminReconnect(RPC *rpc)\r
12278 {\r
12279         SESSION *s;\r
12280         SOCK *sock;\r
12281         CEDAR *cedar;\r
12282         UINT err;\r
12283         // 引数チェック\r
12284         if (rpc == NULL || rpc->IsVpnServer == false)\r
12285         {\r
12286                 return ERR_INTERNAL_ERROR;\r
12287         }\r
12288 \r
12289         s = (SESSION *)rpc->Param;\r
12290         cedar = s->Cedar;\r
12291         AddRef(cedar->ref);\r
12292 \r
12293         sock = rpc->Sock;\r
12294         Disconnect(sock);\r
12295         ReleaseSock(sock);\r
12296         ReleaseSession(s);\r
12297         rpc->Param = NULL;\r
12298 \r
12299         rpc->Sock = NULL;\r
12300 \r
12301         s = AdminConnectMain(cedar, &rpc->VpnServerClientOption,\r
12302                 rpc->VpnServerHubName,\r
12303                 rpc->VpnServerHashedPassword,\r
12304                 &err,\r
12305                 rpc->VpnServerClientName, NULL);\r
12306 \r
12307         ReleaseCedar(cedar);\r
12308 \r
12309         if (s == NULL)\r
12310         {\r
12311                 return err;\r
12312         }\r
12313 \r
12314         rpc->Param = s;\r
12315         rpc->Sock = s->Connection->FirstSock;\r
12316         AddRef(rpc->Sock->ref);\r
12317 \r
12318         return ERR_NO_ERROR;\r
12319 }\r
12320 \r