Context Navigation

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

trunk

Last change on this file since 072e48b 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

Rev	Line
[a1bae3e]	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: