Context Navigation

source: lab.git/Dev/utvpn/utvpn-unix-v101-7101-public/src/Cedar/Protocol.c

Last change on this file was a1bae3e, checked in by mitty <mitty@…>, 12 years ago

copy vendor drop to trunk

git-svn-id: https://lab.mitty.jp/svn/lab/trunk@147 7d2118f6-f56c-43e7-95a2-4bb3031d96e7

Property mode set to 100644

File size: 157.7 KB

Line
1	// SoftEther UT-VPN SourceCode
2	//
3	// Copyright (C) 2004-2010 SoftEther Corporation.
4	// Copyright (C) 2004-2010 University of Tsukuba, Japan.
5	// Copyright (C) 2003-2010 Daiyuu Nobori.
6	// All Rights Reserved.
7	//
8	// http://utvpn.tsukuba.ac.jp/
9	//
10	// This program is free software; you can redistribute it and/or
11	// modify it under the terms of the GNU General Public License
12	// version 2 as published by the Free Software Foundation.
13	//
14	// This program is distributed in the hope that it will be useful,
15	// but WITHOUT ANY WARRANTY; without even the implied warranty of
16	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	// GNU General Public License for more details.
18	//
19	// You should have received a copy of the GNU General Public License version 2
20	// along with this program; if not, write to the Free Software
21	// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22	//
23	// このファイルは GPL バージョン 2 ライセンスで公開されています。
24	// 誰でもこのファイルの内容を複製、改変したり、改変したバージョンを再配布
25	// することができます。ただし、原著作物を改変した場合は、原著作物の著作権表示
26	// を除去することはできません。改変した著作物を配布する場合は、改変実施者の
27	// 著作権表示を原著作物の著作権表示に付随して記載するようにしてください。
28	//
29	// この SoftEther UT-VPN オープンソース・プロジェクトは、日本国の
30	// ソフトイーサ株式会社 (SoftEther Corporation, http://www.softether.co.jp/ )
31	// および筑波大学 (University of Tsukuba, http://www.tsukuba.ac.jp/ ) によって
32	// ホストされています。
33	// 本プログラムの配布者は、本プログラムを、業としての利用以外のため、
34	// および、試験または研究のために利用が行われることを想定して配布
35	// しています。
36	// SoftEther UT-VPN プロジェクトの Web サイトは http://utvpn.tsukuba.ac.jp/ に
37	// あります。
38	// 本ソフトウェアの不具合の修正、機能改良、セキュリティホールの修復などのコード
39	// の改変を行った場合で、その成果物を SoftEther UT-VPN プロジェクトに提出して
40	// いただける場合は、 http://utvpn.tsukuba.ac.jp/ までソースコードを送付して
41	// ください。SoftEther UT-VPN プロジェクトの本体リリースまたはブランチリリース
42	// に組み込みさせていただきます。
43	//
44	// GPL に基づいて原著作物が提供される本ソフトウェアの改良版を配布、販売する
45	// 場合は、そのソースコードを GPL に基づいて誰にでも開示する義務が生じます。
46	//
47	// 本ソフトウェアに関連する著作権、特許権、商標権はソフトイーサ株式会社
48	// (SoftEther Corporation) およびその他の著作権保持者が保有しています。
49	// ソフトイーサ株式会社等はこれらの権利を放棄していません。本ソフトウェアの
50	// 二次著作物を配布、販売する場合は、これらの権利を侵害しないようにご注意
51	// ください。
52	//
53	// お願い: どのような通信ソフトウェアにも通常は必ず未発見の
54	// セキュリティホールが潜んでいます。本ソースコードをご覧いただいた結果、
55	// UT-VPN にセキュリティホールを発見された場合は、当該セキュリティホールの
56	// 情報を不特定多数に開示される前に、必ず、ソフトイーサ株式会社
57	// および脆弱性情報の届出を受け付ける公的機関まで通報いただき、
58	// 公益保護にご協力いただきますようお願い申し上げます。
59	//
60	// ソフトイーサ株式会社は、当該セキュリティホールについて迅速に対処を
61	// 行い、UT-VPN および UT-VPN に関連するソフトウェアのユーザー・顧客
62	// を保護するための努力を行います。
63	//
64	// ソフトイーサへの届出先: http://www.softether.co.jp/jp/contact/
65	// 日本国内の脆弱性情報届出受付公的機関:
66	// 独立行政法人情報処理推進機構
67	// http://www.ipa.go.jp/security/vuln/report/
68	//
69	// 上記各事項について不明な点は、ソフトイーサ株式会社までご連絡ください。
70	// 連絡先: http://www.softether.co.jp/jp/contact/
71
72	// -----------------------------------------------
73	// [ChangeLog]
74	// 2010.05.20
75	// 新規リリース by SoftEther
76	// -----------------------------------------------
77
78	// Protocol.c
79	// SoftEther プロトコル関係のルーチン
80
81	#include "CedarPch.h"
82
83	static char http_404_str[] = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<HTML><HEAD>\r\n<TITLE>404 Not Found</TITLE>\r\n</HEAD><BODY>\r\n<H1>Not Found</H1>\r\nThe requested URL $TARGET$ was not found on this server.<P>\r\n<HR>\r\n<ADDRESS>HTTP Server at $HOST$ Port $PORT$</ADDRESS>\r\n</BODY></HTML>\r\n";
84	static char http_403_str[] = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<HTML><HEAD>\r\n<TITLE>403 Forbidden</TITLE>\r\n</HEAD><BODY>\r\n<H1>Forbidden</H1>\r\nYou don't have permission to access $TARGET$\r\non this server.<P>\r\n<HR>\r\n<ADDRESS>HTTP Server at $HOST$ Port $PORT$</ADDRESS>\r\n</BODY></HTML>\r\n";
85	static char http_501_str[] = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<HTML><HEAD>\r\n<TITLE>501 Method Not Implemented</TITLE>\r\n</HEAD><BODY>\r\n<H1>Method Not Implemented</H1>\r\n$METHOD$ to $TARGET$ not supported.<P>\r\nInvalid method in request $METHOD$ $TARGET$ $VERSION$<P>\r\n<HR>\r\n<ADDRESS>HTTP Server at $HOST$ Port $PORT$</ADDRESS>\r\n</BODY></HTML>\r\n";
86
87	// マシンごとにユニークな ID を生成する
88	void GenerateMachineUniqueHash(void *data)
89	{
90	BUF *b;
91	char name[64];
92	char ip_str[64];
93	IP ip;
94	OS_INFO *osinfo;
95	// 引数チェック
96	if (data == NULL)
97	{
98	return;
99	}
100
101	b = NewBuf();
102	GetMachineName(name, sizeof(name));
103	GetMachineIp(&ip);
104	IPToStr(ip_str, sizeof(ip_str), &ip);
105
106	osinfo = GetOsInfo();
107
108	WriteBuf(b, name, StrLen(name));
109	WriteBuf(b, ip_str, StrLen(ip_str));
110
111	WriteBuf(b, &osinfo->OsType, sizeof(osinfo->OsType));
112	WriteBuf(b, osinfo->KernelName, StrLen(osinfo->KernelName));
113	WriteBuf(b, osinfo->KernelVersion, StrLen(osinfo->KernelVersion));
114	WriteBuf(b, osinfo->OsProductName, StrLen(osinfo->OsProductName));
115	WriteBuf(b, &osinfo->OsServicePack, sizeof(osinfo->OsServicePack));
116	WriteBuf(b, osinfo->OsSystemName, StrLen(osinfo->OsSystemName));
117	WriteBuf(b, osinfo->OsVendorName, StrLen(osinfo->OsVendorName));
118	WriteBuf(b, osinfo->OsVersion, StrLen(osinfo->OsVersion));
119
120	Hash(data, b->Buf, b->Size, true);
121
122	FreeBuf(b);
123	}
124
125	// ノード情報を文字列に変換する
126	void NodeInfoToStr(wchar_t str, UINT size, NODE_INFO info)
127	{
128	char client_ip[128], server_ip[128], proxy_ip[128], unique_id[128];
129	// 引数チェック
130	if (str == NULL \|\| info == NULL)
131	{
132	return;
133	}
134
135	IPToStr4or6(client_ip, sizeof(client_ip), info->ClientIpAddress, info->ClientIpAddress6);
136	IPToStr4or6(server_ip, sizeof(server_ip), info->ServerIpAddress, info->ServerIpAddress6);
137	IPToStr4or6(proxy_ip, sizeof(proxy_ip), info->ProxyIpAddress, info->ProxyIpAddress6);
138	BinToStr(unique_id, sizeof(unique_id), info->UniqueId, sizeof(info->UniqueId));
139
140	UniFormat(str, size, _UU("LS_NODE_INFO_TAG"), info->ClientProductName,
141	Endian32(info->ClientProductVer), Endian32(info->ClientProductBuild),
142	info->ServerProductName, Endian32(info->ServerProductVer), Endian32(info->ServerProductBuild),
143	info->ClientOsName, info->ClientOsVer, info->ClientOsProductId,
144	info->ClientHostname, client_ip, Endian32(info->ClientPort),
145	info->ServerHostname, server_ip, Endian32(info->ServerPort),
146	info->ProxyHostname, proxy_ip, Endian32(info->ProxyPort),
147	info->HubName, unique_id);
148	}
149
150	// ノード情報の比較
151	bool CompareNodeInfo(NODE_INFO a, NODE_INFO b)
152	{
153	// 引数チェック
154	if (a == NULL \|\| b == NULL)
155	{
156	return false;
157	}
158
159	// このあたりは急いで実装したのでコードがあまり美しくない。
160	if (StrCmp(a->ClientProductName, b->ClientProductName) != 0)
161	{
162	return false;
163	}
164	if (a->ClientProductVer != b->ClientProductVer)
165	{
166	return false;
167	}
168	if (a->ClientProductBuild != b->ClientProductBuild)
169	{
170	return false;
171	}
172	if (StrCmp(a->ServerProductName, b->ServerProductName) != 0)
173	{
174	return false;
175	}
176	if (a->ServerProductVer != b->ServerProductVer)
177	{
178	return false;
179	}
180	if (a->ServerProductBuild != b->ServerProductBuild)
181	{
182	return false;
183	}
184	if (StrCmp(a->ClientOsName, b->ClientOsName) != 0)
185	{
186	return false;
187	}
188	if (StrCmp(a->ClientOsVer, b->ClientOsVer) != 0)
189	{
190	return false;
191	}
192	if (StrCmp(a->ClientOsProductId, b->ClientOsProductId) != 0)
193	{
194	return false;
195	}
196	if (StrCmp(a->ClientHostname, b->ClientHostname) != 0)
197	{
198	return false;
199	}
200	if (a->ClientIpAddress != b->ClientIpAddress)
201	{
202	return false;
203	}
204	if (StrCmp(a->ServerHostname, b->ServerHostname) != 0)
205	{
206	return false;
207	}
208	if (a->ServerIpAddress != b->ServerIpAddress)
209	{
210	return false;
211	}
212	if (a->ServerPort != b->ServerPort)
213	{
214	return false;
215	}
216	if (StrCmp(a->ProxyHostname, b->ProxyHostname) != 0)
217	{
218	return false;
219	}
220	if (a->ProxyIpAddress != b->ProxyIpAddress)
221	{
222	return false;
223	}
224	if (a->ProxyPort != b->ProxyPort)
225	{
226	return false;
227	}
228	if (StrCmp(a->HubName, b->HubName) != 0)
229	{
230	return false;
231	}
232	if (Cmp(a->UniqueId, b->UniqueId, 16) != 0)
233	{
234	return false;
235	}
236
237	return true;
238	}
239
240	// パスワード変更受付
241	UINT ChangePasswordAccept(CONNECTION c, PACK p)
242	{
243	CEDAR *cedar;
244	UCHAR random[SHA1_SIZE];
245	char hubname[MAX_HUBNAME_LEN + 1];
246	char username[MAX_USERNAME_LEN + 1];
247	UCHAR secure_old_password[SHA1_SIZE];
248	UCHAR new_password[SHA1_SIZE];
249	UCHAR check_secure_old_password[SHA1_SIZE];
250	UINT ret = ERR_NO_ERROR;
251	HUB *hub;
252	bool save = false;
253	// 引数チェック
254	if (c == NULL \|\| p == NULL)
255	{
256	return ERR_INTERNAL_ERROR;
257	}
258
259	Copy(random, c->Random, SHA1_SIZE);
260	if (PackGetStr(p, "hubname", hubname, sizeof(hubname)) == false \|\|
261	PackGetStr(p, "username", username, sizeof(username)) == false \|\|
262	PackGetData2(p, "secure_old_password", secure_old_password, sizeof(secure_old_password)) == false \|\|
263	PackGetData2(p, "new_password", new_password, sizeof(new_password)) == false)
264	{
265	return ERR_PROTOCOL_ERROR;
266	}
267
268	cedar = c->Cedar;
269
270	LockHubList(cedar);
271	{
272	hub = GetHub(cedar, hubname);
273	}
274	UnlockHubList(cedar);
275
276	if (hub == NULL)
277	{
278	ret = ERR_HUB_NOT_FOUND;
279	}
280	else
281	{
282	char tmp[MAX_SIZE];
283
284	if (GetHubAdminOption(hub, "deny_change_user_password") != 0)
285	{
286	ReleaseHub(hub);
287	return ERR_NOT_ENOUGH_RIGHT;
288	}
289
290	IPToStr(tmp, sizeof(tmp), &c->FirstSock->RemoteIP);
291	HLog(hub, "LH_CHANGE_PASSWORD_1", c->Name, tmp);
292
293	AcLock(hub);
294	{
295	USER *u = AcGetUser(hub, username);
296	if (u == NULL)
297	{
298	HLog(hub, "LH_CHANGE_PASSWORD_2", c->Name, username);
299	ret = ERR_OLD_PASSWORD_WRONG;
300	}
301	else
302	{
303	Lock(u->lock);
304	{
305	if (u->AuthType != AUTHTYPE_PASSWORD)
306	{
307	// パスワード認証ではない
308	HLog(hub, "LH_CHANGE_PASSWORD_3", c->Name, username);
309	ret = ERR_USER_AUTHTYPE_NOT_PASSWORD;
310	}
311	else
312	{
313	bool fix_password = false;
314	if (u->Policy != NULL)
315	{
316	fix_password = u->Policy->FixPassword;
317	}
318	else
319	{
320	if (u->Group != NULL)
321	{
322	if (u->Group->Policy != NULL)
323	{
324	fix_password = u->Group->Policy->FixPassword;
325	}
326	}
327	}
328	if (fix_password == false)
329	{
330	// 古いパスワードの確認
331	AUTHPASSWORD pw = (AUTHPASSWORD )u->AuthData;
332
333	SecurePassword(check_secure_old_password, pw->HashedKey, random);
334	if (Cmp(check_secure_old_password, secure_old_password, SHA1_SIZE) != 0)
335	{
336	// 古いパスワードが間違っている
337	ret = ERR_OLD_PASSWORD_WRONG;
338	HLog(hub, "LH_CHANGE_PASSWORD_4", c->Name, username);
339	}
340	else
341	{
342	// 新しいパスワードの書き込み
343	Copy(pw->HashedKey, new_password, SHA1_SIZE);
344	HLog(hub, "LH_CHANGE_PASSWORD_5", c->Name, username);
345	save = true;
346	}
347	}
348	else
349	{
350	// パスワード変更は禁止
351	ret = ERR_NOT_ENOUGH_RIGHT;
352	}
353	}
354	}
355	Unlock(u->lock);
356
357	ReleaseUser(u);
358	}
359	}
360	AcUnlock(hub);
361	ReleaseHub(hub);
362	}
363
364	return ret;
365	}
366
367	// パスワードを変更する
368	UINT ChangePassword(CEDAR cedar, CLIENT_OPTION o, char hubname, char username, char old_pass, char new_pass)
369	{
370	UINT ret = ERR_NO_ERROR;
371	UCHAR old_password[SHA1_SIZE];
372	UCHAR secure_old_password[SHA1_SIZE];
373	UCHAR new_password[SHA1_SIZE];
374	SOCK *sock;
375	SESSION *s;
376	// 引数チェック
377	if (cedar == NULL \|\| o == NULL \|\| hubname == NULL \|\| username == NULL \|\| old_pass == NULL \|\| new_pass == NULL)
378	{
379	return ERR_INTERNAL_ERROR;
380	}
381
382
383	// セッション作成
384	s = NewRpcSessionEx(cedar, o, &ret, NULL);
385
386	if (s != NULL)
387	{
388	PACK *p = NewPack();
389
390	sock = s->Connection->FirstSock;
391
392	HashPassword(old_password, username, old_pass);
393	SecurePassword(secure_old_password, old_password, s->Connection->Random);
394	HashPassword(new_password, username, new_pass);
395
396	PackAddClientVersion(p, s->Connection);
397
398	PackAddStr(p, "method", "password");
399	PackAddStr(p, "hubname", hubname);
400	PackAddStr(p, "username", username);
401	PackAddData(p, "secure_old_password", secure_old_password, SHA1_SIZE);
402	PackAddData(p, "new_password", new_password, SHA1_SIZE);
403
404	if (HttpClientSend(sock, p))
405	{
406	PACK *p = HttpClientRecv(sock);
407	if (p == NULL)
408	{
409	ret = ERR_DISCONNECTED;
410	}
411	else
412	{
413	ret = GetErrorFromPack(p);
414	}
415	FreePack(p);
416	}
417	else
418	{
419	ret = ERR_DISCONNECTED;
420	}
421	FreePack(p);
422
423	ReleaseSession(s);
424	}
425
426	return ret;
427	}
428
429	// HUB を列挙する
430	TOKEN_LIST EnumHub(SESSION s)
431	{
432	SOCK *sock;
433	TOKEN_LIST *ret;
434	PACK *p;
435	UINT num;
436	UINT i;
437	// 引数チェック
438	if (s == NULL \|\| s->Connection == NULL)
439	{
440	return NULL;
441	}
442
443	sock = s->Connection->FirstSock;
444	if (sock == NULL)
445	{
446	return NULL;
447	}
448
449	// タイムアウトの設定
450	SetTimeout(sock, 10000);
451
452	p = NewPack();
453	PackAddStr(p, "method", "enum_hub");
454
455	PackAddClientVersion(p, s->Connection);
456
457	if (HttpClientSend(sock, p) == false)
458	{
459	FreePack(p);
460	return NULL;
461	}
462	FreePack(p);
463
464	p = HttpClientRecv(sock);
465	if (p == NULL)
466	{
467	return NULL;
468	}
469
470	num = PackGetInt(p, "NumHub");
471	ret = ZeroMalloc(sizeof(TOKEN_LIST));
472	ret->NumTokens = num;
473	ret->Token = ZeroMalloc(sizeof(char ) num);
474	for (i = 0;i < num;i++)
475	{
476	char tmp[MAX_SIZE];
477	if (PackGetStrEx(p, "HubName", tmp, sizeof(tmp), i))
478	{
479	ret->Token[i] = CopyStr(tmp);
480	}
481	}
482	FreePack(p);
483
484	return ret;
485	}
486
487	// サーバーがクライアントからの接続を受け付ける
488	bool ServerAccept(CONNECTION *c)
489	{
490	bool ret = false;
491	UINT err;
492	PACK *p;
493	char username_real[MAX_SIZE];
494	char method[MAX_SIZE];
495	char hubname[MAX_SIZE];
496	char username[MAX_SIZE];
497	char groupname[MAX_SIZE];
498	UCHAR session_key[SHA1_SIZE];
499	UCHAR ticket[SHA1_SIZE];
500	RC4_KEY_PAIR key_pair;
501	UINT authtype;
502	POLICY *policy;
503	HUB *hub;
504	SESSION *s;
505	UINT64 user_expires = 0;
506	bool use_encrypt;
507	bool use_compress;
508	bool half_connection;
509	bool use_fast_rc4;
510	bool admin_mode = false;
511	UINT direction;
512	UINT max_connection;
513	UINT timeout;
514	bool farm_controller = false;
515	bool farm_member = false;
516	bool farm_mode = false;
517	bool require_bridge_routing_mode;
518	bool require_monitor_mode;
519	bool use_client_license = false, use_bridge_license = false;
520	bool local_host_session = false;
521	char sessionname[MAX_SESSION_NAME_LEN + 1];
522	bool is_server_or_bridge = false;
523	bool qos = false;
524	bool cluster_dynamic_secure_nat = false;
525	bool no_save_password = false;
526	NODE_INFO node;
527	wchar_t *msg = NULL;
528	USER *loggedin_user_object = NULL;
529	FARM_MEMBER *f = NULL;
530	SERVER *server = NULL;
531	POLICY ticketed_policy;
532	UINT64 timestamp;
533	UCHAR unique[SHA1_SIZE], unique2[SHA1_SIZE];
534	LICENSE_STATUS license;
535	CEDAR *cedar;
536	RPC_WINVER winver;
537	UINT client_id;
538	bool no_more_users_in_server = false;
539
540	// 引数チェック
541	if (c == NULL)
542	{
543	return false;
544	}
545
546	Zero(&winver, sizeof(winver));
547
548	StrCpy(groupname, sizeof(groupname), "");
549	StrCpy(sessionname, sizeof(sessionname), "");
550
551	cedar = c->Cedar;
552
553	// ライセンス状況の取得
554	Zero(&license, sizeof(license));
555	if (c->Cedar->Server != NULL)
556	{
557	LiParseCurrentLicenseStatus(c->Cedar->Server->LicenseSystem, &license);
558	}
559
560	no_more_users_in_server = SiTooManyUserObjectsInServer(cedar->Server, true);
561
562	c->Status = CONNECTION_STATUS_NEGOTIATION;
563
564	if (c->Cedar->Server != NULL)
565	{
566	SERVER *s = c->Cedar->Server;
567	server = s;
568
569	if (s->ServerType == SERVER_TYPE_FARM_MEMBER)
570	{
571	farm_member = true;
572	farm_mode = true;
573	}
574
575	if (s->ServerType == SERVER_TYPE_FARM_CONTROLLER)
576	{
577	farm_controller = true;
578	farm_mode = true;
579	}
580	}
581
582	// シグネチャを受信
583	Debug("Downloading Signature...\n");
584	if (ServerDownloadSignature(c) == false)
585	{
586	goto CLEANUP;
587	}
588
589	// Hello パケットを送信
590	Debug("Uploading Hello...\n");
591	if (ServerUploadHello(c) == false)
592	{
593	goto CLEANUP;
594	}
595
596	// 認証データを受信
597	Debug("Auth...\n");
598
599	p = HttpServerRecv(c->FirstSock);
600	if (p == NULL)
601	{
602	// 通信切断
603	c->Err = ERR_DISCONNECTED;
604	goto CLEANUP;
605	}
606
607	if (err = GetErrorFromPack(p))
608	{
609	// エラー発生
610	FreePack(p);
611	c->Err = err;
612	goto CLEANUP;
613	}
614
615	// メソッド取得
616	if (GetMethodFromPack(p, method, sizeof(method)) == false)
617	{
618	// プロトコルエラー
619	FreePack(p);
620	c->Err = ERR_PROTOCOL_ERROR;
621	goto CLEANUP;
622	}
623
624	// 時刻検査
625	timestamp = PackGetInt64(p, "timestamp");
626	if (timestamp != 0)
627	{
628	UINT64 now = SystemTime64();
629	UINT64 abs;
630	if (now >= timestamp)
631	{
632	abs = now - timestamp;
633	}
634	else
635	{
636	abs = timestamp - now;
637	}
638
639	if (abs > ALLOW_TIMESTAMP_DIFF)
640	{
641	// 時差が大きすぎる
642	FreePack(p);
643	c->Err = ERR_BAD_CLOCK;
644	goto CLEANUP;
645	}
646	}
647
648	// クライアントバージョン取得
649	PackGetStr(p, "client_str", c->ClientStr, sizeof(c->ClientStr));
650	c->ClientVer = PackGetInt(p, "client_ver");
651	c->ClientBuild = PackGetInt(p, "client_build");
652
653	if (SearchStrEx(c->ClientStr, "server", 0, false) != INFINITE \|\|
654	SearchStrEx(c->ClientStr, "bridge", 0, false) != INFINITE)
655	{
656	is_server_or_bridge = true;
657	}
658
659	// クライアント Windows バージョンの取得
660	InRpcWinVer(&winver, p);
661
662	DecrementNoSsl(c->Cedar, &c->FirstSock->RemoteIP, 2);
663
664	if (StrCmpi(method, "login") == 0)
665	{
666	bool auth_ret = false;
667
668	Debug("Login...\n");
669	c->Status = CONNECTION_STATUS_USERAUTH;
670
671	c->Type = CONNECTION_TYPE_LOGIN;
672
673	if (no_more_users_in_server)
674	{
675	// VPN Server に許可されているよりも多くのユーザーが存在する
676	FreePack(p);
677	c->Err = ERR_TOO_MANY_USER;
678	goto CLEANUP;
679	}
680
681	// クライアント名など
682	if (PackGetStr(p, "hello", c->ClientStr, sizeof(c->ClientStr)) == false)
683	{
684	StrCpy(c->ClientStr, sizeof(c->ClientStr), "Unknown");
685	}
686	c->ServerVer = CEDAR_VER;
687	c->ServerBuild = CEDAR_BUILD;
688
689	// NODE_INFO を取得する
690	Zero(&node, sizeof(node));
691	InRpcNodeInfo(&node, p);
692
693	// プロトコル
694	c->Protocol = GetProtocolFromPack(p);
695	if (c->Protocol == CONNECTION_UDP)
696	{
697	// TCP 関係の構造体を解放する
698	if (c->Tcp)
699	{
700	ReleaseList(c->Tcp->TcpSockList);
701	Free(c->Tcp);
702	}
703	}
704
705	if (GetServerCapsBool(c->Cedar->Server, "b_vpn_client_connect") == false)
706	{
707	// VPN クライアントが接続不可能である
708	FreePack(p);
709	c->Err = ERR_NOT_SUPPORTED;
710	goto CLEANUP;
711	}
712
713	// ログイン
714	if (GetHubnameAndUsernameFromPack(p, username, sizeof(username), hubname, sizeof(hubname)) == false)
715	{
716	// プロトコルエラー
717	FreePack(p);
718	c->Err = ERR_PROTOCOL_ERROR;
719	goto CLEANUP;
720	}
721
722	if (farm_member)
723	{
724	bool ok = false;
725	UINT authtype;
726
727	authtype = GetAuthTypeFromPack(p);
728	if (StrCmpi(username, ADMINISTRATOR_USERNAME) == 0 &&
729	authtype == AUTHTYPE_PASSWORD)
730	{
731	ok = true;
732	}
733
734	if (authtype == AUTHTYPE_TICKET)
735	{
736	ok = true;
737	}
738
739	if (ok == false)
740	{
741	// サーバーファームメンバへの Administrators 以外の直接ログオンは
742	// 禁止されている
743	FreePack(p);
744	SLog(c->Cedar, "LS_FARMMEMBER_NOT_ADMIN", c->Name, hubname, ADMINISTRATOR_USERNAME, username);
745	c->Err = ERR_ACCESS_DENIED;
746	goto CLEANUP;
747	}
748	}
749
750	Debug("Username = %s, HubName = %s\n", username, hubname);
751	LockHubList(c->Cedar);
752	{
753	hub = GetHub(c->Cedar, hubname);
754	}
755	UnlockHubList(c->Cedar);
756	if (hub == NULL)
757	{
758	// HUB が存在しない
759	FreePack(p);
760	c->Err = ERR_HUB_NOT_FOUND;
761	SLog(c->Cedar, "LS_HUB_NOT_FOUND", c->Name, hubname);
762	goto CLEANUP;
763	}
764
765	Lock(hub->lock);
766	{
767	USER *user;
768	USERGROUP *group;
769	if (hub->Halt \|\| hub->Offline)
770	{
771	// HUB は停止中
772	FreePack(p);
773	Unlock(hub->lock);
774	ReleaseHub(hub);
775	c->Err = ERR_HUB_STOPPING;
776	goto CLEANUP;
777	}
778
779	// 各種フラグの取得
780	use_encrypt = PackGetInt(p, "use_encrypt") == 0 ? false : true;
781	use_compress = PackGetInt(p, "use_compress") == 0 ? false : true;
782	max_connection = PackGetInt(p, "max_connection");
783	half_connection = PackGetInt(p, "half_connection") == 0 ? false : true;
784	use_fast_rc4 = PackGetInt(p, "use_fast_rc4") == 0 ? false : true;
785	qos = PackGetInt(p, "qos") ? true : false;
786	client_id = PackGetInt(p, "client_id");
787
788	// 要求モード
789	require_bridge_routing_mode = PackGetBool(p, "require_bridge_routing_mode");
790	require_monitor_mode = PackGetBool(p, "require_monitor_mode");
791	if (require_monitor_mode)
792	{
793	qos = false;
794	}
795
796	if (is_server_or_bridge)
797	{
798	require_bridge_routing_mode = true;
799	}
800
801	// クライアントユニーク ID
802	Zero(unique, sizeof(unique));
803	if (PackGetDataSize(p, "unique_id") == SHA1_SIZE)
804	{
805	PackGetData(p, "unique_id", unique);
806	}
807
808	// 認証方法の取得
809	authtype = GetAuthTypeFromPack(p);
810
811	if (1)
812	{
813	// ログ
814	char ip1[64], ip2[64], verstr[64];
815	wchar_t *authtype_str = _UU("LH_AUTH_UNKNOWN");
816	switch (authtype)
817	{
818	case CLIENT_AUTHTYPE_ANONYMOUS:
819	authtype_str = _UU("LH_AUTH_ANONYMOUS");
820	break;
821	case CLIENT_AUTHTYPE_PASSWORD:
822	authtype_str = _UU("LH_AUTH_PASSWORD");
823	break;
824	case CLIENT_AUTHTYPE_PLAIN_PASSWORD:
825	authtype_str = _UU("LH_AUTH_PLAIN_PASSWORD");
826	break;
827	case CLIENT_AUTHTYPE_CERT:
828	authtype_str = _UU("LH_AUTH_CERT");
829	break;
830	case AUTHTYPE_TICKET:
831	authtype_str = _UU("LH_AUTH_TICKET");
832	break;
833	}
834	IPToStr(ip1, sizeof(ip1), &c->FirstSock->RemoteIP);
835	IPToStr(ip2, sizeof(ip2), &c->FirstSock->LocalIP);
836
837	Format(verstr, sizeof(verstr), "%u.%02u", c->ClientVer / 100, c->ClientVer % 100);
838
839	HLog(hub, "LH_CONNECT_CLIENT", c->Name, ip1, c->FirstSock->RemoteHostname, c->FirstSock->RemotePort,
840	c->ClientStr, verstr, c->ClientBuild, authtype_str, username);
841	}
842
843	// まず匿名認証を試行する
844	auth_ret = SamAuthUserByAnonymous(hub, username);
845
846	if (auth_ret)
847	{
848	// ユーザー認証成功
849	HLog(hub, "LH_AUTH_OK", c->Name, username);
850	}
851
852	if (auth_ret == false)
853	{
854	// 匿名認証に失敗した場合は他の認証方法を試行する
855	switch (authtype)
856	{
857	case CLIENT_AUTHTYPE_ANONYMOUS:
858	// 匿名認証 (すでに試行している)
859	break;
860
861	case AUTHTYPE_TICKET:
862	// チケット認証
863	if (PackGetDataSize(p, "ticket") == SHA1_SIZE)
864	{
865	PackGetData(p, "ticket", ticket);
866
867	auth_ret = SiCheckTicket(hub, ticket, username, sizeof(username), username_real, sizeof(username_real),
868	&ticketed_policy, sessionname, sizeof(sessionname), groupname, sizeof(groupname));
869	}
870	break;
871
872	case CLIENT_AUTHTYPE_PASSWORD:
873	// パスワード認証
874	if (PackGetDataSize(p, "secure_password") == SHA1_SIZE)
875	{
876	POLICY *pol = NULL;
877	UCHAR secure_password[SHA1_SIZE];
878	Zero(secure_password, sizeof(secure_password));
879	if (PackGetDataSize(p, "secure_password") == SHA1_SIZE)
880	{
881	PackGetData(p, "secure_password", secure_password);
882	}
883	auth_ret = SamAuthUserByPassword(hub, username, c->Random, secure_password);
884
885	pol = SamGetUserPolicy(hub, username);
886	if (pol != NULL)
887	{
888	no_save_password = pol->NoSavePassword;
889	Free(pol);
890	}
891	}
892	break;
893
894	case CLIENT_AUTHTYPE_PLAIN_PASSWORD:
895	// 外部サーバーによる認証はサポートされていない
896	HLog(hub, "LH_AUTH_RADIUS_NOT_SUPPORT", c->Name, username);
897	Unlock(hub->lock);
898	ReleaseHub(hub);
899	FreePack(p);
900	c->Err = ERR_AUTHTYPE_NOT_SUPPORTED;
901	goto CLEANUP;
902
903	case CLIENT_AUTHTYPE_CERT:
904	// 証明書認証はサポートされていない
905	HLog(hub, "LH_AUTH_CERT_NOT_SUPPORT", c->Name, username);
906	Unlock(hub->lock);
907	ReleaseHub(hub);
908	FreePack(p);
909	c->Err = ERR_AUTHTYPE_NOT_SUPPORTED;
910	goto CLEANUP;
911
912	default:
913	// 不明な認証方法
914	Unlock(hub->lock);
915	ReleaseHub(hub);
916	FreePack(p);
917	c->Err = ERR_AUTHTYPE_NOT_SUPPORTED;
918	goto CLEANUP;
919	}
920
921	if (auth_ret == false)
922	{
923	// 認証失敗
924	HLog(hub, "LH_AUTH_NG", c->Name, username);
925	}
926	else
927	{
928	// 認証成功
929	HLog(hub, "LH_AUTH_OK", c->Name, username);
930	}
931	}
932
933	if (auth_ret == false)
934	{
935	// 認証失敗
936	Unlock(hub->lock);
937	ReleaseHub(hub);
938	FreePack(p);
939	c->Err = ERR_AUTH_FAILED;
940	goto CLEANUP;
941	}
942	else
943	{
944	if (authtype == CLIENT_AUTHTYPE_PASSWORD)
945	{
946	UCHAR test[SHA1_SIZE];
947	HashPassword(test, username, "");
948	if (Cmp(test, hub->SecurePassword, SHA1_SIZE) == 0)
949	{
950	SOCK *s = c->FirstSock;
951	if (s != NULL)
952	{
953	if (GetHubAdminOption(hub, "deny_empty_password") != 0 \|\|
954	(StrCmpi(username, ADMINISTRATOR_USERNAME) == 0 && s->RemoteIP.addr[0] != 127))
955	{
956	// パスワードが空のとき、リモートから接続してはいけない
957	HLog(hub, "LH_LOCAL_ONLY", c->Name, username);
958
959	Unlock(hub->lock);
960	ReleaseHub(hub);
961	FreePack(p);
962	c->Err = ERR_NULL_PASSWORD_LOCAL_ONLY;
963	goto CLEANUP;
964	}
965	}
966	}
967	}
968	}
969
970	policy = NULL;
971
972	// 認証成功
973	FreePack(p);
974
975	if (StrCmpi(username, ADMINISTRATOR_USERNAME) != 0)
976	{
977	// ポリシーを取得
978	if (farm_member == false)
979	{
980	// ファームメンバ以外の場合
981	user = AcGetUser(hub, username);
982	if (user == NULL)
983	{
984	user = AcGetUser(hub, "*");
985	if (user == NULL)
986	{
987	// ユーザー取得失敗
988	Unlock(hub->lock);
989	ReleaseHub(hub);
990	c->Err = ERR_ACCESS_DENIED;
991	goto CLEANUP;
992	}
993	}
994
995	policy = NULL;
996
997	Lock(user->lock);
998	{
999	// 有効期限を取得
1000	user_expires = user->ExpireTime;
1001
1002	StrCpy(username_real, sizeof(username_real), user->Name);
1003	group = user->Group;
1004	if (group != NULL)
1005	{
1006	AddRef(group->ref);
1007
1008	Lock(group->lock);
1009	{
1010	// グループ名を取得
1011	StrCpy(groupname, sizeof(groupname), group->Name);
1012	}
1013	Unlock(group->lock);
1014	}
1015
1016	if (user->Policy != NULL)
1017	{
1018	policy = ClonePolicy(user->Policy);
1019	}
1020	else
1021	{
1022	if (group)
1023	{
1024	Lock(group->lock);
1025	{
1026	if (group->Policy != NULL)
1027	{
1028	policy = ClonePolicy(group->Policy);
1029	}
1030	}
1031	Unlock(group->lock);
1032	}
1033	}
1034
1035	if (group != NULL)
1036	{
1037	ReleaseGroup(group);
1038	}
1039	}
1040	Unlock(user->lock);
1041	loggedin_user_object = user;
1042	}
1043	else
1044	{
1045	// ファームメンバの場合
1046	policy = ClonePolicy(&ticketed_policy);
1047	}
1048	}
1049	else
1050	{
1051	// 管理者モード
1052	admin_mode = true;
1053	StrCpy(username_real, sizeof(username_real), ADMINISTRATOR_USERNAME);
1054
1055	policy = ClonePolicy(GetDefaultPolicy());
1056	policy->NoBroadcastLimiter = true;
1057	policy->MonitorPort = true;
1058	}
1059
1060	if (policy == NULL)
1061	{
1062	// デフォルトのポリシーを使用する
1063	policy = ClonePolicy(GetDefaultPolicy());
1064	}
1065
1066	if (policy->MaxConnection == 0)
1067	{
1068	policy->MaxConnection = MAX_TCP_CONNECTION;
1069	}
1070
1071	if (policy->TimeOut == 0)
1072	{
1073	policy->TimeOut = 20;
1074	}
1075
1076	if (qos)
1077	{
1078	// VoIP / QoS
1079	if (policy->NoQoS)
1080	{
1081	// ポリシーが許可していない
1082	qos = false;
1083	}
1084	if (GetServerCapsBool(c->Cedar->Server, "b_support_qos") == false)
1085	{
1086	// サーバーがサポートしていない
1087	qos = false;
1088	policy->NoQoS = true;
1089	}
1090	if (GetHubAdminOption(hub, "deny_qos") != 0)
1091	{
1092	// 管理オプションで禁止されている
1093	qos = false;
1094	policy->NoQoS = true;
1095	}
1096	}
1097
1098	if (GetHubAdminOption(hub, "max_bitrates_download") != 0)
1099	{
1100	if (policy->MaxDownload == 0)
1101	{
1102	policy->MaxDownload = GetHubAdminOption(hub, "max_bitrates_download");
1103	}
1104	else
1105	{
1106	policy->MaxDownload = MIN(policy->MaxDownload, GetHubAdminOption(hub, "max_bitrates_download"));
1107	}
1108	}
1109
1110	if (GetHubAdminOption(hub, "max_bitrates_upload") != 0)
1111	{
1112	if (policy->MaxUpload == 0)
1113	{
1114	policy->MaxUpload = GetHubAdminOption(hub, "max_bitrates_upload");
1115	}
1116	else
1117	{
1118	policy->MaxUpload = MIN(policy->MaxUpload, GetHubAdminOption(hub, "max_bitrates_upload"));
1119	}
1120	}
1121
1122	if (GetHubAdminOption(hub, "deny_bridge") != 0)
1123	{
1124	policy->NoBridge = true;
1125	}
1126
1127	if (GetHubAdminOption(hub, "deny_routing") != 0)
1128	{
1129	policy->NoRouting = true;
1130	}
1131
1132	if (hub->Option->ClientMinimumRequiredBuild > c->ClientBuild &&
1133	InStrEx(c->ClientStr, "client", false))
1134	{
1135	// クライアントのビルド番号が小さすぎる
1136	HLog(hub, "LH_CLIENT_VERSION_OLD", c->Name, c->ClientBuild, hub->Option->ClientMinimumRequiredBuild);
1137
1138	Unlock(hub->lock);
1139	ReleaseHub(hub);
1140	c->Err = ERR_VERSION_INVALID;
1141	Free(policy);
1142	goto CLEANUP;
1143	}
1144
1145	if (hub->Option->RequiredClientId != 0 &&
1146	hub->Option->RequiredClientId != client_id &&
1147	InStrEx(c->ClientStr, "client", false))
1148	{
1149	// クライアントのビルド番号が小さすぎる
1150	HLog(hub, "LH_CLIENT_ID_REQUIRED", c->Name, client_id, hub->Option->RequiredClientId);
1151
1152	Unlock(hub->lock);
1153	ReleaseHub(hub);
1154	c->Err = ERR_CLIENT_ID_REQUIRED;
1155	Free(policy);
1156	goto CLEANUP;
1157	}
1158
1159	if ((policy->NoSavePassword) \|\| (policy->AutoDisconnect != 0))
1160	{
1161	if (c->ClientBuild < 6560 && InStrEx(c->ClientStr, "client", false))
1162	{
1163	// NoSavePassword ポリシーが指定されている場合は対応クライアント
1164	// でなければ接続できない
1165	HLog(hub, "LH_CLIENT_VERSION_OLD", c->Name, c->ClientBuild, 6560);
1166
1167	Unlock(hub->lock);
1168	ReleaseHub(hub);
1169	c->Err = ERR_VERSION_INVALID;
1170	Free(policy);
1171	goto CLEANUP;
1172	}
1173	}
1174
1175	if (user_expires != 0 && user_expires <= SystemTime64())
1176	{
1177	// 有効期限が切れている
1178	// アクセスが拒否されている
1179	HLog(hub, "LH_USER_EXPIRES", c->Name, username);
1180
1181	Unlock(hub->lock);
1182	ReleaseHub(hub);
1183	c->Err = ERR_ACCESS_DENIED;
1184	Free(policy);
1185	goto CLEANUP;
1186	}
1187
1188	if (policy->Access == false)
1189	{
1190	// アクセスが拒否されている
1191	HLog(hub, "LH_POLICY_ACCESS_NG", c->Name, username);
1192
1193	Unlock(hub->lock);
1194	ReleaseHub(hub);
1195	c->Err = ERR_ACCESS_DENIED;
1196	Free(policy);
1197	goto CLEANUP;
1198	}
1199
1200	// ポリシーの内容をクライアントが要求したオプションと比較して
1201	// 決定するか接続を拒否する
1202	// 最初にモニタポートモードで接続できるかどうか確認する
1203	if (require_monitor_mode && policy->MonitorPort == false)
1204	{
1205	// モニタポートモードで接続できない
1206	HLog(hub, "LH_POLICY_MONITOR_MODE", c->Name);
1207
1208	Unlock(hub->lock);
1209	ReleaseHub(hub);
1210	c->Err = ERR_MONITOR_MODE_DENIED;
1211	Free(policy);
1212	goto CLEANUP;
1213	}
1214
1215	if (policy->MonitorPort)
1216	{
1217	if (require_monitor_mode == false)
1218	{
1219	policy->MonitorPort = false;
1220	}
1221	}
1222
1223	if (policy->MonitorPort)
1224	{
1225	qos = false;
1226	}
1227
1228	// 次にブリッジ / ルーティングモードで接続できるか確認する
1229	if (require_bridge_routing_mode &&
1230	(policy->NoBridge && policy->NoRouting))
1231	{
1232	// ブリッジ / ルーティングモードで接続できない
1233	HLog(hub, "LH_POLICY_BRIDGE_MODE", c->Name);
1234
1235	Unlock(hub->lock);
1236	ReleaseHub(hub);
1237	c->Err = ERR_BRIDGE_MODE_DENIED;
1238	Free(policy);
1239	goto CLEANUP;
1240	}
1241
1242	if (require_bridge_routing_mode == false)
1243	{
1244	policy->NoBridge = true;
1245	policy->NoRouting = true;
1246	}
1247
1248	// ライセンスが必要かどうかチェック
1249	GenerateMachineUniqueHash(unique2);
1250
1251	if (Cmp(unique, unique2, SHA1_SIZE) == 0)
1252	{
1253	// ローカルホストセッションである
1254	local_host_session = true;
1255	}
1256	else
1257	{
1258	if (license.NumUserLicense != INFINITE)
1259	{
1260	// ユーザー作成数が制限されているエディションでは多重ログイン禁止
1261	policy->MultiLogins = 1;
1262	}
1263
1264	if (policy->NoBridge == false \|\| policy->NoRouting == false)
1265	{
1266	// ブリッジライセンスを消費
1267	use_bridge_license = true;
1268	}
1269	else
1270	{
1271	// クライアントライセンスを消費
1272	use_client_license = true;
1273	}
1274	}
1275
1276	if (server != NULL && server->ServerType != SERVER_TYPE_FARM_MEMBER &&
1277	(use_bridge_license \|\| use_client_license))
1278	{
1279	// クラスタコントローラまたはスタンドアロンサーバーの場合で
1280	// クライアントにライセンスが必要になった場合、ここでライセンス数が
1281	// 足りているかどうかを計算する
1282
1283	if (use_client_license)
1284	{
1285	if (server->CurrentAssignedClientLicense >= license.NumClientLicense)
1286	{
1287	// クライアント接続ライセンスが足りない
1288	Unlock(hub->lock);
1289
1290	// 詳細エラーログを吐く
1291	HLog(hub, "LH_NOT_ENOUGH_CLIENT_LICENSE", c->Name,
1292	license.NumClientLicense,
1293	server->CurrentAssignedClientLicense + 1);
1294
1295	ReleaseHub(hub);
1296	c->Err = ERR_CLIENT_LICENSE_NOT_ENOUGH;
1297	Free(policy);
1298	goto CLEANUP;
1299	}
1300	}
1301	if (use_bridge_license)
1302	{
1303	if (server->CurrentAssignedBridgeLicense >= license.NumBridgeLicense)
1304	{
1305	// ブリッジ接続ライセンス数が足りない
1306	Unlock(hub->lock);
1307
1308	// 詳細エラーログを吐く
1309	HLog(hub, "LH_NOT_ENOUGH_BRIDGE_LICENSE", c->Name,
1310	license.NumBridgeLicense,
1311	server->CurrentAssignedBridgeLicense + 1);
1312
1313	ReleaseHub(hub);
1314	c->Err = ERR_BRIDGE_LICENSE_NOT_ENOUGH;
1315	Free(policy);
1316	goto CLEANUP;
1317	}
1318	}
1319	}
1320
1321	if (server != NULL && server->ServerType != SERVER_TYPE_FARM_MEMBER &&
1322	policy != NULL)
1323	{
1324	if (GetServerCapsBool(hub->Cedar->Server, "b_support_limit_multilogin"))
1325	{
1326	// ポリシーで多重ログイン制限数が指定されている場合は確認する
1327	RPC_ENUM_SESSION t;
1328	UINT i, num;
1329	UINT max_logins = policy->MultiLogins;
1330	UINT ao = GetHubAdminOption(hub, "max_multilogins_per_user");
1331
1332	if (ao != 0)
1333	{
1334	if (max_logins != 0)
1335	{
1336	max_logins = MIN(max_logins, ao);
1337	}
1338	else
1339	{
1340	max_logins = ao;
1341	}
1342	}
1343
1344	if (max_logins != 0)
1345	{
1346	Zero(&t, sizeof(t));
1347	StrCpy(t.HubName, sizeof(t.HubName), hub->Name);
1348
1349	Unlock(hub->lock);
1350
1351	SiEnumSessionMain(server, &t);
1352
1353	Lock(hub->lock);
1354
1355	num = 0;
1356
1357	for (i = 0;i < t.NumSession;i++)
1358	{
1359	RPC_ENUM_SESSION_ITEM *e = &t.Sessions[i];
1360
1361	if (e->BridgeMode == false && e->Layer3Mode == false && e->LinkMode == false && e->CurrentNumTcp != 0)
1362	{
1363	if (StrCmpi(e->Username, username) == 0 &&
1364	(IsZero(e->UniqueId, 16) \|\| Cmp(e->UniqueId, node.UniqueId, 16) != 0))
1365	{
1366	num++;
1367	}
1368	}
1369	}
1370
1371	FreeRpcEnumSession(&t);
1372
1373	if (num >= max_logins)
1374	{
1375	// これ以上接続できない
1376	Unlock(hub->lock);
1377
1378	// 詳細エラーログを吐く
1379	HLog(hub, license.NumUserLicense == INFINITE ? "LH_TOO_MANY_MULTILOGINS" : "LH_TOO_MANY_MULTILOGINS2",
1380	c->Name,
1381	username, max_logins, num);
1382
1383	ReleaseHub(hub);
1384	c->Err = ERR_TOO_MANY_USER_SESSION;
1385	Free(policy);
1386	goto CLEANUP;
1387	}
1388	}
1389	}
1390	}
1391
1392	if (loggedin_user_object != NULL)
1393	{
1394	// ユーザー情報の更新
1395	Lock(loggedin_user_object->lock);
1396	{
1397	loggedin_user_object->NumLogin++;
1398	loggedin_user_object->LastLoginTime = SystemTime64();
1399	}
1400	Unlock(loggedin_user_object->lock);
1401	}
1402
1403	// ログイン回数を更新する
1404	hub->NumLogin++;
1405	hub->LastCommTime = hub->LastLoginTime = SystemTime64();
1406
1407	if (farm_controller)
1408	{
1409	wchar_t *msg = GetHubMsg(hub);
1410
1411	Unlock(hub->lock);
1412
1413	Lock(cedar->CedarSuperLock);
1414
1415	// ファームコントローラの場合、この HUB をホスティングする
1416	// ファームメンバを選定する
1417	LockList(server->FarmMemberList);
1418	{
1419	HLog(hub, "LH_FARM_SELECT_1", c->Name);
1420	f = SiGetHubHostingMember(server, hub, admin_mode);
1421
1422	if (f == NULL)
1423	{
1424	// 選定に失敗した
1425	HLog(hub, "LH_FARM_SELECT_2", c->Name);
1426	UnlockList(server->FarmMemberList);
1427	Unlock(cedar->CedarSuperLock);
1428	ReleaseHub(hub);
1429	c->Err = ERR_COULD_NOT_HOST_HUB_ON_FARM;
1430	Free(policy);
1431	Free(msg);
1432	goto CLEANUP;
1433	}
1434	else
1435	{
1436	if (f->Me == false)
1437	{
1438	UCHAR ticket[SHA1_SIZE];
1439	PACK *p;
1440	BUF *b;
1441	UINT i;
1442
1443	SLog(c->Cedar, "LH_FARM_SELECT_4", c->Name, f->hostname);
1444
1445	// 選定したサーバーファームメンバにセッションを作成する
1446	Rand(ticket, sizeof(ticket));
1447	SiCallCreateTicket(server, f, hub->Name,
1448	username, username_real, policy, ticket, Inc(hub->SessionCounter), groupname);
1449
1450	p = NewPack();
1451	PackAddInt(p, "Redirect", 1);
1452	PackAddIp32(p, "Ip", f->Ip);
1453	for (i = 0;i < f->NumPort;i++)
1454	{
1455	PackAddIntEx(p, "Port", f->Ports[i], i, f->NumPort);
1456	}
1457	PackAddData(p, "Ticket", ticket, sizeof(ticket));
1458
1459	if (true)
1460	{
1461	char *utf = CopyUniToUtf(msg);
1462
1463	PackAddData(p, "Msg", utf, StrLen(utf));
1464
1465	Free(utf);
1466	}
1467
1468	b = XToBuf(f->ServerCert, false);
1469	PackAddBuf(p, "Cert", b);
1470	FreeBuf(b);
1471
1472	UnlockList(server->FarmMemberList);
1473	Unlock(cedar->CedarSuperLock);
1474	ReleaseHub(hub);
1475
1476	HttpServerSend(c->FirstSock, p);
1477	FreePack(p);
1478
1479	c->Err = 0;
1480	Free(policy);
1481
1482	FreePack(HttpServerRecv(c->FirstSock));
1483	Free(msg);
1484	goto CLEANUP;
1485	}
1486	else
1487	{
1488	HLog(hub, "LH_FARM_SELECT_3", c->Name);
1489	// 自分自身が選定されたのでこのまま続ける
1490	UnlockList(server->FarmMemberList);
1491	Unlock(cedar->CedarSuperLock);
1492	f->Point = SiGetPoint(server);
1493	Lock(hub->lock);
1494	Free(msg);
1495	}
1496	}
1497	}
1498	}
1499
1500	if (admin_mode == false)
1501	{
1502	// HUB の最大接続数をチェック
1503	if (hub->Option->MaxSession != 0 &&
1504	hub->Option->MaxSession <= Count(hub->NumSessions))
1505	{
1506	// これ以上接続できない
1507	Unlock(hub->lock);
1508
1509	HLog(hub, "LH_MAX_SESSION", c->Name, hub->Option->MaxSession);
1510
1511	ReleaseHub(hub);
1512	c->Err = ERR_HUB_IS_BUSY;
1513	Free(policy);
1514	goto CLEANUP;
1515	}
1516	}
1517
1518	if (use_client_license \|\| use_bridge_license)
1519	{
1520	// 仮想 HUB 管理オプションで規定された同時接続セッション数
1521	// の制限に抵触しないかどうか調べる
1522	if (
1523	(GetHubAdminOption(hub, "max_sessions") != 0 &&
1524	(Count(hub->NumSessionsClient) + Count(hub->NumSessionsBridge)) >= GetHubAdminOption(hub, "max_sessions"))
1525	\|\|
1526	(hub->Option->MaxSession != 0 &&
1527	(Count(hub->NumSessionsClient) + Count(hub->NumSessionsBridge)) >= hub->Option->MaxSession))
1528	{
1529	// これ以上接続できない
1530	Unlock(hub->lock);
1531
1532	HLog(hub, "LH_MAX_SESSION", c->Name, GetHubAdminOption(hub, "max_sessions"));
1533
1534	ReleaseHub(hub);
1535	c->Err = ERR_HUB_IS_BUSY;
1536	Free(policy);
1537	goto CLEANUP;
1538	}
1539	}
1540
1541	if (use_client_license)
1542	{
1543	// 仮想 HUB 管理オプションで規定された同時接続セッション数 (クライアント)
1544	// の制限に抵触しないかどうか調べる
1545	if (((GetHubAdminOption(hub, "max_sessions_client_bridge_apply") != 0 \|\| license.CarrierEdition) &&
1546	Count(hub->NumSessionsClient) >= GetHubAdminOption(hub, "max_sessions_client") && hub->Cedar->Server != NULL && hub->Cedar->Server->ServerType != SERVER_TYPE_FARM_MEMBER)
1547	\|\|
1548	(hub->FarmMember_MaxSessionClientBridgeApply &&
1549	Count(hub->NumSessionsClient) >= hub->FarmMember_MaxSessionClient))
1550	{
1551	// これ以上接続できない
1552	Unlock(hub->lock);
1553
1554	HLog(hub, "LH_MAX_SESSION_CLIENT", c->Name, GetHubAdminOption(hub, "max_sessions_client"));
1555
1556	ReleaseHub(hub);
1557	c->Err = ERR_HUB_IS_BUSY;
1558	Free(policy);
1559	goto CLEANUP;
1560	}
1561	}
1562
1563	if (use_bridge_license)
1564	{
1565	// 仮想 HUB 管理オプションで規定された同時接続セッション数 (ブリッジ)
1566	// の制限に抵触しないかどうか調べる
1567	if (((GetHubAdminOption(hub, "max_sessions_client_bridge_apply") != 0 \|\| license.CarrierEdition) &&
1568	Count(hub->NumSessionsBridge) >= GetHubAdminOption(hub, "max_sessions_bridge") && hub->Cedar->Server != NULL && hub->Cedar->Server->ServerType != SERVER_TYPE_FARM_MEMBER)
1569	\|\|
1570	(hub->FarmMember_MaxSessionClientBridgeApply &&
1571	Count(hub->NumSessionsBridge) >= hub->FarmMember_MaxSessionBridge))
1572	{
1573	// これ以上接続できない
1574	Unlock(hub->lock);
1575
1576	HLog(hub, "LH_MAX_SESSION_BRIDGE", c->Name, GetHubAdminOption(hub, "max_sessions_bridge"));
1577
1578	ReleaseHub(hub);
1579	c->Err = ERR_HUB_IS_BUSY;
1580	Free(policy);
1581	goto CLEANUP;
1582	}
1583	}
1584
1585	if (Count(hub->Cedar->CurrentSessions) >= GetServerCapsInt(hub->Cedar->Server, "i_max_sessions"))
1586	{
1587	// これ以上接続できない
1588	Unlock(hub->lock);
1589
1590	HLog(hub, "LH_MAX_SESSION_2", c->Name, GetServerCapsInt(hub->Cedar->Server, "i_max_sessions"));
1591
1592	ReleaseHub(hub);
1593	c->Err = ERR_HUB_IS_BUSY;
1594	Free(policy);
1595	goto CLEANUP;
1596	}
1597
1598	// 現在の接続数をインクリメント
1599	Inc(hub->NumSessions);
1600	if (use_bridge_license)
1601	{
1602	Inc(hub->NumSessionsBridge);
1603	}
1604
1605	if (use_client_license)
1606	{
1607	Inc(hub->NumSessionsClient);
1608	}
1609	Inc(hub->Cedar->CurrentSessions);
1610
1611	// タイムアウト時間を計算
1612	timeout = policy->TimeOut * 1000; // ミリ秒 → 秒に変換
1613	if (timeout == 0)
1614	{
1615	timeout = TIMEOUT_DEFAULT;
1616	}
1617	timeout = MIN(timeout, TIMEOUT_MAX);
1618	timeout = MAX(timeout, TIMEOUT_MIN);
1619
1620	// ポリシーに応じて max_connection を更新
1621	max_connection = MIN(max_connection, policy->MaxConnection);
1622	max_connection = MIN(max_connection, MAX_TCP_CONNECTION);
1623	max_connection = MAX(max_connection, 1);
1624	if (half_connection)
1625	{
1626	// Half Connection 時にはコネクション数は 2 以上とする
1627	max_connection = MAX(max_connection, 2);
1628	}
1629
1630	if (qos)
1631	{
1632	// VoIP / QoS 使用時にはコネクション数は 2 以上とする
1633	max_connection = MAX(max_connection, 2);
1634	if (half_connection)
1635	{
1636	max_connection = MAX(max_connection, 4);
1637	}
1638	}
1639
1640	c->Status = CONNECTION_STATUS_ESTABLISHED;
1641
1642	// コネクションを Cedar から削除
1643	DelConnection(c->Cedar, c);
1644
1645	// セッションの作成
1646	StrLower(username);
1647	s = NewServerSession(c->Cedar, c, hub, username, policy);
1648
1649	if (server != NULL)
1650	{
1651	s->NoSendSignature = server->NoSendSignature;
1652	}
1653
1654	s->UseClientLicense = use_client_license;
1655	s->UseBridgeLicense = use_bridge_license;
1656
1657	s->IsBridgeMode = (policy->NoBridge == false) \|\| (policy->NoRouting == false);
1658	s->IsMonitorMode = policy->MonitorPort;
1659
1660	// IPv6 セッションかどうかの判定
1661	s->IPv6Session = false;
1662
1663	if (node.ClientIpAddress == 0)
1664	{
1665	s->IPv6Session = true;
1666	}
1667
1668	if (use_bridge_license)
1669	{
1670	Inc(s->Cedar->AssignedBridgeLicense);
1671	}
1672
1673	if (use_client_license)
1674	{
1675	Inc(s->Cedar->AssignedClientLicense);
1676	}
1677
1678	if (server != NULL)
1679	{
1680	// Server 構造体の合計割り当て済みライセンス数の更新
1681	if (server->ServerType == SERVER_TYPE_STANDALONE)
1682	{
1683	// スタンドアロンモードのみ更新
1684	// (クラスタコントローラモードでは定期的にポーリングしている)
1685	server->CurrentAssignedClientLicense = Count(s->Cedar->AssignedClientLicense);
1686	server->CurrentAssignedBridgeLicense = Count(s->Cedar->AssignedBridgeLicense);
1687	}
1688	}
1689
1690	if (StrLen(sessionname) != 0)
1691	{
1692	// セッション名の指定
1693	Free(s->Name);
1694	s->Name = CopyStr(sessionname);
1695	}
1696
1697	{
1698	char ip[128];
1699	IPToStr(ip, sizeof(ip), &c->FirstSock->RemoteIP);
1700	HLog(hub, "LH_NEW_SESSION", c->Name, s->Name, ip, c->FirstSock->RemotePort);
1701	}
1702
1703	c->Session = s;
1704	s->AdministratorMode = admin_mode;
1705	StrCpy(s->UserNameReal, sizeof(s->UserNameReal), username_real);
1706	StrCpy(s->GroupName, sizeof(s->GroupName), groupname);
1707
1708	// セッションキーの取得
1709	Copy(session_key, s->SessionKey, SHA1_SIZE);
1710
1711	// パラメータをセット
1712	s->MaxConnection = max_connection;
1713	s->UseEncrypt = use_encrypt;
1714	if (s->UseEncrypt && use_fast_rc4)
1715	{
1716	s->UseFastRC4 = use_fast_rc4;
1717	}
1718	s->UseCompress = use_compress;
1719	s->HalfConnection = half_connection;
1720	s->Timeout = timeout;
1721	s->QoS = qos;
1722
1723	if (policy != NULL)
1724	{
1725	s->VLanId = policy->VLanId;
1726	}
1727
1728	// ユーザー名
1729	s->Username = CopyStr(username);
1730
1731	HLog(hub, "LH_SET_SESSION", s->Name, s->MaxConnection,
1732	s->UseEncrypt ? _UU("L_YES") : _UU("L_NO"),
1733	s->UseCompress ? _UU("L_YES") : _UU("L_NO"),
1734	s->HalfConnection ? _UU("L_YES") : _UU("L_NO"),
1735	s->Timeout / 1000);
1736
1737	msg = GetHubMsg(hub);
1738	}
1739	Unlock(hub->lock);
1740
1741	// クライアントに Welcome パケットを送信
1742	p = PackWelcome(s);
1743
1744	if (true)
1745	{
1746	// VPN Client に表示するメッセージ
1747	char *utf;
1748	wchar_t winver_msg_client[3800];
1749	wchar_t winver_msg_server[3800];
1750	wchar_t *utvpn_msg;
1751	UINT tmpsize;
1752	wchar_t *tmp;
1753	RPC_WINVER server_winver;
1754
1755	GetWinVer(&server_winver);
1756
1757	Zero(winver_msg_client, sizeof(winver_msg_client));
1758	Zero(winver_msg_server, sizeof(winver_msg_server));
1759
1760	utvpn_msg = _UU("UTVPN_MSG");
1761
1762	if (IsSupportedWinVer(&winver) == false)
1763	{
1764	SYSTEMTIME st;
1765
1766	LocalTime(&st);
1767
1768	UniFormat(winver_msg_client, sizeof(winver_msg_client), _UU("WINVER_ERROR_FORMAT"),
1769	_UU("WINVER_ERROR_PC_LOCAL"),
1770	winver.Title,
1771	_UU("WINVER_ERROR_VPNSERVER"),
1772	SUPPORTED_WINDOWS_LIST,
1773	_UU("WINVER_ERROR_PC_LOCAL"),
1774	_UU("WINVER_ERROR_VPNSERVER"),
1775	_UU("WINVER_ERROR_VPNSERVER"),
1776	_UU("WINVER_ERROR_VPNSERVER"),
1777	st.wYear, st.wMonth);
1778	}
1779
1780	if (IsSupportedWinVer(&server_winver) == false)
1781	{
1782	SYSTEMTIME st;
1783
1784	LocalTime(&st);
1785
1786	UniFormat(winver_msg_server, sizeof(winver_msg_server), _UU("WINVER_ERROR_FORMAT"),
1787	_UU("WINVER_ERROR_PC_REMOTE"),
1788	server_winver.Title,
1789	_UU("WINVER_ERROR_VPNSERVER"),
1790	SUPPORTED_WINDOWS_LIST,
1791	_UU("WINVER_ERROR_PC_REMOTE"),
1792	_UU("WINVER_ERROR_VPNSERVER"),
1793	_UU("WINVER_ERROR_VPNSERVER"),
1794	_UU("WINVER_ERROR_VPNSERVER"),
1795	st.wYear, st.wMonth);
1796	}
1797
1798	tmpsize = UniStrSize(winver_msg_client) + UniStrSize(winver_msg_server) + UniStrSize(utvpn_msg) + UniStrSize(msg) * 100;
1799
1800	tmp = ZeroMalloc(tmpsize);
1801
1802	if (IsURLMsg(msg, NULL, 0) == false)
1803	{
1804	UniStrCat(tmp, tmpsize, utvpn_msg);
1805	UniStrCat(tmp, tmpsize, winver_msg_client);
1806	UniStrCat(tmp, tmpsize, winver_msg_server);
1807	}
1808	UniStrCat(tmp, tmpsize, msg);
1809
1810	utf = CopyUniToUtf(tmp);
1811
1812	PackAddData(p, "Msg", utf, StrLen(utf));
1813
1814	Free(tmp);
1815	Free(utf);
1816	}
1817
1818	Free(msg);
1819
1820	if (s->UseFastRC4)
1821	{
1822	// RC4 キーペアを生成
1823	GenerateRC4KeyPair(&key_pair);
1824
1825	// Welcome パケットに追加
1826	PackAddData(p, "rc4_key_client_to_server", key_pair.ClientToServerKey, sizeof(key_pair.ClientToServerKey));
1827	PackAddData(p, "rc4_key_server_to_client", key_pair.ServerToClientKey, sizeof(key_pair.ServerToClientKey));
1828	{
1829	char key1[64], key2[64];
1830	BinToStr(key1, sizeof(key1), key_pair.ClientToServerKey, 16);
1831	BinToStr(key2, sizeof(key2), key_pair.ServerToClientKey, 16);
1832	Debug(
1833	"Client to Server Key: %s\n"
1834	"Server to Client Key: %s\n",
1835	key1, key2);
1836	}
1837	}
1838	HttpServerSend(c->FirstSock, p);
1839	FreePack(p);
1840
1841	Copy(&c->Session->NodeInfo, &node, sizeof(NODE_INFO));
1842	{
1843	wchar_t tmp[MAX_SIZE * 2];
1844	NodeInfoToStr(tmp, sizeof(tmp), &s->NodeInfo);
1845
1846	HLog(hub, "LH_NODE_INFO", s->Name, tmp);
1847	}
1848
1849	// コネクションをトンネリングモードに移行
1850	StartTunnelingMode(c);
1851
1852	// ハーフコネクションモード時の処理
1853	if (s->HalfConnection)
1854	{
1855	// 1 つ目のソケットはクライアント→サーバー方向とする
1856	TCPSOCK ts = (TCPSOCK )LIST_DATA(c->Tcp->TcpSockList, 0);
1857	ts->Direction = TCP_CLIENT_TO_SERVER;
1858	}
1859
1860	if (s->UseFastRC4)
1861	{
1862	// 1 つ目の TCP コネクションに RC4 キー情報をセットする
1863	TCPSOCK ts = (TCPSOCK )LIST_DATA(c->Tcp->TcpSockList, 0);
1864	Copy(&ts->Rc4KeyPair, &key_pair, sizeof(RC4_KEY_PAIR));
1865
1866	InitTcpSockRc4Key(ts, true);
1867	}
1868
1869	if (s->UseEncrypt && s->UseFastRC4 == false)
1870	{
1871	s->UseSSLDataEncryption = true;
1872	}
1873	else
1874	{
1875	s->UseSSLDataEncryption = false;
1876	}
1877
1878	if (s->Hub->Type == HUB_TYPE_FARM_DYNAMIC && s->Cedar->Server != NULL && s->Cedar->Server->ServerType == SERVER_TYPE_FARM_CONTROLLER)
1879	{
1880	if (s->Hub->BeingOffline == false)
1881	{
1882	// ダイナミック仮想 HUB で SecureNAT を開始
1883	EnableSecureNATEx(s->Hub, false, true);
1884
1885	cluster_dynamic_secure_nat = true;
1886	}
1887	}
1888
1889	// セッションのメインルーチン
1890	SessionMain(s);
1891
1892	// 現在の接続数をデクリメント
1893	Lock(s->Hub->lock);
1894	{
1895	if (use_bridge_license)
1896	{
1897	Dec(hub->NumSessionsBridge);
1898	}
1899
1900	if (use_client_license)
1901	{
1902	Dec(hub->NumSessionsClient);
1903	}
1904
1905	Dec(s->Hub->NumSessions);
1906	Dec(s->Hub->Cedar->CurrentSessions);
1907
1908	// ライセンス数のデクリメント
1909	if (use_bridge_license)
1910	{
1911	Dec(s->Cedar->AssignedBridgeLicense);
1912	}
1913
1914	if (use_client_license)
1915	{
1916	Dec(s->Cedar->AssignedClientLicense);
1917	}
1918
1919	if (server != NULL)
1920	{
1921	// Server 構造体の合計割り当て済みライセンス数の更新
1922	if (server->ServerType == SERVER_TYPE_STANDALONE)
1923	{
1924	// スタンドアロンモードのみ更新
1925	// (クラスタコントローラモードでは定期的にポーリングしている)
1926	server->CurrentAssignedClientLicense = Count(s->Cedar->AssignedClientLicense);
1927	server->CurrentAssignedBridgeLicense = Count(s->Cedar->AssignedBridgeLicense);
1928	}
1929	}
1930	}
1931	Unlock(s->Hub->lock);
1932
1933	PrintSessionTotalDataSize(s);
1934
1935	HLog(s->Hub, "LH_END_SESSION", s->Name, s->TotalSendSizeReal, s->TotalRecvSizeReal);
1936
1937	if (cluster_dynamic_secure_nat && s->Hub->BeingOffline == false)
1938	{
1939	// ダイナミック仮想 HUB で SecureNAT を停止
1940	EnableSecureNATEx(s->Hub, false, true);
1941	}
1942
1943	ReleaseSession(s);
1944
1945	ret = true;
1946	c->Err = ERR_SESSION_REMOVED;
1947
1948	ReleaseHub(hub);
1949
1950	goto CLEANUP;
1951	}
1952	else if (StrCmpi(method, "additional_connect") == 0)
1953	{
1954	SOCK *sock;
1955	TCPSOCK *ts;
1956	UINT dummy;
1957
1958	c->Type = CONNECTION_TYPE_ADDITIONAL;
1959
1960	// 追加接続
1961	// セッションキーを読み出し
1962	if (GetSessionKeyFromPack(p, session_key, &dummy) == false)
1963	{
1964	FreePack(p);
1965	c->Err = ERR_PROTOCOL_ERROR;
1966	goto CLEANUP;
1967	}
1968
1969	FreePack(p);
1970
1971	// セッションキーからセッションを取得
1972	s = GetSessionFromKey(c->Cedar, session_key);
1973	if (s == NULL \|\| s->Halt)
1974	{
1975	// セッションが発見できない
1976	Debug("Session Not Found.\n");
1977	c->Err = ERR_SESSION_TIMEOUT;
1978	goto CLEANUP;
1979	}
1980
1981	// セッションが見つかった
1982	Debug("Session Found: %s\n", s->Name);
1983	// セッションのプロトコルを確認
1984	c->Err = 0;
1985	Lock(s->lock);
1986	{
1987	if (s->Connection->Protocol != CONNECTION_TCP)
1988	{
1989	c->Err = ERR_INVALID_PROTOCOL;
1990	}
1991	}
1992	Unlock(s->lock);
1993	// セッションの現在のコネクション数を調べる
1994	Lock(s->Connection->lock);
1995	if (c->Err == 0)
1996	{
1997	if (Count(s->Connection->CurrentNumConnection) > s->MaxConnection)
1998	{
1999	c->Err = ERR_TOO_MANY_CONNECTION;
2000	}
2001	}
2002	if (c->Err != 0)
2003	{
2004	Unlock(s->Connection->lock);
2005	if (c->Err == ERR_TOO_MANY_CONNECTION)
2006	{
2007	Debug("Session TOO MANY CONNECTIONS !!: %u\n",
2008	Count(s->Connection->CurrentNumConnection));
2009	}
2010	else
2011	{
2012	Debug("Session Invalid Protocol.\n");
2013	}
2014	ReleaseSession(s);
2015	goto CLEANUP;
2016	}
2017
2018	// RC4 高速暗号化鍵の生成
2019	if (s->UseFastRC4)
2020	{
2021	GenerateRC4KeyPair(&key_pair);
2022	}
2023
2024	// セッションのコネクションリスト (TCP) にこのコネクションのソケットを追加する
2025	sock = c->FirstSock;
2026	ts = NewTcpSock(sock);
2027	SetTimeout(sock, CONNECTING_TIMEOUT);
2028	direction = TCP_BOTH;
2029	LockList(s->Connection->Tcp->TcpSockList);
2030	{
2031	if (s->HalfConnection)
2032	{
2033	// ハーフコネクション時、現在のすべての TCP コネクションの方向を
2034	// 調べて自動的に調整する
2035	UINT i, c2s, s2c;
2036	c2s = s2c = 0;
2037	for (i = 0;i < LIST_NUM(s->Connection->Tcp->TcpSockList);i++)
2038	{
2039	TCPSOCK ts = (TCPSOCK )LIST_DATA(s->Connection->Tcp->TcpSockList, i);
2040	if (ts->Direction == TCP_SERVER_TO_CLIENT)
2041	{
2042	s2c++;
2043	}
2044	else
2045	{
2046	c2s++;
2047	}
2048	}
2049	if (s2c > c2s)
2050	{
2051	direction = TCP_CLIENT_TO_SERVER;
2052	}
2053	else
2054	{
2055	direction = TCP_SERVER_TO_CLIENT;
2056	}
2057	Debug("%u/%u\n", s2c, c2s);
2058	ts->Direction = direction;
2059	}
2060	}
2061	UnlockList(s->Connection->Tcp->TcpSockList);
2062
2063	if (s->UseFastRC4)
2064	{
2065	// RC4 鍵情報の設定
2066	Copy(&ts->Rc4KeyPair, &key_pair, sizeof(RC4_KEY_PAIR));
2067
2068	InitTcpSockRc4Key(ts, true);
2069	}
2070
2071	// 成功結果を返す
2072	p = PackError(ERR_NO_ERROR);
2073	PackAddInt(p, "direction", direction);
2074
2075	if (s->UseFastRC4)
2076	{
2077	// RC4 鍵情報の追加
2078	PackAddData(p, "rc4_key_client_to_server", key_pair.ClientToServerKey, sizeof(key_pair.ClientToServerKey));
2079	PackAddData(p, "rc4_key_server_to_client", key_pair.ServerToClientKey, sizeof(key_pair.ServerToClientKey));
2080	{
2081	char key1[64], key2[64];
2082	BinToStr(key1, sizeof(key1), key_pair.ClientToServerKey, 16);
2083	BinToStr(key2, sizeof(key2), key_pair.ServerToClientKey, 16);
2084	Debug(
2085	"Client to Server Key: %s\n"
2086	"Server to Client Key: %s\n",
2087	key1, key2);
2088	}
2089	}
2090
2091	HttpServerSend(c->FirstSock, p);
2092	FreePack(p);
2093
2094	SetTimeout(sock, INFINITE);
2095
2096	LockList(s->Connection->Tcp->TcpSockList);
2097	{
2098	Add(s->Connection->Tcp->TcpSockList, ts);
2099	}
2100	UnlockList(s->Connection->Tcp->TcpSockList);
2101
2102	// コネクション数をインクリメントする
2103	Inc(s->Connection->CurrentNumConnection);
2104	Debug("TCP Connection Incremented: %u\n", Count(s->Connection->CurrentNumConnection));
2105
2106	// セッションの Cancel を発行する
2107	Cancel(s->Cancel1);
2108
2109	Unlock(s->Connection->lock);
2110
2111	c->flag1 = true;
2112
2113	ReleaseSession(s);
2114
2115	return true;
2116	}
2117	else if (StrCmpi(method, "enum_hub") == 0)
2118	{
2119	// 仮想 HUB の列挙
2120	UINT i, num;
2121	LIST *o;
2122	o = NewListFast(NULL);
2123
2124	c->Type = CONNECTION_TYPE_ENUM_HUB;
2125
2126	FreePack(p);
2127	p = NewPack();
2128	LockList(c->Cedar->HubList);
2129	{
2130	num = LIST_NUM(c->Cedar->HubList);
2131	for (i = 0;i < num;i++)
2132	{
2133	HUB *h = LIST_DATA(c->Cedar->HubList, i);
2134	if (h->Option != NULL && h->Option->NoEnum == false)
2135	{
2136	Insert(o, CopyStr(h->Name));
2137	}
2138	}
2139	}
2140	UnlockList(c->Cedar->HubList);
2141
2142	num = LIST_NUM(o);
2143	for (i = 0;i < num;i++)
2144	{
2145	char *name = LIST_DATA(o, i);
2146	PackAddStrEx(p, "HubName", name, i, num);
2147	Free(name);
2148	}
2149	ReleaseList(o);
2150	PackAddInt(p, "NumHub", num);
2151
2152	HttpServerSend(c->FirstSock, p);
2153	FreePack(p);
2154	FreePack(HttpServerRecv(c->FirstSock));
2155	c->Err = 0;
2156
2157	SLog(c->Cedar, "LS_ENUM_HUB", c->Name, num);
2158
2159	goto CLEANUP;
2160	}
2161	else if (StrCmpi(method, "farm_connect") == 0)
2162	{
2163	// サーバーファーム接続要求
2164	CEDAR *cedar = c->Cedar;
2165	c->Type = CONNECTION_TYPE_FARM_RPC;
2166	c->Err = 0;
2167	if (c->Cedar->Server == NULL)
2168	{
2169	// サポートされていない
2170	c->Err = ERR_NOT_FARM_CONTROLLER;
2171	}
2172	else
2173	{
2174	SERVER *s = c->Cedar->Server;
2175	if (s->ServerType != SERVER_TYPE_FARM_CONTROLLER \|\| s->FarmControllerInited == false)
2176	{
2177	// ファームコントローラではない
2178	SLog(c->Cedar, "LS_FARM_ACCEPT_1", c->Name);
2179	c->Err = ERR_NOT_FARM_CONTROLLER;
2180	}
2181	else
2182	{
2183	UCHAR check_secure_password[SHA1_SIZE];
2184	UCHAR secure_password[SHA1_SIZE];
2185	// ユーザー認証
2186	SecurePassword(check_secure_password, s->HashedPassword, c->Random);
2187	if (PackGetDataSize(p, "SecurePassword") == sizeof(secure_password))
2188	{
2189	PackGetData(p, "SecurePassword", secure_password);
2190	}
2191	else
2192	{
2193	Zero(secure_password, sizeof(secure_password));
2194	}
2195
2196	if (Cmp(secure_password, check_secure_password, SHA1_SIZE) != 0)
2197	{
2198	// パスワードが違う
2199	SLog(c->Cedar, "LS_FARM_ACCEPT_2", c->Name);
2200	c->Err = ERR_ACCESS_DENIED;
2201	}
2202	else
2203	{
2204	// 証明書を取得する
2205	BUF *b;
2206	X *server_x;
2207
2208	SLog(c->Cedar, "LS_FARM_ACCEPT_3", c->Name);
2209	b = PackGetBuf(p, "ServerCert");
2210	if (b == NULL)
2211	{
2212	c->Err = ERR_PROTOCOL_ERROR;
2213	}
2214	else
2215	{
2216	server_x = BufToX(b, false);
2217	FreeBuf(b);
2218	if (server_x == NULL)
2219	{
2220	c->Err = ERR_PROTOCOL_ERROR;
2221	}
2222	else
2223	{
2224	UINT ip;
2225	UINT point;
2226	char hostname[MAX_SIZE];
2227
2228	#ifdef OS_WIN32
2229	MsSetThreadPriorityRealtime();
2230	#endif // OS_WIN32
2231
2232	SetTimeout(c->FirstSock, SERVER_CONTROL_TCP_TIMEOUT);
2233
2234	ip = PackGetIp32(p, "PublicIp");
2235	point = PackGetInt(p, "Point");
2236	if (PackGetStr(p, "HostName", hostname, sizeof(hostname)))
2237	{
2238	UINT num_port = PackGetIndexCount(p, "PublicPort");
2239	if (num_port >= 1 && num_port <= MAX_PUBLIC_PORT_NUM)
2240	{
2241	UINT ports = ZeroMalloc(sizeof(UINT) num_port);
2242	UINT i;
2243
2244	for (i = 0;i < num_port;i++)
2245	{
2246	ports[i] = PackGetIntEx(p, "PublicPort", i);
2247	}
2248
2249	SiFarmServ(s, c->FirstSock, server_x, ip, num_port, ports, hostname, point,
2250	PackGetInt(p, "Weight"), PackGetInt(p, "MaxSessions"));
2251
2252	Free(ports);
2253	}
2254	}
2255
2256	FreeX(server_x);
2257	}
2258	}
2259	}
2260	}
2261	}
2262	FreePack(p);
2263	goto CLEANUP;
2264	}
2265	else if (StrCmpi(method, "admin") == 0 && c->Cedar->Server != NULL)
2266	{
2267	UINT err;
2268	// 管理用 RPC 接続要求
2269	c->Type = CONNECTION_TYPE_ADMIN_RPC;
2270	err = AdminAccept(c, p);
2271	FreePack(p);
2272	if (err != ERR_NO_ERROR)
2273	{
2274	PACK *p = PackError(err);
2275	HttpServerSend(c->FirstSock, p);
2276	FreePack(p);
2277	}
2278	goto CLEANUP;
2279	}
2280	else if (StrCmpi(method, "password") == 0)
2281	{
2282	UINT err;
2283	// パスワード変更要求
2284	c->Type = CONNECTION_TYPE_PASSWORD;
2285	err = ChangePasswordAccept(c, p);
2286	FreePack(p);
2287
2288	p = PackError(err);
2289	HttpServerSend(c->FirstSock, p);
2290	FreePack(p);
2291	goto CLEANUP;
2292	}
2293	else
2294	{
2295	// 不明なメソッド
2296	FreePack(p);
2297	c->Err = ERR_PROTOCOL_ERROR;
2298	goto CLEANUP;
2299	}
2300
2301	CLEANUP:
2302	// ユーザーオブジェクトの解放
2303	if (loggedin_user_object != NULL)
2304	{
2305	ReleaseUser(loggedin_user_object);
2306	}
2307
2308	// エラーパケット送信
2309	p = PackError(c->Err);
2310	PackAddBool(p, "no_save_password", no_save_password);
2311	HttpServerSend(c->FirstSock, p);
2312	FreePack(p);
2313
2314	SLog(c->Cedar, "LS_CONNECTION_ERROR", c->Name, GetUniErrorStr(c->Err), c->Err);
2315
2316	return ret;
2317	}
2318	// シグネチャの送信 (TCP パケット) 用スレッド
2319	void SendSignatureByTcpThread(THREAD thread, void param)
2320	{
2321	BUF *buf;
2322	SEND_SIGNATURE_PARAM *p;
2323	SOCK *s;
2324	// 引数チェック
2325	if (thread == NULL \|\| param == NULL)
2326	{
2327	return;
2328	}
2329
2330	p = (SEND_SIGNATURE_PARAM *)param;
2331
2332	AddWaitThread(thread);
2333	NoticeThreadInit(thread);
2334
2335	buf = p->Buffer;
2336
2337	s = Connect(p->Hostname, p->Port);
2338
2339	if (s != NULL)
2340	{
2341	SendAll(s, buf->Buf, buf->Size, false);
2342
2343	Disconnect(s);
2344	ReleaseSock(s);
2345	}
2346
2347	DelWaitThread(thread);
2348
2349	FreeBuf(buf);
2350	Free(p);
2351	}
2352
2353	// シグネチャの送信 (TCP パケット)
2354	void SendSignatureByTcp(CONNECTION c, IP ip)
2355	{
2356	NODE_INFO info;
2357	BUF *b;
2358	SEND_SIGNATURE_PARAM *param;
2359	THREAD *t;
2360	// 引数チェック
2361	if (c == NULL \|\| ip == NULL)
2362	{
2363	return;
2364	}
2365
2366	if (c->Session == NULL \|\| c->Session->ClientOption == NULL)
2367	{
2368	return;
2369	}
2370
2371	CreateNodeInfo(&info, c);
2372
2373	b = NewBuf();
2374	WriteBuf(b, CEDAR_SIGNATURE_STR, StrLen(CEDAR_SIGNATURE_STR));
2375	SeekBuf(b, 0, 0);
2376
2377	param = ZeroMalloc(sizeof(SEND_SIGNATURE_PARAM));
2378	param->Buffer = b;
2379
2380	if (c->Session != NULL && c->Session->ClientOption != NULL)
2381	{
2382	CLIENT_OPTION *o = c->Session->ClientOption;
2383
2384	if (o->ProxyType == PROXY_DIRECT)
2385	{
2386	IPToStr(param->Hostname, sizeof(param->Hostname), ip);
2387	param->Port = o->Port;
2388	}
2389	else
2390	{
2391	StrCpy(param->Hostname, sizeof(param->Hostname), o->ProxyName);
2392	param->Port = o->ProxyPort;
2393	}
2394	}
2395
2396	t = NewThread(SendSignatureByTcpThread, param);
2397	WaitThreadInit(t);
2398	ReleaseThread(t);
2399	}
2400
2401	// ノード情報の作成
2402	void CreateNodeInfo(NODE_INFO info, CONNECTION c)
2403	{
2404	SESSION *s;
2405	OS_INFO *os;
2406	char *product_id;
2407	IP ip;
2408	// 引数チェック
2409	if (c == NULL)
2410	{
2411	return;
2412	}
2413
2414	s = c->Session;
2415	os = GetOsInfo();
2416
2417	Zero(info, sizeof(NODE_INFO));
2418
2419	// クライアント製品名
2420	StrCpy(info->ClientProductName, sizeof(info->ClientProductName), c->ClientStr);
2421	// クライアントバージョン
2422	info->ClientProductVer = Endian32(c->ClientVer);
2423	// クライアントビルド番号
2424	info->ClientProductBuild = Endian32(c->ClientBuild);
2425
2426	// サーバー製品名
2427	StrCpy(info->ServerProductName, sizeof(info->ServerProductName), c->ServerStr);
2428	// サーバーバージョン
2429	info->ServerProductVer = Endian32(c->ServerVer);
2430	// サーバービルド番号
2431	info->ServerProductBuild = Endian32(c->ServerBuild);
2432
2433	// クライアント OS 名
2434	StrCpy(info->ClientOsName, sizeof(info->ClientOsName), os->OsProductName);
2435	// クライアント OS バージョン
2436	StrCpy(info->ClientOsVer, sizeof(info->ClientOsVer), os->OsVersion);
2437	// クライアント OS プロダクト ID
2438	product_id = OSGetProductId();
2439	StrCpy(info->ClientOsProductId, sizeof(info->ClientOsProductId), product_id);
2440	Free(product_id);
2441
2442	// クライアントホスト名
2443	GetMachineName(info->ClientHostname, sizeof(info->ClientHostname));
2444	// クライアント IP アドレス
2445	if (IsIP6(&c->FirstSock->LocalIP) == false)
2446	{
2447	info->ClientIpAddress = IPToUINT(&c->FirstSock->LocalIP);
2448	}
2449	else
2450	{
2451	Copy(info->ClientIpAddress6, c->FirstSock->LocalIP.ipv6_addr, sizeof(info->ClientIpAddress6));
2452	}
2453	// クライアントポート番号
2454	info->ClientPort = Endian32(c->FirstSock->LocalPort);
2455
2456	// サーバーホスト名
2457	StrCpy(info->ServerHostname, sizeof(info->ServerHostname), c->ServerName);
2458	// サーバー IP アドレス
2459	if (GetIP(&ip, info->ServerHostname))
2460	{
2461	if (IsIP6(&ip) == false)
2462	{
2463	info->ServerIpAddress = IPToUINT(&ip);
2464	}
2465	else
2466	{
2467	Copy(info->ServerIpAddress6, ip.ipv6_addr, sizeof(info->ServerIpAddress6));
2468	}
2469	}
2470	// サーバーポート番号
2471	info->ServerPort = Endian32(c->ServerPort);
2472
2473	if (s->ClientOption->ProxyType == PROXY_SOCKS \|\| s->ClientOption->ProxyType == PROXY_HTTP)
2474	{
2475	// プロキシホスト名
2476	StrCpy(info->ProxyHostname, sizeof(info->ProxyHostname), s->ClientOption->ProxyName);
2477
2478	// プロキシ IP アドレス
2479	if (IsIP6(&c->FirstSock->RemoteIP) == false)
2480	{
2481	info->ProxyIpAddress = IPToUINT(&c->FirstSock->RemoteIP);
2482	}
2483	else
2484	{
2485	Copy(&info->ProxyIpAddress6, c->FirstSock->RemoteIP.ipv6_addr, sizeof(info->ProxyIpAddress6));
2486	}
2487
2488	info->ProxyPort = Endian32(c->FirstSock->RemotePort);
2489	}
2490
2491	// HUB 名
2492	StrCpy(info->HubName, sizeof(info->HubName), s->ClientOption->HubName);
2493
2494	// ユニーク ID
2495	Copy(info->UniqueId, c->Cedar->UniqueId, sizeof(info->UniqueId));
2496	}
2497
2498	// ソケットを追加接続する
2499	SOCK ClientAdditionalConnectToServer(CONNECTION c)
2500	{
2501	SOCK *s;
2502	// 引数チェック
2503	if (c == NULL)
2504	{
2505	return NULL;
2506	}
2507
2508	// ソケット接続
2509	s = ClientConnectGetSocket(c, true);
2510	if (s == NULL)
2511	{
2512	// 接続失敗
2513	return NULL;
2514	}
2515
2516	// ソケットをリストに追加する
2517	LockList(c->ConnectingSocks);
2518	{
2519	Add(c->ConnectingSocks, s);
2520	AddRef(s->ref);
2521	}
2522	UnlockList(c->ConnectingSocks);
2523
2524	if (c->Session->Halt)
2525	{
2526	// 停止
2527	Disconnect(s);
2528	LockList(c->ConnectingSocks);
2529	{
2530	if (Delete(c->ConnectingSocks, s))
2531	{
2532	ReleaseSock(s);
2533	}
2534	}
2535	UnlockList(c->ConnectingSocks);
2536	ReleaseSock(s);
2537	return NULL;
2538	}
2539
2540	// タイムアウト
2541	SetTimeout(s, CONNECTING_TIMEOUT);
2542
2543	// SSL 通信開始
2544	if (StartSSLEx(s, NULL, NULL, (c->DontUseTls1 ? false : true)) == false)
2545	{
2546	// SSL 通信失敗
2547	Disconnect(s);
2548	LockList(c->ConnectingSocks);
2549	{
2550	if (Delete(c->ConnectingSocks, s))
2551	{
2552	ReleaseSock(s);
2553	}
2554	}
2555	UnlockList(c->ConnectingSocks);
2556	ReleaseSock(s);
2557	return NULL;
2558	}
2559
2560	// 証明書のチェック
2561	if (CompareX(s->RemoteX, c->ServerX) == false)
2562	{
2563	// 証明書が不正
2564	Disconnect(s);
2565	c->Session->SessionTimeOuted = true;
2566	}
2567
2568	return s;
2569	}
2570
2571	// セキュアデバイス内の証明書と鍵を削除する
2572	UINT SecureDelete(UINT device_id, char pin, char cert_name, char *key_name)
2573	{
2574	SECURE *sec;
2575	// 引数チェック
2576	if (pin == NULL \|\| device_id == 0)
2577	{
2578	return ERR_INTERNAL_ERROR;
2579	}
2580
2581	// デバイスを開く
2582	sec = OpenSec(device_id);
2583	if (sec == NULL)
2584	{
2585	return ERR_SECURE_DEVICE_OPEN_FAILED;
2586	}
2587
2588	// セッションを開く
2589	if (OpenSecSession(sec, 0) == false)
2590	{
2591	CloseSec(sec);
2592	return ERR_SECURE_DEVICE_OPEN_FAILED;
2593	}
2594
2595	// ログイン
2596	if (LoginSec(sec, pin) == false)
2597	{
2598	CloseSecSession(sec);
2599	CloseSec(sec);
2600	return ERR_SECURE_PIN_LOGIN_FAILED;
2601	}
2602
2603	// 証明書削除
2604	if (cert_name != NULL)
2605	{
2606	DeleteSecCert(sec, cert_name);
2607	}
2608
2609	// 秘密鍵削除
2610	if (key_name != NULL)
2611	{
2612	DeleteSecKey(sec, key_name);
2613	}
2614
2615	// ログアウト
2616	LogoutSec(sec);
2617
2618	// セッションを閉じる
2619	CloseSecSession(sec);
2620
2621	// デバイスを閉じる
2622	CloseSec(sec);
2623
2624	return ERR_NO_ERROR;
2625	}
2626
2627	// セキュアデバイス内の証明書と鍵を列挙する
2628	UINT SecureEnum(UINT device_id, char pin, TOKEN_LIST cert_list, TOKEN_LIST *key_list)
2629	{
2630	SECURE *sec;
2631	LIST *o;
2632	LIST cert_name_list, key_name_list;
2633	// 引数チェック
2634	if (pin == NULL \|\| device_id == 0 \|\| cert_list == NULL \|\| key_list == NULL)
2635	{
2636	return ERR_INTERNAL_ERROR;
2637	}
2638
2639	// デバイスを開く
2640	sec = OpenSec(device_id);
2641	if (sec == NULL)
2642	{
2643	return ERR_SECURE_DEVICE_OPEN_FAILED;
2644	}
2645
2646	// セッションを開く
2647	if (OpenSecSession(sec, 0) == false)
2648	{
2649	CloseSec(sec);
2650	return ERR_SECURE_DEVICE_OPEN_FAILED;
2651	}
2652
2653	// ログイン
2654	if (LoginSec(sec, pin) == false)
2655	{
2656	CloseSecSession(sec);
2657	CloseSec(sec);
2658	return ERR_SECURE_PIN_LOGIN_FAILED;
2659	}
2660
2661	// オブジェクトの列挙
2662	if ((o = EnumSecObject(sec)) != NULL)
2663	{
2664	UINT i;
2665
2666	cert_name_list = NewList(CompareStr);
2667	key_name_list = NewList(CompareStr);
2668
2669	for (i = 0;i < LIST_NUM(o);i++)
2670	{
2671	SEC_OBJ *obj = LIST_DATA(o, i);
2672
2673	if (obj->Type == SEC_X)
2674	{
2675	Add(cert_name_list, CopyStr(obj->Name));
2676	}
2677	else if (obj->Type == SEC_K)
2678	{
2679	Add(key_name_list, CopyStr(obj->Name));
2680	}
2681	}
2682
2683	Sort(cert_name_list);
2684	Sort(key_name_list);
2685
2686	*cert_list = ListToTokenList(cert_name_list);
2687	*key_list = ListToTokenList(key_name_list);
2688
2689	// メモリ解放
2690	FreeStrList(cert_name_list);
2691	FreeStrList(key_name_list);
2692	FreeEnumSecObject(o);
2693	}
2694	else
2695	{
2696	*cert_list = NullToken();
2697	*key_list = NullToken();
2698	}
2699
2700	// ログアウト
2701	LogoutSec(sec);
2702
2703	// セッションを閉じる
2704	CloseSecSession(sec);
2705
2706	// デバイスを閉じる
2707	CloseSec(sec);
2708
2709	return ERR_NO_ERROR;
2710	}
2711
2712	// セキュアデバイスに証明書と鍵を記録する
2713	UINT SecureWrite(UINT device_id, char cert_name, X x, char key_name, K k, char *pin)
2714	{
2715	SECURE *sec;
2716	bool failed;
2717	// 引数チェック
2718	if (pin == NULL \|\| device_id == 0 \|\| cert_name == NULL \|\| x == NULL \|\| key_name == NULL \|\| k == NULL)
2719	{
2720	return ERR_INTERNAL_ERROR;
2721	}
2722
2723	// デバイスを開く
2724	sec = OpenSec(device_id);
2725	if (sec == NULL)
2726	{
2727	return ERR_SECURE_DEVICE_OPEN_FAILED;
2728	}
2729
2730	// セッションを開く
2731	if (OpenSecSession(sec, 0) == false)
2732	{
2733	CloseSec(sec);
2734	return ERR_SECURE_DEVICE_OPEN_FAILED;
2735	}
2736
2737	// ログイン
2738	if (LoginSec(sec, pin) == false)
2739	{
2740	CloseSecSession(sec);
2741	CloseSec(sec);
2742	return ERR_SECURE_PIN_LOGIN_FAILED;
2743	}
2744
2745	// 登録
2746	failed = false;
2747
2748	// 証明書の登録
2749	if (WriteSecCert(sec, true, cert_name, x) == false)
2750	{
2751	failed = true;
2752	}
2753
2754	// 秘密鍵の登録
2755	if (WriteSecKey(sec, true, key_name, k) == false)
2756	{
2757	failed = true;
2758	}
2759
2760	// ログアウト
2761	LogoutSec(sec);
2762
2763	// セッションを閉じる
2764	CloseSecSession(sec);
2765
2766	// デバイスを閉じる
2767	CloseSec(sec);
2768
2769	if (failed == false)
2770	{
2771	// 成功
2772	return ERR_NO_ERROR;
2773	}
2774	else
2775	{
2776	// 失敗
2777	return ERR_SECURE_CANT_WRITE;
2778	}
2779	}
2780
2781	// セキュアデバイスによる署名を試行する
2782	UINT SecureSign(SECURE_SIGN sign, UINT device_id, char pin)
2783	{
2784	SECURE *sec;
2785	X *x;
2786	// 引数チェック
2787	if (sign == false \|\| pin == NULL \|\| device_id == 0)
2788	{
2789	return ERR_INTERNAL_ERROR;
2790	}
2791
2792	// デバイスを開く
2793	sec = OpenSec(device_id);
2794	if (sec == NULL)
2795	{
2796	return ERR_SECURE_DEVICE_OPEN_FAILED;
2797	}
2798
2799	// セッションを開く
2800	if (OpenSecSession(sec, 0) == false)
2801	{
2802	CloseSec(sec);
2803	return ERR_SECURE_DEVICE_OPEN_FAILED;
2804	}
2805
2806	// ログイン
2807	if (LoginSec(sec, pin) == false)
2808	{
2809	CloseSecSession(sec);
2810	CloseSec(sec);
2811	return ERR_SECURE_PIN_LOGIN_FAILED;
2812	}
2813
2814	// 証明書の読み込み
2815	x = ReadSecCert(sec, sign->SecurePublicCertName);
2816	if (x == NULL)
2817	{
2818	LogoutSec(sec);
2819	CloseSecSession(sec);
2820	CloseSec(sec);
2821	return ERR_SECURE_NO_CERT;
2822	}
2823
2824	// 秘密鍵による署名
2825	if (SignSec(sec, sign->SecurePrivateKeyName, sign->Signature, sign->Random, SHA1_SIZE) == false)
2826	{
2827	// 署名失敗
2828	FreeX(x);
2829	LogoutSec(sec);
2830	CloseSecSession(sec);
2831	CloseSec(sec);
2832	return ERR_SECURE_NO_PRIVATE_KEY;
2833	}
2834
2835	// 証明書をバッファに変換
2836	sign->ClientCert = x;
2837
2838	// ログアウト
2839	LogoutSec(sec);
2840
2841	// セッションを閉じる
2842	CloseSecSession(sec);
2843
2844	// デバイスを閉じる
2845	CloseSec(sec);
2846
2847	// 成功
2848	return ERR_NO_ERROR;
2849	}
2850
2851	// クライアントがサーバーに追加接続する
2852	bool ClientAdditionalConnect(CONNECTION c, THREAD t)
2853	{
2854	SOCK *s;
2855	PACK *p;
2856	TCPSOCK *ts;
2857	UINT err;
2858	UINT direction;
2859	RC4_KEY_PAIR key_pair;
2860	// 引数チェック
2861	if (c == NULL)
2862	{
2863	return false;
2864	}
2865
2866	// サーバーにソケット接続
2867	s = ClientAdditionalConnectToServer(c);
2868	if (s == NULL)
2869	{
2870	// ソケット接続に失敗
2871	return false;
2872	}
2873
2874	if (c->Halt)
2875	{
2876	goto CLEANUP;
2877	}
2878
2879	// シグネチャを送信
2880	Debug("Uploading Signature...\n");
2881	if (ClientUploadSignature(s) == false)
2882	{
2883	goto CLEANUP;
2884	}
2885
2886	if (c->Halt)
2887	{
2888	// 停止
2889	goto CLEANUP;
2890	}
2891
2892	// Hello パケットを受信
2893	Debug("Downloading Hello...\n");
2894	if (ClientDownloadHello(c, s) == false)
2895	{
2896	goto CLEANUP;
2897	}
2898
2899	if (c->Halt)
2900	{
2901	// 停止
2902	goto CLEANUP;
2903	}
2904
2905	// 追加接続用の認証データを送信
2906	if (ClientUploadAuth2(c, s) == false)
2907	{
2908	// 切断された
2909	goto CLEANUP;
2910	}
2911
2912	// 応答を受信
2913	p = HttpClientRecv(s);
2914	if (p == NULL)
2915	{
2916	// 切断された
2917	goto CLEANUP;
2918	}
2919
2920	err = GetErrorFromPack(p);
2921	direction = PackGetInt(p, "direction");
2922
2923	if (c->Session->UseFastRC4)
2924	{
2925	// RC4 鍵情報の取得
2926	if (PackGetDataSize(p, "rc4_key_client_to_server") == 16)
2927	{
2928	PackGetData(p, "rc4_key_client_to_server", key_pair.ClientToServerKey);
2929	}
2930	if (PackGetDataSize(p, "rc4_key_server_to_client") == 16)
2931	{
2932	PackGetData(p, "rc4_key_server_to_client", key_pair.ServerToClientKey);
2933	}
2934	{
2935	char key1[64], key2[64];
2936	BinToStr(key1, sizeof(key1), key_pair.ClientToServerKey, 16);
2937	BinToStr(key2, sizeof(key2), key_pair.ServerToClientKey, 16);
2938	Debug(
2939	"Client to Server Key: %s\n"
2940	"Server to Client Key: %s\n",
2941	key1, key2);
2942	}
2943	}
2944
2945	FreePack(p);
2946	p = NULL;
2947
2948	if (err != 0)
2949	{
2950	// エラーが発生した
2951	Debug("Additional Connect Error: %u\n", err);
2952	if (err == ERR_SESSION_TIMEOUT \|\| err == ERR_INVALID_PROTOCOL)
2953	{
2954	// 致命的なエラーなので再接続しなおすことにする
2955	c->Session->SessionTimeOuted = true;
2956	}
2957	goto CLEANUP;
2958	}
2959
2960	Debug("Additional Connect Succeed!\n");
2961
2962	// 追加接続成功
2963	// コネクションの TcpSockList に追加する
2964	ts = NewTcpSock(s);
2965
2966	if (c->ServerMode == false)
2967	{
2968	if (c->Session->ClientOption->ConnectionDisconnectSpan != 0)
2969	{
2970	ts->DisconnectTick = Tick64() + c->Session->ClientOption->ConnectionDisconnectSpan * (UINT64)1000;
2971	}
2972	}
2973
2974	LockList(c->Tcp->TcpSockList);
2975	{
2976	ts->Direction = direction;
2977	Add(c->Tcp->TcpSockList, ts);
2978	}
2979	UnlockList(c->Tcp->TcpSockList);
2980	Debug("TCP Connection Incremented: %u\n", Count(c->CurrentNumConnection));
2981
2982	if (c->Session->HalfConnection)
2983	{
2984	Debug("New Half Connection: %s\n",
2985	direction == TCP_SERVER_TO_CLIENT ? "TCP_SERVER_TO_CLIENT" : "TCP_CLIENT_TO_SERVER"
2986	);
2987	}
2988
2989	if (c->Session->UseFastRC4)
2990	{
2991	// RC4 暗号化鍵のセット
2992	Copy(&ts->Rc4KeyPair, &key_pair, sizeof(RC4_KEY_PAIR));
2993
2994	InitTcpSockRc4Key(ts, false);
2995	}
2996
2997	// セッションに Cancel を発行する
2998	Cancel(c->Session->Cancel1);
2999
3000	// 接続中のソケット一覧からこのソケットを削除
3001	LockList(c->ConnectingSocks);
3002	{
3003	if (Delete(c->ConnectingSocks, s))
3004	{
3005	ReleaseSock(s);
3006	}
3007	}
3008	UnlockList(c->ConnectingSocks);
3009	ReleaseSock(s);
3010	return true;
3011
3012	CLEANUP:
3013	// 切断処理
3014	Disconnect(s);
3015	LockList(c->ConnectingSocks);
3016	{
3017	if (Delete(c->ConnectingSocks, s))
3018	{
3019	ReleaseSock(s);
3020
3021	}
3022	}
3023	UnlockList(c->ConnectingSocks);
3024	ReleaseSock(s);
3025	return false;
3026	}
3027
3028	// セキュアデバイス署名スレッド
3029	void ClientSecureSignThread(THREAD thread, void param)
3030	{
3031	SECURE_SIGN_THREAD_PROC p = (SECURE_SIGN_THREAD_PROC )param;
3032	// 引数チェック
3033	if (thread == NULL \|\| param == NULL)
3034	{
3035	return;
3036	}
3037
3038	NoticeThreadInit(thread);
3039
3040	p->Ok = p->SecureSignProc(p->Connection->Session, p->Connection, p->SecureSign);
3041	p->UserFinished = true;
3042	}
3043
3044	// セキュアデバイスを使用した署名
3045	bool ClientSecureSign(CONNECTION c, UCHAR sign, UCHAR random, X *x)
3046	{
3047	SECURE_SIGN_THREAD_PROC *p;
3048	SECURE_SIGN *ss;
3049	SESSION *s;
3050	CLIENT_OPTION *o;
3051	CLIENT_AUTH *a;
3052	THREAD *thread;
3053	UINT64 start;
3054	bool ret;
3055	// 引数チェック
3056	if (c == NULL \|\| sign == NULL \|\| random == NULL \|\| x == NULL)
3057	{
3058	return false;
3059	}
3060
3061	s = c->Session;
3062	o = s->ClientOption;
3063	a = s->ClientAuth;
3064
3065	p = ZeroMalloc(sizeof(SECURE_SIGN_THREAD_PROC));
3066	p->Connection = c;
3067	ss = p->SecureSign = ZeroMallocEx(sizeof(SECURE_SIGN), true);
3068	StrCpy(ss->SecurePrivateKeyName, sizeof(ss->SecurePrivateKeyName),
3069	a->SecurePrivateKeyName);
3070	StrCpy(ss->SecurePublicCertName, sizeof(ss->SecurePublicCertName),
3071	a->SecurePublicCertName);
3072	ss->UseSecureDeviceId = c->Cedar->Client->UseSecureDeviceId;
3073	Copy(ss->Random, random, SHA1_SIZE);
3074
3075	#ifdef OS_WIN32
3076	ss->BitmapId = CmGetSecureBitmapId(c->ServerName);
3077	#endif // OS_WIN32
3078
3079	p->SecureSignProc = a->SecureSignProc;
3080
3081	// スレッド作成
3082	thread = NewThread(ClientSecureSignThread, p);
3083	WaitThreadInit(thread);
3084
3085	// 署名が完了するかキャンセルするまで 0.5 秒ごとにポーリングする
3086	start = Tick64();
3087	while (true)
3088	{
3089	if ((Tick64() - start) > CONNECTING_POOLING_SPAN)
3090	{
3091	// 切断防止のため一定期間ごとに NOOP を送信する
3092	start = Tick64();
3093	ClientUploadNoop(c);
3094	}
3095	if (p->UserFinished)
3096	{
3097	// ユーザーが選択した
3098	break;
3099	}
3100	WaitThread(thread, 500);
3101	}
3102	ReleaseThread(thread);
3103
3104	ret = p->Ok;
3105
3106	if (ret)
3107	{
3108	Copy(sign, ss->Signature, 128);
3109	*x = ss->ClientCert;
3110	}
3111
3112	Free(p->SecureSign);
3113	Free(p);
3114
3115	return ret;
3116	}
3117
3118	// サーバー証明書確認用スレッド
3119	void ClientCheckServerCertThread(THREAD thread, void param)
3120	{
3121	CHECK_CERT_THREAD_PROC p = (CHECK_CERT_THREAD_PROC )param;
3122	// 引数チェック
3123	if (thread == NULL \|\| param == NULL)
3124	{
3125	return;
3126	}
3127
3128	// 初期化完了を通知する
3129	NoticeThreadInit(thread);
3130
3131	// ユーザーに選択を問い合わせる
3132	p->Ok = p->CheckCertProc(p->Connection->Session, p->Connection, p->ServerX, &p->Exipred);
3133	p->UserSelected = true;
3134	}
3135
3136	// クライアントがサーバーの証明書を確認する
3137	bool ClientCheckServerCert(CONNECTION c, bool expired)
3138	{
3139	CLIENT_AUTH *auth;
3140	X *x;
3141	CHECK_CERT_THREAD_PROC *p;
3142	THREAD *thread;
3143	CEDAR *cedar;
3144	bool ret;
3145	UINT64 start;
3146	// 引数チェック
3147	if (c == NULL)
3148	{
3149	return false;
3150	}
3151
3152	if (expired != NULL)
3153	{
3154	*expired = false;
3155	}
3156
3157	auth = c->Session->ClientAuth;
3158	cedar = c->Cedar;
3159
3160	if (auth->CheckCertProc == NULL && c->Session->LinkModeClient == false)
3161	{
3162	// チェック関数無し
3163	return true;
3164	}
3165
3166	if (c->Session->LinkModeClient && c->Session->Link->CheckServerCert == false)
3167	{
3168	// カスケード接続モードだがサーバー証明書はチェックしない
3169	return true;
3170	}
3171
3172	if (c->UseTicket)
3173	{
3174	// リダイレクト先 VPN サーバーの証明書を確認する
3175	if (CompareX(c->FirstSock->RemoteX, c->ServerX) == false)
3176	{
3177	return false;
3178	}
3179	else
3180	{
3181	return true;
3182	}
3183	}
3184
3185	x = CloneX(c->FirstSock->RemoteX);
3186	if (x == NULL)
3187	{
3188	// 変なエラーが発生した
3189	return false;
3190	}
3191
3192	if (CheckXDateNow(x))
3193	{
3194	// 信頼するルート証明書によって署名されているかどうか確認する
3195	if (c->Session->LinkModeClient == false)
3196	{
3197	// 通常の VPN Client モード
3198	if (CheckSignatureByCa(cedar, x))
3199	{
3200	// 署名されているのでこの証明書は信頼できる
3201	FreeX(x);
3202	return true;
3203	}
3204	}
3205	else
3206	{
3207	// カスケード接続モード
3208	if (CheckSignatureByCaLinkMode(c->Session, x))
3209	{
3210	// 署名されているのでこの証明書は信頼できる
3211	FreeX(x);
3212	return true;
3213	}
3214	}
3215	}
3216
3217	if (c->Session->LinkModeClient)
3218	{
3219	if (CheckXDateNow(x))
3220	{
3221	Lock(c->Session->Link->lock);
3222	{
3223	if (c->Session->Link->ServerCert != NULL)
3224	{
3225	if (CompareX(c->Session->Link->ServerCert, x))
3226	{
3227	Unlock(c->Session->Link->lock);
3228	// カスケード接続設定に登録されている証明書と完全一致
3229	FreeX(x);
3230	return true;
3231	}
3232	}
3233	}
3234	Unlock(c->Session->Link->lock);
3235	}
3236	else
3237	{
3238	if (expired != NULL)
3239	{
3240	*expired = true;
3241	}
3242	}
3243
3244	// カスケード接続モードの場合はこの時点で検証失敗
3245	FreeX(x);
3246	return false;
3247	}
3248
3249	p = ZeroMalloc(sizeof(CHECK_CERT_THREAD_PROC));
3250	p->ServerX = x;
3251	p->CheckCertProc = auth->CheckCertProc;
3252	p->Connection = c;
3253
3254	// スレッドを作成する
3255	thread = NewThread(ClientCheckServerCertThread, p);
3256	WaitThreadInit(thread);
3257
3258	// ユーザーが接続の可否を選択するまで 0.5 秒間隔でポーリングする
3259	start = Tick64();
3260	while (true)
3261	{
3262	if ((Tick64() - start) > CONNECTING_POOLING_SPAN)
3263	{
3264	// 切断防止のため一定期間ごとに NOOP を送信する
3265	start = Tick64();
3266	ClientUploadNoop(c);
3267	}
3268	if (p->UserSelected)
3269	{
3270	// ユーザーが選択した
3271	break;
3272	}
3273	WaitThread(thread, 500);
3274	}
3275
3276	if (expired != NULL)
3277	{
3278	*expired = p->Exipred;
3279	}
3280
3281	ret = p->Ok;
3282	FreeX(p->ServerX);
3283	Free(p);
3284	ReleaseThread(thread);
3285
3286	return ret;
3287	}
3288
3289	// クライアントがサーバーに接続する
3290	bool ClientConnect(CONNECTION *c)
3291	{
3292	bool ret = false;
3293	bool ok = false;
3294	UINT err;
3295	SOCK *s;
3296	PACK *p = NULL;
3297	UINT session_key_32;
3298	SESSION *sess;
3299	char session_name[MAX_SESSION_NAME_LEN + 1];
3300	char connection_name[MAX_CONNECTION_NAME_LEN + 1];
3301	UCHAR session_key[SHA1_SIZE];
3302	RC4_KEY_PAIR key_pair;
3303	POLICY *policy;
3304	bool expired = false;
3305	IP server_ip;
3306	// 引数チェック
3307	if (c == NULL)
3308	{
3309	return false;
3310	}
3311
3312	sess = c->Session;
3313
3314	PrintStatus(sess, L"init");
3315	PrintStatus(sess, _UU("STATUS_1"));
3316
3317	REDIRECTED:
3318
3319	// [接続中]
3320	c->Status = CONNECTION_STATUS_CONNECTING;
3321	c->Session->ClientStatus = CLIENT_STATUS_CONNECTING;
3322
3323	s = ClientConnectToServer(c);
3324	if (s == NULL)
3325	{
3326	PrintStatus(sess, L"free");
3327	return false;
3328	}
3329
3330	Copy(&server_ip, &s->RemoteIP, sizeof(IP));
3331
3332	if (c->Halt)
3333	{
3334	// 停止
3335	c->Err = ERR_USER_CANCEL;
3336	goto CLEANUP;
3337	}
3338
3339	// [ネゴシエーション中]
3340	c->Session->ClientStatus = CLIENT_STATUS_NEGOTIATION;
3341
3342	// シグネチャを送信
3343	Debug("Uploading Signature...\n");
3344	if (ClientUploadSignature(s) == false)
3345	{
3346	c->Err = ERR_DISCONNECTED;
3347	goto CLEANUP;
3348	}
3349
3350	if (c->Halt)
3351	{
3352	// 停止
3353	c->Err = ERR_USER_CANCEL;
3354	goto CLEANUP;
3355	}
3356
3357	PrintStatus(sess, _UU("STATUS_5"));
3358
3359	// Hello パケットを受信
3360	Debug("Downloading Hello...\n");
3361	if (ClientDownloadHello(c, s) == false)
3362	{
3363	goto CLEANUP;
3364	}
3365
3366	if (c->Session->ClientOption != NULL && c->Session->ClientOption->FromAdminPack)
3367	{
3368	if (IsAdminPackSupportedServerProduct(c->ServerStr) == false)
3369	{
3370	c->Err = ERR_NOT_ADMINPACK_SERVER;
3371	goto CLEANUP;
3372	}
3373	}
3374
3375	if (c->Halt)
3376	{
3377	// 停止
3378	c->Err = ERR_USER_CANCEL;
3379	goto CLEANUP;
3380	}
3381
3382	Debug("Server Version : %u\n"
3383	"Server String : %s\n"
3384	"Server Build : %u\n"
3385	"Client Version : %u\n"
3386	"Client String : %s\n"
3387	"Client Build : %u\n",
3388	c->ServerVer, c->ServerStr, c->ServerBuild,
3389	c->ClientVer, c->ClientStr, c->ClientBuild);
3390
3391	// ユーザー認証中
3392	c->Session->ClientStatus = CLIENT_STATUS_AUTH;
3393
3394	// クライアントによるサーバー証明書の確認
3395	if (ClientCheckServerCert(c, &expired) == false)
3396	{
3397	if (expired == false)
3398	{
3399	c->Err = ERR_CERT_NOT_TRUSTED;
3400	}
3401	else
3402	{
3403	c->Err = ERR_SERVER_CERT_EXPIRES;
3404	}
3405
3406	if (c->Session->LinkModeClient == false && c->Err == ERR_CERT_NOT_TRUSTED)
3407	{
3408	c->Session->ForceStopFlag = true;
3409	}
3410
3411	goto CLEANUP;
3412	}
3413
3414	PrintStatus(sess, _UU("STATUS_6"));
3415
3416	// 認証データを送信
3417	if (ClientUploadAuth(c) == false)
3418	{
3419	goto CLEANUP;
3420	}
3421
3422	if (c->Halt)
3423	{
3424	// 停止
3425	c->Err = ERR_USER_CANCEL;
3426	goto CLEANUP;
3427	}
3428
3429	// Welcome パケットを受信
3430	p = HttpClientRecv(s);
3431	if (p == NULL)
3432	{
3433	c->Err = ERR_DISCONNECTED;
3434	goto CLEANUP;
3435	}
3436
3437	// エラーチェック
3438	err = GetErrorFromPack(p);
3439	if (err != 0)
3440	{
3441	// エラー発生
3442	c->Err = err;
3443	c->ClientConnectError_NoSavePassword = PackGetBool(p, "no_save_password");
3444	goto CLEANUP;
3445	}
3446
3447	// 接続制限のためのブランド化文字列チェック
3448	{
3449	char tmp[20];
3450	char *branded_cfroms = _SS("BRANDED_C_FROM_S");
3451	PackGetStr(p, "branded_cfroms", tmp, sizeof(tmp));
3452
3453	if(StrLen(branded_cfroms) > 0 && StrCmpi(branded_cfroms, tmp) != 0)
3454	{
3455	c->Err = ERR_BRANDED_C_FROM_S;
3456	goto CLEANUP;
3457	}
3458	}
3459
3460	if (true)
3461	{
3462	// メッセージ取得
3463	UINT utf_size;
3464	char *utf;
3465	wchar_t *msg;
3466
3467	utf_size = PackGetDataSize(p, "Msg");
3468	utf = ZeroMalloc(utf_size + 8);
3469	PackGetData(p, "Msg", utf);
3470
3471	msg = CopyUtfToUni(utf);
3472
3473	if (IsEmptyUniStr(msg) == false)
3474	{
3475	if (c->Session->Client_Message != NULL)
3476	{
3477	Free(c->Session->Client_Message);
3478	}
3479
3480	c->Session->Client_Message = msg;
3481	}
3482	else
3483	{
3484	Free(msg);
3485	}
3486
3487	Free(utf);
3488	}
3489
3490	if (PackGetInt(p, "Redirect") != 0)
3491	{
3492	UINT i;
3493	UINT ip;
3494	UINT num_port;
3495	UINT *ports;
3496	UINT use_port = 0;
3497	UINT current_port = c->ServerPort;
3498	UCHAR ticket[SHA1_SIZE];
3499	X *server_cert;
3500	BUF *b;
3501
3502	// リダイレクトモード
3503	PrintStatus(sess, _UU("STATUS_8"));
3504
3505	ip = PackGetIp32(p, "Ip");
3506	num_port = MAX(MIN(PackGetIndexCount(p, "Port"), MAX_PUBLIC_PORT_NUM), 1);
3507	ports = ZeroMalloc(sizeof(UINT) * num_port);
3508	for (i = 0;i < num_port;i++)
3509	{
3510	ports[i] = PackGetIntEx(p, "Port", i);
3511	}
3512
3513	// ポート番号を選定する
3514	for (i = 0;i < num_port;i++)
3515	{
3516	if (ports[i] == current_port)
3517	{
3518	use_port = current_port;
3519	}
3520	}
3521	if (use_port == 0)
3522	{
3523	use_port = ports[0];
3524	}
3525
3526	Free(ports);
3527
3528	if (PackGetDataSize(p, "Ticket") == SHA1_SIZE)
3529	{
3530	PackGetData(p, "Ticket", ticket);
3531	}
3532
3533	b = PackGetBuf(p, "Cert");
3534	if (b != NULL)
3535	{
3536	server_cert = BufToX(b, false);
3537	FreeBuf(b);
3538	}
3539
3540	if (c->ServerX != NULL)
3541	{
3542	FreeX(c->ServerX);
3543	}
3544	c->ServerX = server_cert;
3545
3546	IPToStr32(c->ServerName, sizeof(c->ServerName), ip);
3547	c->ServerPort = use_port;
3548
3549	c->UseTicket = true;
3550	Copy(c->Ticket, ticket, SHA1_SIZE);
3551
3552	FreePack(p);
3553
3554	p = NewPack();
3555	HttpClientSend(s, p);
3556	FreePack(p);
3557
3558	p = NULL;
3559
3560	c->FirstSock = NULL;
3561	Disconnect(s);
3562	ReleaseSock(s);
3563	s = NULL;
3564
3565	goto REDIRECTED;
3566	}
3567
3568	PrintStatus(sess, _UU("STATUS_7"));
3569
3570	// Welcome パケットをパース
3571	if (ParseWelcomeFromPack(p, session_name, sizeof(session_name),
3572	connection_name, sizeof(connection_name), &policy) == false)
3573	{
3574	// パース失敗
3575	c->Err = ERR_PROTOCOL_ERROR;
3576	goto CLEANUP;
3577	}
3578
3579	// セッションキーを取得
3580	if (GetSessionKeyFromPack(p, session_key, &session_key_32) == false)
3581	{
3582	// 取得失敗
3583	Free(policy);
3584	policy = NULL;
3585	c->Err = ERR_PROTOCOL_ERROR;
3586	goto CLEANUP;
3587	}
3588
3589	Copy(c->Session->SessionKey, session_key, SHA1_SIZE);
3590	c->Session->SessionKey32 = session_key_32;
3591
3592	// Welcome パケットの内容を保存
3593	Debug("session_name: %s, connection_name: %s\n",
3594	session_name, connection_name);
3595
3596	Lock(c->Session->lock);
3597	{
3598	// 接続パラメータの展開と更新
3599	c->Session->MaxConnection = PackGetInt(p, "max_connection");
3600	c->Session->MaxConnection = MIN(c->Session->MaxConnection, c->Session->ClientOption->MaxConnection);
3601	c->Session->MaxConnection = MIN(c->Session->MaxConnection, MAX_TCP_CONNECTION);
3602	c->Session->MaxConnection = MAX(c->Session->MaxConnection, 1);
3603	c->Session->UseCompress = PackGetInt(p, "use_compress") == 0 ? false : true;
3604	c->Session->UseEncrypt = PackGetInt(p, "use_encrypt") == 0 ? false : true;
3605	c->Session->NoSendSignature = PackGetBool(p, "no_send_signature");
3606	if (c->Session->UseEncrypt)
3607	{
3608	c->Session->UseFastRC4 = PackGetInt(p, "use_fast_rc4") == 0 ? false : true;
3609	}
3610	c->Session->HalfConnection = PackGetInt(p, "half_connection") == 0 ? false : true;
3611	c->Session->Timeout = PackGetInt(p, "timeout");
3612	c->Session->QoS = PackGetInt(p, "qos") == 0 ? false : true;
3613	if (c->Session->QoS)
3614	{
3615	c->Session->MaxConnection = MAX(c->Session->MaxConnection, (UINT)(c->Session->HalfConnection ? 4 : 2));
3616	}
3617	c->Session->VLanId = PackGetInt(p, "vlan_id");
3618
3619	if (c->Protocol == CONNECTION_UDP)
3620	{
3621	// UDP プロトコルの場合、サーバーから鍵を受け取る
3622	if (PackGetDataSize(p, "udp_send_key") == sizeof(c->Session->UdpSendKey))
3623	{
3624	PackGetData(p, "udp_send_key", c->Session->UdpSendKey);
3625	}
3626
3627	if (PackGetDataSize(p, "udp_recv_key") == sizeof(c->Session->UdpRecvKey))
3628	{
3629	PackGetData(p, "udp_recv_key", c->Session->UdpRecvKey);
3630	}
3631	}
3632
3633	if (c->Session->UseFastRC4)
3634	{
3635	// RC4 鍵情報の取得
3636	if (PackGetDataSize(p, "rc4_key_client_to_server") == 16)
3637	{
3638	PackGetData(p, "rc4_key_client_to_server", key_pair.ClientToServerKey);
3639	}
3640	if (PackGetDataSize(p, "rc4_key_server_to_client") == 16)
3641	{
3642	PackGetData(p, "rc4_key_server_to_client", key_pair.ServerToClientKey);
3643	}
3644	{
3645	char key1[64], key2[64];
3646	BinToStr(key1, sizeof(key1), key_pair.ClientToServerKey, 16);
3647	BinToStr(key2, sizeof(key2), key_pair.ServerToClientKey, 16);
3648	Debug(
3649	"Client to Server Key: %s\n"
3650	"Server to Client Key: %s\n",
3651	key1, key2);
3652	}
3653	}
3654	}
3655	Unlock(c->Session->lock);
3656
3657	Lock(c->lock);
3658	{
3659	if (c->Name != NULL)
3660	{
3661	Free(c->Name);
3662	}
3663	c->Name = CopyStr(connection_name);
3664
3665	// 暗号化アルゴリズム名の保存
3666	if (c->CipherName != NULL)
3667	{
3668	Free(c->CipherName);
3669	}
3670
3671	c->CipherName = CopyStr(c->FirstSock->CipherName);
3672	}
3673	Unlock(c->lock);
3674
3675	Lock(c->Session->lock);
3676	{
3677	if (c->Session->Name != NULL)
3678	{
3679	Free(c->Session->Name);
3680	}
3681	c->Session->Name = CopyStr(session_name);
3682
3683	c->Session->Policy = policy;
3684	}
3685	Unlock(c->Session->lock);
3686
3687	// Welcome パケットを破棄
3688	FreePack(p);
3689	p = NULL;
3690
3691	// server_ip に対して TCP でシグネチャを送信
3692	if (c->Session->NoSendSignature == false)
3693	{
3694	SendSignatureByTcp(c, &server_ip);
3695	}
3696
3697	// コネクション確立
3698	c->Session->ClientStatus = CLIENT_STATUS_ESTABLISHED;
3699
3700	// サーバー証明書の保存
3701	if (c->ServerX == NULL)
3702	{
3703	c->ServerX = CloneX(c->FirstSock->RemoteX);
3704	}
3705
3706	PrintStatus(sess, _UU("STATUS_9"));
3707
3708	// コネクションをトンネリングモードに移行
3709	StartTunnelingMode(c);
3710	s = NULL;
3711
3712	if (c->Session->HalfConnection)
3713	{
3714	// ハーフコネクション時の処理
3715	TCPSOCK ts = (TCPSOCK )LIST_DATA(c->Tcp->TcpSockList, 0);
3716	ts->Direction = TCP_CLIENT_TO_SERVER;
3717	}
3718
3719	if (c->Session->UseFastRC4)
3720	{
3721	// RC4 高速暗号化鍵のセット
3722	TCPSOCK ts = (TCPSOCK )LIST_DATA(c->Tcp->TcpSockList, 0);
3723	Copy(&ts->Rc4KeyPair, &key_pair, sizeof(key_pair));
3724
3725	InitTcpSockRc4Key(ts, false);
3726	}
3727
3728	// SSL 暗号化フラグ
3729	if (c->Session->UseEncrypt && c->Session->UseFastRC4 == false)
3730	{
3731	c->Session->UseSSLDataEncryption = true;
3732	}
3733	else
3734	{
3735	c->Session->UseSSLDataEncryption = false;
3736	}
3737
3738	PrintStatus(sess, L"free");
3739
3740	CLog(c->Cedar->Client, "LC_CONNECT_2", c->Session->ClientOption->AccountName,
3741	session_name);
3742
3743	if (c->Session->LinkModeClient && c->Session->Link != NULL)
3744	{
3745	HLog(c->Session->Link->Hub, "LH_CONNECT_2", c->Session->ClientOption->AccountName, session_name);
3746	}
3747
3748	// セッションのメインルーチン
3749	SessionMain(c->Session);
3750
3751	ok = true;
3752
3753	if (c->Err == ERR_USER_CANCEL)
3754	{
3755	ret = true;
3756	}
3757
3758	CLEANUP:
3759	c->FirstSock = NULL;
3760
3761	if (p != NULL)
3762	{
3763	FreePack(p);
3764	}
3765
3766	Disconnect(s);
3767	ReleaseSock(s);
3768
3769	Debug("Error: %u\n", c->Err);
3770
3771	if (ok == false)
3772	{
3773	PrintStatus(sess, L"free");
3774	}
3775
3776	return ret;
3777	}
3778
3779	// Welcome パケットのパース
3780	bool ParseWelcomeFromPack(PACK p, char session_name, UINT session_name_size,
3781	char *connection_name, UINT connection_name_size,
3782	POLICY **policy)
3783	{
3784	// 引数チェック
3785	if (p == NULL \|\| session_name == NULL \|\| connection_name == NULL \|\| policy == NULL)
3786	{
3787	return false;
3788	}
3789
3790	// セッション名
3791	if (PackGetStr(p, "session_name", session_name, session_name_size) == false)
3792	{
3793	return false;
3794	}
3795
3796	// コネクション名
3797	if (PackGetStr(p, "connection_name", connection_name, connection_name_size) == false)
3798	{
3799	return false;
3800	}
3801
3802	// ポリシー
3803	*policy = PackGetPolicy(p);
3804	if (*policy == NULL)
3805	{
3806	return false;
3807	}
3808
3809	return true;
3810	}
3811
3812	// Welcome パケットの生成
3813	PACK PackWelcome(SESSION s)
3814	{
3815	PACK *p;
3816	// 引数チェック
3817	if (s == NULL)
3818	{
3819	return NULL;
3820	}
3821
3822	p = NewPack();
3823
3824	// セッション名
3825	PackAddStr(p, "session_name", s->Name);
3826
3827	// コネクション名
3828	PackAddStr(p, "connection_name", s->Connection->Name);
3829
3830	// パラメータ
3831	PackAddInt(p, "max_connection", s->MaxConnection);
3832	PackAddInt(p, "use_encrypt", s->UseEncrypt == false ? 0 : 1);
3833	PackAddInt(p, "use_fast_rc4", s->UseFastRC4 == false ? 0 : 1);
3834	PackAddInt(p, "use_compress", s->UseCompress == false ? 0 : 1);
3835	PackAddInt(p, "half_connection", s->HalfConnection == false ? 0 : 1);
3836	PackAddInt(p, "timeout", s->Timeout);
3837	PackAddInt(p, "qos", s->QoS ? 1 : 0);
3838
3839	// セッションキー
3840	PackAddData(p, "session_key", s->SessionKey, SHA1_SIZE);
3841	PackAddInt(p, "session_key_32", s->SessionKey32);
3842
3843	// ポリシー
3844	PackAddPolicy(p, s->Policy);
3845
3846	// VLAN ID
3847	PackAddInt(p, "vlan_id", s->VLanId);
3848
3849	if (s->Connection->Protocol == CONNECTION_UDP)
3850	{
3851	// UDP プロトコルの場合、2 組のキーを生成する
3852	Rand(s->UdpSendKey, sizeof(s->UdpSendKey));
3853	Rand(s->UdpRecvKey, sizeof(s->UdpRecvKey));
3854
3855	// クライアントには鍵を反転して送る
3856	PackAddData(p, "udp_send_key", s->UdpRecvKey, sizeof(s->UdpRecvKey));
3857	PackAddData(p, "udp_recv_key", s->UdpSendKey, sizeof(s->UdpSendKey));
3858	}
3859
3860	// no_send_signature
3861	if (s->NoSendSignature)
3862	{
3863	PackAddBool(p, "no_send_signature", true);
3864	}
3865
3866	return p;
3867	}
3868
3869	#define PACK_ADD_POLICY_BOOL(name, value) \
3870	PackAddInt(p, "policy:" name, y->value == false ? 0 : 1)
3871	#define PACK_ADD_POLICY_UINT(name, value) \
3872	PackAddInt(p, "policy:" name, y->value)
3873	#define PACK_GET_POLICY_BOOL(name, value) \
3874	y->value = (PackGetInt(p, "policy:" name) == 0 ? false : true)
3875	#define PACK_GET_POLICY_UINT(name, value) \
3876	y->value = PackGetInt(p, "policy:" name)
3877
3878	// セッションキーを PACK から取得
3879	bool GetSessionKeyFromPack(PACK p, UCHAR session_key, UINT *session_key_32)
3880	{
3881	// 引数チェック
3882	if (p == NULL \|\| session_key == NULL \|\| session_key_32 == NULL)
3883	{
3884	return false;
3885	}
3886
3887	if (PackGetDataSize(p, "session_key") != SHA1_SIZE)
3888	{
3889	return false;
3890	}
3891	if (PackGetData(p, "session_key", session_key) == false)
3892	{
3893	return false;
3894	}
3895	*session_key_32 = PackGetInt(p, "session_key_32");
3896
3897	return true;
3898	}
3899
3900	// ポリシーを PACK から取得
3901	POLICY PackGetPolicy(PACK p)
3902	{
3903	// このあたりは急いで実装したのでコードがあまり美しくない。
3904	POLICY *y;
3905	// 引数チェック
3906	if (p == NULL)
3907	{
3908	return NULL;
3909	}
3910
3911	y = ZeroMalloc(sizeof(POLICY));
3912
3913	// bool 値
3914	// Ver 2
3915	PACK_GET_POLICY_BOOL("Access", Access);
3916	PACK_GET_POLICY_BOOL("DHCPFilter", DHCPFilter);
3917	PACK_GET_POLICY_BOOL("DHCPNoServer", DHCPNoServer);
3918	PACK_GET_POLICY_BOOL("DHCPForce", DHCPForce);
3919	PACK_GET_POLICY_BOOL("NoBridge", NoBridge);
3920	PACK_GET_POLICY_BOOL("NoRouting", NoRouting);
3921	PACK_GET_POLICY_BOOL("PrivacyFilter", PrivacyFilter);
3922	PACK_GET_POLICY_BOOL("NoServer", NoServer);
3923	PACK_GET_POLICY_BOOL("CheckMac", CheckMac);
3924	PACK_GET_POLICY_BOOL("CheckIP", CheckIP);
3925	PACK_GET_POLICY_BOOL("ArpDhcpOnly", ArpDhcpOnly);
3926	PACK_GET_POLICY_BOOL("MonitorPort", MonitorPort);
3927	PACK_GET_POLICY_BOOL("NoBroadcastLimiter", NoBroadcastLimiter);
3928	PACK_GET_POLICY_BOOL("FixPassword", FixPassword);
3929	PACK_GET_POLICY_BOOL("NoQoS", NoQoS);
3930	// Ver 3
3931	PACK_GET_POLICY_BOOL("RSandRAFilter", RSandRAFilter);
3932	PACK_GET_POLICY_BOOL("RAFilter", RAFilter);
3933	PACK_GET_POLICY_BOOL("DHCPv6Filter", DHCPv6Filter);
3934	PACK_GET_POLICY_BOOL("DHCPv6NoServer", DHCPv6NoServer);
3935	PACK_GET_POLICY_BOOL("NoRoutingV6", NoRoutingV6);
3936	PACK_GET_POLICY_BOOL("CheckIPv6", CheckIPv6);
3937	PACK_GET_POLICY_BOOL("NoServerV6", NoServerV6);
3938	PACK_GET_POLICY_BOOL("NoSavePassword", NoSavePassword);
3939	PACK_GET_POLICY_BOOL("FilterIPv4", FilterIPv4);
3940	PACK_GET_POLICY_BOOL("FilterIPv6", FilterIPv6);
3941	PACK_GET_POLICY_BOOL("FilterNonIP", FilterNonIP);
3942	PACK_GET_POLICY_BOOL("NoIPv6DefaultRouterInRA", NoIPv6DefaultRouterInRA);
3943	PACK_GET_POLICY_BOOL("NoIPv6DefaultRouterInRAWhenIPv6", NoIPv6DefaultRouterInRAWhenIPv6);
3944
3945	// UINT 値
3946	// Ver 2
3947	PACK_GET_POLICY_UINT("MaxConnection", MaxConnection);
3948	PACK_GET_POLICY_UINT("TimeOut", TimeOut);
3949	PACK_GET_POLICY_UINT("MaxMac", MaxMac);
3950	PACK_GET_POLICY_UINT("MaxIP", MaxIP);
3951	PACK_GET_POLICY_UINT("MaxUpload", MaxUpload);
3952	PACK_GET_POLICY_UINT("MaxDownload", MaxDownload);
3953	PACK_GET_POLICY_UINT("MultiLogins", MultiLogins);
3954	// Ver 3
3955	PACK_GET_POLICY_UINT("MaxIPv6", MaxIPv6);
3956	PACK_GET_POLICY_UINT("AutoDisconnect", AutoDisconnect);
3957	PACK_GET_POLICY_UINT("VLanId", VLanId);
3958
3959	// Ver 3 フラグ
3960	PACK_GET_POLICY_BOOL("Ver3", Ver3);
3961
3962	return y;
3963	}
3964
3965	// ポリシーを PACK に挿入
3966	void PackAddPolicy(PACK p, POLICY y)
3967	{
3968	// このあたりは急いで実装したのでコードがあまり美しくない。
3969	// 引数チェック
3970	if (p == NULL \|\| y == NULL)
3971	{
3972	return;
3973	}
3974
3975	// bool 値
3976	// Ver 2
3977	PACK_ADD_POLICY_BOOL("Access", Access);
3978	PACK_ADD_POLICY_BOOL("DHCPFilter", DHCPFilter);
3979	PACK_ADD_POLICY_BOOL("DHCPNoServer", DHCPNoServer);
3980	PACK_ADD_POLICY_BOOL("DHCPForce", DHCPForce);
3981	PACK_ADD_POLICY_BOOL("NoBridge", NoBridge);
3982	PACK_ADD_POLICY_BOOL("NoRouting", NoRouting);
3983	PACK_ADD_POLICY_BOOL("PrivacyFilter", PrivacyFilter);
3984	PACK_ADD_POLICY_BOOL("NoServer", NoServer);
3985	PACK_ADD_POLICY_BOOL("CheckMac", CheckMac);
3986	PACK_ADD_POLICY_BOOL("CheckIP", CheckIP);
3987	PACK_ADD_POLICY_BOOL("ArpDhcpOnly", ArpDhcpOnly);
3988	PACK_ADD_POLICY_BOOL("MonitorPort", MonitorPort);
3989	PACK_ADD_POLICY_BOOL("NoBroadcastLimiter", NoBroadcastLimiter);
3990	PACK_ADD_POLICY_BOOL("FixPassword", FixPassword);
3991	PACK_ADD_POLICY_BOOL("NoQoS", NoQoS);
3992	// Ver 3
3993	PACK_ADD_POLICY_BOOL("RSandRAFilter", RSandRAFilter);
3994	PACK_ADD_POLICY_BOOL("RAFilter", RAFilter);
3995	PACK_ADD_POLICY_BOOL("DHCPv6Filter", DHCPv6Filter);
3996	PACK_ADD_POLICY_BOOL("DHCPv6NoServer", DHCPv6NoServer);
3997	PACK_ADD_POLICY_BOOL("NoRoutingV6", NoRoutingV6);
3998	PACK_ADD_POLICY_BOOL("CheckIPv6", CheckIPv6);
3999	PACK_ADD_POLICY_BOOL("NoServerV6", NoServerV6);
4000	PACK_ADD_POLICY_BOOL("NoSavePassword", NoSavePassword);
4001	PACK_ADD_POLICY_BOOL("FilterIPv4", FilterIPv4);
4002	PACK_ADD_POLICY_BOOL("FilterIPv6", FilterIPv6);
4003	PACK_ADD_POLICY_BOOL("FilterNonIP", FilterNonIP);
4004	PACK_ADD_POLICY_BOOL("NoIPv6DefaultRouterInRA", NoIPv6DefaultRouterInRA);
4005	PACK_ADD_POLICY_BOOL("NoIPv6DefaultRouterInRAWhenIPv6", NoIPv6DefaultRouterInRAWhenIPv6);
4006
4007	// UINT 値
4008	// Ver 2
4009	PACK_ADD_POLICY_UINT("MaxConnection", MaxConnection);
4010	PACK_ADD_POLICY_UINT("TimeOut", TimeOut);
4011	PACK_ADD_POLICY_UINT("MaxMac", MaxMac);
4012	PACK_ADD_POLICY_UINT("MaxIP", MaxIP);
4013	PACK_ADD_POLICY_UINT("MaxUpload", MaxUpload);
4014	PACK_ADD_POLICY_UINT("MaxDownload", MaxDownload);
4015	PACK_ADD_POLICY_UINT("MultiLogins", MultiLogins);
4016	// Ver 3
4017	PACK_ADD_POLICY_UINT("MaxIPv6", MaxIPv6);
4018	PACK_ADD_POLICY_UINT("AutoDisconnect", AutoDisconnect);
4019	PACK_ADD_POLICY_UINT("VLanId", VLanId);
4020
4021	// Ver 3 フラグ
4022	PackAddBool(p, "policy:Ver3", true);
4023	}
4024
4025	// 追加接続用の認証データをアップロードする
4026	bool ClientUploadAuth2(CONNECTION c, SOCK s)
4027	{
4028	PACK *p = NULL;
4029	// 引数チェック
4030	if (c == NULL)
4031	{
4032	return false;
4033	}
4034
4035	p = PackAdditionalConnect(c->Session->SessionKey);
4036
4037	PackAddClientVersion(p, c);
4038
4039	if (HttpClientSend(s, p) == false)
4040	{
4041	FreePack(p);
4042	return false;
4043	}
4044	FreePack(p);
4045
4046	return true;
4047	}
4048
4049	// NOOP を送信する
4050	void ClientUploadNoop(CONNECTION *c)
4051	{
4052	PACK *p;
4053	// 引数チェック
4054	if (c == NULL)
4055	{
4056	return;
4057	}
4058
4059	p = PackError(0);
4060	PackAddInt(p, "noop", 1);
4061	HttpClientSend(c->FirstSock, p);
4062	FreePack(p);
4063
4064	p = HttpClientRecv(c->FirstSock);
4065	if (p != NULL)
4066	{
4067	FreePack(p);
4068	}
4069	}
4070
4071	// クライアントのバージョン情報を PACK に追加する
4072	void PackAddClientVersion(PACK p, CONNECTION c)
4073	{
4074	// 引数チェック
4075	if (p == NULL \|\| c == NULL)
4076	{
4077	return;
4078	}
4079
4080	PackAddStr(p, "client_str", c->ClientStr);
4081	PackAddInt(p, "client_ver", c->ClientVer);
4082	PackAddInt(p, "client_build", c->ClientBuild);
4083	}
4084
4085	// 新規接続用の認証データをアップロードする
4086	bool ClientUploadAuth(CONNECTION *c)
4087	{
4088	PACK *p = NULL;
4089	CLIENT_AUTH *a;
4090	CLIENT_OPTION *o;
4091	X *x;
4092	bool ret;
4093	NODE_INFO info;
4094	UCHAR secure_password[SHA1_SIZE];
4095	UCHAR sign[4096 / 8];
4096	UCHAR unique[SHA1_SIZE];
4097	RPC_WINVER v;
4098	// 引数チェック
4099	if (c == NULL)
4100	{
4101	return false;
4102	}
4103
4104	Zero(sign, sizeof(sign));
4105
4106	a = c->Session->ClientAuth;
4107	o = c->Session->ClientOption;
4108
4109	if (c->UseTicket == false)
4110	{
4111	switch (a->AuthType)
4112	{
4113	case CLIENT_AUTHTYPE_ANONYMOUS:
4114	// 匿名認証
4115	p = PackLoginWithAnonymous(o->HubName, a->Username);
4116	break;
4117
4118	case CLIENT_AUTHTYPE_PASSWORD:
4119	// パスワード認証
4120	SecurePassword(secure_password, a->HashedPassword, c->Random);
4121	p = PackLoginWithPassword(o->HubName, a->Username, secure_password);
4122	break;
4123
4124	case CLIENT_AUTHTYPE_PLAIN_PASSWORD:
4125	// 平文パスワード認証
4126	p = PackLoginWithPlainPassword(o->HubName, a->Username, a->PlainPassword);
4127	break;
4128
4129	case CLIENT_AUTHTYPE_CERT:
4130	// 証明書認証
4131	if (a->ClientX != NULL && a->ClientX->is_compatible_bit &&
4132	a->ClientX->bits != 0 && (a->ClientX->bits / 8) <= sizeof(sign))
4133	{
4134	if (RsaSignEx(sign, c->Random, SHA1_SIZE, a->ClientK, a->ClientX->bits))
4135	{
4136	p = PackLoginWithCert(o->HubName, a->Username, a->ClientX, sign, a->ClientX->bits / 8);
4137	c->ClientX = CloneX(a->ClientX);
4138	}
4139	}
4140	break;
4141
4142	case CLIENT_AUTHTYPE_SECURE:
4143	// セキュアデバイスによる認証
4144	if (ClientSecureSign(c, sign, c->Random, &x))
4145	{
4146	p = PackLoginWithCert(o->HubName, a->Username, x, sign, 128);
4147	c->ClientX = CloneX(x);
4148	FreeX(x);
4149	}
4150	else
4151	{
4152	c->Err = ERR_SECURE_DEVICE_OPEN_FAILED;
4153	c->Session->ForceStopFlag = true;
4154	}
4155	break;
4156	}
4157	}
4158	else
4159	{
4160	// チケット
4161	p = NewPack();
4162	PackAddStr(p, "method", "login");
4163	PackAddStr(p, "hubname", o->HubName);
4164	PackAddStr(p, "username", a->Username);
4165	PackAddInt(p, "authtype", AUTHTYPE_TICKET);
4166	PackAddData(p, "ticket", c->Ticket, SHA1_SIZE);
4167	}
4168
4169	// 現在時刻
4170	PackAddInt64(p, "timestamp", SystemTime64());
4171
4172	if (p == NULL)
4173	{
4174	// エラー
4175	if (c->Err != ERR_SECURE_DEVICE_OPEN_FAILED)
4176	{
4177	c->Err = ERR_PROTOCOL_ERROR;
4178	}
4179	return false;
4180	}
4181
4182	PackAddClientVersion(p, c);
4183
4184	// プロトコル
4185	PackAddInt(p, "protocol", c->Protocol);
4186
4187	// バージョン等
4188	PackAddStr(p, "hello", c->ClientStr);
4189	PackAddInt(p, "version", c->ClientVer);
4190	PackAddInt(p, "build", c->ClientBuild);
4191	PackAddInt(p, "client_id", c->Cedar->ClientId);
4192
4193	// 最大コネクション数
4194	PackAddInt(p, "max_connection", o->MaxConnection);
4195	// 暗号化使用フラグ
4196	PackAddInt(p, "use_encrypt", o->UseEncrypt == false ? 0 : 1);
4197	// 高速暗号化使用フラグ
4198	// PackAddInt(p, "use_fast_rc4", o->UseFastRC4 == false ? 0 : 1);
4199	// データ圧縮使用フラグ
4200	PackAddInt(p, "use_compress", o->UseCompress == false ? 0 : 1);
4201	// ハーフコネクションフラグ
4202	PackAddInt(p, "half_connection", o->HalfConnection == false ? 0 : 1);
4203
4204	// ブリッジ / ルーティングモードフラグ
4205	PackAddBool(p, "require_bridge_routing_mode", o->RequireBridgeRoutingMode);
4206
4207	// モニタモードフラグ
4208	PackAddBool(p, "require_monitor_mode", o->RequireMonitorMode);
4209
4210	// VoIP / QoS フラグ
4211	PackAddBool(p, "qos", o->DisableQoS ? false : true);
4212
4213	// ユニーク ID
4214	GenerateMachineUniqueHash(unique);
4215	PackAddData(p, "unique_id", unique, SHA1_SIZE);
4216
4217	// ノード情報
4218	CreateNodeInfo(&info, c);
4219	OutRpcNodeInfo(p, &info);
4220
4221	// OS 情報
4222	GetWinVer(&v);
4223	OutRpcWinVer(p, &v);
4224
4225	ret = HttpClientSend(c->FirstSock, p);
4226	if (ret == false)
4227	{
4228	c->Err = ERR_DISCONNECTED;
4229	}
4230
4231	FreePack(p);
4232
4233	return ret;
4234	}
4235
4236	// Hello パケットをアップロードする
4237	bool ServerUploadHello(CONNECTION *c)
4238	{
4239	PACK *p;
4240	// 引数チェック
4241	if (c == NULL)
4242	{
4243	return false;
4244	}
4245
4246	// 乱数生成
4247	Rand(c->Random, SHA1_SIZE);
4248
4249	p = PackHello(c->Random, c->ServerVer, c->ServerBuild, c->ServerStr);
4250	if (HttpServerSend(c->FirstSock, p) == false)
4251	{
4252	FreePack(p);
4253	c->Err = ERR_DISCONNECTED;
4254	return false;
4255	}
4256
4257	FreePack(p);
4258
4259	return true;
4260	}
4261
4262	// Hello パケットをダウンロードする
4263	bool ClientDownloadHello(CONNECTION c, SOCK s)
4264	{
4265	PACK *p;
4266	UINT err;
4267	UCHAR random[SHA1_SIZE];
4268	// 引数チェック
4269	if (c == NULL)
4270	{
4271	return false;
4272	}
4273
4274	// データ受信
4275	p = HttpClientRecv(s);
4276	if (p == NULL)
4277	{
4278	c->Err = ERR_SERVER_IS_NOT_VPN;
4279	return false;
4280	}
4281
4282	if (err = GetErrorFromPack(p))
4283	{
4284	// エラー発生
4285	c->Err = err;
4286	FreePack(p);
4287	return false;
4288	}
4289
4290	// パケット解釈
4291	if (GetHello(p, random, &c->ServerVer, &c->ServerBuild, c->ServerStr, sizeof(c->ServerStr)) == false)
4292	{
4293	c->Err = ERR_SERVER_IS_NOT_VPN;
4294	FreePack(p);
4295	return false;
4296	}
4297
4298	if (c->FirstSock == s)
4299	{
4300	Copy(c->Random, random, SHA1_SIZE);
4301	}
4302
4303	FreePack(p);
4304
4305	return true;
4306	}
4307
4308	// シグネチャをダウンロードする
4309	bool ServerDownloadSignature(CONNECTION *c)
4310	{
4311	HTTP_HEADER *h;
4312	UCHAR *data;
4313	UINT data_size;
4314	SOCK *s;
4315	UINT num = 0, max = 19;
4316	// 引数チェック
4317	if (c == NULL)
4318	{
4319	return false;
4320	}
4321
4322	s = c->FirstSock;
4323
4324	while (true)
4325	{
4326	num++;
4327	if (num > max)
4328	{
4329	// 切断
4330	Disconnect(s);
4331	c->Err = ERR_CLIENT_IS_NOT_VPN;
4332	return false;
4333	}
4334	// ヘッダを受信する
4335	h = RecvHttpHeader(s);
4336	if (h == NULL)
4337	{
4338	c->Err = ERR_CLIENT_IS_NOT_VPN;
4339	return false;
4340	}
4341
4342	// 解釈する
4343	if (StrCmpi(h->Method, "POST") == 0)
4344	{
4345	// POST なのでデータを受信する
4346	data_size = GetContentLength(h);
4347	if ((data_size > 3411 \|\| data_size < 1411) && (data_size != StrLen(HTTP_VPN_TARGET_POSTDATA)))
4348	{
4349	// データが大きすぎる
4350	HttpSendForbidden(s, h->Target, NULL);
4351	FreeHttpHeader(h);
4352	c->Err = ERR_CLIENT_IS_NOT_VPN;
4353	return false;
4354	}
4355	data = Malloc(data_size);
4356	if (RecvAll(s, data, data_size, s->SecureMode) == false)
4357	{
4358	// データ受信失敗
4359	Free(data);
4360	FreeHttpHeader(h);
4361	c->Err = ERR_DISCONNECTED;
4362	return false;
4363	}
4364	// Target を確認する
4365	if (StrCmpi(h->Target, HTTP_VPN_TARGET2) != 0)
4366	{
4367	// ターゲットが不正
4368	HttpSendNotFound(s, h->Target);
4369	Free(data);
4370	FreeHttpHeader(h);
4371	}
4372	else
4373	{
4374	if (((data_size == StrLen(HTTP_VPN_TARGET_POSTDATA)) && (Cmp(data, HTTP_VPN_TARGET_POSTDATA, data_size) == 0)) \|\| (data_size >= 1411))
4375	{
4376	// VPN Client が接続してきた
4377	Free(data);
4378	FreeHttpHeader(h);
4379	return true;
4380	}
4381	else
4382	{
4383	// VPN Client 以外のソフトウェアが接続してきた
4384	HttpSendForbidden(s, h->Target, NULL);
4385	FreeHttpHeader(h);
4386	}
4387	}
4388	}
4389	else
4390	{
4391	// これ以上解釈しても VPN クライアントで無い可能性が高いが
4392	// 一応する
4393	if (StrCmpi(h->Method, "GET") != 0)
4394	{
4395	// サポートされていないメソッド呼び出し
4396	HttpSendNotImplemented(s, h->Method, h->Target, h->Version);
4397	}
4398	else
4399	{
4400	if (StrCmpi(h->Target, "/") == 0)
4401	{
4402	// ルートディレクトリ
4403	HttpSendForbidden(c->FirstSock, h->Target, "");
4404	}
4405	else
4406	{
4407	// Not Found
4408	HttpSendNotFound(s, h->Target);
4409	}
4410	}
4411	FreeHttpHeader(h);
4412	}
4413	}
4414	}
4415
4416	// シグネチャをアップロードする
4417	bool ClientUploadSignature(SOCK *s)
4418	{
4419	HTTP_HEADER *h;
4420	// 引数チェック
4421	if (s == NULL)
4422	{
4423	return false;
4424	}
4425
4426	h = NewHttpHeader("POST", HTTP_VPN_TARGET2, "HTTP/1.1");
4427	AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE3));
4428	AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
4429
4430	if (PostHttp(s, h, HTTP_VPN_TARGET_POSTDATA, StrLen(HTTP_VPN_TARGET_POSTDATA)) == false)
4431	{
4432	FreeHttpHeader(h);
4433	return false;
4434	}
4435
4436	FreeHttpHeader(h);
4437
4438	return true;
4439	}
4440
4441	// サーバーへの接続を確立する
4442	SOCK ClientConnectToServer(CONNECTION c)
4443	{
4444	SOCK *s = NULL;
4445	X *x = NULL;
4446	K *k = NULL;
4447	// 引数チェック
4448	if (c == NULL)
4449	{
4450	return NULL;
4451	}
4452
4453	if (c->Halt)
4454	{
4455	c->Err = ERR_USER_CANCEL;
4456	return NULL;
4457	}
4458
4459	// 接続してソケットを取得
4460	s = ClientConnectGetSocket(c, false);
4461	if (s == NULL)
4462	{
4463	// 接続失敗
4464	return NULL;
4465	}
4466
4467	c->FirstSock = s;
4468
4469	if (c->Halt)
4470	{
4471	c->Err = ERR_USER_CANCEL;
4472	ReleaseSock(s);
4473	c->FirstSock = NULL;
4474	return NULL;
4475	}
4476
4477	// タイムアウト
4478	SetTimeout(s, CONNECTING_TIMEOUT);
4479
4480	// SSL 通信の開始
4481	if (StartSSLEx(s, x, k, (c->DontUseTls1 ? false : true)) == false)
4482	{
4483	// SSL 通信開始失敗
4484	Disconnect(s);
4485	ReleaseSock(s);
4486	c->FirstSock = NULL;
4487	c->Err = ERR_SERVER_IS_NOT_VPN;
4488	return NULL;
4489	}
4490
4491	if (s->RemoteX == NULL)
4492	{
4493	// SSL 通信開始失敗
4494	Disconnect(s);
4495	ReleaseSock(s);
4496	c->FirstSock = NULL;
4497	c->Err = ERR_SERVER_IS_NOT_VPN;
4498	return NULL;
4499	}
4500
4501	return s;
4502	}
4503
4504	// サーバーに接続しソケットを返す
4505	SOCK ClientConnectGetSocket(CONNECTION c, bool additional_connect)
4506	{
4507	SOCK *s = NULL;
4508	CLIENT_OPTION *o;
4509	char *host_for_direct_connection;
4510	UINT port_for_direct_connection;
4511	wchar_t tmp[MAX_SIZE];
4512	SESSION *sess;
4513	volatile bool *cancel_flag = NULL;
4514	void *hWnd;
4515	// 引数チェック
4516	if (c == NULL)
4517	{
4518	return NULL;
4519	}
4520
4521	sess = c->Session;
4522
4523	if (sess != NULL)
4524	{
4525	cancel_flag = &sess->CancelConnect;
4526	}
4527
4528	hWnd = c->hWndForUI;
4529
4530	o = c->Session->ClientOption;
4531
4532	if (c->RestoreServerNameAndPort && additional_connect)
4533	{
4534	// サーバー名とポート番号を元に戻す
4535	c->RestoreServerNameAndPort = false;
4536
4537	StrCpy(c->ServerName, sizeof(c->ServerName), o->Hostname);
4538	c->ServerPort = o->Port;
4539	}
4540
4541	host_for_direct_connection = c->ServerName;
4542	port_for_direct_connection = c->ServerPort;
4543
4544	if (o->PortUDP != 0)
4545	{
4546	// UDP Connection
4547	goto UDP_CONNECTION;
4548	}
4549
4550	switch (o->ProxyType)
4551	{
4552	case PROXY_DIRECT: // TCP/IP
4553	UDP_CONNECTION:
4554	UniFormat(tmp, sizeof(tmp), _UU("STATUS_4"), c->ServerName);
4555	PrintStatus(sess, tmp);
4556	// 本番
4557	s = TcpIpConnectEx(host_for_direct_connection, port_for_direct_connection,
4558	(bool *)cancel_flag, hWnd);
4559	if (s == NULL)
4560	{
4561	// 接続失敗
4562	c->Err = ERR_CONNECT_FAILED;
4563	return NULL;
4564	}
4565	break;
4566
4567	case PROXY_HTTP: // HTTP Proxy
4568	host_for_direct_connection = o->ProxyName;
4569	port_for_direct_connection = o->ProxyPort;
4570
4571	UniFormat(tmp, sizeof(tmp), _UU("STATUS_2"), c->ServerName, o->ProxyName);
4572	PrintStatus(sess, tmp);
4573	// プロキシ接続
4574	s = ProxyConnectEx(c, host_for_direct_connection, port_for_direct_connection,
4575	c->ServerName, c->ServerPort, o->ProxyUsername, o->ProxyPassword,
4576	additional_connect, (bool *)cancel_flag, hWnd);
4577	if (s == NULL)
4578	{
4579	// 接続失敗
4580	return NULL;
4581	}
4582	break;
4583
4584	case PROXY_SOCKS: // SOCKS Proxy
4585	host_for_direct_connection = o->ProxyName;
4586
4587	port_for_direct_connection = o->ProxyPort;
4588
4589	UniFormat(tmp, sizeof(tmp), _UU("STATUS_2"), c->ServerName, o->ProxyName);
4590	PrintStatus(sess, tmp);
4591	// SOCKS 接続
4592	s = SocksConnectEx(c, host_for_direct_connection, port_for_direct_connection,
4593	c->ServerName, c->ServerPort, o->ProxyUsername,
4594	additional_connect, (bool *)cancel_flag, hWnd);
4595	if (s == NULL)
4596	{
4597	// 接続失敗
4598	return NULL;
4599	}
4600	break;
4601	}
4602
4603	if (s == NULL)
4604	{
4605	// 接続失敗
4606	c->Err = ERR_CONNECT_FAILED;
4607	}
4608	else
4609	{
4610	// 接続成功
4611	// IP アドレスを控えておく
4612	if (GetIP(&c->Session->ServerIP, host_for_direct_connection) == false)
4613	{
4614	Copy(&c->Session->ServerIP, &s->RemoteIP, sizeof(IP));
4615	}
4616	}
4617
4618	return s;
4619	}
4620
4621	// SOCKS 経由で接続する
4622	SOCK SocksConnect(CONNECTION c, char *proxy_host_name, UINT proxy_port,
4623	char *server_host_name, UINT server_port,
4624	char *username, bool additional_connect)
4625	{
4626	return SocksConnectEx(c, proxy_host_name, proxy_port,
4627	server_host_name, server_port, username, additional_connect, NULL, NULL);
4628	}
4629	SOCK SocksConnectEx(CONNECTION c, char *proxy_host_name, UINT proxy_port,
4630	char *server_host_name, UINT server_port,
4631	char *username, bool additional_connect,
4632	bool cancel_flag, void hWnd)
4633	{
4634	SOCK *s = NULL;
4635	IP ip;
4636	// 引数チェック
4637	if (c == NULL \|\| proxy_host_name == NULL \|\| proxy_port == 0 \|\| server_host_name == NULL
4638	\|\| server_port == 0)
4639	{
4640	c->Err = ERR_PROXY_CONNECT_FAILED;
4641	return NULL;
4642	}
4643
4644	// 接続先サーバーの IP アドレスを取得す
4645	if (GetIP(&ip, server_host_name) == false)
4646	{
4647	// 失敗
4648	c->Err = ERR_CONNECT_FAILED;
4649	return NULL;
4650	}
4651
4652	if (c->Halt)
4653	{
4654	// 停止
4655	c->Err = ERR_USER_CANCEL;
4656	return NULL;
4657	}
4658
4659	// 接続
4660	s = TcpConnectEx2(proxy_host_name, proxy_port, 0, cancel_flag, hWnd);
4661	if (s == NULL)
4662	{
4663	// 失敗
4664	c->Err = ERR_PROXY_CONNECT_FAILED;
4665	return NULL;
4666	}
4667
4668	// タイムアウト設定
4669	SetTimeout(s, CONNECTING_TIMEOUT_PROXY);
4670
4671	if (additional_connect == false)
4672	{
4673	c->FirstSock = s;
4674	}
4675
4676	// リクエストパケット送信
4677	if (SocksSendRequestPacket(c, s, server_port, &ip, username) == false)
4678	{
4679	// 失敗
4680	if (additional_connect == false)
4681	{
4682	c->FirstSock = NULL;
4683	}
4684	Disconnect(s);
4685	ReleaseSock(s);
4686	return NULL;
4687	}
4688
4689	// 応答パケット受信
4690	if (SocksRecvResponsePacket(c, s) == false)
4691	{
4692	// 失敗
4693	if (additional_connect == false)
4694	{
4695	c->FirstSock = NULL;
4696	}
4697	Disconnect(s);
4698	ReleaseSock(s);
4699	return NULL;
4700	}
4701
4702	SetTimeout(s, INFINITE);
4703
4704	return s;
4705	}
4706
4707	// SOCKS 応答パケットを受信する
4708	bool SocksRecvResponsePacket(CONNECTION c, SOCK s)
4709	{
4710	BUF *b;
4711	UINT size = 8;
4712	UCHAR tmp[8];
4713	UCHAR vn, cd;
4714	// 引数チェック
4715	if (c == NULL \|\| s == NULL)
4716	{
4717	return false;
4718	}
4719
4720	if (RecvAll(s, tmp, sizeof(tmp), false) == false)
4721	{
4722	c->Err = ERR_DISCONNECTED;
4723	return false;
4724	}
4725
4726	b = NewBuf();
4727	WriteBuf(b, tmp, sizeof(tmp));
4728	SeekBuf(b, 0, 0);
4729
4730	ReadBuf(b, &vn, 1);
4731	ReadBuf(b, &cd, 1);
4732
4733	FreeBuf(b);
4734
4735	if (vn != 0)
4736	{
4737	c->Err = ERR_PROXY_ERROR;
4738	return false;
4739	}
4740
4741	switch (cd)
4742	{
4743	case 90:
4744	// 成功
4745	return true;
4746
4747	case 93:
4748	// 認証失敗
4749	c->Err = ERR_PROXY_AUTH_FAILED;
4750	return false;
4751
4752	default:
4753	// サーバーへの接続失敗
4754	c->Err = ERR_CONNECT_FAILED;
4755	return false;
4756	}
4757	}
4758
4759	// SOCKS リクエストパケットを送信する
4760	bool SocksSendRequestPacket(CONNECTION c, SOCK s, UINT dest_port, IP dest_ip, char userid)
4761	{
4762	BUF *b;
4763	UCHAR vn, cd;
4764	USHORT port;
4765	UINT ip;
4766	bool ret;
4767	// 引数チェック
4768	if (s == NULL \|\| dest_port == 0 \|\| dest_ip == NULL \|\| c == NULL)
4769	{
4770	return false;
4771	}
4772	if (userid == NULL)
4773	{
4774	userid = "";
4775	}
4776
4777	b = NewBuf();
4778	vn = 4;
4779	cd = 1;
4780	WriteBuf(b, &vn, 1);
4781	WriteBuf(b, &cd, 1);
4782	port = Endian16((USHORT)dest_port);
4783	ip = IPToUINT(dest_ip);
4784	WriteBuf(b, &port, 2);
4785	WriteBuf(b, &ip, 4);
4786	WriteBuf(b, userid, StrLen(userid) + 1);
4787
4788	ret = SendAll(s, b->Buf, b->Size, false);
4789	if (ret == false)
4790	{
4791	c->Err = ERR_DISCONNECTED;
4792	}
4793
4794	FreeBuf(b);
4795
4796	return ret;
4797	}
4798
4799	// プロキシ経由で接続する
4800	SOCK ProxyConnect(CONNECTION c, char *proxy_host_name, UINT proxy_port,
4801	char *server_host_name, UINT server_port,
4802	char username, char password, bool additional_connect)
4803	{
4804	return ProxyConnectEx(c, proxy_host_name, proxy_port,
4805	server_host_name, server_port, username, password, additional_connect, NULL, NULL);
4806	}
4807	SOCK ProxyConnectEx(CONNECTION c, char *proxy_host_name, UINT proxy_port,
4808	char *server_host_name, UINT server_port,
4809	char username, char password, bool additional_connect,
4810	bool cancel_flag, void hWnd)
4811	{
4812	SOCK *s = NULL;
4813	bool use_auth = false;
4814	char tmp[MAX_SIZE];
4815	char auth_tmp_str[MAX_SIZE], auth_b64_str[MAX_SIZE * 2];
4816	char basic_str[MAX_SIZE * 2];
4817	UINT http_error_code;
4818	HTTP_HEADER *h;
4819	// 引数チェック
4820	if (c == NULL \|\| proxy_host_name == NULL \|\| proxy_port == 0 \|\| server_host_name == NULL \|\|
4821	server_port == 0)
4822	{
4823	c->Err = ERR_PROXY_CONNECT_FAILED;
4824	return NULL;
4825	}
4826	if (username != NULL && password != NULL &&
4827	(StrLen(username) != 0 \|\| StrLen(password) != 0))
4828	{
4829	use_auth = true;
4830	}
4831
4832	if (c->Halt)
4833	{
4834	// 停止
4835	c->Err = ERR_USER_CANCEL;
4836	return NULL;
4837	}
4838
4839	// 接続
4840	s = TcpConnectEx2(proxy_host_name, proxy_port, 0, cancel_flag, hWnd);
4841	if (s == NULL)
4842	{
4843	// 失敗
4844	c->Err = ERR_PROXY_CONNECT_FAILED;
4845	return NULL;
4846	}
4847
4848	// タイムアウト設定
4849	SetTimeout(s, CONNECTING_TIMEOUT_PROXY);
4850
4851	if (additional_connect == false)
4852	{
4853	c->FirstSock = s;
4854	}
4855
4856	// HTTP ヘッダ生成
4857	if (IsStrIPv6Address(server_host_name))
4858	{
4859	IP ip;
4860	char iptmp[MAX_PATH];
4861
4862	StrToIP(&ip, server_host_name);
4863	IPToStr(iptmp, sizeof(iptmp), &ip);
4864
4865	Format(tmp, sizeof(tmp), "[%s]:%u", iptmp, server_port);
4866	}
4867	else
4868	{
4869	Format(tmp, sizeof(tmp), "%s:%u", server_host_name, server_port);
4870	}
4871
4872	h = NewHttpHeader("CONNECT", tmp, "HTTP/1.0");
4873	AddHttpValue(h, NewHttpValue("User-Agent", c->Cedar->HttpUserAgent));
4874	Debug("proxy user agent = %s\n", c->Cedar->HttpUserAgent);
4875	AddHttpValue(h, NewHttpValue("Host", server_host_name));
4876	AddHttpValue(h, NewHttpValue("Content-Length", "0"));
4877	AddHttpValue(h, NewHttpValue("Proxy-Connection", "Keep-Alive"));
4878	AddHttpValue(h, NewHttpValue("Pragma", "no-cache"));
4879
4880	if (use_auth)
4881	{
4882	wchar_t tmp[MAX_SIZE];
4883	UniFormat(tmp, sizeof(tmp), _UU("STATUS_3"), server_host_name);
4884	// 認証文字列の生成
4885	Format(auth_tmp_str, sizeof(auth_tmp_str), "%s:%s",
4886	username, password);
4887
4888	// Base64 エンコード
4889	Zero(auth_b64_str, sizeof(auth_b64_str));
4890	Encode64(auth_b64_str, auth_tmp_str);
4891	Format(basic_str, sizeof(basic_str), "Basic %s", auth_b64_str);
4892
4893	AddHttpValue(h, NewHttpValue("Proxy-Authorization", basic_str));
4894	}
4895
4896	// 送信
4897	if (SendHttpHeader(s, h) == false)
4898	{
4899	// 失敗
4900	if (additional_connect == false)
4901	{
4902	c->FirstSock = NULL;
4903	}
4904	FreeHttpHeader(h);
4905	Disconnect(s);
4906	ReleaseSock(s);
4907	c->Err = ERR_PROXY_ERROR;
4908	return NULL;
4909	}
4910
4911	FreeHttpHeader(h);
4912
4913	if (c->Halt)
4914	{
4915	// 停止
4916	if (additional_connect == false)
4917	{
4918	c->FirstSock = NULL;
4919	}
4920	Disconnect(s);
4921	ReleaseSock(s);
4922	c->Err = ERR_USER_CANCEL;
4923	return NULL;
4924	}
4925
4926	// 結果を受信
4927	h = RecvHttpHeader(s);
4928	if (h == NULL)
4929	{
4930	// 失敗
4931	if (additional_connect == false)
4932	{
4933	c->FirstSock = NULL;
4934	}
4935	FreeHttpHeader(h);
4936	Disconnect(s);
4937	ReleaseSock(s);
4938	c->Err = ERR_PROXY_ERROR;
4939	return NULL;
4940	}
4941
4942	http_error_code = 0;
4943	if (StrLen(h->Method) == 8)
4944	{
4945	if (Cmp(h->Method, "HTTP/1.", 7) == 0)
4946	{
4947	http_error_code = ToInt(h->Target);
4948	}
4949	}
4950	FreeHttpHeader(h);
4951
4952	// コードを確認
4953	switch (http_error_code)
4954	{
4955	case 401:
4956	case 403:
4957	case 407:
4958	// 認証失敗
4959	if (additional_connect == false)
4960	{
4961	c->FirstSock = NULL;
4962	}
4963	Disconnect(s);
4964	ReleaseSock(s);
4965	c->Err = ERR_PROXY_AUTH_FAILED;
4966	return NULL;
4967
4968	default:
4969	if ((http_error_code / 100) == 2)
4970	{
4971	// 成功
4972	SetTimeout(s, INFINITE);
4973	return s;
4974	}
4975	else
4976	{
4977	// 不明な結果を受信
4978	if (additional_connect == false)
4979	{
4980	c->FirstSock = NULL;
4981	}
4982	Disconnect(s);
4983	ReleaseSock(s);
4984	c->Err = ERR_PROXY_ERROR;
4985	return NULL;
4986	}
4987	}
4988	}
4989
4990	// TCP 接続関数
4991	SOCK TcpConnectEx2(char hostname, UINT port, UINT timeout, bool cancel_flag, void hWnd)
4992	{
4993	#ifdef OS_WIN32
4994	if (hWnd == NULL)
4995	{
4996	return ConnectEx2(hostname, port, timeout, cancel_flag);
4997	}
4998	else
4999	{
5000	return WinConnectEx2((HWND)hWnd, hostname, port, timeout, 0, NULL, NULL);
5001	}
5002	#else // OS_WIN32
5003	return ConnectEx2(hostname, port, timeout, cancel_flag);
5004	#endif // OS_WIN32
5005	}
5006
5007	// TCP/IP で接続する
5008	SOCK TcpIpConnect(char hostname, UINT port)
5009	{
5010	return TcpIpConnectEx(hostname, port, NULL, NULL);
5011	}
5012	SOCK TcpIpConnectEx(char hostname, UINT port, bool cancel_flag, void hWnd)
5013	{
5014	SOCK *s = NULL;
5015	// 引数チェック
5016	if (hostname == NULL \|\| port == 0)
5017	{
5018	return NULL;
5019	}
5020
5021	s = TcpConnectEx2(hostname, port, 0, cancel_flag, hWnd);
5022	if (s == NULL)
5023	{
5024	return NULL;
5025	}
5026
5027	return s;
5028	}
5029
5030	// PACK にダミーのエントリを作成する
5031	// Q. なぜランダムなサイズのランダムデータをここで挿入するのか?
5032	// A. ネットワーク経路中の盗聴者によってこの SSL 通信が VPN 通信であること
5033	// を検出しにくいようにするためである。
5034	void CreateDummyValue(PACK *p)
5035	{
5036	UINT size;
5037	UCHAR *buf;
5038	// 引数チェック
5039	if (p == NULL)
5040	{
5041	return;
5042	}
5043
5044	size = Rand32() % HTTP_PACK_RAND_SIZE_MAX;
5045	buf = Malloc(size);
5046	Rand(buf, size);
5047
5048	PackAddData(p, "pencore", buf, size);
5049
5050	Free(buf);
5051	}
5052
5053	// サーバーがクライアントから PACK を受信する
5054	PACK HttpServerRecv(SOCK s)
5055	{
5056	BUF *b;
5057	PACK *p;
5058	HTTP_HEADER *h;
5059	UINT size;
5060	UCHAR *tmp;
5061	HTTP_VALUE *v;
5062	// 引数チェック
5063	if (s == NULL)
5064	{
5065	return NULL;
5066	}
5067
5068	START:
5069
5070	h = RecvHttpHeader(s);
5071	if (h == NULL)
5072	{
5073	goto BAD_REQUEST;
5074	}
5075
5076	if (StrCmpi(h->Method, "POST") != 0 \|\|
5077	StrCmpi(h->Target, HTTP_VPN_TARGET) != 0 \|\|
5078	StrCmpi(h->Version, "HTTP/1.1") != 0)
5079	{
5080	FreeHttpHeader(h);
5081	goto BAD_REQUEST;
5082	}
5083
5084	v = GetHttpValue(h, "Content-Type");
5085	if (v == NULL \|\| StrCmpi(v->Data, HTTP_CONTENT_TYPE2) != 0)
5086	{
5087	FreeHttpHeader(h);
5088	goto BAD_REQUEST;
5089	}
5090
5091	size = GetContentLength(h);
5092	if (size == 0 \|\| size > MAX_PACK_SIZE)
5093	{
5094	FreeHttpHeader(h);
5095	goto BAD_REQUEST;
5096	}
5097
5098	tmp = MallocEx(size, true);
5099	if (RecvAll(s, tmp, size, s->SecureMode) == false)
5100	{
5101	Free(tmp);
5102	FreeHttpHeader(h);
5103	return NULL;
5104	}
5105
5106	b = NewBuf();
5107	WriteBuf(b, tmp, size);
5108	Free(tmp);
5109	FreeHttpHeader(h);
5110
5111	SeekBuf(b, 0, 0);
5112	p = BufToPack(b);
5113	FreeBuf(b);
5114
5115	// NOOP かどうか判断
5116	if (PackGetInt(p, "noop") != 0)
5117	{
5118	Debug("recv: noop\n");
5119	FreePack(p);
5120
5121	p = PackError(0);
5122	PackAddInt(p, "noop", 1);
5123	if (HttpServerSend(s, p) == false)
5124	{
5125	FreePack(p);
5126	return NULL;
5127	}
5128
5129	FreePack(p);
5130
5131	goto START;
5132	}
5133
5134	return p;
5135
5136	BAD_REQUEST:
5137	// エラーを返す
5138
5139
5140	return NULL;
5141	}
5142
5143	// クライアントがサーバーから PACK を受信する
5144	PACK HttpClientRecv(SOCK s)
5145	{
5146	BUF *b;
5147	PACK *p;
5148	HTTP_HEADER *h;
5149	UINT size;
5150	UCHAR *tmp;
5151	HTTP_VALUE *v;
5152	// 引数チェック
5153	if (s == NULL)
5154	{
5155	return NULL;
5156	}
5157
5158	h = RecvHttpHeader(s);
5159	if (h == NULL)
5160	{
5161	return NULL;
5162	}
5163
5164	if (StrCmpi(h->Method, "HTTP/1.1") != 0 \|\|
5165	StrCmpi(h->Target, "200") != 0)
5166	{
5167	FreeHttpHeader(h);
5168	return NULL;
5169	}
5170
5171	v = GetHttpValue(h, "Content-Type");
5172	if (v == NULL \|\| StrCmpi(v->Data, HTTP_CONTENT_TYPE2) != 0)
5173	{
5174	FreeHttpHeader(h);
5175	return NULL;
5176	}
5177
5178	size = GetContentLength(h);
5179	if (size == 0 \|\| size > MAX_PACK_SIZE)
5180	{
5181	FreeHttpHeader(h);
5182	return NULL;
5183	}
5184
5185	tmp = MallocEx(size, true);
5186	if (RecvAll(s, tmp, size, s->SecureMode) == false)
5187	{
5188	Free(tmp);
5189	FreeHttpHeader(h);
5190	return NULL;
5191	}
5192
5193	b = NewBuf();
5194	WriteBuf(b, tmp, size);
5195	Free(tmp);
5196	FreeHttpHeader(h);
5197
5198	SeekBuf(b, 0, 0);
5199	p = BufToPack(b);
5200	FreeBuf(b);
5201
5202	return p;
5203	}
5204
5205	// クライアントからサーバーに PACK を送信する
5206	bool HttpClientSend(SOCK s, PACK p)
5207	{
5208	BUF *b;
5209	bool ret;
5210	HTTP_HEADER *h;
5211	char date_str[MAX_SIZE];
5212	// 引数チェック
5213	if (s == NULL \|\| p == NULL)
5214	{
5215	return false;
5216	}
5217
5218	CreateDummyValue(p);
5219
5220	b = PackToBuf(p);
5221	if (b == NULL)
5222	{
5223	return false;
5224	}
5225
5226	h = NewHttpHeader("POST", HTTP_VPN_TARGET, "HTTP/1.1");
5227
5228	GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
5229	AddHttpValue(h, NewHttpValue("Date", date_str));
5230	AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
5231	AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
5232	AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE2));
5233
5234	ret = PostHttp(s, h, b->Buf, b->Size);
5235
5236	FreeHttpHeader(h);
5237	FreeBuf(b);
5238
5239	return ret;
5240	}
5241
5242	// サーバーからクライアントに PACK を送信する
5243	bool HttpServerSend(SOCK s, PACK p)
5244	{
5245	BUF *b;
5246	bool ret;
5247	HTTP_HEADER *h;
5248	char date_str[MAX_SIZE];
5249	// 引数チェック
5250	if (s == NULL \|\| p == NULL)
5251	{
5252	return false;
5253	}
5254
5255	CreateDummyValue(p);
5256
5257	b = PackToBuf(p);
5258	if (b == NULL)
5259	{
5260	return false;
5261	}
5262
5263	h = NewHttpHeader("HTTP/1.1", "200", "OK");
5264
5265	GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
5266	AddHttpValue(h, NewHttpValue("Date", date_str));
5267	AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
5268	AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
5269	AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE2));
5270
5271	ret = PostHttp(s, h, b->Buf, b->Size);
5272
5273	FreeHttpHeader(h);
5274	FreeBuf(b);
5275
5276	return ret;
5277	}
5278
5279	// 501 Not Implemented エラーの送信
5280	bool HttpSendNotImplemented(SOCK s, char method, char target, char version)
5281	{
5282	HTTP_HEADER *h;
5283	char date_str[MAX_SIZE];
5284	char *str;
5285	UINT str_size;
5286	char port_str[MAX_SIZE];
5287	bool ret;
5288	char host[MAX_SIZE];
5289	UINT port;
5290	// 引数チェック
5291	if (s == NULL \|\| target == NULL)
5292	{
5293	return false;
5294	}
5295
5296	// ホスト名の取得
5297	GetMachineName(host, MAX_SIZE);
5298	// ポート番号の取得
5299	port = s->LocalPort;
5300
5301	// ヘッダの作成
5302	GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
5303
5304	h = NewHttpHeader("HTTP/1.1", "501", "Method Not Implemented");
5305
5306	AddHttpValue(h, NewHttpValue("Date", date_str));
5307	AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
5308	AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
5309	AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE));
5310
5311	// データの作成
5312	str_size = sizeof(http_501_str) * 2 + StrLen(target) + StrLen(host) + StrLen(method) + StrLen(version);
5313	str = Malloc(str_size);
5314	StrCpy(str, str_size, http_501_str);
5315
5316	// TARGET
5317	ReplaceStri(str, str_size, str, "$TARGET$", target);
5318
5319	// HOST
5320	ReplaceStri(str, str_size, str, "$HOST$", host);
5321
5322	// PORT
5323	ToStr(port_str, port);
5324	ReplaceStri(str, str_size, str, "$PORT$", port_str);
5325
5326	// METHOD
5327	ReplaceStri(str, str_size, str, "$METHOD$", method);
5328
5329	// VERSION
5330	ReplaceStri(str, str_size, str, "$VERSION$", version);
5331
5332	// 送信
5333	ret = PostHttp(s, h, str, StrLen(str));
5334
5335	FreeHttpHeader(h);
5336	Free(str);
5337
5338	return ret;
5339	}
5340
5341	// 404 Not Found エラーの送信
5342	bool HttpSendNotFound(SOCK s, char target)
5343	{
5344	HTTP_HEADER *h;
5345	char date_str[MAX_SIZE];
5346	char *str;
5347	UINT str_size;
5348	char port_str[MAX_SIZE];
5349	bool ret;
5350	char host[MAX_SIZE];
5351	UINT port;
5352	// 引数チェック
5353	if (s == NULL \|\| target == NULL)
5354	{
5355	return false;
5356	}
5357
5358	// ホスト名の取得
5359	GetMachineName(host, MAX_SIZE);
5360	// ポート番号の取得
5361	port = s->LocalPort;
5362
5363	// ヘッダの作成
5364	GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
5365
5366	h = NewHttpHeader("HTTP/1.1", "404", "Not Found");
5367
5368	AddHttpValue(h, NewHttpValue("Date", date_str));
5369	AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
5370	AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
5371	AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE));
5372
5373	// データの作成
5374	str_size = sizeof(http_404_str) * 2 + StrLen(target) + StrLen(host);
5375	str = Malloc(str_size);
5376	StrCpy(str, str_size, http_404_str);
5377
5378	// TARGET
5379	ReplaceStri(str, str_size, str, "$TARGET$", target);
5380
5381	// HOST
5382	ReplaceStri(str, str_size, str, "$HOST$", host);
5383
5384	// PORT
5385	ToStr(port_str, port);
5386	ReplaceStri(str, str_size, str, "$PORT$", port_str);
5387
5388	// 送信
5389	ret = PostHttp(s, h, str, StrLen(str));
5390
5391	FreeHttpHeader(h);
5392	Free(str);
5393
5394	return ret;
5395	}
5396
5397	// 403 Forbidden エラーの送信
5398	bool HttpSendForbidden(SOCK s, char target, char *server_id)
5399	{
5400	HTTP_HEADER *h;
5401	char date_str[MAX_SIZE];
5402	char *str;
5403	UINT str_size;
5404	char port_str[MAX_SIZE];
5405	bool ret;
5406	char host[MAX_SIZE];
5407	UINT port;
5408	// 引数チェック
5409	if (s == NULL \|\| target == NULL)
5410	{
5411	return false;
5412	}
5413
5414	// ホスト名の取得
5415	GetMachineName(host, MAX_SIZE);
5416	// ポート番号の取得
5417	port = s->LocalPort;
5418
5419	// ヘッダの作成
5420	GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
5421
5422	h = NewHttpHeader("HTTP/1.1", "403", "Forbidden");
5423
5424	AddHttpValue(h, NewHttpValue("Date", date_str));
5425	AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
5426	AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
5427	AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE));
5428
5429	// データの作成
5430	str_size = sizeof(http_403_str) * 2 + StrLen(target) + StrLen(host);
5431	str = Malloc(str_size);
5432	StrCpy(str, str_size, http_403_str);
5433
5434	// TARGET
5435	ReplaceStri(str, str_size, str, "$TARGET$", target);
5436
5437	// HOST
5438	ReplaceStri(str, str_size, str, "$HOST$", host);
5439
5440	// PORT
5441	ToStr(port_str, port);
5442	ReplaceStri(str, str_size, str, "$PORT$", port_str);
5443
5444	// 送信
5445	ret = PostHttp(s, h, str, StrLen(str));
5446
5447	FreeHttpHeader(h);
5448	Free(str);
5449
5450	return ret;
5451	}
5452
5453	// HTTP ヘッダ用の日時文字列を取得
5454	void GetHttpDateStr(char *str, UINT size, UINT64 t)
5455	{
5456	SYSTEMTIME s;
5457	static char *wday[] =
5458	{
5459	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
5460	};
5461	static char *month[] =
5462	{
5463	"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
5464	"Nov", "Dec",
5465	};
5466	// 引数チェック
5467	if (str == NULL)
5468	{
5469	return;
5470	}
5471	UINT64ToSystem(&s, t);
5472
5473	Format(str, size, "%s, %02u %s %04u %02u:%02u:%02u GMT",
5474	wday[s.wDayOfWeek], s.wDay, month[s.wMonth - 1], s.wYear,
5475	s.wHour, s.wMinute, s.wSecond);
5476	}
5477
5478	// HTTP ヘッダからコンテンツ長を取得する
5479	UINT GetContentLength(HTTP_HEADER *header)
5480	{
5481	UINT ret;
5482	HTTP_VALUE *v;
5483	// 引数チェック
5484	if (header == NULL)
5485	{
5486	return 0;
5487	}
5488
5489	v = GetHttpValue(header, "Content-Length");
5490	if (v == NULL)
5491	{
5492	return 0;
5493	}
5494
5495	ret = ToInt(v->Data);
5496
5497	return ret;
5498	}
5499
5500	// HTTP でデータを送信する
5501	bool PostHttp(SOCK s, HTTP_HEADER header, void *post_data, UINT post_size)
5502	{
5503	char *header_str;
5504	BUF *b;
5505	bool ret;
5506	// 引数チェック
5507	if (s == NULL \|\| header == NULL \|\| post_data == NULL)
5508	{
5509	return false;
5510	}
5511
5512	// Content-Lentgh が存在するかどうかチェック
5513	if (GetHttpValue(header, "Content-Length") == NULL)
5514	{
5515	char tmp[MAX_SIZE];
5516	// 存在しないので付加する
5517	ToStr(tmp, post_size);
5518	AddHttpValue(header, NewHttpValue("Content-Length", tmp));
5519	}
5520
5521	// ヘッダを文字列にする
5522	header_str = HttpHeaderToStr(header);
5523	if (header_str == NULL)
5524	{
5525	return false;
5526	}
5527	b = NewBuf();
5528	WriteBuf(b, header_str, StrLen(header_str));
5529	Free(header_str);
5530
5531	// データを追記する
5532	WriteBuf(b, post_data, post_size);
5533
5534	// 送信する
5535	ret = SendAll(s, b->Buf, b->Size, s->SecureMode);
5536
5537	FreeBuf(b);
5538
5539	return ret;
5540	}
5541
5542	// HTTP ヘッダを文字列に変換
5543	char HttpHeaderToStr(HTTP_HEADER header)
5544	{
5545	BUF *b;
5546	char *tmp;
5547	UINT i;
5548	char *s;
5549	// 引数チェック
5550	if (header == NULL)
5551	{
5552	return NULL;
5553	}
5554
5555	tmp = Malloc(HTTP_HEADER_LINE_MAX_SIZE);
5556	b = NewBuf();
5557
5558	// ヘッダ
5559	Format(tmp, HTTP_HEADER_LINE_MAX_SIZE,
5560	"%s %s %s\r\n", header->Method, header->Target, header->Version);
5561	WriteBuf(b, tmp, StrLen(tmp));
5562
5563	// 値
5564	for (i = 0;i < LIST_NUM(header->ValueList);i++)
5565	{
5566	HTTP_VALUE v = (HTTP_VALUE )LIST_DATA(header->ValueList, i);
5567	Format(tmp, HTTP_HEADER_LINE_MAX_SIZE,
5568	"%s: %s\r\n", v->Name, v->Data);
5569	WriteBuf(b, tmp, StrLen(tmp));
5570	}
5571
5572	// 最後の改行
5573	WriteBuf(b, "\r\n", 2);
5574	s = Malloc(b->Size + 1);
5575	Copy(s, b->Buf, b->Size);
5576	s[b->Size] = 0;
5577
5578	FreeBuf(b);
5579	Free(tmp);
5580
5581	return s;
5582	}
5583
5584	// HTTP ヘッダを送信
5585	bool SendHttpHeader(SOCK s, HTTP_HEADER header)
5586	{
5587	char *str;
5588	bool ret;
5589	// 引数チェック
5590	if (s == NULL \|\| header == NULL)
5591	{
5592	return false;
5593	}
5594
5595	// 文字列に変換
5596	str = HttpHeaderToStr(header);
5597
5598	// 送信
5599	ret = SendAll(s, str, StrLen(str), s->SecureMode);
5600
5601	Free(str);
5602
5603	return ret;
5604	}
5605
5606	// HTTP ヘッダを受信
5607	HTTP_HEADER RecvHttpHeader(SOCK s)
5608	{
5609	TOKEN_LIST *token = NULL;
5610	char *str = NULL;
5611	HTTP_HEADER *header = NULL;
5612	// 引数チェック
5613	if (s == NULL)
5614	{
5615	return NULL;
5616	}
5617
5618	// 1 行目を取得する
5619	str = RecvLine(s, HTTP_HEADER_LINE_MAX_SIZE);
5620	if (str == NULL)
5621	{
5622	goto ERROR;
5623	}
5624
5625	// トークンに分割する
5626	token = ParseToken(str, " ");
5627	if (token->NumTokens < 3)
5628	{
5629	goto ERROR;
5630	}
5631
5632	Free(str);
5633	str = NULL;
5634
5635	// ヘッダの作成
5636	header = NewHttpHeader(token->Token[0], token->Token[1], token->Token[2]);
5637
5638	if (!StrCmpi(header->Version, "HTTP/1.0") \|\| !StrCmpi(header->Version, "HTTP/0.9"))
5639	{
5640	// この行で終わり
5641	return header;
5642	}
5643
5644	// 2 行目以降を取得する
5645	while (true)
5646	{
5647	UINT pos;
5648	HTTP_VALUE *v;
5649	char value_name, value_data;
5650	str = RecvLine(s, HTTP_HEADER_LINE_MAX_SIZE);
5651	if (str == NULL)
5652	{
5653	goto ERROR;
5654	}
5655	Trim(str);
5656
5657	if (StrLen(str) == 0)
5658	{
5659	// ヘッダの終了
5660	Free(str);
5661	str = NULL;
5662	break;
5663	}
5664
5665	// コロンの位置を取得する
5666	pos = SearchStr(str, ":", 0);
5667	if (pos == INFINITE)
5668	{
5669	// コロンが存在しない
5670	goto ERROR;
5671	}
5672	if ((pos + 1) >= StrLen(str))
5673	{
5674	// データが存在しない
5675	goto ERROR;
5676	}
5677
5678	// 名前とデータの 2 つに分ける
5679	value_name = Malloc(pos + 1);
5680	Copy(value_name, str, pos);
5681	value_name[pos] = 0;
5682	value_data = &str[pos + 1];
5683
5684	v = NewHttpValue(value_name, value_data);
5685	if (v == NULL)
5686	{
5687	Free(value_name);
5688	goto ERROR;
5689	}
5690
5691	Free(value_name);
5692
5693	AddHttpValue(header, v);
5694	Free(str);
5695	}
5696
5697	FreeToken(token);
5698
5699	return header;
5700
5701	ERROR:
5702	// メモリ解放
5703	if (token)
5704	{
5705	FreeToken(token);
5706	}
5707	if (str)
5708	{
5709	Free(str);
5710	}
5711	if (header)
5712	{
5713	FreeHttpHeader(header);
5714	}
5715	return NULL;
5716	}
5717
5718	// 1 行を受信する
5719	char RecvLine(SOCK s, UINT max_size)
5720	{
5721	BUF *b;
5722	char c;
5723	char *str;
5724	// 引数チェック
5725	if (s == NULL \|\| max_size == 0)
5726	{
5727	return NULL;
5728	}
5729
5730	b = NewBuf();
5731	while (true)
5732	{
5733	UCHAR *buf;
5734	if (RecvAll(s, &c, sizeof(c), s->SecureMode) == false)
5735	{
5736	FreeBuf(b);
5737	return NULL;
5738	}
5739	WriteBuf(b, &c, sizeof(c));
5740	buf = (UCHAR *)b->Buf;
5741	if (b->Size > max_size)
5742	{
5743	FreeBuf(b);
5744	return NULL;
5745	}
5746	if (b->Size >= 1)
5747	{
5748	if (buf[b->Size - 1] == '\n')
5749	{
5750	b->Size--;
5751	if (b->Size >= 1)
5752	{
5753	if (buf[b->Size - 1] == '\r')
5754	{
5755	b->Size--;
5756	}
5757	}
5758	str = Malloc(b->Size + 1);
5759	Copy(str, b->Buf, b->Size);
5760	str[b->Size] = 0;
5761	FreeBuf(b);
5762
5763	return str;
5764	}
5765	}
5766	}
5767	}
5768
5769	// 新しい HTTP 値の作成
5770	HTTP_VALUE NewHttpValue(char name, char *data)
5771	{
5772	HTTP_VALUE *v;
5773	// 引数チェック
5774	if (name == NULL \|\| data == NULL)
5775	{
5776	return NULL;
5777	}
5778
5779	v = ZeroMalloc(sizeof(HTTP_VALUE));
5780
5781	v->Name = CopyStr(name);
5782	v->Data = CopyStr(data);
5783
5784	Trim(v->Name);
5785	Trim(v->Data);
5786
5787	return v;
5788	}
5789
5790	// プロトコルルーチンの初期化
5791	void InitProtocol()
5792	{
5793	}
5794
5795	// プロトコルルーチンの解放
5796	void FreeProtocol()
5797	{
5798	}
5799
5800	// HTTP ヘッダから HTTP 値を探す
5801	HTTP_VALUE GetHttpValue(HTTP_HEADER header, char *name)
5802	{
5803	HTTP_VALUE *v, t;
5804	// 引数チェック
5805	if (header == NULL \|\| name == NULL)
5806	{
5807	return NULL;
5808	}
5809
5810	t.Name = name;
5811	v = Search(header->ValueList, &t);
5812	if (v == NULL)
5813	{
5814	return NULL;
5815	}
5816
5817	return v;
5818	}
5819
5820	// HTTP ヘッダに HTTP 値を追加
5821	void AddHttpValue(HTTP_HEADER header, HTTP_VALUE value)
5822	{
5823	// 引数チェック
5824	if (header == NULL \|\| value == NULL)
5825	{
5826	return;
5827	}
5828
5829	Insert(header->ValueList, value);
5830	}
5831
5832	// HTTP ヘッダを作成
5833	HTTP_HEADER NewHttpHeader(char method, char target, char version)
5834	{
5835	HTTP_HEADER *header;
5836	// 引数チェック
5837	if (method == NULL \|\| target == NULL \|\| version == NULL)
5838	{
5839	return NULL;
5840	}
5841
5842	header = ZeroMalloc(sizeof(HTTP_HEADER));
5843
5844	header->Method = CopyStr(method);
5845	header->Target = CopyStr(target);
5846	header->Version = CopyStr(version);
5847	header->ValueList = NewListFast(CompareHttpValue);
5848
5849	return header;
5850	}
5851
5852	// HTTP 値の比較関数
5853	int CompareHttpValue(void p1, void p2)
5854	{
5855	HTTP_VALUE v1, v2;
5856	if (p1 == NULL \|\| p2 == NULL)
5857	{
5858	return 0;
5859	}
5860	v1 = (HTTP_VALUE *)p1;
5861	v2 = (HTTP_VALUE *)p2;
5862	if (v1 == NULL \|\| v2 == NULL)
5863	{
5864	return 0;
5865	}
5866	return StrCmpi(v1->Name, v2->Name);
5867	}
5868
5869	// HTTP 値を解放
5870	void FreeHttpValue(HTTP_VALUE *value)
5871	{
5872	// 引数チェック
5873	if (value == NULL)
5874	{
5875	return;
5876	}
5877
5878	Free(value->Data);
5879	Free(value->Name);
5880
5881	Free(value);
5882	}
5883
5884	// HTTP ヘッダを解放
5885	void FreeHttpHeader(HTTP_HEADER *header)
5886	{
5887	UINT i;
5888	HTTP_VALUE **values;
5889	// 引数チェック
5890	if (header == NULL)
5891	{
5892	return;
5893	}
5894
5895	Free(header->Method);
5896	Free(header->Target);
5897	Free(header->Version);
5898
5899	values = ToArray(header->ValueList);
5900	for (i = 0;i < LIST_NUM(header->ValueList);i++)
5901	{
5902	FreeHttpValue(values[i]);
5903	}
5904	Free(values);
5905
5906	ReleaseList(header->ValueList);
5907
5908	Free(header);
5909	}
5910
5911	// パケットを受信
5912	PACK RecvPack(SOCK s)
5913	{
5914	PACK *p;
5915	BUF *b;
5916	void *data;
5917	UINT sz;
5918	// 引数チェック
5919	if (s == NULL \|\| s->Type != SOCK_TCP)
5920	{
5921	return false;
5922	}
5923
5924	if (RecvAll(s, &sz, sizeof(UINT), s->SecureMode) == false)
5925	{
5926	return false;
5927	}
5928	sz = Endian32(sz);
5929	if (sz > MAX_PACK_SIZE)
5930	{
5931	return false;
5932	}
5933	data = MallocEx(sz, true);
5934	if (RecvAll(s, data, sz, s->SecureMode) == false)
5935	{
5936	Free(data);
5937	return false;
5938	}
5939
5940	b = NewBuf();
5941	WriteBuf(b, data, sz);
5942	SeekBuf(b, 0, 0);
5943	p = BufToPack(b);
5944	FreeBuf(b);
5945	Free(data);
5946
5947	return p;
5948	}
5949
5950	// パケットを送信
5951	bool SendPack(SOCK s, PACK p)
5952	{
5953	BUF *b;
5954	UINT sz;
5955	// 引数チェック
5956	if (s == NULL \|\| p == NULL \|\| s->Type != SOCK_TCP)
5957	{
5958	return false;
5959	}
5960
5961	b = PackToBuf(p);
5962	sz = Endian32(b->Size);
5963
5964	SendAdd(s, &sz, sizeof(UINT));
5965	SendAdd(s, b->Buf, b->Size);
5966	FreeBuf(b);
5967
5968	return SendNow(s, s->SecureMode);
5969	}
5970
5971	// Hello パケットを作成
5972	PACK PackHello(void random, UINT ver, UINT build, char *server_str)
5973	{
5974	PACK *p;
5975	// 引数チェック
5976	if (random == NULL \|\| server_str == NULL)
5977	{
5978	return NULL;
5979	}
5980
5981	p = NewPack();
5982	PackAddStr(p, "hello", server_str);
5983	PackAddInt(p, "version", ver);
5984	PackAddInt(p, "build", build);
5985	PackAddData(p, "random", random, SHA1_SIZE);
5986
5987	return p;
5988	}
5989
5990	// Hello パケットを解釈
5991	bool GetHello(PACK p, void random, UINT ver, UINT build, char *server_str, UINT server_str_size)
5992	{
5993	// 引数チェック
5994	if (p == NULL \|\| random == NULL \|\| ver == NULL \|\| server_str == NULL)
5995	{
5996	return false;
5997	}
5998
5999	if (PackGetStr(p, "hello", server_str, server_str_size) == false)
6000	{
6001	return false;
6002	}
6003	*ver = PackGetInt(p, "version");
6004	*build = PackGetInt(p, "build");
6005	if (PackGetDataSize(p, "random") != SHA1_SIZE)
6006	{
6007	return false;
6008	}
6009	if (PackGetData(p, "random", random) == false)
6010	{
6011	return false;
6012	}
6013
6014	return true;
6015	}
6016
6017	// エラー値を PACK に格納
6018	PACK *PackError(UINT error)
6019	{
6020	PACK *p;
6021
6022	p = NewPack();
6023	PackAddInt(p, "error", error);
6024
6025	return p;
6026	}
6027
6028	// エラー値を PACK から取得
6029	UINT GetErrorFromPack(PACK *p)
6030	{
6031	// 引数チェック
6032	if (p == NULL)
6033	{
6034	return 0;
6035	}
6036
6037	return PackGetInt(p, "error");
6038	}
6039
6040	// 認証方法を PACK から取得
6041	UINT GetAuthTypeFromPack(PACK *p)
6042	{
6043	// 引数チェック
6044	if (p == NULL)
6045	{
6046	return 0;
6047	}
6048
6049	return PackGetInt(p, "authtype");
6050	}
6051
6052	// ユーザー名と HUB 名を PACK から取得
6053	bool GetHubnameAndUsernameFromPack(PACK p, char username, UINT username_size,
6054	char *hubname, UINT hubname_size)
6055	{
6056	// 引数チェック
6057	if (p == NULL \|\| username == NULL \|\| hubname == NULL)
6058	{
6059	return false;
6060	}
6061
6062	if (PackGetStr(p, "username", username, username_size) == false)
6063	{
6064	return false;
6065	}
6066	if (PackGetStr(p, "hubname", hubname, hubname_size) == false)
6067	{
6068	return false;
6069	}
6070	return true;
6071	}
6072
6073	// プロトコルを PACK から取得
6074	UINT GetProtocolFromPack(PACK *p)
6075	{
6076	// 引数チェック
6077	if (p == NULL)
6078	{
6079	return 0;
6080	}
6081
6082	#if 0
6083	return PackGetInt(p, "protocol");
6084	#else
6085	// 現バージョンでは TCP プロトコルに限定する
6086	return CONNECTION_TCP;
6087	#endif
6088	}
6089
6090	// メソッドを PACK から取得
6091	bool GetMethodFromPack(PACK p, char method, UINT size)
6092	{
6093	// 引数チェック
6094	if (p == NULL \|\| method == NULL \|\| size == 0)
6095	{
6096	return false;
6097	}
6098
6099	return PackGetStr(p, "method", method, size);
6100	}
6101
6102	// 証明書認証ログイン用のパケットを生成
6103	PACK PackLoginWithCert(char hubname, char username, X x, void *sign, UINT sign_size)
6104	{
6105	PACK *p;
6106	BUF *b;
6107	// 引数チェック
6108	if (hubname == NULL \|\| username == NULL)
6109	{
6110	return NULL;
6111	}
6112
6113	p = NewPack();
6114	PackAddStr(p, "method", "login");
6115	PackAddStr(p, "hubname", hubname);
6116	PackAddStr(p, "username", username);
6117	PackAddInt(p, "authtype", CLIENT_AUTHTYPE_CERT);
6118
6119	// 証明書
6120	b = XToBuf(x, false);
6121	PackAddData(p, "cert", b->Buf, b->Size);
6122	FreeBuf(b);
6123
6124	// 署名データ
6125	PackAddData(p, "sign", sign, sign_size);
6126
6127	return p;
6128	}
6129
6130	// 平文パスワード認証ログイン用のパケットを生成
6131	PACK PackLoginWithPlainPassword(char hubname, char username, void plain_password)
6132	{
6133	PACK *p;
6134	// 引数チェック
6135	if (hubname == NULL \|\| username == NULL)
6136	{
6137	return NULL;
6138	}
6139
6140	p = NewPack();
6141	PackAddStr(p, "method", "login");
6142	PackAddStr(p, "hubname", hubname);
6143	PackAddStr(p, "username", username);
6144	PackAddInt(p, "authtype", CLIENT_AUTHTYPE_PLAIN_PASSWORD);
6145	PackAddStr(p, "plain_password", plain_password);
6146
6147	return p;
6148	}
6149
6150	// パスワード認証ログイン用のパケットを作成
6151	PACK PackLoginWithPassword(char hubname, char username, void secure_password)
6152	{
6153	PACK *p;
6154	// 引数チェック
6155	if (hubname == NULL \|\| username == NULL)
6156	{
6157	return NULL;
6158	}
6159
6160	p = NewPack();
6161	PackAddStr(p, "method", "login");
6162	PackAddStr(p, "hubname", hubname);
6163	PackAddStr(p, "username", username);
6164	PackAddInt(p, "authtype", CLIENT_AUTHTYPE_PASSWORD);
6165	PackAddData(p, "secure_password", secure_password, SHA1_SIZE);
6166
6167	return p;
6168	}
6169
6170	// 匿名ログイン用のパケットを作成
6171	PACK PackLoginWithAnonymous(char hubname, char *username)
6172	{
6173	PACK *p;
6174	// 引数チェック
6175	if (hubname == NULL \|\| username == NULL)
6176	{
6177	return NULL;
6178	}
6179
6180	p = NewPack();
6181	PackAddStr(p, "method", "login");
6182	PackAddStr(p, "hubname", hubname);
6183	PackAddStr(p, "username", username);
6184	PackAddInt(p, "authtype", CLIENT_AUTHTYPE_ANONYMOUS);
6185
6186	return p;
6187	}
6188
6189	// 追加接続用のパケットを作成
6190	PACK PackAdditionalConnect(UCHAR session_key)
6191	{
6192	PACK *p;
6193	// 引数チェック
6194	if (session_key == NULL)
6195	{
6196	return NULL;
6197	}
6198
6199	p = NewPack();
6200	PackAddStr(p, "method", "additional_connect");
6201	PackAddData(p, "session_key", session_key, SHA1_SIZE);
6202
6203	return p;
6204	}
6205
6206	// PACK から K を取得
6207	K PackGetK(PACK p, char *name)
6208	{
6209	K *k;
6210	BUF *b;
6211	// 引数チェック
6212	if (p == NULL \|\| name == NULL)
6213	{
6214	return NULL;
6215	}
6216
6217	b = PackGetBuf(p, name);
6218	if (b == NULL)
6219	{
6220	return NULL;
6221	}
6222
6223	k = BufToK(b, true, false, NULL);
6224	FreeBuf(b);
6225
6226	return k;
6227	}
6228
6229	// PACK から X を取得
6230	X PackGetX(PACK p, char *name)
6231	{
6232	X *x;
6233	BUF *b;
6234	// 引数チェック
6235	if (p == NULL \|\| name == NULL)
6236	{
6237	return NULL;
6238	}
6239
6240	b = PackGetBuf(p, name);
6241	if (b == NULL)
6242	{
6243	return NULL;
6244	}
6245
6246	x = BufToX(b, false);
6247	FreeBuf(b);
6248
6249	return x;
6250	}
6251
6252	// PACK に K を追加
6253	void PackAddK(PACK p, char name, K *k)
6254	{
6255	BUF *b;
6256	// 引数チェック
6257	if (p == NULL \|\| name == NULL \|\| k == NULL)
6258	{
6259	return;
6260	}
6261
6262	b = KToBuf(k, false, NULL);
6263	if (b == NULL)
6264	{
6265	return;
6266	}
6267
6268	PackAddBuf(p, name, b);
6269	FreeBuf(b);
6270	}
6271
6272	// PACK に X を追加
6273	void PackAddX(PACK p, char name, X *x)
6274	{
6275	BUF *b;
6276	// 引数チェック
6277	if (p == NULL \|\| name == NULL \|\| x == NULL)
6278	{
6279	return;
6280	}
6281
6282	b = XToBuf(x, false);
6283	if (b == NULL)
6284	{
6285	return;
6286	}
6287
6288	PackAddBuf(p, name, b);
6289	FreeBuf(b);
6290	}
6291
6292	// PACK からバッファを取得
6293	BUF PackGetBuf(PACK p, char *name)
6294	{
6295	return PackGetBufEx(p, name, 0);
6296	}
6297	BUF PackGetBufEx(PACK p, char *name, UINT index)
6298	{
6299	UINT size;
6300	void *tmp;
6301	BUF *b;
6302	// 引数チェック
6303	if (p == NULL \|\| name == NULL)
6304	{
6305	return NULL;
6306	}
6307
6308	size = PackGetDataSizeEx(p, name, index);
6309	tmp = MallocEx(size, true);
6310	if (PackGetDataEx(p, name, tmp, index) == false)
6311	{
6312	Free(tmp);
6313	return NULL;
6314	}
6315
6316	b = NewBuf();
6317	WriteBuf(b, tmp, size);
6318	SeekBuf(b, 0, 0);
6319
6320	Free(tmp);
6321
6322	return b;
6323	}
6324
6325	// PACK からデータを取得
6326	bool PackGetData(PACK p, char name, void *data)
6327	{
6328	return PackGetDataEx(p, name, data, 0);
6329	}
6330	bool PackGetDataEx(PACK p, char name, void *data, UINT index)
6331	{
6332	ELEMENT *e;
6333	// 引数チェック
6334	if (p == NULL \|\| name == NULL)
6335	{
6336	return false;
6337	}
6338
6339	e = GetElement(p, name, VALUE_DATA);
6340	if (e == NULL)
6341	{
6342	return false;
6343	}
6344	Copy(data, GetDataValue(e, index), GetDataValueSize(e, index));
6345	return true;
6346	}
6347	bool PackGetData2(PACK p, char name, void *data, UINT size)
6348	{
6349	return PackGetDataEx2(p, name, data, size, 0);
6350	}
6351	bool PackGetDataEx2(PACK p, char name, void *data, UINT size, UINT index)
6352	{
6353	ELEMENT *e;
6354	// 引数チェック
6355	if (p == NULL \|\| name == NULL)
6356	{
6357	return false;
6358	}
6359
6360	e = GetElement(p, name, VALUE_DATA);
6361	if (e == NULL)
6362	{
6363	return false;
6364	}
6365	if (GetDataValueSize(e, index) != size)
6366	{
6367	return false;
6368	}
6369	Copy(data, GetDataValue(e, index), GetDataValueSize(e, index));
6370	return true;
6371	}
6372
6373	// PACK からデータサイズを取得
6374	UINT PackGetDataSize(PACK p, char name)
6375	{
6376	return PackGetDataSizeEx(p, name, 0);
6377	}
6378	UINT PackGetDataSizeEx(PACK p, char name, UINT index)
6379	{
6380	ELEMENT *e;
6381	// 引数チェック
6382	if (p == NULL \|\| name == NULL)
6383	{
6384	return 0;
6385	}
6386
6387	e = GetElement(p, name, VALUE_DATA);
6388	if (e == NULL)
6389	{
6390	return 0;
6391	}
6392	return GetDataValueSize(e, index);
6393	}
6394
6395	// PACK から整数を取得
6396	UINT64 PackGetInt64(PACK p, char name)
6397	{
6398	return PackGetInt64Ex(p, name, 0);
6399	}
6400	UINT64 PackGetInt64Ex(PACK p, char name, UINT index)
6401	{
6402	ELEMENT *e;
6403	// 引数チェック
6404	if (p == NULL \|\| name == NULL)
6405	{
6406	return 0;
6407	}
6408
6409	e = GetElement(p, name, VALUE_INT64);
6410	if (e == NULL)
6411	{
6412	return 0;
6413	}
6414	return GetInt64Value(e, index);
6415	}
6416
6417	// PACK からインデックス数を取得
6418	UINT PackGetIndexCount(PACK p, char name)
6419	{
6420	ELEMENT *e;
6421	// 引数チェック
6422	if (p == NULL \|\| name == NULL)
6423	{
6424	return 0;
6425	}
6426
6427	e = GetElement(p, name, INFINITE);
6428	if (e == NULL)
6429	{
6430	return 0;
6431	}
6432
6433	return e->num_value;
6434	}
6435
6436	// PACK から個数を取得
6437	UINT PackGetNum(PACK p, char name)
6438	{
6439	return MIN(PackGetInt(p, name), 65536);
6440	}
6441
6442	// PACK から bool 型を取得
6443	bool PackGetBool(PACK p, char name)
6444	{
6445	return PackGetInt(p, name) == 0 ? false : true;
6446	}
6447	bool PackGetBoolEx(PACK p, char name, UINT index)
6448	{
6449	return PackGetIntEx(p, name, index) == 0 ? false : true;
6450	}
6451
6452	// PACK に bool 型を追加
6453	void PackAddBool(PACK p, char name, bool b)
6454	{
6455	PackAddInt(p, name, b ? 1 : 0);
6456	}
6457	void PackAddBoolEx(PACK p, char name, bool b, UINT index, UINT total)
6458	{
6459	PackAddIntEx(p, name, b ? 1 : 0, index, total);
6460	}
6461
6462	// PACK に IPV6_ADDR を追加
6463	void PackAddIp6AddrEx(PACK p, char name, IPV6_ADDR *addr, UINT index, UINT total)
6464	{
6465	// 引数チェック
6466	if (p == NULL \|\| name == NULL \|\| addr == NULL)
6467	{
6468	return;
6469	}
6470
6471	PackAddDataEx(p, name, addr, sizeof(IPV6_ADDR), index, total);
6472	}
6473	void PackAddIp6Addr(PACK p, char name, IPV6_ADDR *addr)
6474	{
6475	PackAddIp6AddrEx(p, name, addr, 0, 1);
6476	}
6477
6478	// PACK から IPV6_ADDR を取得
6479	bool PackGetIp6AddrEx(PACK p, char name, IPV6_ADDR *addr, UINT index)
6480	{
6481	// 引数チェック
6482	if (p == NULL \|\| name == NULL \|\| addr == NULL)
6483	{
6484	Zero(addr, sizeof(IPV6_ADDR));
6485	return false;
6486	}
6487
6488	return PackGetDataEx2(p, name, addr, sizeof(IPV6_ADDR), index);
6489	}
6490	bool PackGetIp6Addr(PACK p, char name, IPV6_ADDR *addr)
6491	{
6492	return PackGetIp6AddrEx(p, name, addr, 0);
6493	}
6494
6495	// PACK に IP を追加
6496	void PackAddIp32Ex(PACK p, char name, UINT ip32, UINT index, UINT total)
6497	{
6498	IP ip;
6499	// 引数チェック
6500	if (p == NULL \|\| name == NULL)
6501	{
6502	return;
6503	}
6504
6505	UINTToIP(&ip, ip32);
6506
6507	PackAddIpEx(p, name, &ip, index, total);
6508	}
6509	void PackAddIp32(PACK p, char name, UINT ip32)
6510	{
6511	PackAddIp32Ex(p, name, ip32, 0, 1);
6512	}
6513	void PackAddIpEx(PACK p, char name, IP *ip, UINT index, UINT total)
6514	{
6515	UINT i;
6516	bool b = false;
6517	char tmp[MAX_PATH];
6518	// 引数チェック
6519	if (p == NULL \|\| name == NULL \|\| ip == NULL)
6520	{
6521	return;
6522	}
6523
6524	b = IsIP6(ip);
6525
6526	Format(tmp, sizeof(tmp), "%s@ipv6_bool", name);
6527	PackAddBoolEx(p, tmp, b, index, total);
6528
6529	Format(tmp, sizeof(tmp), "%s@ipv6_array", name);
6530	if (b)
6531	{
6532	PackAddDataEx(p, tmp, ip->ipv6_addr, sizeof(ip->ipv6_addr), index, total);
6533	}
6534	else
6535	{
6536	UCHAR dummy[16];
6537
6538	Zero(dummy, sizeof(dummy));
6539
6540	PackAddDataEx(p, tmp, dummy, sizeof(dummy), index, total);
6541	}
6542
6543	Format(tmp, sizeof(tmp), "%s@ipv6_scope_id", name);
6544	if (b)
6545	{
6546	PackAddIntEx(p, tmp, ip->ipv6_scope_id, index, total);
6547	}
6548	else
6549	{
6550	PackAddIntEx(p, tmp, 0, index, total);
6551	}
6552
6553	i = IPToUINT(ip);
6554
6555	if (IsBigEndian())
6556	{
6557	i = Swap32(i);
6558	}
6559
6560	PackAddIntEx(p, name, i, index, total);
6561	}
6562	void PackAddIp(PACK p, char name, IP *ip)
6563	{
6564	PackAddIpEx(p, name, ip, 0, 1);
6565	}
6566
6567	// PACK から IP を取得
6568	UINT PackGetIp32Ex(PACK p, char name, UINT index)
6569	{
6570	IP ip;
6571	// 引数チェック
6572	if (p == NULL \|\| name == NULL)
6573	{
6574	return 0;
6575	}
6576
6577	if (PackGetIpEx(p, name, &ip, index) == false)
6578	{
6579	return 0;
6580	}
6581
6582	return IPToUINT(&ip);
6583	}
6584	UINT PackGetIp32(PACK p, char name)
6585	{
6586	return PackGetIp32Ex(p, name, 0);
6587	}
6588	bool PackGetIpEx(PACK p, char name, IP *ip, UINT index)
6589	{
6590	UINT i;
6591	char tmp[MAX_PATH];
6592	// 引数チェック
6593	if (p == NULL \|\| ip == NULL \|\| name == NULL)
6594	{
6595	return false;
6596	}
6597
6598	Format(tmp, sizeof(tmp), "%s@ipv6_bool", name);
6599	if (PackGetBoolEx(p, tmp, index))
6600	{
6601	UCHAR data[16];
6602	UINT scope_id;
6603
6604	Zero(data, sizeof(data));
6605
6606	Format(tmp, sizeof(tmp), "%s@ipv6_array", name);
6607	PackGetDataEx2(p, tmp, data, sizeof(data), index);
6608
6609	Format(tmp, sizeof(tmp), "%s@ipv6_scope_id", name);
6610	scope_id = PackGetIntEx(p, tmp, index);
6611
6612	SetIP6(ip, data);
6613	ip->ipv6_scope_id = scope_id;
6614	}
6615	else
6616	{
6617	if (GetElement(p, name, VALUE_INT) == NULL)
6618	{
6619	Zero(ip, sizeof(IP));
6620	return false;
6621	}
6622
6623	i = PackGetIntEx(p, name, index);
6624
6625	if (IsBigEndian())
6626	{
6627	i = Swap32(i);
6628	}
6629
6630	UINTToIP(ip, i);
6631	}
6632
6633	return true;
6634	}
6635	bool PackGetIp(PACK p, char name, IP *ip)
6636	{
6637	return PackGetIpEx(p, name, ip, 0);
6638	}
6639
6640	// PACK から整数を取得
6641	UINT PackGetInt(PACK p, char name)
6642	{
6643	return PackGetIntEx(p, name, 0);
6644	}
6645	UINT PackGetIntEx(PACK p, char name, UINT index)
6646	{
6647	ELEMENT *e;
6648	// 引数チェック
6649	if (p == NULL \|\| name == NULL)
6650	{
6651	return 0;
6652	}
6653
6654	e = GetElement(p, name, VALUE_INT);
6655	if (e == NULL)
6656	{
6657	return 0;
6658	}
6659	return GetIntValue(e, index);
6660	}
6661
6662	// PACK から Unicode 文字列を取得
6663	bool PackGetUniStr(PACK p, char name, wchar_t *unistr, UINT size)
6664	{
6665	return PackGetUniStrEx(p, name, unistr, size, 0);
6666	}
6667	bool PackGetUniStrEx(PACK p, char name, wchar_t *unistr, UINT size, UINT index)
6668	{
6669	ELEMENT *e;
6670	// 引数チェック
6671	if (p == NULL \|\| name == NULL \|\| unistr == NULL \|\| size == 0)
6672	{
6673	return false;
6674	}
6675
6676	unistr[0] = 0;
6677
6678	e = GetElement(p, name, VALUE_UNISTR);
6679	if (e == NULL)
6680	{
6681	return false;
6682	}
6683	UniStrCpy(unistr, size, GetUniStrValue(e, index));
6684	return true;
6685	}
6686
6687	// PACK から文字列を取得
6688	bool PackGetStr(PACK p, char name, char *str, UINT size)
6689	{
6690	return PackGetStrEx(p, name, str, size, 0);
6691	}
6692	bool PackGetStrEx(PACK p, char name, char *str, UINT size, UINT index)
6693	{
6694	ELEMENT *e;
6695	// 引数チェック
6696	if (p == NULL \|\| name == NULL \|\| str == NULL \|\| size == 0)
6697	{
6698	return false;
6699	}
6700
6701	str[0] = 0;
6702
6703	e = GetElement(p, name, VALUE_STR);
6704	if (e == NULL)
6705	{
6706	return false;
6707	}
6708
6709	StrCpy(str, size, GetStrValue(e, index));
6710	return true;
6711	}
6712
6713	// バッファを PACK に追加 (配列)
6714	void PackAddBufEx(PACK p, char name, BUF *b, UINT index, UINT total)
6715	{
6716	// 引数チェック
6717	if (p == NULL \|\| name == NULL \|\| b == NULL \|\| total == 0)
6718	{
6719	return;
6720	}
6721
6722	PackAddDataEx(p, name, b->Buf, b->Size, index, total);
6723	}
6724
6725	// データを PACK に追加 (配列)
6726	void PackAddDataEx(PACK p, char name, void *data, UINT size, UINT index, UINT total)
6727	{
6728	VALUE *v;
6729	ELEMENT *e;
6730	// 引数チェック
6731	if (p == NULL \|\| data == NULL \|\| name == NULL \|\| total == 0)
6732	{
6733	return;
6734	}
6735
6736	v = NewDataValue(data, size);
6737	e = GetElement(p, name, VALUE_DATA);
6738	if (e != NULL)
6739	{
6740	if (e->num_value <= total)
6741	{
6742	e->values[index] = v;
6743	}
6744	else
6745	{
6746	FreeValue(v, VALUE_DATA);
6747	}
6748	}
6749	else
6750	{
6751	e = ZeroMallocEx(sizeof(ELEMENT), true);
6752	StrCpy(e->name, sizeof(e->name), name);
6753	e->num_value = total;
6754	e->type = VALUE_DATA;
6755	e->values = ZeroMallocEx(sizeof(VALUE ) total, true);
6756	e->values[index] = v;
6757	AddElement(p, e);
6758	}
6759	}
6760
6761	// バッファを PACK に追加
6762	void PackAddBuf(PACK p, char name, BUF *b)
6763	{
6764	// 引数チェック
6765	if (p == NULL \|\| name == NULL \|\| b == NULL)
6766	{
6767	return;
6768	}
6769
6770	PackAddData(p, name, b->Buf, b->Size);
6771	}
6772
6773	// データを PACK に追加
6774	void PackAddData(PACK p, char name, void *data, UINT size)
6775	{
6776	VALUE *v;
6777	// 引数チェック
6778	if (p == NULL \|\| data == NULL \|\| name == NULL)
6779	{
6780	return;
6781	}
6782
6783	v = NewDataValue(data, size);
6784	AddElement(p, NewElement(name, VALUE_DATA, 1, &v));
6785	}
6786
6787	// 64 bit 整数を PACK に追加 (配列)
6788	void PackAddInt64Ex(PACK p, char name, UINT64 i, UINT index, UINT total)
6789	{
6790	VALUE *v;
6791	ELEMENT *e;
6792	// 引数チェック
6793	if (p == NULL \|\| name == NULL \|\| total == 0)
6794	{
6795	return;
6796	}
6797
6798	v = NewInt64Value(i);
6799	e = GetElement(p, name, VALUE_INT64);
6800	if (e != NULL)
6801	{
6802	if (e->num_value <= total)
6803	{
6804	e->values[index] = v;
6805	}
6806	else
6807	{
6808	FreeValue(v, VALUE_INT64);
6809	}
6810	}
6811	else
6812	{
6813	e = ZeroMallocEx(sizeof(ELEMENT), true);
6814	StrCpy(e->name, sizeof(e->name), name);
6815	e->num_value = total;
6816	e->type = VALUE_INT64;
6817	e->values = ZeroMallocEx(sizeof(VALUE ) total, true);
6818	e->values[index] = v;
6819	AddElement(p, e);
6820	}
6821	}
6822
6823	// 整数を PACK に追加 (配列)
6824	void PackAddIntEx(PACK p, char name, UINT i, UINT index, UINT total)
6825	{
6826	VALUE *v;
6827	ELEMENT *e;
6828	// 引数チェック
6829	if (p == NULL \|\| name == NULL \|\| total == 0)
6830	{
6831	return;
6832	}
6833
6834	v = NewIntValue(i);
6835	e = GetElement(p, name, VALUE_INT);
6836	if (e != NULL)
6837	{
6838	if (e->num_value <= total)
6839	{
6840	e->values[index] = v;
6841	}
6842	else
6843	{
6844	FreeValue(v, VALUE_INT);
6845	}
6846	}
6847	else
6848	{
6849	e = ZeroMallocEx(sizeof(ELEMENT), true);
6850	StrCpy(e->name, sizeof(e->name), name);
6851	e->num_value = total;
6852	e->type = VALUE_INT;
6853	e->values = ZeroMallocEx(sizeof(VALUE ) total, true);
6854	e->values[index] = v;
6855	AddElement(p, e);
6856	}
6857	}
6858
6859	// 64 bit 整数を PACK に追加
6860	void PackAddInt64(PACK p, char name, UINT64 i)
6861	{
6862	VALUE *v;
6863	// 引数チェック
6864	if (p == NULL \|\| name == NULL)
6865	{
6866	return;
6867	}
6868
6869	v = NewInt64Value(i);
6870	AddElement(p, NewElement(name, VALUE_INT64, 1, &v));
6871	}
6872
6873	// 個数を PACK に追加
6874	void PackAddNum(PACK p, char name, UINT num)
6875	{
6876	PackAddInt(p, name, num);
6877	}
6878
6879	// 整数を PACK に追加
6880	void PackAddInt(PACK p, char name, UINT i)
6881	{
6882	VALUE *v;
6883	// 引数チェック
6884	if (p == NULL \|\| name == NULL)
6885	{
6886	return;
6887	}
6888
6889	v = NewIntValue(i);
6890	AddElement(p, NewElement(name, VALUE_INT, 1, &v));
6891	}
6892
6893	// Unicode 文字列を PACK に追加 (配列)
6894	void PackAddUniStrEx(PACK p, char name, wchar_t *unistr, UINT index, UINT total)
6895	{
6896	VALUE *v;
6897	ELEMENT *e;
6898	// 引数チェック
6899	if (p == NULL \|\| name == NULL \|\| unistr == NULL \|\| total == 0)
6900	{
6901	return;
6902	}
6903
6904	v = NewUniStrValue(unistr);
6905	e = GetElement(p, name, VALUE_UNISTR);
6906	if (e != NULL)
6907	{
6908	if (e->num_value <= total)
6909	{
6910	e->values[index] = v;
6911	}
6912	else
6913	{
6914	FreeValue(v, VALUE_UNISTR);
6915	}
6916	}
6917	else
6918	{
6919	e = ZeroMallocEx(sizeof(ELEMENT), true);
6920	StrCpy(e->name, sizeof(e->name), name);
6921	e->num_value = total;
6922	e->type = VALUE_UNISTR;
6923	e->values = ZeroMallocEx(sizeof(VALUE ) total, true);
6924	e->values[index] = v;
6925	AddElement(p, e);
6926	}
6927	}
6928
6929	// Unicode 文字列を PACK に追加
6930	void PackAddUniStr(PACK p, char name, wchar_t *unistr)
6931	{
6932	VALUE *v;
6933	// 引数チェック
6934	if (p == NULL \|\| name == NULL \|\| unistr == NULL)
6935	{
6936	return;
6937	}
6938
6939	v = NewUniStrValue(unistr);
6940	AddElement(p, NewElement(name, VALUE_UNISTR, 1, &v));
6941	}
6942
6943	// 文字列を PACK に追加 (配列)
6944	void PackAddStrEx(PACK p, char name, char *str, UINT index, UINT total)
6945	{
6946	VALUE *v;
6947	ELEMENT *e;
6948	// 引数チェック
6949	if (p == NULL \|\| name == NULL \|\| str == NULL \|\| total == 0)
6950	{
6951	return;
6952	}
6953
6954	v = NewStrValue(str);
6955	e = GetElement(p, name, VALUE_STR);
6956	if (e != NULL)
6957	{
6958	if (e->num_value <= total)
6959	{
6960	e->values[index] = v;
6961	}
6962	else
6963	{
6964	FreeValue(v, VALUE_STR);
6965	}
6966	}
6967	else
6968	{
6969	e = ZeroMallocEx(sizeof(ELEMENT), true);
6970	StrCpy(e->name, sizeof(e->name), name);
6971	e->num_value = total;
6972	e->type = VALUE_STR;
6973	e->values = ZeroMallocEx(sizeof(VALUE ) total, true);
6974	e->values[index] = v;
6975	AddElement(p, e);
6976	}
6977	}
6978
6979	// 文字列を PACK に追加
6980	void PackAddStr(PACK p, char name, char *str)
6981	{
6982	VALUE *v;
6983	// 引数チェック
6984	if (p == NULL \|\| name == NULL \|\| str == NULL)
6985	{
6986	return;
6987	}
6988
6989	v = NewStrValue(str);
6990	AddElement(p, NewElement(name, VALUE_STR, 1, &v));
6991	}
6992
6993	// RC4 キーペアを生成
6994	void GenerateRC4KeyPair(RC4_KEY_PAIR *k)
6995	{
6996	// 引数チェック
6997	if (k == NULL)
6998	{
6999	return;
7000	}
7001
7002	Rand(k->ClientToServerKey, sizeof(k->ClientToServerKey));
7003	Rand(k->ServerToClientKey, sizeof(k->ServerToClientKey));
7004	}
7005

Note: See TracBrowser for help on using the repository browser.

Download in other formats: